@ringozz/godot 0.1.0

package/gen/classes/SkeletonIK3D.ts

@@ -0,0 +1,119 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModifier3D } from './SkeletonModifier3D.ts';
+import type { NodePath, StringName } from '../heap-types/index.ts';
+import type { Transform3D, Vector3 } from '../value-types/index.ts';
+import type { Skeleton3D } from './Skeleton3D.ts';
+
+/**
+ * SkeletonIK3D is used to rotate all bones of a {@link Skeleton3D} bone chain a way that places the end bone at a desired 3D position. A typical scenario for IK in games is to place a character's feet on the ground or a character's hands on a currently held object. SkeletonIK uses FabrikInverseKinematic internally to solve the bone chain and applies the results to the {@link Skeleton3D} `bones_global_pose_override` property for all affected bones in the chain. If fully applied, this overwrites any bone transform from {@link Animation}s or bone custom poses set by users. The applied amount can be controlled with the {@link SkeletonModifier3D.influence} property.
+ *
+ * ```text
+ *
+ * # Apply IK effect automatically on every new frame (not the current)
+ * skeleton_ik_node.start()
+ *
+ * # Apply IK effect only on the current frame
+ * skeleton_ik_node.start(true)
+ *
+ * # Stop IK effect and reset bones_global_pose_override on Skeleton
+ * skeleton_ik_node.stop()
+ *
+ * # Apply full IK effect
+ * skeleton_ik_node.set_influence(1.0)
+ *
+ * # Apply half IK effect
+ * skeleton_ik_node.set_influence(0.5)
+ *
+ * # Apply zero IK effect (a value at or below 0.01 also removes bones_global_pose_override on Skeleton)
+ * skeleton_ik_node.set_influence(0.0)
+ *
+ * ```
+ */
+export class SkeletonIK3D extends SkeletonModifier3D {
+    constructor(name = 703) { super(name); }
+
+    /**
+     * Returns the parent {@link Skeleton3D} node that was present when SkeletonIK entered the scene tree. Returns `null` if the parent node was not a {@link Skeleton3D} node when SkeletonIK3D entered the scene tree.
+     */
+    getParentSkeleton(): Skeleton3D | null { return _C(this, 5825) as Skeleton3D | null; }
+
+    /**
+     * Returns `true` if SkeletonIK is applying IK effects on continues frames to the {@link Skeleton3D} bones. Returns `false` if SkeletonIK is stopped or {@link start} was used with the `one_time` parameter set to `true`.
+     */
+    isRunning(): boolean { return _C(this, 8258) as boolean; }
+
+    /**
+     * Starts applying IK effects on each frame to the {@link Skeleton3D} bones but will only take effect starting on the next frame. If `oneTime` is `true`, this will take effect immediately but also reset on the next frame.
+     */
+    start(oneTime?: boolean /* = false */): void { _C(this, 13829, oneTime); }
+
+    /**
+     * Stops applying IK effects on each frame to the {@link Skeleton3D} bones and also calls {@link Skeleton3D.clearBonesGlobalPoseOverride} to remove existing overrides on all bones.
+     */
+    stop(): void { _C(this, 13866); }
+
+    /**
+     * The name of the current root bone, the first bone in the IK chain.
+     */
+    get rootBone(): StringName { return _C(this, 6189) as StringName; }
+    set rootBone(v: StringName) { _C(this, 12566, v); }
+
+    /**
+     * The name of the current tip bone, the last bone in the IK chain placed at the {@link target} transform (or {@link targetNode} if defined).
+     */
+    get tipBone(): StringName { return _C(this, 6826) as StringName; }
+    set tipBone(v: StringName) { _C(this, 13096, v); }
+
+    /**
+     * First target of the IK chain where the tip bone is placed and, if {@link overrideTipBasis} is `true`, how the tip bone is rotated. If a {@link targetNode} path is available the nodes transform is used instead and this property is ignored.
+     */
+    get target(): Transform3D { return _C(this, 6704) as Transform3D; }
+    set target(v: Transform3D) { _C(this, 13009, v); }
+
+    /**
+     * If `true` overwrites the rotation of the tip bone with the rotation of the {@link target} (or {@link targetNode} if defined).
+     */
+    get overrideTipBasis(): boolean { return _C(this, 8160) as boolean; }
+    set overrideTipBasis(v: boolean) { _C(this, 12227, v); }
+
+    /**
+     * If `true`, instructs the IK solver to consider the secondary magnet target (pole target) when calculating the bone chain. Use the magnet position (pole target) to control the bending of the IK chain.
+     */
+    get useMagnet(): boolean { return _C(this, 8409) as boolean; }
+    set useMagnet(v: boolean) { _C(this, 13225, v); }
+
+    /**
+     * Secondary target position (first is {@link target} property or {@link targetNode}) for the IK chain. Use magnet position (pole target) to control the bending of the IK chain. Only works if the bone chain has more than 2 bones. The middle chain bone position will be linearly interpolated with the magnet position.
+     */
+    get magnet(): Vector3 { return _C(this, 5429) as Vector3; }
+    set magnet(v: Vector3) { _C(this, 11961, v); }
+
+    /**
+     * Target node {@link NodePath} for the IK chain. If available, the node's current {@link Transform3D} is used instead of the {@link target} property.
+     */
+    get targetNode(): NodePath { return _C(this, 6701) as NodePath; }
+    set targetNode(v: NodePath) { _C(this, 13005, v); }
+
+    /**
+     * The minimum distance between bone and goal target. If the distance is below this value, the IK solver stops further iterations.
+     */
+    get minDistance(): number { return _C(this, 5538) as number; }
+    set minDistance(v: number) { _C(this, 12049, v); }
+
+    /**
+     * Number of iteration loops used by the IK solver to produce more accurate (and elegant) bone chain results.
+     */
+    get maxIterations(): number { return _C(this, 5471) as number; }
+    set maxIterations(v: number) { _C(this, 11995, v); }
+
+    /**
+     * Interpolation value for how much the IK results are applied to the current skeleton bone chain. A value of `1.0` will overwrite all skeleton bone transforms completely while a value of `0.0` will visually disable the SkeletonIK.
+     */
+    get interpolation(): number { return _C(this, 5154) as number; }
+    set interpolation(v: number) { _C(this, 11742, v); }
+
+    static readonly name = _R(703, SkeletonIK3D);
+}

package/gen/classes/SkeletonModification2D.ts

@@ -0,0 +1,58 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { SkeletonModificationStack2D } from './SkeletonModificationStack2D.ts';
+
+/**
+ * This resource provides an interface that can be expanded so code that operates on {@link Bone2D} nodes in a {@link Skeleton2D} can be mixed and matched together to create complex interactions.
+ * This is used to provide Godot with a flexible and powerful Inverse Kinematics solution that can be adapted for many different uses.
+ */
+export class SkeletonModification2D extends Resource {
+    constructor(name = 704) { super(name); }
+
+    /**
+     * Returns the {@link SkeletonModificationStack2D} that this modification is bound to. Through the modification stack, you can access the Skeleton2D the modification is operating on.
+     */
+    getModificationStack(): SkeletonModificationStack2D { return _C(this, 5572) as SkeletonModificationStack2D; }
+
+    /**
+     * Manually allows you to set the setup state of the modification. This function should only rarely be used, as the {@link SkeletonModificationStack2D} the modification is bound to should handle setting the modification up.
+     */
+    setIsSetup(isSetup: boolean): void { _C(this, 11755, isSetup); }
+
+    /**
+     * Returns whether this modification has been successfully setup or not.
+     */
+    getIsSetup(): boolean { return _C(this, 5173) as boolean; }
+
+    /**
+     * Takes an angle and clamps it so it is within the passed-in `min` and `max` range. `invert` will inversely clamp the angle, clamping it to the range outside of the given bounds.
+     */
+    clampAngle(angle: number, min: number, max: number, invert: boolean): number { return _C(this, 2203, angle, min, max, invert) as number; }
+
+    /**
+     * Sets whether this modification will call {@link _drawEditorGizmo} in the Godot editor to draw modification-specific gizmos.
+     */
+    setEditorDrawGizmo(drawGizmo: boolean): void { _C(this, 11220, drawGizmo); }
+
+    /**
+     * Returns whether this modification will call {@link _drawEditorGizmo} in the Godot editor to draw modification-specific gizmos.
+     */
+    getEditorDrawGizmo(): boolean { return _C(this, 4604) as boolean; }
+
+    /**
+     * If `true`, the modification's {@link _execute} function will be called by the {@link SkeletonModificationStack2D}.
+     */
+    get enabled(): boolean { return _C(this, 4656) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * The execution mode for the modification. This tells the modification stack when to execute the modification. Some modifications have settings that are only available in certain execution modes.
+     */
+    get executionMode(): number { return _C(this, 4703) as number; }
+    set executionMode(v: number) { _C(this, 11318, v); }
+
+    static readonly name = _R(704, SkeletonModification2D);
+}

package/gen/classes/SkeletonModification2DCCDIK.ts

@@ -0,0 +1,107 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModification2D } from './SkeletonModification2D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+
+/**
+ * This {@link SkeletonModification2D} uses an algorithm called Cyclic Coordinate Descent Inverse Kinematics, or CCDIK, to manipulate a chain of bones in a {@link Skeleton2D} so it reaches a defined target.
+ * CCDIK works by rotating a set of bones, typically called a "bone chain", on a single axis. Each bone is rotated to face the target from the tip (by default), which over a chain of bones allow it to rotate properly to reach the target. Because the bones only rotate on a single axis, CCDIK *can* look more robotic than other IK solvers.
+ * **Note:** The CCDIK modifier has `ccdik_joints`, which are the data objects that hold the data for each joint in the CCDIK chain. This is different from a bone! CCDIK joints hold the data needed for each bone in the bone chain used by CCDIK.
+ * CCDIK also fully supports angle constraints, allowing for more control over how a solution is met.
+ */
+export class SkeletonModification2DCCDIK extends SkeletonModification2D {
+    constructor(name = 705) { super(name); }
+
+    /**
+     * Sets the {@link Bone2D} node assigned to the CCDIK joint at `jointIdx`.
+     */
+    setCcdikJointBone2dNode(jointIdx: number, bone2dNodepath: NodePath): void { _C(this, 10812, jointIdx, bone2dNodepath); }
+
+    /**
+     * Returns the {@link Bone2D} node assigned to the CCDIK joint at `jointIdx`.
+     */
+    getCcdikJointBone2dNode(jointIdx: number): NodePath { return _C(this, 4098, jointIdx) as NodePath; }
+
+    /**
+     * Sets the bone index, `boneIdx`, of the CCDIK joint at `jointIdx`. When possible, this will also update the `bone2d_node` of the CCDIK joint based on data provided by the linked skeleton.
+     */
+    setCcdikJointBoneIndex(jointIdx: number, boneIdx: number): void { _C(this, 10813, jointIdx, boneIdx); }
+
+    /**
+     * Returns the index of the {@link Bone2D} node assigned to the CCDIK joint at `jointIdx`.
+     */
+    getCcdikJointBoneIndex(jointIdx: number): number { return _C(this, 4099, jointIdx) as number; }
+
+    /**
+     * Sets whether the joint at `jointIdx` is set to rotate from the joint, `true`, or to rotate from the tip, `false`.
+     */
+    setCcdikJointRotateFromJoint(jointIdx: number, rotateFromJoint: boolean): void { _C(this, 10818, jointIdx, rotateFromJoint); }
+
+    /**
+     * Returns whether the joint at `jointIdx` is set to rotate from the joint, `true`, or to rotate from the tip, `false`. The default is to rotate from the tip.
+     */
+    getCcdikJointRotateFromJoint(jointIdx: number): boolean { return _C(this, 4104, jointIdx) as boolean; }
+
+    /**
+     * Determines whether angle constraints on the CCDIK joint at `jointIdx` are enabled. When `true`, constraints will be enabled and taken into account when solving.
+     */
+    setCcdikJointEnableConstraint(jointIdx: number, enableConstraint: boolean): void { _C(this, 10817, jointIdx, enableConstraint); }
+
+    /**
+     * Returns whether angle constraints on the CCDIK joint at `jointIdx` are enabled.
+     */
+    getCcdikJointEnableConstraint(jointIdx: number): boolean { return _C(this, 4103, jointIdx) as boolean; }
+
+    /**
+     * Sets the minimum angle constraint for the joint at `jointIdx`.
+     */
+    setCcdikJointConstraintAngleMin(jointIdx: number, angleMin: number): void { _C(this, 10816, jointIdx, angleMin); }
+
+    /**
+     * Returns the minimum angle constraint for the joint at `jointIdx`.
+     */
+    getCcdikJointConstraintAngleMin(jointIdx: number): number { return _C(this, 4102, jointIdx) as number; }
+
+    /**
+     * Sets the maximum angle constraint for the joint at `jointIdx`.
+     */
+    setCcdikJointConstraintAngleMax(jointIdx: number, angleMax: number): void { _C(this, 10815, jointIdx, angleMax); }
+
+    /**
+     * Returns the maximum angle constraint for the joint at `jointIdx`.
+     */
+    getCcdikJointConstraintAngleMax(jointIdx: number): number { return _C(this, 4101, jointIdx) as number; }
+
+    /**
+     * Sets whether the CCDIK joint at `jointIdx` uses an inverted joint constraint.
+     * An inverted joint constraint only constraints the CCDIK joint to the angles *outside of* the inputted minimum and maximum angles. For this reason, it is referred to as an inverted joint constraint, as it constraints the joint to the outside of the inputted values.
+     */
+    setCcdikJointConstraintAngleInvert(jointIdx: number, invert: boolean): void { _C(this, 10814, jointIdx, invert); }
+
+    /**
+     * Returns whether the CCDIK joint at `jointIdx` uses an inverted joint constraint. See {@link setCcdikJointConstraintAngleInvert} for details.
+     */
+    getCcdikJointConstraintAngleInvert(jointIdx: number): boolean { return _C(this, 4100, jointIdx) as boolean; }
+
+    /**
+     * The NodePath to the node that is the target for the CCDIK modification. This node is what the CCDIK chain will attempt to rotate the bone chain to.
+     */
+    get targetNodepath(): NodePath { return _C(this, 6701) as NodePath; }
+    set targetNodepath(v: NodePath) { _C(this, 13005, v); }
+
+    /**
+     * The end position of the CCDIK chain. Typically, this should be a child of a {@link Bone2D} node attached to the final {@link Bone2D} in the CCDIK chain.
+     */
+    get tipNodepath(): NodePath { return _C(this, 6827) as NodePath; }
+    set tipNodepath(v: NodePath) { _C(this, 13097, v); }
+
+    /**
+     * The number of CCDIK joints in the CCDIK modification.
+     */
+    get ccdikDataChainLength(): number { return _C(this, 4097) as number; }
+    set ccdikDataChainLength(v: number) { _C(this, 10811, v); }
+
+    static readonly name = _R(705, SkeletonModification2DCCDIK);
+}

package/gen/classes/SkeletonModification2DFABRIK.ts

@@ -0,0 +1,73 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModification2D } from './SkeletonModification2D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * This {@link SkeletonModification2D} uses an algorithm called Forward And Backward Reaching Inverse Kinematics, or FABRIK, to rotate a bone chain so that it reaches a target.
+ * FABRIK works by knowing the positions and lengths of a series of bones, typically called a "bone chain". It first starts by running a forward pass, which places the final bone at the target's position. Then all other bones are moved towards the tip bone, so they stay at the defined bone length away. Then a backwards pass is performed, where the root/first bone in the FABRIK chain is placed back at the origin. Then all other bones are moved so they stay at the defined bone length away. This positions the bone chain so that it reaches the target when possible, but all of the bones stay the correct length away from each other.
+ * Because of how FABRIK works, it often gives more natural results than those seen in {@link SkeletonModification2DCCDIK}.
+ * **Note:** The FABRIK modifier has `fabrik_joints`, which are the data objects that hold the data for each joint in the FABRIK chain. This is different from {@link Bone2D} nodes! FABRIK joints hold the data needed for each {@link Bone2D} in the bone chain used by FABRIK.
+ * To help control how the FABRIK joints move, a magnet vector can be passed, which can nudge the bones in a certain direction prior to solving, giving a level of control over the final result.
+ */
+export class SkeletonModification2DFABRIK extends SkeletonModification2D {
+    constructor(name = 706) { super(name); }
+
+    /**
+     * Sets the {@link Bone2D} node assigned to the FABRIK joint at `jointIdx`.
+     */
+    setFabrikJointBone2dNode(jointIdx: number, bone2dNodepath: NodePath): void { _C(this, 11345, jointIdx, bone2dNodepath); }
+
+    /**
+     * Returns the {@link Bone2D} node assigned to the FABRIK joint at `jointIdx`.
+     */
+    getFabrikJointBone2dNode(jointIdx: number): NodePath { return _C(this, 4725, jointIdx) as NodePath; }
+
+    /**
+     * Sets the bone index, `boneIdx`, of the FABRIK joint at `jointIdx`. When possible, this will also update the `bone2d_node` of the FABRIK joint based on data provided by the linked skeleton.
+     */
+    setFabrikJointBoneIndex(jointIdx: number, boneIdx: number): void { _C(this, 11346, jointIdx, boneIdx); }
+
+    /**
+     * Returns the index of the {@link Bone2D} node assigned to the FABRIK joint at `jointIdx`.
+     */
+    getFabrikJointBoneIndex(jointIdx: number): number { return _C(this, 4726, jointIdx) as number; }
+
+    /**
+     * Sets the magnet position vector for the joint at `jointIdx`.
+     */
+    setFabrikJointMagnetPosition(jointIdx: number, magnetPosition: Vector2): void { _C(this, 11347, jointIdx, magnetPosition); }
+
+    /**
+     * Returns the magnet position vector for the joint at `jointIdx`.
+     */
+    getFabrikJointMagnetPosition(jointIdx: number): Vector2 { return _C(this, 4727, jointIdx) as Vector2; }
+
+    /**
+     * Sets whether the joint at `jointIdx` will use the target node's rotation rather than letting FABRIK rotate the node.
+     * **Note:** This option only works for the tip/final joint in the chain. For all other nodes, this option will be ignored.
+     */
+    setFabrikJointUseTargetRotation(jointIdx: number, useTargetRotation: boolean): void { _C(this, 11348, jointIdx, useTargetRotation); }
+
+    /**
+     * Returns whether the joint is using the target's rotation rather than allowing FABRIK to rotate the joint. This option only applies to the tip/final joint in the chain.
+     */
+    getFabrikJointUseTargetRotation(jointIdx: number): boolean { return _C(this, 4728, jointIdx) as boolean; }
+
+    /**
+     * The NodePath to the node that is the target for the FABRIK modification. This node is what the FABRIK chain will attempt to rotate the bone chain to.
+     */
+    get targetNodepath(): NodePath { return _C(this, 6701) as NodePath; }
+    set targetNodepath(v: NodePath) { _C(this, 13005, v); }
+
+    /**
+     * The number of FABRIK joints in the FABRIK modification.
+     */
+    get fabrikDataChainLength(): number { return _C(this, 4724) as number; }
+    set fabrikDataChainLength(v: number) { _C(this, 11344, v); }
+
+    static readonly name = _R(706, SkeletonModification2DFABRIK);
+}

package/gen/classes/SkeletonModification2DJiggle.ts

@@ -0,0 +1,165 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModification2D } from './SkeletonModification2D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * This modification moves a series of bones, typically called a bone chain, towards a target. What makes this modification special is that it calculates the velocity and acceleration for each bone in the bone chain, and runs a very light physics-like calculation using the inputted values. This allows the bones to overshoot the target and "jiggle" around. It can be configured to act more like a spring, or sway around like cloth might.
+ * This modification is useful for adding additional motion to things like hair, the edges of clothing, and more. It has several settings to that allow control over how the joint moves when the target moves.
+ * **Note:** The Jiggle modifier has `jiggle_joints`, which are the data objects that hold the data for each joint in the Jiggle chain. This is different from than {@link Bone2D} nodes! Jiggle joints hold the data needed for each {@link Bone2D} in the bone chain used by the Jiggle modification.
+ */
+export class SkeletonModification2DJiggle extends SkeletonModification2D {
+    constructor(name = 707) { super(name); }
+
+    /**
+     * If `true`, the Jiggle modifier will take colliders into account, keeping them from entering into these collision objects.
+     */
+    setUseColliders(useColliders: boolean): void { _C(this, 13200, useColliders); }
+
+    /**
+     * Returns whether the jiggle modifier is taking physics colliders into account when solving.
+     */
+    getUseColliders(): boolean { return _C(this, 6973) as boolean; }
+
+    /**
+     * Sets the collision mask that the Jiggle modifier will use when reacting to colliders, if the Jiggle modifier is set to take colliders into account.
+     */
+    setCollisionMask(collisionMask: number): void { _C(this, 10894, collisionMask); }
+
+    /**
+     * Returns the collision mask used by the Jiggle modifier when collisions are enabled.
+     */
+    getCollisionMask(): number { return _C(this, 4205) as number; }
+
+    /**
+     * Resets the internal jiggle simulation state to the current bone positions, clearing velocity, acceleration, and accumulated forces.
+     */
+    reset(): void { _C(this, 10064); }
+
+    /**
+     * Sets the {@link Bone2D} node assigned to the Jiggle joint at `jointIdx`.
+     */
+    setJiggleJointBone2dNode(jointIdx: number, bone2dNode: NodePath): void { _C(this, 11811, jointIdx, bone2dNode); }
+
+    /**
+     * Returns the {@link Bone2D} node assigned to the Jiggle joint at `jointIdx`.
+     */
+    getJiggleJointBone2dNode(jointIdx: number): NodePath { return _C(this, 5225, jointIdx) as NodePath; }
+
+    /**
+     * Sets the bone index, `boneIdx`, of the Jiggle joint at `jointIdx`. When possible, this will also update the `bone2d_node` of the Jiggle joint based on data provided by the linked skeleton.
+     */
+    setJiggleJointBoneIndex(jointIdx: number, boneIdx: number): void { _C(this, 11812, jointIdx, boneIdx); }
+
+    /**
+     * Returns the index of the {@link Bone2D} node assigned to the Jiggle joint at `jointIdx`.
+     */
+    getJiggleJointBoneIndex(jointIdx: number): number { return _C(this, 5226, jointIdx) as number; }
+
+    /**
+     * Sets whether the Jiggle joint at `jointIdx` should override the default Jiggle joint settings. Setting this to `true` will make the joint use its own settings rather than the default ones attached to the modification.
+     */
+    setJiggleJointOverride(jointIdx: number, override: boolean): void { _C(this, 11816, jointIdx, override); }
+
+    /**
+     * Returns a boolean that indicates whether the joint at `jointIdx` is overriding the default Jiggle joint data defined in the modification.
+     */
+    getJiggleJointOverride(jointIdx: number): boolean { return _C(this, 5230, jointIdx) as boolean; }
+
+    /**
+     * Sets the of stiffness of the Jiggle joint at `jointIdx`.
+     */
+    setJiggleJointStiffness(jointIdx: number, stiffness: number): void { _C(this, 11817, jointIdx, stiffness); }
+
+    /**
+     * Returns the stiffness of the Jiggle joint at `jointIdx`.
+     */
+    getJiggleJointStiffness(jointIdx: number): number { return _C(this, 5231, jointIdx) as number; }
+
+    /**
+     * Sets the of mass of the Jiggle joint at `jointIdx`.
+     */
+    setJiggleJointMass(jointIdx: number, mass: number): void { _C(this, 11815, jointIdx, mass); }
+
+    /**
+     * Returns the amount of mass of the jiggle joint at `jointIdx`.
+     */
+    getJiggleJointMass(jointIdx: number): number { return _C(this, 5229, jointIdx) as number; }
+
+    /**
+     * Sets the amount of damping of the Jiggle joint at `jointIdx`.
+     */
+    setJiggleJointDamping(jointIdx: number, damping: number): void { _C(this, 11813, jointIdx, damping); }
+
+    /**
+     * Returns the amount of damping of the Jiggle joint at `jointIdx`.
+     */
+    getJiggleJointDamping(jointIdx: number): number { return _C(this, 5227, jointIdx) as number; }
+
+    /**
+     * Sets whether the Jiggle joint at `jointIdx` should use gravity.
+     */
+    setJiggleJointUseGravity(jointIdx: number, useGravity: boolean): void { _C(this, 11818, jointIdx, useGravity); }
+
+    /**
+     * Returns a boolean that indicates whether the joint at `jointIdx` is using gravity or not.
+     */
+    getJiggleJointUseGravity(jointIdx: number): boolean { return _C(this, 5232, jointIdx) as boolean; }
+
+    /**
+     * Sets the gravity vector of the Jiggle joint at `jointIdx`.
+     */
+    setJiggleJointGravity(jointIdx: number, gravity: Vector2): void { _C(this, 11814, jointIdx, gravity); }
+
+    /**
+     * Returns a {@link Vector2} representing the amount of gravity the Jiggle joint at `jointIdx` is influenced by.
+     */
+    getJiggleJointGravity(jointIdx: number): Vector2 { return _C(this, 5228, jointIdx) as Vector2; }
+
+    /**
+     * The NodePath to the node that is the target for the Jiggle modification. This node is what the Jiggle chain will attempt to rotate the bone chain to.
+     */
+    get targetNodepath(): NodePath { return _C(this, 6701) as NodePath; }
+    set targetNodepath(v: NodePath) { _C(this, 13005, v); }
+
+    /**
+     * The amount of Jiggle joints in the Jiggle modification.
+     */
+    get jiggleDataChainLength(): number { return _C(this, 5224) as number; }
+    set jiggleDataChainLength(v: number) { _C(this, 11810, v); }
+
+    /**
+     * The default amount of stiffness assigned to the Jiggle joints, if they are not overridden. Higher values act more like springs, quickly moving into the correct position.
+     */
+    get stiffness(): number { return _C(this, 6554) as number; }
+    set stiffness(v: number) { _C(this, 12893, v); }
+
+    /**
+     * The default amount of mass assigned to the Jiggle joints, if they are not overridden. Higher values lead to faster movements and more overshooting.
+     */
+    get mass(): number { return _C(this, 5451) as number; }
+    set mass(v: number) { _C(this, 11977, v); }
+
+    /**
+     * The default amount of damping applied to the Jiggle joints, if they are not overridden. Higher values lead to more of the calculated velocity being applied.
+     */
+    get damping(): number { return _C(this, 4405) as number; }
+    set damping(v: number) { _C(this, 11029, v); }
+
+    /**
+     * Whether the gravity vector, {@link gravity}, should be applied to the Jiggle joints, assuming they are not overriding the default settings.
+     */
+    get useGravity(): boolean { return _C(this, 6979) as boolean; }
+    set useGravity(v: boolean) { _C(this, 13219, v); }
+
+    /**
+     * The default amount of gravity applied to the Jiggle joints, if they are not overridden.
+     */
+    get gravity(): Vector2 { return _C(this, 4971) as Vector2; }
+    set gravity(v: Vector2) { _C(this, 11553, v); }
+
+    static readonly name = _R(707, SkeletonModification2DJiggle);
+}

package/gen/classes/SkeletonModification2DLookAt.ts

@@ -0,0 +1,84 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModification2D } from './SkeletonModification2D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+
+/**
+ * This {@link SkeletonModification2D} rotates a bone to look a target. This is extremely helpful for moving character's head to look at the player, rotating a turret to look at a target, or any other case where you want to make a bone rotate towards something quickly and easily.
+ */
+export class SkeletonModification2DLookAt extends SkeletonModification2D {
+    constructor(name = 708) { super(name); }
+
+    /**
+     * Sets the amount of additional rotation that is to be applied after executing the modification. This allows for offsetting the results by the inputted rotation amount.
+     */
+    setAdditionalRotation(rotation: number): void { _C(this, 10429, rotation); }
+
+    /**
+     * Returns the amount of additional rotation that is applied after the LookAt modification executes.
+     */
+    getAdditionalRotation(): number { return _C(this, 3695) as number; }
+
+    /**
+     * Sets whether this modification will use constraints or not. When `true`, constraints will be applied when solving the LookAt modification.
+     */
+    setEnableConstraint(enableConstraint: boolean): void { _C(this, 11268, enableConstraint); }
+
+    /**
+     * Returns `true` if the LookAt modification is using constraints.
+     */
+    getEnableConstraint(): boolean { return _C(this, 4643) as boolean; }
+
+    /**
+     * Sets the constraint's minimum allowed angle.
+     */
+    setConstraintAngleMin(angleMin: number): void { _C(this, 10950, angleMin); }
+
+    /**
+     * Returns the constraint's minimum allowed angle.
+     */
+    getConstraintAngleMin(): number { return _C(this, 4293) as number; }
+
+    /**
+     * Sets the constraint's maximum allowed angle.
+     */
+    setConstraintAngleMax(angleMax: number): void { _C(this, 10949, angleMax); }
+
+    /**
+     * Returns the constraint's maximum allowed angle.
+     */
+    getConstraintAngleMax(): number { return _C(this, 4292) as number; }
+
+    /**
+     * When `true`, the modification will use an inverted joint constraint.
+     * An inverted joint constraint only constraints the {@link Bone2D} to the angles *outside of* the inputted minimum and maximum angles. For this reason, it is referred to as an inverted joint constraint, as it constraints the joint to the outside of the inputted values.
+     */
+    setConstraintAngleInvert(invert: boolean): void { _C(this, 10948, invert); }
+
+    /**
+     * Returns whether the constraints to this modification are inverted or not.
+     */
+    getConstraintAngleInvert(): boolean { return _C(this, 4291) as boolean; }
+
+    /**
+     * The index of the {@link Bone2D} node that the modification will operate on.
+     */
+    get boneIndex(): number { return _C(this, 3968) as number; }
+    set boneIndex(v: number) { _C(this, 10707, v); }
+
+    /**
+     * The {@link Bone2D} node that the modification will operate on.
+     */
+    get bone2dNode(): NodePath { return _C(this, 3955) as NodePath; }
+    set bone2dNode(v: NodePath) { _C(this, 10700, v); }
+
+    /**
+     * The NodePath to the node that is the target for the LookAt modification. This node is what the modification will rotate the {@link Bone2D} to.
+     */
+    get targetNodepath(): NodePath { return _C(this, 6701) as NodePath; }
+    set targetNodepath(v: NodePath) { _C(this, 13005, v); }
+
+    static readonly name = _R(708, SkeletonModification2DLookAt);
+}

package/gen/classes/SkeletonModification2DPhysicalBones.ts

@@ -0,0 +1,49 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModification2D } from './SkeletonModification2D.ts';
+import type { GodotArray, NodePath, StringName } from '../heap-types/index.ts';
+
+/**
+ * This modification takes the transforms of {@link PhysicalBone2D} nodes and applies them to {@link Bone2D} nodes. This allows the {@link Bone2D} nodes to react to physics thanks to the linked {@link PhysicalBone2D} nodes.
+ */
+export class SkeletonModification2DPhysicalBones extends SkeletonModification2D {
+    constructor(name = 709) { super(name); }
+
+    /**
+     * Sets the {@link PhysicalBone2D} node at `jointIdx`.
+     * **Note:** This is just the index used for this modification, not the bone index used in the {@link Skeleton2D}.
+     */
+    setPhysicalBoneNode(jointIdx: number, physicalbone2dNode: NodePath): void { _C(this, 12306, jointIdx, physicalbone2dNode); }
+
+    /**
+     * Returns the {@link PhysicalBone2D} node at `jointIdx`.
+     */
+    getPhysicalBoneNode(jointIdx: number): NodePath { return _C(this, 5883, jointIdx) as NodePath; }
+
+    /**
+     * Empties the list of {@link PhysicalBone2D} nodes and populates it with all {@link PhysicalBone2D} nodes that are children of the {@link Skeleton2D}.
+     */
+    fetchPhysicalBones(): void { _C(this, 3243); }
+
+    /**
+     * Tell the {@link PhysicalBone2D} nodes to start simulating and interacting with the physics world.
+     * Optionally, an array of bone names can be passed to this function, and that will cause only {@link PhysicalBone2D} nodes with those names to start simulating.
+     */
+    startSimulation(bones?: GodotArray<StringName> /* = [] */): void { _C(this, 13844, bones); }
+
+    /**
+     * Tell the {@link PhysicalBone2D} nodes to stop simulating and interacting with the physics world.
+     * Optionally, an array of bone names can be passed to this function, and that will cause only {@link PhysicalBone2D} nodes with those names to stop simulating.
+     */
+    stopSimulation(bones?: GodotArray<StringName> /* = [] */): void { _C(this, 13870, bones); }
+
+    /**
+     * The number of {@link PhysicalBone2D} nodes linked in this modification.
+     */
+    get physicalBoneChainLength(): number { return _C(this, 5882) as number; }
+    set physicalBoneChainLength(v: number) { _C(this, 12305, v); }
+
+    static readonly name = _R(709, SkeletonModification2DPhysicalBones);
+}