@fps-games/vfx 0.3.2 → 0.3.4

package/packages/effects/wood-sawdust-effect-factory.ts

@@ -1,194 +0,0 @@
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import type { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../types';
-import {
-  cloneLegacyEmitters,
-  findEmitter,
-  setNestedValue,
-  startLegacyParticleRuntime,
-  type LegacyParticleEmitterConfig,
-} from '../legacy-particle-runtime';
-
-export interface WoodSawdustParams extends VfxParamValues {
-  lifetime: number;
-  scale: number;
-  initialHeight: number;
-  dustCount: number;
-  fragmentCount: number;
-  dustColor: VfxColorValue;
-  fragmentColor: VfxColorValue;
-  dustSize: number;
-  fragmentSize: number;
-  dustLifetime: number;
-  fragmentLifetime: number;
-  dustSpeed: number;
-  fragmentSpeed: number;
-  fragmentSpread: number;
-}
-
-interface WoodSawdustPackageConfig {
-  id: string;
-  nameZh: string;
-  manifest: unknown;
-  runtimeUrl: string;
-  assetUrls: Record<string, string>;
-  sourceEmitters: unknown;
-  dustEmitterName: string;
-  fragmentEmitterName: string;
-  fragmentLabel: string;
-  fragmentSizeLabel: string;
-  fragmentColorLabel: string;
-  fragmentCountLabel: string;
-  fragmentSpeedLabel: string;
-  fragmentSpreadLabel: string;
-  defaultParams: WoodSawdustParams;
-}
-
-export function createWoodSawdustEffectPackage(config: WoodSawdustPackageConfig): VfxEffectPackage<WoodSawdustParams> {
-  return {
-    id: config.id,
-    nameZh: config.nameZh,
-    manifest: config.manifest as any,
-    defaultParams: config.defaultParams,
-    debugAnchor: 'playerRight',
-    debugParams: [
-      { key: 'lifetime', label: '生命周期', kind: 'lifetime', min: 0.08, max: 4, step: 0.01 },
-      { key: 'scale', label: '整体缩放', kind: 'scale', min: 0.1, max: 4, step: 0.01 },
-      { key: 'initialHeight', label: '初始高度', kind: 'number', min: -1, max: 3, step: 0.01 },
-      { key: 'dustCount', label: '木粉数量', kind: 'number', min: 1, max: 180, step: 1 },
-      { key: 'fragmentCount', label: config.fragmentCountLabel, kind: 'number', min: 0, max: 90, step: 1 },
-      { key: 'dustColor', label: '木粉颜色', kind: 'color' },
-      { key: 'fragmentColor', label: config.fragmentColorLabel, kind: 'color' },
-      { key: 'dustSize', label: '木粉大小', kind: 'number', min: 0.2, max: 4, step: 0.01 },
-      { key: 'fragmentSize', label: config.fragmentSizeLabel, kind: 'number', min: 0.2, max: 4, step: 0.01 },
-      { key: 'dustLifetime', label: '木粉生命周期', kind: 'lifetime', min: 0.08, max: 3, step: 0.01 },
-      { key: 'fragmentLifetime', label: `${config.fragmentLabel}生命周期`, kind: 'lifetime', min: 0.08, max: 2, step: 0.01 },
-      { key: 'dustSpeed', label: '木粉喷散速度', kind: 'number', min: 0, max: 4, step: 0.01 },
-      { key: 'fragmentSpeed', label: config.fragmentSpeedLabel, kind: 'number', min: 0, max: 8, step: 0.01 },
-      { key: 'fragmentSpread', label: config.fragmentSpreadLabel, kind: 'number', min: 0, max: 4, step: 0.01 },
-    ],
-    create({ scene, root, position, params }) {
-      root.position.copyFrom(position).addInPlace(new Vector3(0, params.initialHeight, 0));
-      const emitters = buildEmitters(config, params, root.position);
-      const runtime = startLegacyParticleRuntime({
-        scene,
-        runtimeUrl: config.runtimeUrl,
-        emitters,
-        assetUrls: config.assetUrls,
-        onError: (error) => console.error(`[VFX:${config.id}] legacy particle runtime failed`, error),
-      });
-      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);
-        runtime.dispose();
-        root.dispose();
-      }
-    },
-  };
-}
-
-function buildEmitters(
-  config: WoodSawdustPackageConfig,
-  params: WoodSawdustParams,
-  origin: Vector3,
-): LegacyParticleEmitterConfig[] {
-  const emitters = cloneLegacyEmitters(config.sourceEmitters);
-  const dust = findEmitter(emitters, config.dustEmitterName);
-  const fragment = findEmitter(emitters, config.fragmentEmitterName);
-  if (dust) {
-    applyCommonEmitterParams(dust, origin, params.scale, params.lifetime);
-    setNestedValue(dust, 'manualEmitCount', Math.round(params.dustCount));
-    setNestedValue(dust, 'renderColor.color', toLegacyColor(params.dustColor));
-    scaleEmitterSize(dust, params.dustSize);
-    scaleMaxLifetime(dust, params.dustLifetime);
-    setNestedValue(dust, 'maxEmitPower', params.dustSpeed);
-  }
-  if (fragment) {
-    applyCommonEmitterParams(fragment, origin, params.scale, params.lifetime);
-    setNestedValue(fragment, 'manualEmitCount', Math.round(params.fragmentCount));
-    setNestedValue(fragment, 'renderColor.color', toLegacyColor(params.fragmentColor));
-    scaleEmitterSize(fragment, params.fragmentSize);
-    scaleMaxLifetime(fragment, params.fragmentLifetime);
-    setNestedValue(fragment, 'maxEmitPower', params.fragmentSpeed);
-    scaleShapeSpread(fragment, params.fragmentSpread);
-  }
-  return emitters;
-}
-
-function applyCommonEmitterParams(
-  emitter: LegacyParticleEmitterConfig,
-  origin: Vector3,
-  scale: number,
-  lifetime: number,
-): void {
-  setNestedValue(emitter, 'origin', { x: origin.x, y: origin.y, z: origin.z });
-  setNestedValue(emitter, 'effectScale', scale);
-  setNestedValue(emitter, 'runtime.stopAfterSeconds', Math.max(0.08, lifetime));
-}
-
-function scaleEmitterSize(emitter: LegacyParticleEmitterConfig, sizeScale: number): void {
-  const baseMin = readNumber(emitter.minSize, 0.05);
-  const baseMax = readNumber(emitter.maxSize, baseMin);
-  emitter.minSize = baseMin * sizeScale;
-  emitter.maxSize = baseMax * sizeScale;
-}
-
-function scaleMaxLifetime(emitter: LegacyParticleEmitterConfig, maxLifeTime: number): void {
-  const baseMin = readNumber(emitter.minLifeTime, maxLifeTime * 0.55);
-  const baseMax = Math.max(baseMin, readNumber(emitter.maxLifeTime, maxLifeTime));
-  const ratio = baseMax > 0 ? baseMin / baseMax : 0.55;
-  emitter.minLifeTime = Math.max(0.02, maxLifeTime * ratio);
-  emitter.maxLifeTime = Math.max(emitter.minLifeTime as number, maxLifeTime);
-}
-
-function scaleShapeSpread(emitter: LegacyParticleEmitterConfig, spread: number): void {
-  scaleVectorAxes(emitter, 'shape.direction1', spread);
-  scaleVectorAxes(emitter, 'shape.direction2', spread);
-}
-
-function scaleVectorAxes(emitter: LegacyParticleEmitterConfig, path: string, scale: number): void {
-  const vector = readNestedObject(emitter, path);
-  if (!vector) return;
-  setNestedValue(emitter, path, {
-    ...vector,
-    x: readNumber(vector.x, 0) * scale,
-    z: readNumber(vector.z, 0) * scale,
-  });
-}
-
-function readNestedObject(target: Record<string, unknown>, path: string): Record<string, unknown> | null {
-  let cursor: unknown = target;
-  for (const part of path.split('.')) {
-    if (!cursor || typeof cursor !== 'object' || Array.isArray(cursor)) return null;
-    cursor = (cursor as Record<string, unknown>)[part];
-  }
-  return cursor && typeof cursor === 'object' && !Array.isArray(cursor)
-    ? cursor as Record<string, unknown>
-    : null;
-}
-
-function toLegacyColor(color: VfxColorValue): { r: number; g: number; b: number; a: number } {
-  return { r: color.r, g: color.g, b: color.b, a: 1 };
-}
-
-function getDisposeDelaySeconds(params: WoodSawdustParams): number {
-  return Math.max(0.08, params.lifetime)
-    + Math.max(0.08, params.dustLifetime, params.fragmentLifetime)
-    + 0.3;
-}
-
-function readNumber(value: unknown, fallback: number): number {
-  const next = Number(value);
-  return Number.isFinite(next) ? next : fallback;
-}

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

@@ -1,318 +0,0 @@
-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/wood_crusher_sawdust/index.ts

@@ -1,29 +0,0 @@
-import manifest from './wood_crusher_sawdust.json';
-import runtimeUrl from './assets/runtime/particleEmitter.v1.js?url';
-import dustTextureUrl from './assets/textures/wood_crusher_sawdust_dust.png?url';
-import fiberTextureUrl from './assets/textures/wood_crusher_sawdust_fiber.png?url';
-import { createManifestRuntimeEffectPackage } from '../../manifestRuntimePackage';
-
-const packageDefinition = createManifestRuntimeEffectPackage({
-  id: 'wood_crusher_sawdust',
-  manifest,
-  assetUrls: {
-    'assets/runtime/particleEmitter.v1.js': runtimeUrl,
-    'assets/textures/wood_crusher_sawdust_dust.png': dustTextureUrl,
-    'assets/textures/wood_crusher_sawdust_fiber.png': fiberTextureUrl,
-  },
-});
-const packageManifest = packageDefinition.manifest ?? {
-  id: packageDefinition.id,
-  nameZh: packageDefinition.nameZh,
-};
-
-export const woodCrusherSawdustEffectPackage = {
-  ...packageDefinition,
-  nameZh: '粉碎机木粉（去皮机）',
-  manifest: {
-    ...packageManifest,
-    id: packageManifest.id,
-    nameZh: '粉碎机木粉（去皮机）',
-  },
-};