@eva/spine-base 2.1.0-beta.3 → 2.1.0-beta.5

package/dist/EVA.plugin.spineBase.js

@@ -0,0 +1,691 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+globalThis.EVA = globalThis.EVA || {};
+globalThis.EVA.plugin = globalThis.EVA.plugin || {};
+var _EVA_IIFE_spineBase = function (exports, eva_js, pluginRenderer, pixi_js) {
+  'use strict';
+  function __decorate(decorators, target, key, desc) {
+    var c = arguments.length,
+      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
+      d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+  }
+  function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+  }
+  function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function (resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator["throw"](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  }
+  typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+    }
+    return t;
+  }
+  typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  class SymbolKeysNotSupportedError extends Error {
+    constructor() {
+      super('Symbol keys are not supported yet!');
+      Object.setPrototypeOf(this, new.target.prototype);
+    }
+  }
+  const IDE_PROPERTY_METADATA = 'IDE_PROPERTY_METADATA';
+  function transformBasicType(type) {
+    if (type === String) {
+      return 'string';
+    }
+    if (type === Number) {
+      return 'number';
+    }
+    if (type === Boolean) {
+      return 'boolean';
+    }
+    return 'unknown';
+  }
+  function defineLegacyIDEProp(target, propertyKey, patch) {
+    const constructor = target.constructor;
+    const current = constructor.IDEProps || {};
+    current[propertyKey] = _extends(_extends({
+      key: propertyKey
+    }, current[propertyKey]), patch);
+    constructor.IDEProps = current;
+  }
+  function defineTypes(target, key, options, returnTypeFunction) {
+    let type = Reflect.getMetadata('design:type', target, key);
+    let isArray = type === Array;
+    const str = transformBasicType(type);
+    if (str !== 'unknown') {
+      type = str;
+    }
+    if (returnTypeFunction) {
+      const returnType = returnTypeFunction();
+      if (Array.isArray(returnType)) {
+        isArray = true;
+        type = returnType[0];
+      } else {
+        type = returnType;
+      }
+    }
+    const properties = Reflect.getMetadata(IDE_PROPERTY_METADATA, target.constructor) || {};
+    const current = properties[key] || {};
+    const property = _extends(_extends(_extends({}, current), {
+      type,
+      isArray: isArray
+    }), options);
+    properties[key] = property;
+    Reflect.defineMetadata(IDE_PROPERTY_METADATA, properties, target.constructor);
+    const legacyProperty = __rest(property, ["isArray"]);
+    defineLegacyIDEProp(target, key, legacyProperty);
+  }
+  function type(type) {
+    return Field({
+      type
+    });
+  }
+  function getTypeDecoratorParams(returnTypeFuncOrOptions, maybeOptions) {
+    if (typeof returnTypeFuncOrOptions === 'function') {
+      return {
+        returnTypeFunc: returnTypeFuncOrOptions,
+        options: maybeOptions || {}
+      };
+    }
+    return {
+      options: returnTypeFuncOrOptions || {}
+    };
+  }
+  function Field(returnTypeFunction, maybeOptions) {
+    return (target, propertyKey) => {
+      if (typeof propertyKey === 'symbol') {
+        throw new SymbolKeysNotSupportedError();
+      }
+      const {
+        options,
+        returnTypeFunc
+      } = getTypeDecoratorParams(returnTypeFunction, maybeOptions);
+      defineTypes(target, propertyKey, options, returnTypeFunc);
+    };
+  }
+  var ExecuteMode;
+  (function (ExecuteMode) {
+    ExecuteMode[ExecuteMode["Edit"] = 2] = "Edit";
+    ExecuteMode[ExecuteMode["Game"] = 4] = "Game";
+    ExecuteMode[ExecuteMode["All"] = 6] = "All";
+  })(ExecuteMode || (ExecuteMode = {}));
+  class Spine extends eva_js.Component {
+    constructor(params) {
+      super(params);
+      this.resource = '';
+      this.scale = 1;
+      this.animationName = '';
+      this.autoPlay = true;
+      this.keepResource = false;
+      this.timeScale = 1;
+      this.skin = '';
+      this._slotGameObjects = new Map();
+      this._pendingSlotObjects = [];
+      this.waitExecuteInfos = [];
+      this.listenerBound = false;
+      this.paused = false;
+      this.init(params);
+    }
+    set armature(val) {
+      this._armature = val;
+      if (!val) return;
+      this.applyTimeScale();
+      if (this.skin) this.setSkin(this.skin);
+      if (this.autoPlay) {
+        this.play(this.animationName);
+      }
+      for (const info of this.waitExecuteInfos) {
+        if (info.playType) {
+          const {
+            name,
+            loop,
+            track
+          } = info;
+          this.play(name, loop, track);
+        } else {
+          this.stop(info.track);
+        }
+      }
+      this.waitExecuteInfos = [];
+    }
+    get armature() {
+      return this._armature;
+    }
+    init(obj) {
+      if (obj) _extends(this, obj);
+      if (!this.listenerBound) {
+        this.listenerBound = true;
+        this.on('start', event => {
+          var _a;
+          (_a = this.onStart) === null || _a === void 0 ? void 0 : _a.call(this, event);
+        });
+        this.on('complete', event => {
+          var _a;
+          (_a = this.onComplete) === null || _a === void 0 ? void 0 : _a.call(this, event);
+        });
+        this.on('event', (track, event) => {
+          var _a;
+          (_a = this.onEvent) === null || _a === void 0 ? void 0 : _a.call(this, track, event);
+        });
+      }
+    }
+    onDestroy() {
+      this.destroied = true;
+    }
+    load() {
+      return this.armature;
+    }
+    destroy() {
+      this.onDestroy();
+      if (this.armature && !this.armature.destroyed) {
+        this._destroySlotGameObjects();
+        this.armature.destroy({
+          children: true
+        });
+      }
+      this.armature = null;
+    }
+    pause() {
+      this.paused = true;
+      this.applyTimeScale();
+    }
+    resume() {
+      this.paused = false;
+      this.applyTimeScale();
+    }
+    setSkin(name) {
+      var _a, _b, _c, _d, _e;
+      this.skin = name;
+      if (!((_a = this.armature) === null || _a === void 0 ? void 0 : _a.skeleton)) return;
+      if (this.armature.skeleton.setSkinByName) {
+        this.armature.skeleton.setSkinByName(name);
+      } else if (this.armature.skeleton.setSkin) {
+        const skin = ((_c = (_b = this.armature.skeleton.data) === null || _b === void 0 ? void 0 : _b.findSkin) === null || _c === void 0 ? void 0 : _c.call(_b, name)) || name;
+        this.armature.skeleton.setSkin(skin);
+      }
+      (_e = (_d = this.armature.skeleton).setSlotsToSetupPose) === null || _e === void 0 ? void 0 : _e.call(_d);
+    }
+    play(name, loopAnimation, track) {
+      try {
+        const loop = loopAnimation !== null && loopAnimation !== void 0 ? loopAnimation : this.autoPlay;
+        if (name) this.animationName = name;
+        if (!this.armature) {
+          this.waitExecuteInfos.push({
+            playType: true,
+            name,
+            loop,
+            track
+          });
+        } else {
+          if (track === undefined) {
+            track = 0;
+          }
+          this.applyTimeScale();
+          this.armature.state.setAnimation(track, this.animationName, loop);
+        }
+      } catch (e) {
+        console.log(e);
+      }
+    }
+    stop(track) {
+      if (!this.armature) {
+        this.waitExecuteInfos.push({
+          playType: false,
+          track
+        });
+        return;
+      }
+      if (track === undefined) {
+        track = 0;
+      }
+      this.armature.state.setEmptyAnimation(track, 0);
+    }
+    applyTimeScale() {
+      var _a;
+      if (!((_a = this.armature) === null || _a === void 0 ? void 0 : _a.state)) return;
+      this.armature.state.timeScale = this.paused ? 0 : this.timeScale;
+    }
+    addAnimation(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);
+      }
+    }
+    setMix(from, to, duration) {
+      if (!this.armature) ;else {
+        this.armature.state.data.setMix(from, to, duration);
+      }
+    }
+    getAnim(track = 0) {
+      try {
+        if (!this.armature) {} else {
+          return this.armature.state.tracks[track].animation.name;
+        }
+      } catch (e) {
+        console.log(e);
+      }
+    }
+    setDefaultMix(duration) {
+      if (!this.armature) ;else {
+        this.armature.state.data.defaultMix = duration;
+      }
+    }
+    setAttachment(slotName, attachmentName) {
+      if (!this.armature) {
+        return;
+      }
+      this.armature.skeleton.setAttachment(slotName, attachmentName);
+    }
+    getBone(boneName) {
+      if (!this.armature) {
+        return;
+      }
+      return this.armature.skeleton.findBone(boneName);
+    }
+    addSlotObject(slot, gameObject, options) {
+      if (!this.armature) {
+        console.warn('Spine armature is not ready, cannot addSlotObject');
+        return;
+      }
+      if (!this._containerManager) {
+        console.warn('ContainerManager is not available');
+        return;
+      }
+      const container = this._containerManager.getContainer(gameObject.id);
+      if (!container) {
+        this._pendingSlotObjects.push({
+          slot,
+          gameObject,
+          options
+        });
+        return;
+      }
+      this._doAddSlotObject(slot, gameObject, container, options);
+    }
+    _doAddSlotObject(slot, gameObject, container, options) {
+      const wrapper = new pixi_js.Container();
+      wrapper.addChild(container);
+      this.armature.addSlotObject(slot, wrapper, options);
+      this._slotGameObjects.set(gameObject, {
+        slot,
+        wrapper
+      });
+      this._syncTransformTree(gameObject);
+    }
+    _syncTransformTree(gameObject) {
+      var _a;
+      if (!this._containerManager) return;
+      this._containerManager.updateTransform({
+        name: gameObject.id,
+        transform: gameObject.transform
+      });
+      if ((_a = gameObject.transform) === null || _a === void 0 ? void 0 : _a.children) {
+        for (const childTransform of gameObject.transform.children) {
+          if (childTransform.gameObject) {
+            this._syncTransformTree(childTransform.gameObject);
+          }
+        }
+      }
+    }
+    _flushPendingSlotObjects() {
+      if (this._pendingSlotObjects.length === 0) return;
+      if (!this.armature || !this._containerManager) return;
+      const still = [];
+      for (const pending of this._pendingSlotObjects) {
+        const container = this._containerManager.getContainer(pending.gameObject.id);
+        if (container) {
+          this._doAddSlotObject(pending.slot, pending.gameObject, container, pending.options);
+        } else {
+          still.push(pending);
+        }
+      }
+      this._pendingSlotObjects = still;
+    }
+    removeSlotObject(gameObject) {
+      this._pendingSlotObjects = this._pendingSlotObjects.filter(p => p.gameObject !== gameObject);
+      const entry = this._slotGameObjects.get(gameObject);
+      if (entry && this.armature) {
+        this.armature.removeSlotObject(entry.wrapper);
+        entry.wrapper.destroy({
+          children: false
+        });
+      }
+      this._slotGameObjects.delete(gameObject);
+    }
+    _destroySlotGameObjects() {
+      for (const [gameObject, entry] of this._slotGameObjects) {
+        if (!gameObject.destroyed) {
+          if (this.armature) {
+            this.armature.removeSlotObject(entry.wrapper);
+          }
+          entry.wrapper.destroy({
+            children: false
+          });
+          gameObject.destroy();
+        }
+      }
+      this._slotGameObjects.clear();
+      this._pendingSlotObjects = [];
+    }
+  }
+  Spine.componentName = 'Spine';
+  __decorate([type('string'), __metadata("design:type", String)], Spine.prototype, "resource", void 0);
+  __decorate([type('number'), __metadata("design:type", Number)], Spine.prototype, "scale", void 0);
+  __decorate([type('string'), __metadata("design:type", String)], Spine.prototype, "animationName", void 0);
+  __decorate([type('boolean'), __metadata("design:type", Boolean)], Spine.prototype, "autoPlay", void 0);
+  __decorate([type('boolean'), __metadata("design:type", Boolean)], Spine.prototype, "keepResource", void 0);
+  __decorate([type('number'), __metadata("design:type", Number)], Spine.prototype, "timeScale", void 0);
+  __decorate([type('string'), __metadata("design:type", String)], Spine.prototype, "skin", void 0);
+  let dataMap = {};
+  function resolveImageSrc(image) {
+    var _a, _b, _c, _d, _e;
+    if (!image) return '';
+    if (typeof image === 'string') return image;
+    return image.label || ((_a = image.source) === null || _a === void 0 ? void 0 : _a.label) || ((_c = (_b = image.source) === null || _b === void 0 ? void 0 : _b.resource) === null || _c === void 0 ? void 0 : _c.src) || ((_d = image.source) === null || _d === void 0 ? void 0 : _d._sourceOrigin) || image.src || ((_e = image.baseTexture) === null || _e === void 0 ? void 0 : _e.cacheId) || '';
+  }
+  function createSpineData(name, data, scale, pixiSpine) {
+    const skeletonAsset = data.ske;
+    const atlasAsset = data.atlas;
+    const attachmentLoader = new pixiSpine.AtlasAttachmentLoader(atlasAsset);
+    const parser = skeletonAsset instanceof Uint8Array ? new pixiSpine.SkeletonBinary(attachmentLoader) : new pixiSpine.SkeletonJson(attachmentLoader);
+    parser.scale = scale || 1;
+    const skeletonData = parser.readSkeletonData(skeletonAsset);
+    const obj = {
+      spineData: skeletonData,
+      ref: 0,
+      imageSrc: resolveImageSrc(data.image)
+    };
+    dataMap[name] = obj;
+    return obj;
+  }
+  function getSpineData(res, scale, pixiSpine) {
+    return __awaiter(this, void 0, void 0, function* () {
+      let data = dataMap[res.name];
+      if (!data) {
+        if (res.complete) {
+          data = createSpineData(res.name, res.data, scale, pixiSpine);
+        } else if (!data) {
+          return;
+        }
+      }
+      data.ref++;
+      return data.spineData;
+    });
+  }
+  function releaseSpineData(res, _imageSrc) {
+    const resourceName = res.name;
+    const data = dataMap[resourceName];
+    if (!data) {
+      return;
+    }
+    data.ref--;
+    setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+      if (data.ref <= 0) {
+        eva_js.resource.destroy(resourceName);
+        delete dataMap[resourceName];
+      }
+    }), 100);
+  }
+  const MaxRetryCount = 20;
+  let SpineSystem = class SpineSystem extends pluginRenderer.Renderer {
+    constructor() {
+      super(...arguments);
+      this.armatures = {};
+      this._spineComponents = {};
+    }
+    init({
+      pixiSpine
+    }) {
+      this.renderSystem = this.game.getSystem(pluginRenderer.RendererSystem);
+      this.renderSystem.rendererManager.register(this);
+      this.pixiSpine = pixiSpine;
+      this.game.canvas.addEventListener('webglcontextrestored', () => {
+        const objs = this.game.gameObjects;
+        let toAdd = [];
+        for (let k in this.armatures) {
+          const id = +k;
+          for (let i = 0; i < objs.length; ++i) {
+            let obj = objs[i];
+            if (obj.id === id) {
+              let sp = obj.getComponent(Spine);
+              if (sp) {
+                this.remove({
+                  type: eva_js.OBSERVER_TYPE.REMOVE,
+                  gameObject: obj,
+                  component: sp,
+                  componentName: Spine.componentName
+                });
+                toAdd.push({
+                  type: eva_js.OBSERVER_TYPE.ADD,
+                  gameObject: obj,
+                  component: sp,
+                  componentName: Spine.componentName
+                });
+              }
+              break;
+            }
+          }
+        }
+        setTimeout(() => {
+          toAdd.forEach(obj => {
+            this.add(obj);
+          });
+        }, 1000);
+      }, false);
+    }
+    update(e) {
+      super.update();
+      for (let key in this.armatures) {
+        const armature = this.armatures[key];
+        const component = this._spineComponents[key];
+        if (!armature || armature.destroyed || (component === null || component === void 0 ? void 0 : component.destroied)) {
+          delete this.armatures[key];
+          delete this._spineComponents[key];
+          continue;
+        }
+        armature.update(e.deltaTime * 0.001);
+      }
+      for (let key in this._spineComponents) {
+        const component = this._spineComponents[key];
+        if (!component || component.destroied) {
+          delete this._spineComponents[key];
+          continue;
+        }
+        component._flushPendingSlotObjects();
+      }
+    }
+    componentChanged(changed) {
+      return __awaiter(this, void 0, void 0, function* () {
+        if (changed.componentName === 'Spine') {
+          if (changed.type === eva_js.OBSERVER_TYPE.ADD) {
+            this.add(changed);
+          } else if (changed.type === eva_js.OBSERVER_TYPE.CHANGE) {
+            switch (changed.prop.prop[0]) {
+              case 'resource':
+                this.change(changed);
+                break;
+            }
+          } else if (changed.type === eva_js.OBSERVER_TYPE.REMOVE) {
+            this.remove(changed);
+          }
+        }
+      });
+    }
+    add(changed, count) {
+      var _a, _b, _c;
+      return __awaiter(this, void 0, void 0, function* () {
+        const component = changed.component;
+        clearTimeout(component.addHandler);
+        const gameObjectId = changed.gameObject.id;
+        const asyncId = this.increaseAsyncId(gameObjectId);
+        const res = yield eva_js.resource.getResource(component.resource);
+        if (!this.validateAsyncId(gameObjectId, asyncId) || component.destroied || changed.gameObject.destroyed) return;
+        const spineData = yield getSpineData(res, component.scale, this.pixiSpine);
+        if (!this.validateAsyncId(gameObjectId, asyncId) || component.destroied || changed.gameObject.destroyed) return;
+        if (!spineData) {
+          component.addHandler = setTimeout(() => {
+            if (!component.destroied && !changed.gameObject.destroyed) {
+              if (count === undefined) {
+                count = MaxRetryCount;
+              }
+              count--;
+              if (count > 0) {
+                this.add(changed, count);
+              } else {
+                console.log('retry exceed max times', component.resource);
+              }
+            }
+          }, 1000);
+          return;
+        }
+        this.remove(changed);
+        const 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 || component.destroied || changed.gameObject.destroyed) {
+          return;
+        }
+        component.lastResource = component.resource;
+        const armature = new this.pixiSpine.Spine({
+          skeletonData: spineData,
+          autoUpdate: false
+        });
+        this.armatures[changed.gameObject.id] = armature;
+        this._spineComponents[changed.gameObject.id] = component;
+        if (changed.gameObject && changed.gameObject.transform) {
+          const 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();
+        component._containerManager = (_c = this.renderSystem) === null || _c === void 0 ? void 0 : _c.containerManager;
+        component.armature = armature;
+        component.emit('loaded', {
+          resource: component.resource
+        });
+        armature.state.addListener({
+          start: (track, event) => {
+            component.emit('start', {
+              track,
+              name: track.animation.name
+            });
+          },
+          complete: (track, event) => {
+            component.emit('complete', {
+              track,
+              name: track.animation.name
+            });
+          },
+          interrupt: (track, event) => {
+            component.emit('interrupt', {
+              track,
+              name: track.animation.name
+            });
+          },
+          end: (track, event) => {
+            component.emit('end', {
+              track,
+              name: track.animation.name
+            });
+          },
+          event: (track, event) => {
+            component.emit('event', track, event);
+          }
+        });
+      });
+    }
+    change(changed) {
+      this.remove(changed);
+      this.add(changed);
+    }
+    remove(changed) {
+      var _a, _b, _c, _d, _e, _f;
+      return __awaiter(this, void 0, void 0, function* () {
+        const gameObjectId = changed.gameObject.id;
+        this.increaseAsyncId(gameObjectId);
+        const component = changed.component;
+        clearTimeout(component.addHandler);
+        const armature = this.armatures[gameObjectId];
+        const container = (_b = (_a = this.renderSystem) === null || _a === void 0 ? void 0 : _a.containerManager) === null || _b === void 0 ? void 0 : _b.getContainer(gameObjectId);
+        if (container && armature) {
+          container.removeChild(armature);
+        }
+        const componentArmature = component.armature;
+        component.armature = null;
+        delete this.armatures[gameObjectId];
+        delete this._spineComponents[gameObjectId];
+        if (componentArmature) {
+          component._destroySlotGameObjects();
+          if (!componentArmature.destroyed) {
+            componentArmature.destroy({
+              children: true
+            });
+          }
+          if (!component.keepResource && component.lastResource) {
+            try {
+              const res = yield eva_js.resource.getResource(component.lastResource);
+              const imageSrc = ((_d = (_c = res.data) === null || _c === void 0 ? void 0 : _c.image) === null || _d === void 0 ? void 0 : _d.src) || ((_f = (_e = res.data) === null || _e === void 0 ? void 0 : _e.image) === null || _f === void 0 ? void 0 : _f.label);
+              releaseSpineData(res, imageSrc);
+            } catch (error) {
+              console.warn('Failed to release Spine resource', component.lastResource, error);
+            }
+          }
+        }
+        if (changed.type === eva_js.OBSERVER_TYPE.CHANGE) ;
+      });
+    }
+  };
+  SpineSystem.systemName = 'SpineSystem';
+  SpineSystem = __decorate([eva_js.decorators.componentObserver({
+    Spine: ['resource']
+  })], SpineSystem);
+  var SpineSystem$1 = SpineSystem;
+  eva_js.resource.registerResourceType('SPINE');
+  exports.Spine = Spine;
+  exports.SpineSystem = SpineSystem$1;
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+  return exports;
+}({}, EVA, EVA.plugin.renderer, PIXI);
+globalThis.EVA.plugin.spineBase = globalThis.EVA.plugin.spineBase || _EVA_IIFE_spineBase;