@ringozz/godot 0.1.0

package/gen/classes/PhysicsDirectBodyState2D.ts

@@ -0,0 +1,249 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Transform2D, Vector2 } from '../value-types/index.ts';
+import type { PhysicsDirectSpaceState2D } from './PhysicsDirectSpaceState2D.ts';
+
+/**
+ * Provides direct access to a physics body in the {@link PhysicsServer2D}, allowing safe changes to physics properties. This object is passed via the direct state callback of {@link RigidBody2D}, and is intended for changing the direct state of that body. See {@link RigidBody2D.IntegrateForces}.
+ */
+export class PhysicsDirectBodyState2D extends Object {
+
+    /**
+     * Returns the body's velocity at the given relative position.
+     * `localPosition` is the offset from the body origin in global coordinates.
+     */
+    getVelocityAtLocalPosition(localPosition: Vector2): Vector2 { return _C(this, 7036, localPosition) as Vector2; }
+
+    /**
+     * Applies a directional impulse without affecting rotation.
+     * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+     * This is equivalent to using {@link applyImpulse} at the body's center of mass.
+     */
+    applyCentralImpulse(impulse: Vector2): void { _C(this, 1529, impulse); }
+
+    /**
+     * Applies a rotational impulse to the body without affecting the position.
+     * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+     * **Note:** {@link inverseInertia} is required for this to work. To have {@link inverseInertia}, an active {@link CollisionShape2D} must be a child of the node, or you can manually set {@link inverseInertia}.
+     */
+    applyTorqueImpulse(impulse: number): void { _C(this, 1537, impulse); }
+
+    /**
+     * Applies a positioned impulse to the body.
+     * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+     * `position` is the offset from the body origin in global coordinates.
+     */
+    applyImpulse(impulse: Vector2, position?: Vector2 /* = Vector2(0, 0) */): void { _C(this, 1533, impulse, position); }
+
+    /**
+     * Applies a directional force without affecting rotation. A force is time dependent and meant to be applied every physics update.
+     * This is equivalent to using {@link applyForce} at the body's center of mass.
+     */
+    applyCentralForce(force?: Vector2 /* = Vector2(0, 0) */): void { _C(this, 1528, force); }
+
+    /**
+     * Applies a positioned force to the body. A force is time dependent and meant to be applied every physics update.
+     * `position` is the offset from the body origin in global coordinates.
+     */
+    applyForce(force: Vector2, position?: Vector2 /* = Vector2(0, 0) */): void { _C(this, 1531, force, position); }
+
+    /**
+     * Applies a rotational force without affecting position. A force is time dependent and meant to be applied every physics update.
+     * **Note:** {@link inverseInertia} is required for this to work. To have {@link inverseInertia}, an active {@link CollisionShape2D} must be a child of the node, or you can manually set {@link inverseInertia}.
+     */
+    applyTorque(torque: number): void { _C(this, 1536, torque); }
+
+    /**
+     * Adds a constant directional force without affecting rotation that keeps being applied over time until cleared with `constant_force = Vector2(0, 0)`.
+     * This is equivalent to using {@link addConstantForce} at the body's center of mass.
+     */
+    addConstantCentralForce(force?: Vector2 /* = Vector2(0, 0) */): void { _C(this, 1202, force); }
+
+    /**
+     * Adds a constant positioned force to the body that keeps being applied over time until cleared with `constant_force = Vector2(0, 0)`.
+     * `position` is the offset from the body origin in global coordinates.
+     */
+    addConstantForce(force: Vector2, position?: Vector2 /* = Vector2(0, 0) */): void { _C(this, 1203, force, position); }
+
+    /**
+     * Adds a constant rotational force without affecting position that keeps being applied over time until cleared with `constant_torque = 0`.
+     */
+    addConstantTorque(torque: number): void { _C(this, 1204, torque); }
+
+    /**
+     * Sets the body's total constant positional forces applied during each physics update.
+     * See {@link addConstantForce} and {@link addConstantCentralForce}.
+     */
+    setConstantForce(force: Vector2): void { _C(this, 10944, force); }
+
+    /**
+     * Returns the body's total constant positional forces applied during each physics update.
+     * See {@link addConstantForce} and {@link addConstantCentralForce}.
+     */
+    getConstantForce(): Vector2 { return _C(this, 4285) as Vector2; }
+
+    /**
+     * Sets the body's total constant rotational forces applied during each physics update.
+     * See {@link addConstantTorque}.
+     */
+    setConstantTorque(torque: number): void { _C(this, 10947, torque); }
+
+    /**
+     * Returns the body's total constant rotational forces applied during each physics update.
+     * See {@link addConstantTorque}.
+     */
+    getConstantTorque(): number { return _C(this, 4289) as number; }
+
+    /**
+     * Returns the number of contacts this body has with other bodies.
+     * **Note:** By default, this returns 0 unless bodies are configured to monitor contacts. See {@link RigidBody2D.contactMonitor}.
+     */
+    getContactCount(): number { return _C(this, 4301) as number; }
+
+    /**
+     * Returns the position of the contact point on the body in the global coordinate system.
+     */
+    getContactLocalPosition(contactIdx: number): Vector2 { return _C(this, 4304, contactIdx) as Vector2; }
+
+    /**
+     * Returns the local normal at the contact point.
+     */
+    getContactLocalNormal(contactIdx: number): Vector2 { return _C(this, 4303, contactIdx) as Vector2; }
+
+    /**
+     * Returns the local shape index of the collision.
+     */
+    getContactLocalShape(contactIdx: number): number { return _C(this, 4305, contactIdx) as number; }
+
+    /**
+     * Returns the velocity vector at the body's contact point.
+     */
+    getContactLocalVelocityAtPosition(contactIdx: number): Vector2 { return _C(this, 4306, contactIdx) as Vector2; }
+
+    /**
+     * Returns the collider's {@link RID}.
+     */
+    getContactCollider(contactIdx: number): RID { return _C(this, 4295, contactIdx) as RID; }
+
+    /**
+     * Returns the position of the contact point on the collider in the global coordinate system.
+     */
+    getContactColliderPosition(contactIdx: number): Vector2 { return _C(this, 4298, contactIdx) as Vector2; }
+
+    /**
+     * Returns the collider's object id.
+     */
+    getContactColliderId(contactIdx: number): number { return _C(this, 4296, contactIdx) as number; }
+
+    /**
+     * Returns the collider object. This depends on how it was created (will return a scene node if such was used to create it).
+     */
+    getContactColliderObject(contactIdx: number): Object { return _C(this, 4297, contactIdx) as Object; }
+
+    /**
+     * Returns the collider's shape index.
+     */
+    getContactColliderShape(contactIdx: number): number { return _C(this, 4299, contactIdx) as number; }
+
+    /**
+     * Returns the velocity vector at the collider's contact point.
+     */
+    getContactColliderVelocityAtPosition(contactIdx: number): Vector2 { return _C(this, 4300, contactIdx) as Vector2; }
+
+    /**
+     * Returns the impulse created by the contact.
+     */
+    getContactImpulse(contactIdx: number): Vector2 { return _C(this, 4302, contactIdx) as Vector2; }
+
+    /**
+     * Updates the body's linear and angular velocity by applying gravity and damping for the equivalent of one physics tick.
+     */
+    integrateForces(): void { _C(this, 7681); }
+
+    /**
+     * Returns the current state of the space, useful for queries.
+     */
+    getSpaceState(): PhysicsDirectSpaceState2D { return _C(this, 6465) as PhysicsDirectSpaceState2D; }
+
+    /**
+     * The timestep (delta) used for the simulation.
+     */
+    get step(): number { return _C(this, 6553) as number; }
+
+    /**
+     * The inverse of the mass of the body.
+     */
+    get inverseMass(): number { return _C(this, 5163) as number; }
+
+    /**
+     * The inverse of the inertia of the body.
+     */
+    get inverseInertia(): number { return _C(this, 5161) as number; }
+
+    /**
+     * The rate at which the body stops rotating, if there are not any other forces moving it.
+     */
+    get totalAngularDamp(): number { return _C(this, 6849) as number; }
+
+    /**
+     * The rate at which the body stops moving, if there are not any other forces moving it.
+     */
+    get totalLinearDamp(): number { return _C(this, 6854) as number; }
+
+    /**
+     * The total gravity vector being currently applied to this body.
+     */
+    get totalGravity(): Vector2 { return _C(this, 6852) as Vector2; }
+
+    /**
+     * The body's center of mass position relative to the body's center in the global coordinate system.
+     */
+    get centerOfMass(): Vector2 { return _C(this, 4126) as Vector2; }
+
+    /**
+     * The body's center of mass position in the body's local coordinate system.
+     */
+    get centerOfMassLocal(): Vector2 { return _C(this, 4127) as Vector2; }
+
+    /**
+     * The body's rotational velocity in *radians* per second.
+     */
+    get angularVelocity(): number { return _C(this, 3757) as number; }
+    set angularVelocity(v: number) { _C(this, 10500, v); }
+
+    /**
+     * The body's linear velocity in pixels per second.
+     */
+    get linearVelocity(): Vector2 { return _C(this, 5386) as Vector2; }
+    set linearVelocity(v: Vector2) { _C(this, 11935, v); }
+
+    /**
+     * If `true`, this body is currently sleeping (not active).
+     */
+    get sleeping(): boolean { return _C(this, 8319) as boolean; }
+    set sleeping(v: boolean) { _C(this, 12777, v); }
+
+    /**
+     * The body's collision layer.
+     */
+    get collisionLayer(): number { return _C(this, 4202) as number; }
+    set collisionLayer(v: number) { _C(this, 10892, v); }
+
+    /**
+     * The body's collision mask.
+     */
+    get collisionMask(): number { return _C(this, 4205) as number; }
+    set collisionMask(v: number) { _C(this, 10894, v); }
+
+    /**
+     * The body's transformation matrix.
+     */
+    get transform(): Transform2D { return _C(this, 6874) as Transform2D; }
+    set transform(v: Transform2D) { _C(this, 13134, v); }
+
+    static readonly name = _R(561, PhysicsDirectBodyState2D);
+}

package/gen/classes/PhysicsDirectBodyState2DExtension.ts

@@ -0,0 +1,19 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PhysicsDirectBodyState2D } from './PhysicsDirectBodyState2D.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Transform2D, Vector2 } from '../value-types/index.ts';
+import type { Object } from './Object.ts';
+import type { PhysicsDirectSpaceState2D } from './PhysicsDirectSpaceState2D.ts';
+
+/**
+ * This class extends {@link PhysicsDirectBodyState2D} by providing additional virtual methods that can be overridden. When these methods are overridden, they will be called instead of the internal methods of the physics server.
+ * Intended for use with GDExtension to create custom implementations of {@link PhysicsDirectBodyState2D}.
+ */
+export class PhysicsDirectBodyState2DExtension extends PhysicsDirectBodyState2D {
+    constructor(name = 562) { super(name); }
+
+    static readonly name = _R(562, PhysicsDirectBodyState2DExtension);
+}

package/gen/classes/PhysicsDirectBodyState3D.ts

@@ -0,0 +1,256 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Basis, Transform3D, Vector3 } from '../value-types/index.ts';
+import type { PhysicsDirectSpaceState3D } from './PhysicsDirectSpaceState3D.ts';
+
+/**
+ * Provides direct access to a physics body in the {@link PhysicsServer3D}, allowing safe changes to physics properties. This object is passed via the direct state callback of {@link RigidBody3D}, and is intended for changing the direct state of that body. See {@link RigidBody3D.IntegrateForces}.
+ */
+export class PhysicsDirectBodyState3D extends Object {
+
+    /**
+     * Returns the body's velocity at the given relative position.
+     * `localPosition` is the offset from the body origin in global coordinates.
+     */
+    getVelocityAtLocalPosition(localPosition: Vector3): Vector3 { return _C(this, 7036, localPosition) as Vector3; }
+
+    /**
+     * Applies a directional impulse without affecting rotation.
+     * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+     * This is equivalent to using {@link applyImpulse} at the body's center of mass.
+     */
+    applyCentralImpulse(impulse?: Vector3 /* = Vector3(0, 0, 0) */): void { _C(this, 1529, impulse); }
+
+    /**
+     * Applies a positioned impulse to the body.
+     * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+     * `position` is the offset from the body origin in global coordinates.
+     */
+    applyImpulse(impulse: Vector3, position?: Vector3 /* = Vector3(0, 0, 0) */): void { _C(this, 1533, impulse, position); }
+
+    /**
+     * Applies a rotational impulse to the body without affecting the position.
+     * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+     * **Note:** {@link inverseInertia} is required for this to work. To have {@link inverseInertia}, an active {@link CollisionShape3D} must be a child of the node, or you can manually set {@link inverseInertia}.
+     */
+    applyTorqueImpulse(impulse: Vector3): void { _C(this, 1537, impulse); }
+
+    /**
+     * Applies a directional force without affecting rotation. A force is time dependent and meant to be applied every physics update.
+     * This is equivalent to using {@link applyForce} at the body's center of mass.
+     */
+    applyCentralForce(force?: Vector3 /* = Vector3(0, 0, 0) */): void { _C(this, 1528, force); }
+
+    /**
+     * Applies a positioned force to the body. A force is time dependent and meant to be applied every physics update.
+     * `position` is the offset from the body origin in global coordinates.
+     */
+    applyForce(force: Vector3, position?: Vector3 /* = Vector3(0, 0, 0) */): void { _C(this, 1531, force, position); }
+
+    /**
+     * Applies a rotational force without affecting position. A force is time dependent and meant to be applied every physics update.
+     * **Note:** {@link inverseInertia} is required for this to work. To have {@link inverseInertia}, an active {@link CollisionShape3D} must be a child of the node, or you can manually set {@link inverseInertia}.
+     */
+    applyTorque(torque: Vector3): void { _C(this, 1536, torque); }
+
+    /**
+     * Adds a constant directional force without affecting rotation that keeps being applied over time until cleared with `constant_force = Vector3(0, 0, 0)`.
+     * This is equivalent to using {@link addConstantForce} at the body's center of mass.
+     */
+    addConstantCentralForce(force?: Vector3 /* = Vector3(0, 0, 0) */): void { _C(this, 1202, force); }
+
+    /**
+     * Adds a constant positioned force to the body that keeps being applied over time until cleared with `constant_force = Vector3(0, 0, 0)`.
+     * `position` is the offset from the body origin in global coordinates.
+     */
+    addConstantForce(force: Vector3, position?: Vector3 /* = Vector3(0, 0, 0) */): void { _C(this, 1203, force, position); }
+
+    /**
+     * Adds a constant rotational force without affecting position that keeps being applied over time until cleared with `constant_torque = Vector3(0, 0, 0)`.
+     */
+    addConstantTorque(torque: Vector3): void { _C(this, 1204, torque); }
+
+    /**
+     * Sets the body's total constant positional forces applied during each physics update.
+     * See {@link addConstantForce} and {@link addConstantCentralForce}.
+     */
+    setConstantForce(force: Vector3): void { _C(this, 10944, force); }
+
+    /**
+     * Returns the body's total constant positional forces applied during each physics update.
+     * See {@link addConstantForce} and {@link addConstantCentralForce}.
+     */
+    getConstantForce(): Vector3 { return _C(this, 4285) as Vector3; }
+
+    /**
+     * Sets the body's total constant rotational forces applied during each physics update.
+     * See {@link addConstantTorque}.
+     */
+    setConstantTorque(torque: Vector3): void { _C(this, 10947, torque); }
+
+    /**
+     * Returns the body's total constant rotational forces applied during each physics update.
+     * See {@link addConstantTorque}.
+     */
+    getConstantTorque(): Vector3 { return _C(this, 4289) as Vector3; }
+
+    /**
+     * Returns the number of contacts this body has with other bodies.
+     * **Note:** By default, this returns 0 unless bodies are configured to monitor contacts. See {@link RigidBody3D.contactMonitor}.
+     */
+    getContactCount(): number { return _C(this, 4301) as number; }
+
+    /**
+     * Returns the position of the contact point on the body in the global coordinate system.
+     */
+    getContactLocalPosition(contactIdx: number): Vector3 { return _C(this, 4304, contactIdx) as Vector3; }
+
+    /**
+     * Returns the local normal at the contact point.
+     */
+    getContactLocalNormal(contactIdx: number): Vector3 { return _C(this, 4303, contactIdx) as Vector3; }
+
+    /**
+     * Impulse created by the contact.
+     */
+    getContactImpulse(contactIdx: number): Vector3 { return _C(this, 4302, contactIdx) as Vector3; }
+
+    /**
+     * Returns the local shape index of the collision.
+     */
+    getContactLocalShape(contactIdx: number): number { return _C(this, 4305, contactIdx) as number; }
+
+    /**
+     * Returns the linear velocity vector at the body's contact point.
+     */
+    getContactLocalVelocityAtPosition(contactIdx: number): Vector3 { return _C(this, 4306, contactIdx) as Vector3; }
+
+    /**
+     * Returns the collider's {@link RID}.
+     */
+    getContactCollider(contactIdx: number): RID { return _C(this, 4295, contactIdx) as RID; }
+
+    /**
+     * Returns the position of the contact point on the collider in the global coordinate system.
+     */
+    getContactColliderPosition(contactIdx: number): Vector3 { return _C(this, 4298, contactIdx) as Vector3; }
+
+    /**
+     * Returns the collider's object id.
+     */
+    getContactColliderId(contactIdx: number): number { return _C(this, 4296, contactIdx) as number; }
+
+    /**
+     * Returns the collider object.
+     */
+    getContactColliderObject(contactIdx: number): Object { return _C(this, 4297, contactIdx) as Object; }
+
+    /**
+     * Returns the collider's shape index.
+     */
+    getContactColliderShape(contactIdx: number): number { return _C(this, 4299, contactIdx) as number; }
+
+    /**
+     * Returns the linear velocity vector at the collider's contact point.
+     */
+    getContactColliderVelocityAtPosition(contactIdx: number): Vector3 { return _C(this, 4300, contactIdx) as Vector3; }
+
+    /**
+     * Updates the body's linear and angular velocity by applying gravity and damping for the equivalent of one physics tick.
+     */
+    integrateForces(): void { _C(this, 7681); }
+
+    /**
+     * Returns the current state of the space, useful for queries.
+     */
+    getSpaceState(): PhysicsDirectSpaceState3D { return _C(this, 6465) as PhysicsDirectSpaceState3D; }
+
+    /**
+     * The timestep (delta) used for the simulation.
+     */
+    get step(): number { return _C(this, 6553) as number; }
+
+    /**
+     * The inverse of the mass of the body.
+     */
+    get inverseMass(): number { return _C(this, 5163) as number; }
+
+    /**
+     * The rate at which the body stops rotating, if there are not any other forces moving it.
+     */
+    get totalAngularDamp(): number { return _C(this, 6849) as number; }
+
+    /**
+     * The rate at which the body stops moving, if there are not any other forces moving it.
+     */
+    get totalLinearDamp(): number { return _C(this, 6854) as number; }
+
+    /**
+     * The inverse of the inertia of the body.
+     */
+    get inverseInertia(): Vector3 { return _C(this, 5161) as Vector3; }
+
+    /**
+     * The inverse of the inertia tensor of the body.
+     */
+    get inverseInertiaTensor(): Basis { return _C(this, 5162) as Basis; }
+
+    /**
+     * The total gravity vector being currently applied to this body.
+     */
+    get totalGravity(): Vector3 { return _C(this, 6852) as Vector3; }
+
+    /**
+     * The body's center of mass position relative to the body's center in the global coordinate system.
+     */
+    get centerOfMass(): Vector3 { return _C(this, 4126) as Vector3; }
+
+    /**
+     * The body's center of mass position in the body's local coordinate system.
+     */
+    get centerOfMassLocal(): Vector3 { return _C(this, 4127) as Vector3; }
+
+    get principalInertiaAxes(): Basis { return _C(this, 6014) as Basis; }
+
+    /**
+     * The body's rotational velocity in *radians* per second.
+     */
+    get angularVelocity(): Vector3 { return _C(this, 3757) as Vector3; }
+    set angularVelocity(v: Vector3) { _C(this, 10500, v); }
+
+    /**
+     * The body's linear velocity in units per second.
+     */
+    get linearVelocity(): Vector3 { return _C(this, 5386) as Vector3; }
+    set linearVelocity(v: Vector3) { _C(this, 11935, v); }
+
+    /**
+     * If `true`, this body is currently sleeping (not active).
+     */
+    get sleeping(): boolean { return _C(this, 8319) as boolean; }
+    set sleeping(v: boolean) { _C(this, 12777, v); }
+
+    /**
+     * The body's collision layer.
+     */
+    get collisionLayer(): number { return _C(this, 4202) as number; }
+    set collisionLayer(v: number) { _C(this, 10892, v); }
+
+    /**
+     * The body's collision mask.
+     */
+    get collisionMask(): number { return _C(this, 4205) as number; }
+    set collisionMask(v: number) { _C(this, 10894, v); }
+
+    /**
+     * The body's transformation matrix.
+     */
+    get transform(): Transform3D { return _C(this, 6874) as Transform3D; }
+    set transform(v: Transform3D) { _C(this, 13134, v); }
+
+    static readonly name = _R(563, PhysicsDirectBodyState3D);
+}

package/gen/classes/PhysicsDirectBodyState3DExtension.ts

@@ -0,0 +1,19 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PhysicsDirectBodyState3D } from './PhysicsDirectBodyState3D.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Basis, Transform3D, Vector3 } from '../value-types/index.ts';
+import type { Object } from './Object.ts';
+import type { PhysicsDirectSpaceState3D } from './PhysicsDirectSpaceState3D.ts';
+
+/**
+ * This class extends {@link PhysicsDirectBodyState3D} by providing additional virtual methods that can be overridden. When these methods are overridden, they will be called instead of the internal methods of the physics server.
+ * Intended for use with GDExtension to create custom implementations of {@link PhysicsDirectBodyState3D}.
+ */
+export class PhysicsDirectBodyState3DExtension extends PhysicsDirectBodyState3D {
+    constructor(name = 564) { super(name); }
+
+    static readonly name = _R(564, PhysicsDirectBodyState3DExtension);
+}

package/gen/classes/PhysicsDirectSpaceState2D.ts

@@ -0,0 +1,77 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { GodotArray, GodotDictionary, PackedFloat32Array } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { PhysicsPointQueryParameters2D } from './PhysicsPointQueryParameters2D.ts';
+import type { PhysicsRayQueryParameters2D } from './PhysicsRayQueryParameters2D.ts';
+import type { PhysicsShapeQueryParameters2D } from './PhysicsShapeQueryParameters2D.ts';
+
+/**
+ * Provides direct access to a physics space in the {@link PhysicsServer2D}. It's used mainly to do queries against objects and areas residing in a given space.
+ * **Note:** This class is not meant to be instantiated directly. Use {@link World2D.directSpaceState} to get the world's physics 2D space state.
+ */
+export class PhysicsDirectSpaceState2D extends Object {
+
+    /**
+     * Checks whether a point is inside any solid shape. Position and other parameters are defined through {@link PhysicsPointQueryParameters2D}. The shapes the point is inside of are returned in an array containing dictionaries with the following fields:
+     * `collider`: The colliding object.
+     * `collider_id`: The colliding object's ID.
+     * `rid`: The intersecting object's {@link RID}.
+     * `shape`: The shape index of the colliding shape.
+     * The number of intersections can be limited with the `maxResults` parameter, to reduce the processing time.
+     * **Note:** {@link ConcavePolygonShape2D}s and {@link CollisionPolygon2D}s in `Segments` build mode are not solid shapes. Therefore, they will not be detected.
+     */
+    intersectPoint(parameters: PhysicsPointQueryParameters2D, maxResults?: number /* = 32 */): GodotArray<GodotDictionary> { return _C(this, 7699, parameters, maxResults) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Intersects a ray in a given space. Ray position and other parameters are defined through {@link PhysicsRayQueryParameters2D}. The returned object is a dictionary with the following fields:
+     * `collider`: The colliding object.
+     * `collider_id`: The colliding object's ID.
+     * `normal`: The object's surface normal at the intersection point, or `Vector2(0, 0)` if the ray starts inside the shape and {@link PhysicsRayQueryParameters2D.hitFromInside} is `true`.
+     * `position`: The intersection point.
+     * `rid`: The intersecting object's {@link RID}.
+     * `shape`: The shape index of the colliding shape.
+     * If the ray did not intersect anything, then an empty dictionary is returned instead.
+     */
+    intersectRay(parameters: PhysicsRayQueryParameters2D): GodotDictionary { return _C(this, 7702, parameters) as GodotDictionary; }
+
+    /**
+     * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters2D} object, against the space. The intersected shapes are returned in an array containing dictionaries with the following fields:
+     * `collider`: The colliding object.
+     * `collider_id`: The colliding object's ID.
+     * `rid`: The intersecting object's {@link RID}.
+     * `shape`: The shape index of the colliding shape.
+     * The number of intersections can be limited with the `maxResults` parameter, to reduce the processing time.
+     */
+    intersectShape(parameters: PhysicsShapeQueryParameters2D, maxResults?: number /* = 32 */): GodotArray<GodotDictionary> { return _C(this, 7704, parameters, maxResults) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Checks how far a {@link Shape2D} can move without colliding. All the parameters for the query, including the shape and the motion, are supplied through a {@link PhysicsShapeQueryParameters2D} object.
+     * Returns an array with the safe and unsafe proportions (between 0 and 1) of the motion. The safe proportion is the maximum fraction of the motion that can be made without a collision. The unsafe proportion is the minimum fraction of the distance that must be moved for a collision. If no collision is detected a result of `[1.0, 1.0]` will be returned.
+     * **Note:** Any {@link Shape2D}s that the shape is already colliding with e.g. inside of, will be ignored. Use {@link collideShape} to determine the {@link Shape2D}s that the shape is already colliding with.
+     */
+    castMotion(parameters: PhysicsShapeQueryParameters2D): PackedFloat32Array { return _C(this, 2153, parameters) as PackedFloat32Array; }
+
+    /**
+     * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters2D} object, against the space. The resulting array contains a list of points where the shape intersects another. Like with {@link intersectShape}, the number of returned results can be limited to save processing time.
+     * Returned points are a list of pairs of contact points. For each pair the first one is in the shape passed in {@link PhysicsShapeQueryParameters2D} object, second one is in the collided shape from the physics space.
+     */
+    collideShape(parameters: PhysicsShapeQueryParameters2D, maxResults?: number /* = 32 */): GodotArray<Vector2> { return _C(this, 2347, parameters, maxResults) as GodotArray<Vector2>; }
+
+    /**
+     * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters2D} object, against the space. If it collides with more than one shape, the nearest one is selected. The returned object is a dictionary containing the following fields:
+     * `collider_id`: The colliding object's ID.
+     * `linear_velocity`: The colliding object's velocity {@link Vector2}. If the object is an {@link Area2D}, the result is `(0, 0)`.
+     * `normal`: The collision normal of the query shape at the intersection point, pointing away from the intersecting object.
+     * `point`: The intersection point.
+     * `rid`: The intersecting object's {@link RID}.
+     * `shape`: The shape index of the colliding shape.
+     * If the shape did not intersect anything, then an empty dictionary is returned instead.
+     */
+    getRestInfo(parameters: PhysicsShapeQueryParameters2D): GodotDictionary { return _C(this, 6169, parameters) as GodotDictionary; }
+
+    static readonly name = _R(565, PhysicsDirectSpaceState2D);
+}

package/gen/classes/PhysicsDirectSpaceState2DExtension.ts

@@ -0,0 +1,19 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PhysicsDirectSpaceState2D } from './PhysicsDirectSpaceState2D.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Transform2D, Vector2 } from '../value-types/index.ts';
+
+/**
+ * This class extends {@link PhysicsDirectSpaceState2D} by providing additional virtual methods that can be overridden. When these methods are overridden, they will be called instead of the internal methods of the physics server.
+ * Intended for use with GDExtension to create custom implementations of {@link PhysicsDirectSpaceState2D}.
+ */
+export class PhysicsDirectSpaceState2DExtension extends PhysicsDirectSpaceState2D {
+    constructor(name = 566) { super(name); }
+
+    isBodyExcludedFromQuery(body: RID): boolean { return _C(this, 7799, body) as boolean; }
+
+    static readonly name = _R(566, PhysicsDirectSpaceState2DExtension);
+}