@fps-games/vfx 0.1.1 → 0.3.3

package/packages/effects/lumber_vehicle_upgrade_aura/lumber_vehicle_upgrade_aura.json

@@ -1,365 +0,0 @@
-{
-  "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_wood_chips/assets/runtime/solidParticleScatter.v1.js

@@ -1,310 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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,
-  },
-});