@drawcall/acta 0.0.0

package/dist/behavior.js

@@ -0,0 +1,458 @@
+import { AdditiveAnimationBlendMode, Euler, EventDispatcher, LoopOnce, Quaternion, Vector2, Vector3, } from 'three';
+import { action, GraphTimeline, parallel, timePassed, animationFinished, runTimeline, scope, switch_, } from '@pmndrs/timeline';
+import { applyMask, fixModelAnimationClip, lowerBody, startAnimation, upperBody, loadCharacterAnimation, WalkAnimationUrl, RunAnimationUrl, } from '@pmndrs/viverse';
+import { makeClipAdditive } from 'three/src/animation/AnimationUtils.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { VRM } from '@pixiv/three-vrm';
+import { clamp } from 'three/src/math/MathUtils.js';
+const ZeroVector = new Vector3();
+const ForwardVector = new Vector3(0, 0, 1);
+const UpVector = new Vector3(0, 1, 0);
+const SpineAimYawOffset = -0.5;
+const quaternionHelper = new Quaternion();
+const parentQuaternionInvHelper = new Quaternion();
+const localQuaternionHelper = new Quaternion();
+const eulerHelper = new Euler();
+const directionHelper = new Vector3();
+const vectorHelper = new Vector3();
+//TODO: support direction AND position targets for head and aim
+//TODO: lerp everything (spine rotation etc)
+//TODO: jumping support
+export class CharacterBehavior extends EventDispatcher {
+    model;
+    applyMove;
+    properties = {};
+    computedProperties = {
+        isMoving: () => this.worldMoveVelocity.length() > 0,
+    };
+    // Direction and movement properties
+    worldHeadDirection;
+    worldAimDirection;
+    worldMoveVelocity = new Vector3(0, 0, 0);
+    abortController = new AbortController();
+    updateTimeline;
+    aimUpAnimation;
+    aimNeutralAnimation;
+    aimDownAnimation;
+    walkAnimation;
+    runAnimation;
+    jogRightAnimation;
+    jogLeftAnimation;
+    jogFwdRightAnimation;
+    jogFwdAnimation;
+    jogFwdLeftAnimation;
+    jogBwdRightAnimation;
+    jogBwdAnimation;
+    jogBwdLeftAnimation;
+    animations = {};
+    audios = {};
+    gltfLoader;
+    moveStatus = 'none';
+    isAiming = false;
+    constructor(behavior, animationUrls, audioUrls, model, applyMove, loadingManager) {
+        super();
+        this.model = model;
+        this.applyMove = applyMove;
+        if (model instanceof VRM) {
+            throw new Error(`not supported yet`);
+        }
+        this.gltfLoader = new GLTFLoader(loadingManager);
+        this.init(behavior, animationUrls, audioUrls).catch(console.error);
+    }
+    async init(behavior, animationUrls, audioUrls) {
+        await Promise.all([
+            this.loadMoveAnimations(),
+            this.loadBaseAimAnimation(),
+            ...Object.entries(animationUrls).map(([name, url]) => this.loadAnimation(name, url)),
+            ...Object.entries(audioUrls).map(([name, url]) => this.loadAudio(name, url)),
+        ]);
+        const timeline = this.convertToTimeline(behavior);
+        this.updateTimeline = runTimeline(timeline, this.abortController.signal);
+    }
+    async loadMoveAnimations() {
+        const [walkAnimation, runAnimation, jogRightAnimation, jogLeftAnimation, jogFwdRightAnimation, jogFwdAnimation, jogFwdLeftAnimation, jogBwdRightAnimation, jogBwdAnimation, jogBwdLeftAnimation,] = await Promise.all([
+            await loadCharacterAnimation(this.model, WalkAnimationUrl),
+            await loadCharacterAnimation(this.model, RunAnimationUrl),
+            await loadCharacterAnimation(this.model, (await import('./animations/Jog_Right.js')).default, 'gltf'),
+            await loadCharacterAnimation(this.model, (await import('./animations/Jog_Left.js')).default, 'gltf'),
+            await loadCharacterAnimation(this.model, (await import('./animations/Jog_Fwd_R.js')).default, 'gltf'),
+            await loadCharacterAnimation(this.model, (await import('./animations/Jog_Fwd.js')).default, 'gltf'),
+            await loadCharacterAnimation(this.model, (await import('./animations/Jog_Fwd_L.js')).default, 'gltf'),
+            await loadCharacterAnimation(this.model, (await import('./animations/Jog_Bwd_R.js')).default, 'gltf'),
+            await loadCharacterAnimation(this.model, (await import('./animations/Jog_Bwd.js')).default, 'gltf'),
+            await loadCharacterAnimation(this.model, (await import('./animations/Jog_Bwd_L.js')).default, 'gltf'),
+        ]);
+        this.walkAnimation = walkAnimation;
+        this.runAnimation = runAnimation;
+        //apply masks because jogging is only used for the lower body
+        applyMask(jogRightAnimation, lowerBody);
+        applyMask(jogLeftAnimation, lowerBody);
+        applyMask(jogFwdRightAnimation, lowerBody);
+        applyMask(jogFwdAnimation, lowerBody);
+        applyMask(jogFwdLeftAnimation, lowerBody);
+        applyMask(jogBwdRightAnimation, lowerBody);
+        applyMask(jogBwdAnimation, lowerBody);
+        applyMask(jogBwdLeftAnimation, lowerBody);
+        this.jogRightAnimation = jogRightAnimation;
+        this.jogLeftAnimation = jogLeftAnimation;
+        this.jogFwdRightAnimation = jogFwdRightAnimation;
+        this.jogFwdAnimation = jogFwdAnimation;
+        this.jogFwdLeftAnimation = jogFwdLeftAnimation;
+        this.jogBwdRightAnimation = jogBwdRightAnimation;
+        this.jogBwdAnimation = jogBwdAnimation;
+        this.jogBwdLeftAnimation = jogBwdLeftAnimation;
+    }
+    async loadBaseAimAnimation() {
+        //TODO: load only if necassary
+        const [aimUpAnimation, aimNeutralAnimation, aimDownAnimation] = await Promise.all([
+            loadCharacterAnimation(this.model, (await import('./animations/Pistol_Aim_Up.js')).default, 'gltf'),
+            loadCharacterAnimation(this.model, (await import('./animations/Pistol_Aim_Neutral.js')).default, 'gltf'),
+            loadCharacterAnimation(this.model, (await import('./animations/Pistol_Aim_Down.js')).default, 'gltf'),
+        ]);
+        this.aimUpAnimation = aimUpAnimation;
+        this.aimNeutralAnimation = aimNeutralAnimation;
+        this.aimDownAnimation = aimDownAnimation;
+    }
+    async loadAnimation(name, url) {
+        const gltf = await this.gltfLoader.loadAsync(url);
+        if (gltf.animations.length != 1) {
+            throw new Error(`gltf contains has more than 1 animation`);
+        }
+        fixModelAnimationClip(this.model, gltf.animations[0], gltf.scene, false);
+        this.animations[name] = gltf.animations[0];
+    }
+    async loadAudio(name, url) { }
+    update(delta) {
+        if (this.moveStatus === 'fullbody' && this.worldMoveVelocity.lengthSq() > 0) {
+            // Signed angle from forward (0,0,1) to move direction on XZ plane
+            this.model.scene.rotation.y = Math.PI + Math.atan2(this.worldMoveVelocity.x, this.worldMoveVelocity.z);
+        }
+        else if (this.worldAimDirection != null && this.isAiming) {
+            this.model.scene.rotation.y = Math.PI + Math.atan2(this.worldAimDirection.x, this.worldAimDirection.z);
+        }
+        else if (this.worldHeadDirection != null) {
+            this.model.scene.rotation.y = Math.PI + Math.atan2(this.worldHeadDirection.x, this.worldHeadDirection.z);
+        }
+        this.updateTimeline?.(undefined, delta);
+        this.model.mixer.update(delta);
+        // Stabilize spine during aiming to face the aim direction
+        if (this.isAiming) {
+            const spineBone = this.model.scene.getObjectByName('spine');
+            // Extract yaw from aim direction and add PI offset for model facing
+            const aimYaw = this.model.scene.rotation.y + Math.PI + SpineAimYawOffset;
+            // Create quaternion with just the yaw (no pitch/roll)
+            eulerHelper.set(0, aimYaw, 0, 'YXZ');
+            quaternionHelper.setFromEuler(eulerHelper);
+            // Transform to spine's local space
+            spineBone.parent.getWorldQuaternion(parentQuaternionInvHelper).invert();
+            localQuaternionHelper.copy(parentQuaternionInvHelper).multiply(quaternionHelper);
+            spineBone.quaternion.copy(localQuaternionHelper);
+            spineBone.updateMatrixWorld();
+        }
+        if (this.worldHeadDirection != null) {
+            const neckBone = this.model.scene.getObjectByName('neck');
+            // Transform worldHeadDirection to neck's parent local space
+            neckBone.parent.getWorldQuaternion(quaternionHelper).invert();
+            directionHelper.copy(this.worldHeadDirection).applyQuaternion(quaternionHelper);
+            // Compute the local rotation that aligns (0,0,1) with the local target direction
+            quaternionHelper.setFromUnitVectors(ForwardVector, directionHelper);
+            neckBone.rotation.setFromQuaternion(quaternionHelper, 'YXZ');
+            neckBone.rotation.z = 0;
+            neckBone.rotation.y = clamp(neckBone.rotation.y, -Math.PI / 2, Math.PI / 2);
+            neckBone.rotation.x = clamp(neckBone.rotation.x, -Math.PI / 2, Math.PI / 2);
+        }
+        this.applyMove?.(this.moveStatus === 'none' ? ZeroVector : this.worldMoveVelocity, delta);
+    }
+    destroy() {
+        this.abortController.abort();
+    }
+    convertToTimeline(behavior, mask) {
+        if (behavior.type === 'animation' && behavior.name === 'Move') {
+            return this.createMoveTimeline(mask);
+        }
+        switch (behavior.type) {
+            case 'animation':
+                return this.createAnimationTimeline(behavior.name, mask);
+            case 'audio':
+                throw new Error('not implemented');
+            case 'graph':
+                return this.createGraphTimeline(behavior, mask);
+            case 'loop':
+                return this.createLoopTimeline(behavior.behavior, mask);
+            case 'parallel':
+                return () => parallel('race', ...behavior.behaviors.map((b) => this.convertToTimeline(b, mask)));
+            case 'sequential':
+                return this.createSequentialTimeline(behavior.behaviors, mask);
+            case 'split':
+                return () => parallel('race', this.convertToTimeline(behavior.lowerBodyBehavior, 'lowerbody'), this.convertToTimeline(behavior.upperBodyBehavior, 'upperbody'));
+            case 'wait':
+                return () => action({ until: timePassed(behavior.seconds, 'seconds') });
+        }
+    }
+    createMoveTimeline(mask) {
+        const layer = computeAnimationLayers(mask);
+        if (mask == null) {
+            //fullbody (just animate between walk and run)
+            const walkAction = this.model.mixer.clipAction(this.walkAnimation);
+            const runAction = this.model.mixer.clipAction(this.runAnimation);
+            const self = this;
+            const vectorHelper = new Vector2();
+            return () => parallel('all', action({
+                update: () => {
+                    vectorHelper.set(this.worldMoveVelocity.x, -this.worldMoveVelocity.z);
+                    const speed = vectorHelper.length();
+                    walkAction.timeScale = 0.667 * speed;
+                    runAction.timeScale = 0.208 * speed;
+                },
+            }), scope(async function* (abortSignal) {
+                self.moveStatus = 'fullbody';
+                self.dispatchEvent({ type: 'animationStarted', name: 'Move' });
+                abortSignal.addEventListener('abort', () => {
+                    self.moveStatus = 'none';
+                    self.dispatchEvent({ type: 'animationFinished', name: 'Move' });
+                }, { once: true });
+                yield* switch_([
+                    {
+                        timeline: () => action({ init: () => startAnimation(walkAction, self.model.currentAnimations, { layer }) }),
+                        condition: () => vectorHelper.length() < 4.5,
+                    },
+                    {
+                        timeline: () => action({ init: () => startAnimation(runAction, self.model.currentAnimations, { layer }) }),
+                    },
+                ]);
+            }));
+        }
+        //only lower body (computing angle between world torso direction and world velocity)
+        const jogRightAction = this.model.mixer.clipAction(this.jogRightAnimation);
+        const jogLeftAction = this.model.mixer.clipAction(this.jogLeftAnimation);
+        const jogFwdRightAction = this.model.mixer.clipAction(this.jogFwdRightAnimation);
+        const jogFwdAction = this.model.mixer.clipAction(this.jogFwdAnimation);
+        const jogFwdLeftAction = this.model.mixer.clipAction(this.jogFwdLeftAnimation);
+        const jogBwdRightAction = this.model.mixer.clipAction(this.jogBwdRightAnimation);
+        const jogBwdAction = this.model.mixer.clipAction(this.jogBwdAnimation);
+        const jogBwdLeftAction = this.model.mixer.clipAction(this.jogBwdLeftAnimation);
+        const normalizedLocalMoveDirection = new Vector2();
+        const self = this;
+        return () => parallel('all', action({
+            update: () => {
+                // Transform world velocity to model's local space by rotating by inverse of model's Y rotation
+                vectorHelper.copy(this.worldMoveVelocity).applyAxisAngle(UpVector, -this.model.scene.rotation.y);
+                const speed = normalizedLocalMoveDirection.set(vectorHelper.x, -vectorHelper.z).length();
+                normalizedLocalMoveDirection.divideScalar(speed);
+                jogFwdAction.timeScale = 0.222 * speed;
+                jogFwdRightAction.timeScale = 0.222 * speed;
+                jogRightAction.timeScale = 0.37 * speed;
+                jogBwdRightAction.timeScale = 0.256 * speed;
+                jogBwdAction.timeScale = 0.238 * speed;
+                jogBwdLeftAction.timeScale = 0.256 * speed;
+                jogLeftAction.timeScale = 0.37 * speed;
+                jogFwdLeftAction.timeScale = 0.222 * speed;
+            },
+        }), scope(async function* (abortSignal) {
+            self.moveStatus = 'lowerbody';
+            self.dispatchEvent({ type: 'animationStarted', name: 'Move' });
+            abortSignal.addEventListener('abort', () => {
+                self.moveStatus = 'none';
+                self.dispatchEvent({ type: 'animationFinished', name: 'Move' });
+            }, { once: true });
+            yield* switch_([
+                {
+                    timeline: () => action({
+                        init: () => startAnimation(jogFwdAction, self.model.currentAnimations, { layer, sync: true }),
+                    }),
+                    condition: () => Math.abs(normalizedLocalMoveDirection.x) < 0.5 && normalizedLocalMoveDirection.y > 0.5,
+                },
+                {
+                    timeline: () => action({
+                        init: () => startAnimation(jogFwdRightAction, self.model.currentAnimations, { layer, sync: true }),
+                    }),
+                    condition: () => normalizedLocalMoveDirection.x > 0.5 && normalizedLocalMoveDirection.y > 0.5,
+                },
+                {
+                    timeline: () => action({
+                        init: () => startAnimation(jogRightAction, self.model.currentAnimations, { layer, sync: true }),
+                    }),
+                    condition: () => normalizedLocalMoveDirection.x > 0.5 && Math.abs(normalizedLocalMoveDirection.y) < 0.5,
+                },
+                {
+                    timeline: () => action({
+                        init: () => startAnimation(jogBwdRightAction, self.model.currentAnimations, { layer, sync: true }),
+                    }),
+                    condition: () => normalizedLocalMoveDirection.x > 0.5 && normalizedLocalMoveDirection.y < -0.5,
+                },
+                {
+                    timeline: () => action({
+                        init: () => startAnimation(jogBwdAction, self.model.currentAnimations, { layer, sync: true }),
+                    }),
+                    condition: () => Math.abs(normalizedLocalMoveDirection.x) < 0.5 && normalizedLocalMoveDirection.y < -0.5,
+                },
+                {
+                    timeline: () => action({
+                        init: () => startAnimation(jogBwdLeftAction, self.model.currentAnimations, { layer, sync: true }),
+                    }),
+                    condition: () => normalizedLocalMoveDirection.x < -0.5 && normalizedLocalMoveDirection.y < -0.5,
+                },
+                {
+                    timeline: () => action({
+                        init: () => startAnimation(jogLeftAction, self.model.currentAnimations, { layer, sync: true }),
+                    }),
+                    condition: () => normalizedLocalMoveDirection.x < -0.5 && Math.abs(normalizedLocalMoveDirection.y) < 0.5,
+                },
+                {
+                    timeline: () => action({
+                        init: () => startAnimation(jogFwdLeftAction, self.model.currentAnimations, { layer, sync: true }),
+                    }),
+                },
+            ]);
+        }));
+    }
+    createAnimationTimeline(name, mask) {
+        let animationClip = this.animations[name];
+        if (mask != null) {
+            animationClip = animationClip.clone();
+            applyMask(animationClip, mask === 'lowerbody' ? lowerBody : upperBody);
+        }
+        if (name.includes('Pistol_')) {
+            return this.createAdditiveAimingTimeline(animationClip, mask, name);
+        }
+        return this.createStandardAnimationTimeline(animationClip, mask, name);
+    }
+    createStandardAnimationTimeline(clip, mask, name) {
+        const animationAction = this.model.mixer.clipAction(clip);
+        animationAction.loop = LoopOnce;
+        animationAction.clampWhenFinished = true;
+        const layer = computeAnimationLayers(mask);
+        const self = this;
+        return async function* () {
+            if (name)
+                self.dispatchEvent({ type: 'animationStarted', name });
+            try {
+                yield* action({
+                    init: () => startAnimation(animationAction, self.model.currentAnimations, { layer }),
+                    until: animationFinished(animationAction),
+                });
+            }
+            finally {
+                if (name)
+                    self.dispatchEvent({ type: 'animationFinished', name });
+            }
+        };
+    }
+    createAdditiveAimingTimeline(clip, mask, name) {
+        let aimUpAnimation = this.aimUpAnimation;
+        let aimNeutralAnimation = this.aimNeutralAnimation;
+        let aimDownAnimation = this.aimDownAnimation;
+        if (mask != null) {
+            aimUpAnimation = aimUpAnimation.clone();
+            aimNeutralAnimation = aimNeutralAnimation.clone();
+            aimDownAnimation = aimDownAnimation.clone();
+            const maskFn = mask === 'lowerbody' ? lowerBody : upperBody;
+            applyMask(aimUpAnimation, maskFn);
+            applyMask(aimNeutralAnimation, maskFn);
+            applyMask(aimDownAnimation, maskFn);
+        }
+        clip = clip.clone();
+        makeClipAdditive(clip, undefined, aimNeutralAnimation);
+        const additiveAction = this.model.mixer.clipAction(clip);
+        additiveAction.loop = LoopOnce;
+        additiveAction.blendMode = AdditiveAnimationBlendMode;
+        additiveAction.clampWhenFinished = true;
+        const aimUpAcion = this.model.mixer.clipAction(aimUpAnimation);
+        const aimNeutralAction = this.model.mixer.clipAction(aimNeutralAnimation);
+        const aimDownAction = this.model.mixer.clipAction(aimDownAnimation);
+        const layer = computeAnimationLayers(mask, false);
+        const self = this;
+        return async function* () {
+            if (name)
+                self.dispatchEvent({ type: 'animationStarted', name });
+            self.isAiming = true;
+            try {
+                yield* action({
+                    init: () => {
+                        startAnimation(aimUpAcion, self.model.currentAnimations, { layer: 'aim-up' });
+                        startAnimation(aimNeutralAction, self.model.currentAnimations, { layer });
+                        startAnimation(aimDownAction, self.model.currentAnimations, { layer: 'adim-down' });
+                        startAnimation(additiveAction, self.model.currentAnimations, { layer: 'aim' });
+                    },
+                    update: () => {
+                        const pitch = self.worldAimDirection ? -Math.asin(self.worldAimDirection.y) : 0;
+                        if (pitch <= 0) {
+                            // looking up
+                            aimUpAcion.weight = Math.min(1, Math.max(0, -pitch / (Math.PI / 2)));
+                            aimNeutralAction.weight = 1 - aimUpAcion.weight;
+                            aimDownAction.weight = 0;
+                        }
+                        else if (pitch > 0) {
+                            // looking down
+                            aimDownAction.weight = Math.min(1, Math.max(0, pitch / (Math.PI / 2)));
+                            aimNeutralAction.weight = 1 - aimDownAction.weight;
+                            aimUpAcion.weight = 0;
+                        }
+                    },
+                    until: animationFinished(additiveAction),
+                });
+            }
+            finally {
+                self.isAiming = false;
+                if (name)
+                    self.dispatchEvent({ type: 'animationFinished', name });
+            }
+        };
+    }
+    createGraphTimeline(behavior, mask) {
+        const graph = new GraphTimeline(behavior.enterState, undefined, behavior.exitState, undefined, true);
+        for (const name in behavior.states) {
+            const state = behavior.states[name];
+            const transitionsTo = {};
+            if (state.finally != null) {
+                transitionsTo.finally = state.finally;
+            }
+            for (const targetState in state.transitionsTo) {
+                const condition = state.transitionsTo[targetState];
+                transitionsTo[targetState] = {
+                    whenUpdate: () => evaluateCondition(condition, this.properties, this.computedProperties),
+                };
+            }
+            graph.attach(name, this.convertToTimeline(state.behavior, mask), transitionsTo);
+        }
+        return () => graph.run();
+    }
+    createLoopTimeline(behavior, mask) {
+        const subTimeline = this.convertToTimeline(behavior, mask);
+        return async function* () {
+            while (true) {
+                yield* subTimeline();
+            }
+        };
+    }
+    createSequentialTimeline(behaviors, mask) {
+        const subTimelines = behaviors.map((b) => this.convertToTimeline(b, mask));
+        return async function* () {
+            for (const timeline of subTimelines) {
+                yield* timeline();
+            }
+        };
+    }
+}
+function computeAnimationLayers(mask, includeAim = true) {
+    const result = [];
+    if (mask !== 'lowerbody')
+        result.push('upperbody');
+    if (mask !== 'lowerbody' && includeAim)
+        result.push('aim', 'aim-up', 'aim-down');
+    if (mask !== 'upperbody')
+        result.push('lowerbody');
+    return result;
+}
+function evaluateCondition(condition, properties, computedProperties) {
+    switch (condition.type) {
+        case 'isTrue':
+            return computedProperties[condition.property]?.() ?? properties[condition.property] ?? false;
+        case 'and':
+            return condition.conditions.every((c) => evaluateCondition(c, properties, computedProperties));
+        case 'or':
+            return condition.conditions.some((c) => evaluateCondition(c, properties, computedProperties));
+        case 'not':
+            return !evaluateCondition(condition.condition, properties, computedProperties);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './behavior.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './behavior.js';

package/dist/types.d.ts

@@ -0,0 +1,52 @@
+export type Condition = {
+    type: 'isTrue';
+    property: string;
+} | {
+    type: 'not';
+    condition: Condition;
+} | {
+    type: 'or';
+    conditions: Condition[];
+} | {
+    type: 'and';
+    conditions: Condition[];
+};
+export type Behavior = {
+    type: 'animation';
+    name: string;
+} | {
+    type: 'audio';
+    name: string;
+} | {
+    type: 'wait';
+    seconds: number;
+} | {
+    type: 'split';
+    upperBodyBehavior: Behavior;
+    lowerBodyBehavior: Behavior;
+} | {
+    type: 'sequential';
+    behaviors: Behavior[];
+} | {
+    type: 'parallel';
+    behaviors: Behavior[];
+} | {
+    type: 'loop';
+    behavior: Behavior;
+} | {
+    type: 'graph';
+    enterState: string;
+    exitState?: string;
+    states: Record<string, {
+        behavior: Behavior;
+        /**
+         *  name of the state to transition to when the behavior finishes.
+         */
+        finally?: string;
+        /**
+         * Transitions are evaluated continuously during the state's behavior execution.
+         * If a condition is met, the current behavior is cancelled immediately and the transition occurs.
+         */
+        transitionsTo?: Record<string, Condition>;
+    }>;
+};

package/dist/types.js

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

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@drawcall/acta",
+  "type": "module",
+  "main": "dist/index.js",
+  "version": "0.0.0",
+  "author": "Bela Bohlender",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://drawcall.ai",
+  "keywords": [
+    "drawcall.ai"
+  ],
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@pixiv/three-vrm": "3.4.4",
+    "@pmndrs/timeline": "^0.3.7",
+    "@pmndrs/viverse": "^0.2.10"
+  },
+  "peerDependencies": {
+    "three": "*"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}