@eva/plugin-renderer-particle 2.1.0-beta.3 → 2.1.0-beta.5

package/dist/EVA.plugin.renderer.particle.js

@@ -0,0 +1,668 @@
+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 || {};
+globalThis.EVA.plugin.renderer = globalThis.EVA.plugin.renderer || {};
+var _EVA_IIFE_particle = 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 ParticleEmitter extends eva_js.Component {
+    constructor() {
+      super(...arguments);
+      this.resource = '';
+      this.auto = true;
+      this.duration = -1;
+      this.frequency = 250;
+      this.quantity = 1;
+      this.maxParticles = 500;
+      this.lifespan = 1000;
+      this.gravityX = 0;
+      this.gravityY = 0;
+      this.paused = false;
+    }
+    init(obj) {
+      if (obj) _extends(this, obj);
+    }
+    stop() {
+      this.paused = true;
+    }
+    start() {
+      this.paused = false;
+    }
+  }
+  ParticleEmitter.componentName = 'ParticleEmitter';
+  __decorate([type('string'), __metadata("design:type", String)], ParticleEmitter.prototype, "resource", void 0);
+  __decorate([type('boolean'), __metadata("design:type", Boolean)], ParticleEmitter.prototype, "auto", void 0);
+  __decorate([type('number'), __metadata("design:type", Number)], ParticleEmitter.prototype, "duration", void 0);
+  __decorate([type('number'), __metadata("design:type", Number)], ParticleEmitter.prototype, "frequency", void 0);
+  __decorate([type('number'), __metadata("design:type", Number)], ParticleEmitter.prototype, "quantity", void 0);
+  __decorate([type('number'), __metadata("design:type", Number)], ParticleEmitter.prototype, "maxParticles", void 0);
+  __decorate([type('number'), __metadata("design:type", Number)], ParticleEmitter.prototype, "gravityX", void 0);
+  __decorate([type('number'), __metadata("design:type", Number)], ParticleEmitter.prototype, "gravityY", void 0);
+  const TAU = Math.PI * 2;
+  const easings = {
+    linear: t => t,
+    'sine.in': t => 1 - Math.cos(t * Math.PI / 2),
+    'sine.out': t => Math.sin(t * Math.PI / 2),
+    'sine.inout': t => -(Math.cos(Math.PI * t) - 1) / 2,
+    'quad.in': t => t * t,
+    'quad.out': t => 1 - (1 - t) * (1 - t),
+    'quad.inout': t => t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2,
+    'cubic.in': t => t * t * t,
+    'cubic.out': t => 1 - Math.pow(1 - t, 3),
+    'expo.out': t => t === 1 ? 1 : 1 - Math.pow(2, -10 * t)
+  };
+  function resolveEase(name) {
+    if (!name) return easings.linear;
+    const k = name.toLowerCase();
+    return easings[k] || easings.linear;
+  }
+  function rand(min, max) {
+    return min + Math.random() * (max - min);
+  }
+  function sampleRange(value, fallback = 0) {
+    if (value == null) return fallback;
+    if (typeof value === 'number') return value;
+    if (Array.isArray(value)) return value[Math.floor(Math.random() * value.length)];
+    if ('min' in value && 'max' in value) return rand(value.min, value.max);
+    if ('start' in value && 'end' in value) return value.start;
+    return fallback;
+  }
+  function getRangeBounds(value) {
+    if (value == null || typeof value === 'number' || Array.isArray(value)) return null;
+    if ('start' in value && 'end' in value) return value;
+    return null;
+  }
+  function samplePosition(zone) {
+    if (!zone) return {
+      x: 0,
+      y: 0
+    };
+    return sampleShape(zone.shape, zone.type === 'edge');
+  }
+  function sampleShape(shape, edgeOnly) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    switch (shape.type) {
+      case 'point':
+        return {
+          x: (_a = shape.x) !== null && _a !== void 0 ? _a : 0,
+          y: (_b = shape.y) !== null && _b !== void 0 ? _b : 0
+        };
+      case 'rect':
+        {
+          const x0 = (_c = shape.x) !== null && _c !== void 0 ? _c : 0;
+          const y0 = (_d = shape.y) !== null && _d !== void 0 ? _d : 0;
+          if (edgeOnly) {
+            const perim = 2 * (shape.width + shape.height);
+            const t = Math.random() * perim;
+            if (t < shape.width) return {
+              x: x0 + t,
+              y: y0
+            };
+            if (t < shape.width + shape.height) return {
+              x: x0 + shape.width,
+              y: y0 + (t - shape.width)
+            };
+            if (t < 2 * shape.width + shape.height) return {
+              x: x0 + shape.width - (t - shape.width - shape.height),
+              y: y0 + shape.height
+            };
+            return {
+              x: x0,
+              y: y0 + shape.height - (t - 2 * shape.width - shape.height)
+            };
+          }
+          return {
+            x: rand(x0, x0 + shape.width),
+            y: rand(y0, y0 + shape.height)
+          };
+        }
+      case 'circle':
+        {
+          const cx = (_e = shape.x) !== null && _e !== void 0 ? _e : 0;
+          const cy = (_f = shape.y) !== null && _f !== void 0 ? _f : 0;
+          const angle = Math.random() * TAU;
+          const r = edgeOnly ? shape.radius : shape.radius * Math.sqrt(Math.random());
+          return {
+            x: cx + Math.cos(angle) * r,
+            y: cy + Math.sin(angle) * r
+          };
+        }
+      case 'ellipse':
+        {
+          const cx = (_g = shape.x) !== null && _g !== void 0 ? _g : 0;
+          const cy = (_h = shape.y) !== null && _h !== void 0 ? _h : 0;
+          const angle = Math.random() * TAU;
+          const k = edgeOnly ? 1 : Math.sqrt(Math.random());
+          return {
+            x: cx + Math.cos(angle) * shape.rx * k,
+            y: cy + Math.sin(angle) * shape.ry * k
+          };
+        }
+      case 'line':
+        {
+          const t = Math.random();
+          return {
+            x: shape.x1 + (shape.x2 - shape.x1) * t,
+            y: shape.y1 + (shape.y2 - shape.y1) * t
+          };
+        }
+    }
+  }
+  function pointInShape(shape, px, py) {
+    var _a, _b, _c, _d, _e, _f;
+    switch (shape.type) {
+      case 'rect':
+        {
+          const x0 = (_a = shape.x) !== null && _a !== void 0 ? _a : 0;
+          const y0 = (_b = shape.y) !== null && _b !== void 0 ? _b : 0;
+          return px >= x0 && px <= x0 + shape.width && py >= y0 && py <= y0 + shape.height;
+        }
+      case 'circle':
+        {
+          const dx = px - ((_c = shape.x) !== null && _c !== void 0 ? _c : 0);
+          const dy = py - ((_d = shape.y) !== null && _d !== void 0 ? _d : 0);
+          return dx * dx + dy * dy <= shape.radius * shape.radius;
+        }
+      case 'ellipse':
+        {
+          const dx = (px - ((_e = shape.x) !== null && _e !== void 0 ? _e : 0)) / shape.rx;
+          const dy = (py - ((_f = shape.y) !== null && _f !== void 0 ? _f : 0)) / shape.ry;
+          return dx * dx + dy * dy <= 1;
+        }
+      case 'point':
+      case 'line':
+        return false;
+    }
+  }
+  class Emitter {
+    constructor(params, container, texture) {
+      this.frameTextures = null;
+      this.particles = [];
+      this.elapsed = 0;
+      this.emittedTotal = 0;
+      this.emitTimer = 0;
+      this.explodeDone = false;
+      this.params = params;
+      this.container = container;
+      this.texture = texture;
+    }
+    setTexture(texture) {
+      this.texture = texture;
+    }
+    setFrameTextures(textures) {
+      this.frameTextures = textures && textures.length > 0 ? textures : null;
+    }
+    setParams(params) {
+      this.params = params;
+    }
+    destroy() {
+      this.particles.length = 0;
+      this.container.particleChildren.length = 0;
+      this.container.update();
+    }
+    update(dt) {
+      this.elapsed += dt;
+      this.advanceParticles(dt);
+      this.spawn(dt);
+      this.container.update();
+    }
+    advanceParticles(dt) {
+      var _a, _b;
+      const dtSec = dt / 1000;
+      const out = [];
+      for (const lp of this.particles) {
+        lp.age += dt;
+        if (lp.age > lp.lifespan) {
+          continue;
+        }
+        lp.vx += lp.ax * dtSec + ((_a = this.params.gravityX) !== null && _a !== void 0 ? _a : 0) * dtSec;
+        lp.vy += lp.ay * dtSec + ((_b = this.params.gravityY) !== null && _b !== void 0 ? _b : 0) * dtSec;
+        lp.particle.x += lp.vx * dtSec;
+        lp.particle.y += lp.vy * dtSec;
+        lp.particle.rotation += lp.rotateSpeed * dtSec;
+        const t = lp.age / lp.lifespan;
+        if (lp.scaleStart && lp.scaleEnd) {
+          const k = (lp.scaleEase || easings.linear)(t);
+          lp.particle.scaleX = lp.scaleStart.x + (lp.scaleEnd.x - lp.scaleStart.x) * k;
+          lp.particle.scaleY = lp.scaleStart.y + (lp.scaleEnd.y - lp.scaleStart.y) * k;
+        }
+        if (lp.alphaStart != null && lp.alphaEnd != null) {
+          const k = (lp.alphaEase || easings.linear)(t);
+          lp.particle.alpha = lp.alphaStart + (lp.alphaEnd - lp.alphaStart) * k;
+        }
+        if (this.params.deathZone && this.shouldDie(lp.particle.x, lp.particle.y)) {
+          continue;
+        }
+        out.push(lp);
+      }
+      this.particles = out;
+      this.container.particleChildren.length = 0;
+      for (const lp of this.particles) this.container.particleChildren.push(lp.particle);
+    }
+    shouldDie(x, y) {
+      const dz = this.params.deathZone;
+      if (!dz) return false;
+      const inside = pointInShape(dz.shape, x, y);
+      return dz.mode === 'onLeave' ? !inside : inside;
+    }
+    spawn(dt) {
+      var _a, _b, _c;
+      const p = this.params;
+      if (p.duration != null && p.duration > 0 && this.elapsed > p.duration) return;
+      if (p.stopAfter != null && this.emittedTotal >= p.stopAfter) return;
+      if (p.paused) return;
+      const max = (_a = p.maxParticles) !== null && _a !== void 0 ? _a : 500;
+      if (this.particles.length >= max) return;
+      if (p.explode != null && !this.explodeDone) {
+        const n = Math.min(p.explode, max - this.particles.length);
+        for (let i = 0; i < n; i++) this.emitOne();
+        this.explodeDone = true;
+        return;
+      }
+      if (p.explode != null) return;
+      if (p.auto === false) return;
+      this.emitTimer += dt;
+      const freq = (_b = p.frequency) !== null && _b !== void 0 ? _b : 250;
+      const quantity = (_c = p.quantity) !== null && _c !== void 0 ? _c : 1;
+      while (this.emitTimer >= freq && this.particles.length < max) {
+        for (let i = 0; i < quantity && this.particles.length < max; i++) {
+          if (p.stopAfter != null && this.emittedTotal >= p.stopAfter) break;
+          this.emitOne();
+        }
+        this.emitTimer -= freq;
+      }
+    }
+    emitOne() {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+      const p = this.params;
+      const pos = samplePosition(p.emitZone);
+      const speedScalar = sampleRange(p.speed, 0);
+      let vx;
+      let vy;
+      if (p.moveTo) {
+        const dx = p.moveTo.x - pos.x;
+        const dy = p.moveTo.y - pos.y;
+        const len = Math.hypot(dx, dy) || 1;
+        vx = dx / len * (speedScalar || 100);
+        vy = dy / len * (speedScalar || 100);
+      } else if (p.speedX != null || p.speedY != null) {
+        vx = sampleRange(p.speedX, 0);
+        vy = sampleRange(p.speedY, 0);
+      } else {
+        const angleDeg = sampleRange(p.angle, 0);
+        const angleRad = angleDeg * Math.PI / 180;
+        vx = Math.cos(angleRad) * speedScalar;
+        vy = Math.sin(angleRad) * speedScalar;
+      }
+      const ax = sampleRange(p.accelerationX, 0);
+      const ay = sampleRange(p.accelerationY, 0);
+      const scaleX = p.scaleX != null ? sampleRange(p.scaleX, 1) : sampleRange(p.scale, 1);
+      const scaleY = p.scaleY != null ? sampleRange(p.scaleY, 1) : sampleRange(p.scale, 1);
+      const alpha = sampleRange(p.alpha, 1);
+      const rotation = sampleRange(p.rotate, 0);
+      const tintNum = Array.isArray(p.tint) ? p.tint[Math.floor(Math.random() * p.tint.length)] : (_a = p.tint) !== null && _a !== void 0 ? _a : 0xffffff;
+      const tex = this.frameTextures ? this.frameTextures[Math.floor(Math.random() * this.frameTextures.length)] : this.texture;
+      const particle = new pixi_js.Particle({
+        texture: tex,
+        x: pos.x,
+        y: pos.y,
+        scaleX,
+        scaleY,
+        alpha,
+        rotation,
+        tint: tintNum,
+        anchorX: 0.5,
+        anchorY: 0.5
+      });
+      const lp = {
+        particle,
+        age: 0,
+        lifespan: sampleRange(p.lifespan, 1000),
+        vx,
+        vy,
+        ax,
+        ay,
+        rotateSpeed: 0
+      };
+      const scaleBounds = getRangeBounds(p.scale);
+      const scaleXBounds = getRangeBounds(p.scaleX);
+      const scaleYBounds = getRangeBounds(p.scaleY);
+      if (scaleBounds || scaleXBounds || scaleYBounds) {
+        const sxs = (_c = (_b = scaleXBounds === null || scaleXBounds === void 0 ? void 0 : scaleXBounds.start) !== null && _b !== void 0 ? _b : scaleBounds === null || scaleBounds === void 0 ? void 0 : scaleBounds.start) !== null && _c !== void 0 ? _c : scaleX;
+        const sxe = (_e = (_d = scaleXBounds === null || scaleXBounds === void 0 ? void 0 : scaleXBounds.end) !== null && _d !== void 0 ? _d : scaleBounds === null || scaleBounds === void 0 ? void 0 : scaleBounds.end) !== null && _e !== void 0 ? _e : scaleX;
+        const sys = (_g = (_f = scaleYBounds === null || scaleYBounds === void 0 ? void 0 : scaleYBounds.start) !== null && _f !== void 0 ? _f : scaleBounds === null || scaleBounds === void 0 ? void 0 : scaleBounds.start) !== null && _g !== void 0 ? _g : scaleY;
+        const sye = (_j = (_h = scaleYBounds === null || scaleYBounds === void 0 ? void 0 : scaleYBounds.end) !== null && _h !== void 0 ? _h : scaleBounds === null || scaleBounds === void 0 ? void 0 : scaleBounds.end) !== null && _j !== void 0 ? _j : scaleY;
+        lp.scaleStart = {
+          x: sxs,
+          y: sys
+        };
+        lp.scaleEnd = {
+          x: sxe,
+          y: sye
+        };
+        lp.scaleEase = resolveEase((_k = scaleXBounds === null || scaleXBounds === void 0 ? void 0 : scaleXBounds.ease) !== null && _k !== void 0 ? _k : scaleBounds === null || scaleBounds === void 0 ? void 0 : scaleBounds.ease);
+        particle.scaleX = sxs;
+        particle.scaleY = sys;
+      }
+      const alphaBounds = getRangeBounds(p.alpha);
+      if (alphaBounds) {
+        lp.alphaStart = alphaBounds.start;
+        lp.alphaEnd = alphaBounds.end;
+        lp.alphaEase = resolveEase(alphaBounds.ease);
+        particle.alpha = alphaBounds.start;
+      }
+      this.particles.push(lp);
+      this.container.particleChildren.push(particle);
+      this.emittedTotal++;
+    }
+  }
+  const SPRITE_KEY_SEP = '_s|r|c_';
+  function isTexture(v) {
+    return !!v && v.isTexture === true && !!v.orig && !!v.uvs;
+  }
+  function pickFrameTextures(instance, resourceName, frame) {
+    if (isTexture(instance)) {
+      return {
+        texture: instance,
+        frameTextures: null
+      };
+    }
+    if (instance && typeof instance === 'object') {
+      const lookup = name => {
+        var _a;
+        const fullKey = resourceName + SPRITE_KEY_SEP + name;
+        const v = (_a = instance[fullKey]) !== null && _a !== void 0 ? _a : instance[name];
+        return isTexture(v) ? v : null;
+      };
+      const frameNames = Array.isArray(frame) ? frame : frame ? [frame] : [];
+      const frameTextures = [];
+      for (const f of frameNames) {
+        const t = lookup(f);
+        if (t) frameTextures.push(t);
+      }
+      if (frameTextures.length > 0) {
+        return {
+          texture: frameTextures[0],
+          frameTextures
+        };
+      }
+      for (const k in instance) {
+        const v = instance[k];
+        if (isTexture(v)) return {
+          texture: v,
+          frameTextures: null
+        };
+      }
+    }
+    return {
+      texture: null,
+      frameTextures: null
+    };
+  }
+  let ParticleEmitterSystem = class ParticleEmitterSystem extends pluginRenderer.Renderer {
+    constructor() {
+      super(...arguments);
+      this.name = 'ParticleEmitter';
+      this.records = {};
+      this.lastDeltaTime = 1000 / 60;
+    }
+    init() {
+      this.renderSystem = this.game.getSystem(pluginRenderer.RendererSystem);
+      this.renderSystem.rendererManager.register(this);
+    }
+    update(e) {
+      if (e === null || e === void 0 ? void 0 : e.deltaTime) this.lastDeltaTime = e.deltaTime;
+      super.update(e);
+    }
+    rendererUpdate(gameObject) {
+      const record = this.records[gameObject.id];
+      if (!record) return;
+      record.emitter.setParams(record.component);
+      record.emitter.update(this.lastDeltaTime);
+    }
+    componentChanged(changed) {
+      var _a, _b, _c, _d;
+      return __awaiter(this, void 0, void 0, function* () {
+        if (changed.componentName !== 'ParticleEmitter') return;
+        const component = changed.component;
+        const gameObjectId = changed.gameObject.id;
+        if (changed.type === eva_js.OBSERVER_TYPE.ADD) {
+          const asyncId = this.increaseAsyncId(gameObjectId);
+          let texture = null;
+          let frameTextures = null;
+          if (component.resource) {
+            const {
+              instance
+            } = yield eva_js.resource.getResource(component.resource);
+            if (!this.validateAsyncId(gameObjectId, asyncId)) return;
+            if (!instance) {
+              console.error(`GameObject:${changed.gameObject.name}'s ParticleEmitter resource load error`);
+              return;
+            }
+            const picked = pickFrameTextures(instance, component.resource, component.frame);
+            texture = picked.texture;
+            frameTextures = picked.frameTextures;
+          }
+          if (!texture) return;
+          const pc = new pixi_js.ParticleContainer({
+            dynamicProperties: {
+              position: true,
+              rotation: true,
+              scale: true,
+              color: true,
+              uvs: true
+            }
+          });
+          pc.texture = texture;
+          this.containerManager.getContainer(gameObjectId).addChildAt(pc, 0);
+          const emitter = new Emitter(component, pc, texture);
+          emitter.setFrameTextures(frameTextures);
+          this.records[gameObjectId] = {
+            container: pc,
+            emitter,
+            component
+          };
+        } else if (changed.type === eva_js.OBSERVER_TYPE.CHANGE) {
+          const record = this.records[gameObjectId];
+          if (!record) return;
+          if (((_b = (_a = changed.prop) === null || _a === void 0 ? void 0 : _a.prop) === null || _b === void 0 ? void 0 : _b[0]) === 'resource') {
+            const asyncId = this.increaseAsyncId(gameObjectId);
+            const {
+              instance
+            } = yield eva_js.resource.getResource(component.resource);
+            if (!this.validateAsyncId(gameObjectId, asyncId)) return;
+            if (instance) {
+              const picked = pickFrameTextures(instance, component.resource, component.frame);
+              if (picked.texture) {
+                record.container.texture = picked.texture;
+                record.emitter.setTexture(picked.texture);
+              }
+              record.emitter.setFrameTextures(picked.frameTextures);
+            }
+          }
+          record.component = component;
+          record.emitter.setParams(component);
+        } else if (changed.type === eva_js.OBSERVER_TYPE.REMOVE) {
+          this.increaseAsyncId(gameObjectId);
+          const record = this.records[gameObjectId];
+          if (!record) return;
+          record.emitter.destroy();
+          (_d = (_c = this.containerManager) === null || _c === void 0 ? void 0 : _c.getContainer(gameObjectId)) === null || _d === void 0 ? void 0 : _d.removeChild(record.container);
+          record.container.destroy({
+            children: true
+          });
+          delete this.records[gameObjectId];
+        }
+      });
+    }
+    destroy() {
+      var _a, _b;
+      for (const key in this.records) {
+        const id = parseInt(key);
+        const record = this.records[id];
+        record.emitter.destroy();
+        (_b = (_a = this.containerManager) === null || _a === void 0 ? void 0 : _a.getContainer(id)) === null || _b === void 0 ? void 0 : _b.removeChild(record.container);
+        record.container.destroy({
+          children: true
+        });
+        delete this.records[id];
+      }
+    }
+  };
+  ParticleEmitterSystem.systemName = 'ParticleEmitter';
+  ParticleEmitterSystem = __decorate([eva_js.decorators.componentObserver({
+    ParticleEmitter: [{
+      prop: ['resource'],
+      deep: false
+    }]
+  })], ParticleEmitterSystem);
+  var ParticleEmitterSystem$1 = ParticleEmitterSystem;
+  exports.Emitter = Emitter;
+  exports.ParticleEmitter = ParticleEmitter;
+  exports.ParticleEmitterSystem = ParticleEmitterSystem$1;
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+  return exports;
+}({}, EVA, EVA.plugin.renderer, PIXI);
+globalThis.EVA.plugin.renderer.particle = globalThis.EVA.plugin.renderer.particle || _EVA_IIFE_particle;