@fps-games/vfx 0.1.1

package/packages/effects/lumber-debris-scatter/vfx-params.json

@@ -0,0 +1,19 @@
+{
+  "__generation.offsetX": 0,
+  "__generation.offsetY": 0,
+  "__generation.offsetZ": 0,
+  "lifetime": 0.3,
+  "scale": 1,
+  "initialHeight": 1,
+  "count": 5,
+  "spread": 3,
+  "speed": 1,
+  "size": 1.6,
+  "sizeX": 1,
+  "sizeY": 1,
+  "sizeZ": 2,
+  "scatterShape": "vertical",
+  "outwardAngle": 240,
+  "scatterGravity": 2,
+  "rotationStrength": 0.5
+}

package/packages/effects/lumber_vehicle_gear_spin/assets/runtime/gearSpin.v1.js

@@ -0,0 +1,202 @@
+export const runtimeId = "gearSpin/v1";
+
+export const runtimeContract = {
+  runtimeId,
+  kind: "gearSpin",
+  emitterFields: {
+    origin: "World-space center of the spinning gear wind effect.",
+    duration: "Total preview lifetime in seconds.",
+    radius: "Ground-plane radius of the circular wind effect.",
+    spinSpeed: "Angular spin speed in radians per second.",
+    windLineCount: "Number of outer wind motion arcs.",
+    windRingCount: "Number of concentric wind line rings.",
+    windLineLength: "World-space length of each wind arc.",
+    color: "Motion line color.",
+  },
+};
+
+function num(value, fallback = 0) {
+  const next = Number(value);
+  return Number.isFinite(next) ? next : fallback;
+}
+
+function readVec(BABYLON, value, fallback = new BABYLON.Vector3(0, 0, 0)) {
+  if (!value) return fallback.clone ? fallback.clone() : 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 scaleColor(BABYLON, color, intensity) {
+  const next = color.clone ? color.clone() : new BABYLON.Color3(color.r, color.g, color.b);
+  return next.scale(Math.max(0, num(intensity, 1)));
+}
+
+function makeMaterial(BABYLON, scene, name, color, alpha, hdrIntensity = 1) {
+  const material = new BABYLON.StandardMaterial(name, scene);
+  material.diffuseColor = color;
+  material.emissiveColor = scaleColor(BABYLON, color, hdrIntensity);
+  material.alpha = alpha;
+  material.backFaceCulling = false;
+  material.disableLighting = true;
+  material.disableDepthWrite = true;
+  material.transparencyMode = BABYLON.Material.MATERIAL_ALPHABLEND;
+  if (BABYLON.Engine?.ALPHA_ADD !== undefined) {
+    material.alphaMode = BABYLON.Engine.ALPHA_ADD;
+  }
+  return material;
+}
+
+function createWindArc(BABYLON, scene, root, material, index, config) {
+  const lineCount = Math.max(1, Math.round(num(config.windLineCount, 4)));
+  const ringIndex = Math.max(0, Math.round(num(config.ringIndex, 0)));
+  const ringCount = Math.max(1, Math.round(num(config.windRingCount, 3)));
+  const radius = Math.max(0.05, num(config.radius, 0.64));
+  const lineLength = Math.max(0.03, num(config.windLineLength, 0.48));
+  const angularLength = Math.min(Math.PI * 0.85, Math.max(0.05, lineLength / radius));
+  const ringOffset = (ringIndex - (ringCount - 1) * 0.5) * Math.max(0.01, num(config.lineSpacing, 0.055));
+  const arcRadius = radius + ringOffset;
+  const phase = (index / lineCount) * Math.PI * 2 + ringIndex * 0.32;
+  const y = num(config.y, 0.035);
+  const steps = 12;
+  const path = [];
+
+  for (let step = 0; step <= steps; step += 1) {
+    const t = step / steps;
+    const angle = phase + t * angularLength;
+    path.push(new BABYLON.Vector3(
+      Math.cos(angle) * arcRadius,
+      y + Math.sin(t * Math.PI) * 0.006,
+      Math.sin(angle) * arcRadius
+    ));
+  }
+
+  const arc = BABYLON.MeshBuilder.CreateTube(
+    `vfx_gear_spin_wind_arc_${index}`,
+    {
+      path,
+      radius: Math.max(0.004, num(config.lineThickness, 0.018)),
+      tessellation: 8,
+      cap: BABYLON.Mesh.CAP_ALL,
+    },
+    scene
+  );
+  arc.parent = root;
+  arc.material = material;
+  arc.metadata = {
+    phase,
+    pulseOffset: index * 0.73,
+  };
+  return arc;
+}
+
+export async function createGearSpinRuntime({ BABYLON, scene, emitter, shouldStart = false }) {
+  if (!BABYLON) throw new Error("createGearSpinRuntime requires BABYLON.");
+  if (!scene) throw new Error("createGearSpinRuntime requires scene.");
+  if (!emitter) throw new Error("createGearSpinRuntime requires emitter.");
+
+  const origin = readVec(BABYLON, emitter.origin, BABYLON.Vector3.Zero());
+  const duration = Math.max(0.1, num(emitter.duration, 1.2));
+  const loop = emitter.loop === true || emitter.loop === "true";
+  const effectScale = Math.max(0.05, num(emitter.effectScale, 1));
+  const radius = Math.max(0.05, num(emitter.radius, 0.64) * effectScale);
+  const color = readColor3(BABYLON, emitter.color, new BABYLON.Color3(1, 1, 1));
+  const hdrIntensity = Math.max(0, num(emitter.hdrIntensity, 1.4));
+  const windLineAlpha = Math.max(0, num(emitter.windLineAlpha, 0.68));
+  const groundOffsetY = Math.max(0.01, num(emitter.groundOffsetY, 0.04) * effectScale);
+
+  const root = new BABYLON.TransformNode(`vfx_gear_spin_${Date.now()}`, scene);
+
+  function setPosition(position) {
+    const next = readVec(BABYLON, position, origin);
+    root.position.copyFrom(next);
+    root.position.y += groundOffsetY;
+  }
+
+  setPosition(origin);
+
+  const windLineMaterial = makeMaterial(BABYLON, scene, "vfx_gear_spin_wind_line_mat", color, windLineAlpha, hdrIntensity);
+
+  const windLineCount = Math.max(1, Math.round(num(emitter.windLineCount, 4)));
+  const windRingCount = Math.max(1, Math.round(num(emitter.windRingCount, 3)));
+  const windArcs = [];
+  for (let ringIndex = 0; ringIndex < windRingCount; ringIndex += 1) {
+    for (let lineIndex = 0; lineIndex < windLineCount; lineIndex += 1) {
+      windArcs.push(createWindArc(BABYLON, scene, root, windLineMaterial, lineIndex, {
+        ringIndex,
+        radius,
+        windLineCount,
+        windRingCount,
+        windLineLength: num(emitter.windLineLength, 0.48) * effectScale,
+        lineThickness: num(emitter.windLineThickness, 0.014) * effectScale,
+        lineSpacing: num(emitter.windLineSpacing, 0.075) * effectScale,
+        y: 0.032 * effectScale + ringIndex * 0.002,
+      }));
+    }
+  }
+
+  let startedAt = 0;
+  let observer = null;
+  let running = false;
+  let disposed = false;
+
+  const update = () => {
+    const elapsed = (performance.now() - startedAt) / 1000;
+    const t = Math.min(1, elapsed / duration);
+    const fade = loop ? 1 : Math.sin(t * Math.PI);
+    const spinSpeed = num(emitter.spinSpeed, 12);
+    root.rotation.y = elapsed * spinSpeed;
+    windLineMaterial.alpha = windLineAlpha * fade;
+    for (const arc of windArcs) {
+      const pulseOffset = num(arc.metadata?.pulseOffset, 0);
+      arc.visibility = 0.7 + Math.sin(elapsed * 10 + pulseOffset) * 0.22;
+      arc.scaling.setAll(0.98 + Math.sin(elapsed * 8 + pulseOffset) * 0.02);
+    }
+
+    if (!loop && elapsed >= duration) {
+      stop();
+    }
+  };
+
+  function start() {
+    if (running || disposed) return;
+    running = true;
+    startedAt = performance.now();
+    root.setEnabled(true);
+    observer = scene.onBeforeRenderObservable.add(update);
+  }
+
+  function stop() {
+    if (!running) return;
+    running = false;
+    if (observer) {
+      scene.onBeforeRenderObservable.remove(observer);
+      observer = null;
+    }
+    dispose();
+  }
+
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    for (const arc of windArcs) arc.dispose(false, true);
+    root.dispose();
+    windLineMaterial.dispose();
+  }
+
+  root.setEnabled(false);
+  const preview = {
+    start,
+    stop,
+    dispose,
+    isStarted: () => running,
+    setPosition,
+    duration,
+  };
+
+  if (shouldStart) start();
+  return preview;
+}

package/packages/effects/lumber_vehicle_gear_spin/index.ts

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

package/packages/effects/lumber_vehicle_gear_spin/lumber_vehicle_gear_spin.json

@@ -0,0 +1,338 @@
+{
+  "schemaVersion": "vfx-effect-package/1.0",
+  "id": "build.particle.lumber_vehicle_gear_spin",
+  "name": {
+    "zh": "伐木车齿轮风圈",
+    "en": "Lumber Vehicle Gear Spin"
+  },
+  "source": {
+    "engine": "babylon",
+    "engineVersion": "8.56.2",
+    "projectPath": "D:/project/lumber_order",
+    "rootAsset": "src/assets/vfx/effects/lumber_vehicle_gear_spin",
+    "sourceId": "lumber_order/lumber_vehicle_gear_spin",
+    "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": "gear_spin_v1",
+        "packagePath": "assets/runtime/gearSpin.v1.js",
+        "runtimeId": "gearSpin/v1",
+        "engine": "babylon",
+        "moduleFormat": "esm",
+        "exports": [
+          "createGearSpinRuntime",
+          "runtimeContract"
+        ],
+        "mimeType": "text/javascript"
+      }
+    ],
+    "raw": []
+  },
+  "emitters": [
+    {
+      "name": "lumber_vehicle_gear_spin_main",
+      "sourceNodeName": "lumber_vehicle_gear_spin_main",
+      "enabled": true,
+      "type": "GearSpin",
+      "duration": 1.2,
+      "effectScale": 1,
+      "radius": 0.82,
+      "windLineCount": 4,
+      "windRingCount": 3,
+      "windLineLength": 0.62,
+      "windLineThickness": 0.014,
+      "windLineSpacing": 0.075,
+      "windLineAlpha": 0.68,
+      "spinSpeed": 12,
+      "groundOffsetY": 0.04,
+      "hdrIntensity": 1.8,
+      "color": {
+        "r": 1,
+        "g": 1,
+        "b": 1,
+        "a": 1
+      },
+      "runtime": {
+        "adapter": "gearSpin/v1",
+        "stopAfterSeconds": 1.2,
+        "disposeOnComplete": true
+      }
+    }
+  ],
+  "runtime": {
+    "driver": "gearSpin",
+    "defaultMesh": null,
+    "defaultOffset": {
+      "x": 0,
+      "y": 0,
+      "z": 0
+    },
+    "start": [
+      "Instantiate Babylon runtime for lumber_vehicle_gear_spin"
+    ],
+    "update": [
+      "Apply Babylon tunable parameter overrides"
+    ],
+    "stop": [
+      "Stop and dispose runtime resources"
+    ],
+    "adapters": [
+      {
+        "id": "gearSpin/v1",
+        "engine": "babylon",
+        "entry": "assets/runtime/gearSpin.v1.js",
+        "moduleFormat": "esm",
+        "exports": [
+          "createGearSpinRuntime",
+          "runtimeContract"
+        ]
+      }
+    ]
+  },
+  "tunableParams": [
+    {
+      "key": "lumber_vehicle_gear_spin.loop",
+      "labelZh": "循环播放",
+      "type": "enum",
+      "default": "false",
+      "options": [
+        {
+          "value": "false",
+          "label": "关闭"
+        },
+        {
+          "value": "true",
+          "label": "开启"
+        }
+      ],
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "loop",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_gear_spin.radius",
+      "labelZh": "风圈半径",
+      "type": "number",
+      "default": 0.82,
+      "min": 0.1,
+      "max": 2,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "radius",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_gear_spin.windLineCount",
+      "labelZh": "风线数量",
+      "type": "number",
+      "default": 4,
+      "min": 1,
+      "max": 12,
+      "step": 1,
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "windLineCount",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_gear_spin.windRingCount",
+      "labelZh": "风线环数",
+      "type": "number",
+      "default": 3,
+      "min": 1,
+      "max": 6,
+      "step": 1,
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "windRingCount",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_gear_spin.windLineLength",
+      "labelZh": "风线长度",
+      "type": "number",
+      "default": 0.62,
+      "min": 0.02,
+      "max": 1,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "windLineLength",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_gear_spin.windLineSpacing",
+      "labelZh": "风线环间距",
+      "type": "number",
+      "default": 0.075,
+      "min": 0.01,
+      "max": 0.3,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "windLineSpacing",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_gear_spin.spinSpeed",
+      "labelZh": "旋转速度",
+      "type": "number",
+      "default": 12,
+      "min": 0,
+      "max": 40,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "spinSpeed",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_gear_spin.color",
+      "labelZh": "风圈颜色",
+      "type": "color",
+      "default": "#ffffff",
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "color",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_gear_spin.hdrIntensity",
+      "labelZh": "HDR强度",
+      "type": "number",
+      "default": 1.8,
+      "min": 0,
+      "max": 6,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "hdrIntensity",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_gear_spin.windLineAlpha",
+      "labelZh": "风线透明度",
+      "type": "number",
+      "default": 0.68,
+      "min": 0,
+      "max": 1,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "windLineAlpha",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_gear_spin.effectScale",
+      "labelZh": "整体缩放",
+      "type": "number",
+      "default": 1,
+      "min": 0.1,
+      "max": 4,
+      "step": 0.01,
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "effectScale",
+        "operator": "set"
+      }
+    },
+    {
+      "key": "lumber_vehicle_gear_spin.duration",
+      "labelZh": "生命周期",
+      "type": "number",
+      "default": 1.2,
+      "min": 0.1,
+      "max": 5,
+      "step": 0.01,
+      "unit": "s",
+      "target": {
+        "emitter": "lumber_vehicle_gear_spin_main",
+        "property": "duration",
+        "operator": "set"
+      }
+    }
+  ],
+  "babylon": {
+    "driver": "gearSpin",
+    "previewConfig": {
+      "textureUrl": null,
+      "emitterCount": 1,
+      "effectFile": "lumber_vehicle_gear_spin.json",
+      "normalizedVfx": null
+    }
+  },
+  "review": {
+    "status": "draft",
+    "artistNotes": [
+      "Peripheral white wind motion arcs for a lumber vehicle gear or saw rotation.",
+      "The effect intentionally avoids rendering the gear or cutting blade itself.",
+      "All visuals are local geometry with additive translucent materials."
+    ],
+    "approvedBy": null,
+    "approvedAt": null
+  },
+  "recording": {
+    "provider": "local-placeholder",
+    "recordedAt": "2026-06-02T00:00:00.000Z",
+    "mimeType": "image/png",
+    "durationSec": 1.2,
+    "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",
+      "gear spin",
+      "motion ring",
+      "wind streak",
+      "lumber vehicle",
+      "casual game"
+    ],
+    "descriptionEn": "A compact circular motion effect with peripheral white wind arcs for spinning lumber vehicle gear teeth.",
+    "useCases": [
+      "lumber vehicle gear rotating",
+      "saw gear motion feedback",
+      "machine action feedback"
+    ],
+    "negativeUseCases": [
+      "upgrade aura",
+      "dust burst",
+      "wood chips",
+      "fire",
+      "explosion"
+    ]
+  },
+  "legacyIds": []
+}

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

@@ -0,0 +1,21 @@
+{
+  "__generation.offsetX": 0,
+  "__generation.offsetY": 0,
+  "__generation.offsetZ": 1.1,
+  "lumber_vehicle_gear_spin.loop": "false",
+  "lumber_vehicle_gear_spin.radius": 0.8,
+  "lumber_vehicle_gear_spin.windLineCount": 2,
+  "lumber_vehicle_gear_spin.windRingCount": 4,
+  "lumber_vehicle_gear_spin.windLineLength": 0.62,
+  "lumber_vehicle_gear_spin.windLineSpacing": 0.075,
+  "lumber_vehicle_gear_spin.spinSpeed": 12,
+  "lumber_vehicle_gear_spin.color": {
+    "r": 1,
+    "g": 1,
+    "b": 1
+  },
+  "lumber_vehicle_gear_spin.hdrIntensity": 1.8,
+  "lumber_vehicle_gear_spin.windLineAlpha": 0.68,
+  "lumber_vehicle_gear_spin.effectScale": 1.4,
+  "lumber_vehicle_gear_spin.duration": 1.2
+}