@eva/spine-base 1.2.8 → 2.0.0-beta.0

package/dist/miniprogram.js

@@ -1,550 +0,0 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-
-import { Component, OBSERVER_TYPE, resource, decorators } from '@eva/eva.js/dist/miniprogram';
-import { __extends, __values, __decorate, __awaiter, __generator } from 'tslib';
-import { RendererSystem, Renderer } from '@eva/plugin-renderer/dist/miniprogram';
-import { type } from '@eva/inspector-decorator';
-import { Texture } from '@eva/miniprogram-pixi';
-
-var Spine = function (_super) {
-  __extends(Spine, _super);
-
-  function Spine() {
-    var _this = _super !== null && _super.apply(this, arguments) || this;
-
-    _this.resource = '';
-    _this.animationName = '';
-    _this.autoPlay = true;
-    _this.waitExecuteInfos = [];
-    return _this;
-  }
-
-  Object.defineProperty(Spine.prototype, "armature", {
-    get: function get() {
-      return this._armature;
-    },
-    set: function set(val) {
-      var e_1, _a;
-
-      this._armature = val;
-      if (!val) return;
-
-      if (this.autoPlay) {
-        this.play(this.animationName);
-      }
-
-      try {
-        for (var _b = __values(this.waitExecuteInfos), _c = _b.next(); !_c.done; _c = _b.next()) {
-          var info = _c.value;
-
-          if (info.playType) {
-            var name_1 = info.name,
-                loop = info.loop,
-                track = info.track;
-            this.play(name_1, loop, track);
-          } else {
-            this.stop(info.track);
-          }
-        }
-      } catch (e_1_1) {
-        e_1 = {
-          error: e_1_1
-        };
-      } finally {
-        try {
-          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-        } finally {
-          if (e_1) throw e_1.error;
-        }
-      }
-
-      this.waitExecuteInfos = [];
-    },
-    enumerable: false,
-    configurable: true
-  });
-
-  Spine.prototype.init = function (obj) {
-    if (!obj) return;
-
-    _extends(this, obj);
-  };
-
-  Spine.prototype.onDestroy = function () {
-    this.destroied = true;
-  };
-
-  Spine.prototype.play = function (name, loop, track) {
-    try {
-      if (name) this.animationName = name;
-
-      if (!this.armature) {
-        this.waitExecuteInfos.push({
-          playType: true,
-          name: name,
-          loop: loop !== null && loop !== void 0 ? loop : this.autoPlay,
-          track: track
-        });
-      } else {
-        if (track === undefined) {
-          track = 0;
-        }
-
-        this.armature.state.setAnimation(track, this.animationName, loop);
-      }
-    } catch (e) {
-      console.log(e);
-    }
-  };
-
-  Spine.prototype.stop = function (track) {
-    if (!this.armature) {
-      this.waitExecuteInfos.push({
-        playType: false,
-        track: track
-      });
-      return;
-    }
-
-    if (track === undefined) {
-      track = 0;
-    }
-
-    this.armature.state.setEmptyAnimation(track, 0);
-  };
-
-  Spine.prototype.addAnimation = function (name, delay, loop, track) {
-    try {
-      if (!this.armature) {} else {
-        if (track === undefined) {
-          track = 0;
-        }
-
-        this.armature.state.addAnimation(track, name, loop, delay);
-      }
-    } catch (e) {
-      console.log(e);
-    }
-  };
-
-  Spine.prototype.setMix = function (from, to, duration) {
-    if (!this.armature) ;else {
-      this.armature.stateData.setMix(from, to, duration);
-    }
-  };
-
-  Spine.prototype.getAnim = function (track) {
-    if (track === void 0) {
-      track = 0;
-    }
-
-    try {
-      if (!this.armature) {} else {
-        return this.armature.state.tracks[track].animation.name;
-      }
-    } catch (e) {
-      console.log(e);
-    }
-  };
-
-  Spine.prototype.setDefaultMix = function (duration) {
-    if (!this.armature) ;else {
-      this.armature.stateData.defaultMix = duration;
-    }
-  };
-
-  Spine.prototype.setAttachment = function (slotName, attachmentName) {
-    if (!this.armature) {
-      return;
-    }
-
-    this.armature.skeleton.setAttachment(slotName, attachmentName);
-  };
-
-  Spine.prototype.getBone = function (boneName) {
-    if (!this.armature) {
-      return;
-    }
-
-    return this.armature.skeleton.findBone(boneName);
-  };
-
-  Spine.componentName = 'Spine';
-
-  __decorate([type('string')], Spine.prototype, "resource", void 0);
-
-  __decorate([type('string')], Spine.prototype, "animationName", void 0);
-
-  __decorate([type('boolean')], Spine.prototype, "autoPlay", void 0);
-
-  return Spine;
-}(Component);
-
-var Spine$1 = Spine;
-var texCache = {};
-
-function cacheImage(data) {
-  var oldImg = data.image;
-  return {
-    tex: Texture.from(oldImg),
-    count: 0
-  };
-}
-
-function retainTexture(name, data) {
-  var cache = texCache[name];
-
-  if (!cache) {
-    cache = cacheImage(data);
-    texCache[name] = cache;
-  }
-
-  cache.count++;
-  return cache.tex;
-}
-
-function getTexture(imageSrc, data) {
-  var cache = texCache[imageSrc];
-
-  if (!cache) {
-    cache = cacheImage(data);
-    texCache[imageSrc] = cache;
-  }
-
-  return cache.tex;
-}
-
-function releaseTexture(imageSrc) {
-  if (!imageSrc) return;
-  setTimeout(function () {
-    var cache = texCache[imageSrc];
-
-    if (cache) {
-      cache.count--;
-
-      if (cache.count <= 0) {
-        if (cache.tex) {
-          cache.tex.destroy(true);
-          cache.tex = null;
-        }
-
-        delete texCache[imageSrc];
-      }
-    }
-  }, 100);
-}
-
-var dataMap = {};
-
-function createSpineData(name, data, scale, pixiSpine) {
-  var spineData = null;
-  var img = getTexture(data.image.src, data);
-  new pixiSpine.core.TextureAtlas(data.atlas, function (line, callback) {
-    callback(img.baseTexture);
-  }, function (spineAtlas) {
-    if (spineAtlas) {
-      var attachmentLoader = new pixiSpine.core.AtlasAttachmentLoader(spineAtlas);
-      var spineJsonParser = new pixiSpine.core.SkeletonJson(attachmentLoader);
-
-      if (scale) {
-        spineJsonParser.scale = scale;
-      }
-
-      spineData = spineJsonParser.readSkeletonData(data.ske);
-    }
-  });
-  var obj = {
-    spineData: spineData,
-    ref: 0,
-    imageSrc: data.image.src
-  };
-  dataMap[name] = obj;
-  return obj;
-}
-
-function getSpineData(res, pixiSpine) {
-  return __awaiter(this, void 0, void 0, function () {
-    var data;
-    return __generator(this, function (_a) {
-      data = dataMap[res.name];
-
-      if (!data) {
-        if (res.complete) {
-          data = createSpineData(res.name, res.data, res.scale, pixiSpine);
-        } else if (!data) {
-          return [2];
-        }
-      }
-
-      retainTexture(res.data.image.src, res.data);
-      data.ref++;
-      return [2, data.spineData];
-    });
-  });
-}
-
-function releaseSpineData(resourceName, imageSrc) {
-  var data = dataMap[resourceName];
-
-  if (!data) {
-    return;
-  }
-
-  data.ref--;
-
-  if (data.ref <= 0) {
-    releaseTexture(imageSrc);
-    delete dataMap[resourceName];
-  }
-}
-
-var MaxRetryCount = 20;
-
-var SpineSystem = function (_super) {
-  __extends(SpineSystem, _super);
-
-  function SpineSystem() {
-    var _this = _super !== null && _super.apply(this, arguments) || this;
-
-    _this.armatures = {};
-    return _this;
-  }
-
-  SpineSystem.prototype.init = function (_a) {
-    var _this = this;
-
-    var pixiSpine = _a.pixiSpine;
-    this.renderSystem = this.game.getSystem(RendererSystem);
-    this.renderSystem.rendererManager.register(this);
-    this.pixiSpine = pixiSpine;
-    this.game.canvas.addEventListener('webglcontextrestored', function () {
-      var objs = _this.game.gameObjects;
-      var toAdd = [];
-
-      for (var k in _this.armatures) {
-        var id = +k;
-
-        for (var i = 0; i < objs.length; ++i) {
-          var obj = objs[i];
-
-          if (obj.id === id) {
-            var sp = obj.getComponent(Spine$1);
-
-            if (sp) {
-              _this.remove({
-                type: OBSERVER_TYPE.REMOVE,
-                gameObject: obj,
-                component: sp,
-                componentName: Spine$1.componentName
-              });
-
-              toAdd.push({
-                type: OBSERVER_TYPE.ADD,
-                gameObject: obj,
-                component: sp,
-                componentName: Spine$1.componentName
-              });
-            }
-
-            break;
-          }
-        }
-      }
-
-      setTimeout(function () {
-        toAdd.forEach(function (obj) {
-          _this.add(obj);
-        });
-      }, 1000);
-    }, false);
-  };
-
-  SpineSystem.prototype.update = function (e) {
-    for (var key in this.armatures) {
-      this.armatures[key].update(e.deltaTime * 0.001);
-      this.armatures[key].updateTransform();
-    }
-
-    _super.prototype.update.call(this);
-  };
-
-  SpineSystem.prototype.componentChanged = function (changed) {
-    return __awaiter(this, void 0, void 0, function () {
-      return __generator(this, function (_a) {
-        if (changed.componentName === 'Spine') {
-          if (changed.type === OBSERVER_TYPE.ADD) {
-            this.add(changed);
-          } else if (changed.type === OBSERVER_TYPE.CHANGE) {
-            switch (changed.prop.prop[0]) {
-              case 'resource':
-                this.change(changed);
-                break;
-            }
-          } else if (changed.type === OBSERVER_TYPE.REMOVE) {
-            this.remove(changed);
-          }
-        }
-
-        return [2];
-      });
-    });
-  };
-
-  SpineSystem.prototype.add = function (changed, count) {
-    var _a, _b;
-
-    return __awaiter(this, void 0, void 0, function () {
-      var component, gameObjectId, asyncId, res, spineData, container, armature, tran;
-
-      var _this = this;
-
-      return __generator(this, function (_c) {
-        switch (_c.label) {
-          case 0:
-            component = changed.component;
-            clearTimeout(component.addHandler);
-            gameObjectId = changed.gameObject.id;
-            asyncId = this.increaseAsyncId(gameObjectId);
-            return [4, resource.getResource(component.resource)];
-
-          case 1:
-            res = _c.sent();
-            if (!this.validateAsyncId(gameObjectId, asyncId)) return [2];
-            return [4, getSpineData(res, this.pixiSpine)];
-
-          case 2:
-            spineData = _c.sent();
-            if (!this.validateAsyncId(gameObjectId, asyncId)) return [2];
-
-            if (!spineData) {
-              component.addHandler = setTimeout(function () {
-                if (!component.destroied) {
-                  if (count === undefined) {
-                    count = MaxRetryCount;
-                  }
-
-                  count--;
-
-                  if (count > 0) {
-                    _this.add(changed, count);
-                  } else {
-                    console.log('retry exceed max times', component.resource);
-                  }
-                }
-              }, 1000);
-              return [2];
-            }
-
-            this.remove(changed);
-            container = (_b = (_a = this.renderSystem) === null || _a === void 0 ? void 0 : _a.containerManager) === null || _b === void 0 ? void 0 : _b.getContainer(changed.gameObject.id);
-
-            if (!container) {
-              return [2];
-            }
-
-            component.lastResource = component.resource;
-            armature = new this.pixiSpine.Spine(spineData);
-            this.armatures[changed.gameObject.id] = armature;
-
-            if (changed.gameObject && changed.gameObject.transform) {
-              tran = changed.gameObject.transform;
-              armature.x = tran.size.width * tran.origin.x;
-              armature.y = tran.size.height * tran.origin.y;
-            }
-
-            container.addChildAt(armature, 0);
-            armature.update();
-            armature.updateTransform();
-            component.armature = armature;
-            component.emit('loaded', {
-              resource: component.resource
-            });
-            armature.state.addListener({
-              start: function start(track, event) {
-                component.emit('start', {
-                  track: track,
-                  name: track.animation.name
-                });
-              },
-              complete: function complete(track, event) {
-                component.emit('complete', {
-                  track: track,
-                  name: track.animation.name
-                });
-              },
-              interrupt: function interrupt(track, event) {
-                component.emit('interrupt', {
-                  track: track,
-                  name: track.animation.name
-                });
-              },
-              end: function end(track, event) {
-                component.emit('end', {
-                  track: track,
-                  name: track.animation.name
-                });
-              },
-              event: function event(track, _event) {
-                component.emit('event', track, _event);
-              }
-            });
-            return [2];
-        }
-      });
-    });
-  };
-
-  SpineSystem.prototype.change = function (changed) {
-    this.remove(changed);
-    this.add(changed);
-  };
-
-  SpineSystem.prototype.remove = function (changed) {
-    var _a, _b, _c, _d;
-
-    return __awaiter(this, void 0, void 0, function () {
-      var component, armature, container, res;
-      return __generator(this, function (_e) {
-        switch (_e.label) {
-          case 0:
-            this.increaseAsyncId(changed.gameObject.id);
-            component = changed.component;
-            clearTimeout(component.addHandler);
-            armature = this.armatures[changed.gameObject.id];
-            container = (_b = (_a = this.renderSystem) === null || _a === void 0 ? void 0 : _a.containerManager) === null || _b === void 0 ? void 0 : _b.getContainer(changed.gameObject.id);
-
-            if (container && armature) {
-              container.removeChild(armature);
-            }
-
-            if (!component.armature) return [3, 2];
-            component.armature.destroy({
-              children: true
-            });
-            return [4, resource.getResource(component.lastResource)];
-
-          case 1:
-            res = _e.sent();
-            releaseSpineData(res.name, (_d = (_c = res.data) === null || _c === void 0 ? void 0 : _c.image) === null || _d === void 0 ? void 0 : _d.src);
-            _e.label = 2;
-
-          case 2:
-            component.armature = null;
-            delete this.armatures[changed.gameObject.id];
-            if (changed.type === OBSERVER_TYPE.CHANGE) ;
-            return [2];
-        }
-      });
-    });
-  };
-
-  SpineSystem.systemName = 'SpineSystem';
-  SpineSystem = __decorate([decorators.componentObserver({
-    Spine: ['resource']
-  })], SpineSystem);
-  return SpineSystem;
-}(Renderer);
-
-var SpineSystem$1 = SpineSystem;
-resource.registerResourceType('SPINE');
-export { Spine$1 as Spine, SpineSystem$1 as SpineSystem };

package/dist/spine-base.d.ts

@@ -1,58 +0,0 @@
-/// <reference path="./global.d.ts"/>
-import { Component } from '@eva/eva.js';
-import { ComponentChanged } from '@eva/eva.js';
-import { ContainerManager } from '@eva/plugin-renderer';
-import { DisplayObject } from 'pixi.js';
-import { Renderer } from '@eva/plugin-renderer';
-import { RendererManager } from '@eva/plugin-renderer';
-import { RendererSystem } from '@eva/plugin-renderer';
-import { UpdateParams } from '@eva/eva.js';
-
-export declare class Spine extends Component<SpineParams> {
-    static componentName: string;
-    resource: string;
-    animationName: string;
-    autoPlay: boolean;
-    private _armature;
-    private waitExecuteInfos;
-    set armature(val: any);
-    get armature(): any;
-    destroied: boolean;
-    addHandler: any;
-    lastResource: string;
-    init(obj?: SpineParams): void;
-    onDestroy(): void;
-    play(name?: string, loop?: boolean, track?: number): void;
-    stop(track?: number): void;
-    addAnimation(name?: string, delay?: number, loop?: boolean, track?: number): void;
-    setMix(from: string, to: string, duration: number): void;
-    getAnim(track?: number): any;
-    setDefaultMix(duration: number): void;
-    setAttachment(slotName: string, attachmentName: string): void;
-    getBone(boneName: string): any;
-}
-
-export declare interface SpineParams {
-    resource: string;
-    animationName?: string;
-    autoPlay?: boolean;
-}
-
-export declare class SpineSystem extends Renderer {
-    static systemName: string;
-    armatures: Record<number, DisplayObject>;
-    renderSystem: RendererSystem;
-    rendererManager: RendererManager;
-    containerManager: ContainerManager;
-    pixiSpine: any;
-    init({ pixiSpine }: {
-        pixiSpine: any;
-    }): void;
-    update(e: UpdateParams): void;
-    componentChanged(changed: ComponentChanged): Promise<void>;
-    add(changed: ComponentChanged, count?: number): Promise<void>;
-    change(changed: ComponentChanged): void;
-    remove(changed: ComponentChanged): Promise<void>;
-}
-
-export { }