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

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

@@ -0,0 +1 @@
+export declare function renameMaterialProperty(name: string): string;

package/types/VRMCore.d.ts

@@ -14,13 +14,18 @@ export declare class VRMCore {
      * `THREE.Group` that contains the entire VRM.
      */
     readonly scene: THREE.Group;
+    /**
+     * Contains meta fields of the VRM.
+     * You might want to refer these license fields before use your VRMs.
+     */
+    readonly meta: VRMMeta;
     /**
      * Contains {@link VRMHumanoid} of the VRM.
-     * You can control each bones using {@link VRMHumanoid.getBoneNode}.
+     * You can control each bones using {@link VRMHumanoid.getNormalizedBoneNode} or {@link VRMHumanoid.getRawBoneNode}.
      *
      * @TODO Add a link to VRM spec
      */
-    readonly humanoid?: VRMHumanoid;
+    readonly humanoid: VRMHumanoid;
     /**
      * Contains {@link VRMExpressionManager} of the VRM.
      * You might want to control these facial expressions via {@link VRMExpressionManager.setValue}.
@@ -36,11 +41,6 @@ export declare class VRMCore {
      * You might want to use {@link VRMLookAt.target} to control the eye direction of your VRMs.
      */
     readonly lookAt?: VRMLookAt;
-    /**
-     * Contains meta fields of the VRM.
-     * You might want to refer these license fields before use your VRMs.
-     */
-    readonly meta?: VRMMeta;
     /**
      * Create a new VRM instance.
      *

package/types/VRMCoreLoaderPlugin.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 { VRMCoreLoaderPluginOptions } from './VRMCoreLoaderPluginOptions';
 import { VRMExpressionLoaderPlugin } from './expressions/VRMExpressionLoaderPlugin';
 import { VRMFirstPersonLoaderPlugin } from './firstPerson/VRMFirstPersonLoaderPlugin';

package/types/VRMCoreLoaderPluginOptions.d.ts

@@ -15,4 +15,5 @@ export interface VRMCoreLoaderPluginOptions {
      * Will be overwritten if you use custom loader plugins for each components.
      */
     helperRoot?: THREE.Object3D;
+    autoUpdateHumanBones?: boolean;
 }

package/types/VRMCoreParameters.d.ts

@@ -8,9 +8,9 @@ import type { VRMMeta } from './meta/VRMMeta';
  */
 export interface VRMCoreParameters {
     scene: THREE.Group;
-    humanoid?: VRMHumanoid;
+    meta: VRMMeta;
+    humanoid: VRMHumanoid;
     expressionManager?: VRMExpressionManager;
     firstPerson?: VRMFirstPerson;
     lookAt?: VRMLookAt;
-    meta?: VRMMeta;
 }

package/types/expressions/VRMExpression.d.ts

@@ -12,7 +12,7 @@ export declare class VRMExpression extends THREE.Object3D {
      */
     weight: number;
     /**
-     * Interpret non-zero values as 1.
+     * Interpret values greater than 0.5 as 1.0, ortherwise 0.0.
      */
     isBinary: boolean;
     /**

package/types/expressions/VRMExpressionLoaderPlugin.d.ts

@@ -1,5 +1,5 @@
 import type * as V0VRM from '@pixiv/types-vrm-0.0';
-import { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';
+import { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';
 import { VRMExpressionPresetName } from './VRMExpressionPresetName';
 /**
  * A plugin of GLTFLoader that imports a {@link VRMExpressionManager} from a VRM extension of a GLTF.

package/types/expressions/VRMExpressionMaterialColorBind.d.ts

@@ -5,6 +5,9 @@ import type { VRMExpressionMaterialColorType } from './VRMExpressionMaterialColo
  * A bind of expression influences to a material color.
  */
 export declare class VRMExpressionMaterialColorBind implements VRMExpressionBind {
+    /**
+     * Mapping of property names from VRMC/materialColorBinds.type to three.js/Material.
+     */
     private static _propertyNameMapMap;
     /**
      * The target material.

package/types/expressions/VRMExpressionMaterialColorType.d.ts

@@ -2,7 +2,11 @@ export declare const VRMExpressionMaterialColorType: {
     readonly Color: "color";
     readonly EmissionColor: "emissionColor";
     readonly ShadeColor: "shadeColor";
+    readonly MatcapColor: "matcapColor";
     readonly RimColor: "rimColor";
     readonly OutlineColor: "outlineColor";
 };
 export declare type VRMExpressionMaterialColorType = typeof VRMExpressionMaterialColorType[keyof typeof VRMExpressionMaterialColorType];
+export declare const v0ExpressionMaterialColorMap: {
+    [key: string]: VRMExpressionMaterialColorType | undefined;
+};

package/types/firstPerson/VRMFirstPersonLoaderPlugin.d.ts

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

package/types/humanoid/VRMHumanBoneList.d.ts

@@ -0,0 +1,5 @@
+import { VRMHumanBoneName } from './VRMHumanBoneName';
+/**
+ * The list of {@link VRMHumanBoneName}. Dependency aware.
+ */
+export declare const VRMHumanBoneList: VRMHumanBoneName[];

package/types/humanoid/VRMHumanBoneName.d.ts

@@ -1,3 +1,8 @@
+/**
+ * The names of {@link VRMHumanoid} bone names.
+ *
+ * Ref: https://github.com/vrm-c/vrm-specification/blob/master/specification/VRMC_vrm-1.0/humanoid.md
+ */
 export declare const VRMHumanBoneName: {
     readonly Hips: "hips";
     readonly Spine: "spine";
@@ -24,8 +29,8 @@ export declare const VRMHumanBoneName: {
     readonly RightUpperArm: "rightUpperArm";
     readonly RightLowerArm: "rightLowerArm";
     readonly RightHand: "rightHand";
+    readonly LeftThumbMetacarpal: "leftThumbMetacarpal";
     readonly LeftThumbProximal: "leftThumbProximal";
-    readonly LeftThumbIntermediate: "leftThumbIntermediate";
     readonly LeftThumbDistal: "leftThumbDistal";
     readonly LeftIndexProximal: "leftIndexProximal";
     readonly LeftIndexIntermediate: "leftIndexIntermediate";
@@ -39,8 +44,8 @@ export declare const VRMHumanBoneName: {
     readonly LeftLittleProximal: "leftLittleProximal";
     readonly LeftLittleIntermediate: "leftLittleIntermediate";
     readonly LeftLittleDistal: "leftLittleDistal";
+    readonly RightThumbMetacarpal: "rightThumbMetacarpal";
     readonly RightThumbProximal: "rightThumbProximal";
-    readonly RightThumbIntermediate: "rightThumbIntermediate";
     readonly RightThumbDistal: "rightThumbDistal";
     readonly RightIndexProximal: "rightIndexProximal";
     readonly RightIndexIntermediate: "rightIndexIntermediate";

package/types/humanoid/VRMHumanBoneParentMap.d.ts

@@ -0,0 +1,9 @@
+import { VRMHumanBoneName } from './VRMHumanBoneName';
+/**
+ * An object that maps from {@link VRMHumanBoneName} to its parent {@link VRMHumanBoneName}.
+ *
+ * Ref: https://github.com/vrm-c/vrm-specification/blob/master/specification/VRMC_vrm-1.0/humanoid.md
+ */
+export declare const VRMHumanBoneParentMap: {
+    [bone in VRMHumanBoneName]: VRMHumanBoneName | null;
+};

package/types/humanoid/VRMHumanoid.d.ts

@@ -8,20 +8,58 @@ import type { 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.
+     */
+    private _rawHumanBones;
+    /**
+     * A normalized rig of the VRM.
+     */
+    private _normalizedHumanBones;
+    /**
+     * @deprecated Deprecated. Use either {@link rawRestPose} or {@link normalizedRestPose} instead.
+     */
+    get 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.
+     */
+    get 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.
+     */
+    get normalizedRestPose(): VRMPose;
+    /**
+     * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.
+     */
+    get humanBones(): VRMHumanBones;
+    /**
+     * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.
+     */
+    get rawHumanBones(): VRMHumanBones;
+    /**
+     * A map from {@link VRMHumanBoneName} to normalized {@link VRMHumanBone}s.
      */
-    humanBones: VRMHumanBones;
+    get normalizedHumanBones(): 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.
+     * The root of normalized {@link VRMHumanBone}s.
      */
-    restPose: VRMPose;
+    get 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;
     /**
-     * Let the humanoid do a specified pose.
+     * @deprecated Deprecated. Use either {@link setRawPose} or {@link setNormalizedPose} instead.
+     */
+    setPose(poseObject: VRMPose): void;
+    /**
+     * 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/types/humanoid/VRMHumanoidLoaderPlugin.d.ts

@@ -1,11 +1,19 @@
-import type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';
+import type { 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;
     get name(): string;
-    constructor(parser: GLTFParser);
+    constructor(parser: GLTFParser, options?: VRMHumanoidLoaderPluginOptions);
     afterRoot(gltf: GLTF): Promise<void>;
     /**
      * Import a {@link VRMHumanoid} from a VRM.

package/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/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/types/humanoid/VRMRig.d.ts

@@ -0,0 +1,62 @@
+import * as THREE from 'three';
+import type { VRMHumanBone } from './VRMHumanBone';
+import type { VRMHumanBones } from './VRMHumanBones';
+import type { VRMHumanBoneName } from './VRMHumanBoneName';
+import type { 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/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/types/humanoid/helpers/index.d.ts

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

package/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 type { VRMHumanBones } from './VRMHumanBones';
 export { VRMHumanoid } from './VRMHumanoid';
 export { VRMHumanoidLoaderPlugin } from './VRMHumanoidLoaderPlugin';
+export { VRMHumanoidLoaderPluginOptions } from './VRMHumanoidLoaderPluginOptions';
 export type { VRMPose } from './VRMPose';
 export type { VRMPoseTransform } from './VRMPoseTransform';
 export { VRMRequiredHumanBoneName } from './VRMRequiredHumanBoneName';

package/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,47 @@ 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 euler direction.
+     * Its current angle around Y axis, in degree.
+     */
+    protected _yaw: number;
+    /**
+     * Its current angle around Y axis, in degree.
+     */
+    get yaw(): number;
+    /**
+     * Its current angle around Y axis, in degree.
+     */
+    set yaw(value: number);
+    /**
+     * Its current angle around X axis, in degree.
+     */
+    protected _pitch: number;
+    /**
+     * Its current angle around X axis, in degree.
+     */
+    get pitch(): number;
+    /**
+     * Its current angle around X axis, in degree.
+     */
+    set pitch(value: 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.
      */
     get euler(): THREE.Euler;
     /**
@@ -49,6 +81,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 +113,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 +135,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 +145,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/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;
 }