@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Bones/bone.d.ts

@@ -0,0 +1,391 @@
+/**
+ * Class used to store bone information
+ * @see https://doc.babylonjs.com/how_to/how_to_use_bones_and_skeletons
+ */
+export class Bone extends Node {
+    /**
+     * Create a new bone
+     * @param name defines the bone name
+     * @param skeleton defines the parent skeleton
+     * @param parentBone defines the parent (can be null if the bone is the root)
+     * @param localMatrix defines the local matrix
+     * @param restPose defines the rest pose matrix
+     * @param baseMatrix defines the base matrix
+     * @param index defines index of the bone in the hierarchy
+     */
+    constructor(name: any, skeleton: any, parentBone?: null, localMatrix?: null, restPose?: null, baseMatrix?: null, index?: null);
+    name: any;
+    /**
+     * Gets the list of child bones
+     */
+    children: any[];
+    /** Gets the animations associated with this bone */
+    animations: any[];
+    /**
+     * @internal Internal only
+     * Set this value to map this bone to a different index in the transform matrices
+     * Set this value to -1 to exclude the bone from the transform matrices
+     */
+    _index: any;
+    _absoluteTransform: Matrix;
+    _invertedAbsoluteTransform: Matrix;
+    _scalingDeterminant: number;
+    _worldTransform: Matrix;
+    _needToDecompose: boolean;
+    _needToCompose: boolean;
+    /** @internal */
+    _linkedTransformNode: any;
+    /** @internal */
+    _waitingTransformNodeId: any;
+    _skeleton: any;
+    _localMatrix: any;
+    _restPose: any;
+    _baseMatrix: any;
+    /** @internal */
+    set _matrix(arg: any);
+    /** @internal */
+    get _matrix(): any;
+    /**
+     * Gets the parent skeleton
+     * @returns a skeleton
+     */
+    getSkeleton(): any;
+    /**
+     * Gets parent bone
+     * @returns a bone or null if the bone is the root of the bone hierarchy
+     */
+    getParent(): import("@babylonjs/core").Nullable<Node>;
+    /**
+     * Returns an array containing the root bones
+     * @returns an array containing the root bones
+     */
+    getChildren(): any[];
+    /**
+     * Gets the node index in matrix array generated for rendering
+     * @returns the node index
+     */
+    getIndex(): any;
+    /**
+     * Sets the parent bone
+     * @param parent defines the parent (can be null if the bone is the root)
+     * @param updateDifferenceMatrix defines if the difference matrix must be updated
+     */
+    setParent(parent: any, updateDifferenceMatrix?: boolean): void;
+    /**
+     * Gets the local matrix
+     * @returns a matrix
+     */
+    getLocalMatrix(): any;
+    /**
+     * Gets the base matrix (initial matrix which remains unchanged)
+     * @returns the base matrix (as known as bind pose matrix)
+     */
+    getBaseMatrix(): any;
+    /**
+     * Gets the rest pose matrix
+     * @returns a matrix
+     */
+    getRestPose(): any;
+    /**
+     * Sets the rest pose matrix
+     * @param matrix the local-space rest pose to set for this bone
+     */
+    setRestPose(matrix: any): void;
+    /**
+     * Gets the bind pose matrix
+     * @returns the bind pose matrix
+     * @deprecated Please use getBaseMatrix instead
+     */
+    getBindPose(): any;
+    /**
+     * Sets the bind pose matrix
+     * @param matrix the local-space bind pose to set for this bone
+     * @deprecated Please use updateMatrix instead
+     */
+    setBindPose(matrix: any): void;
+    /**
+     * Sets the local matrix to rest pose matrix
+     */
+    returnToRest(): void;
+    /**
+     * Gets the inverse of the absolute transform matrix.
+     * This matrix will be multiplied by local matrix to get the difference matrix (ie. the difference between original state and current state)
+     * @returns a matrix
+     */
+    getInvertedAbsoluteTransform(): Matrix;
+    /**
+     * Gets the absolute transform matrix (ie base matrix * parent world matrix)
+     * @returns a matrix
+     */
+    getAbsoluteTransform(): Matrix;
+    /**
+     * Links with the given transform node.
+     * The local matrix of this bone is copied from the transform node every frame.
+     * @param transformNode defines the transform node to link to
+     */
+    linkTransformNode(transformNode: any): void;
+    /**
+     * Gets the node used to drive the bone's transformation
+     * @returns a transform node or null
+     */
+    getTransformNode(): any;
+    set position(arg: Vector3 | undefined);
+    /** Gets or sets current position (in local space) */
+    get position(): Vector3 | undefined;
+    set rotation(arg: Vector3);
+    /** Gets or sets current rotation (in local space) */
+    get rotation(): Vector3;
+    set rotationQuaternion(arg: Quaternion | undefined);
+    /** Gets or sets current rotation quaternion (in local space) */
+    get rotationQuaternion(): Quaternion | undefined;
+    set scaling(arg: Vector3 | undefined);
+    /** Gets or sets current scaling (in local space) */
+    get scaling(): Vector3 | undefined;
+    /**
+     * Gets the animation properties override
+     */
+    get animationPropertiesOverride(): any;
+    _decompose(): void;
+    _localScaling: Vector3 | undefined;
+    _localRotation: Quaternion | undefined;
+    _localPosition: Vector3 | undefined;
+    _compose(): void;
+    /**
+     * Update the base and local matrices
+     * @param matrix defines the new base or local matrix
+     * @param updateDifferenceMatrix defines if the difference matrix must be updated
+     * @param updateLocalMatrix defines if the local matrix should be updated
+     */
+    updateMatrix(matrix: any, updateDifferenceMatrix?: boolean, updateLocalMatrix?: boolean): void;
+    /**
+     * @internal
+     */
+    _updateDifferenceMatrix(rootMatrix: any, updateChildren?: boolean): void;
+    /**
+     * Flag the bone as dirty (Forcing it to update everything)
+     * @returns this bone
+     */
+    markAsDirty(): Bone;
+    /** @internal */
+    _markAsDirtyAndCompose(): void;
+    _markAsDirtyAndDecompose(): void;
+    /**
+     * Translate the bone in local or world space
+     * @param vec The amount to translate the bone
+     * @param space The space that the translation is in
+     * @param tNode The TransformNode that this bone is attached to. This is only used in world space
+     */
+    translate(vec: any, space: Space | undefined, tNode: any): void;
+    /**
+     * Set the position of the bone in local or world space
+     * @param position The position to set the bone
+     * @param space The space that the position is in
+     * @param tNode The TransformNode that this bone is attached to.  This is only used in world space
+     */
+    setPosition(position: any, space: Space | undefined, tNode: any): void;
+    /**
+     * Set the absolute position of the bone (world space)
+     * @param position The position to set the bone
+     * @param tNode The TransformNode that this bone is attached to
+     */
+    setAbsolutePosition(position: any, tNode: any): void;
+    /**
+     * Scale the bone on the x, y and z axes (in local space)
+     * @param x The amount to scale the bone on the x axis
+     * @param y The amount to scale the bone on the y axis
+     * @param z The amount to scale the bone on the z axis
+     * @param scaleChildren sets this to true if children of the bone should be scaled as well (false by default)
+     */
+    scale(x: any, y: any, z: any, scaleChildren?: boolean): void;
+    /**
+     * Set the bone scaling in local space
+     * @param scale defines the scaling vector
+     */
+    setScale(scale: any): void;
+    /**
+     * Gets the current scaling in local space
+     * @returns the current scaling vector
+     */
+    getScale(): Vector3 | undefined;
+    /**
+     * Gets the current scaling in local space and stores it in a target vector
+     * @param result defines the target vector
+     */
+    getScaleToRef(result: any): void;
+    /**
+     * Set the yaw, pitch, and roll of the bone in local or world space
+     * @param yaw The rotation of the bone on the y axis
+     * @param pitch The rotation of the bone on the x axis
+     * @param roll The rotation of the bone on the z axis
+     * @param space The space that the axes of rotation are in
+     * @param tNode The TransformNode that this bone is attached to.  This is only used in world space
+     */
+    setYawPitchRoll(yaw: any, pitch: any, roll: any, space: Space | undefined, tNode: any): void;
+    /**
+     * Add a rotation to the bone on an axis in local or world space
+     * @param axis The axis to rotate the bone on
+     * @param amount The amount to rotate the bone
+     * @param space The space that the axis is in
+     * @param tNode The TransformNode that this bone is attached to. This is only used in world space
+     */
+    rotate(axis: any, amount: any, space: Space | undefined, tNode: any): void;
+    /**
+     * Set the rotation of the bone to a particular axis angle in local or world space
+     * @param axis The axis to rotate the bone on
+     * @param angle The angle that the bone should be rotated to
+     * @param space The space that the axis is in
+     * @param tNode The TransformNode that this bone is attached to.  This is only used in world space
+     */
+    setAxisAngle(axis: any, angle: any, space: Space | undefined, tNode: any): void;
+    /**
+     * Set the euler rotation of the bone in local or world space
+     * @param rotation The euler rotation that the bone should be set to
+     * @param space The space that the rotation is in
+     * @param tNode The TransformNode that this bone is attached to. This is only used in world space
+     */
+    setRotation(rotation: any, space: Space | undefined, tNode: any): void;
+    /**
+     * Set the quaternion rotation of the bone in local or world space
+     * @param quat The quaternion rotation that the bone should be set to
+     * @param space The space that the rotation is in
+     * @param tNode The TransformNode that this bone is attached to. This is only used in world space
+     */
+    setRotationQuaternion(quat: any, space: Space | undefined, tNode: any): void;
+    /**
+     * Set the rotation matrix of the bone in local or world space
+     * @param rotMat The rotation matrix that the bone should be set to
+     * @param space The space that the rotation is in
+     * @param tNode The TransformNode that this bone is attached to. This is only used in world space
+     */
+    setRotationMatrix(rotMat: any, space: Space | undefined, tNode: any): void;
+    _rotateWithMatrix(rmat: any, space: Space | undefined, tNode: any): void;
+    _getNegativeRotationToRef(rotMatInv: any, tNode: any): boolean;
+    /**
+     * Get the position of the bone in local or world space
+     * @param space The space that the returned position is in
+     * @param tNode The TransformNode that this bone is attached to. This is only used in world space
+     * @returns The position of the bone
+     */
+    getPosition(space?: Space, tNode?: null): Vector3;
+    /**
+     * Copy the position of the bone to a vector3 in local or world space
+     * @param space The space that the returned position is in
+     * @param tNode The TransformNode that this bone is attached to. This is only used in world space
+     * @param result The vector3 to copy the position to
+     */
+    getPositionToRef(space: Space | undefined, tNode: any, result: any): void;
+    /**
+     * Get the absolute position of the bone (world space)
+     * @param tNode The TransformNode that this bone is attached to
+     * @returns The absolute position of the bone
+     */
+    getAbsolutePosition(tNode?: null): Vector3;
+    /**
+     * Copy the absolute position of the bone (world space) to the result param
+     * @param tNode The TransformNode that this bone is attached to
+     * @param result The vector3 to copy the absolute position to
+     */
+    getAbsolutePositionToRef(tNode: any, result: any): void;
+    /**
+     * Compute the absolute transforms of this bone and its children
+     */
+    computeAbsoluteTransforms(): void;
+    /**
+     * Get the world direction from an axis that is in the local space of the bone
+     * @param localAxis The local direction that is used to compute the world direction
+     * @param tNode The TransformNode that this bone is attached to
+     * @returns The world direction
+     */
+    getDirection(localAxis: any, tNode?: null): Vector3;
+    /**
+     * Copy the world direction to a vector3 from an axis that is in the local space of the bone
+     * @param localAxis The local direction that is used to compute the world direction
+     * @param tNode The TransformNode that this bone is attached to
+     * @param result The vector3 that the world direction will be copied to
+     */
+    getDirectionToRef(localAxis: any, tNode: null | undefined, result: any): void;
+    /**
+     * Get the euler rotation of the bone in local or world space
+     * @param space The space that the rotation should be in
+     * @param tNode The TransformNode that this bone is attached to.  This is only used in world space
+     * @returns The euler rotation
+     */
+    getRotation(space?: Space, tNode?: null): Vector3;
+    /**
+     * Copy the euler rotation of the bone to a vector3.  The rotation can be in either local or world space
+     * @param space The space that the rotation should be in
+     * @param tNode The TransformNode that this bone is attached to.  This is only used in world space
+     * @param result The vector3 that the rotation should be copied to
+     */
+    getRotationToRef(space: Space | undefined, tNode: null | undefined, result: any): void;
+    /**
+     * Get the quaternion rotation of the bone in either local or world space
+     * @param space The space that the rotation should be in
+     * @param tNode The TransformNode that this bone is attached to.  This is only used in world space
+     * @returns The quaternion rotation
+     */
+    getRotationQuaternion(space?: Space, tNode?: null): Quaternion;
+    /**
+     * Copy the quaternion rotation of the bone to a quaternion.  The rotation can be in either local or world space
+     * @param space The space that the rotation should be in
+     * @param tNode The TransformNode that this bone is attached to.  This is only used in world space
+     * @param result The quaternion that the rotation should be copied to
+     */
+    getRotationQuaternionToRef(space: Space | undefined, tNode: null | undefined, result: any): void;
+    /**
+     * Get the rotation matrix of the bone in local or world space
+     * @param space The space that the rotation should be in
+     * @param tNode The TransformNode that this bone is attached to.  This is only used in world space
+     * @returns The rotation matrix
+     */
+    getRotationMatrix(space: Space | undefined, tNode: any): Matrix;
+    /**
+     * Copy the rotation matrix of the bone to a matrix.  The rotation can be in either local or world space
+     * @param space The space that the rotation should be in
+     * @param tNode The TransformNode that this bone is attached to.  This is only used in world space
+     * @param result The quaternion that the rotation should be copied to
+     */
+    getRotationMatrixToRef(space: Space | undefined, tNode: any, result: any): void;
+    /**
+     * Get the world position of a point that is in the local space of the bone
+     * @param position The local position
+     * @param tNode The TransformNode that this bone is attached to
+     * @returns The world position
+     */
+    getAbsolutePositionFromLocal(position: any, tNode?: null): Vector3;
+    /**
+     * Get the world position of a point that is in the local space of the bone and copy it to the result param
+     * @param position The local position
+     * @param tNode The TransformNode that this bone is attached to
+     * @param result The vector3 that the world position should be copied to
+     */
+    getAbsolutePositionFromLocalToRef(position: any, tNode: null | undefined, result: any): void;
+    /**
+     * Get the local position of a point that is in world space
+     * @param position The world position
+     * @param tNode The TransformNode that this bone is attached to
+     * @returns The local position
+     */
+    getLocalPositionFromAbsolute(position: any, tNode?: null): Vector3;
+    /**
+     * Get the local position of a point that is in world space and copy it to the result param
+     * @param position The world position
+     * @param tNode The TransformNode that this bone is attached to
+     * @param result The vector3 that the local position should be copied to
+     */
+    getLocalPositionFromAbsoluteToRef(position: any, tNode: null | undefined, result: any): void;
+    /**
+     * Set the current local matrix as the restPose for this bone.
+     */
+    setCurrentPoseAsRest(): void;
+}
+export namespace Bone {
+    const _TmpVecs: Vector3[];
+    const _TmpQuat: Quaternion;
+    const _TmpMats: Matrix[];
+}
+import { Node } from "../node.js";
+import { Matrix } from "../Maths/math.vector.js";
+import { Vector3 } from "../Maths/math.vector.js";
+import { Quaternion } from "../Maths/math.vector.js";
+import { Space } from "../Maths/math.axis.js";

package/dist/types/node_modules/@babylonjs/core/Bones/boneIKController.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Class used to apply inverse kinematics to bones
+ * @see https://doc.babylonjs.com/how_to/how_to_use_bones_and_skeletons#boneikcontroller
+ */
+export class BoneIKController {
+    /**
+     * Creates a new BoneIKController
+     * @param mesh defines the TransformNode to control
+     * @param bone defines the bone to control
+     * @param options defines options to set up the controller
+     * @param options.targetMesh
+     * @param options.poleTargetMesh
+     * @param options.poleTargetBone
+     * @param options.poleTargetLocalOffset
+     * @param options.poleAngle
+     * @param options.bendAxis
+     * @param options.maxAngle
+     * @param options.slerpAmount
+     */
+    constructor(mesh: any, bone: any, options: any);
+    /**
+     * Gets or sets the target position
+     */
+    targetPosition: Vector3;
+    /**
+     * Gets or sets the pole target position
+     */
+    poleTargetPosition: Vector3;
+    /**
+     * Gets or sets the pole target local offset
+     */
+    poleTargetLocalOffset: Vector3;
+    /**
+     * Gets or sets the pole angle
+     */
+    poleAngle: any;
+    /**
+     * The amount to slerp (spherical linear interpolation) to the target.  Set this to a value between 0 and 1 (a value of 1 disables slerp)
+     */
+    slerpAmount: any;
+    _bone1Quat: Quaternion;
+    _bone1Mat: Matrix;
+    _bone2Ang: number;
+    _maxAngle: number;
+    _rightHandedSystem: boolean;
+    _bendAxis: Vector3;
+    _slerping: boolean;
+    _adjustRoll: number;
+    _bone2: any;
+    _bone1: any;
+    mesh: any;
+    _bone1Length: number | undefined;
+    _bone2Length: number | undefined;
+    set maxAngle(arg: number);
+    /**
+     * Gets or sets maximum allowed angle
+     */
+    get maxAngle(): number;
+    targetMesh: any;
+    poleTargetMesh: any;
+    poleTargetBone: any;
+    _setMaxAngle(ang: any): void;
+    _maxReach: number | undefined;
+    /**
+     * Force the controller to update the bones
+     */
+    update(): void;
+    _updateLinkedTransformRotation(bone: any): void;
+}
+export namespace BoneIKController {
+    const _TmpVecs: Vector3[];
+    const _TmpQuat: Quaternion;
+    const _TmpMats: Matrix[];
+}
+import { Vector3 } from "../Maths/math.vector.js";
+import { Quaternion } from "../Maths/math.vector.js";
+import { Matrix } from "../Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Bones/boneLookController.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Class used to make a bone look toward a point in space
+ * @see https://doc.babylonjs.com/how_to/how_to_use_bones_and_skeletons#bonelookcontroller
+ */
+export class BoneLookController {
+    /**
+     * Create a BoneLookController
+     * @param mesh the TransformNode that the bone belongs to
+     * @param bone the bone that will be looking to the target
+     * @param target the target Vector3 to look at
+     * @param options optional settings:
+     * * maxYaw: the maximum angle the bone will yaw to
+     * * minYaw: the minimum angle the bone will yaw to
+     * * maxPitch: the maximum angle the bone will pitch to
+     * * minPitch: the minimum angle the bone will yaw to
+     * * slerpAmount: set the between 0 and 1 to make the bone slerp to the target.
+     * * upAxis: the up axis of the coordinate system
+     * * upAxisSpace: the space that the up axis is in - Space.BONE, Space.LOCAL (default), or Space.WORLD.
+     * * yawAxis: set yawAxis if the bone does not yaw on the y axis
+     * * pitchAxis: set pitchAxis if the bone does not pitch on the x axis
+     * * adjustYaw: used to make an adjustment to the yaw of the bone
+     * * adjustPitch: used to make an adjustment to the pitch of the bone
+     * * adjustRoll: used to make an adjustment to the roll of the bone
+     * @param options.maxYaw
+     * @param options.minYaw
+     * @param options.maxPitch
+     * @param options.minPitch
+     * @param options.slerpAmount
+     * @param options.upAxis
+     * @param options.upAxisSpace
+     * @param options.yawAxis
+     * @param options.pitchAxis
+     * @param options.adjustYaw
+     * @param options.adjustPitch
+     * @param options.adjustRoll
+     **/
+    constructor(mesh: any, bone: any, target: any, options: any);
+    /**
+     * The up axis of the coordinate system that is used when the bone is rotated
+     */
+    upAxis: any;
+    /**
+     * The space that the up axis is in - Space.BONE, Space.LOCAL (default), or Space.WORLD
+     */
+    upAxisSpace: any;
+    /**
+     * Used to make an adjustment to the yaw of the bone
+     */
+    adjustYaw: any;
+    /**
+     * Used to make an adjustment to the pitch of the bone
+     */
+    adjustPitch: any;
+    /**
+     * Used to make an adjustment to the roll of the bone
+     */
+    adjustRoll: any;
+    /**
+     * The amount to slerp (spherical linear interpolation) to the target.  Set this to a value between 0 and 1 (a value of 1 disables slerp)
+     */
+    slerpAmount: any;
+    _boneQuat: Quaternion;
+    _slerping: boolean;
+    _firstFrameSkipped: boolean;
+    _fowardAxis: Vector3;
+    mesh: any;
+    bone: any;
+    target: any;
+    set maxYaw(arg: any);
+    /**
+     * Gets or sets the maximum yaw angle that the bone can look to
+     */
+    get maxYaw(): any;
+    set minYaw(arg: any);
+    /**
+     * Gets or sets the minimum yaw angle that the bone can look to
+     */
+    get minYaw(): any;
+    set maxPitch(arg: any);
+    /**
+     * Gets or sets the maximum pitch angle that the bone can look to
+     */
+    get maxPitch(): any;
+    set minPitch(arg: any);
+    /**
+     * Gets or sets the minimum pitch angle that the bone can look to
+     */
+    get minPitch(): any;
+    _transformYawPitch: Matrix | undefined;
+    _transformYawPitchInv: Matrix | undefined;
+    _minYaw: any;
+    _minYawSin: number | undefined;
+    _minYawCos: number | undefined;
+    _midYawConstraint: any;
+    _yawRange: number | undefined;
+    _maxYaw: any;
+    _maxYawSin: number | undefined;
+    _maxYawCos: number | undefined;
+    _minPitch: any;
+    _minPitchTan: number | undefined;
+    _maxPitch: any;
+    _maxPitchTan: number | undefined;
+    /**
+     * Update the bone to look at the target.  This should be called before the scene is rendered (use scene.registerBeforeRender())
+     */
+    update(): void;
+    _getAngleDiff(ang1: any, ang2: any): number;
+    _getAngleBetween(ang1: any, ang2: any): number;
+    _isAngleBetween(ang: any, ang1: any, ang2: any): boolean;
+    _updateLinkedTransformRotation(): void;
+}
+export namespace BoneLookController {
+    const _TmpVecs: Vector3[];
+    const _TmpQuat: Quaternion;
+    const _TmpMats: Matrix[];
+}
+import { Quaternion } from "../Maths/math.vector.js";
+import { Vector3 } from "../Maths/math.vector.js";
+import { Matrix } from "../Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Bones/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./bone.js";
+export * from "./boneIKController.js";
+export * from "./boneLookController.js";
+export * from "./skeleton.js";