@ives_xxz/framework 1.0.0

package/manager/FWAnimationManager.ts

@@ -0,0 +1,128 @@
+import { FWSkeleton } from '../animation/FWSkeleton';
+import { FWTween } from '../animation/FWTween';
+import { FWManager } from './FWManager';
+import { FWSystemDefine } from '../define/FWSystemDefine';
+import FWLog from '../log/FWLog';
+import { FWAnimationMachine } from '../machine/FWAnimationMachine';
+
+export default class FWAnimationManager extends FWManager {
+  private animationMachineMap: Map<string, FWAnimationMachine>;
+  public initialize(): void {
+    this.animationMachineMap = new Map<string, FWAnimationMachine>();
+
+    this.createAnimationMachine(FWSystemDefine.FWAnimationMachineType.TWEEN);
+    this.createAnimationMachine(FWSystemDefine.FWAnimationMachineType.SKELETON);
+    this.createAnimationMachine(FWSystemDefine.FWAnimationMachineType.ANIMATION);
+  }
+
+  /**
+   * 创建一个tween动画
+   * @param args
+   * @returns
+   */
+  createTween(args?: FW.TweenArgs) {
+    const t = new FWTween();
+    const machine = this.animationMachineMap.get(FWSystemDefine.FWAnimationMachineType.TWEEN);
+    t.animationName = args?.tag || '';
+    t.animation = cc.tween(args?.target);
+    t.timeScale(args?.timeScale || 1);
+    machine.addAnimation(t);
+    return t;
+  }
+
+  /**
+   * 创建一个skeleton动画
+   * @param skeleton
+   * @returns
+   */
+  createSkeleton(skeleton: sp.Skeleton) {
+    const s = new FWSkeleton();
+    const machine = this.animationMachineMap.get(FWSystemDefine.FWAnimationMachineType.SKELETON);
+    s.animationName = skeleton.name;
+    s.animation = skeleton;
+    machine.addAnimation(s);
+    return s;
+  }
+
+  /**
+   * 获取一个skeleton动画
+   * @param animationName
+   * @returns
+   */
+  getSkeleton(animationName: string) {
+    if (!this.animationMachineMap.has(FWSystemDefine.FWAnimationMachineType.SKELETON)) return;
+    return this.animationMachineMap
+      .get(FWSystemDefine.FWAnimationMachineType.SKELETON)
+      .getAnimation(animationName) as FWSkeleton;
+  }
+
+  /**
+   * 暂停一个skeleton动画
+   * @param animationName
+   * @returns
+   */
+  pauseSkeleton(animationName: string) {
+    if (!this.animationMachineMap.has(FWSystemDefine.FWAnimationMachineType.SKELETON)) return;
+    this.animationMachineMap.get(animationName).pause();
+  }
+
+  /**
+   * 恢复一个skeleton动画
+   * @param animationName
+   * @returns
+   */
+  resumeSkeleton(animationName: string) {
+    if (!this.animationMachineMap.has(FWSystemDefine.FWAnimationMachineType.SKELETON)) return;
+    this.animationMachineMap.get(animationName).resume();
+  }
+  /**
+   * 移除一个skeleton动画
+   * @param animationName
+   * @returns
+   */
+  removeSkeleton(animationName: string) {
+    if (!this.animationMachineMap.has(FWSystemDefine.FWAnimationMachineType.SKELETON)) return;
+    this.animationMachineMap.delete(animationName);
+  }
+
+  /**
+   * 暂停所有动画
+   */
+  pauseAll() {
+    this.animationMachineMap.forEach((v) => v.pause());
+  }
+
+  /** 恢复所有动画 */
+  resumeAll() {
+    this.animationMachineMap.forEach((v) => v.resume());
+  }
+
+  /**
+   * 创建动画机
+   * @param animationMachineName
+   * @returns
+   */
+  createAnimationMachine(animationMachineName: string) {
+    if (this.animationMachineMap.has(animationMachineName)) {
+      FWLog.warn(`已创建动画机:${animationMachineName},请勿重复注册!`);
+      return;
+    }
+    const machine = new FWAnimationMachine();
+    this.animationMachineMap.set(animationMachineName, machine);
+    return machine;
+  }
+
+  /**
+   * 移除动画机
+   * @param animationMachineName
+   * @returns
+   */
+  removeAnimationMachine(animationMachineName: string) {
+    if (!this.animationMachineMap.has(animationMachineName)) {
+      return;
+    }
+    this.animationMachineMap.delete(animationMachineName);
+  }
+
+  onDestroy(): void {}
+}

package/manager/FWAnimationManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "c2448e26-e096-4b98-83bc-f54fe3600ac8",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWAssetManager.ts

@@ -0,0 +1,349 @@
+import FWLog from '../log/FWLog';
+import { FWManager } from './FWManager';
+
+/**
+ * 资源数据
+ */
+class FWAssetData implements FW.AssetData {
+  asset: cc.Asset;
+  uuid: string;
+  user: string;
+  depend: string[];
+  reference: string[];
+  type: typeof cc.Asset;
+  dependentBundle: string;
+  loaded: boolean;
+  autoRelease: boolean;
+  refCount: number;
+}
+
+export class FWAssetManager extends FWManager implements FW.AssetManager {
+  assetsMap: Map<string, FWAssetData>;
+
+  constructor(protected readonly resMgr: FW.ResManager) {
+    super();
+  }
+
+  public async initialize(): Promise<void> {
+    this.assetsMap = new Map<string, FWAssetData>();
+  }
+
+  /**
+   * 从远程加载spine动画
+   * @param data
+   * @returns
+   */
+  async loadSpineDataFromRemote(data: {
+    img: string;
+    ske: string;
+    atlas: string;
+    bin?: boolean;
+  }): Promise<sp.SkeletonData> {
+    try {
+      return new Promise((resolve) => {
+        const bin = data.bin === undefined ? false : data.bin;
+        const img = data.img;
+        const ske = data.ske;
+        const atlas = data.atlas;
+        const type = bin ? '.bin' : '.txt';
+        cc.assetManager.loadAny(
+          [
+            { url: atlas, ext: type },
+            { url: ske, ext: type },
+          ],
+          (error, assets) => {
+            cc.assetManager.loadRemote(img, (error, texture: cc.Texture2D) => {
+              var asset = new sp.SkeletonData();
+              asset.skeletonJson = assets[1];
+              asset.atlasText = assets[0];
+              asset.textures.push(texture);
+              asset['textureNames'] = [`${img}.png`];
+              asset['_uuid'] = ske;
+              resolve(asset);
+            });
+          },
+        );
+      });
+    } catch (e) {
+      FWLog.error('从远程加载spine动画资源失败!');
+    }
+  }
+
+  /** 加载远程资源 */
+  loadRemote<T extends cc.Asset = cc.Asset>(
+    url?: string,
+    cb?: (asset: cc.Asset) => void,
+  ): Promise<T> {
+    return new Promise((resolve, reject) => {
+      cc.assetManager.loadRemote(url, { cacheEnabled: true, maxRetryCount: 0 }, (err, asset) => {
+        cb?.(asset as T);
+        resolve(asset as T);
+      });
+    });
+  }
+
+  /**
+   * 加载资源
+   * @param assetProperty
+   * @returns
+   */
+  async load(assetProperty: FW.AssetProperty): Promise<FW.AssetData> {
+    if (!assetProperty) {
+      FWLog.error(`加载资源失败,请检查参数列表:${assetProperty}!`);
+      return undefined;
+    }
+    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
+    const type = assetProperty.type;
+    const path = assetProperty.path;
+    const cb = assetProperty.cb;
+    const progress = assetProperty.progress;
+    const autoRelease = assetProperty.autoRelease;
+
+    if (!bundleName || bundleName === '') {
+      FWLog.error(`找不到bundle${bundleName},或者bundle未加载!`);
+      return undefined;
+    }
+
+    if (!path || path === '') {
+      FWLog.error(`找不到资源路径${path},请检查!`);
+      return undefined;
+    }
+
+    let bundle: cc.AssetManager.Bundle = await this.resMgr.loadBundle(bundleName);
+
+    if (!bundle) {
+      FWLog.error(`加载bundle失败,请检查!`);
+      return undefined;
+    }
+    const key = this.createAssetMapKey(assetProperty);
+
+    if (this.assetsMap.has(key)) {
+      const assetData = this.assetsMap.get(key);
+      assetData.refCount++;
+      return assetData;
+    }
+
+    const assetData = new FWAssetData();
+
+    assetData.loaded = false;
+
+    return new Promise(
+      (
+        resolve: (value: FW.AssetData | PromiseLike<FW.AssetData>) => void,
+        reject: (reason?: any) => void,
+      ) => {
+        const self = this;
+        bundle.load(
+          path,
+          type,
+          (finish: number, total: number, item: cc.AssetManager.RequestItem) => {
+            progress?.(finish, total, item);
+          },
+          (err: Error, asset: cc.Asset) => {
+            if (err || !asset) {
+              FWLog.error(`加载资源失败:${asset},请检查!`);
+              reject(err);
+            }
+
+            assetData.loaded = true;
+            assetData.dependentBundle = bundleName;
+            assetData.uuid = asset['_uuid'];
+            assetData.autoRelease = autoRelease;
+            assetData.asset = asset;
+            assetData.user = assetProperty.user;
+            assetData.refCount = 1;
+            self.assetsMap.set(key, assetData);
+
+            cb?.(assetData);
+            resolve(assetData);
+          },
+        );
+      },
+    );
+  }
+  /**
+   * 加载文件夹
+   * @param assetProperty
+   * @returns
+   */
+  async loadDir(assetProperty: FW.AssetProperty): Promise<FW.AssetData[]> {
+    if (!assetProperty) {
+      FWLog.error(`加载资源失败,请检查参数列表:${assetProperty}!`);
+      return undefined;
+    }
+
+    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
+    const type = assetProperty.type;
+    const path = assetProperty.path;
+    const cb = assetProperty.cb;
+    const autoRelease = assetProperty.autoRelease;
+
+    if (!bundleName || bundleName === '') {
+      FWLog.error(`找不到bundle${bundleName},或者bundle未加载!`);
+      return undefined;
+    }
+
+    if (!path || path === '') {
+      FWLog.error(`找不到资源路径${path},请检查!`);
+      return undefined;
+    }
+
+    const bundle: cc.AssetManager.Bundle = await this.resMgr.loadBundle(bundleName);
+
+    if (!bundle) {
+      FWLog.error(`加载bundle失败,请检查!`);
+      return undefined;
+    }
+
+    return new Promise(
+      (
+        resolve: (value: FW.AssetData[] | PromiseLike<FW.AssetData[]>) => void,
+        reject: (reason?: any) => void,
+      ) => {
+        bundle.loadDir(path, type, (err: Error, assets: cc.Asset[]) => {
+          if (err || assets.length === 0) {
+            FWLog.error(`加载资源失败:${assets},请检查!`);
+            reject(err);
+          }
+
+          const assetDataList = [];
+
+          for (const asset of assets) {
+            const assetData = new FWAssetData();
+            assetData.loaded = true;
+            assetData.dependentBundle = bundleName;
+            assetData.uuid = asset['_uuid'];
+            assetData.autoRelease = autoRelease;
+            assetData.asset = asset;
+            assetData.type = type;
+
+            const key = `${this.createAssetMapKey({
+              bundle: bundleName,
+              path: path,
+            })}/${asset.name}${type ? `_${type?.name}` : ''}`;
+
+            this.assetsMap.set(key, assetData);
+
+            assetDataList.push(assetData);
+          }
+
+          cb?.(assetDataList);
+          resolve(assetDataList);
+        });
+      },
+    );
+  }
+
+  /**
+   * 获取资源
+   * @param assetProperty
+   * @returns
+   */
+  get(assetProperty: FW.AssetProperty): FW.AssetData {
+    if (!assetProperty) {
+      FWLog.error(`加载资源失败,请检查参数列表:${assetProperty}!`);
+      return undefined;
+    }
+    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
+    const path = assetProperty.path;
+
+    if (!bundleName || bundleName === '') {
+      FWLog.error(`找不到bundle${bundleName},或者bundle未加载!`);
+      return undefined;
+    }
+
+    if (!path || path === '') {
+      FWLog.error(`找不到资源路径${path},请检查!`);
+      return undefined;
+    }
+
+    if (!this.has(assetProperty)) {
+      FWLog.error('获取资源失败,请先加载!');
+      return undefined;
+    }
+
+    const key = this.createAssetMapKey(assetProperty);
+    const assetsData = this.assetsMap.get(key);
+    assetsData.refCount++;
+    return assetsData;
+  }
+
+  /**
+   * 释放资源
+   * @param assetProperty
+   * @returns
+   */
+  release(assetProperty: FW.AssetProperty): void {
+    if (!assetProperty) {
+      FWLog.error(`加载资源失败,请检查参数列表:${assetProperty}!`);
+      return undefined;
+    }
+    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
+    const path = assetProperty.path;
+    const autoRelease = assetProperty.autoRelease;
+
+    if (!bundleName || bundleName === '') {
+      FWLog.error(`找不到bundle${bundleName},或者bundle未加载!`);
+      return undefined;
+    }
+
+    if (!path || path === '') {
+      FWLog.error(`找不到资源路径${path},请检查!`);
+      return undefined;
+    }
+
+    if (!this.has(assetProperty)) {
+      FWLog.error('获取资源失败,请先加载!');
+      return undefined;
+    }
+    const key = this.createAssetMapKey(assetProperty);
+    const assetData = this.assetsMap.get(key);
+    assetData.refCount--;
+
+    if (assetData.refCount <= 0) {
+      this.assetsMap.delete(key);
+      autoRelease && this.resMgr.getBundle(bundleName)?.release(path);
+    }
+  }
+
+  /**
+   * 获取资源引用计数
+   * @param assetProperty
+   * @returns
+   */
+  public getReferenceCount(assetProperty: FW.AssetProperty): number {
+    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
+    const path = assetProperty.path;
+    const type = assetProperty.type;
+    const key = this.createAssetMapKey(assetProperty);
+    return this.assetsMap.get(key)?.refCount || 0;
+  }
+
+  /**
+   * 资源是否存在
+   * @param uid
+   * @returns
+   */
+  has(assetProperty: FW.AssetProperty) {
+    if (!assetProperty) {
+      FWLog.error(`判断资源是否存在失败,请检查参数列表:${assetProperty}!`);
+      return;
+    }
+
+    return this.assetsMap.has(this.createAssetMapKey(assetProperty));
+  }
+
+  private createAssetMapKey(assetProperty: FW.AssetProperty) {
+    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
+    const path = assetProperty.path;
+    const type = assetProperty.type;
+    if (!type) {
+      return `${bundleName}_${path}`;
+    }
+    return `${bundleName}_${path}_${type}`;
+  }
+
+  public onDestroy(): void {
+    this.assetsMap.clear();
+  }
+}

package/manager/FWAssetManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "eb4a5a74-0281-4aba-af9b-ae616f1d94f2",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}