@ringozz/godot 0.1.0

package/gen/classes/Area2D.ts

@@ -0,0 +1,252 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { CollisionObject2D } from './CollisionObject2D.ts';
+import type { GodotArray, RID, Signal, StringName } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { Node } from './Node.ts';
+import type { Node2D } from './Node2D.ts';
+
+/**
+ * {@link Area2D} is a region of 2D space defined by one or multiple {@link CollisionShape2D} or {@link CollisionPolygon2D} child nodes. It detects when other {@link CollisionObject2D}s enter or exit it, and it also keeps track of which collision objects haven't exited it yet (i.e. which one are overlapping it).
+ * This node can also locally alter or override physics parameters (gravity, damping) and route audio to custom audio buses.
+ * **Note:** Areas and bodies created with {@link PhysicsServer2D} might not interact as expected with {@link Area2D}s, and might not emit signals or track objects correctly.
+ */
+export class Area2D extends CollisionObject2D {
+    constructor(name = 79) { super(name); }
+
+    /**
+     * Returns a list of intersecting {@link PhysicsBody2D}s and {@link TileMap}s. The overlapping body's {@link CollisionObject2D.collisionLayer} must be part of this area's {@link CollisionObject2D.collisionMask} in order to be detected.
+     * For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead.
+     */
+    getOverlappingBodies(): GodotArray<Node2D> { return _C(this, 5775) as GodotArray<Node2D>; }
+
+    /**
+     * Returns a list of intersecting {@link Area2D}s. The overlapping area's {@link CollisionObject2D.collisionLayer} must be part of this area's {@link CollisionObject2D.collisionMask} in order to be detected.
+     * For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead.
+     */
+    getOverlappingAreas(): GodotArray<Area2D> { return _C(this, 5774) as GodotArray<Area2D>; }
+
+    /**
+     * Returns `true` if intersecting any {@link PhysicsBody2D}s or {@link TileMap}s, otherwise returns `false`. The overlapping body's {@link CollisionObject2D.collisionLayer} must be part of this area's {@link CollisionObject2D.collisionMask} in order to be detected.
+     * For performance reasons (collisions are all processed at the same time) the list of overlapping bodies is modified once during the physics step, not immediately after objects are moved. Consider using signals instead.
+     */
+    hasOverlappingBodies(): boolean { return _C(this, 7427) as boolean; }
+
+    /**
+     * Returns `true` if intersecting any {@link Area2D}s, otherwise returns `false`. The overlapping area's {@link CollisionObject2D.collisionLayer} must be part of this area's {@link CollisionObject2D.collisionMask} in order to be detected.
+     * For performance reasons (collisions are all processed at the same time) the list of overlapping areas is modified once during the physics step, not immediately after objects are moved. Consider using signals instead.
+     */
+    hasOverlappingAreas(): boolean { return _C(this, 7426) as boolean; }
+
+    /**
+     * Returns `true` if the given physics body intersects or overlaps this {@link Area2D}, `false` otherwise.
+     * **Note:** The result of this test is not immediate after moving objects. For performance, list of overlaps is updated once per frame and before the physics step. Consider using signals instead.
+     * The `body` argument can either be a {@link PhysicsBody2D} or a {@link TileMap} instance. While TileMaps are not physics bodies themselves, they register their tiles with collision shapes as a virtual physics body.
+     */
+    overlapsBody(body: Node): boolean { return _C(this, 9246, body) as boolean; }
+
+    /**
+     * Returns `true` if the given {@link Area2D} intersects or overlaps this {@link Area2D}, `false` otherwise.
+     * **Note:** The result of this test is not immediate after moving objects. For performance, the list of overlaps is updated once per frame and before the physics step. Consider using signals instead.
+     */
+    overlapsArea(area: Node): boolean { return _C(this, 9245, area) as boolean; }
+
+    /**
+     * If `true`, the area detects bodies or areas entering and exiting it.
+     */
+    get monitoring(): boolean { return _C(this, 8112) as boolean; }
+    set monitoring(v: boolean) { _C(this, 12084, v); }
+
+    /**
+     * If `true`, other monitoring areas can detect this area.
+     */
+    get monitorable(): boolean { return _C(this, 8111) as boolean; }
+    set monitorable(v: boolean) { _C(this, 12083, v); }
+
+    /**
+     * The area's priority. Higher priority areas are processed first. The {@link World2D}'s physics is always processed last, after all areas.
+     */
+    get priority(): number { return _C(this, 6015) as number; }
+    set priority(v: number) { _C(this, 12419, v); }
+
+    /**
+     * Override mode for gravity calculations within this area.
+     */
+    get gravitySpaceOverride(): SpaceOverride { return _C(this, 4977) as SpaceOverride; }
+    set gravitySpaceOverride(v: SpaceOverride) { _C(this, 11560, v); }
+
+    /**
+     * If `true`, gravity is calculated from a point (set via {@link gravityPointCenter}). See also {@link gravitySpaceOverride}.
+     */
+    get gravityPoint(): boolean { return _C(this, 7976) as boolean; }
+    set gravityPoint(v: boolean) { _C(this, 11556, v); }
+
+    /**
+     * The distance at which the gravity strength is equal to {@link gravity}. For example, on a planet 100 pixels in radius with a surface gravity of 4.0 px/s², set the {@link gravity} to 4.0 and the unit distance to 100.0. The gravity will have falloff according to the inverse square law, so in the example, at 200 pixels from the center the gravity will be 1.0 px/s² (twice the distance, 1/4th the gravity), at 50 pixels it will be 16.0 px/s² (half the distance, 4x the gravity), and so on.
+     * The above is true only when the unit distance is a positive number. When this is set to 0.0, the gravity will be constant regardless of distance.
+     */
+    get gravityPointUnitDistance(): number { return _C(this, 4975) as number; }
+    set gravityPointUnitDistance(v: number) { _C(this, 11558, v); }
+
+    /**
+     * If gravity is a point (see {@link gravityPoint}), this will be the point of attraction.
+     */
+    get gravityPointCenter(): Vector2 { return _C(this, 4974) as Vector2; }
+    set gravityPointCenter(v: Vector2) { _C(this, 11557, v); }
+
+    /**
+     * The area's gravity vector (not normalized).
+     */
+    get gravityDirection(): Vector2 { return _C(this, 4973) as Vector2; }
+    set gravityDirection(v: Vector2) { _C(this, 11555, v); }
+
+    /**
+     * The area's gravity intensity (in pixels per second squared). This value multiplies the gravity direction. This is useful to alter the force of gravity without altering its direction.
+     */
+    get gravity(): number { return _C(this, 4971) as number; }
+    set gravity(v: number) { _C(this, 11553, v); }
+
+    /**
+     * Override mode for linear damping calculations within this area.
+     */
+    get linearDampSpaceOverride(): SpaceOverride { return _C(this, 5384) as SpaceOverride; }
+    set linearDampSpaceOverride(v: SpaceOverride) { _C(this, 11933, v); }
+
+    /**
+     * The rate at which objects stop moving in this area. Represents the linear velocity lost per second.
+     * See {@link ProjectSettings.physics/2d/defaultLinearDamp} for more details about damping.
+     */
+    get linearDamp(): number { return _C(this, 5382) as number; }
+    set linearDamp(v: number) { _C(this, 11931, v); }
+
+    /**
+     * Override mode for angular damping calculations within this area.
+     */
+    get angularDampSpaceOverride(): SpaceOverride { return _C(this, 3753) as SpaceOverride; }
+    set angularDampSpaceOverride(v: SpaceOverride) { _C(this, 10495, v); }
+
+    /**
+     * The rate at which objects stop spinning in this area. Represents the angular velocity lost per second.
+     * See {@link ProjectSettings.physics/2d/defaultAngularDamp} for more details about damping.
+     */
+    get angularDamp(): number { return _C(this, 3751) as number; }
+    set angularDamp(v: number) { _C(this, 10493, v); }
+
+    /**
+     * If `true`, the area's audio bus overrides the default audio bus.
+     */
+    get audioBusOverride(): boolean { return _C(this, 8161) as boolean; }
+    set audioBusOverride(v: boolean) { _C(this, 10557, v); }
+
+    /**
+     * The name of the area's audio bus.
+     */
+    get audioBusName(): StringName { return _C(this, 3817) as StringName; }
+    set audioBusName(v: StringName) { _C(this, 10556, v); }
+
+    /**
+     * Emitted when a {@link Shape2D} of the received `body` enters a shape of this area. `body` can be a {@link PhysicsBody2D} or a {@link TileMap}. {@link TileMap}s are detected if their {@link TileSet} has collision shapes configured. Requires {@link monitoring} to be set to `true`.
+     * `localShapeIndex` and `bodyShapeIndex` contain indices of the interacting shapes from this area and the interacting body, respectively. `bodyRid` contains the {@link RID} of the body. These values can be used with the {@link PhysicsServer2D}.
+     * **Example:** Get the {@link CollisionShape2D} node from the shape index:
+     *
+     *
+     * ```gdscript
+     *
+     * var body_shape_owner = body.shape_find_owner(body_shape_index)
+     * var body_shape_node = body.shape_owner_get_owner(body_shape_owner)
+     *
+     * var local_shape_owner = shape_find_owner(local_shape_index)
+     * var local_shape_node = shape_owner_get_owner(local_shape_owner)
+     *
+     * ```
+     */
+    get bodyShapeEntered(): Signal<(bodyRid: RID, body: Node2D, bodyShapeIndex: number, localShapeIndex: number) => void> { return _G(this, 1869) as Signal<(bodyRid: RID, body: Node2D, bodyShapeIndex: number, localShapeIndex: number) => void>; }
+    set bodyShapeEntered(v: ((bodyRid: RID, body: Node2D, bodyShapeIndex: number, localShapeIndex: number) => void) | null) { _G(this, 1869, v); }
+
+    /**
+     * Emitted when a {@link Shape2D} of the received `body` exits a shape of this area. `body` can be a {@link PhysicsBody2D} or a {@link TileMap}. {@link TileMap}s are detected if their {@link TileSet} has collision shapes configured. Requires {@link monitoring} to be set to `true`.
+     * See also {@link body_shape_entered}.
+     */
+    get bodyShapeExited(): Signal<(bodyRid: RID, body: Node2D, bodyShapeIndex: number, localShapeIndex: number) => void> { return _G(this, 1870) as Signal<(bodyRid: RID, body: Node2D, bodyShapeIndex: number, localShapeIndex: number) => void>; }
+    set bodyShapeExited(v: ((bodyRid: RID, body: Node2D, bodyShapeIndex: number, localShapeIndex: number) => void) | null) { _G(this, 1870, v); }
+
+    /**
+     * Emitted when the received `body` enters this area. `body` can be a {@link PhysicsBody2D} or a {@link TileMap}. {@link TileMap}s are detected if their {@link TileSet} has collision shapes configured. Requires {@link monitoring} to be set to `true`.
+     */
+    get bodyEntered(): Signal<(body: Node2D) => void> { return _G(this, 1820) as Signal<(body: Node2D) => void>; }
+    set bodyEntered(v: ((body: Node2D) => void) | null) { _G(this, 1820, v); }
+
+    /**
+     * Emitted when the received `body` exits this area. `body` can be a {@link PhysicsBody2D} or a {@link TileMap}. {@link TileMap}s are detected if their {@link TileSet} has collision shapes configured. Requires {@link monitoring} to be set to `true`.
+     */
+    get bodyExited(): Signal<(body: Node2D) => void> { return _G(this, 1821) as Signal<(body: Node2D) => void>; }
+    set bodyExited(v: ((body: Node2D) => void) | null) { _G(this, 1821, v); }
+
+    /**
+     * Emitted when a {@link Shape2D} of the received `area` enters a shape of this area. Requires {@link monitoring} to be set to `true`.
+     * `localShapeIndex` and `areaShapeIndex` contain indices of the interacting shapes from this area and the other area, respectively. `areaRid` contains the {@link RID} of the other area. These values can be used with the {@link PhysicsServer2D}.
+     * **Example:** Get the {@link CollisionShape2D} node from the shape index:
+     *
+     *
+     * ```gdscript
+     *
+     * var other_shape_owner = area.shape_find_owner(area_shape_index)
+     * var other_shape_node = area.shape_owner_get_owner(other_shape_owner)
+     *
+     * var local_shape_owner = shape_find_owner(local_shape_index)
+     * var local_shape_node = shape_owner_get_owner(local_shape_owner)
+     *
+     * ```
+     */
+    get areaShapeEntered(): Signal<(areaRid: RID, area: Area2D, areaShapeIndex: number, localShapeIndex: number) => void> { return _G(this, 1586) as Signal<(areaRid: RID, area: Area2D, areaShapeIndex: number, localShapeIndex: number) => void>; }
+    set areaShapeEntered(v: ((areaRid: RID, area: Area2D, areaShapeIndex: number, localShapeIndex: number) => void) | null) { _G(this, 1586, v); }
+
+    /**
+     * Emitted when a {@link Shape2D} of the received `area` exits a shape of this area. Requires {@link monitoring} to be set to `true`.
+     * See also {@link area_shape_entered}.
+     */
+    get areaShapeExited(): Signal<(areaRid: RID, area: Area2D, areaShapeIndex: number, localShapeIndex: number) => void> { return _G(this, 1587) as Signal<(areaRid: RID, area: Area2D, areaShapeIndex: number, localShapeIndex: number) => void>; }
+    set areaShapeExited(v: ((areaRid: RID, area: Area2D, areaShapeIndex: number, localShapeIndex: number) => void) | null) { _G(this, 1587, v); }
+
+    /**
+     * Emitted when the received `area` enters this area. Requires {@link monitoring} to be set to `true`.
+     */
+    get areaEntered(): Signal<(area: Area2D) => void> { return _G(this, 1557) as Signal<(area: Area2D) => void>; }
+    set areaEntered(v: ((area: Area2D) => void) | null) { _G(this, 1557, v); }
+
+    /**
+     * Emitted when the received `area` exits this area. Requires {@link monitoring} to be set to `true`.
+     */
+    get areaExited(): Signal<(area: Area2D) => void> { return _G(this, 1558) as Signal<(area: Area2D) => void>; }
+    set areaExited(v: ((area: Area2D) => void) | null) { _G(this, 1558, v); }
+
+    static readonly name = _R(79, Area2D);
+}
+
+export const SpaceOverride = {
+    /**
+     * This area does not affect gravity/damping.
+     */
+    SPACE_OVERRIDE_DISABLED: 0,
+    /**
+     * This area adds its gravity/damping values to whatever has been calculated so far (in {@link priority} order).
+     */
+    SPACE_OVERRIDE_COMBINE: 1,
+    /**
+     * This area adds its gravity/damping values to whatever has been calculated so far (in {@link priority} order), ignoring any lower priority areas.
+     */
+    SPACE_OVERRIDE_COMBINE_REPLACE: 2,
+    /**
+     * This area replaces any gravity/damping, even the defaults, ignoring any lower priority areas.
+     */
+    SPACE_OVERRIDE_REPLACE: 3,
+    /**
+     * This area replaces any gravity/damping calculated so far (in {@link priority} order), but keeps calculating the rest of the areas.
+     */
+    SPACE_OVERRIDE_REPLACE_COMBINE: 4,
+} as const;
+
+export type SpaceOverride = (typeof SpaceOverride)[keyof typeof SpaceOverride];
+

package/gen/classes/Area3D.ts

@@ -0,0 +1,305 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { CollisionObject3D } from './CollisionObject3D.ts';
+import type { GodotArray, NodePath, RID, Signal, StringName } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+import type { Node } from './Node.ts';
+import type { Node3D } from './Node3D.ts';
+
+/**
+ * {@link Area3D} is a region of 3D space defined by one or multiple {@link CollisionShape3D} or {@link CollisionPolygon3D} child nodes. It detects when other {@link CollisionObject3D}s enter or exit it, and it also keeps track of which collision objects haven't exited it yet (i.e. which one are overlapping it).
+ * This node can also locally alter or override physics parameters (gravity, damping) and route audio to custom audio buses.
+ * **Note:** Areas and bodies created with {@link PhysicsServer3D} might not interact as expected with {@link Area3D}s, and might not emit signals or track objects correctly.
+ * **Warning:** Using a {@link ConcavePolygonShape3D} inside a {@link CollisionShape3D} child of this node (created e.g. by using the **Create Trimesh Collision Sibling** option in the **Mesh** menu that appears when selecting a {@link MeshInstance3D} node) may give unexpected results, since this collision shape is hollow. If this is not desired, it has to be split into multiple {@link ConvexPolygonShape3D}s or primitive shapes like {@link BoxShape3D}, or in some cases it may be replaceable by a {@link CollisionPolygon3D}.
+ */
+export class Area3D extends CollisionObject3D {
+    constructor(name = 80) { super(name); }
+
+    /**
+     * Returns a list of intersecting {@link PhysicsBody3D}s, {@link SoftBody3D}s, and {@link GridMap}s. The overlapping body's {@link CollisionObject3D.collisionLayer} must be part of this area's {@link CollisionObject3D.collisionMask} in order to be detected.
+     * For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead.
+     * **Note:** Godot Physics does not support reporting overlaps with {@link SoftBody3D}, so will not return any such bodies.
+     */
+    getOverlappingBodies(): GodotArray<Node3D> { return _C(this, 5775) as GodotArray<Node3D>; }
+
+    /**
+     * Returns a list of intersecting {@link Area3D}s. The overlapping area's {@link CollisionObject3D.collisionLayer} must be part of this area's {@link CollisionObject3D.collisionMask} in order to be detected.
+     * For performance reasons (collisions are all processed at the same time) this list is modified once during the physics step, not immediately after objects are moved. Consider using signals instead.
+     */
+    getOverlappingAreas(): GodotArray<Area3D> { return _C(this, 5774) as GodotArray<Area3D>; }
+
+    /**
+     * Returns `true` if intersecting any {@link PhysicsBody3D}s, {@link SoftBody3D}s, or {@link GridMap}s, otherwise returns `false`. The overlapping body's {@link CollisionObject3D.collisionLayer} must be part of this area's {@link CollisionObject3D.collisionMask} in order to be detected.
+     * For performance reasons (collisions are all processed at the same time) the list of overlapping bodies is modified once during the physics step, not immediately after objects are moved. Consider using signals instead.
+     * **Note:** Godot Physics does not support reporting overlaps with {@link SoftBody3D}, so will not consider such bodies.
+     */
+    hasOverlappingBodies(): boolean { return _C(this, 7427) as boolean; }
+
+    /**
+     * Returns `true` if intersecting any {@link Area3D}s, otherwise returns `false`. The overlapping area's {@link CollisionObject3D.collisionLayer} must be part of this area's {@link CollisionObject3D.collisionMask} in order to be detected.
+     * For performance reasons (collisions are all processed at the same time) the list of overlapping areas is modified once during the physics step, not immediately after objects are moved. Consider using signals instead.
+     */
+    hasOverlappingAreas(): boolean { return _C(this, 7426) as boolean; }
+
+    /**
+     * Returns `true` if the given physics body intersects or overlaps this {@link Area3D}, `false` otherwise.
+     * `body` argument can either be a {@link PhysicsBody3D}, {@link SoftBody3D}, or a {@link GridMap} instance. While GridMaps are not physics body themselves, they register their tiles with collision shapes as a virtual physics body.
+     * **Note:** The result of this test is not immediate after moving objects. For performance, list of overlaps is updated once per frame and before the physics step. Consider using signals instead.
+     * **Note:** Godot Physics does not support reporting overlaps with {@link SoftBody3D}, so will return `false` in such cases.
+     */
+    overlapsBody(body: Node): boolean { return _C(this, 9246, body) as boolean; }
+
+    /**
+     * Returns `true` if the given {@link Area3D} intersects or overlaps this {@link Area3D}, `false` otherwise.
+     * **Note:** The result of this test is not immediate after moving objects. For performance, list of overlaps is updated once per frame and before the physics step. Consider using signals instead.
+     */
+    overlapsArea(area: Node): boolean { return _C(this, 9245, area) as boolean; }
+
+    /**
+     * If `true`, the area detects bodies or areas entering and exiting it.
+     */
+    get monitoring(): boolean { return _C(this, 8112) as boolean; }
+    set monitoring(v: boolean) { _C(this, 12084, v); }
+
+    /**
+     * If `true`, other monitoring areas can detect this area.
+     */
+    get monitorable(): boolean { return _C(this, 8111) as boolean; }
+    set monitorable(v: boolean) { _C(this, 12083, v); }
+
+    /**
+     * The area's priority. Higher priority areas are processed first. The {@link World3D}'s physics is always processed last, after all areas.
+     */
+    get priority(): number { return _C(this, 6015) as number; }
+    set priority(v: number) { _C(this, 12419, v); }
+
+    /**
+     * Override mode for gravity calculations within this area.
+     */
+    get gravitySpaceOverride(): SpaceOverride { return _C(this, 4977) as SpaceOverride; }
+    set gravitySpaceOverride(v: SpaceOverride) { _C(this, 11560, v); }
+
+    /**
+     * If `true`, gravity is calculated from a point (set via {@link gravityPointCenter}). See also {@link gravitySpaceOverride}.
+     */
+    get gravityPoint(): boolean { return _C(this, 7976) as boolean; }
+    set gravityPoint(v: boolean) { _C(this, 11556, v); }
+
+    /**
+     * The distance at which the gravity strength is equal to {@link gravity}. For example, on a planet 100 meters in radius with a surface gravity of 4.0 m/s², set the {@link gravity} to 4.0 and the unit distance to 100.0. The gravity will have falloff according to the inverse square law, so in the example, at 200 meters from the center the gravity will be 1.0 m/s² (twice the distance, 1/4th the gravity), at 50 meters it will be 16.0 m/s² (half the distance, 4x the gravity), and so on.
+     * The above is true only when the unit distance is a positive number. When this is set to 0.0, the gravity will be constant regardless of distance.
+     */
+    get gravityPointUnitDistance(): number { return _C(this, 4975) as number; }
+    set gravityPointUnitDistance(v: number) { _C(this, 11558, v); }
+
+    /**
+     * If gravity is a point (see {@link gravityPoint}), this will be the point of attraction.
+     */
+    get gravityPointCenter(): Vector3 { return _C(this, 4974) as Vector3; }
+    set gravityPointCenter(v: Vector3) { _C(this, 11557, v); }
+
+    /**
+     * The area's gravity vector (not normalized).
+     */
+    get gravityDirection(): Vector3 { return _C(this, 4973) as Vector3; }
+    set gravityDirection(v: Vector3) { _C(this, 11555, v); }
+
+    /**
+     * The area's gravity intensity (in meters per second squared). This value multiplies the gravity direction. This is useful to alter the force of gravity without altering its direction.
+     */
+    get gravity(): number { return _C(this, 4971) as number; }
+    set gravity(v: number) { _C(this, 11553, v); }
+
+    /**
+     * Override mode for linear damping calculations within this area.
+     */
+    get linearDampSpaceOverride(): SpaceOverride { return _C(this, 5384) as SpaceOverride; }
+    set linearDampSpaceOverride(v: SpaceOverride) { _C(this, 11933, v); }
+
+    /**
+     * The rate at which objects stop moving in this area. Represents the linear velocity lost per second.
+     * See {@link ProjectSettings.physics/3d/defaultLinearDamp} for more details about damping.
+     */
+    get linearDamp(): number { return _C(this, 5382) as number; }
+    set linearDamp(v: number) { _C(this, 11931, v); }
+
+    /**
+     * Override mode for angular damping calculations within this area.
+     */
+    get angularDampSpaceOverride(): SpaceOverride { return _C(this, 3753) as SpaceOverride; }
+    set angularDampSpaceOverride(v: SpaceOverride) { _C(this, 10495, v); }
+
+    /**
+     * The rate at which objects stop spinning in this area. Represents the angular velocity lost per second.
+     * See {@link ProjectSettings.physics/3d/defaultAngularDamp} for more details about damping.
+     */
+    get angularDamp(): number { return _C(this, 3751) as number; }
+    set angularDamp(v: number) { _C(this, 10493, v); }
+
+    /**
+     * The magnitude of area-specific wind force.
+     * **Note:** This wind force only applies to {@link SoftBody3D} nodes. Other physics bodies are currently not affected by wind.
+     */
+    get windForceMagnitude(): number { return _C(this, 7150) as number; }
+    set windForceMagnitude(v: number) { _C(this, 13374, v); }
+
+    /**
+     * The exponential rate at which wind force decreases with distance from its origin.
+     * **Note:** This wind force only applies to {@link SoftBody3D} nodes. Other physics bodies are currently not affected by wind.
+     */
+    get windAttenuationFactor(): number { return _C(this, 7149) as number; }
+    set windAttenuationFactor(v: number) { _C(this, 13373, v); }
+
+    /**
+     * The {@link Node3D} which is used to specify the direction and origin of an area-specific wind force. The direction is opposite to the z-axis of the {@link Node3D}'s local transform, and its origin is the origin of the {@link Node3D}'s local transform.
+     * **Note:** This wind force only applies to {@link SoftBody3D} nodes. Other physics bodies are currently not affected by wind.
+     */
+    get windSourcePath(): NodePath { return _C(this, 7151) as NodePath; }
+    set windSourcePath(v: NodePath) { _C(this, 13375, v); }
+
+    /**
+     * If `true`, the area's audio bus overrides the default audio bus.
+     */
+    get audioBusOverride(): boolean { return _C(this, 8161) as boolean; }
+    set audioBusOverride(v: boolean) { _C(this, 10557, v); }
+
+    /**
+     * The name of the area's audio bus.
+     */
+    get audioBusName(): StringName { return _C(this, 3817) as StringName; }
+    set audioBusName(v: StringName) { _C(this, 10556, v); }
+
+    /**
+     * If `true`, the area applies reverb to its associated audio.
+     */
+    get reverbBusEnabled(): boolean { return _C(this, 8415) as boolean; }
+    set reverbBusEnabled(v: boolean) { _C(this, 13234, v); }
+
+    /**
+     * The name of the reverb bus to use for this area's associated audio.
+     */
+    get reverbBusName(): StringName { return _C(this, 6174) as StringName; }
+    set reverbBusName(v: StringName) { _C(this, 12550, v); }
+
+    /**
+     * The degree to which this area applies reverb to its associated audio. Ranges from `0` to `1` with `0.1` precision.
+     */
+    get reverbBusAmount(): number { return _C(this, 6173) as number; }
+    set reverbBusAmount(v: number) { _C(this, 12549, v); }
+
+    /**
+     * The degree to which this area's reverb is a uniform effect. Ranges from `0` to `1` with `0.1` precision.
+     */
+    get reverbBusUniformity(): number { return _C(this, 6175) as number; }
+    set reverbBusUniformity(v: number) { _C(this, 12551, v); }
+
+    /**
+     * Emitted when a {@link Shape3D} of the received `body` enters a shape of this area. `body` can be a {@link PhysicsBody3D}, {@link SoftBody3D} or {@link GridMap}. {@link GridMap}s are detected if their {@link MeshLibrary} has collision shapes configured. Requires {@link monitoring} to be set to `true`.
+     * `localShapeIndex` and `bodyShapeIndex` contain indices of the interacting shapes from this area and the interacting body, respectively. `bodyRid` contains the {@link RID} of the body. These values can be used with the {@link PhysicsServer3D}.
+     * **Note:** Godot Physics does not support reporting overlaps with {@link SoftBody3D}, so will not emit this signal in such cases.
+     * **Example:** Get the {@link CollisionShape3D} node from the shape index:
+     *
+     *
+     * ```gdscript
+     *
+     * var body_shape_owner = body.shape_find_owner(body_shape_index)
+     * var body_shape_node = body.shape_owner_get_owner(body_shape_owner)
+     *
+     * var local_shape_owner = shape_find_owner(local_shape_index)
+     * var local_shape_node = shape_owner_get_owner(local_shape_owner)
+     *
+     * ```
+     */
+    get bodyShapeEntered(): Signal<(bodyRid: RID, body: Node3D, bodyShapeIndex: number, localShapeIndex: number) => void> { return _G(this, 1869) as Signal<(bodyRid: RID, body: Node3D, bodyShapeIndex: number, localShapeIndex: number) => void>; }
+    set bodyShapeEntered(v: ((bodyRid: RID, body: Node3D, bodyShapeIndex: number, localShapeIndex: number) => void) | null) { _G(this, 1869, v); }
+
+    /**
+     * Emitted when a {@link Shape3D} of the received `body` exits a shape of this area. `body` can be a {@link PhysicsBody3D}, {@link SoftBody3D} or {@link GridMap}. {@link GridMap}s are detected if their {@link MeshLibrary} has collision shapes configured. Requires {@link monitoring} to be set to `true`.
+     * See also {@link body_shape_entered}.
+     * **Note:** Godot Physics does not support reporting overlaps with {@link SoftBody3D}, so will not emit this signal in such cases.
+     */
+    get bodyShapeExited(): Signal<(bodyRid: RID, body: Node3D, bodyShapeIndex: number, localShapeIndex: number) => void> { return _G(this, 1870) as Signal<(bodyRid: RID, body: Node3D, bodyShapeIndex: number, localShapeIndex: number) => void>; }
+    set bodyShapeExited(v: ((bodyRid: RID, body: Node3D, bodyShapeIndex: number, localShapeIndex: number) => void) | null) { _G(this, 1870, v); }
+
+    /**
+     * Emitted when the received `body` enters this area. `body` can be a {@link PhysicsBody3D}, {@link SoftBody3D} or {@link GridMap}. {@link GridMap}s are detected if their {@link MeshLibrary} has collision shapes configured. Requires {@link monitoring} to be set to `true`.
+     * **Note:** Godot Physics does not support reporting overlaps with {@link SoftBody3D}, so will not emit this signal in such cases.
+     */
+    get bodyEntered(): Signal<(body: Node3D) => void> { return _G(this, 1820) as Signal<(body: Node3D) => void>; }
+    set bodyEntered(v: ((body: Node3D) => void) | null) { _G(this, 1820, v); }
+
+    /**
+     * Emitted when the received `body` exits this area. `body` can be a {@link PhysicsBody3D}, {@link SoftBody3D} or {@link GridMap}. {@link GridMap}s are detected if their {@link MeshLibrary} has collision shapes configured. Requires {@link monitoring} to be set to `true`.
+     * **Note:** Godot Physics does not support reporting overlaps with {@link SoftBody3D}, so will not emit this signal in such cases.
+     */
+    get bodyExited(): Signal<(body: Node3D) => void> { return _G(this, 1821) as Signal<(body: Node3D) => void>; }
+    set bodyExited(v: ((body: Node3D) => void) | null) { _G(this, 1821, v); }
+
+    /**
+     * Emitted when a {@link Shape3D} of the received `area` enters a shape of this area. Requires {@link monitoring} to be set to `true`.
+     * `localShapeIndex` and `areaShapeIndex` contain indices of the interacting shapes from this area and the other area, respectively. `areaRid` contains the {@link RID} of the other area. These values can be used with the {@link PhysicsServer3D}.
+     * **Example:** Get the {@link CollisionShape3D} node from the shape index:
+     *
+     *
+     * ```gdscript
+     *
+     * var other_shape_owner = area.shape_find_owner(area_shape_index)
+     * var other_shape_node = area.shape_owner_get_owner(other_shape_owner)
+     *
+     * var local_shape_owner = shape_find_owner(local_shape_index)
+     * var local_shape_node = shape_owner_get_owner(local_shape_owner)
+     *
+     * ```
+     */
+    get areaShapeEntered(): Signal<(areaRid: RID, area: Area3D, areaShapeIndex: number, localShapeIndex: number) => void> { return _G(this, 1586) as Signal<(areaRid: RID, area: Area3D, areaShapeIndex: number, localShapeIndex: number) => void>; }
+    set areaShapeEntered(v: ((areaRid: RID, area: Area3D, areaShapeIndex: number, localShapeIndex: number) => void) | null) { _G(this, 1586, v); }
+
+    /**
+     * Emitted when a {@link Shape3D} of the received `area` exits a shape of this area. Requires {@link monitoring} to be set to `true`.
+     * See also {@link area_shape_entered}.
+     */
+    get areaShapeExited(): Signal<(areaRid: RID, area: Area3D, areaShapeIndex: number, localShapeIndex: number) => void> { return _G(this, 1587) as Signal<(areaRid: RID, area: Area3D, areaShapeIndex: number, localShapeIndex: number) => void>; }
+    set areaShapeExited(v: ((areaRid: RID, area: Area3D, areaShapeIndex: number, localShapeIndex: number) => void) | null) { _G(this, 1587, v); }
+
+    /**
+     * Emitted when the received `area` enters this area. Requires {@link monitoring} to be set to `true`.
+     */
+    get areaEntered(): Signal<(area: Area3D) => void> { return _G(this, 1557) as Signal<(area: Area3D) => void>; }
+    set areaEntered(v: ((area: Area3D) => void) | null) { _G(this, 1557, v); }
+
+    /**
+     * Emitted when the received `area` exits this area. Requires {@link monitoring} to be set to `true`.
+     */
+    get areaExited(): Signal<(area: Area3D) => void> { return _G(this, 1558) as Signal<(area: Area3D) => void>; }
+    set areaExited(v: ((area: Area3D) => void) | null) { _G(this, 1558, v); }
+
+    static readonly name = _R(80, Area3D);
+}
+
+export const SpaceOverride = {
+    /**
+     * This area does not affect gravity/damping.
+     */
+    SPACE_OVERRIDE_DISABLED: 0,
+    /**
+     * This area adds its gravity/damping values to whatever has been calculated so far (in {@link priority} order).
+     */
+    SPACE_OVERRIDE_COMBINE: 1,
+    /**
+     * This area adds its gravity/damping values to whatever has been calculated so far (in {@link priority} order), ignoring any lower priority areas.
+     */
+    SPACE_OVERRIDE_COMBINE_REPLACE: 2,
+    /**
+     * This area replaces any gravity/damping, even the defaults, ignoring any lower priority areas.
+     */
+    SPACE_OVERRIDE_REPLACE: 3,
+    /**
+     * This area replaces any gravity/damping calculated so far (in {@link priority} order), but keeps calculating the rest of the areas.
+     */
+    SPACE_OVERRIDE_REPLACE_COMBINE: 4,
+} as const;
+
+export type SpaceOverride = (typeof SpaceOverride)[keyof typeof SpaceOverride];
+

package/gen/classes/AreaLight3D.ts

@@ -0,0 +1,56 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Light3D } from './Light3D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * An area light is a type of {@link Light3D} node that emits light over a two-dimensional area, in the shape of a rectangle. The light is attenuated throughout the distance. This attenuation can be configured by changing the energy, {@link areaAttenuation}, and {@link areaRange}.
+ * Light is emitted in the -Z direction of the node's global basis. For an unrotated light, this means that the light is emitted forwards, illuminating the front side of a 3D model (see {@link Vector3.FORWARD} and {@link Vector3.MODEL_FRONT}).
+ * Area lights can cast soft shadows using PCSS, which you can control by tweaking the size parameter. The shadow map is drawn from the center of the light.
+ * **Note:** Area lights have limited support in the Mobile and Compatibility renderers. In the Mobile renderer, the size of the penumbra doesn't vary as it should with PCSS. In Compatibility, area lights cannot cast shadows.
+ * **Warning:** Shadows cast by an area light may look incorrect if the object casting shadows doesn't have enough subdivisions and it's very close to the area light. This is the same limitation as the Dual Paraboloid shadow mode on an {@link OmniLight3D}.
+ * **Performance:** Area lights are more demanding on the GPU compared to omni and spot lights. In Forward+, there is an additional GPU cost on *all* rendered objects as soon as one area light is present in the view frustum (due to the nature of clustered lighting). Consider using them only for cinematics or when targeting high-end devices.
+ */
+export class AreaLight3D extends Light3D {
+    constructor(name = 81) { super(name); }
+
+    /**
+     * The range of the area in meters. This determines the maximum distance from any point on the area at which the area can still emit light.
+     */
+    get areaRange(): number { return _C(this, 5809, 4) as number; }
+    set areaRange(v: number) { _C(this, 12248, 4, v); }
+
+    /**
+     * Controls the distance attenuation function for this area light.
+     * A value of `0.0` will maintain a constant brightness through most of the range, but will smoothly attenuate the light at the edge of the range. Use a value of `2.0` for physically accurate lights as it results in the proper inverse square attenuation.
+     * **Note:** Setting attenuation to `2.0` or higher may result in distant objects receiving minimal light, even when within range. For example, with a range of `4096`, an object at `100` units is attenuated by a factor of `0.0001`. With a default brightness of `1`, the light would not be visible at that distance.
+     * **Note:** Using negative values or values higher than `10.0` may lead to unexpected results.
+     */
+    get areaAttenuation(): number { return _C(this, 5809, 6) as number; }
+    set areaAttenuation(v: number) { _C(this, 12248, 6, v); }
+
+    /**
+     * Defines whether the energy is normalized (divided) by the surface area of the light. If set to `true`, changing the size does not affect the total energy output, and does not dramatically alter the brightness of the scene.
+     */
+    get areaNormalizeEnergy(): boolean { return _C(this, 7765) as boolean; }
+    set areaNormalizeEnergy(v: boolean) { _C(this, 10528, v); }
+
+    /**
+     * The extents (width and height) of the area in meters.
+     */
+    get areaSize(): Vector2 { return _C(this, 3791) as Vector2; }
+    set areaSize(v: Vector2) { _C(this, 10529, v); }
+
+    /**
+     * An optional texture to use as a light source. Changing the texture at runtime might impact performance, as it needs to be drawn to the area light atlas with filtered mipmaps.
+     * If no texture is assigned, the area light emits uniform light across its surface.
+     * **Note:** Area light textures are only supported in the Forward+ and Mobile rendering methods, not Compatibility. To reduce the performance impact of switching textures at runtime, make sure each dimension of an area texture is either a multiple of 128 pixels, or a power of two. This removes the need for a scaling pass, which slows down texture changes. The textures don't necessarily have to be square to be optimal. Examples of optimal texture sizes include 32x64, 128x128, and 256x384.
+     */
+    get areaTexture(): Texture2D { return _C(this, 3792) as Texture2D; }
+    set areaTexture(v: Texture2D) { _C(this, 10530, v); }
+
+    static readonly name = _R(81, AreaLight3D);
+}