@pixiv/three-vrm-core 2.1.0-beta.3 → 2.1.0

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

@@ -0,0 +1,149 @@
+import * as THREE from 'three';
+import { VRMHumanoid } from '../humanoid';
+import { 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.
+    
+    
+    * Its current angle around Y axis, in degree.
+    */
+    yaw: number;
+    /**
+     * Its current angle around X axis, in degree.
+     */
+    protected _pitch: number;
+    /*
+    * 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;
+    /**
+     * 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}; it returns `Euler(0, 0, 0; "YXZ")` by default regardless of the faceFront value.
+     *
+     * @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 (yaw and pitch) to the initial direction.
+     */
+    reset(): void;
+    /**
+     * Get its lookAt position in world coordinate.
+     *
+     * @param target A target `THREE.Vector3`
+     */
+    getLookAtWorldPosition(target: THREE.Vector3): THREE.Vector3;
+    /**
+     * Get its lookAt 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 target position.
+     *
+     * Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.
+     *
+     * If you want to track an object continuously, you might want to use {@link target} instead.
+     *
+     * @param position A target position, in world space
+     */
+    lookAt(position: THREE.Vector3): void;
+    /**
+     * Update the VRMLookAtHead.
+     * If {@link autoUpdate} is enabled, this will make it look at the {@link target}.
+     *
+     * @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/ts3.4/types/lookAt/VRMLookAtApplier.d.ts

@@ -0,0 +1,18 @@
+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/ts3.4/types/lookAt/VRMLookAtBoneApplier.d.ts

@@ -0,0 +1,83 @@
+import { VRMHumanoid } from '../humanoid';
+import * as THREE from 'three';
+import { 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/ts3.4/types/lookAt/VRMLookAtExpressionApplier.d.ts

@@ -0,0 +1,56 @@
+import { VRMExpressionManager } from '../expressions';
+import * as THREE from 'three';
+import { 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/ts3.4/types/lookAt/VRMLookAtLoaderPlugin.d.ts

@@ -0,0 +1,30 @@
+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.
+ */
+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;
+    readonly 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/ts3.4/types/lookAt/VRMLookAtLoaderPluginOptions.d.ts

@@ -0,0 +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;
+}

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

@@ -0,0 +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;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Represents a type of applier.
+ */
+export declare const VRMLookAtTypeName: {
+    Bone: string;
+    Expression: string;
+};
+export type VRMLookAtTypeName = typeof VRMLookAtTypeName[keyof typeof VRMLookAtTypeName];

package/ts3.4/types/lookAt/helpers/VRMLookAtHelper.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import { VRMLookAt } from '../VRMLookAt';
+export declare class VRMLookAtHelper extends THREE.Group {
+    readonly vrmLookAt: VRMLookAt;
+    private readonly _meshYaw;
+    private readonly _meshPitch;
+    private readonly _lineTarget;
+    constructor(lookAt: VRMLookAt);
+    dispose(): void;
+    updateMatrixWorld(force: boolean): void;
+}

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

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

package/ts3.4/types/lookAt/helpers/utils/FanBufferGeometry.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from 'three';
+export declare class FanBufferGeometry extends THREE.BufferGeometry {
+    theta: number;
+    radius: number;
+    private _currentTheta;
+    private _currentRadius;
+    private readonly _attrPos;
+    private readonly _attrIndex;
+    constructor();
+    update(): void;
+    private _buildPosition;
+    private _buildIndex;
+}

package/ts3.4/types/lookAt/helpers/utils/LineAndSphereBufferGeometry.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from 'three';
+export declare class LineAndSphereBufferGeometry extends THREE.BufferGeometry {
+    radius: number;
+    tail: THREE.Vector3;
+    private _currentRadius;
+    private _currentTail;
+    private readonly _attrPos;
+    private readonly _attrIndex;
+    constructor();
+    update(): void;
+    private _buildPosition;
+    private _buildIndex;
+}

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

@@ -0,0 +1,8 @@
+export * from './helpers';
+export { VRMLookAt } from './VRMLookAt';
+export { VRMLookAtApplier } from './VRMLookAtApplier';
+export { VRMLookAtBoneApplier } from './VRMLookAtBoneApplier';
+export { VRMLookAtExpressionApplier } from './VRMLookAtExpressionApplier';
+export { VRMLookAtLoaderPlugin } from './VRMLookAtLoaderPlugin';
+export { VRMLookAtRangeMap } from './VRMLookAtRangeMap';
+export { VRMLookAtTypeName } from './VRMLookAtTypeName';

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/VRM0Meta.d.ts

@@ -0,0 +1,62 @@
+import * as THREE from 'three';
+/**
+ * Interface represents metadata of a VRM 0.0 model.
+ */
+export interface VRM0Meta {
+    /**
+     * The version of meta.
+     */
+    metaVersion: '0';
+    /**
+     * Enum indicates a condition who can perform with this avatar.
+     */
+    allowedUserName?: 'Everyone' | 'ExplicitlyLicensedPerson' | 'OnlyAuthor';
+    /**
+     * Author of the model.
+     */
+    author?: string;
+    /**
+     * Enum indicates allow or disallow commercial use.
+     */
+    commercialUssageName?: 'Allow' | 'Disallow';
+    /**
+     * Contact Information of its author.
+     */
+    contactInformation?: string;
+    /**
+     * Enum indicates a license type.
+     */
+    licenseName?: 'CC0' | 'CC_BY' | 'CC_BY_NC' | 'CC_BY_NC_ND' | 'CC_BY_NC_SA' | 'CC_BY_ND' | 'CC_BY_SA' | 'Other' | 'Redistribution_Prohibited';
+    /**
+     * If `Other` is selected for {@link licenseName}, put the URL link of the license document here.
+     */
+    otherLicenseUrl?: string;
+    /**
+     * If there are any conditions not mentioned in {@link licenseName} or {@link otherLicenseUrl}, put the URL link of the license document here.
+     */
+    otherPermissionUrl?: string;
+    /**
+     * Reference of the model.
+     */
+    reference?: string;
+    /**
+     * Enum indicates allow or disallow sexual expressions.
+     */
+    sexualUssageName?: 'Allow' | 'Disallow';
+    /**
+     * Thumbnail of the model.
+     */
+    texture?: THREE.Texture;
+    /**
+     * Title of the model.
+     */
+    title?: string;
+    /**
+     * Version of the model.
+     */
+    version?: string;
+    /**
+     * Enum indicates allow or disallow violent expressions.
+     */
+    violentUssageName?: 'Allow' | 'Disallow';
+}

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

@@ -0,0 +1,86 @@
+/**
+ * Interface represents metadata of a VRM 1.0 model.
+ */
+export interface VRM1Meta {
+    /**
+     * The version of meta.
+     */
+    metaVersion: '1';
+    /**
+     * The name of the model.
+     */
+    name: string;
+    /**
+     * The version of the model.
+     */
+    version?: string;
+    /**
+     * Authors of the model.
+     */
+    authors: string[];
+    /**
+     * An information that describes the copyright of the model.
+     */
+    copyrightInformation?: string;
+    /**
+     * An information that describes the contact information of the author.
+     */
+    contactInformation?: string;
+    /**
+     * References / original works of the model.
+     */
+    references?: string[];
+    /**
+     * Third party licenses of the model, if required. You can use line breaks.
+     */
+    thirdPartyLicenses?: string;
+    /**
+     * An image of the thumbnail image of the model.
+     * This is for the application to use as an icon.
+     */
+    thumbnailImage?: HTMLImageElement;
+    /**
+     * A URL towards the license document this model refers to
+     */
+    licenseUrl: string;
+    /**
+     * A person who can perform as an avatar with this model.
+     */
+    avatarPermission?: 'onlyAuthor' | 'onlySeparatelyLicensedPerson' | 'everyone';
+    /**
+     * A flag that permits to use this model in excessively violent contents.
+     */
+    allowExcessivelyViolentUsage?: boolean;
+    /**
+     * A flag that permits to use this model in excessively sexual contents.
+     */
+    allowExcessivelySexualUsage?: boolean;
+    /**
+     * An option that permits to use this model in commercial products.
+     */
+    commercialUsage?: 'personalNonProfit' | 'personalProfit' | 'corporation';
+    /**
+     * A flag that permits to use this model in political or religious contents.
+     */
+    allowPoliticalOrReligiousUsage?: boolean;
+    /**
+     * A flag that permits to use this model in contents contain anti-social activities or hate speeches.
+     */
+    allowAntisocialOrHateUsage?: boolean;
+    /**
+     * An option that forces or abandons to display the credit of this model.
+     */
+    creditNotation?: 'required' | 'unnecessary';
+    /**
+     * A flag that permits to redistribute this model.
+     */
+    allowRedistribution?: boolean;
+    /**
+     * An option that controls the condition to modify this model.
+     */
+    modification?: 'prohibited' | 'allowModification' | 'allowModificationRedistribution';
+    /**
+     * Describe the URL links of other license.
+     */
+    otherLicenseUrl?: string;
+}

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

@@ -0,0 +1,6 @@
+import { VRM0Meta } from './VRM0Meta';
+import { VRM1Meta } from './VRM1Meta';
+/**
+ * VRMMeta can be either {@link VRM0Meta} or {@link VRM1Meta}.
+ */
+export type VRMMeta = VRM0Meta | VRM1Meta;

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

@@ -0,0 +1,32 @@
+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.
+ */
+export declare class VRMMetaLoaderPlugin implements GLTFLoaderPlugin {
+    readonly parser: GLTFParser;
+    /**
+     * If `false`, it won't load its thumbnail image ({@link VRM1Meta.thumbnailImage}).
+     * `true` by default.
+     */
+    needThumbnailImage: boolean;
+    /**
+     * A list of license urls.
+     * This meta loader will accept these `licenseUrl`s.
+     * Otherwise it won't be loaded.
+     */
+    acceptLicenseUrls: string[];
+    /**
+     * 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.
+     */
+    acceptV0Meta: boolean;
+    readonly name: string;
+    constructor(parser: GLTFParser, options?: VRMMetaLoaderPluginOptions);
+    afterRoot(gltf: GLTF): Promise<void>;
+    private _import;
+    private _v1Import;
+    private _v0Import;
+    private _extractGLTFImage;
+}