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

package/types/lookAt/VRMLookAt.d.ts

@@ -1,104 +1,148 @@
-import * as THREE from 'three';
-import { VRMHumanoid } from '../humanoid';
-import type { VRMLookAtApplier } from './VRMLookAtApplier';
-/**
- * A class controls eye gaze movements of a VRM.
- */
-export declare class VRMLookAt {
-    static readonly EULER_ORDER = "YXZ";
-    /**
-     * The origin of LookAt. Position offset from the head bone.
-     */
-    offsetFromHeadBone: THREE.Vector3;
-    /**
-     * Its associated {@link VRMHumanoid}.
-     */
-    readonly humanoid: VRMHumanoid;
-    /**
-     * The {@link VRMLookAtApplier} of the LookAt.
-     */
-    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}
-     */
-    autoUpdate: boolean;
-    /**
-     * The target object of the LookAt.
-     * Note that it does not make any sense if {@link autoUpdate} is disabled.
-     *
-     * See also: {@link autoUpdate}
-     */
-    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.
-     */
-    get euler(): THREE.Euler;
-    /**
-     * Create a new {@link VRMLookAt}.
-     *
-     * @param humanoid A {@link VRMHumanoid}
-     * @param applier A {@link VRMLookAtApplier}
-     */
-    constructor(humanoid: VRMHumanoid, applier: VRMLookAtApplier);
-    /**
-     * Copy the given {@link VRMLookAt} into this one.
-     * {@link humanoid} must be same as the source one.
-     * {@link applier} will reference the same instance as the source one.
-     * @param source The {@link VRMLookAt} you want to copy
-     * @returns this
-     */
-    copy(source: VRMLookAt): this;
-    /**
-     * Returns a clone of this {@link VRMLookAt}.
-     * Note that {@link humanoid} and {@link applier} will reference the same instance as this one.
-     * @returns Copied {@link VRMLookAt}
-     */
-    clone(): VRMLookAt;
-    /**
-     * Reset the lookAt direction to initial direction.
-     */
-    reset(): void;
-    /**
-     * Get its head position in world coordinate.
-     *
-     * @param target A target `THREE.Vector3`
-     */
-    getLookAtWorldPosition(target: THREE.Vector3): THREE.Vector3;
-    /**
-     * Get its LookAt orientation in world coordinate.
-     *
-     * @param target A target `THREE.Vector3`
-     */
-    getLookAtWorldQuaternion(target: THREE.Quaternion): THREE.Quaternion;
-    /**
-     * Get its LookAt direction in world coordinate.
-     *
-     * @param target A target `THREE.Vector3`
-     */
-    getLookAtWorldDirection(target: THREE.Vector3): THREE.Vector3;
-    /**
-     * Set its LookAt position.
-     * Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.
-     *
-     * @param position A target position
-     */
-    lookAt(position: THREE.Vector3): void;
-    /**
-     * Update the VRMLookAtHead.
-     * If {@link VRMLookAtHead.autoUpdate} is disabled, it will do nothing.
-     *
-     * @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;
-}
+import * as THREE from 'three';
+import { VRMHumanoid } from '../humanoid';
+import type { VRMLookAtApplier } from './VRMLookAtApplier';
+/**
+ * A class controls eye gaze movements of a VRM.
+ */
+export declare class VRMLookAt {
+    static readonly EULER_ORDER = "YXZ";
+    /**
+     * The origin of LookAt. Position offset from the head bone.
+     */
+    offsetFromHeadBone: THREE.Vector3;
+    /**
+     * Its associated {@link VRMHumanoid}.
+     */
+    readonly humanoid: VRMHumanoid;
+    /**
+     * The {@link VRMLookAtApplier} of the LookAt.
+     */
+    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}
+     */
+    autoUpdate: boolean;
+    /**
+     * The target object of the LookAt.
+     * Note that it does not make any sense if {@link autoUpdate} is disabled.
+     *
+     * See also: {@link autoUpdate}
+     */
+    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;
+    /**
+     * 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;
+    /**
+     * Create a new {@link VRMLookAt}.
+     *
+     * @param humanoid A {@link VRMHumanoid}
+     * @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.
+     * {@link applier} will reference the same instance as the source one.
+     * @param source The {@link VRMLookAt} you want to copy
+     * @returns this
+     */
+    copy(source: VRMLookAt): this;
+    /**
+     * Returns a clone of this {@link VRMLookAt}.
+     * Note that {@link humanoid} and {@link applier} will reference the same instance as this one.
+     * @returns Copied {@link VRMLookAt}
+     */
+    clone(): VRMLookAt;
+    /**
+     * Reset the lookAt direction to initial direction.
+     */
+    reset(): void;
+    /**
+     * Get its head position in world coordinate.
+     *
+     * @param target A target `THREE.Vector3`
+     */
+    getLookAtWorldPosition(target: THREE.Vector3): THREE.Vector3;
+    /**
+     * Get its head rotation in world coordinate.
+     * Does NOT consider {@link faceFront}.
+     *
+     * @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.
+     *
+     * @param target A target `THREE.Vector3`
+     */
+    getLookAtWorldDirection(target: THREE.Vector3): THREE.Vector3;
+    /**
+     * Set its LookAt position.
+     * Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.
+     *
+     * @param position A target position, in world space
+     */
+    lookAt(position: THREE.Vector3): void;
+    /**
+     * Update the VRMLookAtHead.
+     * If {@link VRMLookAtHead.autoUpdate} is disabled, it will do nothing.
+     *
+     * @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;
+}

package/types/lookAt/VRMLookAtApplier.d.ts

@@ -1,12 +1,18 @@
-/**
- * This class is used by {@link VRMLookAtHead}, 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
-     */
-    lookAt: (euler: THREE.Euler) => void;
-}
+import * as THREE from 'three';
+/**
+ * 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 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/types/lookAt/VRMLookAtBoneApplier.d.ts

@@ -1,50 +1,83 @@
-import { VRMHumanoid } from '../humanoid';
-import * as THREE from 'three';
-import type { VRMLookAtApplier } from './VRMLookAtApplier';
-import { VRMLookAtRangeMap } from './VRMLookAtRangeMap';
-/**
- * A class that applies eye gaze directions to a VRM.
- * It will be used by {@link VRMLookAt}.
- */
-export declare class VRMLookAtBoneApplier implements VRMLookAtApplier {
-    /**
-     * Represent its type of applier.
-     */
-    static readonly type = "bone";
-    /**
-     * Its associated {@link VRMHumanoid}.
-     */
-    readonly humanoid: VRMHumanoid;
-    /**
-     * A {@link VRMLookAtRangeMap} for horizontal inward movement. The left eye moves right. The right eye moves left.
-     */
-    rangeMapHorizontalInner: VRMLookAtRangeMap;
-    /**
-     * A {@link VRMLookAtRangeMap} for horizontal outward movement. The left eye moves left. The right eye moves right.
-     */
-    rangeMapHorizontalOuter: VRMLookAtRangeMap;
-    /**
-     * A {@link VRMLookAtRangeMap} for vertical downward movement. Both eyes move upwards.
-     */
-    rangeMapVerticalDown: VRMLookAtRangeMap;
-    /**
-     * A {@link VRMLookAtRangeMap} for vertical upward movement. Both eyes move downwards.
-     */
-    rangeMapVerticalUp: VRMLookAtRangeMap;
-    /**
-     * Create a new {@link VRMLookAtBoneApplier}.
-     *
-     * @param humanoid A {@link VRMHumanoid}
-     * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
-     * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
-     * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
-     * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
-     */
-    constructor(humanoid: VRMHumanoid, rangeMapHorizontalInner: VRMLookAtRangeMap, rangeMapHorizontalOuter: VRMLookAtRangeMap, rangeMapVerticalDown: VRMLookAtRangeMap, rangeMapVerticalUp: VRMLookAtRangeMap);
-    /**
-     * Apply the input angle to its associated VRM model.
-     *
-     * @param angle An input angle
-     */
-    lookAt(angle: THREE.Euler): void;
-}
+import { VRMHumanoid } from '../humanoid';
+import * as THREE from 'three';
+import type { VRMLookAtApplier } from './VRMLookAtApplier';
+import { VRMLookAtRangeMap } from './VRMLookAtRangeMap';
+/**
+ * A class that applies eye gaze directions to a VRM.
+ * It will be used by {@link VRMLookAt}.
+ */
+export declare class VRMLookAtBoneApplier implements VRMLookAtApplier {
+    /**
+     * Represent its type of applier.
+     */
+    static readonly type = "bone";
+    /**
+     * Its associated {@link VRMHumanoid}.
+     */
+    readonly humanoid: VRMHumanoid;
+    /**
+     * A {@link VRMLookAtRangeMap} for horizontal inward movement. The left eye moves right. The right eye moves left.
+     */
+    rangeMapHorizontalInner: VRMLookAtRangeMap;
+    /**
+     * A {@link VRMLookAtRangeMap} for horizontal outward movement. The left eye moves left. The right eye moves right.
+     */
+    rangeMapHorizontalOuter: VRMLookAtRangeMap;
+    /**
+     * A {@link VRMLookAtRangeMap} for vertical downward movement. Both eyes move upwards.
+     */
+    rangeMapVerticalDown: VRMLookAtRangeMap;
+    /**
+     * 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}.
+     *
+     * @param humanoid A {@link VRMHumanoid}
+     * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
+     * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
+     * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
+     * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
+     */
+    constructor(humanoid: VRMHumanoid, rangeMapHorizontalInner: VRMLookAtRangeMap, rangeMapHorizontalOuter: VRMLookAtRangeMap, rangeMapVerticalDown: VRMLookAtRangeMap, rangeMapVerticalUp: VRMLookAtRangeMap);
+    /**
+     * Apply the input angle to its associated VRM model.
+     *
+     * @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`
+     */
+    private _getWorldFaceFrontQuat;
+}

package/types/lookAt/VRMLookAtExpressionApplier.d.ts

@@ -1,51 +1,56 @@
-import { VRMExpressionManager } from '../expressions';
-import * as THREE from 'three';
-import type { VRMLookAtApplier } from './VRMLookAtApplier';
-import { VRMLookAtRangeMap } from './VRMLookAtRangeMap';
-/**
- * A class that applies eye gaze directions to a VRM.
- * It will be used by {@link VRMLookAt}.
- */
-export declare class VRMLookAtExpressionApplier implements VRMLookAtApplier {
-    /**
-     * Represent its type of applier.
-     */
-    static readonly type = "expression";
-    /**
-     * Its associated {@link VRMExpressionManager}.
-     */
-    readonly expressions: VRMExpressionManager;
-    /**
-     * It won't be used in expression applier.
-     * See also: {@link rangeMapHorizontalOuter}
-     */
-    rangeMapHorizontalInner: VRMLookAtRangeMap;
-    /**
-     * A {@link VRMLookAtRangeMap} for horizontal movement. Both eyes move left or right.
-     */
-    rangeMapHorizontalOuter: VRMLookAtRangeMap;
-    /**
-     * A {@link VRMLookAtRangeMap} for vertical downward movement. Both eyes move upwards.
-     */
-    rangeMapVerticalDown: VRMLookAtRangeMap;
-    /**
-     * A {@link VRMLookAtRangeMap} for vertical upward movement. Both eyes move downwards.
-     */
-    rangeMapVerticalUp: VRMLookAtRangeMap;
-    /**
-     * Create a new {@link VRMLookAtExpressionApplier}.
-     *
-     * @param expressions A {@link VRMExpressionManager}
-     * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
-     * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
-     * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
-     * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
-     */
-    constructor(expressions: VRMExpressionManager, rangeMapHorizontalInner: VRMLookAtRangeMap, rangeMapHorizontalOuter: VRMLookAtRangeMap, rangeMapVerticalDown: VRMLookAtRangeMap, rangeMapVerticalUp: VRMLookAtRangeMap);
-    /**
-     * Apply the input angle to its associated VRM model.
-     *
-     * @param angle An input angle
-     */
-    lookAt(angle: THREE.Euler): void;
-}
+import { VRMExpressionManager } from '../expressions';
+import * as THREE from 'three';
+import type { VRMLookAtApplier } from './VRMLookAtApplier';
+import { VRMLookAtRangeMap } from './VRMLookAtRangeMap';
+/**
+ * A class that applies eye gaze directions to a VRM.
+ * It will be used by {@link VRMLookAt}.
+ */
+export declare class VRMLookAtExpressionApplier implements VRMLookAtApplier {
+    /**
+     * Represent its type of applier.
+     */
+    static readonly type = "expression";
+    /**
+     * Its associated {@link VRMExpressionManager}.
+     */
+    readonly expressions: VRMExpressionManager;
+    /**
+     * It won't be used in expression applier.
+     * See also: {@link rangeMapHorizontalOuter}
+     */
+    rangeMapHorizontalInner: VRMLookAtRangeMap;
+    /**
+     * A {@link VRMLookAtRangeMap} for horizontal movement. Both eyes move left or right.
+     */
+    rangeMapHorizontalOuter: VRMLookAtRangeMap;
+    /**
+     * A {@link VRMLookAtRangeMap} for vertical downward movement. Both eyes move upwards.
+     */
+    rangeMapVerticalDown: VRMLookAtRangeMap;
+    /**
+     * A {@link VRMLookAtRangeMap} for vertical upward movement. Both eyes move downwards.
+     */
+    rangeMapVerticalUp: VRMLookAtRangeMap;
+    /**
+     * Create a new {@link VRMLookAtExpressionApplier}.
+     *
+     * @param expressions A {@link VRMExpressionManager}
+     * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
+     * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
+     * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
+     * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
+     */
+    constructor(expressions: VRMExpressionManager, rangeMapHorizontalInner: VRMLookAtRangeMap, rangeMapHorizontalOuter: VRMLookAtRangeMap, rangeMapVerticalDown: VRMLookAtRangeMap, rangeMapVerticalUp: VRMLookAtRangeMap);
+    /**
+     * Apply the input angle to its associated VRM model.
+     *
+     * @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/types/lookAt/VRMLookAtLoaderPlugin.d.ts

@@ -1,30 +1,30 @@
-import type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';
-import type { VRMLookAtLoaderPluginOptions } from './VRMLookAtLoaderPluginOptions';
-/**
- * A plugin of GLTFLoader that imports a {@link VRMLookAt} from a VRM extension of a GLTF.
- */
-export declare class VRMLookAtLoaderPlugin implements GLTFLoaderPlugin {
-    /**
-     * Specify an Object3D to add {@link VRMLookAtHelper} s.
-     * If not specified, helper will not be created.
-     * If `renderOrder` is set to the root, helpers will copy the same `renderOrder` .
-     */
-    helperRoot?: THREE.Object3D;
-    readonly parser: GLTFParser;
-    get name(): string;
-    constructor(parser: GLTFParser, options?: VRMLookAtLoaderPluginOptions);
-    afterRoot(gltf: GLTF): Promise<void>;
-    /**
-     * Import a {@link VRMLookAt} from a VRM.
-     *
-     * @param gltf A parsed result of GLTF taken from GLTFLoader
-     * @param humanoid A {@link VRMHumanoid} instance that represents the VRM
-     * @param expressions A {@link VRMExpressionManager} instance that represents the VRM
-     */
-    private _import;
-    private _v1Import;
-    private _v1ImportRangeMap;
-    private _v0Import;
-    private _v0ImportDegreeMap;
-    private _importLookAt;
-}
+import type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import type { VRMLookAtLoaderPluginOptions } from './VRMLookAtLoaderPluginOptions';
+/**
+ * A plugin of GLTFLoader that imports a {@link VRMLookAt} from a VRM extension of a GLTF.
+ */
+export declare class VRMLookAtLoaderPlugin implements GLTFLoaderPlugin {
+    /**
+     * Specify an Object3D to add {@link VRMLookAtHelper} s.
+     * If not specified, helper will not be created.
+     * If `renderOrder` is set to the root, helpers will copy the same `renderOrder` .
+     */
+    helperRoot?: THREE.Object3D;
+    readonly parser: GLTFParser;
+    get name(): string;
+    constructor(parser: GLTFParser, options?: VRMLookAtLoaderPluginOptions);
+    afterRoot(gltf: GLTF): Promise<void>;
+    /**
+     * Import a {@link VRMLookAt} from a VRM.
+     *
+     * @param gltf A parsed result of GLTF taken from GLTFLoader
+     * @param humanoid A {@link VRMHumanoid} instance that represents the VRM
+     * @param expressions A {@link VRMExpressionManager} instance that represents the VRM
+     */
+    private _import;
+    private _v1Import;
+    private _v1ImportRangeMap;
+    private _v0Import;
+    private _v0ImportDegreeMap;
+    private _importLookAt;
+}

package/types/lookAt/VRMLookAtLoaderPluginOptions.d.ts

@@ -1,8 +1,8 @@
-export interface VRMLookAtLoaderPluginOptions {
-    /**
-     * Specify an Object3D to add {@link VRMLookAtHelper} s.
-     * If not specified, helper will not be created.
-     * If `renderOrder` is set to the root, helpers will copy the same `renderOrder` .
-     */
-    helperRoot?: THREE.Object3D;
-}
+export interface VRMLookAtLoaderPluginOptions {
+    /**
+     * Specify an Object3D to add {@link VRMLookAtHelper} s.
+     * If not specified, helper will not be created.
+     * If `renderOrder` is set to the root, helpers will copy the same `renderOrder` .
+     */
+    helperRoot?: THREE.Object3D;
+}

package/types/lookAt/VRMLookAtRangeMap.d.ts

@@ -1,23 +1,23 @@
-export declare class VRMLookAtRangeMap {
-    /**
-     * Limits the maximum angle of the input angle of the LookAt vector from the front of the head (the positive z axis).
-     */
-    inputMaxValue: number;
-    /**
-     * Represents an angle (in degrees) for bone type of LookAt appliers, or a weight for expression type of LookAt appliers.
-     * The input value will take `1.0` when the input angle equals (or greater) to {@link inputMaxValue}.
-     */
-    outputScale: number;
-    /**
-     * Create a new {@link VRMLookAtRangeMap}.
-     *
-     * @param inputMaxValue The {@link inputMaxValue} of the map
-     * @param outputScale The {@link outputScale} of the map
-     */
-    constructor(inputMaxValue: number, outputScale: number);
-    /**
-     * Evaluate an input value and output a mapped value.
-     * @param src The input value
-     */
-    map(src: number): number;
-}
+export declare class VRMLookAtRangeMap {
+    /**
+     * Limits the maximum angle of the input angle of the LookAt vector from the front of the head (the positive z axis).
+     */
+    inputMaxValue: number;
+    /**
+     * Represents an angle (in degrees) for bone type of LookAt appliers, or a weight for expression type of LookAt appliers.
+     * The input value will take `1.0` when the input angle equals (or greater) to {@link inputMaxValue}.
+     */
+    outputScale: number;
+    /**
+     * Create a new {@link VRMLookAtRangeMap}.
+     *
+     * @param inputMaxValue The {@link inputMaxValue} of the map
+     * @param outputScale The {@link outputScale} of the map
+     */
+    constructor(inputMaxValue: number, outputScale: number);
+    /**
+     * Evaluate an input value and output a mapped value.
+     * @param src The input value
+     */
+    map(src: number): number;
+}