@fps-games/vfx 0.1.1

package/packages/effects/building-upgrade/vfx-params.json

@@ -0,0 +1,24 @@
+{
+  "__generation.offsetX": 0,
+  "__generation.offsetY": 0,
+  "__generation.offsetZ": 0,
+  "lifetime": 1,
+  "scale": 2,
+  "initialHeight": 0.05,
+  "color": {
+    "r": 1,
+    "g": 0.8392156862745098,
+    "b": 0.12156862745098039
+  },
+  "opacity": 1,
+  "scaleX": 2,
+  "scaleY": 0.2,
+  "scaleZ": 2,
+  "centerCount": 100,
+  "outlineCount": 300,
+  "strandWidth": 0.1,
+  "riseSpeed": 0.5,
+  "centerSpread": 1,
+  "outlineThickness": 0.18,
+  "glowOpacity": 1
+}

package/packages/effects/character-entrance/effect.json

@@ -0,0 +1,6 @@
+{
+  "id": "character-entrance",
+  "nameZh": "人物登场光柱",
+  "source": "runtime-generated",
+  "assets": []
+}

package/packages/effects/character-entrance/index.ts

@@ -0,0 +1,308 @@
+import { Color3 } from '@babylonjs/core/Maths/math.color';
+import { Constants } from '@babylonjs/core/Engines/constants';
+import { DynamicTexture } from '@babylonjs/core/Materials/Textures/dynamicTexture';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+import { CreateCylinder } from '@babylonjs/core/Meshes/Builders/cylinderBuilder';
+import { CreateTorus } from '@babylonjs/core/Meshes/Builders/torusBuilder';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import type { Texture } from '@babylonjs/core/Materials/Textures/texture';
+import type { Scene } from '@babylonjs/core/scene';
+import type { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import type { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+import { VFX_RENDERING_GROUP_ID } from '../../rendering';
+import manifest from './effect.json';
+
+interface CharacterEntranceParams extends VfxParamValues {
+  lifetime: number;
+  scale: number;
+  initialHeight: number;
+  offsetX: number;
+  offsetZ: number;
+  color: VfxColorValue;
+  opacity: number;
+  radius: number;
+  height: number;
+  beamWidth: number;
+  riseSpeed: number;
+  ringOpacity: number;
+  fadeStart: number;
+}
+
+const DEFAULT_PARAMS: CharacterEntranceParams = {
+  lifetime: 2.2,
+  scale: 1,
+  initialHeight: 0.02,
+  offsetX: 0,
+  offsetZ: 0,
+  color: { r: 0.72, g: 0.96, b: 1 },
+  opacity: 0.82,
+  radius: 0.58,
+  height: 2.35,
+  beamWidth: 0.08,
+  riseSpeed: 0.9,
+  ringOpacity: 0.78,
+  fadeStart: 0.58,
+};
+
+export const characterEntranceEffectPackage: VfxEffectPackage<CharacterEntranceParams> = {
+  id: 'character-entrance',
+  nameZh: '人物登场光柱',
+  manifest,
+  defaultParams: DEFAULT_PARAMS,
+  debugAnchor: 'player',
+  debugParams: [
+    { key: 'lifetime', label: '生命周期', kind: 'lifetime', min: 0.4, max: 6, step: 0.01 },
+    { key: 'scale', label: '整体缩放', kind: 'scale', min: 0.1, max: 5, step: 0.01 },
+    { key: 'color', label: '光柱颜色', kind: 'color' },
+    { key: 'opacity', label: '透明度', kind: 'opacity', min: 0, max: 1, step: 0.01 },
+    { key: 'radius', label: '光柱半径', kind: 'number', min: 0.05, max: 3, step: 0.01 },
+    { key: 'height', label: '光柱高度', kind: 'number', min: 0.2, max: 8, step: 0.01 },
+    { key: 'beamWidth', label: '杯壁厚度', kind: 'number', min: 0.005, max: 0.35, step: 0.001 },
+    { key: 'riseSpeed', label: '流动速度', kind: 'number', min: 0, max: 5, step: 0.01 },
+    { key: 'ringOpacity', label: '底部强度', kind: 'opacity', min: 0, max: 1, step: 0.01 },
+    { key: 'fadeStart', label: '淡出开始', kind: 'number', min: 0.05, max: 0.95, step: 0.01 },
+  ],
+  create({ scene, root, position, params }) {
+    root.position.copyFrom(position);
+
+    const beam = createCupBeam(scene, root, params);
+    let disposed = false;
+    const disposeTimer = window.setTimeout(() => disposeAll(), Math.max(0.05, params.lifetime + 0.45) * 1000);
+
+    beam.start();
+
+    return {
+      root,
+      dispose() {
+        disposeAll();
+      },
+    };
+
+    function disposeAll(): void {
+      if (disposed) return;
+      disposed = true;
+      window.clearTimeout(disposeTimer);
+      beam.dispose();
+      root.dispose();
+    }
+  },
+};
+
+function createCupBeam(scene: Scene, root: TransformNode, params: CharacterEntranceParams): { start(): void; dispose(): void } {
+  const scale = Math.max(0.05, params.scale);
+  const height = Math.max(0.05, params.height * scale);
+  const radius = Math.max(0.02, params.radius * scale);
+  const wallThickness = Math.max(0.006, params.beamWidth * scale);
+  const shellAlpha = clamp01(params.opacity * 0.68);
+  const flowAlpha = clamp01(params.opacity * 0.78);
+  const rimAlpha = clamp01(params.opacity * params.ringOpacity * 1.18);
+  const shellMaterial = createCupBeamMaterial(scene, params, 'shell', getCupBeamTexture(scene), shellAlpha);
+  const flowTexture = getCupFlowTexture(scene);
+  const flowMaterial = createCupBeamMaterial(scene, params, 'flow', flowTexture, flowAlpha);
+  const rimMaterial = createCupBeamMaterial(scene, params, 'bottom-rim', getBottomRimTexture(scene), rimAlpha);
+  const shell = createOpenCylinder(scene, 'character-entrance.cup.shell');
+  const flow = createOpenCylinder(scene, 'character-entrance.cup.flow');
+  const rim = CreateTorus('character-entrance.cup.bottom-rim', {
+    diameter: radius * 2,
+    thickness: Math.max(0.018, wallThickness * 0.9),
+    tessellation: 64,
+    sideOrientation: Mesh.DOUBLESIDE,
+  }, scene);
+  const meshes = [
+    { mesh: shell, radius: radius + wallThickness * 1.6, material: shellMaterial, alpha: shellAlpha },
+    { mesh: flow, radius: radius + wallThickness * 0.55, material: flowMaterial, alpha: flowAlpha },
+  ];
+  let age = 0;
+  let observer: ReturnType<Scene['onBeforeRenderObservable']['add']> | null = null;
+  let disposed = false;
+
+  for (const entry of meshes) {
+    entry.mesh.parent = root;
+    entry.mesh.position.y = 0;
+    entry.mesh.scaling.set(entry.radius, 0.001, entry.radius);
+    entry.mesh.renderingGroupId = VFX_RENDERING_GROUP_ID;
+    entry.mesh.isPickable = false;
+    entry.mesh.material = entry.material;
+    entry.material.alpha = 0;
+  }
+  rim.parent = root;
+  rim.position.y = 0.025 * scale;
+  rim.renderingGroupId = VFX_RENDERING_GROUP_ID;
+  rim.isPickable = false;
+  rim.material = rimMaterial;
+  rimMaterial.alpha = 0;
+
+  return { start, dispose };
+
+  function start(): void {
+    if (observer) return;
+    observer = scene.onBeforeRenderObservable.add(() => {
+      if (disposed) return;
+      const deltaSeconds = Math.min(0.05, scene.getEngine().getDeltaTime() / 1000);
+      age += deltaSeconds;
+      const t = Math.min(1, age / Math.max(0.01, params.lifetime));
+      const riseDuration = Math.max(0.1, Math.min(0.68, 0.55 / Math.max(0.2, params.riseSpeed)));
+      const rise = easeOutCubic(Math.min(1, t / riseDuration));
+      const fadeStart = Math.max(0.05, Math.min(0.95, params.fadeStart));
+      const fade = Math.max(0, 1 - Math.max(0, t - fadeStart) / Math.max(0.01, 1 - fadeStart));
+      const visibleHeight = Math.max(0.001, height * rise);
+      const softPulse = 0.96 + Math.sin(age * 4.2) * 0.04;
+      flowTexture.vOffset -= deltaSeconds * Math.max(0, params.riseSpeed) * 0.34;
+
+      for (const entry of meshes) {
+        entry.mesh.scaling.y = visibleHeight;
+        entry.mesh.position.y = visibleHeight * 0.5;
+        entry.material.alpha = entry.alpha * fade * softPulse;
+      }
+      rim.scaling.setAll(1 + rise * 0.06);
+      rimMaterial.alpha = rimAlpha * fade * (0.82 + rise * 0.18);
+    });
+  }
+
+  function dispose(): void {
+    if (disposed) return;
+    disposed = true;
+    if (observer) scene.onBeforeRenderObservable.remove(observer);
+    observer = null;
+    shell.dispose();
+    flow.dispose();
+    rim.dispose();
+    shellMaterial.dispose();
+    flowMaterial.dispose();
+    rimMaterial.dispose();
+  }
+}
+
+function createOpenCylinder(scene: Scene, name: string): Mesh {
+  return CreateCylinder(name, {
+    height: 1,
+    diameter: 2,
+    tessellation: 96,
+    subdivisions: 12,
+    cap: Mesh.NO_CAP,
+    sideOrientation: Mesh.DOUBLESIDE,
+  }, scene);
+}
+
+function createCupBeamMaterial(
+  scene: Scene,
+  params: CharacterEntranceParams,
+  suffix: string,
+  texture: Texture,
+  alpha: number,
+): StandardMaterial {
+  const material = new StandardMaterial(`character-entrance.cup.${suffix}.material`, scene);
+  texture.hasAlpha = true;
+  material.diffuseTexture = texture;
+  material.opacityTexture = texture;
+  material.useAlphaFromDiffuseTexture = true;
+  material.emissiveColor = toColor3(params.color);
+  material.diffuseColor = toColor3(params.color);
+  material.alpha = alpha;
+  material.disableLighting = true;
+  material.backFaceCulling = false;
+  material.alphaMode = Constants.ALPHA_ADD;
+  return material;
+}
+
+function getCupBeamTexture(scene: Scene): DynamicTexture {
+  const key = '__vfx_character_entrance_cup_beam_texture';
+  const metadata = scene.metadata && typeof scene.metadata === 'object' ? scene.metadata as Record<string, unknown> : {};
+  scene.metadata = metadata;
+  const existing = metadata[key] as DynamicTexture | undefined;
+  if (existing) return existing;
+
+  const texture = new DynamicTexture('character_entrance_cup_beam_texture', { width: 128, height: 256 }, scene, true);
+  const context = texture.getContext();
+  const composite = context as unknown as CanvasRenderingContext2D;
+  context.clearRect(0, 0, 128, 256);
+  const side = context.createLinearGradient(0, 0, 128, 0);
+  side.addColorStop(0, 'rgba(205, 250, 255, 0)');
+  side.addColorStop(0.22, 'rgba(205, 250, 255, 0.42)');
+  side.addColorStop(0.5, 'rgba(245, 255, 255, 0.82)');
+  side.addColorStop(0.78, 'rgba(205, 250, 255, 0.42)');
+  side.addColorStop(1, 'rgba(205, 250, 255, 0)');
+  const vertical = context.createLinearGradient(0, 0, 0, 256);
+  vertical.addColorStop(0, 'rgba(210, 250, 255, 0)');
+  vertical.addColorStop(0.18, 'rgba(210, 250, 255, 0.1)');
+  vertical.addColorStop(0.62, 'rgba(185, 246, 255, 0.58)');
+  vertical.addColorStop(1, 'rgba(245, 255, 255, 0.96)');
+  context.fillStyle = side;
+  context.fillRect(0, 0, 128, 256);
+  composite.globalCompositeOperation = 'source-in';
+  context.fillStyle = vertical;
+  context.fillRect(0, 0, 128, 256);
+  composite.globalCompositeOperation = 'source-over';
+  texture.hasAlpha = true;
+  texture.update(false);
+  return texture;
+}
+
+function getCupFlowTexture(scene: Scene): DynamicTexture {
+  const key = '__vfx_character_entrance_cup_flow_texture';
+  const metadata = scene.metadata && typeof scene.metadata === 'object' ? scene.metadata as Record<string, unknown> : {};
+  scene.metadata = metadata;
+  const existing = metadata[key] as DynamicTexture | undefined;
+  if (existing) return existing;
+
+  const texture = new DynamicTexture('character_entrance_cup_flow_texture', { width: 128, height: 256 }, scene, true);
+  const context = texture.getContext();
+  const composite = context as unknown as CanvasRenderingContext2D;
+  context.clearRect(0, 0, 128, 256);
+  const side = context.createLinearGradient(0, 0, 128, 0);
+  side.addColorStop(0, 'rgba(255, 255, 255, 0)');
+  side.addColorStop(0.28, 'rgba(255, 255, 255, 0.22)');
+  side.addColorStop(0.5, 'rgba(255, 255, 255, 0.7)');
+  side.addColorStop(0.72, 'rgba(255, 255, 255, 0.22)');
+  side.addColorStop(1, 'rgba(255, 255, 255, 0)');
+  context.fillStyle = side;
+  context.fillRect(0, 0, 128, 256);
+  composite.globalCompositeOperation = 'source-in';
+  for (let y = -48; y < 304; y += 56) {
+    const band = context.createLinearGradient(0, y, 0, y + 42);
+    band.addColorStop(0, 'rgba(255, 255, 255, 0)');
+    band.addColorStop(0.48, 'rgba(255, 255, 255, 0.92)');
+    band.addColorStop(1, 'rgba(255, 255, 255, 0)');
+    context.fillStyle = band;
+    context.fillRect(0, y, 128, 42);
+  }
+  composite.globalCompositeOperation = 'source-over';
+  texture.hasAlpha = true;
+  texture.vScale = 1.2;
+  texture.update(false);
+  return texture;
+}
+
+function getBottomRimTexture(scene: Scene): DynamicTexture {
+  const key = '__vfx_character_entrance_bottom_rim_texture';
+  const metadata = scene.metadata && typeof scene.metadata === 'object' ? scene.metadata as Record<string, unknown> : {};
+  scene.metadata = metadata;
+  const existing = metadata[key] as DynamicTexture | undefined;
+  if (existing) return existing;
+
+  const texture = new DynamicTexture('character_entrance_bottom_rim_texture', { width: 64, height: 64 }, scene, true);
+  const context = texture.getContext();
+  context.clearRect(0, 0, 64, 64);
+  const glow = context.createRadialGradient(32, 32, 8, 32, 32, 31);
+  glow.addColorStop(0, 'rgba(245, 255, 255, 0.96)');
+  glow.addColorStop(0.55, 'rgba(185, 246, 255, 0.68)');
+  glow.addColorStop(1, 'rgba(150, 230, 255, 0)');
+  context.fillStyle = glow;
+  context.fillRect(0, 0, 64, 64);
+  texture.hasAlpha = true;
+  texture.update(false);
+  return texture;
+}
+
+function toColor3(color: VfxColorValue): Color3 {
+  return new Color3(clamp01(color.r), clamp01(color.g), clamp01(color.b));
+}
+
+function clamp01(value: number): number {
+  return Math.min(1, Math.max(0, value));
+}
+
+function easeOutCubic(value: number): number {
+  const t = clamp01(value);
+  return 1 - Math.pow(1 - t, 3);
+}

package/packages/effects/character-entrance/vfx-params.json

@@ -0,0 +1,24 @@
+{
+  "schemaVersion": "vfx-params/1.0",
+  "effectId": "character-entrance",
+  "updatedAt": "2026-06-04T00:00:00.000Z",
+  "params": {
+    "__generation.offsetX": 0,
+    "__generation.offsetY": 1,
+    "__generation.offsetZ": 0,
+    "lifetime": 2.2,
+    "scale": 2,
+    "color": {
+      "r": 0,
+      "g": 0.8666666666666667,
+      "b": 1
+    },
+    "opacity": 1,
+    "radius": 1,
+    "height": 2.35,
+    "beamWidth": 0.055,
+    "riseSpeed": 1,
+    "ringOpacity": 0.72,
+    "fadeStart": 0.48
+  }
+}

package/packages/effects/coin-burst/index.ts

@@ -0,0 +1,43 @@
+// 金币爆出(移植自 babylon-laser 击破掉落金币, 特效#11)。
+// 金色 primitive 圆柱,抛物 flyer 池(重力9/寿命1.9),一次性。无外部资产。
+import { CreateCylinder } from '@babylonjs/core/Meshes/Builders/cylinderBuilder';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+import { Color3 } from '@babylonjs/core/Maths/math.color';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import type { VfxEffectPackage, VfxParamValues } from '../../types';
+import { FlyerPool } from '../space-shared';
+
+interface CoinBurstParams extends VfxParamValues { count: number; }
+const DEFAULT_PARAMS: CoinBurstParams = { count: 6 };
+
+export const coinBurstEffectPackage: VfxEffectPackage<CoinBurstParams> = {
+  id: 'coin-burst',
+  nameZh: '金币爆出',
+  debugAnchor: 'playerRight',
+  defaultParams: DEFAULT_PARAMS,
+  debugParams: [
+    { key: 'count', label: '金币数量', kind: 'number', min: 0, max: 20, step: 1 },
+  ],
+
+  create({ scene, root, position, params }) {
+    root.position.copyFrom(position);
+    const pool = new FlyerPool(scene);
+    const coinMat = new StandardMaterial('vfx_coin_mat', scene);
+    coinMat.diffuseColor = new Color3(1, 0.78, 0.1);
+    coinMat.emissiveColor = new Color3(0.5, 0.36, 0.02);
+    coinMat.specularColor = new Color3(1, 0.9, 0.4);
+    for (let i = 0; i < Math.round(params.count); i++) {
+      const c = CreateCylinder('vfx_coin', { diameter: 0.8, height: 0.12, tessellation: 18 }, scene);
+      c.rotation.x = Math.random() * Math.PI; c.material = coinMat;
+      pool.spawn(c, position, new Vector3((Math.random() - 0.5) * 6, Math.random() * 6 + 4, (Math.random() - 0.5) * 6), 9, 1.9);
+    }
+    let disposed = false;
+    const disposeTimer = window.setTimeout(() => disposeAll(), 2300);
+    function disposeAll(): void {
+      if (disposed) return; disposed = true;
+      window.clearTimeout(disposeTimer);
+      pool.dispose(); coinMat.dispose(); root.dispose();
+    }
+    return { root, dispose() { disposeAll(); } };
+  },
+};

package/packages/effects/coin-burst/vfx-params.json

@@ -0,0 +1,5 @@
+{
+  "schemaVersion": "vfx-params/1.0",
+  "effectId": "coin-burst",
+  "params": {}
+}

package/packages/effects/comet-trail-flame/index.ts

@@ -0,0 +1,106 @@
+// 陨石/彗星拖尾火焰(移植自 babylon-laser TrailFlame, 特效#5)。
+// 十字两面片(沿 +Z 长 1,root.scaling.z=length 拉长)+ trail_5x4 序列帧(20帧5x4,全局同步播)。
+// 偏橙 emissive,ALPHA_COMBINE(非 ADD,不过曝)。自排除 GlowLayer。亮头在 z=0、尾端淡出。
+// 库版为持续型:头在 root、尾沿局部 +Z 延伸(宿主把 +Z 朝运动反方向即成拖尾)。
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { VertexData } from '@babylonjs/core/Meshes/mesh.vertexData';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+import { Texture } from '@babylonjs/core/Materials/Textures/texture';
+import { Color3 } from '@babylonjs/core/Maths/math.color';
+import { Constants } from '@babylonjs/core/Engines/constants';
+import type { Scene } from '@babylonjs/core/scene';
+import type { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import type { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+import trailTextureUrl from './assets/textures/trail_5x4.webp?url';
+import { LIFETIME_DEBUG_PARAMS, LIFETIME_DEFAULTS, scheduleLifetime } from '../space-shared';
+
+interface CometTrailFlameParams extends VfxParamValues {
+  lifetimeMode: string; lifetime: number;
+  width: number;
+  length: number;
+  fps: number;
+  tint: VfxColorValue;
+}
+
+const DEFAULT_PARAMS: CometTrailFlameParams = {
+  ...LIFETIME_DEFAULTS,
+  width: 3.0, length: 7.0, fps: 20, tint: { r: 1.0, g: 0.62, b: 0.35 },
+};
+
+function createTrailPlaneGeo(name: string, width: number, axis: 'x' | 'y', scene: Scene): Mesh {
+  const h = width / 2;
+  const positions = axis === 'x'
+    ? [-h, 0, 0, h, 0, 0, h, 0, 1, -h, 0, 1]
+    : [0, -h, 0, 0, h, 0, 0, h, 1, 0, -h, 1];
+  const normals = axis === 'x' ? [0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0] : [1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0];
+  const uvs = [0, 0, 1, 0, 1, 1, 0, 1];
+  const indices = [0, 1, 2, 0, 2, 3];
+  const mesh = new Mesh(name, scene);
+  const vd = new VertexData();
+  vd.positions = positions; vd.normals = normals; vd.uvs = uvs; vd.indices = indices;
+  vd.applyToMesh(mesh);
+  return mesh;
+}
+
+function excludeFromGlow(scene: Scene, mesh: AbstractMesh): void {
+  for (const layer of scene.effectLayers ?? []) {
+    const add = (layer as unknown as { addExcludedMesh?: (m: AbstractMesh) => void }).addExcludedMesh;
+    if (typeof add === 'function') add.call(layer, mesh);
+  }
+}
+
+export const cometTrailFlameEffectPackage: VfxEffectPackage<CometTrailFlameParams> = {
+  id: 'comet-trail-flame',
+  nameZh: '拖尾火焰',
+  debugAnchor: 'player',
+  defaultParams: DEFAULT_PARAMS,
+  debugParams: [
+    ...LIFETIME_DEBUG_PARAMS,
+    { key: 'width', label: '宽度', kind: 'scale', min: 0.3, max: 10, step: 0.1 },
+    { key: 'length', label: '长度', kind: 'scale', min: 0.5, max: 20, step: 0.1 },
+    { key: 'fps', label: '播放帧率', kind: 'number', min: 1, max: 60, step: 1 },
+    { key: 'tint', label: '火焰色', kind: 'color' },
+  ],
+
+  create({ scene, root, position, rotationY, params }) {
+    root.position.copyFrom(position);
+    root.rotation.y = rotationY;
+
+    const tex = new Texture(trailTextureUrl, scene);
+    tex.hasAlpha = true;
+    tex.uScale = 1 / 5; tex.vScale = 1 / 4; // 5列x4行序列帧
+    const mat = new StandardMaterial('vfx_trail_mat', scene);
+    mat.emissiveTexture = tex; mat.opacityTexture = tex;
+    mat.emissiveColor = new Color3(params.tint.r, params.tint.g, params.tint.b);
+    mat.alpha = 0.9; mat.disableLighting = true; mat.backFaceCulling = false;
+    mat.alphaMode = Constants.ALPHA_COMBINE;
+
+    const trailRoot = new TransformNode('vfx_trail_root', scene);
+    trailRoot.parent = root;
+    trailRoot.scaling.z = params.length;
+    const a = createTrailPlaneGeo('vfx_trail_a', params.width, 'x', scene);
+    const b = createTrailPlaneGeo('vfx_trail_b', params.width, 'y', scene);
+    for (const m of [a, b]) { m.material = mat; m.isPickable = false; m.parent = trailRoot; excludeFromGlow(scene, m); }
+
+    let t = 0;
+    const observer = scene.onBeforeRenderObservable.add(() => {
+      t += Math.min(scene.getEngine().getDeltaTime() / 1000, 0.05);
+      const f = Math.floor(t * params.fps) % 20; // 20 帧循环
+      tex.uOffset = (f % 5) / 5;
+      tex.vOffset = 1 - (Math.floor(f / 5) + 1) / 4; // V 翻转
+    });
+
+    let disposed = false;
+    let ltTimer = 0;
+    const dispose = (): void => {
+      if (disposed) return; disposed = true;
+      if (ltTimer) window.clearTimeout(ltTimer);
+      scene.onBeforeRenderObservable.remove(observer);
+      a.dispose(); b.dispose(); trailRoot.dispose();
+      mat.dispose(); tex.dispose(); root.dispose();
+    };
+    ltTimer = scheduleLifetime(params, dispose);
+    return { root, dispose };
+  },
+};

package/packages/effects/comet-trail-flame/vfx-params.json

@@ -0,0 +1,5 @@
+{
+  "schemaVersion": "vfx-params/1.0",
+  "effectId": "comet-trail-flame",
+  "params": {}
+}

package/packages/effects/conveyor-upgrade/effect.json

@@ -0,0 +1,6 @@
+{
+  "id": "conveyor-upgrade",
+  "nameZh": "传送带升级光效",
+  "source": "runtime-generated",
+  "assets": []
+}