@ringozz/godot 0.1.0

package/gen/classes/PhysicsServer3DExtension.ts

@@ -0,0 +1,26 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PhysicsServer3D } from './PhysicsServer3D.ts';
+import type { Callable, GodotArray, PackedVector3Array, RID, Variant } from '../heap-types/index.ts';
+import type { AABB, Transform3D, Vector3 } from '../value-types/index.ts';
+import type { JointType } from './PhysicalBone3D.ts';
+import type { PhysicsDirectBodyState3D } from './PhysicsDirectBodyState3D.ts';
+import type { PhysicsDirectSpaceState3D } from './PhysicsDirectSpaceState3D.ts';
+import type { AreaParameter, BodyAxis, BodyMode, BodyParameter, BodyState, ConeTwistJointParam, G6DOFJointAxisFlag, G6DOFJointAxisParam, HingeJointFlag, HingeJointParam, PinJointParam, ProcessInfo, ShapeType, SliderJointParam, SpaceParameter } from './PhysicsServer3D.ts';
+import type { PhysicsServer3DRenderingServerHandler } from './PhysicsServer3DRenderingServerHandler.ts';
+
+/**
+ * This class extends {@link PhysicsServer3D} 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 PhysicsServer3D}.
+ */
+export class PhysicsServer3DExtension extends PhysicsServer3D {
+    constructor(name = 578) { super(name); }
+
+    bodyTestMotionIsExcludingBody(body: RID): boolean { return _C(this, 1873, body) as boolean; }
+
+    bodyTestMotionIsExcludingObject(object: number /* uint64 */): boolean { return _C(this, 1874, object) as boolean; }
+
+    static readonly name = _R(578, PhysicsServer3DExtension);
+}

package/gen/classes/PhysicsServer3DManager.ts

@@ -0,0 +1,28 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Callable } from '../heap-types/index.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 579));
+
+/**
+ * {@link PhysicsServer3DManager} is the API for registering {@link PhysicsServer3D} implementations and for setting the default implementation.
+ * **Note:** It is not possible to switch physics servers at runtime. This class is only used on startup at the server initialization level, by Godot itself and possibly by GDExtensions.
+ */
+export class PhysicsServer3DManager extends GodotVar {
+
+    /**
+     * Register a {@link PhysicsServer3D} implementation by passing a `name` and a {@link Callable} that returns a {@link PhysicsServer3D} object.
+     */
+    static registerServer(name: string, createCallback: Callable): void { _C($(), 9856, name, createCallback); }
+
+    /**
+     * Set the default {@link PhysicsServer3D} implementation to the one identified by `name`, if `priority` is greater than the priority of the current default implementation.
+     */
+    static setDefaultServer(name: string, priority: number): void { _C($(), 11067, name, priority); }
+
+    static readonly name = _R(579, PhysicsServer3DManager);
+}

package/gen/classes/PhysicsServer3DRenderingServerHandler.ts

@@ -0,0 +1,27 @@
+// 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 { AABB, Vector3 } from '../value-types/index.ts';
+
+export class PhysicsServer3DRenderingServerHandler extends Object {
+    constructor(name = 580) { super(name); }
+
+    /**
+     * Sets the position for the {@link SoftBody3D} vertex at the index specified by `vertexId`.
+     */
+    setVertex(vertexId: number, vertex: Vector3): void { _C(this, 13286, vertexId, vertex); }
+
+    /**
+     * Sets the normal for the {@link SoftBody3D} vertex at the index specified by `vertexId`.
+     */
+    setNormal(vertexId: number, normal: Vector3): void { _C(this, 12145, vertexId, normal); }
+
+    /**
+     * Sets the bounding box for the {@link SoftBody3D}.
+     */
+    setAabb(aabb: AABB): void { _C(this, 10395, aabb); }
+
+    static readonly name = _R(580, PhysicsServer3DRenderingServerHandler);
+}

package/gen/classes/PhysicsShapeQueryParameters2D.ts

@@ -0,0 +1,89 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { GodotArray, RID } from '../heap-types/index.ts';
+import type { Transform2D, Vector2 } from '../value-types/index.ts';
+import type { Resource } from './Resource.ts';
+
+/**
+ * By changing various properties of this object, such as the shape, you can configure the parameters for {@link PhysicsDirectSpaceState2D}'s methods.
+ */
+export class PhysicsShapeQueryParameters2D extends RefCounted {
+    constructor(name = 581) { super(name); }
+
+    /**
+     * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. See [Collision layers and masks]($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+     */
+    get collisionMask(): number { return _C(this, 4205) as number; }
+    set collisionMask(v: number) { _C(this, 10894, v); }
+
+    /**
+     * The list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject2D.getRid} to get the {@link RID} associated with a {@link CollisionObject2D}-derived node.
+     * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+     */
+    get exclude(): GodotArray<RID> { return _C(this, 4693) as GodotArray<RID>; }
+    set exclude(v: GodotArray<RID>) { _C(this, 11309, v); }
+
+    /**
+     * The collision margin for the shape.
+     */
+    get margin(): number { return _C(this, 5441) as number; }
+    set margin(v: number) { _C(this, 11969, v); }
+
+    /**
+     * The motion of the shape being queried for.
+     */
+    get motion(): Vector2 { return _C(this, 5579) as Vector2; }
+    set motion(v: Vector2) { _C(this, 12086, v); }
+
+    /**
+     * The {@link Shape2D} that will be used for collision/intersection queries. This stores the actual reference which avoids the shape to be released while being used for queries, so always prefer using this over {@link shapeRid}.
+     */
+    get shape(): Resource { return _C(this, 6370) as Resource; }
+    set shape(v: Resource) { _C(this, 12717, v); }
+
+    /**
+     * The queried shape's {@link RID} that will be used for collision/intersection queries. Use this over {@link shape} if you want to optimize for performance using the Servers API:
+     *
+     *
+     * ```gdscript
+     *
+     * var shape_rid = PhysicsServer2D.circle_shape_create()
+     * var radius = 64
+     * PhysicsServer2D.shape_set_data(shape_rid, radius)
+     *
+     * var params = PhysicsShapeQueryParameters2D.new()
+     * params.shape_rid = shape_rid
+     *
+     * # Execute physics queries here...
+     *
+     * # Release the shape when done with physics queries.
+     * PhysicsServer2D.free_rid(shape_rid)
+     *
+     * ```
+     */
+    get shapeRid(): RID { return _C(this, 6374) as RID; }
+    set shapeRid(v: RID) { _C(this, 12719, v); }
+
+    /**
+     * The queried shape's transform matrix.
+     */
+    get transform(): Transform2D { return _C(this, 6874) as Transform2D; }
+    set transform(v: Transform2D) { _C(this, 13134, v); }
+
+    /**
+     * If `true`, the query will take {@link PhysicsBody2D}s into account.
+     */
+    get collideWithBodies(): boolean { return _C(this, 7840) as boolean; }
+    set collideWithBodies(v: boolean) { _C(this, 10885, v); }
+
+    /**
+     * If `true`, the query will take {@link Area2D}s into account.
+     */
+    get collideWithAreas(): boolean { return _C(this, 7839) as boolean; }
+    set collideWithAreas(v: boolean) { _C(this, 10884, v); }
+
+    static readonly name = _R(581, PhysicsShapeQueryParameters2D);
+}

package/gen/classes/PhysicsShapeQueryParameters3D.ts

@@ -0,0 +1,89 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { GodotArray, RID } from '../heap-types/index.ts';
+import type { Transform3D, Vector3 } from '../value-types/index.ts';
+import type { Resource } from './Resource.ts';
+
+/**
+ * By changing various properties of this object, such as the shape, you can configure the parameters for {@link PhysicsDirectSpaceState3D}'s methods.
+ */
+export class PhysicsShapeQueryParameters3D extends RefCounted {
+    constructor(name = 582) { super(name); }
+
+    /**
+     * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. See [Collision layers and masks]($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+     */
+    get collisionMask(): number { return _C(this, 4205) as number; }
+    set collisionMask(v: number) { _C(this, 10894, v); }
+
+    /**
+     * The list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject3D.getRid} to get the {@link RID} associated with a {@link CollisionObject3D}-derived node.
+     * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+     */
+    get exclude(): GodotArray<RID> { return _C(this, 4693) as GodotArray<RID>; }
+    set exclude(v: GodotArray<RID>) { _C(this, 11309, v); }
+
+    /**
+     * The collision margin for the shape.
+     */
+    get margin(): number { return _C(this, 5441) as number; }
+    set margin(v: number) { _C(this, 11969, v); }
+
+    /**
+     * The motion of the shape being queried for.
+     */
+    get motion(): Vector3 { return _C(this, 5579) as Vector3; }
+    set motion(v: Vector3) { _C(this, 12086, v); }
+
+    /**
+     * The {@link Shape3D} that will be used for collision/intersection queries. This stores the actual reference which avoids the shape to be released while being used for queries, so always prefer using this over {@link shapeRid}.
+     */
+    get shape(): Resource { return _C(this, 6370) as Resource; }
+    set shape(v: Resource) { _C(this, 12717, v); }
+
+    /**
+     * The queried shape's {@link RID} that will be used for collision/intersection queries. Use this over {@link shape} if you want to optimize for performance using the Servers API:
+     *
+     *
+     * ```gdscript
+     *
+     * var shape_rid = PhysicsServer3D.sphere_shape_create()
+     * var radius = 2.0
+     * PhysicsServer3D.shape_set_data(shape_rid, radius)
+     *
+     * var params = PhysicsShapeQueryParameters3D.new()
+     * params.shape_rid = shape_rid
+     *
+     * # Execute physics queries here...
+     *
+     * # Release the shape when done with physics queries.
+     * PhysicsServer3D.free_rid(shape_rid)
+     *
+     * ```
+     */
+    get shapeRid(): RID { return _C(this, 6374) as RID; }
+    set shapeRid(v: RID) { _C(this, 12719, v); }
+
+    /**
+     * The queried shape's transform matrix.
+     */
+    get transform(): Transform3D { return _C(this, 6874) as Transform3D; }
+    set transform(v: Transform3D) { _C(this, 13134, v); }
+
+    /**
+     * If `true`, the query will take {@link PhysicsBody3D}s into account.
+     */
+    get collideWithBodies(): boolean { return _C(this, 7840) as boolean; }
+    set collideWithBodies(v: boolean) { _C(this, 10885, v); }
+
+    /**
+     * If `true`, the query will take {@link Area3D}s into account.
+     */
+    get collideWithAreas(): boolean { return _C(this, 7839) as boolean; }
+    set collideWithAreas(v: boolean) { _C(this, 10884, v); }
+
+    static readonly name = _R(582, PhysicsShapeQueryParameters3D);
+}

package/gen/classes/PhysicsTestMotionParameters2D.ts

@@ -0,0 +1,60 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { GodotArray, RID } from '../heap-types/index.ts';
+import type { Transform2D, Vector2 } from '../value-types/index.ts';
+
+/**
+ * By changing various properties of this object, such as the motion, you can configure the parameters for {@link PhysicsServer2D.bodyTestMotion}.
+ */
+export class PhysicsTestMotionParameters2D extends RefCounted {
+    constructor(name = 583) { super(name); }
+
+    /**
+     * Transform in global space where the motion should start. Usually set to {@link Node2D.globalTransform} for the current body's transform.
+     */
+    get from(): Transform2D { return _C(this, 4899) as Transform2D; }
+    set from(v: Transform2D) { _C(this, 11492, v); }
+
+    /**
+     * Motion vector to define the length and direction of the motion to test.
+     */
+    get motion(): Vector2 { return _C(this, 5579) as Vector2; }
+    set motion(v: Vector2) { _C(this, 12086, v); }
+
+    /**
+     * Increases the size of the shapes involved in the collision detection.
+     */
+    get margin(): number { return _C(this, 5441) as number; }
+    set margin(v: number) { _C(this, 11969, v); }
+
+    /**
+     * If set to `true`, shapes of type {@link PhysicsServer2D.SHAPE_SEPARATION_RAY} are used to detect collisions and can stop the motion. Can be useful when snapping to the ground.
+     * If set to `false`, shapes of type {@link PhysicsServer2D.SHAPE_SEPARATION_RAY} are only used for separation when overlapping with other bodies. That's the main use for separation ray shapes.
+     */
+    get collideSeparationRay(): boolean { return _C(this, 7838) as boolean; }
+    set collideSeparationRay(v: boolean) { _C(this, 10883, v); }
+
+    /**
+     * Optional array of body {@link RID} to exclude from collision. Use {@link CollisionObject2D.getRid} to get the {@link RID} associated with a {@link CollisionObject2D}-derived node.
+     */
+    get excludeBodies(): GodotArray<RID> { return _C(this, 4694) as GodotArray<RID>; }
+    set excludeBodies(v: GodotArray<RID>) { _C(this, 11310, v); }
+
+    /**
+     * Optional array of object unique instance ID to exclude from collision. See {@link Object.getInstanceId}.
+     */
+    get excludeObjects(): GodotArray<number> { return _C(this, 4698) as GodotArray<number>; }
+    set excludeObjects(v: GodotArray<number>) { _C(this, 11314, v); }
+
+    /**
+     * If set to `true`, any depenetration from the recovery phase is reported as a collision; this is used e.g. by {@link CharacterBody2D} for improving floor detection during floor snapping.
+     * If set to `false`, only collisions resulting from the motion are reported, which is generally the desired behavior.
+     */
+    get recoveryAsCollision(): boolean { return _C(this, 8232) as boolean; }
+    set recoveryAsCollision(v: boolean) { _C(this, 12488, v); }
+
+    static readonly name = _R(583, PhysicsTestMotionParameters2D);
+}

package/gen/classes/PhysicsTestMotionParameters3D.ts

@@ -0,0 +1,66 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { GodotArray, RID } from '../heap-types/index.ts';
+import type { Transform3D, Vector3 } from '../value-types/index.ts';
+
+/**
+ * By changing various properties of this object, such as the motion, you can configure the parameters for {@link PhysicsServer3D.bodyTestMotion}.
+ */
+export class PhysicsTestMotionParameters3D extends RefCounted {
+    constructor(name = 584) { super(name); }
+
+    /**
+     * Transform in global space where the motion should start. Usually set to {@link Node3D.globalTransform} for the current body's transform.
+     */
+    get from(): Transform3D { return _C(this, 4899) as Transform3D; }
+    set from(v: Transform3D) { _C(this, 11492, v); }
+
+    /**
+     * Motion vector to define the length and direction of the motion to test.
+     */
+    get motion(): Vector3 { return _C(this, 5579) as Vector3; }
+    set motion(v: Vector3) { _C(this, 12086, v); }
+
+    /**
+     * Increases the size of the shapes involved in the collision detection.
+     */
+    get margin(): number { return _C(this, 5441) as number; }
+    set margin(v: number) { _C(this, 11969, v); }
+
+    /**
+     * Maximum number of returned collisions, between `1` and `32`. Always returns the deepest detected collisions.
+     */
+    get maxCollisions(): number { return _C(this, 5460) as number; }
+    set maxCollisions(v: number) { _C(this, 11985, v); }
+
+    /**
+     * If set to `true`, shapes of type {@link PhysicsServer3D.SHAPE_SEPARATION_RAY} are used to detect collisions and can stop the motion. Can be useful when snapping to the ground.
+     * If set to `false`, shapes of type {@link PhysicsServer3D.SHAPE_SEPARATION_RAY} are only used for separation when overlapping with other bodies. That's the main use for separation ray shapes.
+     */
+    get collideSeparationRay(): boolean { return _C(this, 7838) as boolean; }
+    set collideSeparationRay(v: boolean) { _C(this, 10883, v); }
+
+    /**
+     * Optional array of body {@link RID} to exclude from collision. Use {@link CollisionObject3D.getRid} to get the {@link RID} associated with a {@link CollisionObject3D}-derived node.
+     */
+    get excludeBodies(): GodotArray<RID> { return _C(this, 4694) as GodotArray<RID>; }
+    set excludeBodies(v: GodotArray<RID>) { _C(this, 11310, v); }
+
+    /**
+     * Optional array of object unique instance ID to exclude from collision. See {@link Object.getInstanceId}.
+     */
+    get excludeObjects(): GodotArray<number> { return _C(this, 4698) as GodotArray<number>; }
+    set excludeObjects(v: GodotArray<number>) { _C(this, 11314, v); }
+
+    /**
+     * If set to `true`, any depenetration from the recovery phase is reported as a collision; this is used e.g. by {@link CharacterBody3D} for improving floor detection during floor snapping.
+     * If set to `false`, only collisions resulting from the motion are reported, which is generally the desired behavior.
+     */
+    get recoveryAsCollision(): boolean { return _C(this, 8232) as boolean; }
+    set recoveryAsCollision(v: boolean) { _C(this, 12488, v); }
+
+    static readonly name = _R(584, PhysicsTestMotionParameters3D);
+}

package/gen/classes/PhysicsTestMotionResult2D.ts

@@ -0,0 +1,82 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * Describes the motion and collision result from {@link PhysicsServer2D.bodyTestMotion}.
+ */
+export class PhysicsTestMotionResult2D extends RefCounted {
+    constructor(name = 585) { super(name); }
+
+    /**
+     * Returns the moving object's travel before collision.
+     */
+    getTravel(): Vector2 { return _C(this, 6901) as Vector2; }
+
+    /**
+     * Returns the moving object's remaining movement vector.
+     */
+    getRemainder(): Vector2 { return _C(this, 6123) as Vector2; }
+
+    /**
+     * Returns the point of collision in global coordinates, if a collision occurred.
+     */
+    getCollisionPoint(): Vector2 { return _C(this, 4210) as Vector2; }
+
+    /**
+     * Returns the colliding body's shape's normal at the point of collision, if a collision occurred.
+     */
+    getCollisionNormal(): Vector2 { return _C(this, 4208) as Vector2; }
+
+    /**
+     * Returns the colliding body's velocity, if a collision occurred.
+     */
+    getColliderVelocity(): Vector2 { return _C(this, 4193) as Vector2; }
+
+    /**
+     * Returns the unique instance ID of the colliding body's attached {@link Object}, if a collision occurred. See {@link Object.getInstanceId}.
+     */
+    getColliderId(): number { return _C(this, 4189) as number; }
+
+    /**
+     * Returns the colliding body's {@link RID} used by the {@link PhysicsServer2D}, if a collision occurred.
+     */
+    getColliderRid(): RID { return _C(this, 4190) as RID; }
+
+    /**
+     * Returns the colliding body's attached {@link Object}, if a collision occurred.
+     */
+    getCollider(): Object { return _C(this, 4188) as Object; }
+
+    /**
+     * Returns the colliding body's shape index, if a collision occurred. See {@link CollisionObject2D}.
+     */
+    getColliderShape(): number { return _C(this, 4191) as number; }
+
+    /**
+     * Returns the moving object's colliding shape, if a collision occurred.
+     */
+    getCollisionLocalShape(): number { return _C(this, 4204) as number; }
+
+    /**
+     * Returns the length of overlap along the collision normal, if a collision occurred.
+     */
+    getCollisionDepth(): number { return _C(this, 4198) as number; }
+
+    /**
+     * Returns the maximum fraction of the motion that can occur without a collision, between `0` and `1`.
+     */
+    getCollisionSafeFraction(): number { return _C(this, 4216) as number; }
+
+    /**
+     * Returns the minimum fraction of the motion needed to collide, if a collision occurred, between `0` and `1`.
+     */
+    getCollisionUnsafeFraction(): number { return _C(this, 4217) as number; }
+
+    static readonly name = _R(585, PhysicsTestMotionResult2D);
+}

package/gen/classes/PhysicsTestMotionResult3D.ts

@@ -0,0 +1,87 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * Describes the motion and collision result from {@link PhysicsServer3D.bodyTestMotion}.
+ */
+export class PhysicsTestMotionResult3D extends RefCounted {
+    constructor(name = 586) { super(name); }
+
+    /**
+     * Returns the moving object's travel before collision.
+     */
+    getTravel(): Vector3 { return _C(this, 6901) as Vector3; }
+
+    /**
+     * Returns the moving object's remaining movement vector.
+     */
+    getRemainder(): Vector3 { return _C(this, 6123) as Vector3; }
+
+    /**
+     * Returns the maximum fraction of the motion that can occur without a collision, between `0` and `1`.
+     */
+    getCollisionSafeFraction(): number { return _C(this, 4216) as number; }
+
+    /**
+     * Returns the minimum fraction of the motion needed to collide, if a collision occurred, between `0` and `1`.
+     */
+    getCollisionUnsafeFraction(): number { return _C(this, 4217) as number; }
+
+    /**
+     * Returns the number of detected collisions.
+     */
+    getCollisionCount(): number { return _C(this, 4197) as number; }
+
+    /**
+     * Returns the point of collision in global coordinates given a collision index (the deepest collision by default), if a collision occurred.
+     */
+    getCollisionPoint(collisionIndex?: number /* = 0 */): Vector3 { return _C(this, 4210, collisionIndex) as Vector3; }
+
+    /**
+     * Returns the colliding body's shape's normal at the point of collision given a collision index (the deepest collision by default), if a collision occurred.
+     */
+    getCollisionNormal(collisionIndex?: number /* = 0 */): Vector3 { return _C(this, 4208, collisionIndex) as Vector3; }
+
+    /**
+     * Returns the colliding body's velocity given a collision index (the deepest collision by default), if a collision occurred.
+     */
+    getColliderVelocity(collisionIndex?: number /* = 0 */): Vector3 { return _C(this, 4193, collisionIndex) as Vector3; }
+
+    /**
+     * Returns the unique instance ID of the colliding body's attached {@link Object} given a collision index (the deepest collision by default), if a collision occurred. See {@link Object.getInstanceId}.
+     */
+    getColliderId(collisionIndex?: number /* = 0 */): number { return _C(this, 4189, collisionIndex) as number; }
+
+    /**
+     * Returns the colliding body's {@link RID} used by the {@link PhysicsServer3D} given a collision index (the deepest collision by default), if a collision occurred.
+     */
+    getColliderRid(collisionIndex?: number /* = 0 */): RID { return _C(this, 4190, collisionIndex) as RID; }
+
+    /**
+     * Returns the colliding body's attached {@link Object} given a collision index (the deepest collision by default), if a collision occurred.
+     */
+    getCollider(collisionIndex?: number /* = 0 */): Object { return _C(this, 4188, collisionIndex) as Object; }
+
+    /**
+     * Returns the colliding body's shape index given a collision index (the deepest collision by default), if a collision occurred. See {@link CollisionObject3D}.
+     */
+    getColliderShape(collisionIndex?: number /* = 0 */): number { return _C(this, 4191, collisionIndex) as number; }
+
+    /**
+     * Returns the moving object's colliding shape given a collision index (the deepest collision by default), if a collision occurred.
+     */
+    getCollisionLocalShape(collisionIndex?: number /* = 0 */): number { return _C(this, 4204, collisionIndex) as number; }
+
+    /**
+     * Returns the length of overlap along the collision normal given a collision index (the deepest collision by default), if a collision occurred.
+     */
+    getCollisionDepth(collisionIndex?: number /* = 0 */): number { return _C(this, 4198, collisionIndex) as number; }
+
+    static readonly name = _R(586, PhysicsTestMotionResult3D);
+}

package/gen/classes/PinJoint2D.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 { Joint2D } from './Joint2D.ts';
+
+/**
+ * A physics joint that attaches two 2D physics bodies at a single point, allowing them to freely rotate. For example, a {@link RigidBody2D} can be attached to a {@link StaticBody2D} to create a pendulum or a seesaw.
+ */
+export class PinJoint2D extends Joint2D {
+    constructor(name = 587) { super(name); }
+
+    /**
+     * The higher this value, the more the bond to the pinned partner can flex.
+     */
+    get softness(): number { return _C(this, 6450) as number; }
+    set softness(v: number) { _C(this, 12807, v); }
+
+    /**
+     * If `true`, the pin maximum and minimum rotation, defined by {@link angularLimitLower} and {@link angularLimitUpper} are applied.
+     */
+    get angularLimitEnabled(): boolean { return _C(this, 7758) as boolean; }
+    set angularLimitEnabled(v: boolean) { _C(this, 10497, v); }
+
+    /**
+     * The minimum rotation. Only active if {@link angularLimitEnabled} is `true`.
+     */
+    get angularLimitLower(): number { return _C(this, 3755) as number; }
+    set angularLimitLower(v: number) { _C(this, 10498, v); }
+
+    /**
+     * The maximum rotation. Only active if {@link angularLimitEnabled} is `true`.
+     */
+    get angularLimitUpper(): number { return _C(this, 3756) as number; }
+    set angularLimitUpper(v: number) { _C(this, 10499, v); }
+
+    /**
+     * When activated, a motor turns the pin.
+     */
+    get motorEnabled(): boolean { return _C(this, 8115) as boolean; }
+    set motorEnabled(v: boolean) { _C(this, 12091, v); }
+
+    /**
+     * Target speed for the motor. In radians per second.
+     */
+    get motorTargetVelocity(): number { return _C(this, 5584) as number; }
+    set motorTargetVelocity(v: number) { _C(this, 12092, v); }
+
+    static readonly name = _R(587, PinJoint2D);
+}

package/gen/classes/PinJoint3D.ts

@@ -0,0 +1,42 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Joint3D } from './Joint3D.ts';
+
+/**
+ * A physics joint that attaches two 3D physics bodies at a single point, allowing them to freely rotate. For example, a {@link RigidBody3D} can be attached to a {@link StaticBody3D} to create a pendulum or a seesaw.
+ */
+export class PinJoint3D extends Joint3D {
+    constructor(name = 588) { super(name); }
+
+    /**
+     * Sets the value of the specified parameter.
+     */
+    setParam(param: Param, value: number): void { _C(this, 12248, param, value); }
+
+    /**
+     * Returns the value of the specified parameter.
+     */
+    getParam(param: Param): number { return _C(this, 5809, param) as number; }
+
+    static readonly name = _R(588, PinJoint3D);
+}
+
+export const Param = {
+    /**
+     * The force with which the pinned objects stay in positional relation to each other. The higher, the stronger.
+     */
+    PARAM_BIAS: 0,
+    /**
+     * The force with which the pinned objects stay in velocity relation to each other. The higher, the stronger.
+     */
+    PARAM_DAMPING: 1,
+    /**
+     * If above 0, this value is the maximum value for an impulse that this Joint3D produces.
+     */
+    PARAM_IMPULSE_CLAMP: 2,
+} as const;
+
+export type Param = (typeof Param)[keyof typeof Param];
+

package/gen/classes/PlaceholderCubemap.ts

@@ -0,0 +1,17 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PlaceholderTextureLayered } from './PlaceholderTextureLayered.ts';
+
+/**
+ * This class replaces a {@link Cubemap} or a {@link Cubemap}-derived class in 2 conditions:
+ * - In dedicated server mode, where the image data shouldn't affect game logic. This allows reducing the exported PCK's size significantly.
+ * - When the {@link Cubemap}-derived class is missing, for example when using a different engine version.
+ * **Note:** This class is not intended for rendering or for use in shaders. Operations like calculating UV are not guaranteed to work.
+ */
+export class PlaceholderCubemap extends PlaceholderTextureLayered {
+    constructor(name = 589) { super(name); }
+
+    static readonly name = _R(589, PlaceholderCubemap);
+}