@eva/plugin-renderer-particle 2.1.0-beta.1

package/dist/plugin-renderer-particle.esm.js

@@ -0,0 +1,567 @@
+import { Component, decorators, OBSERVER_TYPE, resource } from '@eva/eva.js';
+import { type } from '@eva/inspector-decorator';
+import { Renderer, RendererSystem } from '@eva/plugin-renderer';
+import { Particle, ParticleContainer } from 'pixi.js';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+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;
+};
+
+class ParticleEmitter extends 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;
+        /** Runtime 标记:由 System 设置,触发时立即停止发射。 */
+        this.paused = false;
+    }
+    init(obj) {
+        if (obj)
+            Object.assign(this, obj);
+    }
+    /** 立刻停止发射(已存在的粒子继续运行直至 lifespan 到期)。 */
+    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);
+}
+/** Range 取值:每次 emit 时算一次具体值。`{start, end}` 留给粒子自己每帧插值。 */
+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;
+    }
+    /** Provide a texture pool when component.frame is set; emitOne samples from it. */
+    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 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_'; // Sync with plugin-renderer-sprite resourceKeySplit.
+/**
+ * Resolve resource instance to a primary texture + optional frame texture pool.
+ * - IMAGE resource → instance is a Texture, return single.
+ * - SPRITE resource → instance is `{[fullKey]: Texture}`. Pick frames listed in `frame`
+ *   (string or array); fall back to first frame as the primary texture.
+ */
+/**
+ * Check if a value is a PixiJS Texture. Uses duck typing because separate copies of pixi.js
+ * may be loaded across plugins (ESM module duplication breaks `instanceof`).
+ */
+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 };
+        }
+        // No frame requested → fall back to first texture in the map.
+        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 Renderer {
+    constructor() {
+        super(...arguments);
+        this.name = 'ParticleEmitter';
+        this.records = {};
+        this.lastDeltaTime = 1000 / 60;
+    }
+    init() {
+        this.renderSystem = this.game.getSystem(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 === OBSERVER_TYPE.ADD) {
+                const asyncId = this.increaseAsyncId(gameObjectId);
+                let texture = null;
+                let frameTextures = null;
+                if (component.resource) {
+                    const { instance } = yield 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 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 === 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 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 === 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([
+    decorators.componentObserver({
+        ParticleEmitter: [{ prop: ['resource'], deep: false }],
+    })
+], ParticleEmitterSystem);
+var ParticleEmitterSystem$1 = ParticleEmitterSystem;
+
+export { Emitter, ParticleEmitter, ParticleEmitterSystem$1 as ParticleEmitterSystem };

package/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/plugin-renderer-particle.cjs.prod.js')
+} else {
+  module.exports = require('./dist/plugin-renderer-particle.cjs.js')
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@eva/plugin-renderer-particle",
+  "version": "2.1.0-beta.1",
+  "description": "@eva/plugin-renderer-particle",
+  "main": "index.js",
+  "module": "dist/plugin-renderer-particle.esm.js",
+  "bundle": "EVA.plugin.renderer.particle",
+  "unpkg": "dist/EVA.plugin.renderer.particle.min.js",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "types": "dist/plugin-renderer-particle.d.ts",
+  "keywords": [
+    "eva.js",
+    "eva-plugin-renderer-particle"
+  ],
+  "author": "dingyike.dyk <dingyike.dyk@alibaba-inc.com>",
+  "license": "MIT",
+  "homepage": "https://eva.js.org",
+  "dependencies": {
+    "@eva/inspector-decorator": "^2.0.0-beta.0",
+    "@eva/eva.js": "2.1.0-beta.1",
+    "@eva/plugin-renderer": "2.1.0-beta.1",
+    "pixi.js": "^8.6.3"
+  }
+}