@fps-games/vfx 0.1.1

package/packages/effects/thruster-flame/index.ts

@@ -0,0 +1,305 @@
+// 战机 shader 推进焰(移植自 babylon-laser index.html thrusterJet, 特效#14)。
+// 程序锥管 + 三段 GLSL(顶点径向舔动 + 片元 fBM 侵蚀/三段色温/马赫环 + 旋涡薄壳)+ 程序噪声纹理。
+// 纯自给:无外部贴图/glb。沿 root 局部 +Z 喷出(z=0 喷口、z=length 尾尖)。
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { VertexData } from '@babylonjs/core/Meshes/mesh.vertexData';
+import { ShaderMaterial } from '@babylonjs/core/Materials/shaderMaterial';
+import { Effect } from '@babylonjs/core/Materials/effect';
+import { RawTexture } from '@babylonjs/core/Materials/Textures/rawTexture';
+import { Texture } from '@babylonjs/core/Materials/Textures/texture';
+import { Constants } from '@babylonjs/core/Engines/constants';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import type { Scene } from '@babylonjs/core/scene';
+import type { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import type { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+import { LIFETIME_DEBUG_PARAMS, LIFETIME_DEFAULTS, scheduleLifetime } from '../space-shared';
+
+type EngineMode = 'ion' | 'chem' | 'plasma';
+
+interface ThrusterFlameParams extends VfxParamValues {
+  lifetimeMode: string; lifetime: number;
+  throttle: number;     // 推力 %(0..100)
+  flow: number;         // 流速 %(0..100)
+  afterburner: number;  // 加力 %(0..100)
+  mode: EngineMode;     // 引擎模式(运动预设:离子/化燃/等离子)
+  rootColor: VfxColorValue;
+  tipColor: VfxColorValue;
+  coreColor: VfxColorValue;
+}
+
+// ── 引擎模式预设(运动/形状;颜色由 *Color 参数控制,默认取 ion) ──────────────────
+interface Preset { diamonds: number; diamondCount: number; lenMul: number; widthMul: number; speed: number; wobble: number; intensity: number; }
+const PRESETS: Record<EngineMode, Preset> = {
+  ion:    { diamonds: 0.18, diamondCount: 6.0, lenMul: 1.15, widthMul: 0.92, speed: 1.25, wobble: 0.055, intensity: 1.0 },
+  chem:   { diamonds: 0.95, diamondCount: 5.0, lenMul: 0.85, widthMul: 1.12, speed: 1.0,  wobble: 0.075, intensity: 1.05 },
+  plasma: { diamonds: 0.45, diamondCount: 7.0, lenMul: 1.0,  widthMul: 1.0,  speed: 1.5,  wobble: 0.065, intensity: 1.05 },
+};
+
+const FLAME_LEN = 3.3;
+const FLAME_R = 0.235;
+
+const DEFAULT_PARAMS: ThrusterFlameParams = {
+  ...LIFETIME_DEFAULTS,
+  throttle: 60, flow: 50, afterburner: 0, mode: 'ion',
+  rootColor: { r: 0.42, g: 0.80, b: 1.0 },
+  tipColor: { r: 0.10, g: 0.30, b: 1.0 },
+  coreColor: { r: 1.0, g: 1.0, b: 1.0 },
+};
+
+// ── GLSL(从 babylon-laser 原样移植,一字未改)──────────────────────────────────
+const FLAME_VERTEX = `precision highp float;
+attribute vec3 position;
+attribute vec2 uv;
+uniform mat4 worldViewProjection;
+uniform float time;
+uniform float uSpeed;
+uniform float uWobble;
+varying vec2 vUV;
+void main(){
+  vUV = uv;
+  float v = uv.y;
+  float ang = uv.x * 6.2831853;
+  vec3 p = position;
+  float w = sin(v * 9.0  - time * uSpeed * 9.5 + sin(ang * 3.0 + time * 1.3) * 1.6)
+          + 0.5 * sin(v * 17.0 - time * uSpeed * 14.5 + ang * 2.0);
+  float amp = pow(v, 1.6) * uWobble;
+  p.xy += vec2(cos(ang), sin(ang)) * w * amp;
+  float sway = pow(v, 2.0) * uWobble * 1.3;
+  p.x += sin(time * 2.1) * sway;
+  p.y += cos(time * 1.6) * sway;
+  p.z *= 1.0 + 0.05 * sin(time * 13.0 + ang) * v;
+  gl_Position = worldViewProjection * vec4(p, 1.0);
+}`;
+
+const FLAME_FRAGMENT = `precision highp float;
+varying vec2 vUV;
+uniform sampler2D noiseTex;
+uniform float time;
+uniform float uSpeed;
+uniform float uIntensity;
+uniform vec3  uColorCore;
+uniform vec3  uColorRoot;
+uniform vec3  uColorTip;
+uniform float uDiamonds;
+uniform float uDiamondCount;
+void main(){
+  float v = vUV.y;
+  float u = vUV.x;
+  float n1 = texture2D(noiseTex, vec2(u * 2.0,        v * 1.8 - time * uSpeed * 2.8)).r;
+  float n2 = texture2D(noiseTex, vec2(u * 4.0 + 0.37, v * 3.6 - time * uSpeed * 5.2)).g;
+  float n  = n1 * 0.62 + n2 * 0.38;
+  float th   = mix(0.13, 0.80, pow(v, 1.15));
+  float body = smoothstep(th, th + 0.22, n);
+  float tipFade  = 1.0 - smoothstep(0.62, 1.0, v);
+  float rootCore = pow(1.0 - v, 2.2);
+  float dm = pow(abs(sin(v * uDiamondCount * 3.14159)), 16.0)
+           * (1.0 - smoothstep(0.45, 0.78, v)) * uDiamonds;
+  float heat = clamp(rootCore * 1.45 + n * 0.25 + dm * 0.85, 0.0, 1.0);
+  vec3 col = mix(uColorRoot, uColorTip, smoothstep(0.18, 0.92, v));
+  col      = mix(col, uColorCore, smoothstep(0.65, 1.0, heat));
+  float a = body * tipFade;
+  a = max(a, rootCore * 0.92);
+  float strength = (a + dm * 0.9) * uIntensity;
+  gl_FragColor = vec4(col * strength, 1.0);
+}`;
+
+const SWIRL_FRAGMENT = `precision highp float;
+varying vec2 vUV;
+uniform sampler2D noiseTex;
+uniform float time;
+uniform float uSpeed;
+uniform float uIntensity;
+uniform vec3  uColorRoot;
+void main(){
+  float v = vUV.y;
+  float u = vUV.x;
+  float n = texture2D(noiseTex,
+    vec2(u * 1.5 + v * 1.4 - time * uSpeed * 2.0, v * 1.2 - time * uSpeed * 3.8)).r;
+  float streak = smoothstep(0.55, 0.82, n);
+  float fade = sin(v * 3.14159);
+  float strength = streak * fade * uIntensity * 0.30;
+  gl_FragColor = vec4(uColorRoot * strength, 1.0);
+}`;
+
+let shadersRegistered = false;
+function registerShaders(): void {
+  if (shadersRegistered) return;
+  Effect.ShadersStore['vfxThrusterFlameVertexShader'] = FLAME_VERTEX;
+  Effect.ShadersStore['vfxThrusterFlameFragmentShader'] = FLAME_FRAGMENT;
+  Effect.ShadersStore['vfxThrusterSwirlFragmentShader'] = SWIRL_FRAGMENT;
+  shadersRegistered = true;
+}
+
+// ── 程序噪声纹理(可平铺 fBM,R/G 两套八度)──────────────────────────────────────
+function makeNoiseTexture(scene: Scene): RawTexture {
+  const S = 256;
+  const data = new Uint8Array(S * S * 4);
+  type Lat = { vals: Float32Array; g: number };
+  function lattice(seed: number, g: number): Lat {
+    const vals = new Float32Array(g * g);
+    let s = seed;
+    for (let i = 0; i < vals.length; i++) { s = (s * 16807) % 2147483647; vals[i] = (s - 1) / 2147483646; }
+    return { vals, g };
+  }
+  function sample(L: Lat, x: number, y: number): number {
+    const g = L.g; const fx = x * g, fy = y * g;
+    let x0 = Math.floor(fx), y0 = Math.floor(fy);
+    const tx = fx - x0, ty = fy - y0;
+    const sx = tx * tx * (3 - 2 * tx), sy = ty * ty * (3 - 2 * ty);
+    const x1 = (x0 + 1) % g, y1 = (y0 + 1) % g; x0 = ((x0 % g) + g) % g; y0 = ((y0 % g) + g) % g;
+    const a = L.vals[y0 * g + x0], b = L.vals[y0 * g + x1], c = L.vals[y1 * g + x0], d = L.vals[y1 * g + x1];
+    return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;
+  }
+  function fbm(layers: Lat[], x: number, y: number): number {
+    let v = 0, amp = 0.5, tot = 0;
+    for (const L of layers) { v += sample(L, x, y) * amp; tot += amp; amp *= 0.5; }
+    return v / tot;
+  }
+  const R = [lattice(1234, 4), lattice(5678, 8), lattice(91011, 16), lattice(1213, 32)];
+  const G = [lattice(4321, 8), lattice(8765, 16), lattice(1110, 32), lattice(3141, 64)];
+  for (let y = 0; y < S; y++) for (let x = 0; x < S; x++) {
+    const u = x / S, vv = y / S; const o = (y * S + x) * 4;
+    data[o] = (fbm(R, u, vv) * 255) | 0;
+    data[o + 1] = (fbm(G, u, vv) * 255) | 0;
+    data[o + 2] = 0; data[o + 3] = 255;
+  }
+  const tex = new RawTexture(data, S, S, Constants.TEXTUREFORMAT_RGBA, scene, false, false, Texture.BILINEAR_SAMPLINGMODE);
+  tex.wrapU = tex.wrapV = Texture.WRAP_ADDRESSMODE;
+  return tex;
+}
+
+// ── 喇叭锥管几何(沿 +Z,z=0 喷口、z=length 尾尖,无端盖)──────────────────────────
+function buildFlameMesh(name: string, scene: Scene, length: number, radius: number, rings: number, sides: number): Mesh {
+  const positions: number[] = [], uvs: number[] = [], indices: number[] = [];
+  for (let i = 0; i <= rings; i++) {
+    const t = i / rings;
+    const bulge = 1 + 0.30 * Math.sin(Math.PI * Math.min(t / 0.55, 1));
+    const taper = t < 0.25 ? 1 : Math.pow(1 - (t - 0.25) / 0.75, 0.78);
+    const r = radius * bulge * taper + 0.0005;
+    for (let j = 0; j <= sides; j++) {
+      const a = (j / sides) * 2 * Math.PI;
+      positions.push(Math.cos(a) * r, Math.sin(a) * r, t * length);
+      uvs.push(j / sides, t);
+    }
+  }
+  for (let i = 0; i < rings; i++) for (let j = 0; j < sides; j++) {
+    const a = i * (sides + 1) + j, b = a + 1, c = a + sides + 1, d = c + 1;
+    indices.push(a, c, b, b, c, d);
+  }
+  const mesh = new Mesh(name, scene);
+  const vd = new VertexData(); vd.positions = positions; vd.uvs = uvs; vd.indices = indices;
+  vd.applyToMesh(mesh);
+  mesh.alwaysSelectAsActiveMesh = true; // 顶点位移超出包围盒,关视锥剔除
+  mesh.isPickable = false;
+  return mesh;
+}
+
+function makeFXMaterial(name: string, scene: Scene, fragment: 'vfxThrusterFlame' | 'vfxThrusterSwirl', noiseTex: RawTexture): ShaderMaterial {
+  const mat = new ShaderMaterial(name, scene, { vertex: 'vfxThrusterFlame', fragment }, {
+    attributes: ['position', 'uv'],
+    uniforms: ['worldViewProjection', 'time', 'uSpeed', 'uWobble', 'uIntensity', 'uColorCore', 'uColorRoot', 'uColorTip', 'uDiamonds', 'uDiamondCount'],
+    samplers: ['noiseTex'],
+    needAlphaBlending: true,
+  });
+  mat.setTexture('noiseTex', noiseTex);
+  mat.alphaMode = Constants.ALPHA_ADD;
+  mat.backFaceCulling = false;
+  mat.disableDepthWrite = true;
+  return mat;
+}
+
+function v3(c: VfxColorValue): Vector3 { return new Vector3(c.r, c.g, c.b); }
+
+// 把网格从场景里任何 GlowLayer 排除(ctx 不带 glow 引用,自查 scene.effectLayers)
+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 thrusterFlameEffectPackage: VfxEffectPackage<ThrusterFlameParams> = {
+  id: 'thruster-flame',
+  nameZh: '战机尾焰',
+  defaultParams: DEFAULT_PARAMS,
+  debugAnchor: 'playerRight',
+  debugParams: [
+    ...LIFETIME_DEBUG_PARAMS,
+    { key: 'throttle', label: '推力 %', kind: 'number', min: 0, max: 100, step: 1 },
+    { key: 'flow', label: '流速 %', kind: 'number', min: 0, max: 100, step: 1 },
+    { key: 'afterburner', label: '加力 %', kind: 'number', min: 0, max: 100, step: 1 },
+    { key: 'mode', label: '引擎模式', kind: 'enum', options: [
+      { value: 'ion', label: '离子(蓝)' }, { value: 'chem', label: '化燃(橙)' }, { value: 'plasma', label: '等离子(紫)' },
+    ] },
+    { key: 'rootColor', label: '根部色', kind: 'color' },
+    { key: 'tipColor', label: '尾端色', kind: 'color' },
+    { key: 'coreColor', label: '内核色', kind: 'color' },
+  ],
+
+  create({ scene, root, position, params }) {
+    root.position.copyFrom(position);
+    registerShaders();
+    const preset = PRESETS[(params.mode as EngineMode)] ?? PRESETS.ion;
+    const noiseTex = makeNoiseTexture(scene);
+
+    const outer = buildFlameMesh('vfx_thruster_outer', scene, FLAME_LEN, FLAME_R, 30, 24);
+    const core = buildFlameMesh('vfx_thruster_core', scene, FLAME_LEN * 0.68, FLAME_R * 0.5, 24, 18);
+    const swirl = buildFlameMesh('vfx_thruster_swirl', scene, FLAME_LEN * 0.42, FLAME_R * 1.3, 14, 24);
+    for (const m of [outer, core, swirl]) { m.parent = root; excludeFromGlow(scene, m); }
+
+    const outerMat = makeFXMaterial('vfx_thruster_outerMat', scene, 'vfxThrusterFlame', noiseTex);
+    const coreMat = makeFXMaterial('vfx_thruster_coreMat', scene, 'vfxThrusterFlame', noiseTex);
+    const swirlMat = makeFXMaterial('vfx_thruster_swirlMat', scene, 'vfxThrusterSwirl', noiseTex);
+    outer.material = outerMat; core.material = coreMat; swirl.material = swirlMat;
+
+    // 颜色分配(coreMat 整体更靠 core/root;swirl 只用 root)
+    const coreCol = v3(params.coreColor), rootCol = v3(params.rootColor), tipCol = v3(params.tipColor);
+    outerMat.setVector3('uColorCore', coreCol); outerMat.setVector3('uColorRoot', rootCol); outerMat.setVector3('uColorTip', tipCol);
+    coreMat.setVector3('uColorCore', coreCol); coreMat.setVector3('uColorRoot', coreCol); coreMat.setVector3('uColorTip', rootCol);
+    swirlMat.setVector3('uColorRoot', rootCol);
+    for (const mat of [outerMat, coreMat, swirlMat]) { mat.setFloat('uDiamondCount', preset.diamondCount); mat.setFloat('uDiamonds', 0); }
+
+    // 缓动状态
+    let t = 0, throttle = 0, flow = 0, abVis = 0;
+    const targetThrottle = params.throttle / 100, targetFlow = params.flow / 100, targetAb = params.afterburner / 100;
+
+    const observer = scene.onBeforeRenderObservable.add(() => {
+      const dt = Math.min(scene.getEngine().getDeltaTime() / 1000, 0.05); t += dt;
+      const k = 1 - Math.exp(-dt * 5);
+      throttle += (targetThrottle - throttle) * k;
+      flow += (targetFlow - flow) * k;
+      abVis += (targetAb - abVis) * (1 - Math.exp(-dt * 7));
+      const eff = throttle * (1 + abVis * 0.45);
+      const flowMul = 0.2 + flow * 4.8;
+
+      const lenS = (0.3 + eff * 1.0) * preset.lenMul;
+      const widS = (0.8 + eff * 0.32) * preset.widthMul;
+      const flick = 1 + 0.04 * Math.sin(t * 17.0) + 0.03 * Math.sin(t * 29.3);
+      outer.scaling.set(widS, widS, lenS * flick);
+      core.scaling.set(widS, widS, lenS * (1 + abVis * 0.25) * flick);
+      swirl.scaling.set(widS * 1.05, widS * 1.05, Math.max(lenS * 0.85, 0.25));
+
+      const inten = preset.intensity * (0.12 + eff * 1.05);
+      const speed = preset.speed * flowMul;
+      const wob = preset.wobble * (0.7 + eff * 0.6);
+      for (const mat of [outerMat, coreMat, swirlMat]) {
+        mat.setFloat('time', t); mat.setFloat('uSpeed', speed); mat.setFloat('uWobble', wob); mat.setFloat('uIntensity', inten);
+      }
+      outerMat.setFloat('uDiamonds', preset.diamonds * Math.min(1, eff * 1.2) * (1 + abVis * 0.8));
+    });
+
+    let disposed = false;
+    let ltTimer = 0;
+    const dispose = (): void => {
+      if (disposed) return; disposed = true;
+      if (ltTimer) window.clearTimeout(ltTimer);
+      scene.onBeforeRenderObservable.remove(observer);
+      outer.dispose(); core.dispose(); swirl.dispose();
+      outerMat.dispose(); coreMat.dispose(); swirlMat.dispose();
+      noiseTex.dispose();
+      root.dispose();
+    };
+    ltTimer = scheduleLifetime(params, dispose);
+    return { root, dispose };
+  },
+};

package/packages/effects/thruster-flame/vfx-params.json

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

package/packages/effects/tree-chop-dust/effect.json

@@ -0,0 +1,8 @@
+{
+  "id": "tree-chop-dust",
+  "nameZh": "砍树烟尘",
+  "source": "runtime-generated",
+  "assets": [
+    "assets/textures/tree_chop_dust_atlas.png"
+  ]
+}

package/packages/effects/tree-chop-dust/index.ts

@@ -0,0 +1,202 @@
+import { Color4 } from '@babylonjs/core/Maths/math.color';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { Sprite } from '@babylonjs/core/Sprites/sprite';
+import { SpriteManager } from '@babylonjs/core/Sprites/spriteManager';
+import type { Scene } from '@babylonjs/core/scene';
+import type { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import type { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+import { configureVfxSpriteManager } from '../../rendering';
+import manifest from './effect.json';
+
+interface TreeChopDustParams extends VfxParamValues {
+  lifetime: number;
+  scale: number;
+  initialHeight: number;
+  color: VfxColorValue;
+  opacity: number;
+  particleCount: number;
+  emitRange: number;
+  riseHeight: number;
+  spread: number;
+  dustSize: number;
+  driftSpeed: number;
+  gravity: number;
+}
+
+interface DustSpriteState {
+  sprite: Sprite;
+  velocity: Vector3;
+  spin: number;
+  width: number;
+  height: number;
+  lifetime: number;
+  startDelay: number;
+}
+
+import DUST_TEXTURE_URL from './assets/textures/tree_chop_dust_atlas.png?url';
+
+const DEFAULT_PARAMS: TreeChopDustParams = {
+  lifetime: 0.95,
+  scale: 1,
+  initialHeight: 1.05,
+  color: { r: 0.33, g: 0.31, b: 0.28 },
+  opacity: 0.82,
+  particleCount: 28,
+  emitRange: 0.3,
+  riseHeight: 0.72,
+  spread: 0.62,
+  dustSize: 0.92,
+  driftSpeed: 0.9,
+  gravity: 0.18,
+};
+
+export const treeChopDustEffectPackage: VfxEffectPackage<TreeChopDustParams> = {
+  id: 'tree-chop-dust',
+  nameZh: '砍树烟尘',
+  manifest,
+  defaultParams: DEFAULT_PARAMS,
+  debugAnchor: 'player',
+  debugParams: [
+    { key: 'lifetime', label: '生命周期', kind: 'lifetime', min: 0.08, max: 3, step: 0.01 },
+    { key: 'scale', label: '整体缩放', kind: 'scale', min: 0.1, max: 6, step: 0.01 },
+    { key: 'initialHeight', label: '初始高度', kind: 'number', min: 0, max: 3, step: 0.01 },
+    { key: 'color', label: '烟尘颜色', kind: 'color' },
+    { key: 'opacity', label: '透明度', kind: 'opacity', min: 0, max: 1, step: 0.01 },
+    { key: 'particleCount', label: '粒子数量', kind: 'number', min: 1, max: 80, step: 1 },
+    { key: 'emitRange', label: '发射范围', kind: 'number', min: 0, max: 2, step: 0.01 },
+    { key: 'riseHeight', label: '上升高度', kind: 'number', min: 0, max: 3, step: 0.01 },
+    { key: 'spread', label: '扩散幅度', kind: 'number', min: 0, max: 4, step: 0.01 },
+    { key: 'dustSize', label: '烟尘大小', kind: 'number', min: 0.02, max: 2, step: 0.01 },
+    { key: 'driftSpeed', label: '飘散速度', kind: 'number', min: 0, max: 4, step: 0.01 },
+    { key: 'gravity', label: '下沉重力', kind: 'number', min: 0, max: 4, step: 0.01 },
+  ],
+  create({ scene, root, position, renderingGroupId, params }) {
+    root.position.copyFrom(position).addInPlace(new Vector3(0, params.initialHeight, 0));
+    const dust = createDustBurst(scene, root, params, renderingGroupId);
+    let disposed = false;
+    const disposeTimer = window.setTimeout(() => disposeAll(), (params.lifetime + 0.35) * 1000);
+
+    return {
+      root,
+      dispose() {
+        disposeAll();
+      },
+    };
+
+    function disposeAll(): void {
+      if (disposed) return;
+      disposed = true;
+      window.clearTimeout(disposeTimer);
+      dust.dispose();
+      root.dispose();
+    }
+  },
+};
+
+function createDustBurst(
+  scene: Scene,
+  root: TransformNode,
+  params: TreeChopDustParams,
+  renderingGroupId?: number,
+): { dispose(): void } {
+  const count = Math.max(1, Math.round(params.particleCount));
+  const manager = new SpriteManager('tree-chop-dust.smoke', DUST_TEXTURE_URL, count, { width: 128, height: 128 }, scene);
+  configureVfxSpriteManager(manager);
+  if (renderingGroupId !== undefined) manager.renderingGroupId = renderingGroupId;
+  manager.texture.hasAlpha = true;
+  manager.fogEnabled = false;
+
+  const effectScale = Math.max(0.05, params.scale);
+  const origin = root.getAbsolutePosition().clone();
+  const states: DustSpriteState[] = [];
+
+  for (let index = 0; index < count; index += 1) {
+    const sprite = new Sprite(`tree-chop-dust.puff.${index}`, manager);
+    const angle = sequence01(index, 0) * Math.PI * 2;
+    const radius = params.emitRange * effectScale * Math.sqrt(sequence01(index, 1));
+    const startY = (sequence01(index, 2) - 0.5) * 0.08 * effectScale;
+    const speed = params.driftSpeed * effectScale * lerp(0.55, 1.15, sequence01(index, 3));
+    const size = Math.max(0.01, params.dustSize * effectScale * lerp(0.72, 1.35, sequence01(index, 4)));
+
+    sprite.position = origin.add(new Vector3(Math.cos(angle) * radius, startY, Math.sin(angle) * radius));
+    sprite.width = size;
+    sprite.height = size * lerp(0.82, 1.16, sequence01(index, 5));
+    sprite.angle = sequence01(index, 6) * Math.PI * 2;
+    sprite.cellIndex = Math.floor(sequence01(index, 7) * 4) % 4;
+    sprite.color = toColor4(params.color, 0);
+
+    states.push({
+      sprite,
+      velocity: new Vector3(
+        Math.cos(angle) * params.spread * speed,
+        params.riseHeight * effectScale * lerp(0.18, 0.46, sequence01(index, 8)),
+        Math.sin(angle) * params.spread * speed,
+      ),
+      spin: lerp(-1.4, 1.4, sequence01(index, 9)),
+      width: sprite.width,
+      height: sprite.height,
+      lifetime: Math.max(0.05, params.lifetime * lerp(0.82, 1.14, sequence01(index, 10))),
+      startDelay: index * 0.006,
+    });
+  }
+
+  let age = 0;
+  let disposed = false;
+  const observer = scene.onBeforeRenderObservable.add(() => {
+    if (disposed) return;
+    const deltaSeconds = Math.min(0.05, scene.getEngine().getDeltaTime() / 1000);
+    age += deltaSeconds;
+    for (const state of states) {
+      const localAge = age - state.startDelay;
+      if (localAge < 0) {
+        state.sprite.isVisible = false;
+        continue;
+      }
+      const t = Math.min(1, localAge / state.lifetime);
+      const fadeIn = Math.min(1, t / 0.12);
+      const fadeOut = Math.max(0, 1 - Math.max(0, t - 0.38) / 0.62);
+      const alpha = params.opacity * fadeIn * fadeOut;
+      state.velocity.y -= params.gravity * deltaSeconds;
+      state.sprite.position.addInPlace(state.velocity.scale(deltaSeconds));
+      state.sprite.angle += state.spin * deltaSeconds;
+      const grow = 1 + t * 1.55;
+      state.sprite.width = state.width * grow;
+      state.sprite.height = state.height * grow;
+      state.sprite.color = toColor4(params.color, alpha);
+      state.sprite.isVisible = alpha > 0.01;
+    }
+    if (age >= params.lifetime + 0.18) dispose();
+  });
+
+  function dispose(): void {
+    if (disposed) return;
+    disposed = true;
+    scene.onBeforeRenderObservable.remove(observer);
+    for (const state of states) state.sprite.dispose();
+    manager.dispose();
+  }
+
+  return { dispose };
+}
+
+function toColor4(color: VfxColorValue, alpha: number): Color4 {
+  return new Color4(clamp01(color.r), clamp01(color.g), clamp01(color.b), clamp01(alpha));
+}
+
+function lerp(min: number, max: number, t: number): number {
+  return min + (max - min) * t;
+}
+
+function clamp01(value: number): number {
+  return Math.min(1, Math.max(0, value));
+}
+
+function fract(value: number): number {
+  return value - Math.floor(value);
+}
+
+function sequence01(index: number, axis: number): number {
+  if (index === 0) return 0.5;
+  const strides = [0.618033988749895, 0.414213562373095, 0.732050807568877, 0.324717957244746, 0.754877666246693, 0.569840290998053];
+  return fract(0.5 + index * strides[axis % strides.length] + axis * 0.173205080756888);
+}

package/packages/effects/tree-chop-dust/vfx-params.json

@@ -0,0 +1,21 @@
+{
+  "__generation.offsetX": 0,
+  "__generation.offsetY": 0,
+  "__generation.offsetZ": 0,
+  "lifetime": 0.5,
+  "scale": 1,
+  "initialHeight": 1.05,
+  "color": {
+    "r": 0.8352941176470589,
+    "g": 0.6980392156862745,
+    "b": 0.5058823529411764
+  },
+  "opacity": 0.82,
+  "particleCount": 28,
+  "emitRange": 0.3,
+  "riseHeight": 0.72,
+  "spread": 0.62,
+  "dustSize": 0.92,
+  "driftSpeed": 0.9,
+  "gravity": 0.18
+}