@fps-games/vfx 0.1.1

package/packages/effects/lumber_vehicle_upgrade_aura/lumber_vehicle_upgrade_aura.json

@@ -0,0 +1,365 @@
+{
+  "schemaVersion": "vfx-effect-package/1.0",
+  "id": "build.particle.lumber_vehicle_upgrade_aura",
+  "name": {
+    "zh": "螺旋状升级",
+    "en": "Lumber Vehicle Upgrade Aura"
+  },
+  "source": {
+    "engine": "babylon",
+    "engineVersion": "8.56.2",
+    "projectPath": "D:/project/lumber_order",
+    "rootAsset": "src/assets/vfx/effects/lumber_vehicle_upgrade_aura",
+    "sourceId": "lumber_order/lumber_vehicle_upgrade_aura",
+    "extractedAt": "2026-06-02T00:00:00.000Z",
+    "extractorVersion": "manual-lumber-order-vfx/0.1.0",
+    "canonicalSource": "local",
+    "legacyId": null,
+    "previousIds": []
+  },
+  "assets": {
+    "textures": [],
+    "materials": [],
+    "meshes": [],
+    "shaders": [],
+    "sounds": [],
+    "scripts": [
+      {
+        "kind": "script",
+        "id": "upgrade_aura_v1",
+        "packagePath": "assets/runtime/upgradeAura.v1.js",
+        "runtimeId": "upgradeAura/v1",
+        "engine": "babylon",
+        "moduleFormat": "esm",
+        "exports": [
+          "createUpgradeAuraRuntime",
+          "runtimeContract"
+        ],
+        "mimeType": "text/javascript"
+      }
+    ],
+    "raw": []
+  },
+  "emitters": [
+    {
+      "name": "lumber_vehicle_upgrade_aura_main",
+      "sourceNodeName": "lumber_vehicle_upgrade_aura_main",
+      "enabled": true,
+      "type": "UpgradeAura",
+      "duration": 1.45,
+      "effectScale": 1,
+      "spiralTurns": 3.4,
+      "ringRadius": 0.72,
+      "ringThickness": 0.035,
+      "spiralHeight": 1.12,
+      "ringRiseHeight": 1.45,
+      "ringAlpha": 0.78,
+      "spiralGlowAlpha": 0.08,
+      "bodyRiseHeight": 1.75,
+      "bodyGlowAlpha": 0.62,
+      "sparkleCount": 24,
+      "sparkleLife": 0.62,
+      "sparkWidth": 0.045,
+      "sparkHeight": 0.22,
+      "sparkAlpha": 0.92,
+      "ringColor": {
+        "r": 1,
+        "g": 0.78,
+        "b": 0.14,
+        "a": 1
+      },
+      "bodyGlowColor": {
+        "r": 1,
+        "g": 0.95,
+        "b": 0.5,
+        "a": 1
+      },
+      "hdrIntensity": 3,
+      "runtime": {
+        "adapter": "upgradeAura/v1",
+        "stopAfterSeconds": 1.45,
+        "disposeOnComplete": true
+      }
+    }
+  ],
+  "runtime": {
+    "driver": "upgradeAura",
+    "defaultMesh": null,
+    "defaultOffset": {
+      "x": 0,
+      "y": 0,
+      "z": 0
+    },
+    "start": [
+      "Instantiate Babylon runtime for lumber_vehicle_upgrade_aura"
+    ],
+    "update": [
+      "Apply Babylon tunable parameter overrides"
+    ],
+    "stop": [
+      "Stop and dispose runtime resources"
+    ],
+    "adapters": [
+      {
+        "id": "upgradeAura/v1",
+        "engine": "babylon",
+        "entry": "assets/runtime/upgradeAura.v1.js",
+        "moduleFormat": "esm",
+        "exports": [
+          "createUpgradeAuraRuntime",
+          "runtimeContract"
+        ]
+      }
+    ]
+  },
+  "tunableParams": [
+    {
+      "key": "lumber_vehicle_upgrade_aura.spiralTurns",
+      "labelZh": "螺旋圈数",
+      "type": "number",
+      "default": 3.4,
+      "min": 1,
+      "max": 7,
+      "step": 0.1,
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "spiralTurns",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.sparkleCount",
+      "labelZh": "上升光点数量",
+      "type": "number",
+      "default": 24,
+      "min": 0,
+      "max": 80,
+      "step": 1,
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "sparkleCount",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.ringColor",
+      "labelZh": "螺旋颜色",
+      "type": "color",
+      "default": "#ffc723",
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "ringColor",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.bodyGlowColor",
+      "labelZh": "身体光效颜色",
+      "type": "color",
+      "default": "#fff280",
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "bodyGlowColor",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.hdrIntensity",
+      "labelZh": "HDR强度",
+      "type": "number",
+      "default": 3,
+      "min": 0,
+      "max": 8,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "hdrIntensity",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.effectScale",
+      "labelZh": "整体缩放",
+      "type": "number",
+      "default": 1,
+      "min": 0.2,
+      "max": 4,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "effectScale",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.ringRadius",
+      "labelZh": "螺旋半径",
+      "type": "number",
+      "default": 0.72,
+      "min": 0.1,
+      "max": 2,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "ringRadius",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.ringRiseHeight",
+      "labelZh": "螺旋上升高度",
+      "type": "number",
+      "default": 1.45,
+      "min": 0.1,
+      "max": 4,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "ringRiseHeight",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.bodyRiseHeight",
+      "labelZh": "身体光效高度",
+      "type": "number",
+      "default": 1.75,
+      "min": 0.1,
+      "max": 4,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "bodyRiseHeight",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.duration",
+      "labelZh": "生命周期",
+      "type": "number",
+      "default": 1.45,
+      "min": 0.2,
+      "max": 5,
+      "step": 0.01,
+      "unit": "s",
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "duration",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.sparkSize",
+      "labelZh": "上升光点大小",
+      "type": "number",
+      "default": 1,
+      "min": 0.2,
+      "max": 4,
+      "step": 0.01,
+      "targets": [
+        {
+          "emitter": "lumber_vehicle_upgrade_aura_main",
+          "property": "sparkWidth",
+          "operator": "scaleDefault",
+          "defaultValue": 0.045
+        },
+        {
+          "emitter": "lumber_vehicle_upgrade_aura_main",
+          "property": "sparkHeight",
+          "operator": "scaleDefault",
+          "defaultValue": 0.22
+        }
+      ]
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.ringAlpha",
+      "labelZh": "螺旋透明度",
+      "type": "number",
+      "default": 0.78,
+      "min": 0,
+      "max": 1,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "ringAlpha",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_upgrade_aura.bodyGlowAlpha",
+      "labelZh": "身体光效透明度",
+      "type": "number",
+      "default": 0.58,
+      "min": 0,
+      "max": 1,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_upgrade_aura_main",
+        "property": "bodyGlowAlpha",
+        "operator": "set"
+      }
+    }
+  ],
+  "babylon": {
+    "driver": "upgradeAura",
+    "previewConfig": {
+      "textureUrl": null,
+      "emitterCount": 1,
+      "effectFile": "lumber_vehicle_upgrade_aura.json",
+      "normalizedVfx": null
+    }
+  },
+  "debug": {
+    "playAnchor": "player"
+  },
+  "review": {
+    "status": "draft",
+    "artistNotes": [
+      "Upgrade effect with horizontal rings rising around the character.",
+      "Body glow and small upward light streaks are driven by tunable runtime parameters.",
+      "No texture dependency; all visuals are Babylon glow materials and primitive meshes."
+    ],
+    "approvedBy": null,
+    "approvedAt": null
+  },
+  "recording": {
+    "provider": "local-placeholder",
+    "recordedAt": "2026-06-02T00:00:00.000Z",
+    "mimeType": "image/png",
+    "durationSec": 1.45,
+    "fps": 0,
+    "media": {
+      "previewVideo": null,
+      "previewWebm": null,
+      "previewMp4": null,
+      "previewGif": null,
+      "thumbnail": "media/thumbnail.png",
+      "contactSheet": "media/contact-sheet.png",
+      "gcsUri": null
+    }
+  },
+  "search": {
+    "tags": [
+      "babylon",
+      "upgrade",
+      "aura",
+      "rising ring",
+      "body glow",
+      "lumber vehicle",
+      "casual game"
+    ],
+    "descriptionEn": "A character upgrade aura with golden rising rings and vertical body light.",
+    "useCases": [
+      "lumber vehicle upgrade",
+      "character upgrade feedback",
+      "reward feedback"
+    ],
+    "negativeUseCases": [
+      "wood cutting",
+      "sawdust",
+      "dust burst",
+      "fire explosion"
+    ]
+  },
+  "legacyIds": []
+}

package/packages/effects/lumber_vehicle_upgrade_aura/vfx-params.json

@@ -0,0 +1,15 @@
+{
+  "lumber_vehicle_upgrade_aura.spiralTurns": 3.4,
+  "lumber_vehicle_upgrade_aura.sparkleCount": 24,
+  "lumber_vehicle_upgrade_aura.ringColor": "#ffbf00",
+  "lumber_vehicle_upgrade_aura.bodyGlowColor": "#ffe70a",
+  "lumber_vehicle_upgrade_aura.hdrIntensity": 2,
+  "lumber_vehicle_upgrade_aura.effectScale": 3,
+  "lumber_vehicle_upgrade_aura.ringRadius": 0.48,
+  "lumber_vehicle_upgrade_aura.ringRiseHeight": 1.45,
+  "lumber_vehicle_upgrade_aura.bodyRiseHeight": 1.75,
+  "lumber_vehicle_upgrade_aura.duration": 1.45,
+  "lumber_vehicle_upgrade_aura.sparkSize": 1.61,
+  "lumber_vehicle_upgrade_aura.ringAlpha": 0.74,
+  "lumber_vehicle_upgrade_aura.bodyGlowAlpha": 0.81
+}

package/packages/effects/lumber_vehicle_wood_chips/assets/runtime/solidParticleScatter.v1.js

@@ -0,0 +1,310 @@
+export const runtimeId = "solidParticleScatter/v1";
+
+export const runtimeContract = {
+  runtimeId,
+  kind: "solidParticleScatter",
+  fields: {
+    count: "Number of lumber pieces emitted per burst.",
+    scatterMode: "vertical drops pieces downward; radial throws pieces from the emitter center outward.",
+    outwardAngleDegrees: "Radial scatter fan angle in degrees, used only when scatterMode is radial.",
+    scatterGravity: "Higher values pull pieces down sooner and reduce hang time.",
+    rotationStrength: "Deterministic random rotation around each lumber piece center, not around the emitter.",
+    effectScale: "Overall spatial scale for piece size, travel distance, and spawn height.",
+  },
+};
+
+function num(value, fallback = 0) {
+  const next = Number(value);
+  return Number.isFinite(next) ? next : fallback;
+}
+
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+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(start, end, t) {
+  return start + (end - start) * t;
+}
+
+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 readColor3(BABYLON, value, fallback = new BABYLON.Color3(1, 1, 1)) {
+  if (!value) return fallback;
+  return new BABYLON.Color3(num(value.r, fallback.r), num(value.g, fallback.g), num(value.b, fallback.b));
+}
+
+function rotateVecY(BABYLON, vector, rotationY = 0) {
+  const sin = Math.sin(num(rotationY, 0));
+  const cos = Math.cos(num(rotationY, 0));
+  return new BABYLON.Vector3(
+    vector.x * cos + vector.z * sin,
+    vector.y,
+    -vector.x * sin + vector.z * cos
+  );
+}
+
+function applyRenderOrder(mesh, material, emitter) {
+  mesh.renderingGroupId = Math.max(0, Math.round(num(emitter.renderingGroupId, 2)));
+  mesh.alphaIndex = num(emitter.alphaIndex, 100);
+  material.disableDepthWrite = emitter.disableDepthWrite !== false;
+}
+
+function splitUrl(url) {
+  const slashIndex = url.lastIndexOf("/");
+  if (slashIndex < 0) return { rootUrl: "", fileName: url };
+  return { rootUrl: url.slice(0, slashIndex + 1), fileName: url.slice(slashIndex + 1) };
+}
+
+function createFallbackSourceMesh(BABYLON, scene, name, emitter = {}) {
+  const primitive = emitter.primitive || {};
+  if (primitive.type === "splinter") {
+    return createSplinterSourceMesh(BABYLON, scene, name, emitter);
+  }
+
+  const source = BABYLON.MeshBuilder.CreateBox(name, {
+    width: Math.max(0.001, num(primitive.width, 0.16)),
+    height: Math.max(0.001, num(primitive.height, 0.018)),
+    depth: Math.max(0.001, num(primitive.depth, 0.045)),
+  }, scene);
+  source.isVisible = false;
+  source.setEnabled(false);
+  return source;
+}
+
+function createSplinterSourceMesh(BABYLON, scene, name, emitter = {}) {
+  const primitive = emitter.primitive || {};
+  const width = Math.max(0.001, num(primitive.width, 0.1));
+  const height = Math.max(0.001, num(primitive.height, 0.008));
+  const depth = Math.max(0.001, num(primitive.depth, 0.02));
+  const mesh = new BABYLON.Mesh(name, scene);
+  const halfWidth = width * 0.5;
+  const halfHeight = height * 0.5;
+  const halfDepth = depth * 0.5;
+  const positions = [
+    -halfWidth, -halfHeight, -halfDepth,
+    -halfWidth, halfHeight, -halfDepth,
+    halfWidth, 0, -halfDepth,
+    -halfWidth, -halfHeight, halfDepth,
+    -halfWidth, halfHeight, halfDepth,
+    halfWidth, 0, halfDepth,
+  ];
+  const indices = [
+    0, 1, 2,
+    3, 5, 4,
+    0, 3, 4,
+    0, 4, 1,
+    1, 4, 5,
+    1, 5, 2,
+    2, 5, 3,
+    2, 3, 0,
+  ];
+  const normals = [];
+  BABYLON.VertexData.ComputeNormals(positions, indices, normals);
+  const vertexData = new BABYLON.VertexData();
+  vertexData.positions = positions;
+  vertexData.indices = indices;
+  vertexData.normals = normals;
+  vertexData.applyToMesh(mesh);
+  mesh.isVisible = false;
+  mesh.setEnabled(false);
+  return mesh;
+}
+
+async function loadSourceMesh(BABYLON, scene, emitter, urlForPackagePath) {
+  const modelPath = emitter.modelPath;
+  if (!modelPath || !BABYLON.SceneLoader) {
+    return createFallbackSourceMesh(BABYLON, scene, `${emitter.name || "lumber_debris_scatter"}Source`, emitter);
+  }
+
+  try {
+    const modelUrl = urlForPackagePath ? urlForPackagePath(modelPath) : modelPath;
+    const { rootUrl, fileName } = splitUrl(modelUrl);
+    const result = await BABYLON.SceneLoader.ImportMeshAsync("", rootUrl, fileName, scene);
+    const meshes = result.meshes.filter((mesh) => mesh instanceof BABYLON.Mesh && mesh.getTotalVertices() > 0);
+    if (!meshes.length) throw new Error(`No mesh was found in ${modelPath}.`);
+    const source = meshes.length === 1 ? meshes[0] : BABYLON.Mesh.MergeMeshes(meshes, true, true, undefined, false, true);
+    if (!source) throw new Error(`Unable to merge meshes from ${modelPath}.`);
+    source.name = `${emitter.name || "lumber_debris_scatter"}ModelSource`;
+    source.isVisible = false;
+    source.setEnabled(false);
+    source.refreshBoundingInfo();
+    const size = source.getBoundingInfo().boundingBox.extendSize.scale(2);
+    const maxDimension = Math.max(size.x, size.y, size.z, 0.0001);
+    source.scaling.scaleInPlace(0.82 / maxDimension);
+    source.rotationQuaternion = null;
+    source.refreshBoundingInfo();
+    return source;
+  } catch (error) {
+    console.warn("Unable to load lumber debris model; using box fallback.", error);
+    return createFallbackSourceMesh(BABYLON, scene, `${emitter.name || "lumber_debris_scatter"}Source`, emitter);
+  }
+}
+
+function createState(BABYLON, index, count, origin, emitter) {
+  const effectScale = Math.max(0.01, num(emitter.effectScale, 1));
+  const resourceScale = Math.max(0.01, num(emitter.resourceScale, 1));
+  const speedScale = Math.max(0.1, num(emitter.speedScale, 1));
+  const duration = Math.max(0.08, num(emitter.duration, 0.74)) / speedScale;
+  const interval = Math.max(0, num(emitter.intervalMs, 18)) / 1000;
+  const mode = emitter.scatterMode === "vertical" ? "vertical" : "radial";
+  const spread = Math.max(0, num(emitter.spread, 0.88)) * effectScale;
+  const gravity = Math.max(0.05, num(emitter.scatterGravity, 1));
+  const rotationStrength = Math.max(0, num(emitter.rotationStrength, 1));
+  const outwardAngleRadians = clamp(num(emitter.outwardAngleDegrees, 240), 0, 360) * (Math.PI / 180);
+  const emissionDirection = rotateVecY(
+    BABYLON,
+    readVec(BABYLON, emitter.emissionDirection, new BABYLON.Vector3(1, 0, 0)),
+    emitter.rotationY
+  );
+
+  const angleSeed = sequence01(index, 0);
+  const radiusSeed = Math.sqrt(sequence01(index, 1));
+  const sideSeed = sequence01(index, 2) < 0.5 ? -1 : 1;
+  emissionDirection.y = 0;
+  if (emissionDirection.lengthSquared() < 0.0001) emissionDirection.set(1, 0, 0);
+  emissionDirection.normalize();
+
+  const baseAngle = Math.atan2(emissionDirection.z, emissionDirection.x);
+  const radialAngle = mode === "radial" && outwardAngleRadians < Math.PI * 2 - 0.001
+    ? baseAngle + (angleSeed - 0.5) * outwardAngleRadians
+    : angleSeed * Math.PI * 2;
+  const scatterRadius = spread * (0.35 + radiusSeed * 0.65);
+  const centerJitter = spread * 0.035;
+  const startAngle = sequence01(index, 12) * Math.PI * 2;
+  const startRadius = centerJitter * sequence01(index, 13);
+  const startPos = new BABYLON.Vector3(
+    origin.x + Math.cos(startAngle) * startRadius,
+    origin.y + (0.12 + sequence01(index, 3) * 0.08) * effectScale,
+    origin.z + Math.sin(startAngle) * startRadius
+  );
+  const rotationBase = Math.PI * 2 * rotationStrength;
+  const particleDuration = duration * (0.88 + sequence01(index, 10) * 0.18);
+  const gravityAccel = (5.4 + gravity * 2.1) * effectScale;
+  const horizontalSpeed = scatterRadius / particleDuration;
+  const verticalVelocity = (1.05 + sequence01(index, 14) * 0.72) * effectScale;
+  const velocity = new BABYLON.Vector3(
+    Math.cos(radialAngle) * horizontalSpeed,
+    verticalVelocity,
+    Math.sin(radialAngle) * horizontalSpeed
+  );
+
+  return {
+    active: index < count,
+    startPos,
+    velocity,
+    groundY: origin.y,
+    startRotation: new BABYLON.Vector3((sequence01(index, 4) - 0.5) * rotationBase, (sequence01(index, 5) - 0.5) * rotationBase, (sequence01(index, 6) - 0.5) * rotationBase),
+    rotationDelta: new BABYLON.Vector3(sideSeed * (2.6 + sequence01(index, 7) * 2.2) * rotationStrength, (sequence01(index, 8) - 0.5) * 7.2 * rotationStrength, sideSeed * (1.7 + sequence01(index, 9) * 2.8) * rotationStrength),
+    duration: particleDuration,
+    elapsed: -index * interval,
+    gravityAccel,
+    scale: resourceScale * effectScale * (0.68 + sequence01(index, 11) * 0.24),
+  };
+}
+
+export async function createSolidParticleScatterRuntime({ BABYLON, scene, emitter, urlForPackagePath, shouldStart = false }) {
+  if (!BABYLON) throw new Error("createSolidParticleScatterRuntime requires BABYLON.");
+  if (!scene) throw new Error("createSolidParticleScatterRuntime requires scene.");
+  if (!emitter) throw new Error("createSolidParticleScatterRuntime requires emitter.");
+
+  const count = Math.max(0, Math.round(num(emitter.count ?? emitter.particleCount, 18)));
+  const capacity = Math.max(8, Math.round(num(emitter.capacity, count)));
+  const origin = readVec(BABYLON, emitter.origin, BABYLON.Vector3.Zero());
+  const sps = new BABYLON.SolidParticleSystem(emitter.name || "lumber_debris_scatter", scene, { updatable: true, isPickable: false });
+  const source = await loadSourceMesh(BABYLON, scene, emitter, urlForPackagePath);
+  sps.addShape(source, capacity);
+  source.dispose();
+
+  const mesh = sps.buildMesh();
+  mesh.isPickable = false;
+  mesh.alwaysSelectAsActiveMesh = true;
+  const material = new BABYLON.StandardMaterial(`${emitter.name || "lumber_debris_scatter"}Material`, scene);
+  const materialConfig = emitter.material || {};
+  material.diffuseColor = readColor3(BABYLON, materialConfig.diffuseColor, new BABYLON.Color3(0.52, 0.31, 0.13));
+  material.emissiveColor = readColor3(BABYLON, materialConfig.emissiveColor, new BABYLON.Color3(0.08, 0.045, 0.02));
+  material.specularColor = BABYLON.Color3.Black();
+  mesh.material = material;
+  applyRenderOrder(mesh, material, emitter);
+
+  const states = Array.from({ length: capacity }, (_, index) => createState(BABYLON, index, count, origin, emitter));
+  let activeCount = Math.min(count, capacity);
+  let elapsed = 0;
+  let started = false;
+  const disposeAfter = Math.max(...states.map((state) => Math.max(0, -state.elapsed) + state.duration), 0) + 0.35;
+
+  sps.updateParticle = (particle) => {
+    const state = states[particle.idx];
+    if (!state?.active || state.elapsed < 0) {
+      particle.position.set(0, -9999, 0);
+      particle.scaling.set(0, 0, 0);
+      return particle;
+    }
+    const t = clamp(state.elapsed / state.duration, 0, 1);
+    const elapsed = clamp(state.elapsed, 0, state.duration);
+    const y = state.startPos.y + state.velocity.y * elapsed - 0.5 * state.gravityAccel * elapsed * elapsed;
+    particle.position.set(
+      state.startPos.x + state.velocity.x * elapsed,
+      Math.max(state.groundY, y),
+      state.startPos.z + state.velocity.z * elapsed
+    );
+    particle.rotation.set(state.startRotation.x + state.rotationDelta.x * t, state.startRotation.y + state.rotationDelta.y * t, state.startRotation.z + state.rotationDelta.z * t);
+    particle.scaling.set(state.scale, state.scale, state.scale);
+    return particle;
+  };
+  sps.setParticles();
+
+  let observer = null;
+  const start = () => {
+    if (started) return;
+    started = true;
+    observer = scene.onBeforeRenderObservable.add(() => {
+      const deltaTime = scene.getEngine().getDeltaTime() / 1000;
+      elapsed += deltaTime;
+      for (const state of states) {
+        if (!state.active) continue;
+        state.elapsed += deltaTime;
+        if (state.elapsed >= state.duration) {
+          state.active = false;
+          activeCount = Math.max(0, activeCount - 1);
+        }
+      }
+      sps.setParticles();
+      if (activeCount <= 0 && elapsed >= disposeAfter) preview.dispose();
+    });
+  };
+
+  const preview = {
+    start,
+    stop: () => {
+      if (observer) scene.onBeforeRenderObservable.remove(observer);
+      observer = null;
+      started = false;
+    },
+    dispose: () => {
+      if (observer) scene.onBeforeRenderObservable.remove(observer);
+      observer = null;
+      sps.dispose();
+      material.dispose();
+    },
+    isStarted: () => started,
+    duration: disposeAfter,
+    mesh,
+    sps,
+  };
+
+  if (shouldStart) start();
+  return preview;
+}

package/packages/effects/lumber_vehicle_wood_chips/index.ts

@@ -0,0 +1,11 @@
+import manifest from './lumber_vehicle_wood_chips.json';
+import runtimeUrl from './assets/runtime/solidParticleScatter.v1.js?url';
+import { createManifestRuntimeEffectPackage } from '../../manifestRuntimePackage';
+
+export const lumberVehicleWoodChipsEffectPackage = createManifestRuntimeEffectPackage({
+  id: 'lumber_vehicle_wood_chips',
+  manifest,
+  assetUrls: {
+    'assets/runtime/solidParticleScatter.v1.js': runtimeUrl,
+  },
+});