@fps-games/vfx 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+`@fps/vfx` 的版本变更记录。由 `pnpm release -- <patch|minor|major>` 自动追加(见 `scripts/release.mjs`)。
+
+版本语义(semver):
+- **patch `0.1.x`** — 改 bug / 调参 / 换资源,无 API 变化。
+- **minor `0.x.0`** — 新增特效 / 新功能,向后兼容。
+- **major `x.0.0`** — `VfxEffectPackage` 契约 / runtime API 破坏性变化,或删除特效。
+
+分发形态:git tag + 提交 dist(做法A)。消费方 `pnpm add git+ssh://git@github.com/forge-play-studio/fps-vfx-library.git#vX.Y.Z`;
+升级用 `node node_modules/@fps/vfx/tooling/vfx-cli.mjs update --project .`(见 issue #4)。
+
+<!-- release.mjs 在此行下方插入新版本区块 -->
+
+## v0.1.1 — 2026-06-27
+
+### 改动
+- `lumber-debris-scatter` 改用精简 glTF loader `@babylonjs/loaders/glTF/2.0/glTFLoader`(只注册 2.0 核心),
+  不再急切注册 `EXT_meshopt_compression` → 不把 `MeshoptDecoder` 拉进 consumer 包。
+  修复 lumber-order prod 单文件 Playable 构建被 meshopt 检查卡住的问题。
+
+### 特效
+- 无新增 / 删除(仍 23 个)。
+
+## v0.1.0 — 2026-06-27
+
+### 首个发布形态
+- `@fps/vfx` 纯净可消费单 ESM 包:vite lib-mode dist(index + 每特效多入口)+ `vite-plugin-dts`。
+- 资源全内联 base64(纹理 `data:image/png` / GLB `data:model/gltf-binary`);babylon 走 peer(external)。
+- 分发 = git tag + 提交 dist(做法A);消费方 `import '@fps/vfx'` 解析到 dist。
+- 纯净契约 boundary 0(`tooling/validate-boundary.mjs`)。
+
+### 特效
+- 23 个特效(code / data / code+mesh+GLB);见 `index.json`。

package/dist/EffectPackageService.d.ts

@@ -0,0 +1,26 @@
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { Scene } from '@babylonjs/core/scene';
+import { VfxRegistry } from './registry';
+import { VfxDebugAnchor, VfxEffectHandle, VfxEffectPackage, VfxParamValues, VfxSpawnTransform } from './types';
+export interface EffectPackageServiceOptions {
+    /** 注入的注册表(由项目侧 glob + buildRegistry 构建);库不直接引用项目注册表 */
+    registry: VfxRegistry;
+    getDebugAnchorPosition?: (anchor: VfxDebugAnchor) => Vector3 | null;
+}
+export declare class EffectPackageService {
+    private readonly scene;
+    private readonly registry;
+    private readonly getDebugAnchorPosition?;
+    private readonly activeHandles;
+    private readonly savedParams;
+    constructor(scene: Scene, options: EffectPackageServiceOptions);
+    getEffectPackages(): VfxEffectPackage[];
+    getEffectPackage(effectId: string): VfxEffectPackage | undefined;
+    getMergedParams(effectId: string, explicitParams?: Partial<VfxParamValues>): VfxParamValues | null;
+    getDebugOverride(effectId: string): Partial<VfxParamValues>;
+    setDebugOverride(effectId: string, params: Partial<VfxParamValues>): void;
+    playEffectPackage(effectId: string, explicitParams?: Partial<VfxParamValues>, spawnTransform?: VfxSpawnTransform | Vector3): VfxEffectHandle | null;
+    dispose(): void;
+    private resolveDebugPosition;
+    private resolveSpawnTransform;
+}

package/dist/SceneVfxService.d.ts

@@ -0,0 +1,27 @@
+import { Scene } from '@babylonjs/core/scene';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { VfxRegistry } from './registry';
+import { VfxDebugAnchor, VfxEffectHandle, VfxEffectPackage, VfxParamValues, VfxSpawnTransform } from './types';
+import { EffectPackageService } from './EffectPackageService';
+export interface SceneVfxWarmupEntry {
+    effectId: string;
+    params?: Partial<VfxParamValues>;
+    spawnTransform?: VfxSpawnTransform | Vector3;
+}
+export interface SceneVfxServiceOptions {
+    /** 注入的注册表(项目侧 glob + buildRegistry 构建) */
+    registry: VfxRegistry;
+    getDebugAnchorPosition?: (anchor: VfxDebugAnchor) => Vector3 | null;
+}
+export declare class SceneVfxService {
+    private effectPackageService;
+    constructor(scene: Scene, options: SceneVfxServiceOptions);
+    getEffectPackageService(): EffectPackageService;
+    getEffectPackages(): VfxEffectPackage[];
+    getMergedParams(effectId: string, explicitParams?: Partial<VfxParamValues>): VfxParamValues | null;
+    playEffectPackage(effectId: string, params?: Partial<VfxParamValues>, spawnTransform?: VfxSpawnTransform | Vector3): VfxEffectHandle | null;
+    warmupEffectPackages(entries: SceneVfxWarmupEntry[]): Promise<void>;
+    private warmupEffectPackage;
+    private waitForAnimationFrames;
+    dispose(): void;
+}

package/dist/chunks/legacy-particle-runtime-CbJYVxdd.js

@@ -0,0 +1,75 @@
+import { Color4 } from "@babylonjs/core/Maths/math.color";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture";
+import { ParticleSystem } from "@babylonjs/core/Particles/particleSystem";
+const LEGACY_BABYLON = {
+  Color4,
+  Vector3,
+  Texture,
+  ParticleSystem
+};
+function startLegacyParticleRuntime(options) {
+  let disposed = false;
+  const previews = [];
+  void import(
+    /* @vite-ignore */
+    options.runtimeUrl
+  ).then((module) => {
+    if (disposed) return;
+    return Promise.all(options.emitters.map((emitter, index) => module.createParticleEmitterRuntime({
+      BABYLON: LEGACY_BABYLON,
+      scene: options.scene,
+      emitter,
+      index,
+      urlForPackagePath: (packagePath) => options.assetUrls[packagePath] ?? packagePath,
+      shouldStart: true
+    })));
+  }).then((nextPreviews) => {
+    if (!nextPreviews) return;
+    if (disposed) {
+      for (const preview of nextPreviews) preview.dispose();
+      return;
+    }
+    previews.push(...nextPreviews);
+  }).catch((error) => {
+    if (disposed) return;
+    options.onError?.(error);
+  });
+  return {
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const preview of previews) preview.dispose();
+      previews.length = 0;
+    }
+  };
+}
+function cloneLegacyEmitters(value) {
+  if (!Array.isArray(value)) return [];
+  return JSON.parse(JSON.stringify(value));
+}
+function setNestedValue(target, path, value) {
+  const parts = path.split(".");
+  let cursor = target;
+  for (let index = 0; index < parts.length - 1; index += 1) {
+    const key = parts[index];
+    const child = cursor[key];
+    if (!child || typeof child !== "object" || Array.isArray(child)) {
+      const next = {};
+      cursor[key] = next;
+      cursor = next;
+    } else {
+      cursor = child;
+    }
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+function findEmitter(emitters, name) {
+  return emitters.find((emitter) => emitter.name === name) ?? null;
+}
+export {
+  setNestedValue as a,
+  cloneLegacyEmitters as c,
+  findEmitter as f,
+  startLegacyParticleRuntime as s
+};

package/dist/chunks/manifestRuntimePackage-CXQFSTo2.js

@@ -0,0 +1,356 @@
+import { Engine } from "@babylonjs/core/Engines/engine";
+import { Color4, Color3 } from "@babylonjs/core/Maths/math.color";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { Material } from "@babylonjs/core/Materials/material";
+import { MaterialPluginBase } from "@babylonjs/core/Materials/materialPluginBase";
+import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial";
+import { DynamicTexture } from "@babylonjs/core/Materials/Textures/dynamicTexture";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture";
+import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial";
+import { CreateBox } from "@babylonjs/core/Meshes/Builders/boxBuilder";
+import { CreateCylinder } from "@babylonjs/core/Meshes/Builders/cylinderBuilder";
+import { CreateDisc } from "@babylonjs/core/Meshes/Builders/discBuilder";
+import { CreatePlane } from "@babylonjs/core/Meshes/Builders/planeBuilder";
+import { CreateTube } from "@babylonjs/core/Meshes/Builders/tubeBuilder";
+import { Mesh } from "@babylonjs/core/Meshes/mesh";
+import { VertexData } from "@babylonjs/core/Meshes/mesh.vertexData";
+import { TransformNode } from "@babylonjs/core/Meshes/transformNode";
+import { ParticleSystem } from "@babylonjs/core/Particles/particleSystem";
+import { SolidParticleSystem } from "@babylonjs/core/Particles/solidParticleSystem";
+import { SceneLoader } from "@babylonjs/core/Loading/sceneLoader";
+const BABYLON_RUNTIME_API = {
+  Color3,
+  Color4,
+  DynamicTexture,
+  Engine,
+  Material,
+  MaterialPluginBase,
+  Mesh,
+  MeshBuilder: {
+    CreateBox,
+    CreateCylinder,
+    CreateDisc,
+    CreatePlane,
+    CreateTube
+  },
+  PBRMaterial,
+  ParticleSystem,
+  SceneLoader,
+  SolidParticleSystem,
+  StandardMaterial,
+  Texture,
+  TransformNode,
+  Vector3,
+  VertexData
+};
+function createManifestRuntimeEffectPackage(options) {
+  const { id, manifest, assetUrls } = options;
+  return {
+    id,
+    nameZh: manifest.name?.zh ?? manifest.name?.en ?? id,
+    manifest: {
+      id: manifest.id ?? id,
+      nameZh: manifest.name?.zh ?? manifest.name?.en ?? id,
+      assets: collectManifestAssetPaths(manifest),
+      source: readManifestSource(manifest)
+    },
+    defaultParams: buildDefaultParams(manifest),
+    debugAnchor: normalizeDebugAnchor(manifest.debug?.playAnchor),
+    debugParams: buildDebugParams(manifest),
+    create(context) {
+      return createManifestRuntimeHandle(context, manifest, assetUrls, id);
+    }
+  };
+}
+function createManifestRuntimeHandle(context, manifest, assetUrls, effectId) {
+  const root = context.root;
+  const previews = [];
+  const cleanupCallbacks = [];
+  let disposed = false;
+  const ready = startRuntimePreviews().catch((error) => {
+    console.warn(`[VFX] Failed to play effect package "${effectId}".`, error);
+  });
+  return {
+    root,
+    ready,
+    dispose() {
+      disposed = true;
+      for (const cleanup of cleanupCallbacks.splice(0)) cleanup();
+      for (const preview of previews.splice(0)) {
+        preview.stop?.();
+        preview.dispose?.();
+      }
+      disposeRoot(root);
+    }
+  };
+  async function startRuntimePreviews() {
+    const emitters = (manifest.emitters ?? []).filter((emitter) => emitter.enabled !== false).map(cloneEmitter);
+    for (const [index, emitter] of emitters.entries()) {
+      if (disposed) return;
+      applyTunableValues(emitter, manifest.tunableParams ?? [], context.params);
+      emitter.origin = {
+        x: context.position.x,
+        y: context.position.y,
+        z: context.position.z
+      };
+      emitter.rotationY = root.rotation.y;
+      const preview = await playEmitter(manifest, emitter, assetUrls, index, effectId, context.scene);
+      if (!preview) continue;
+      if (disposed) {
+        preview.stop?.();
+        preview.dispose?.();
+        continue;
+      }
+      syncPreviewPosition(context, preview, cleanupCallbacks);
+      previews.push(preview);
+    }
+  }
+}
+function syncPreviewPosition(context, preview, cleanupCallbacks) {
+  if (typeof preview.setPosition !== "function") return;
+  preview.setPosition(context.root.getAbsolutePosition());
+  const observer = context.scene.onBeforeRenderObservable.add(() => {
+    preview.setPosition?.(context.root.getAbsolutePosition());
+    preview.setScaling?.(context.root.scaling);
+  });
+  cleanupCallbacks.push(() => {
+    context.scene.onBeforeRenderObservable.remove(observer);
+  });
+}
+async function playEmitter(manifest, emitter, assetUrls, index, effectId, scene) {
+  const adapterId = resolveEmitterAdapterId(manifest, emitter);
+  if (!adapterId) {
+    console.warn(`[VFX] Missing runtime adapter for ${effectId}/${emitter.name}`);
+    return null;
+  }
+  const adapter = manifest.runtime?.adapters?.find((item) => item.id === adapterId) ?? manifest.runtime?.adapters?.[0];
+  if (!adapter) {
+    console.warn(`[VFX] Adapter "${adapterId}" is not registered in ${effectId}`);
+    return null;
+  }
+  const adapterUrl = assetUrls[adapter.entry];
+  if (!adapterUrl) {
+    console.warn(`[VFX] Missing runtime asset "${adapter.entry}" for ${effectId}`);
+    return null;
+  }
+  const runtimeModule = await import(
+    /* @vite-ignore */
+    adapterUrl
+  );
+  const createRuntimeName = adapter.exports?.find((name) => name.startsWith("create")) ?? getRuntimeFactoryName(adapter.id);
+  const createRuntime = runtimeModule[createRuntimeName];
+  if (typeof createRuntime !== "function") {
+    console.warn(`[VFX] Runtime "${adapter.id}" does not export "${createRuntimeName}"`);
+    return null;
+  }
+  return await createRuntime({
+    BABYLON: BABYLON_RUNTIME_API,
+    scene,
+    emitter,
+    index,
+    shouldStart: true,
+    urlForPackagePath: (packagePath) => assetUrls[packagePath] ?? packagePath
+  });
+}
+function resolveEmitterAdapterId(manifest, emitter) {
+  const runtimeAdapter = emitter.runtime?.adapter;
+  if (runtimeAdapter) return runtimeAdapter;
+  const adapters = manifest.runtime?.adapters ?? [];
+  if (adapters.length === 1) return adapters[0].id;
+  if (manifest.runtime?.driver === "solidParticleScatter") return "solidParticleScatter/v1";
+  if (manifest.runtime?.driver === "particle") return "particleEmitter/v1";
+  return adapters[0]?.id;
+}
+function getRuntimeFactoryName(adapterId) {
+  if (adapterId === "solidParticleScatter/v1") return "createSolidParticleScatterRuntime";
+  if (adapterId === "particleEmitter/v1") return "createParticleEmitterRuntime";
+  if (adapterId === "gearSpin/v1") return "createGearSpinRuntime";
+  if (adapterId === "goldFlakes/v1") return "createGoldFlakesRuntime";
+  if (adapterId === "upgradeAura/v1") return "createUpgradeAuraRuntime";
+  if (adapterId === "woodPeelMaterialTest/v1") return "createWoodPeelMaterialTestRuntime";
+  if (adapterId === "simpleMeshEffect/v1") return "createSimpleMeshEffectRuntime";
+  return "createVfxRuntime";
+}
+function applyTunableValues(emitter, params, values) {
+  for (const param of params) {
+    if (!(param.key in values)) continue;
+    const targets = param.targets ?? (param.target ? [param.target] : []);
+    for (const target of targets) {
+      if (target.emitter !== emitter.name) continue;
+      applyTunableTarget(emitter, target, values[param.key]);
+    }
+  }
+}
+function applyTunableTarget(emitter, target, value) {
+  const operator = target.operator ?? "set";
+  if (operator === "set") {
+    setNestedValue(emitter, target.property, normalizeTunableValue(emitter, target.property, value));
+    return;
+  }
+  if (operator === "scaleDefault") {
+    const multiplier = Number(value);
+    const baseValue = Number(target.defaultValue ?? getNestedValue(emitter, target.property));
+    if (!Number.isFinite(multiplier) || !Number.isFinite(baseValue)) return;
+    setNestedValue(emitter, target.property, baseValue * multiplier);
+    return;
+  }
+  if (operator === "scaleVectorDefault") {
+    const multiplier = Number(value);
+    if (!Number.isFinite(multiplier)) return;
+    setNestedValue(emitter, target.property, scaleVectorDefaultValue(target.defaultValue, multiplier));
+  }
+}
+function scaleVectorDefaultValue(defaultValue, multiplier) {
+  if (!defaultValue || typeof defaultValue !== "object" || Array.isArray(defaultValue)) return defaultValue;
+  const source = defaultValue;
+  const scaleAxes = source.scaleAxes && typeof source.scaleAxes === "object" && !Array.isArray(source.scaleAxes) ? source.scaleAxes : { x: true, y: true, z: true };
+  const scaleComponent = (axis) => {
+    const base = Number(source[axis] ?? 0);
+    if (!Number.isFinite(base)) return 0;
+    return scaleAxes[axis] === false ? base : base * multiplier;
+  };
+  return {
+    x: scaleComponent("x"),
+    y: scaleComponent("y"),
+    z: scaleComponent("z")
+  };
+}
+function setNestedValue(target, path, value) {
+  const parts = path.split(".").filter(Boolean);
+  if (parts.length === 0) return;
+  let cursor = target;
+  for (const part of parts.slice(0, -1)) {
+    const next = cursor[part];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      cursor[part] = {};
+    }
+    cursor = cursor[part];
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+function normalizeTunableValue(emitter, path, value) {
+  if (isColorValue(value)) {
+    return {
+      r: value.r,
+      g: value.g,
+      b: value.b,
+      a: readExistingAlpha(emitter, path)
+    };
+  }
+  if (typeof value !== "string" || !/^#[0-9a-f]{6}$/i.test(value)) return value;
+  const alpha = readExistingAlpha(emitter, path);
+  return {
+    r: parseInt(value.slice(1, 3), 16) / 255,
+    g: parseInt(value.slice(3, 5), 16) / 255,
+    b: parseInt(value.slice(5, 7), 16) / 255,
+    a: alpha
+  };
+}
+function readExistingAlpha(emitter, path) {
+  const existing = getNestedValue(emitter, path);
+  const alpha = existing && typeof existing === "object" && "a" in existing ? Number(existing.a) : 1;
+  return Number.isFinite(alpha) ? alpha : 1;
+}
+function getNestedValue(target, path) {
+  let cursor = target;
+  for (const part of path.split(".").filter(Boolean)) {
+    if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) return void 0;
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function buildDefaultParams(manifest) {
+  const params = {};
+  for (const [key, value] of Object.entries(manifest.defaultParams ?? {})) {
+    if (isVfxParamValue(value)) params[key] = value;
+  }
+  for (const param of manifest.tunableParams ?? []) {
+    if (param.default !== void 0 && isVfxParamValue(param.default)) {
+      params[param.key] = param.default;
+    }
+  }
+  return params;
+}
+function buildDebugParams(manifest) {
+  const result = [];
+  for (const param of manifest.tunableParams ?? []) {
+    const label = param.labelZh ?? param.label ?? param.labelEn ?? param.key;
+    if (param.type === "number") {
+      result.push({
+        key: param.key,
+        label,
+        kind: "number",
+        min: param.min,
+        max: param.max,
+        step: param.step
+      });
+      continue;
+    }
+    if (param.type === "color") {
+      result.push({
+        key: param.key,
+        label,
+        kind: "color"
+      });
+      continue;
+    }
+    if (param.type === "enum" && Array.isArray(param.options)) {
+      result.push({
+        key: param.key,
+        label,
+        kind: "enum",
+        options: param.options.map((option) => ({
+          value: option.value,
+          label: option.label ?? option.value
+        }))
+      });
+    }
+  }
+  return result;
+}
+function isVfxParamValue(value) {
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value === "string") return true;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const color = value;
+  return typeof color.r === "number" && Number.isFinite(color.r) && typeof color.g === "number" && Number.isFinite(color.g) && typeof color.b === "number" && Number.isFinite(color.b);
+}
+function isColorValue(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const color = value;
+  return typeof color.r === "number" && Number.isFinite(color.r) && typeof color.g === "number" && Number.isFinite(color.g) && typeof color.b === "number" && Number.isFinite(color.b);
+}
+function normalizeDebugAnchor(value) {
+  return value === "player" || value === "playerRight" ? value : void 0;
+}
+function collectManifestAssetPaths(manifest) {
+  const paths = [];
+  const collect = (value) => {
+    if (Array.isArray(value)) {
+      for (const item of value) collect(item);
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    const record = value;
+    if (typeof record.packagePath === "string") paths.push(record.packagePath);
+    for (const child of Object.values(record)) collect(child);
+  };
+  collect(manifest.assets);
+  return Array.from(new Set(paths));
+}
+function readManifestSource(manifest) {
+  if (typeof manifest.source === "string") return manifest.source;
+  if (!manifest.source || typeof manifest.source !== "object") return void 0;
+  const source = manifest.source;
+  return typeof source.sourceId === "string" ? source.sourceId : void 0;
+}
+function cloneEmitter(emitter) {
+  return JSON.parse(JSON.stringify(emitter));
+}
+function disposeRoot(root) {
+  if (typeof root.isDisposed === "function" && root.isDisposed()) return;
+  root.dispose(false, true);
+}
+export {
+  createManifestRuntimeEffectPackage as c
+};

package/dist/chunks/rendering-CV3nhygX.js

@@ -0,0 +1,13 @@
+const VFX_RENDERING_GROUP_ID = 2;
+function configureVfxSpriteManager(manager) {
+  manager.renderingGroupId = VFX_RENDERING_GROUP_ID;
+  manager.disableDepthWrite = true;
+}
+function configureVfxParticleSystem(system) {
+  system.renderingGroupId = VFX_RENDERING_GROUP_ID;
+}
+export {
+  VFX_RENDERING_GROUP_ID as V,
+  configureVfxSpriteManager as a,
+  configureVfxParticleSystem as c
+};

package/dist/chunks/space-shared-BXV1hc0k.js

@@ -0,0 +1,124 @@
+import { ParticleSystem } from "@babylonjs/core/Particles/particleSystem";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture";
+import { DynamicTexture } from "@babylonjs/core/Materials/Textures/dynamicTexture";
+import "@babylonjs/core/Maths/math.color";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+const LIFETIME_DEBUG_PARAMS = [
+  { key: "lifetimeMode", label: "生命周期模式", kind: "enum", options: [
+    { value: "infinite", label: "无限" },
+    { value: "duration", label: "自定义时间" }
+  ] },
+  { key: "lifetime", label: "自定义时长", kind: "lifetime", min: 0.1, max: 30, step: 0.01 }
+];
+const LIFETIME_DEFAULTS = { lifetimeMode: "infinite", lifetime: 2 };
+function scheduleLifetime(params, dispose) {
+  if (params.lifetimeMode === "duration") return window.setTimeout(dispose, Math.max(0.05, params.lifetime ?? 2) * 1e3);
+  return 0;
+}
+function makeFlareTexture(scene, name = "vfx_flare", inner = "255,255,255", outer = "90,160,255") {
+  const dt = new DynamicTexture(name, 128, scene, false);
+  const ctx = dt.getContext();
+  const g = ctx.createRadialGradient(64, 64, 0, 64, 64, 64);
+  g.addColorStop(0, `rgba(${inner},1)`);
+  g.addColorStop(0.35, `rgba(${outer},0.55)`);
+  g.addColorStop(1, `rgba(${outer},0)`);
+  ctx.clearRect(0, 0, 128, 128);
+  ctx.fillStyle = g;
+  ctx.fillRect(0, 0, 128, 128);
+  dt.update();
+  dt.hasAlpha = true;
+  return dt;
+}
+function makeBurstPS(name, scene, texUrl, opts) {
+  const ps = new ParticleSystem(name, opts.cap, scene, null, !!opts.sheet);
+  ps.particleTexture = new Texture(texUrl, scene);
+  ps.particleTexture.hasAlpha = true;
+  ps.emitter = new Vector3(0, 0, 0);
+  ps.minEmitBox = new Vector3(0, 0, 0);
+  ps.maxEmitBox = new Vector3(0, 0, 0);
+  ps.direction1 = new Vector3(-1, -1, -1);
+  ps.direction2 = new Vector3(1, 1, 1);
+  ps.minInitialRotation = -Math.PI;
+  ps.maxInitialRotation = Math.PI;
+  ps.minSize = opts.size[0];
+  ps.maxSize = opts.size[1];
+  ps.minLifeTime = opts.life[0];
+  ps.maxLifeTime = opts.life[1];
+  ps.minEmitPower = opts.power[0];
+  ps.maxEmitPower = opts.power[1];
+  ps.gravity = opts.gravity;
+  ps.color1 = opts.c1;
+  ps.color2 = opts.c2;
+  ps.colorDead = opts.cd;
+  ps.blendMode = opts.blend;
+  ps.emitRate = 0;
+  if (opts.sheet) {
+    ps.spriteCellWidth = opts.sheet[0];
+    ps.spriteCellHeight = opts.sheet[1];
+    ps.startSpriteCellID = 0;
+    ps.endSpriteCellID = opts.sheet[2] - 1;
+    ps.spriteCellChangeSpeed = 1;
+  }
+  ps.start();
+  return ps;
+}
+class FlyerPool {
+  constructor(scene) {
+    this.scene = scene;
+    this.flyers = [];
+    this.disposed = false;
+    this.observer = scene.onBeforeRenderObservable.add(() => this.update());
+  }
+  spawn(mesh, origin, vel, gravity, maxLife) {
+    mesh.position.copyFrom(origin);
+    mesh.isPickable = false;
+    this.flyers.push({
+      mesh,
+      vel,
+      gravity,
+      maxLife,
+      life: 0,
+      base: mesh.scaling.x || 1,
+      spin: new Vector3((Math.random() - 0.5) * 8, (Math.random() - 0.5) * 8, (Math.random() - 0.5) * 8)
+    });
+  }
+  get activeCount() {
+    return this.flyers.length;
+  }
+  update() {
+    if (this.disposed) return;
+    const dt = Math.min(this.scene.getEngine().getDeltaTime() / 1e3, 0.05);
+    for (let i = this.flyers.length - 1; i >= 0; i--) {
+      const f = this.flyers[i];
+      f.life += dt;
+      f.vel.y -= f.gravity * dt;
+      f.mesh.position.addInPlace(f.vel.scale(dt));
+      f.mesh.rotation.x += f.spin.x * dt;
+      f.mesh.rotation.y += f.spin.y * dt;
+      f.mesh.rotation.z += f.spin.z * dt;
+      if (f.life > f.maxLife * 0.7) {
+        const k = Math.max(1e-3, 1 - (f.life - f.maxLife * 0.7) / (f.maxLife * 0.3));
+        f.mesh.scaling.setAll(f.base * k);
+      }
+      if (f.life >= f.maxLife) {
+        f.mesh.dispose();
+        this.flyers.splice(i, 1);
+      }
+    }
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.scene.onBeforeRenderObservable.remove(this.observer);
+    for (const f of this.flyers) f.mesh.dispose();
+    this.flyers.length = 0;
+  }
+}
+export {
+  FlyerPool as F,
+  LIFETIME_DEBUG_PARAMS as L,
+  LIFETIME_DEFAULTS as a,
+  makeFlareTexture as b,
+  makeBurstPS as m,
+  scheduleLifetime as s
+};