@ringozz/godot 0.1.0

package/gen/classes/SkeletonModification2DStackHolder.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 { SkeletonModification2D } from './SkeletonModification2D.ts';
+import type { SkeletonModificationStack2D } from './SkeletonModificationStack2D.ts';
+
+/**
+ * This {@link SkeletonModification2D} holds a reference to a {@link SkeletonModificationStack2D}, allowing you to use multiple modification stacks on a single {@link Skeleton2D}.
+ * **Note:** The modifications in the held {@link SkeletonModificationStack2D} will only be executed if their execution mode matches the execution mode of the SkeletonModification2DStackHolder.
+ */
+export class SkeletonModification2DStackHolder extends SkeletonModification2D {
+    constructor(name = 710) { super(name); }
+
+    /**
+     * Sets the {@link SkeletonModificationStack2D} that this modification is holding. This modification stack will then be executed when this modification is executed.
+     */
+    setHeldModificationStack(heldModificationStack: SkeletonModificationStack2D): void { _C(this, 11619, heldModificationStack); }
+
+    /**
+     * Returns the {@link SkeletonModificationStack2D} that this modification is holding.
+     */
+    getHeldModificationStack(): SkeletonModificationStack2D { return _C(this, 5033) as SkeletonModificationStack2D; }
+
+    static readonly name = _R(710, SkeletonModification2DStackHolder);
+}

package/gen/classes/SkeletonModification2DTwoBoneIK.ts

@@ -0,0 +1,80 @@
+// 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 typically called TwoBoneIK. This algorithm works by leveraging the law of cosines and the lengths of the bones to figure out what rotation the bones currently have, and what rotation they need to make a complete triangle, where the first bone, the second bone, and the target form the three vertices of the triangle. Because the algorithm works by making a triangle, it can only operate on two bones.
+ * TwoBoneIK is great for arms, legs, and really any joints that can be represented by just two bones that bend to reach a target. This solver is more lightweight than {@link SkeletonModification2DFABRIK}, but gives similar, natural looking results.
+ */
+export class SkeletonModification2DTwoBoneIK extends SkeletonModification2D {
+    constructor(name = 711) { super(name); }
+
+    /**
+     * Sets the {@link Bone2D} node that is being used as the first bone in the TwoBoneIK modification.
+     */
+    setJointOneBone2dNode(bone2dNode: NodePath): void { _C(this, 11831, bone2dNode); }
+
+    /**
+     * Returns the {@link Bone2D} node that is being used as the first bone in the TwoBoneIK modification.
+     */
+    getJointOneBone2dNode(): NodePath { return _C(this, 5249) as NodePath; }
+
+    /**
+     * Sets the index of the {@link Bone2D} node that is being used as the first bone in the TwoBoneIK modification.
+     */
+    setJointOneBoneIdx(boneIdx: number): void { _C(this, 11832, boneIdx); }
+
+    /**
+     * Returns the index of the {@link Bone2D} node that is being used as the first bone in the TwoBoneIK modification.
+     */
+    getJointOneBoneIdx(): number { return _C(this, 5250) as number; }
+
+    /**
+     * Sets the {@link Bone2D} node that is being used as the second bone in the TwoBoneIK modification.
+     */
+    setJointTwoBone2dNode(bone2dNode: NodePath): void { _C(this, 11840, bone2dNode); }
+
+    /**
+     * Returns the {@link Bone2D} node that is being used as the second bone in the TwoBoneIK modification.
+     */
+    getJointTwoBone2dNode(): NodePath { return _C(this, 5258) as NodePath; }
+
+    /**
+     * Sets the index of the {@link Bone2D} node that is being used as the second bone in the TwoBoneIK modification.
+     */
+    setJointTwoBoneIdx(boneIdx: number): void { _C(this, 11841, boneIdx); }
+
+    /**
+     * Returns the index of the {@link Bone2D} node that is being used as the second bone in the TwoBoneIK modification.
+     */
+    getJointTwoBoneIdx(): number { return _C(this, 5259) as number; }
+
+    /**
+     * The NodePath to the node that is the target for the TwoBoneIK modification. This node is what the modification will use when bending the {@link Bone2D} nodes.
+     */
+    get targetNodepath(): NodePath { return _C(this, 6701) as NodePath; }
+    set targetNodepath(v: NodePath) { _C(this, 13005, v); }
+
+    /**
+     * The minimum distance the target can be at. If the target is closer than this distance, the modification will solve as if it's at this minimum distance. When set to `0`, the modification will solve without distance constraints.
+     */
+    get targetMinimumDistance(): number { return _C(this, 6700) as number; }
+    set targetMinimumDistance(v: number) { _C(this, 13004, v); }
+
+    /**
+     * The maximum distance the target can be at. If the target is farther than this distance, the modification will solve as if it's at this maximum distance. When set to `0`, the modification will solve without distance constraints.
+     */
+    get targetMaximumDistance(): number { return _C(this, 6699) as number; }
+    set targetMaximumDistance(v: number) { _C(this, 13003, v); }
+
+    /**
+     * If `true`, the bones in the modification will bend outward as opposed to inwards when contracting. If `false`, the bones will bend inwards when contracting.
+     */
+    get flipBendDirection(): boolean { return _C(this, 4809) as boolean; }
+    set flipBendDirection(v: boolean) { _C(this, 11415, v); }
+
+    static readonly name = _R(711, SkeletonModification2DTwoBoneIK);
+}

package/gen/classes/SkeletonModificationStack2D.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 { Resource } from './Resource.ts';
+import type { Skeleton2D } from './Skeleton2D.ts';
+import type { SkeletonModification2D } from './SkeletonModification2D.ts';
+
+/**
+ * This resource is used by the Skeleton and holds a stack of {@link SkeletonModification2D}s.
+ * This controls the order of the modifications and how they are applied. Modification order is especially important for full-body IK setups, as you need to execute the modifications in the correct order to get the desired results. For example, you want to execute a modification on the spine *before* the arms on a humanoid skeleton.
+ * This resource also controls how strongly all of the modifications are applied to the {@link Skeleton2D}.
+ */
+export class SkeletonModificationStack2D extends Resource {
+    constructor(name = 712) { super(name); }
+
+    /**
+     * Sets up the modification stack so it can execute. This function should be called by {@link Skeleton2D} and shouldn't be manually called unless you know what you are doing.
+     */
+    setup(): void { _C(this, 13415); }
+
+    /**
+     * Executes all of the {@link SkeletonModification2D}s in the stack that use the same execution mode as the passed-in `executionMode`, starting from index `0` to {@link modificationCount}.
+     * **Note:** The order of the modifications can matter depending on the modifications. For example, modifications on a spine should operate before modifications on the arms in order to get proper results.
+     */
+    execute(delta: number, executionMode: number): void { _C(this, 3180, delta, executionMode); }
+
+    /**
+     * Enables all {@link SkeletonModification2D}s in the stack.
+     */
+    enableAllModifications(enabled: boolean): void { _C(this, 3056, enabled); }
+
+    /**
+     * Returns the {@link SkeletonModification2D} at the passed-in index, `modIdx`.
+     */
+    getModification(modIdx: number): SkeletonModification2D { return _C(this, 5570, modIdx) as SkeletonModification2D; }
+
+    /**
+     * Adds the passed-in {@link SkeletonModification2D} to the stack.
+     */
+    addModification(modification: SkeletonModification2D): void { _C(this, 1252, modification); }
+
+    /**
+     * Deletes the {@link SkeletonModification2D} at the index position `modIdx`, if it exists.
+     */
+    deleteModification(modIdx: number): void { _C(this, 2722, modIdx); }
+
+    /**
+     * Sets the modification at `modIdx` to the passed-in modification, `modification`.
+     */
+    setModification(modIdx: number, modification: SkeletonModification2D): void { _C(this, 12077, modIdx, modification); }
+
+    /**
+     * Returns a boolean that indicates whether the modification stack is setup and can execute.
+     */
+    getIsSetup(): boolean { return _C(this, 5173) as boolean; }
+
+    /**
+     * Returns the {@link Skeleton2D} node that the SkeletonModificationStack2D is bound to.
+     */
+    getSkeleton(): Skeleton2D { return _C(this, 6405) as Skeleton2D; }
+
+    /**
+     * If `true`, the modification's in the stack will be called. This is handled automatically through the {@link Skeleton2D} node.
+     */
+    get enabled(): boolean { return _C(this, 4656) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * The interpolation strength of the modifications in stack. A value of `0` will make it where the modifications are not applied, a strength of `0.5` will be half applied, and a strength of `1` will allow the modifications to be fully applied and override the {@link Skeleton2D} {@link Bone2D} poses.
+     */
+    get strength(): number { return _C(this, 6567) as number; }
+    set strength(v: number) { _C(this, 12904, v); }
+
+    /**
+     * The number of modifications in the stack.
+     */
+    get modificationCount(): number { return _C(this, 5571) as number; }
+    set modificationCount(v: number) { _C(this, 12078, v); }
+
+    static readonly name = _R(712, SkeletonModificationStack2D);
+}

package/gen/classes/SkeletonModifier3D.ts

@@ -0,0 +1,168 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { Skeleton3D } from './Skeleton3D.ts';
+
+/**
+ * {@link SkeletonModifier3D} retrieves a target {@link Skeleton3D} by having a {@link Skeleton3D} parent.
+ * If there is an {@link AnimationMixer}, a modification always performs after playback process of the {@link AnimationMixer}.
+ * This node should be used to implement custom IK solvers, constraints, or skeleton physics.
+ */
+export class SkeletonModifier3D extends Node3D {
+    constructor(name = 713) { super(name); }
+
+    /**
+     * Returns the parent {@link Skeleton3D} node if it exists. Otherwise, returns `null`.
+     */
+    getSkeleton(): Skeleton3D | null { return _C(this, 6405) as Skeleton3D | null; }
+
+    /**
+     * If `true`, the {@link SkeletonModifier3D} will be processing.
+     */
+    get active(): boolean { return _C(this, 7746) as boolean; }
+    set active(v: boolean) { _C(this, 10426, v); }
+
+    /**
+     * Sets the influence of the modification.
+     * **Note:** This value is used by {@link Skeleton3D} to blend, so the {@link SkeletonModifier3D} should always apply only 100% of the result without interpolation.
+     */
+    get influence(): number { return _C(this, 5097) as number; }
+    set influence(v: number) { _C(this, 11698, v); }
+
+    /**
+     * Notifies when the modification have been finished.
+     * **Note:** If you want to get the modified bone pose by the modifier, you must use {@link Skeleton3D.getBonePose} or {@link Skeleton3D.getBoneGlobalPose} at the moment this signal is fired.
+     */
+    get modificationProcessed(): Signal<() => void> { return _G(this, 8945) as Signal<() => void>; }
+    set modificationProcessed(v: (() => void) | null) { _G(this, 8945, v); }
+
+    static readonly name = _R(713, SkeletonModifier3D);
+}
+
+export const BoneAxis = {
+    /**
+     * Enumerated value for the +X axis.
+     */
+    BONE_AXIS_PLUS_X: 0,
+    /**
+     * Enumerated value for the -X axis.
+     */
+    BONE_AXIS_MINUS_X: 1,
+    /**
+     * Enumerated value for the +Y axis.
+     */
+    BONE_AXIS_PLUS_Y: 2,
+    /**
+     * Enumerated value for the -Y axis.
+     */
+    BONE_AXIS_MINUS_Y: 3,
+    /**
+     * Enumerated value for the +Z axis.
+     */
+    BONE_AXIS_PLUS_Z: 4,
+    /**
+     * Enumerated value for the -Z axis.
+     */
+    BONE_AXIS_MINUS_Z: 5,
+} as const;
+
+export type BoneAxis = (typeof BoneAxis)[keyof typeof BoneAxis];
+
+export const BoneDirection = {
+    /**
+     * Enumerated value for the +X axis.
+     */
+    BONE_DIRECTION_PLUS_X: 0,
+    /**
+     * Enumerated value for the -X axis.
+     */
+    BONE_DIRECTION_MINUS_X: 1,
+    /**
+     * Enumerated value for the +Y axis.
+     */
+    BONE_DIRECTION_PLUS_Y: 2,
+    /**
+     * Enumerated value for the -Y axis.
+     */
+    BONE_DIRECTION_MINUS_Y: 3,
+    /**
+     * Enumerated value for the +Z axis.
+     */
+    BONE_DIRECTION_PLUS_Z: 4,
+    /**
+     * Enumerated value for the -Z axis.
+     */
+    BONE_DIRECTION_MINUS_Z: 5,
+    /**
+     * Enumerated value for the axis from a parent bone to the child bone.
+     */
+    BONE_DIRECTION_FROM_PARENT: 6,
+} as const;
+
+export type BoneDirection = (typeof BoneDirection)[keyof typeof BoneDirection];
+
+export const SecondaryDirection = {
+    /**
+     * Enumerated value for the case when the axis is undefined.
+     */
+    SECONDARY_DIRECTION_NONE: 0,
+    /**
+     * Enumerated value for the +X axis.
+     */
+    SECONDARY_DIRECTION_PLUS_X: 1,
+    /**
+     * Enumerated value for the -X axis.
+     */
+    SECONDARY_DIRECTION_MINUS_X: 2,
+    /**
+     * Enumerated value for the +Y axis.
+     */
+    SECONDARY_DIRECTION_PLUS_Y: 3,
+    /**
+     * Enumerated value for the -Y axis.
+     */
+    SECONDARY_DIRECTION_MINUS_Y: 4,
+    /**
+     * Enumerated value for the +Z axis.
+     */
+    SECONDARY_DIRECTION_PLUS_Z: 5,
+    /**
+     * Enumerated value for the -Z axis.
+     */
+    SECONDARY_DIRECTION_MINUS_Z: 6,
+    /**
+     * Enumerated value for an optional axis.
+     */
+    SECONDARY_DIRECTION_CUSTOM: 7,
+} as const;
+
+export type SecondaryDirection = (typeof SecondaryDirection)[keyof typeof SecondaryDirection];
+
+export const RotationAxis = {
+    /**
+     * Enumerated value for the rotation of the X axis.
+     */
+    ROTATION_AXIS_X: 0,
+    /**
+     * Enumerated value for the rotation of the Y axis.
+     */
+    ROTATION_AXIS_Y: 1,
+    /**
+     * Enumerated value for the rotation of the Z axis.
+     */
+    ROTATION_AXIS_Z: 2,
+    /**
+     * Enumerated value for the unconstrained rotation.
+     */
+    ROTATION_AXIS_ALL: 3,
+    /**
+     * Enumerated value for an optional rotation axis.
+     */
+    ROTATION_AXIS_CUSTOM: 4,
+} as const;
+
+export type RotationAxis = (typeof RotationAxis)[keyof typeof RotationAxis];
+

package/gen/classes/SkeletonProfile.ts

@@ -0,0 +1,180 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { Signal, StringName } from '../heap-types/index.ts';
+import type { Transform3D, Vector2 } from '../value-types/index.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * This resource is used in {@link EditorScenePostImport}. Some parameters are referring to bones in {@link Skeleton3D}, {@link Skin}, {@link Animation}, and some other nodes are rewritten based on the parameters of {@link SkeletonProfile}.
+ * **Note:** These parameters need to be set only when creating a custom profile. In {@link SkeletonProfileHumanoid}, they are defined internally as read-only values.
+ */
+export class SkeletonProfile extends Resource {
+    constructor(name = 714) { super(name); }
+
+    /**
+     * Returns the name of the group at `groupIdx` that will be the drawing group in the {@link BoneMap} editor.
+     */
+    getGroupName(groupIdx: number): StringName { return _C(this, 4987, groupIdx) as StringName; }
+
+    /**
+     * Sets the name of the group at `groupIdx` that will be the drawing group in the {@link BoneMap} editor.
+     */
+    setGroupName(groupIdx: number, groupName: StringName): void { _C(this, 11570, groupIdx, groupName); }
+
+    /**
+     * Returns the texture of the group at `groupIdx` that will be the drawing group background image in the {@link BoneMap} editor.
+     */
+    getTexture(groupIdx: number): Texture2D { return _C(this, 6726, groupIdx) as Texture2D; }
+
+    /**
+     * Sets the texture of the group at `groupIdx` that will be the drawing group background image in the {@link BoneMap} editor.
+     */
+    setTexture(groupIdx: number, texture: Texture2D): void { _C(this, 13024, groupIdx, texture); }
+
+    /**
+     * Returns the bone index that matches `boneName` as its name.
+     */
+    findBone(boneName: StringName): number { return _C(this, 3283, boneName) as number; }
+
+    /**
+     * Returns the name of the bone at `boneIdx` that will be the key name in the {@link BoneMap}.
+     * In the retargeting process, the returned bone name is the bone name of the target skeleton.
+     */
+    getBoneName(boneIdx: number): StringName { return _C(this, 3972, boneIdx) as StringName; }
+
+    /**
+     * Sets the name of the bone at `boneIdx` that will be the key name in the {@link BoneMap}.
+     * In the retargeting process, the setting bone name is the bone name of the target skeleton.
+     */
+    setBoneName(boneIdx: number, boneName: StringName): void { _C(this, 10710, boneIdx, boneName); }
+
+    /**
+     * Returns the name of the bone which is the parent to the bone at `boneIdx`. The result is empty if the bone has no parent.
+     */
+    getBoneParent(boneIdx: number): StringName { return _C(this, 3973, boneIdx) as StringName; }
+
+    /**
+     * Sets the bone with name `boneParent` as the parent of the bone at `boneIdx`. If an empty string is passed, then the bone has no parent.
+     */
+    setBoneParent(boneIdx: number, boneParent: StringName): void { _C(this, 10711, boneIdx, boneParent); }
+
+    /**
+     * Returns the tail direction of the bone at `boneIdx`.
+     */
+    getTailDirection(boneIdx: number): TailDirection { return _C(this, 6690, boneIdx) as TailDirection; }
+
+    /**
+     * Sets the tail direction of the bone at `boneIdx`.
+     * **Note:** This only specifies the method of calculation. The actual coordinates required should be stored in an external skeleton, so the calculation itself needs to be done externally.
+     */
+    setTailDirection(boneIdx: number, tailDirection: TailDirection): void { _C(this, 12991, boneIdx, tailDirection); }
+
+    /**
+     * Returns the name of the bone which is the tail of the bone at `boneIdx`.
+     */
+    getBoneTail(boneIdx: number): StringName { return _C(this, 3981, boneIdx) as StringName; }
+
+    /**
+     * Sets the bone with name `boneTail` as the tail of the bone at `boneIdx`.
+     */
+    setBoneTail(boneIdx: number, boneTail: StringName): void { _C(this, 10719, boneIdx, boneTail); }
+
+    /**
+     * Returns the reference pose transform for bone `boneIdx`.
+     */
+    getReferencePose(boneIdx: number): Transform3D { return _C(this, 6102, boneIdx) as Transform3D; }
+
+    /**
+     * Sets the reference pose transform for bone `boneIdx`.
+     */
+    setReferencePose(boneIdx: number, boneName: Transform3D): void { _C(this, 12495, boneIdx, boneName); }
+
+    /**
+     * Returns the offset of the bone at `boneIdx` that will be the button position in the {@link BoneMap} editor.
+     * This is the offset with origin at the top left corner of the square.
+     */
+    getHandleOffset(boneIdx: number): Vector2 { return _C(this, 5019, boneIdx) as Vector2; }
+
+    /**
+     * Sets the offset of the bone at `boneIdx` that will be the button position in the {@link BoneMap} editor.
+     * This is the offset with origin at the top left corner of the square.
+     */
+    setHandleOffset(boneIdx: number, handleOffset: Vector2): void { _C(this, 11602, boneIdx, handleOffset); }
+
+    /**
+     * Returns the group of the bone at `boneIdx`.
+     */
+    getGroup(boneIdx: number): StringName { return _C(this, 4985, boneIdx) as StringName; }
+
+    /**
+     * Sets the group of the bone at `boneIdx`.
+     */
+    setGroup(boneIdx: number, group: StringName): void { _C(this, 11568, boneIdx, group); }
+
+    /**
+     * Returns whether the bone at `boneIdx` is required for retargeting.
+     * This value is used by the bone map editor. If this method returns `true`, and no bone is assigned, the handle color will be red on the bone map editor.
+     */
+    isRequired(boneIdx: number): boolean { return _C(this, 8241, boneIdx) as boolean; }
+
+    /**
+     * Sets the required status for bone `boneIdx` to `required`.
+     */
+    setRequired(boneIdx: number, required: boolean): void { _C(this, 12534, boneIdx, required); }
+
+    /**
+     * A bone name that will be used as the root bone in {@link AnimationTree}. This should be the bone of the parent of hips that exists at the world origin.
+     */
+    get rootBone(): StringName { return _C(this, 6189) as StringName; }
+    set rootBone(v: StringName) { _C(this, 12566, v); }
+
+    /**
+     * A bone name which will use model's height as the coefficient for normalization. For example, {@link SkeletonProfileHumanoid} defines it as `Hips`.
+     */
+    get scaleBaseBone(): StringName { return _C(this, 6239) as StringName; }
+    set scaleBaseBone(v: StringName) { _C(this, 12611, v); }
+
+    /**
+     * The amount of groups of bones in retargeting section's {@link BoneMap} editor. For example, {@link SkeletonProfileHumanoid} has 4 groups.
+     * This property exists to separate the bone list into several sections in the editor.
+     */
+    get groupSize(): number { return _C(this, 4989) as number; }
+    set groupSize(v: number) { _C(this, 11571, v); }
+
+    /**
+     * The amount of bones in retargeting section's {@link BoneMap} editor. For example, {@link SkeletonProfileHumanoid} has 56 bones.
+     * The size of elements in {@link BoneMap} updates when changing this property in it's assigned {@link SkeletonProfile}.
+     */
+    get boneSize(): number { return _C(this, 3980) as number; }
+    set boneSize(v: number) { _C(this, 10718, v); }
+
+    /**
+     * This signal is emitted when change the value in profile. This is used to update key name in the {@link BoneMap} and to redraw the {@link BoneMap} editor.
+     * **Note:** This signal is not connected directly to editor to simplify the reference, instead it is passed on to editor through the {@link BoneMap}.
+     */
+    get profileUpdated(): Signal<() => void> { return _G(this, 9583) as Signal<() => void>; }
+    set profileUpdated(v: (() => void) | null) { _G(this, 9583, v); }
+
+    static readonly name = _R(714, SkeletonProfile);
+}
+
+export const TailDirection = {
+    /**
+     * Direction to the average coordinates of bone children.
+     */
+    TAIL_DIRECTION_AVERAGE_CHILDREN: 0,
+    /**
+     * Direction to the coordinates of specified bone child.
+     */
+    TAIL_DIRECTION_SPECIFIC_CHILD: 1,
+    /**
+     * Direction is not calculated.
+     */
+    TAIL_DIRECTION_END: 2,
+} as const;
+
+export type TailDirection = (typeof TailDirection)[keyof typeof TailDirection];
+

package/gen/classes/SkeletonProfileHumanoid.ts

@@ -0,0 +1,76 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonProfile } from './SkeletonProfile.ts';
+
+/**
+ * A {@link SkeletonProfile} as a preset that is optimized for the human form. This exists for standardization, so all parameters are read-only.
+ * A humanoid skeleton profile contains 56 bones divided into 4 groups: `"Body"`, `"Face"`, `"LeftHand"`, and `"RightHand"`. It is structured as follows:
+ *
+ * ```text
+ *
+ * Root
+ * └─ Hips
+ *     ├─ LeftUpperLeg
+ *     │  └─ LeftLowerLeg
+ *     │     └─ LeftFoot
+ *     │        └─ LeftToes
+ *     ├─ RightUpperLeg
+ *     │  └─ RightLowerLeg
+ *     │     └─ RightFoot
+ *     │        └─ RightToes
+ *     └─ Spine
+ *         └─ Chest
+ *             └─ UpperChest
+ *                 ├─ Neck
+ *                 │   └─ Head
+ *                 │       ├─ Jaw
+ *                 │       ├─ LeftEye
+ *                 │       └─ RightEye
+ *                 ├─ LeftShoulder
+ *                 │  └─ LeftUpperArm
+ *                 │     └─ LeftLowerArm
+ *                 │        └─ LeftHand
+ *                 │           ├─ LeftThumbMetacarpal
+ *                 │           │  └─ LeftThumbProximal
+ *                 │           │    └─ LeftThumbDistal
+ *                 │           ├─ LeftIndexProximal
+ *                 │           │  └─ LeftIndexIntermediate
+ *                 │           │    └─ LeftIndexDistal
+ *                 │           ├─ LeftMiddleProximal
+ *                 │           │  └─ LeftMiddleIntermediate
+ *                 │           │    └─ LeftMiddleDistal
+ *                 │           ├─ LeftRingProximal
+ *                 │           │  └─ LeftRingIntermediate
+ *                 │           │    └─ LeftRingDistal
+ *                 │           └─ LeftLittleProximal
+ *                 │              └─ LeftLittleIntermediate
+ *                 │                └─ LeftLittleDistal
+ *                 └─ RightShoulder
+ *                    └─ RightUpperArm
+ *                       └─ RightLowerArm
+ *                          └─ RightHand
+ *                             ├─ RightThumbMetacarpal
+ *                             │  └─ RightThumbProximal
+ *                             │     └─ RightThumbDistal
+ *                             ├─ RightIndexProximal
+ *                             │  └─ RightIndexIntermediate
+ *                             │     └─ RightIndexDistal
+ *                             ├─ RightMiddleProximal
+ *                             │  └─ RightMiddleIntermediate
+ *                             │     └─ RightMiddleDistal
+ *                             ├─ RightRingProximal
+ *                             │  └─ RightRingIntermediate
+ *                             │     └─ RightRingDistal
+ *                             └─ RightLittleProximal
+ *                                └─ RightLittleIntermediate
+ *                                  └─ RightLittleDistal
+ *
+ * ```
+ */
+export class SkeletonProfileHumanoid extends SkeletonProfile {
+    constructor(name = 715) { super(name); }
+
+    static readonly name = _R(715, SkeletonProfileHumanoid);
+}

package/gen/classes/Skin.ts

@@ -0,0 +1,35 @@
+// 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 { StringName } from '../heap-types/index.ts';
+import type { Transform3D } from '../value-types/index.ts';
+
+export class Skin extends Resource {
+    constructor(name = 716) { super(name); }
+
+    setBindCount(bindCount: number): void { _C(this, 10662, bindCount); }
+
+    getBindCount(): number { return _C(this, 3916) as number; }
+
+    addBind(bone: number, pose: Transform3D): void { _C(this, 1183, bone, pose); }
+
+    addNamedBind(name: string, pose: Transform3D): void { _C(this, 1254, name, pose); }
+
+    setBindPose(bindIndex: number, pose: Transform3D): void { _C(this, 10665, bindIndex, pose); }
+
+    getBindPose(bindIndex: number): Transform3D { return _C(this, 3918, bindIndex) as Transform3D; }
+
+    setBindName(bindIndex: number, name: StringName): void { _C(this, 10664, bindIndex, name); }
+
+    getBindName(bindIndex: number): StringName { return _C(this, 3917, bindIndex) as StringName; }
+
+    setBindBone(bindIndex: number, bone: number): void { _C(this, 10661, bindIndex, bone); }
+
+    getBindBone(bindIndex: number): number { return _C(this, 3915, bindIndex) as number; }
+
+    clearBinds(): void { _C(this, 2236); }
+
+    static readonly name = _R(716, Skin);
+}

package/gen/classes/SkinReference.ts

@@ -0,0 +1,30 @@
+// 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 { Skin } from './Skin.ts';
+
+/**
+ * An internal object containing a mapping from a {@link Skin} used within the context of a particular {@link MeshInstance3D} to refer to the skeleton's {@link RID} in the RenderingServer.
+ * See also {@link MeshInstance3D.getSkinReference} and {@link RenderingServer.instanceAttachSkeleton}.
+ * Note that despite the similar naming, the skeleton RID used in the {@link RenderingServer} does not have a direct one-to-one correspondence to a {@link Skeleton3D} node.
+ * In particular, a {@link Skeleton3D} node with no {@link MeshInstance3D} children may be unknown to the {@link RenderingServer}.
+ * On the other hand, a {@link Skeleton3D} with multiple {@link MeshInstance3D} nodes which each have different {@link MeshInstance3D.skin} objects may have multiple SkinReference instances (and hence, multiple skeleton {@link RID}s).
+ */
+export class SkinReference extends RefCounted {
+
+    /**
+     * Returns the {@link RID} owned by this SkinReference, as returned by {@link RenderingServer.skeletonCreate}.
+     */
+    getSkeleton(): RID { return _C(this, 6405) as RID; }
+
+    /**
+     * Returns the {@link Skin} connected to this SkinReference. In the case of {@link MeshInstance3D} with no {@link MeshInstance3D.skin} assigned, this will reference an internal default {@link Skin} owned by that {@link MeshInstance3D}.
+     * Note that a single {@link Skin} may have more than one {@link SkinReference} in the case that it is shared by meshes across multiple {@link Skeleton3D} nodes.
+     */
+    getSkin(): Skin { return _C(this, 6413) as Skin; }
+
+    static readonly name = _R(717, SkinReference);
+}