@ringozz/godot 0.1.0

package/gen/classes/BitMap.ts

@@ -0,0 +1,94 @@
+// 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 { GodotArray, GodotDictionary, PackedVector2Array } from '../heap-types/index.ts';
+import type { Rect2i, Vector2i } from '../value-types/index.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * A two-dimensional array of boolean values, can be used to efficiently store a binary matrix (every matrix element takes only one bit) and query the values using natural cartesian coordinates.
+ */
+export class BitMap extends Resource {
+    constructor(name = 148) { super(name); }
+
+    /**
+     * Creates a bitmap with the specified size, filled with `false`.
+     */
+    create(size: Vector2i): void { _C(this, 2506, size); }
+
+    /**
+     * Creates a bitmap that matches the given image dimensions, every element of the bitmap is set to `false` if the alpha value of the image at that position is equal to `threshold` or less, and `true` in other case.
+     */
+    createFromImageAlpha(image: Image, threshold?: number /* = 0.1 */): void { _C(this, 2534, image, threshold); }
+
+    /**
+     * Sets the bitmap's element at the specified position, to the specified value.
+     */
+    setBitv(position: Vector2i, bit: boolean): void { _C(this, 10673, position, bit); }
+
+    /**
+     * Sets the bitmap's element at the specified position, to the specified value.
+     */
+    setBit(x: number, y: number, bit: boolean): void { _C(this, 10670, x, y, bit); }
+
+    /**
+     * Returns bitmap's value at the specified position.
+     */
+    getBitv(position: Vector2i): boolean { return _C(this, 3928, position) as boolean; }
+
+    /**
+     * Returns bitmap's value at the specified position.
+     */
+    getBit(x: number, y: number): boolean { return _C(this, 3926, x, y) as boolean; }
+
+    /**
+     * Sets a rectangular portion of the bitmap to the specified value.
+     */
+    setBitRect(rect: Rect2i, bit: boolean): void { _C(this, 10671, rect, bit); }
+
+    /**
+     * Returns the number of bitmap elements that are set to `true`.
+     */
+    getTrueBitCount(): number { return _C(this, 6912) as number; }
+
+    /**
+     * Returns bitmap's dimensions.
+     */
+    getSize(): Vector2i { return _C(this, 6399) as Vector2i; }
+
+    /**
+     * Resizes the image to `newSize`.
+     */
+    resize(newSize: Vector2i): void { _C(this, 10077, newSize); }
+
+    /**
+     * Applies morphological dilation or erosion to the bitmap. If `pixels` is positive, dilation is applied to the bitmap. If `pixels` is negative, erosion is applied to the bitmap. `rect` defines the area where the morphological operation is applied. Pixels located outside the `rect` are unaffected by {@link growMask}.
+     */
+    growMask(pixels: number, rect: Rect2i): void { _C(this, 7310, pixels, rect); }
+
+    /**
+     * Returns an image of the same size as the bitmap and with an {@link Image.Format} of type {@link Image.FORMAT_L8}. `true` bits of the bitmap are being converted into white pixels, and `false` bits into black.
+     */
+    convertToImage(): Image { return _C(this, 2481) as Image; }
+
+    /**
+     * Creates an {@link Array} of polygons covering a rectangular portion of the bitmap. It uses a marching squares algorithm, followed by Ramer-Douglas-Peucker (RDP) reduction of the number of vertices. Each polygon is described as a {@link PackedVector2Array} of its vertices.
+     * To get polygons covering the whole bitmap, pass:
+     *
+     * ```text
+     *
+     * Rect2(Vector2(), get_size())
+     *
+     * ```
+     *
+     * `epsilon` is passed to RDP to control how accurately the polygons cover the bitmap: a lower `epsilon` corresponds to more points in the polygons.
+     */
+    opaqueToPolygons(rect: Rect2i, epsilon?: number /* = 2.0 */): GodotArray<PackedVector2Array> { return _C(this, 9188, rect, epsilon) as GodotArray<PackedVector2Array>; }
+
+    get data(): GodotDictionary { return _C(this, 1000) as GodotDictionary; }
+    set data(v: GodotDictionary) { _C(this, 1026, v); }
+
+    static readonly name = _R(148, BitMap);
+}

package/gen/classes/BlitMaterial.ts

@@ -0,0 +1,46 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Material } from './Material.ts';
+
+/**
+ * A material resource that can be used by DrawableTextures when processing blit calls to draw.
+ */
+export class BlitMaterial extends Material {
+    constructor(name = 149) { super(name); }
+
+    /**
+     * The manner in which the newly blitted texture is blended with the original DrawableTexture.
+     */
+    get blendMode(): BlendMode { return _C(this, 3932) as BlendMode; }
+    set blendMode(v: BlendMode) { _C(this, 10677, v); }
+
+    static readonly name = _R(149, BlitMaterial);
+}
+
+export const BlendMode = {
+    /**
+     * Mix blending mode. Colors are assumed to be independent of the alpha (opacity) value.
+     */
+    BLEND_MODE_MIX: 0,
+    /**
+     * Additive blending mode.
+     */
+    BLEND_MODE_ADD: 1,
+    /**
+     * Subtractive blending mode.
+     */
+    BLEND_MODE_SUB: 2,
+    /**
+     * Multiplicative blending mode.
+     */
+    BLEND_MODE_MUL: 3,
+    /**
+     * No blending mode, direct color copy.
+     */
+    BLEND_MODE_DISABLED: 4,
+} as const;
+
+export type BlendMode = (typeof BlendMode)[keyof typeof BlendMode];
+

package/gen/classes/Bone2D.ts

@@ -0,0 +1,71 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { Transform2D } from '../value-types/index.ts';
+
+/**
+ * A hierarchy of {@link Bone2D}s can be bound to a {@link Skeleton2D} to control and animate other {@link Node2D} nodes.
+ * You can use {@link Bone2D} and {@link Skeleton2D} nodes to animate 2D meshes created with the {@link Polygon2D} UV editor.
+ * Each bone has a {@link rest} transform that you can reset to with {@link applyRest}. These rest poses are relative to the bone's parent.
+ * If in the editor, you can set the rest pose of an entire skeleton using a menu option, from the code, you need to iterate over the bones to set their individual rest poses.
+ */
+export class Bone2D extends Node2D {
+    constructor(name = 150) { super(name); }
+
+    /**
+     * Resets the bone to the rest pose. This is equivalent to setting {@link Node2D.transform} to {@link rest}.
+     */
+    applyRest(): void { _C(this, 1534); }
+
+    /**
+     * Returns the node's {@link rest} {@link Transform2D} if it doesn't have a parent, or its rest pose relative to its parent.
+     */
+    getSkeletonRest(): Transform2D { return _C(this, 6408) as Transform2D; }
+
+    /**
+     * Returns the node's index as part of the entire skeleton. See {@link Skeleton2D}.
+     */
+    getIndexInSkeleton(): number { return _C(this, 5088) as number; }
+
+    /**
+     * When set to `true`, the {@link Bone2D} node will attempt to automatically calculate the bone angle and length using the first child {@link Bone2D} node, if one exists. If none exist, the {@link Bone2D} cannot automatically calculate these values and will print a warning.
+     */
+    setAutocalculateLengthAndAngle(autoCalculate: boolean): void { _C(this, 10585, autoCalculate); }
+
+    /**
+     * Returns whether this {@link Bone2D} is going to autocalculate its length and bone angle using its first {@link Bone2D} child node, if one exists. If there are no {@link Bone2D} children, then it cannot autocalculate these values and will print a warning.
+     */
+    getAutocalculateLengthAndAngle(): boolean { return _C(this, 3841) as boolean; }
+
+    /**
+     * Sets the length of the bone in the {@link Bone2D}.
+     */
+    setLength(length: number): void { _C(this, 11891, length); }
+
+    /**
+     * Returns the length of the bone in the {@link Bone2D} node.
+     */
+    getLength(): number { return _C(this, 5331) as number; }
+
+    /**
+     * Sets the bone angle for the {@link Bone2D}. This is typically set to the rotation from the {@link Bone2D} to a child {@link Bone2D} node.
+     * **Note:** This is different from the {@link Bone2D}'s rotation. The bone's angle is the rotation of the bone shown by the gizmo, which is unaffected by the {@link Bone2D}'s {@link Node2D.transform}.
+     */
+    setBoneAngle(angle: number): void { _C(this, 10702, angle); }
+
+    /**
+     * Returns the angle of the bone in the {@link Bone2D}.
+     * **Note:** This is different from the {@link Bone2D}'s rotation. The bone's angle is the rotation of the bone shown by the gizmo, which is unaffected by the {@link Bone2D}'s {@link Node2D.transform}.
+     */
+    getBoneAngle(): number { return _C(this, 3957) as number; }
+
+    /**
+     * Rest transform of the bone. You can reset the node's transforms to this value using {@link applyRest}.
+     */
+    get rest(): Transform2D { return _C(this, 6168) as Transform2D; }
+    set rest(v: Transform2D) { _C(this, 12544, v); }
+
+    static readonly name = _R(150, Bone2D);
+}

package/gen/classes/BoneAttachment3D.ts

@@ -0,0 +1,57 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+import type { Skeleton3D } from './Skeleton3D.ts';
+
+/**
+ * This node selects a bone in a {@link Skeleton3D} and attaches to it. This means that the {@link BoneAttachment3D} node will either dynamically copy or override the 3D transform of the selected bone.
+ */
+export class BoneAttachment3D extends Node3D {
+    constructor(name = 151) { super(name); }
+
+    /**
+     * Returns the parent or external {@link Skeleton3D} node if it exists, otherwise returns `null`.
+     */
+    getSkeleton(): Skeleton3D | null { return _C(this, 6405) as Skeleton3D | null; }
+
+    /**
+     * A function that is called automatically when the {@link Skeleton3D} is updated. This function is where the {@link BoneAttachment3D} node updates its position so it is correctly bound when it is *not* set to override the bone pose.
+     */
+    onSkeletonUpdate(): void { _C(this, 9181); }
+
+    /**
+     * The name of the attached bone.
+     */
+    get boneName(): string { return _C(this, 3972) as string; }
+    set boneName(v: string) { _C(this, 10710, v); }
+
+    /**
+     * The index of the attached bone.
+     */
+    get boneIdx(): number { return _C(this, 3967) as number; }
+    set boneIdx(v: number) { _C(this, 10706, v); }
+
+    /**
+     * Whether the {@link BoneAttachment3D} node will override the bone pose of the bone it is attached to. When set to `true`, the {@link BoneAttachment3D} node can change the pose of the bone. When set to `false`, the {@link BoneAttachment3D} will always be set to the bone's transform.
+     * **Note:** This override performs interruptively in the skeleton update process using signals due to the old design. It may cause unintended behavior when used at the same time with {@link SkeletonModifier3D}.
+     */
+    get overridePose(): boolean { return _C(this, 5776) as boolean; }
+    set overridePose(v: boolean) { _C(this, 12226, v); }
+
+    /**
+     * Whether the {@link BoneAttachment3D} node will use an external {@link Skeleton3D} node rather than attempting to use its parent node as the {@link Skeleton3D}. When set to `true`, the {@link BoneAttachment3D} node will use the external {@link Skeleton3D} node set in {@link externalSkeleton}.
+     */
+    get useExternalSkeleton(): boolean { return _C(this, 6976) as boolean; }
+    set useExternalSkeleton(v: boolean) { _C(this, 13213, v); }
+
+    /**
+     * The {@link NodePath} to the external {@link Skeleton3D} node.
+     */
+    get externalSkeleton(): NodePath { return _C(this, 4717) as NodePath; }
+    set externalSkeleton(v: NodePath) { _C(this, 11338, v); }
+
+    static readonly name = _R(151, BoneAttachment3D);
+}

package/gen/classes/BoneConstraint3D.ts

@@ -0,0 +1,122 @@
+// 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 } from '../heap-types/index.ts';
+
+/**
+ * Base class of {@link SkeletonModifier3D} that modifies the bone set in {@link setApplyBone} based on the transform of the bone retrieved by {@link getReferenceBone}.
+ * **Note:** Most methods in this class take an `index` parameter. This parameter specifies which setting list entry to return if the IK has multiple entries (e.g. `settings/<index>/amount`).
+ */
+export class BoneConstraint3D extends SkeletonModifier3D {
+    constructor(name = 152) { super(name); }
+
+    /**
+     * Sets the apply amount of the setting at `index` to `amount`.
+     */
+    setAmount(index: number, amount: number): void { _C(this, 10482, index, amount); }
+
+    /**
+     * Returns the apply amount of the setting at `index`.
+     */
+    getAmount(index: number): number { return _C(this, 3741, index) as number; }
+
+    /**
+     * Sets the apply bone of the setting at `index` to `boneName`. This bone will be modified.
+     */
+    setApplyBoneName(index: number, boneName: string): void { _C(this, 10522, index, boneName); }
+
+    /**
+     * Returns the apply bone name of the setting at `index`. This bone will be modified.
+     */
+    getApplyBoneName(index: number): string { return _C(this, 3783, index) as string; }
+
+    /**
+     * Sets the apply bone of the setting at `index` to `bone`. This bone will be modified.
+     */
+    setApplyBone(index: number, bone: number): void { _C(this, 10521, index, bone); }
+
+    /**
+     * Returns the apply bone of the setting at `index`. This bone will be modified.
+     */
+    getApplyBone(index: number): number { return _C(this, 3782, index) as number; }
+
+    /**
+     * Sets the reference target type of the setting at `index` to `type`. See also {@link ReferenceType}.
+     */
+    setReferenceType(index: number, type: ReferenceType): void { _C(this, 12499, index, type); }
+
+    /**
+     * Returns the reference target type of the setting at `index`. See also {@link ReferenceType}.
+     */
+    getReferenceType(index: number): ReferenceType { return _C(this, 6107, index) as ReferenceType; }
+
+    /**
+     * Sets the reference bone of the setting at `index` to `boneName`.
+     * This bone will be only referenced and not modified by this modifier.
+     */
+    setReferenceBoneName(index: number, boneName: string): void { _C(this, 12493, index, boneName); }
+
+    /**
+     * Returns the reference bone name of the setting at `index`.
+     * This bone will be only referenced and not modified by this modifier.
+     */
+    getReferenceBoneName(index: number): string { return _C(this, 6098, index) as string; }
+
+    /**
+     * Sets the reference bone of the setting at `index` to `bone`.
+     * This bone will be only referenced and not modified by this modifier.
+     */
+    setReferenceBone(index: number, bone: number): void { _C(this, 12492, index, bone); }
+
+    /**
+     * Returns the reference bone of the setting at `index`.
+     * This bone will be only referenced and not modified by this modifier.
+     */
+    getReferenceBone(index: number): number { return _C(this, 6097, index) as number; }
+
+    /**
+     * Sets the reference node path of the setting at `index` to `node`.
+     * This node will be only referenced and not modified by this modifier.
+     */
+    setReferenceNode(index: number, node: NodePath): void { _C(this, 12494, index, node); }
+
+    /**
+     * Returns the reference node path of the setting at `index`.
+     * This node will be only referenced and not modified by this modifier.
+     */
+    getReferenceNode(index: number): NodePath { return _C(this, 6101, index) as NodePath; }
+
+    /**
+     * Sets the number of settings in the modifier.
+     */
+    setSettingCount(count: number): void { _C(this, 12700, count); }
+
+    /**
+     * Returns the number of settings in the modifier.
+     */
+    getSettingCount(): number { return _C(this, 6350) as number; }
+
+    /**
+     * Clear all settings.
+     */
+    clearSetting(): void { _C(this, 2292); }
+
+    static readonly name = _R(152, BoneConstraint3D);
+}
+
+export const ReferenceType = {
+    /**
+     * The reference target is a bone. In this case, the reference target spaces is local space.
+     */
+    REFERENCE_TYPE_BONE: 0,
+    /**
+     * The reference target is a {@link Node3D}. In this case, the reference target spaces is model space.
+     * In other words, the reference target's coordinates are treated as if it were placed directly under {@link Skeleton3D} which parent of the {@link BoneConstraint3D}.
+     */
+    REFERENCE_TYPE_NODE: 1,
+} as const;
+
+export type ReferenceType = (typeof ReferenceType)[keyof typeof ReferenceType];
+

package/gen/classes/BoneMap.ts

@@ -0,0 +1,53 @@
+// 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 { SkeletonProfile } from './SkeletonProfile.ts';
+
+/**
+ * This class contains a dictionary that uses a list of bone names in {@link SkeletonProfile} as key names.
+ * By assigning the actual {@link Skeleton3D} bone name as the key value, it maps the {@link Skeleton3D} to the {@link SkeletonProfile}.
+ */
+export class BoneMap extends Resource {
+    constructor(name = 153) { super(name); }
+
+    /**
+     * Returns a skeleton bone name is mapped to `profileBoneName`.
+     * In the retargeting process, the returned bone name is the bone name of the source skeleton.
+     */
+    getSkeletonBoneName(profileBoneName: StringName): StringName { return _C(this, 6406, profileBoneName) as StringName; }
+
+    /**
+     * Maps a skeleton bone name to `profileBoneName`.
+     * In the retargeting process, the setting bone name is the bone name of the source skeleton.
+     */
+    setSkeletonBoneName(profileBoneName: StringName, skeletonBoneName: StringName): void { _C(this, 12758, profileBoneName, skeletonBoneName); }
+
+    /**
+     * Returns a profile bone name having `skeletonBoneName`. If not found, an empty {@link StringName} will be returned.
+     * In the retargeting process, the returned bone name is the bone name of the target skeleton.
+     */
+    findProfileBoneName(skeletonBoneName: StringName): StringName { return _C(this, 3300, skeletonBoneName) as StringName; }
+
+    /**
+     * A {@link SkeletonProfile} of the mapping target. Key names in the {@link BoneMap} are synchronized with it.
+     */
+    get profile(): SkeletonProfile { return _C(this, 6035) as SkeletonProfile; }
+    set profile(v: SkeletonProfile) { _C(this, 12435, v); }
+
+    /**
+     * This signal is emitted when change the key value in the {@link BoneMap}. This is used to validate mapping and to update {@link BoneMap} editor.
+     */
+    get boneMapUpdated(): Signal<() => void> { return _G(this, 1886) as Signal<() => void>; }
+    set boneMapUpdated(v: (() => void) | null) { _G(this, 1886, v); }
+
+    /**
+     * This signal is emitted when change the value in profile or change the reference of profile. This is used to update key names in the {@link BoneMap} and to redraw the {@link BoneMap} editor.
+     */
+    get profileUpdated(): Signal<() => void> { return _G(this, 9583) as Signal<() => void>; }
+    set profileUpdated(v: (() => void) | null) { _G(this, 9583, v); }
+
+    static readonly name = _R(153, BoneMap);
+}

package/gen/classes/BoneTwistDisperser3D.ts

@@ -0,0 +1,209 @@
+// 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 { Quaternion } from '../value-types/index.ts';
+import type { Curve } from './Curve.ts';
+import type { BoneDirection } from './SkeletonModifier3D.ts';
+
+/**
+ * This {@link BoneTwistDisperser3D} allows for smooth twist interpolation between multiple bones by dispersing the end bone's twist to the parents. This only changes the twist without changing the global position of each joint.
+ * This is useful for smoothly twisting bones in combination with {@link CopyTransformModifier3D} and IK.
+ * **Note:** If an extracted twist is greater than 180 degrees, flipping occurs. This is similar to {@link ConvertTransformModifier3D}.
+ * **Note:** Most methods in this class take an `index` parameter. This parameter specifies which setting list entry to return if the IK has multiple entries (e.g. `settings/<index>/root_bone_name`).
+ */
+export class BoneTwistDisperser3D extends SkeletonModifier3D {
+    constructor(name = 154) { super(name); }
+
+    /**
+     * Clears all settings.
+     */
+    clearSettings(): void { _C(this, 2293); }
+
+    /**
+     * Sets the root bone name of the bone chain.
+     */
+    setRootBoneName(index: number, boneName: string): void { _C(this, 12567, index, boneName); }
+
+    /**
+     * Returns the root bone name of the bone chain.
+     */
+    getRootBoneName(index: number): string { return _C(this, 6190, index) as string; }
+
+    /**
+     * Sets the root bone index of the bone chain.
+     */
+    setRootBone(index: number, bone: number): void { _C(this, 12566, index, bone); }
+
+    /**
+     * Returns the root bone index of the bone chain.
+     */
+    getRootBone(index: number): number { return _C(this, 6189, index) as number; }
+
+    /**
+     * Sets the end bone name of the bone chain.
+     * **Note:** The end bone must be a child of the root bone.
+     */
+    setEndBoneName(index: number, boneName: string): void { _C(this, 11292, index, boneName); }
+
+    /**
+     * Returns the end bone name of the bone chain.
+     */
+    getEndBoneName(index: number): string { return _C(this, 4664, index) as string; }
+
+    /**
+     * Sets the end bone index of the bone chain.
+     */
+    setEndBone(index: number, bone: number): void { _C(this, 11289, index, bone); }
+
+    /**
+     * Returns the end bone index of the bone chain.
+     */
+    getEndBone(index: number): number { return _C(this, 4661, index) as number; }
+
+    /**
+     * Returns the reference bone name to extract twist of the setting at `index`.
+     * This bone is either the end of the chain or its parent, depending on {@link isEndBoneExtended}.
+     */
+    getReferenceBoneName(index: number): string { return _C(this, 6098, index) as string; }
+
+    /**
+     * Returns the reference bone to extract twist of the setting at `index`.
+     * This bone is either the end of the chain or its parent, depending on {@link isEndBoneExtended}.
+     */
+    getReferenceBone(index: number): number { return _C(this, 6097, index) as number; }
+
+    /**
+     * If `enabled` is `true`, the end bone is extended to have a tail.
+     * If `enabled` is `false`, {@link getReferenceBone} becomes a parent of the end bone and it uses the vector to the end bone as a twist axis.
+     */
+    setExtendEndBone(index: number, enabled: boolean): void { _C(this, 11332, index, enabled); }
+
+    /**
+     * Returns `true` if the end bone is extended to have a tail.
+     */
+    isEndBoneExtended(index: number): boolean { return _C(this, 7936, index) as boolean; }
+
+    /**
+     * Sets the end bone tail direction of the bone chain when {@link isEndBoneExtended} is `true`.
+     */
+    setEndBoneDirection(index: number, boneDirection: BoneDirection): void { _C(this, 11290, index, boneDirection); }
+
+    /**
+     * Returns the tail direction of the end bone of the bone chain when {@link isEndBoneExtended} is `true`.
+     */
+    getEndBoneDirection(index: number): BoneDirection { return _C(this, 4662, index) as BoneDirection; }
+
+    /**
+     * If `enabled` is `true`, it extracts the twist amount from the difference between the bone rest and the current bone pose.
+     * If `enabled` is `false`, it extracts the twist amount from the difference between {@link getTwistFrom} and the current bone pose. See also {@link setTwistFrom}.
+     */
+    setTwistFromRest(index: number, enabled: boolean): void { _C(this, 13161, index, enabled); }
+
+    /**
+     * Returns `true` if extracting the twist amount from the difference between the bone rest and the current bone pose.
+     */
+    isTwistFromRest(index: number): boolean { return _C(this, 8377, index) as boolean; }
+
+    /**
+     * Sets the rotation to an arbitrary state before twisting for the current bone pose to extract the twist when {@link isTwistFromRest} is `false`.
+     * In other words, by calling {@link setTwistFrom} by {@link SkeletonModifier3D.modification_processed} of a specific {@link SkeletonModifier3D}, you can extract only the twists generated by modifiers processed after that but before this {@link BoneTwistDisperser3D}.
+     */
+    setTwistFrom(index: number, from: Quaternion): void { _C(this, 13160, index, from); }
+
+    /**
+     * Returns the rotation to an arbitrary state before twisting for the current bone pose to extract the twist when {@link isTwistFromRest} is `false`.
+     */
+    getTwistFrom(index: number): Quaternion { return _C(this, 6920, index) as Quaternion; }
+
+    /**
+     * Sets whether to use automatic amount assignment or to allow manual assignment.
+     */
+    setDisperseMode(index: number, disperseMode: DisperseMode): void { _C(this, 11127, index, disperseMode); }
+
+    /**
+     * Returns whether to use automatic amount assignment or to allow manual assignment.
+     */
+    getDisperseMode(index: number): DisperseMode { return _C(this, 4516, index) as DisperseMode; }
+
+    /**
+     * Sets the position at which to divide the segment between joints for weight assignment when {@link getDisperseMode} is {@link DISPERSE_MODE_WEIGHTED}.
+     * For example, when `weightPosition` is `0.5`, if two bone segments with a length of `1.0` exist between three joints, weights are assigned to each joint from root to end at ratios of `0.5`, `1.0`, and `0.5`. Then amounts become `0.25`, `0.75`, and `1.0` respectively.
+     */
+    setWeightPosition(index: number, weightPosition: number): void { _C(this, 13368, index, weightPosition); }
+
+    /**
+     * Returns the position at which to divide the segment between joints for weight assignment when {@link getDisperseMode} is {@link DISPERSE_MODE_WEIGHTED}.
+     */
+    getWeightPosition(index: number): number { return _C(this, 7144, index) as number; }
+
+    /**
+     * Sets the damping curve when {@link getDisperseMode} is {@link DISPERSE_MODE_CUSTOM}.
+     */
+    setDampingCurve(index: number, curve: Curve): void { _C(this, 11032, index, curve); }
+
+    /**
+     * Returns the damping curve when {@link getDisperseMode} is {@link DISPERSE_MODE_CUSTOM}.
+     */
+    getDampingCurve(index: number): Curve { return _C(this, 4408, index) as Curve; }
+
+    /**
+     * Returns the bone name at `joint` in the bone chain's joint list.
+     */
+    getJointBoneName(index: number, joint: number): string { return _C(this, 5235, index, joint) as string; }
+
+    /**
+     * Returns the bone index at `joint` in the bone chain's joint list.
+     */
+    getJointBone(index: number, joint: number): number { return _C(this, 5234, index, joint) as number; }
+
+    /**
+     * Returns the twist amount at `joint` in the bone chain's joint list when {@link getDisperseMode} is {@link DISPERSE_MODE_CUSTOM}.
+     */
+    getJointTwistAmount(index: number, joint: number): number { return _C(this, 5257, index, joint) as number; }
+
+    /**
+     * Sets the twist amount at `joint` in the bone chain's joint list when {@link getDisperseMode} is {@link DISPERSE_MODE_CUSTOM}.
+     */
+    setJointTwistAmount(index: number, joint: number, twistAmount: number): void { _C(this, 11839, index, joint, twistAmount); }
+
+    /**
+     * Returns the joint count of the bone chain's joint list.
+     */
+    getJointCount(index: number): number { return _C(this, 5236, index) as number; }
+
+    /**
+     * If `true`, the solver retrieves the bone axis from the bone pose every frame.
+     * If `false`, the solver retrieves the bone axis from the bone rest and caches it.
+     */
+    get mutableBoneAxes(): boolean { return _C(this, 1541) as boolean; }
+    set mutableBoneAxes(v: boolean) { _C(this, 12112, v); }
+
+    /**
+     * The number of settings.
+     */
+    get settingCount(): number { return _C(this, 6350) as number; }
+    set settingCount(v: number) { _C(this, 12700, v); }
+
+    static readonly name = _R(154, BoneTwistDisperser3D);
+}
+
+export const DisperseMode = {
+    /**
+     * Assign amounts so that they monotonically increase from `0.0` to `1.0`, ensuring all weights are equal. For example, with five joints, the amounts would be `0.2`, `0.4`, `0.6`, `0.8`, and `1.0` starting from the root bone.
+     */
+    DISPERSE_MODE_EVEN: 0,
+    /**
+     * Assign amounts so that they monotonically increase from `0.0` to `1.0`, based on the length of the bones between joint segments. See also {@link setWeightPosition}.
+     */
+    DISPERSE_MODE_WEIGHTED: 1,
+    /**
+     * You can assign arbitrary amounts to the joint list. See also {@link setJointTwistAmount}.
+     * When {@link isEndBoneExtended} is `false`, a child of the reference bone exists solely to determine the twist axis, so its custom amount has absolutely no effect at all.
+     */
+    DISPERSE_MODE_CUSTOM: 2,
+} as const;
+
+export type DisperseMode = (typeof DisperseMode)[keyof typeof DisperseMode];
+