Add AnimatorController loader for AniamtorController Editor (#1078)

* feat: add AnimatorController loader  for AniamtorController Editor

packages/core/src/asset/AssetType.ts

@@ -25,8 +25,10 @@ export enum AssetType {
   Material = "material",
   /** Mesh. */
   Mesh = "mesh",
-  /** Animation Clip. */
-  AnimationClip = "animation-clip",
+  /** AnimationClip. */
+  AnimationClip = "AnimationClip",
+  /** AnimatorController. */
+  AnimatorController = "AnimatorController",
   /** Prefab.*/
   Prefab = "prefab",
   /** Compress Texture. */

packages/loader/src/AnimatorControllerLoader.ts

@@ -0,0 +1,87 @@
+import {
+  resourceLoader,
+  Loader,
+  AssetPromise,
+  AssetType,
+  LoadItem,
+  ResourceManager,
+  AnimatorController,
+  AnimatorControllerLayer,
+  AnimatorStateMachine,
+  AnimatorStateTransition
+} from "@oasis-engine/core";
+
+@resourceLoader(AssetType.AnimatorController, ["json"], false)
+class AnimatorControllerLoader extends Loader<AnimatorController> {
+  load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<AnimatorController> {
+    return new AssetPromise((resolve, reject) => {
+      this.request<any>(item.url, {
+        ...item,
+        type: "json"
+      }).then(async (data) => {
+        const animatorController = new AnimatorController();
+        const { layers } = data;
+        const promises = [];
+        layers.forEach((layerData, layerIndex: number) => {
+          const { name, blendingMode, weight, stateMachine: stateMachineData } = layerData;
+          const layer = new AnimatorControllerLayer(name);
+          layer.blendingMode = blendingMode;
+          layer.weight = weight;
+          if (stateMachineData) {
+            const { states } = stateMachineData;
+            const stateMachine = (layer.stateMachine = new AnimatorStateMachine());
+            states.forEach((stateData, stateIndex: number) => {
+              const {
+                name,
+                speed,
+                wrapMode,
+                clipStartNormalizedTime,
+                clipEndNormalizedTime,
+                isDefaultState,
+                clip: clipData
+              } = stateData;
+              const state = stateMachine.addState(name);
+              state.speed = speed;
+              state.wrapMode = wrapMode;
+              state.clipStartTime = clipStartNormalizedTime;
+              state.clipEndTime = clipEndNormalizedTime;
+              if (clipData) {
+                promises.push(
+                  new Promise(async (resolve) => {
+                    resolve({
+                      layerIndex,
+                      stateIndex,
+                      clip: await resourceManager.getResourceByRef(clipData)
+                    });
+                  })
+                );
+              }
+            });
+            states.forEach((stateData) => {
+              const { name, transitions } = stateData;
+              transitions.forEach((transitionData) => {
+                const { targetStateName, duration, offset, exitTime } = transitionData;
+                const sourceState = stateMachine.findStateByName(name);
+                const destState = stateMachine.findStateByName(targetStateName);
+                const transition = new AnimatorStateTransition();
+                transition.destinationState = destState;
+                transition.duration = duration;
+                transition.exitTime = exitTime;
+                transition.offset = offset;
+                sourceState.addTransition(transition);
+              });
+            });
+          }
+          animatorController.addLayer(layer);
+        });
+        Promise.all(promises).then((clipData) => {
+          clipData.forEach((data) => {
+            const { layerIndex, stateIndex, clip } = data;
+            animatorController.layers[layerIndex].stateMachine.states[stateIndex].clip = clip;
+          });
+          resolve(animatorController);
+        });
+      });
+    });
+  }
+}

packages/loader/src/index.ts

@@ -12,8 +12,9 @@ import "./HDRLoader";
 import "./gltf/extensions/index";
 import "./MaterialLoader";
 import "./MeshLoader";
+import "./AnimatorControllerLoader";
 
 export * from "./resource-deserialize";
 export { GLTFResource } from "./gltf/GLTFResource";
 export * from "./SceneLoader";
-export { parseSingleKTX } from "./compressed-texture";
+export { parseSingleKTX } from "./compressed-texture";

packages/loader/src/resource-deserialize/index.ts

@@ -9,7 +9,6 @@ export { ReflectionParser } from "./resources/prefab/ReflectionParser";
 export { PrefabParser } from "./resources/prefab/PrefabParser";
 export type { IModelMesh } from "./resources/mesh/IModelMesh";
 export type { IAnimationClipAsset } from "./resources/animationClip/type";
-export type { IAnimatorControllerAsset } from "./resources/animatorController/type";
 
 /**
  * Decode engine binary resource.

packages/loader/src/resource-deserialize/resources/prefab/ReflectionParser.ts

@@ -19,7 +19,11 @@ export class ReflectionParser {
       for (let i = 0; i < entityConfig.components.length; i++) {
         const componentConfig = entityConfig.components[i];
         const key = !componentConfig.refId ? componentConfig.class : componentConfig.refId;
-        const component = entity.addComponent(Loader.getClass(key));
+        let component;
+        if (key === "Animator") {
+          component = entity.getComponent(Loader.getClass(key));
+        }
+        component = component || entity.addComponent(Loader.getClass(key));
         const promise = this.parsePropsAndMethods(component, componentConfig, engine);
         promises.push(promise);
       }