@pixiv/three-vrm-core 1.0.0-beta.8 → 1.0.0

package/ts3.4/types/humanoid/VRMHumanoid.d.ts

@@ -8,20 +8,58 @@ import { VRMPose } from './VRMPose';
  */
 export declare class VRMHumanoid {
     /**
-     * A {@link VRMHumanBones} that contains all the human bones of the VRM.
-     * You might want to get these bones using {@link VRMHumanoid.getBone}.
+     * Whether it copies pose from normalizedHumanBones to rawHumanBones on {@link update}.
+     * `true` by default.
+     *
+     * @default true
+     */
+    autoUpdateHumanBones: boolean;
+    /**
+     * A raw rig of the VRM.
      */
-    humanBones: VRMHumanBones;
+    private _rawHumanBones;
     /**
-     * A {@link VRMPose} that is its default state.
-     * Note that it's not compatible with {@link setPose} and {@link getPose}, since it contains non-relative values of each local transforms.
+     * A normalized rig of the VRM.
      */
-    restPose: VRMPose;
+    private _normalizedHumanBones;
+    /*
+    * @deprecated Deprecated. Use either {@link rawRestPose} or {@link normalizedRestPose} instead.
+    */
+    readonly restPose: VRMPose;
+    /*
+    * A {@link VRMPose} of its raw human bones that is its default state.
+    * Note that it's not compatible with {@link setRawPose} and {@link getRawPose}, since it contains non-relative values of each local transforms.
+    */
+    readonly rawRestPose: VRMPose;
+    /*
+    * A {@link VRMPose} of its normalized human bones that is its default state.
+    * Note that it's not compatible with {@link setNormalizedPose} and {@link getNormalizedPose}, since it contains non-relative values of each local transforms.
+    */
+    readonly normalizedRestPose: VRMPose;
+    /*
+    * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.
+    */
+    readonly humanBones: VRMHumanBones;
+    /*
+    * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.
+    */
+    readonly rawHumanBones: VRMHumanBones;
+    /*
+    * A map from {@link VRMHumanBoneName} to normalized {@link VRMHumanBone}s.
+    */
+    readonly normalizedHumanBones: VRMHumanBones;
+    /*
+    * The root of normalized {@link VRMHumanBone}s.
+    */
+    readonly normalizedHumanBonesRoot: THREE.Object3D;
     /**
      * Create a new {@link VRMHumanoid}.
-     * @param boneArray A {@link VRMHumanBones} contains all the bones of the new humanoid
+     * @param humanBones A {@link VRMHumanBones} contains all the bones of the new humanoid
+     * @param autoUpdateHumanBones Whether it copies pose from normalizedHumanBones to rawHumanBones on {@link update}. `true` by default.
      */
-    constructor(humanBones: VRMHumanBones);
+    constructor(humanBones: VRMHumanBones, options?: {
+        autoUpdateHumanBones?: boolean;
+    });
     /**
      * Copy the given {@link VRMHumanoid} into this one.
      * @param source The {@link VRMHumanoid} you want to copy
@@ -34,40 +72,111 @@ export declare class VRMHumanoid {
      */
     clone(): VRMHumanoid;
     /**
-     * Return the current absolute pose of this humanoid as a {@link VRMPose}.
-     * Note that the output result will contain initial state of the VRM and not compatible between different models.
-     * You might want to use {@link getPose} instead.
+     * @deprecated Deprecated. Use either {@link getRawAbsolutePose} or {@link getNormalizedAbsolutePose} instead.
      */
     getAbsolutePose(): VRMPose;
     /**
-     * Return the current pose of this humanoid as a {@link VRMPose}.
+     * Return the current absolute pose of this raw human bones as a {@link VRMPose}.
+     * Note that the output result will contain initial state of the VRM and not compatible between different models.
+     * You might want to use {@link getRawPose} instead.
+     */
+    getRawAbsolutePose(): VRMPose;
+    /**
+     * Return the current absolute pose of this normalized human bones as a {@link VRMPose}.
+     * Note that the output result will contain initial state of the VRM and not compatible between different models.
+     * You might want to use {@link getNormalizedPose} instead.
+     */
+    getNormalizedAbsolutePose(): VRMPose;
+    /**
+     * @deprecated Deprecated. Use either {@link getRawPose} or {@link getNormalizedPose} instead.
+     */
+    getPose(): VRMPose;
+    /**
+     * Return the current pose of raw human bones as a {@link VRMPose}.
      *
      * Each transform is a local transform relative from rest pose (T-pose).
      */
-    getPose(): VRMPose;
+    getRawPose(): VRMPose;
+    /**
+     * Return the current pose of normalized human bones as a {@link VRMPose}.
+     *
+     * Each transform is a local transform relative from rest pose (T-pose).
+     */
+    getNormalizedPose(): VRMPose;
+    /**
+     * @deprecated Deprecated. Use either {@link setRawPose} or {@link setNormalizedPose} instead.
+     */
+    setPose(poseObject: VRMPose): void;
     /**
-     * Let the humanoid do a specified pose.
+     * Let the raw human bones do a specified pose.
      *
      * Each transform have to be a local transform relative from rest pose (T-pose).
-     * You can pass what you got from {@link getPose}.
+     * You can pass what you got from {@link getRawPose}.
+     *
+     * If you are using {@link autoUpdateHumanBones}, you might want to use {@link setNormalizedPose} instead.
      *
-     * @param poseObject A [[VRMPose]] that represents a single pose
+     * @param poseObject A {@link VRMPose} that represents a single pose
      */
-    setPose(poseObject: VRMPose): void;
+    setRawPose(poseObject: VRMPose): void;
+    /**
+     * Let the normalized human bones do a specified pose.
+     *
+     * Each transform have to be a local transform relative from rest pose (T-pose).
+     * You can pass what you got from {@link getNormalizedPose}.
+     *
+     * @param poseObject A {@link VRMPose} that represents a single pose
+     */
+    setNormalizedPose(poseObject: VRMPose): void;
     /**
-     * Reset the humanoid to its rest pose.
+     * @deprecated Deprecated. Use either {@link resetRawPose} or {@link resetNormalizedPose} instead.
      */
     resetPose(): void;
     /**
-     * Return a bone bound to a specified {@link VRMHumanBoneName}, as a {@link VRMHumanBone}.
+     * Reset the raw humanoid to its rest pose.
      *
-     * @param name Name of the bone you want
+     * If you are using {@link autoUpdateHumanBones}, you might want to use {@link resetNormalizedPose} instead.
+     */
+    resetRawPose(): void;
+    /**
+     * Reset the normalized humanoid to its rest pose.
+     */
+    resetNormalizedPose(): void;
+    /**
+     * @deprecated Deprecated. Use either {@link getRawBone} or {@link getNormalizedBone} instead.
      */
     getBone(name: VRMHumanBoneName): VRMHumanBone | undefined;
     /**
-     * Return a bone bound to a specified {@link VRMHumanBoneName}, as a `THREE.Object3D`.
+     * Return a raw {@link VRMHumanBone} bound to a specified {@link VRMHumanBoneName}.
+     *
+     * @param name Name of the bone you want
+     */
+    getRawBone(name: VRMHumanBoneName): VRMHumanBone | undefined;
+    /**
+     * Return a normalized {@link VRMHumanBone} bound to a specified {@link VRMHumanBoneName}.
      *
      * @param name Name of the bone you want
      */
+    getNormalizedBone(name: VRMHumanBoneName): VRMHumanBone | undefined;
+    /**
+     * @deprecated Deprecated. Use either {@link getRawBoneNode} or {@link getNormalizedBoneNode} instead.
+     */
     getBoneNode(name: VRMHumanBoneName): THREE.Object3D | null;
+    /**
+     * Return a raw bone as a `THREE.Object3D` bound to a specified {@link VRMHumanBoneName}.
+     *
+     * @param name Name of the bone you want
+     */
+    getRawBoneNode(name: VRMHumanBoneName): THREE.Object3D | null;
+    /**
+     * Return a normalized bone as a `THREE.Object3D` bound to a specified {@link VRMHumanBoneName}.
+     *
+     * @param name Name of the bone you want
+     */
+    getNormalizedBoneNode(name: VRMHumanBoneName): THREE.Object3D | null;
+    /**
+     * Update the humanoid component.
+     *
+     * If {@link autoUpdateHumanBones} is `true`, it transfers the pose of normalized human bones to raw human bones.
+     */
+    update(): void;
 }

package/ts3.4/types/humanoid/VRMHumanoidLoaderPlugin.d.ts

@@ -1,11 +1,19 @@
-import { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';
+import { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { VRMHumanoidLoaderPluginOptions } from './VRMHumanoidLoaderPluginOptions';
 /**
  * A plugin of GLTFLoader that imports a {@link VRMHumanoid} from a VRM extension of a GLTF.
  */
 export declare class VRMHumanoidLoaderPlugin implements GLTFLoaderPlugin {
+    /**
+     * Specify an Object3D to add {@link VRMHumanoidHelper}.
+     * If not specified, helper will not be created.
+     * If `renderOrder` is set to the root, the helper will copy the same `renderOrder` .
+     */
+    helperRoot?: THREE.Object3D;
+    autoUpdateHumanBones?: boolean;
     readonly parser: GLTFParser;
     readonly name: string;
-    constructor(parser: GLTFParser);
+    constructor(parser: GLTFParser, options?: VRMHumanoidLoaderPluginOptions);
     afterRoot(gltf: GLTF): Promise<void>;
     /**
      * Import a {@link VRMHumanoid} from a VRM.

package/ts3.4/types/humanoid/VRMHumanoidLoaderPluginOptions.d.ts

@@ -0,0 +1,15 @@
+export interface VRMHumanoidLoaderPluginOptions {
+    /**
+     * Specify an Object3D to add {@link VRMHumanoidHelper}.
+     * If not specified, helper will not be created.
+     * If `renderOrder` is set to the root, helpers will copy the same `renderOrder` .
+     */
+    helperRoot?: THREE.Object3D;
+    /**
+     * Whether it copies pose from normalizedHumanBones to rawHumanBones on {@link update}.
+     * `true` by default.
+     *
+     * @default true
+     */
+    autoUpdateHumanBones?: boolean;
+}

package/ts3.4/types/humanoid/VRMHumanoidRig.d.ts

@@ -0,0 +1,31 @@
+import * as THREE from 'three';
+import { VRMHumanBoneName, VRMHumanBones } from '.';
+import { VRMRig } from './VRMRig';
+/**
+ * A class represents the normalized Rig of a VRM.
+ */
+export declare class VRMHumanoidRig extends VRMRig {
+    protected static _setupTransforms(modelRig: VRMRig): {
+        rigBones: VRMHumanBones;
+        root: THREE.Object3D;
+        parentWorldRotations: {
+            [boneName in VRMHumanBoneName]?: THREE.Quaternion;
+        };
+        boneRotations: {
+            [boneName in VRMHumanBoneName]?: THREE.Quaternion;
+        };
+    };
+    readonly original: VRMRig;
+    readonly root: THREE.Object3D;
+    protected readonly _parentWorldRotations: {
+        [boneName in VRMHumanBoneName]?: THREE.Quaternion;
+    };
+    protected readonly _boneRotations: {
+        [boneName in VRMHumanBoneName]?: THREE.Quaternion;
+    };
+    constructor(humanoid: VRMRig);
+    /**
+     * Update this humanoid rig.
+     */
+    update(): void;
+}

package/ts3.4/types/humanoid/VRMRig.d.ts

@@ -0,0 +1,62 @@
+import * as THREE from 'three';
+import { VRMHumanBone } from './VRMHumanBone';
+import { VRMHumanBones } from './VRMHumanBones';
+import { VRMHumanBoneName } from './VRMHumanBoneName';
+import { VRMPose } from './VRMPose';
+/**
+ * A class represents the Rig of a VRM.
+ */
+export declare class VRMRig {
+    /**
+     * A {@link VRMHumanBones} that contains all the human bones of the VRM.
+     * You might want to get these bones using {@link VRMHumanoid.getBone}.
+     */
+    humanBones: VRMHumanBones;
+    /**
+     * A {@link VRMPose} that is its default state.
+     * Note that it's not compatible with {@link setPose} and {@link getPose}, since it contains non-relative values of each local transforms.
+     */
+    restPose: VRMPose;
+    /**
+     * Create a new {@link VRMHumanoid}.
+     * @param humanBones A {@link VRMHumanBones} contains all the bones of the new humanoid
+     */
+    constructor(humanBones: VRMHumanBones);
+    /**
+     * Return the current absolute pose of this humanoid as a {@link VRMPose}.
+     * Note that the output result will contain initial state of the VRM and not compatible between different models.
+     * You might want to use {@link getPose} instead.
+     */
+    getAbsolutePose(): VRMPose;
+    /**
+     * Return the current pose of this humanoid as a {@link VRMPose}.
+     *
+     * Each transform is a local transform relative from rest pose (T-pose).
+     */
+    getPose(): VRMPose;
+    /**
+     * Let the humanoid do a specified pose.
+     *
+     * Each transform have to be a local transform relative from rest pose (T-pose).
+     * You can pass what you got from {@link getPose}.
+     *
+     * @param poseObject A [[VRMPose]] that represents a single pose
+     */
+    setPose(poseObject: VRMPose): void;
+    /**
+     * Reset the humanoid to its rest pose.
+     */
+    resetPose(): void;
+    /**
+     * Return a bone bound to a specified {@link VRMHumanBoneName}, as a {@link VRMHumanBone}.
+     *
+     * @param name Name of the bone you want
+     */
+    getBone(name: VRMHumanBoneName): VRMHumanBone | undefined;
+    /**
+     * Return a bone bound to a specified {@link VRMHumanBoneName}, as a `THREE.Object3D`.
+     *
+     * @param name Name of the bone you want
+     */
+    getBoneNode(name: VRMHumanBoneName): THREE.Object3D | null;
+}

package/ts3.4/types/humanoid/helpers/VRMHumanoidHelper.d.ts

@@ -0,0 +1,9 @@
+import * as THREE from 'three';
+import { VRMHumanoid } from '../VRMHumanoid';
+export declare class VRMHumanoidHelper extends THREE.Group {
+    readonly vrmHumanoid: VRMHumanoid;
+    private _boneAxesMap;
+    constructor(humanoid: VRMHumanoid);
+    dispose(): void;
+    updateMatrixWorld(force: boolean): void;
+}

package/ts3.4/types/humanoid/helpers/index.d.ts

@@ -0,0 +1 @@
+export { VRMHumanoidHelper } from './VRMHumanoidHelper';

package/ts3.4/types/humanoid/index.d.ts

@@ -1,8 +1,12 @@
+export * from './helpers';
 export { VRMHumanBone } from './VRMHumanBone';
+export { VRMHumanBoneList } from './VRMHumanBoneList';
 export { VRMHumanBoneName } from './VRMHumanBoneName';
+export { VRMHumanBoneParentMap } from './VRMHumanBoneParentMap';
 export { VRMHumanBones } from './VRMHumanBones';
 export { VRMHumanoid } from './VRMHumanoid';
 export { VRMHumanoidLoaderPlugin } from './VRMHumanoidLoaderPlugin';
+export { VRMHumanoidLoaderPluginOptions } from './VRMHumanoidLoaderPluginOptions';
 export { VRMPose } from './VRMPose';
 export { VRMPoseTransform } from './VRMPoseTransform';
 export { VRMRequiredHumanBoneName } from './VRMRequiredHumanBoneName';

package/ts3.4/types/lookAt/VRMLookAt.d.ts

@@ -20,6 +20,7 @@ export declare class VRMLookAt {
     applier: VRMLookAtApplier;
     /**
      * If this is true, the LookAt will be updated automatically by calling {@link update}, towarding the direction to the {@link target}.
+     * `true` by default.
      *
      * See also: {@link target}
      */
@@ -30,16 +31,45 @@ export declare class VRMLookAt {
      *
      * See also: {@link autoUpdate}
      */
-    target?: THREE.Object3D;
+    target?: THREE.Object3D | null;
     /**
      * The front direction of the face.
      * Intended to be used for VRM 0.0 compat (VRM 0.0 models are facing Z- instead of Z+).
      * You usually don't want to touch this.
      */
     faceFront: THREE.Vector3;
-    protected _euler: THREE.Euler;
+    /**
+     * Its current angle around Y axis, in degree.
+     */
+    protected _yaw: number;
+    /*
+    * Its current angle around Y axis, in degree.
+    
+    
+    * Its current angle around Y axis, in degree.
+    */
+    yaw: number;
+    /**
+     * Its current angle around X axis, in degree.
+     */
+    protected _pitch: number;
     /*
-    * Its current euler direction.
+    * Its current angle around X axis, in degree.
+    
+    
+    * Its current angle around X axis, in degree.
+    */
+    pitch: number;
+    /**
+     * Specifies that angles need to be applied to its [@link applier].
+     */
+    protected _needsUpdate: boolean;
+    /**
+     * World rotation of the head in its rest pose.
+     */
+    private _restHeadWorldQuaternion;
+    /*
+    * @deprecated Use {@link getEuler} instead.
     */
     readonly euler: THREE.Euler;
     /**
@@ -49,6 +79,13 @@ export declare class VRMLookAt {
      * @param applier A {@link VRMLookAtApplier}
      */
     constructor(humanoid: VRMHumanoid, applier: VRMLookAtApplier);
+    /**
+     * Get its yaw-pitch angles as an `Euler`.
+     * Does NOT consider {@link faceFront}.
+     *
+     * @param target The target euler
+     */
+    getEuler(target: THREE.Euler): THREE.Euler;
     /**
      * Copy the given {@link VRMLookAt} into this one.
      * {@link humanoid} must be same as the source one.
@@ -74,11 +111,18 @@ export declare class VRMLookAt {
      */
     getLookAtWorldPosition(target: THREE.Vector3): THREE.Vector3;
     /**
-     * Get its LookAt orientation in world coordinate.
+     * Get its head rotation in world coordinate.
+     * Does NOT consider {@link faceFront}.
      *
-     * @param target A target `THREE.Vector3`
+     * @param target A target `THREE.Quaternion`
      */
     getLookAtWorldQuaternion(target: THREE.Quaternion): THREE.Quaternion;
+    /**
+     * Get a quaternion that rotates the +Z unit vector of the humanoid Head to the {@link faceFront} direction.
+     *
+     * @param target A target `THREE.Quaternion`
+     */
+    getFaceFrontQuaternion(target: THREE.Quaternion): THREE.Quaternion;
     /**
      * Get its LookAt direction in world coordinate.
      *
@@ -89,7 +133,7 @@ export declare class VRMLookAt {
      * Set its LookAt position.
      * Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.
      *
-     * @param position A target position
+     * @param position A target position, in world space
      */
     lookAt(position: THREE.Vector3): void;
     /**
@@ -99,5 +143,4 @@ export declare class VRMLookAt {
      * @param delta deltaTime, it isn't used though. You can use the parameter if you want to use this in your own extended {@link VRMLookAt}.
      */
     update(delta: number): void;
-    protected _calcEuler(target: THREE.Euler, position: THREE.Vector3): THREE.Euler;
 }

package/ts3.4/types/lookAt/VRMLookAtApplier.d.ts

@@ -1,12 +1,18 @@
+import * as THREE from 'three';
 /**
- * This class is used by {@link VRMLookAtHead}, applies look at direction.
+ * This class is used by {@link VRMLookAt}, applies look at direction.
  * There are currently two variant of applier: {@link VRMLookAtBoneApplier} and {@link VRMLookAtExpressionApplier}.
  */
 export interface VRMLookAtApplier {
     /**
      * Apply look at direction to its associated VRM model.
      *
-     * @param euler `THREE.Euler` object that represents the look at direction
+     * @param yaw Rotation around Y axis, in degree
+     * @param pitch Rotation around X axis, in degree
+     */
+    applyYawPitch: (yaw: number, pitch: number) => void;
+    /**
+     * @deprecated Use {@link applyYawPitch} instead.
      */
     lookAt: (euler: THREE.Euler) => void;
 }

package/ts3.4/types/lookAt/VRMLookAtBoneApplier.d.ts

@@ -31,6 +31,28 @@ export declare class VRMLookAtBoneApplier implements VRMLookAtApplier {
      * A {@link VRMLookAtRangeMap} for vertical upward movement. Both eyes move downwards.
      */
     rangeMapVerticalUp: VRMLookAtRangeMap;
+    /**
+     * The front direction of the face.
+     * Intended to be used for VRM 0.0 compat (VRM 0.0 models are facing Z- instead of Z+).
+     * You usually don't want to touch this.
+     */
+    faceFront: THREE.Vector3;
+    /**
+     * The rest quaternion of LeftEye bone.
+     */
+    private _restQuatLeftEye;
+    /**
+     * The rest quaternion of RightEye bone.
+     */
+    private _restQuatRightEye;
+    /**
+     * The world-space rest quaternion of the parent of the humanoid LeftEye.
+     */
+    private _restLeftEyeParentWorldQuat;
+    /**
+     * The world-space rest quaternion of the parent of the humanoid RightEye.
+     */
+    private _restRightEyeParentWorldQuat;
     /**
      * Create a new {@link VRMLookAtBoneApplier}.
      *
@@ -44,7 +66,18 @@ export declare class VRMLookAtBoneApplier implements VRMLookAtApplier {
     /**
      * Apply the input angle to its associated VRM model.
      *
-     * @param angle An input angle
+     * @param yaw Rotation around Y axis, in degree
+     * @param pitch Rotation around X axis, in degree
+     */
+    applyYawPitch(yaw: number, pitch: number): void;
+    /**
+     * @deprecated Use {@link applyYawPitch} instead.
+     */
+    lookAt(euler: THREE.Euler): void;
+    /**
+     * Get a quaternion that rotates the world-space +Z unit vector to the {@link faceFront} direction.
+     *
+     * @param target A target `THREE.Quaternion`
      */
-    lookAt(angle: THREE.Euler): void;
+    private _getWorldFaceFrontQuat;
 }

package/ts3.4/types/lookAt/VRMLookAtExpressionApplier.d.ts

@@ -45,7 +45,12 @@ export declare class VRMLookAtExpressionApplier implements VRMLookAtApplier {
     /**
      * Apply the input angle to its associated VRM model.
      *
-     * @param angle An input angle
+     * @param yaw Rotation around Y axis, in degree
+     * @param pitch Rotation around X axis, in degree
      */
-    lookAt(angle: THREE.Euler): void;
+    applyYawPitch(yaw: number, pitch: number): void;
+    /**
+     * @deprecated Use {@link applyYawPitch} instead.
+     */
+    lookAt(euler: THREE.Euler): void;
 }

package/ts3.4/types/lookAt/VRMLookAtLoaderPlugin.d.ts

@@ -1,4 +1,4 @@
-import { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';
+import { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';
 import { VRMLookAtLoaderPluginOptions } from './VRMLookAtLoaderPluginOptions';
 /**
  * A plugin of GLTFLoader that imports a {@link VRMLookAt} from a VRM extension of a GLTF.

package/ts3.4/types/lookAt/tests/VRMLookAt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/ts3.4/types/lookAt/tests/VRMLookAtBoneApplier.test.d.ts

@@ -0,0 +1 @@
+export {};

package/ts3.4/types/lookAt/utils/calcAzimuthAltitude.d.ts

@@ -0,0 +1,16 @@
+import * as THREE from 'three';
+/**
+ * Calculate azimuth / altitude angles from a vector.
+ *
+ * This returns a difference of angles from (1, 0, 0).
+ * Azimuth represents an angle around Y axis.
+ * Altitude represents an angle around Z axis.
+ * It is rotated in intrinsic Y-Z order.
+ *
+ * @param vector The vector
+ * @returns A tuple contains two angles, `[ azimuth, altitude ]`
+ */
+export declare function calcAzimuthAltitude(vector: THREE.Vector3): [
+    /*azimuth*/ number,
+    /*altitude*/ number
+];

package/ts3.4/types/lookAt/utils/sanitizeAngle.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Make sure the angle is within -PI to PI.
+ *
+ * @example
+ * ```js
+ * sanitizeAngle(1.5 * Math.PI) // -0.5 * PI
+ * ```
+ *
+ * @param angle An input angle
+ */
+export declare function sanitizeAngle(angle: number): number;

package/ts3.4/types/lookAt/utils/tests/calcAzimuthAltitude.test.d.ts

@@ -0,0 +1 @@
+export {};

package/ts3.4/types/lookAt/utils/tests/sanitizeAngle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/ts3.4/types/meta/VRMMetaLoaderPlugin.d.ts

@@ -1,4 +1,4 @@
-import { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';
+import { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';
 import { VRMMetaLoaderPluginOptions } from './VRMMetaLoaderPluginOptions';
 /**
  * A plugin of GLTFLoader that imports a {@link VRM1Meta} from a VRM extension of a GLTF.
@@ -17,7 +17,7 @@ export declare class VRMMetaLoaderPlugin implements GLTFLoaderPlugin {
      */
     acceptLicenseUrls: string[];
     /**
-     * Whether it should accept VRM0.X meta or not.
+     * Whether it should accept VRM0.0 meta or not.
      * Note that it might load {@link VRM0Meta} instead of {@link VRM1Meta} when this is `true`.
      * `true` by default.
      */

package/ts3.4/types/meta/VRMMetaLoaderPluginOptions.d.ts

@@ -14,7 +14,7 @@ export interface VRMMetaLoaderPluginOptions {
      */
     acceptLicenseUrls?: string[];
     /**
-     * Whether it should accept VRM0.X meta or not.
+     * Whether it should accept VRM0.0 meta or not.
      * Note that it might load {@link VRM0Meta} instead of {@link VRM1Meta} when this is `true`.
      * `true` by default.
      */

package/ts3.4/types/tests/matchers/toBeCloseToQuaternion.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import * as THREE from 'three';
+export declare function toBeCloseToQuaternion(received: THREE.Quaternion, expected: THREE.Quaternion, precision?: number): jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toBeCloseToQuaternion(expected: THREE.Quaternion, precision?: number): R;
+        }
+    }
+}

package/ts3.4/types/tests/matchers/toBeCloseToVector3.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import * as THREE from 'three';
+export declare function toBeCloseToVector3(received: THREE.Vector3, expected: THREE.Vector3, precision?: number): jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toBeCloseToVector3(expected: THREE.Vector3, precision?: number): R;
+        }
+    }
+}

package/ts3.4/types/utils/gltfExtractPrimitivesFromNode.d.ts

@@ -1,4 +1,4 @@
-import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
 /**
  * Extract primitives ( `THREE.Mesh[]` ) of a node from a loaded GLTF.
  * The main purpose of this function is to distinguish primitives and children from a node that has both meshes and children.

package/ts3.4/types/utils/gltfGetAssociatedMaterialIndex.d.ts

@@ -1,5 +1,5 @@
 import * as THREE from 'three';
-import { GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';
+import { GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';
 /**
  * Get a material definition index of glTF from associated material.
  * It's basically a comat code between Three.js r133 or above and previous versions.