@fps-games/vfx 0.1.1

package/packages/effects/tree-leaf-chop-burst/index.ts

@@ -0,0 +1,294 @@
+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';
+
+interface TreeLeafChopBurstParams extends VfxParamValues {
+  lifetime: number;
+  scale: number;
+  initialHeight: number;
+  leafColor: VfxColorValue;
+  deadColor: VfxColorValue;
+  opacity: number;
+  particleCount: number;
+  emitRange: number;
+  riseHeight: number;
+  spread: number;
+  minSpeed: number;
+  maxSpeed: number;
+  leafSize: number;
+  gravity: number;
+}
+
+interface SourceEmitter {
+  capacity?: unknown;
+  manualEmitCount?: unknown;
+  effectScale?: unknown;
+  minSize?: unknown;
+  maxSize?: unknown;
+  minLifeTime?: unknown;
+  maxLifeTime?: unknown;
+  minEmitPower?: unknown;
+  maxEmitPower?: unknown;
+  updateSpeed?: unknown;
+  gravity?: { y?: unknown };
+  shape?: {
+    direction1?: { x?: unknown; y?: unknown; z?: unknown };
+    direction2?: { x?: unknown; y?: unknown; z?: unknown };
+    minEmitBox?: { x?: unknown; y?: unknown; z?: unknown };
+    maxEmitBox?: { x?: unknown; y?: unknown; z?: unknown };
+  };
+  runtime?: {
+    stopAfterSeconds?: unknown;
+  };
+}
+
+interface LeafSpriteState {
+  sprite: Sprite;
+  velocity: Vector3;
+  spin: number;
+  width: number;
+  height: number;
+  lifetime: number;
+}
+
+import LEAF_TEXTURE_URL from './assets/textures/tree_leaf_chop_burst_leaf_atlas.png?url';
+const SOURCE_EMITTER: SourceEmitter = {
+  manualEmitCount: 42,
+  effectScale: 1,
+  maxSize: 0.21,
+  maxLifeTime: 0.775,
+  minEmitPower: 3.125,
+  maxEmitPower: 3.125,
+  gravity: { y: -3.8 },
+  shape: {
+    direction1: { x: -1.103, y: 0.55, z: -0.62 },
+    direction2: { x: 0.943, y: 1.85, z: 0.62 },
+    minEmitBox: { x: -0.08, y: 0.05, z: -0.08 },
+    maxEmitBox: { x: 0.08, y: 0.18, z: 0.08 },
+  },
+  runtime: { stopAfterSeconds: 1.25 },
+};
+const SOURCE_SHAPE = SOURCE_EMITTER.shape ?? {};
+
+const DEFAULT_PARAMS: TreeLeafChopBurstParams = {
+  lifetime: readNumber(SOURCE_EMITTER.maxLifeTime, 0.775),
+  scale: readNumber(SOURCE_EMITTER.effectScale, 1),
+  initialHeight: 1.4,
+  leafColor: { r: 0.82, g: 1, b: 0.32 },
+  deadColor: { r: 0.54, g: 0.43, b: 0.12 },
+  opacity: 1,
+  particleCount: readNumber(SOURCE_EMITTER.manualEmitCount, 42),
+  emitRange: Math.max(
+    Math.abs(readNumber(SOURCE_SHAPE.minEmitBox?.x, -0.08)),
+    Math.abs(readNumber(SOURCE_SHAPE.maxEmitBox?.x, 0.08)),
+    0.08,
+  ),
+  riseHeight: Math.max(
+    readNumber(SOURCE_SHAPE.direction1?.y, 0.55),
+    readNumber(SOURCE_SHAPE.direction2?.y, 1.85),
+  ),
+  spread: Math.max(
+    Math.abs(readNumber(SOURCE_SHAPE.direction1?.x, -1.103)),
+    Math.abs(readNumber(SOURCE_SHAPE.direction2?.x, 0.943)),
+    Math.abs(readNumber(SOURCE_SHAPE.direction1?.z, -0.62)),
+    Math.abs(readNumber(SOURCE_SHAPE.direction2?.z, 0.62)),
+  ),
+  minSpeed: readNumber(SOURCE_EMITTER.minEmitPower, 3.125),
+  maxSpeed: readNumber(SOURCE_EMITTER.maxEmitPower, 3.125),
+  leafSize: readNumber(SOURCE_EMITTER.maxSize, 0.21),
+  gravity: Math.abs(readNumber(SOURCE_EMITTER.gravity?.y, -3.8)),
+};
+
+export const treeLeafChopBurstEffectPackage: VfxEffectPackage<TreeLeafChopBurstParams> = {
+  id: 'tree-leaf-chop-burst',
+  nameZh: '砍树树叶溅射',
+  manifest: {
+    id: 'build.particle.tree_leaf_chop_burst',
+    nameZh: '砍树树叶溅射',
+    assets: [
+      'assets/textures/tree_leaf_chop_burst_leaf_atlas.png',
+    ],
+    source: 'tree_leaf_chop_burst.json',
+  },
+  defaultParams: DEFAULT_PARAMS,
+  debugAnchor: 'player',
+  debugParams: [
+    { key: 'lifetime', label: '生命周期', kind: 'lifetime', min: 0.08, max: 4, step: 0.01 },
+    { key: 'scale', label: '整体缩放', kind: 'scale', min: 0.1, max: 8, step: 0.01 },
+    { key: 'initialHeight', label: '初始高度', kind: 'number', min: 0, max: 5, step: 0.01 },
+    { key: 'leafColor', label: '叶子颜色', kind: 'color' },
+    { key: 'deadColor', label: '消失颜色', kind: 'color' },
+    { key: 'opacity', label: '透明度', kind: 'opacity', min: 0, max: 1, step: 0.01 },
+    { key: 'particleCount', label: '粒子数量', kind: 'number', min: 1, max: 160, step: 1 },
+    { key: 'emitRange', label: '发射范围', kind: 'number', min: 0, max: 2, step: 0.01 },
+    { key: 'riseHeight', label: '上升高度', kind: 'number', min: 0, max: 6, step: 0.01 },
+    { key: 'spread', label: '扩散幅度', kind: 'number', min: 0, max: 8, step: 0.01 },
+    { key: 'minSpeed', label: '最小速度', kind: 'number', min: 0, max: 20, step: 0.01 },
+    { key: 'maxSpeed', label: '最大速度', kind: 'number', min: 0, max: 30, step: 0.01 },
+    { key: 'leafSize', label: '叶片大小', kind: 'number', min: 0.01, max: 3, step: 0.01 },
+    { key: 'gravity', label: '下落重力', kind: 'number', min: 0, max: 16, step: 0.01 },
+  ],
+  create({ scene, root, position, renderingGroupId, params }) {
+    root.position.copyFrom(position).addInPlace(new Vector3(0, params.initialHeight, 0));
+    const leaves = createLeafSpriteBurst(scene, root, params, renderingGroupId);
+    let disposed = false;
+
+    const disposeDelay = getDisposeDelaySeconds(params);
+    const disposeTimer = window.setTimeout(() => disposeAll(), disposeDelay * 1000);
+
+    return {
+      root,
+      dispose() {
+        disposeAll();
+      },
+    };
+
+    function disposeAll(): void {
+      if (disposed) return;
+      disposed = true;
+      window.clearTimeout(disposeTimer);
+      leaves.dispose();
+      root.dispose();
+    }
+  },
+};
+
+function createLeafSpriteBurst(
+  scene: Scene,
+  root: TransformNode,
+  params: TreeLeafChopBurstParams,
+  renderingGroupId?: number,
+): { dispose(): void } {
+  const count = Math.max(1, Math.round(params.particleCount));
+  const spatialScale = Math.sqrt(Math.max(0.1, params.scale));
+  const manager = new SpriteManager('tree-leaf-chop-burst.leaves', LEAF_TEXTURE_URL, count, { width: 128, height: 128 }, scene);
+  configureVfxSpriteManager(manager);
+  if (renderingGroupId !== undefined) manager.renderingGroupId = renderingGroupId;
+  manager.texture.hasAlpha = true;
+  manager.texture.getAlphaFromRGB = false;
+  manager.fogEnabled = false;
+
+  const minSpeed = Math.max(0, Math.min(params.minSpeed, params.maxSpeed));
+  const maxSpeed = Math.max(minSpeed, params.maxSpeed);
+  const minLife = Math.max(0.03, params.lifetime * 0.72);
+  const maxLife = Math.max(minLife, params.lifetime);
+  const origin = root.getAbsolutePosition().clone();
+  const states: LeafSpriteState[] = [];
+
+  for (let index = 0; index < count; index += 1) {
+    const sprite = new Sprite(`tree-leaf-chop-burst.leaf.${index}`, manager);
+    const localPosition = new Vector3(
+      lerp(-params.emitRange * spatialScale, params.emitRange * spatialScale, sequence01(index, 0)),
+      lerp(0.05 * spatialScale, 0.18 * spatialScale, sequence01(index, 1)),
+      lerp(-params.emitRange * spatialScale, params.emitRange * spatialScale, sequence01(index, 2)),
+    );
+    const direction = new Vector3(
+      lerp(-params.spread * spatialScale, params.spread * 0.85 * spatialScale, sequence01(index, 3)),
+      lerp(params.riseHeight * 0.3 * spatialScale, params.riseHeight * spatialScale, sequence01(index, 4)),
+      lerp(-params.spread * 0.56 * spatialScale, params.spread * 0.56 * spatialScale, sequence01(index, 5)),
+    );
+    const speed = lerp(minSpeed, maxSpeed, sequence01(index, 6));
+    if (direction.lengthSquared() > 0.0001) direction.normalize().scaleInPlace(speed);
+
+    const size = Math.max(0.01, params.leafSize * params.scale * lerp(0.72, 1.24, sequence01(index, 7)));
+    sprite.position = origin.add(localPosition);
+    sprite.cellIndex = Math.floor(sequence01(index, 8) * 16) % 16;
+    sprite.width = size * lerp(0.82, 1.28, sequence01(index, 9));
+    sprite.height = size * lerp(0.72, 1.08, sequence01(index, 10));
+    sprite.angle = sequence01(index, 11) * Math.PI * 2;
+    sprite.color = toColor4(params.leafColor, params.opacity);
+    states.push({
+      sprite,
+      velocity: direction,
+      spin: lerp(-8, 8, sequence01(index, 12)),
+      width: sprite.width,
+      height: sprite.height,
+      lifetime: lerp(minLife, maxLife, sequence01(index, 13)),
+    });
+  }
+
+  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 t = Math.min(1, age / state.lifetime);
+      const fade = t < 0.72 ? 1 : Math.max(0, 1 - (t - 0.72) / 0.28);
+      const color = mixColor(params.leafColor, params.deadColor, Math.max(0, (t - 0.55) / 0.45));
+      state.velocity.y -= Math.max(0, params.gravity) * deltaSeconds;
+      state.sprite.position.addInPlace(state.velocity.scale(deltaSeconds));
+      state.sprite.angle += state.spin * deltaSeconds;
+      state.sprite.color = toColor4(color, params.opacity * fade);
+      const shrink = 1 - Math.max(0, t - 0.78) / 0.22 * 0.65;
+      state.sprite.width = state.width * shrink;
+      state.sprite.height = state.height * shrink;
+      state.sprite.isVisible = fade > 0.01;
+    }
+    if (age >= maxLife + 0.08) 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 getDisposeDelaySeconds(params: TreeLeafChopBurstParams): number {
+  return Math.max(
+    readNumber(SOURCE_EMITTER.runtime?.stopAfterSeconds, 1.25),
+    params.lifetime + 0.45,
+  );
+}
+
+function toColor4(color: VfxColorValue, alpha: number): Color4 {
+  return new Color4(
+    clamp01(color.r),
+    clamp01(color.g),
+    clamp01(color.b),
+    clamp01(alpha),
+  );
+}
+
+function mixColor(from: VfxColorValue, to: VfxColorValue, amount: number): VfxColorValue {
+  const t = clamp01(amount);
+  return {
+    r: from.r + (to.r - from.r) * t,
+    g: from.g + (to.g - from.g) * t,
+    b: from.b + (to.b - from.b) * t,
+  };
+}
+
+function readNumber(value: unknown, fallback: number): number {
+  const next = Number(value);
+  return Number.isFinite(next) ? next : fallback;
+}
+
+function clamp01(value: number): number {
+  return Math.min(1, Math.max(0, value));
+}
+
+function lerp(min: number, max: number, t: number): number {
+  return min + (max - min) * t;
+}
+
+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-leaf-chop-burst/vfx-params.json

@@ -0,0 +1,27 @@
+{
+  "__generation.offsetX": 0,
+  "__generation.offsetY": 1,
+  "__generation.offsetZ": 0,
+  "lifetime": 0.775,
+  "scale": 2,
+  "initialHeight": 1.4,
+  "leafColor": {
+    "r": 0.26666666666666666,
+    "g": 1,
+    "b": 0
+  },
+  "deadColor": {
+    "r": 0.5411764705882353,
+    "g": 0.43137254901960786,
+    "b": 0.12156862745098039
+  },
+  "opacity": 0.5,
+  "particleCount": 20,
+  "emitRange": 0.2,
+  "riseHeight": 0,
+  "spread": 6,
+  "minSpeed": 2,
+  "maxSpeed": 3,
+  "leafSize": 0.3,
+  "gravity": 3.8
+}

package/packages/effects/tree_chop_dust_burst/assets/runtime/particleEmitter.v1.js

@@ -0,0 +1,318 @@
+export const runtimeId = "particleEmitter/v1";
+
+export const runtimeContract = {
+  runtimeId,
+  kind: "particleEmitter",
+  emitterFields: {
+    capacity: "Maximum Babylon particle capacity.",
+    particleTexturePath: "Package-relative particle texture path used to load the Babylon ParticleSystem.particleTexture.",
+    blendMode: "Babylon particle blend mode label: ADD, STANDARD, MULTIPLY, or ONEONE.",
+    shape: "Emitter shape definition generated by the package build stage.",
+    spriteSheet: "Optional Babylon particle spritesheet settings for atlas-based particle textures.",
+    effectScale: "Spatial scale for the whole effect; scales emitter volume, particle size, velocity, and gravity together.",
+    renderColor: "Converted particle color inputs: one base color plus RGB/alpha intensity before writing Babylon color1/color2/colorDead.",
+    alphaKeys: "Color alpha gradients sampled over normalized particle lifetime.",
+    sizeKeys: "Size gradients sampled over normalized particle lifetime.",
+  },
+  runtimeBindings: {
+    "ParticleSystem.particleTexture": "Texture loaded from emitter.particleTexturePath through urlForPackagePath.",
+    "ParticleSystem.blendMode": "Mapped from emitter.blendMode.",
+    "ParticleSystem.manualEmitCount": "emitter.manualEmitCount when emitRate is 0.",
+    "ParticleSystem.emitRate": "emitter.emitRate for sustained emitters.",
+    "ParticleSystem.shape": "Mapped from emitter.shape.type and shape parameters, then scaled by emitter.effectScale.",
+    "ParticleSystem.spriteSheet": "Applied from emitter.spriteSheet when enabled.",
+    "ParticleSystem.colorGradient": "emitter.alphaKeys applied to the final ParticleSystem.color1.",
+    "ParticleSystem.sizeGradient": "emitter.sizeKeys multiplied by emitter.maxSize and emitter.effectScale.",
+  },
+};
+
+const BABYLON_PARTICLE_UPDATE_SPEED_UNIT = 0.01;
+
+function num(value, fallback = 0) {
+  const next = Number(value);
+  return Number.isFinite(next) ? next : fallback;
+}
+
+function readColor(BABYLON, value, fallback = new BABYLON.Color4(1, 1, 1, 1)) {
+  if (!value) return fallback;
+  return new BABYLON.Color4(num(value.r, fallback.r), num(value.g, fallback.g), num(value.b, fallback.b), num(value.a, fallback.a));
+}
+
+function applyRenderColorIntensity(BABYLON, color, renderColor = {}) {
+  const colorIntensity = Math.max(0, num(renderColor.colorIntensity, 1));
+  const alphaIntensity = Math.max(0, num(renderColor.alphaIntensity, colorIntensity));
+  return new BABYLON.Color4(
+    color.r * colorIntensity,
+    color.g * colorIntensity,
+    color.b * colorIntensity,
+    Math.min(1, color.a * alphaIntensity)
+  );
+}
+
+function particleColors(BABYLON, emitter) {
+  const renderColor = emitter.renderColor;
+  const baseColor = readColor(BABYLON, renderColor?.color, new BABYLON.Color4(1, 1, 1, 1));
+  const color1 = applyRenderColorIntensity(BABYLON, baseColor, renderColor);
+  return {
+    color1,
+    color2: color1,
+    colorDead: new BABYLON.Color4(color1.r, color1.g, color1.b, 0),
+  };
+}
+
+function readVec(BABYLON, value, fallback = new BABYLON.Vector3(0, 0, 0)) {
+  if (!value) return fallback;
+  return new BABYLON.Vector3(num(value.x, fallback.x), num(value.y, fallback.y), num(value.z, fallback.z));
+}
+
+function blendMode(BABYLON, value) {
+  if (value === "STANDARD") return BABYLON.ParticleSystem.BLENDMODE_STANDARD;
+  if (value === "MULTIPLY") return BABYLON.ParticleSystem.BLENDMODE_MULTIPLY;
+  if (value === "ONEONE") return BABYLON.ParticleSystem.BLENDMODE_ONEONE;
+  return BABYLON.ParticleSystem.BLENDMODE_ADD;
+}
+
+function billboardMode(BABYLON, value) {
+  if (!value || BABYLON.ParticleSystem[value] === undefined) return undefined;
+  return BABYLON.ParticleSystem[value];
+}
+
+function effectScale(emitter) {
+  return Math.max(0.0001, num(emitter.effectScale, 1));
+}
+
+function applyRenderOrder(system, emitter) {
+  system.renderingGroupId = Math.max(0, Math.round(num(emitter.renderingGroupId, 2)));
+  system.alphaIndex = num(emitter.alphaIndex, 100);
+  if ("forceDepthWrite" in system) {
+    system.forceDepthWrite = false;
+  }
+}
+
+function isDeterministic(emitter) {
+  return emitter?.deterministic !== false && emitter?.randomize !== true;
+}
+
+function midpoint(min, max) {
+  return (min + max) * 0.5;
+}
+
+function fract(value) {
+  return value - Math.floor(value);
+}
+
+function sequence01(index, axis) {
+  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);
+}
+
+function lerp(min, max, t) {
+  return min + (max - min) * t;
+}
+
+function applyDeterministicBoxEmitter(BABYLON, system, direction1, direction2, boxMin, boxMax) {
+  system.minEmitBox = boxMin;
+  system.maxEmitBox = boxMax;
+  system.direction1 = direction1;
+  system.direction2 = direction2;
+
+  let positionIndex = 0;
+  let directionIndex = 0;
+
+  system.startPositionFunction = (worldMatrix, positionToUpdate, _particle, isLocal) => {
+    const index = positionIndex;
+    positionIndex += 1;
+    const x = lerp(boxMin.x, boxMax.x, sequence01(index, 0));
+    const y = lerp(boxMin.y, boxMax.y, sequence01(index, 1));
+    const z = lerp(boxMin.z, boxMax.z, sequence01(index, 2));
+    if (isLocal) positionToUpdate.set(x, y, z);
+    else BABYLON.Vector3.TransformCoordinatesFromFloatsToRef(x, y, z, worldMatrix, positionToUpdate);
+  };
+
+  system.startDirectionFunction = (worldMatrix, directionToUpdate, _particle, isLocal) => {
+    const index = directionIndex;
+    directionIndex += 1;
+    const x = lerp(direction1.x, direction2.x, sequence01(index, 3));
+    const y = lerp(direction1.y, direction2.y, sequence01(index, 4));
+    const z = lerp(direction1.z, direction2.z, sequence01(index, 5));
+    if (isLocal) directionToUpdate.set(x, y, z);
+    else BABYLON.Vector3.TransformNormalFromFloatsToRef(x, y, z, worldMatrix, directionToUpdate);
+  };
+}
+
+function applyCocosConeEmitFunctions(BABYLON, system, radius, angle, radiusRange, scale) {
+  const safeRadius = Math.max(0, radius * scale);
+  const innerSq = (safeRadius * Math.max(0, 1 - radiusRange)) ** 2;
+  const outerSq = safeRadius * safeRadius;
+  const halfAngle = Math.min(Math.PI, Math.max(0, angle));
+  const cosAngle = Math.cos(halfAngle);
+
+  system.startPositionFunction = (worldMatrix, positionToUpdate, _particle, isLocal) => {
+    const s = Math.random() * Math.PI * 2;
+    const r2 = innerSq + Math.random() * (outerSq - innerSq);
+    const r = Math.sqrt(Math.max(0, r2));
+    const lx = r * Math.cos(s);
+    const lz = r * Math.sin(s);
+    if (isLocal) positionToUpdate.set(lx, 0, lz);
+    else BABYLON.Vector3.TransformCoordinatesFromFloatsToRef(lx, 0, lz, worldMatrix, positionToUpdate);
+  };
+
+  system.startDirectionFunction = (worldMatrix, directionToUpdate, _particle, isLocal) => {
+    const phi = Math.random() * Math.PI * 2;
+    const cosTheta = 1 - Math.random() * (1 - cosAngle);
+    const sinTheta = Math.sqrt(Math.max(0, 1 - cosTheta * cosTheta));
+    const dx = sinTheta * Math.cos(phi);
+    const dy = cosTheta;
+    const dz = sinTheta * Math.sin(phi);
+    if (isLocal) directionToUpdate.set(dx, dy, dz);
+    else BABYLON.Vector3.TransformNormalFromFloatsToRef(dx, dy, dz, worldMatrix, directionToUpdate);
+  };
+}
+
+function applyEmitterShape(BABYLON, system, emitter) {
+  const scale = effectScale(emitter);
+  const shape = emitter.shape || {};
+  const type = shape.type;
+  const radius = num(shape.radius, 1);
+  const radiusRange = Math.min(1, Math.max(0, num(shape.radiusRange, 1)));
+  const angle = num(shape.angle, Math.PI / 4);
+  const direction1 = readVec(BABYLON, shape.direction1, new BABYLON.Vector3(0, 1, 0));
+  const direction2 = readVec(BABYLON, shape.direction2, new BABYLON.Vector3(0, 1, 0));
+  const boxMin = readVec(BABYLON, shape.minEmitBox, new BABYLON.Vector3(-radius * 0.5, -radius * 0.5, -radius * 0.5)).scale(scale);
+  const boxMax = readVec(BABYLON, shape.maxEmitBox, new BABYLON.Vector3(radius * 0.5, radius * 0.5, radius * 0.5)).scale(scale);
+
+  if (type === "Box") {
+    if (isDeterministic(emitter)) applyDeterministicBoxEmitter(BABYLON, system, direction1, direction2, boxMin, boxMax);
+    else system.createBoxEmitter(direction1, direction2, boxMin, boxMax);
+  } else if (type === "SphereDirected") {
+    system.createDirectedSphereEmitter(radius * scale, direction1, direction2);
+  } else if (type === "Sphere") {
+    system.createSphereEmitter(radius * scale, radiusRange);
+  } else if (type === "Hemisphere") {
+    system.createHemisphericEmitter(radius * scale, radiusRange);
+  } else if (type === "Cone") {
+    const dirSpread = direction1.subtract(direction2).lengthSquared();
+    if (dirSpread < 1e-4) {
+      system.createConeEmitter(Math.max(0.001, radius * scale), angle);
+      applyCocosConeEmitFunctions(BABYLON, system, radius, angle, radiusRange, scale);
+    } else {
+      system.createDirectedConeEmitter(Math.max(0.001, radius * scale), angle, direction1, direction2);
+    }
+  }
+}
+
+function applySpriteSheet(system, emitter) {
+  const spriteSheet = emitter.spriteSheet || {};
+  if (!spriteSheet.enabled) return;
+  const deterministic = isDeterministic(emitter);
+
+  system.isAnimationSheetEnabled = true;
+  system.spriteCellWidth = Math.max(1, Math.round(num(spriteSheet.cellWidth, 256)));
+  system.spriteCellHeight = Math.max(1, Math.round(num(spriteSheet.cellHeight, 256)));
+  system.startSpriteCellID = Math.max(0, Math.round(num(spriteSheet.startCellID, 0)));
+  system.endSpriteCellID = Math.max(system.startSpriteCellID, Math.round(num(spriteSheet.endCellID, system.startSpriteCellID)));
+  system.spriteCellChangeSpeed = Math.max(0, num(spriteSheet.cellChangeSpeed, 0));
+  system.spriteRandomStartCell = deterministic ? spriteSheet.randomStartCell === true && emitter.randomize === true : spriteSheet.randomStartCell !== false;
+}
+
+function addGradients(BABYLON, system, emitter, color1) {
+  const scale = effectScale(emitter);
+  for (const key of emitter.alphaKeys || []) {
+    const time = Math.min(1, Math.max(0, num(key.time, 0)));
+    const alpha = Math.min(1, Math.max(0, num(key.alpha, 1)));
+    system.addColorGradient?.(time, new BABYLON.Color4(color1.r, color1.g, color1.b, Math.min(1, color1.a * alpha)));
+  }
+  for (const key of emitter.sizeKeys || []) {
+    const time = Math.min(1, Math.max(0, num(key.time, 0)));
+    const size = Math.max(0.001, num(key.size, 1) * num(emitter.maxSize, 1) * scale);
+    system.addSizeGradient?.(time, size);
+  }
+}
+
+function playbackSpeed(emitter) {
+  return Math.max(0.001, num(emitter.updateSpeed, BABYLON_PARTICLE_UPDATE_SPEED_UNIT) / BABYLON_PARTICLE_UPDATE_SPEED_UNIT);
+}
+
+function runtimeDuration(emitter) {
+  return Math.max(0.1, num(emitter.runtime?.stopAfterSeconds, 3) / playbackSpeed(emitter));
+}
+
+export async function createParticleEmitterRuntime({ BABYLON, scene, emitter, index = 0, urlForPackagePath, shouldStart = false }) {
+  if (!BABYLON) throw new Error("createParticleEmitterRuntime requires BABYLON.");
+  if (!scene) throw new Error("createParticleEmitterRuntime requires scene.");
+  if (!emitter) throw new Error("createParticleEmitterRuntime requires emitter.");
+
+  const scale = effectScale(emitter);
+  const deterministic = isDeterministic(emitter);
+  const capacity = Math.max(1, Math.round(num(emitter.capacity, 100)));
+  const system = new BABYLON.ParticleSystem(`particle-emitter-${emitter.name || index}`, capacity, scene);
+  const root = new BABYLON.TransformNode(`particle-emitter-root-${emitter.name || index}`, scene);
+  root.position.copyFrom(readVec(BABYLON, emitter.origin, BABYLON.Vector3.Zero()));
+  root.rotation.y = num(emitter.rotationY, 0);
+  applyRenderOrder(system, emitter);
+  const textureUrl = urlForPackagePath ? urlForPackagePath(emitter.particleTexturePath) : emitter.particleTexturePath;
+  system.particleTexture = new BABYLON.Texture(textureUrl, scene);
+  system.particleTexture.hasAlpha = true;
+  system.emitter = root;
+  system.blendMode = blendMode(BABYLON, emitter.blendMode);
+  system.isLocal = emitter.isLocal === true;
+  const minSize = Math.max(0.001, num(emitter.minSize, 1) * scale);
+  const maxSize = Math.max(minSize, num(emitter.maxSize, minSize) * scale);
+  system.minSize = deterministic ? midpoint(minSize, maxSize) : minSize;
+  system.maxSize = deterministic ? system.minSize : maxSize;
+  const minScaleX = Math.max(0.001, num(emitter.minScaleX, 1));
+  const maxScaleX = Math.max(minScaleX, num(emitter.maxScaleX, minScaleX));
+  system.minScaleX = deterministic ? midpoint(minScaleX, maxScaleX) : minScaleX;
+  system.maxScaleX = deterministic ? system.minScaleX : maxScaleX;
+  const minScaleY = Math.max(0.001, num(emitter.minScaleY, 1));
+  const maxScaleY = Math.max(minScaleY, num(emitter.maxScaleY, minScaleY));
+  system.minScaleY = deterministic ? midpoint(minScaleY, maxScaleY) : minScaleY;
+  system.maxScaleY = deterministic ? system.minScaleY : maxScaleY;
+  const minLifeTime = Math.max(0.02, num(emitter.minLifeTime, 0.55));
+  const maxLifeTime = Math.max(minLifeTime, num(emitter.maxLifeTime, minLifeTime));
+  system.minLifeTime = deterministic ? midpoint(minLifeTime, maxLifeTime) : minLifeTime;
+  system.maxLifeTime = deterministic ? system.minLifeTime : maxLifeTime;
+  const minEmitPower = Math.max(0, num(emitter.minEmitPower, 1) * scale);
+  const maxEmitPower = Math.max(minEmitPower, num(emitter.maxEmitPower, minEmitPower) * scale);
+  system.minEmitPower = deterministic ? midpoint(minEmitPower, maxEmitPower) : minEmitPower;
+  system.maxEmitPower = deterministic ? system.minEmitPower : maxEmitPower;
+  system.updateSpeed = Math.max(0.00001, num(emitter.updateSpeed, BABYLON_PARTICLE_UPDATE_SPEED_UNIT));
+  system.gravity = readVec(BABYLON, emitter.gravity, new BABYLON.Vector3(0, -6, 0)).scale(scale);
+  system.emitRate = Math.max(0, num(emitter.emitRate, 0));
+  if (system.emitRate <= 0) system.manualEmitCount = Math.max(0, Math.round(num(emitter.manualEmitCount, 0)));
+
+  const colors = particleColors(BABYLON, emitter);
+  system.color1 = colors.color1;
+  system.color2 = colors.color2;
+  system.colorDead = colors.colorDead;
+  const minInitialRotation = num(emitter.minInitialRotation, 0);
+  const maxInitialRotation = Math.max(minInitialRotation, num(emitter.maxInitialRotation, minInitialRotation));
+  system.minInitialRotation = deterministic ? midpoint(minInitialRotation, maxInitialRotation) : minInitialRotation;
+  system.maxInitialRotation = deterministic ? system.minInitialRotation : maxInitialRotation;
+  const minAngularSpeed = num(emitter.minAngularSpeed, 0);
+  const maxAngularSpeed = Math.max(minAngularSpeed, num(emitter.maxAngularSpeed, minAngularSpeed));
+  system.minAngularSpeed = deterministic ? midpoint(minAngularSpeed, maxAngularSpeed) : minAngularSpeed;
+  system.maxAngularSpeed = deterministic ? system.minAngularSpeed : maxAngularSpeed;
+
+  const nextBillboardMode = billboardMode(BABYLON, emitter.billboardMode);
+  if (nextBillboardMode !== undefined) system.billboardMode = nextBillboardMode;
+
+  applyEmitterShape(BABYLON, system, emitter);
+  applySpriteSheet(system, emitter);
+  addGradients(BABYLON, system, emitter, system.color1);
+
+  const preview = {
+    start: () => system.start(),
+    stop: () => system.stop(),
+    dispose: () => {
+      system.dispose();
+      root.dispose();
+    },
+    isStarted: () => system.isStarted(),
+    duration: runtimeDuration(emitter),
+    system,
+  };
+  if (shouldStart) preview.start();
+  return preview;
+}

package/packages/effects/tree_chop_dust_burst/index.ts

@@ -0,0 +1,13 @@
+import manifest from './tree_chop_dust_burst.json';
+import runtimeUrl from './assets/runtime/particleEmitter.v1.js?url';
+import dustTextureUrl from './assets/textures/tree_chop_dust_burst_dust.png?url';
+import { createManifestRuntimeEffectPackage } from '../../manifestRuntimePackage';
+
+export const treeChopDustBurstEffectPackage = createManifestRuntimeEffectPackage({
+  id: 'tree_chop_dust_burst',
+  manifest,
+  assetUrls: {
+    'assets/runtime/particleEmitter.v1.js': runtimeUrl,
+    'assets/textures/tree_chop_dust_burst_dust.png': dustTextureUrl,
+  },
+});