@fps-games/vfx 0.1.1

package/dist/effects/pulse-laser-volley/index.js

@@ -0,0 +1,173 @@
+import { CreatePlane } from "@babylonjs/core/Meshes/Builders/planeBuilder";
+import { CreateSphere } from "@babylonjs/core/Meshes/Builders/sphereBuilder";
+import { ShaderMaterial } from "@babylonjs/core/Materials/shaderMaterial";
+import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial";
+import { Effect } from "@babylonjs/core/Materials/effect";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture";
+import { Color3 } from "@babylonjs/core/Maths/math.color";
+import { Constants } from "@babylonjs/core/Engines/constants";
+import { L as LIFETIME_DEBUG_PARAMS, a as LIFETIME_DEFAULTS, s as scheduleLifetime } from "../../chunks/space-shared-BXV1hc0k.js";
+const boltTextureUrl = "data:image/webp;base64,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";
+const DEFAULT_PARAMS = {
+  ...LIFETIME_DEFAULTS,
+  targetDistance: 12,
+  volleyInterval: 0.22,
+  boltSpeed: 26,
+  boltsPerVolley: 6,
+  boltSpacing: 0.5,
+  boltLen: 1,
+  boltColor: { r: 0.071, g: 0.408, b: 1 },
+  // #1268ff
+  boltCore: 0.3,
+  boltCorePow: 3,
+  boltBright: 1.3
+};
+const BOLT_LEN = 2, BOLT_W = 0.34, POOL_SIZE = 60;
+const BOLT_VERTEX = `precision highp float;
+attribute vec3 position; attribute vec2 uv;
+uniform mat4 worldViewProjection;
+varying vec2 vUV;
+void main() { vUV = uv; gl_Position = worldViewProjection * vec4(position, 1.0); }`;
+const BOLT_FRAGMENT = `precision highp float;
+varying vec2 vUV;
+uniform sampler2D tex;
+uniform vec3 tint;
+uniform float coreStr; uniform float corePow; uniform float bright;
+void main() {
+  vec4 t = texture2D(tex, vUV);
+  float core = pow(t.a, corePow) * coreStr;
+  vec3 col = mix(tint, vec3(1.0), core) * bright;
+  gl_FragColor = vec4(col, t.a);
+}`;
+let shadersRegistered = false;
+function registerShaders() {
+  if (shadersRegistered) return;
+  Effect.ShadersStore["vfxPulseBoltVertexShader"] = BOLT_VERTEX;
+  Effect.ShadersStore["vfxPulseBoltFragmentShader"] = BOLT_FRAGMENT;
+  shadersRegistered = true;
+}
+function colorVec(c) {
+  return new Color3(c.r, c.g, c.b);
+}
+function excludeFromGlow(scene, mesh) {
+  for (const layer of scene.effectLayers ?? []) {
+    const add = layer.addExcludedMesh;
+    if (typeof add === "function") add.call(layer, mesh);
+  }
+}
+const pulseLaserVolleyEffectPackage = {
+  id: "pulse-laser-volley",
+  nameZh: "脉冲激光",
+  defaultParams: DEFAULT_PARAMS,
+  debugAnchor: "playerRight",
+  debugParams: [
+    ...LIFETIME_DEBUG_PARAMS,
+    { key: "targetDistance", label: "目标距离", kind: "number", min: 2, max: 40, step: 0.5 },
+    { key: "volleyInterval", label: "齐射间隔(s)", kind: "number", min: 0.08, max: 1, step: 0.01 },
+    { key: "boltSpeed", label: "光弹速度", kind: "number", min: 5, max: 60, step: 1 },
+    { key: "boltsPerVolley", label: "每排弹数", kind: "number", min: 1, max: 12, step: 1 },
+    { key: "boltSpacing", label: "排内间距", kind: "number", min: 0.2, max: 1.5, step: 0.05 },
+    { key: "boltLen", label: "光弹长度", kind: "number", min: 0.3, max: 4, step: 0.05 },
+    { key: "boltColor", label: "光弹颜色", kind: "color" },
+    { key: "boltCore", label: "白芯强度", kind: "number", min: 0, max: 1, step: 0.01 },
+    { key: "boltCorePow", label: "白芯收窄", kind: "number", min: 0.5, max: 8, step: 0.1 },
+    { key: "boltBright", label: "光弹亮度", kind: "number", min: 0.2, max: 3, step: 0.05 }
+  ],
+  create({ scene, root, position, rotationY, params }) {
+    root.position.copyFrom(position);
+    root.rotation.y = rotationY;
+    registerShaders();
+    const boltTex = new Texture(boltTextureUrl, scene);
+    boltTex.hasAlpha = true;
+    const boltMat = new ShaderMaterial("vfx_pulse_boltMat", scene, { vertex: "vfxPulseBolt", fragment: "vfxPulseBolt" }, {
+      attributes: ["position", "uv"],
+      uniforms: ["worldViewProjection", "tint", "coreStr", "corePow", "bright"],
+      samplers: ["tex"],
+      needAlphaBlending: true
+    });
+    boltMat.setTexture("tex", boltTex);
+    boltMat.backFaceCulling = false;
+    boltMat.disableDepthWrite = true;
+    boltMat.alphaMode = Constants.ALPHA_ADD;
+    boltMat.setColor3("tint", colorVec(params.boltColor));
+    boltMat.setFloat("coreStr", params.boltCore);
+    boltMat.setFloat("corePow", params.boltCorePow);
+    boltMat.setFloat("bright", params.boltBright);
+    const pool = [];
+    for (let i = 0; i < POOL_SIZE; i++) {
+      const mesh = CreatePlane(`vfx_pulse_bolt${i}`, { width: BOLT_W, height: BOLT_LEN }, scene);
+      mesh.rotation.x = Math.PI / 2;
+      mesh.material = boltMat;
+      mesh.isPickable = false;
+      mesh.parent = root;
+      mesh.setEnabled(false);
+      excludeFromGlow(scene, mesh);
+      pool.push({ mesh, left: 0 });
+    }
+    const muzzle = CreateSphere("vfx_pulse_muzzle", { diameter: 0.85, segments: 16 }, scene);
+    const muzzleMat = new StandardMaterial("vfx_pulse_muzzleMat", scene);
+    muzzleMat.emissiveColor = new Color3(1, 1, 1);
+    muzzleMat.diffuseColor = Color3.Black();
+    muzzleMat.disableLighting = true;
+    muzzleMat.alpha = 0.95;
+    muzzle.material = muzzleMat;
+    muzzle.isPickable = false;
+    muzzle.parent = root;
+    muzzle.position.set(0, 0, 0);
+    let muzzleFlash = 0;
+    function fireVolley() {
+      const n = Math.max(1, Math.round(params.boltsPerVolley));
+      const dist = params.targetDistance;
+      let fired = 0;
+      for (const b of pool) {
+        if (fired >= n) break;
+        if (b.left > 0) continue;
+        const off = (fired - (n - 1) / 2) * params.boltSpacing;
+        b.mesh.position.set(off, 0, 0);
+        b.mesh.scaling.z = params.boltLen / BOLT_LEN;
+        b.left = dist / params.boltSpeed;
+        b.mesh.setEnabled(true);
+        fired += 1;
+      }
+      muzzleFlash = 1;
+    }
+    let volleyTimer = 0;
+    const observer = scene.onBeforeRenderObservable.add(() => {
+      const dt = Math.min(scene.getEngine().getDeltaTime() / 1e3, 0.05);
+      volleyTimer += dt;
+      if (volleyTimer >= params.volleyInterval) {
+        volleyTimer = 0;
+        fireVolley();
+      }
+      muzzleFlash = Math.max(0, muzzleFlash - dt * 6);
+      const s = 1 + muzzleFlash * 0.6;
+      muzzle.scaling.set(s, s, s);
+      const step = params.boltSpeed * dt;
+      for (const b of pool) {
+        if (b.left <= 0) continue;
+        b.left -= dt;
+        b.mesh.position.z += step;
+        if (b.left <= 0) b.mesh.setEnabled(false);
+      }
+    });
+    let disposed = false;
+    let ltTimer = 0;
+    const dispose = () => {
+      if (disposed) return;
+      disposed = true;
+      if (ltTimer) window.clearTimeout(ltTimer);
+      scene.onBeforeRenderObservable.remove(observer);
+      for (const b of pool) b.mesh.dispose();
+      muzzle.dispose();
+      muzzleMat.dispose();
+      boltMat.dispose();
+      boltTex.dispose();
+      root.dispose();
+    };
+    ltTimer = scheduleLifetime(params, dispose);
+    return { root, dispose };
+  }
+};
+export {
+  pulseLaserVolleyEffectPackage
+};

package/dist/effects/resource-collect-sparkles/effect.json.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+  "id": "resource-collect-sparkles",
+  "nameZh": "资源持续收集圆点",
+  "assets": [],
+  "source": "procedural"
+}
+;
+
+export default _default;

package/dist/effects/resource-collect-sparkles/index.d.ts

@@ -0,0 +1,21 @@
+import { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+interface ResourceCollectSparklesParams extends VfxParamValues {
+    lifetime: number;
+    emitMode: string;
+    scale: number;
+    initialHeight: number;
+    color: VfxColorValue;
+    opacity: number;
+    particleCount: number;
+    particleLife: number;
+    minSize: number;
+    maxSize: number;
+    directionX: number;
+    directionY: number;
+    directionZ: number;
+    riseSpeed: number;
+    drift: number;
+    glowStrength: number;
+}
+export declare const resourceCollectSparklesEffectPackage: VfxEffectPackage<ResourceCollectSparklesParams>;
+export {};

package/dist/effects/resource-collect-sparkles/index.js

@@ -0,0 +1,222 @@
+import { Color4 } from "@babylonjs/core/Maths/math.color";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { DynamicTexture } from "@babylonjs/core/Materials/Textures/dynamicTexture";
+import { ParticleSystem } from "@babylonjs/core/Particles/particleSystem";
+import { c as configureVfxParticleSystem } from "../../chunks/rendering-CV3nhygX.js";
+const id = "resource-collect-sparkles";
+const nameZh = "资源持续收集圆点";
+const assets = [];
+const source = "procedural";
+const manifest = {
+  id,
+  nameZh,
+  assets,
+  source
+};
+const DEFAULT_PARAMS = {
+  lifetime: 1,
+  emitMode: "loop",
+  scale: 1,
+  initialHeight: 0.035,
+  color: { r: 1, g: 0.82, b: 0.38 },
+  opacity: 0.88,
+  particleCount: 26,
+  particleLife: 0.86,
+  minSize: 0.045,
+  maxSize: 0.12,
+  directionX: 0,
+  directionY: 1,
+  directionZ: 0,
+  riseSpeed: 0.58,
+  drift: 0.08,
+  glowStrength: 2.4
+};
+const resourceCollectSparklesEffectPackage = {
+  id: "resource-collect-sparkles",
+  nameZh: "资源持续收集圆点",
+  manifest,
+  defaultParams: DEFAULT_PARAMS,
+  debugAnchor: "playerRight",
+  debugParams: [
+    {
+      key: "emitMode",
+      label: "发射模式",
+      kind: "enum",
+      options: [
+        { value: "loop", label: "一直发射" },
+        { value: "timed", label: "自定义时间" }
+      ]
+    },
+    { key: "lifetime", label: "生命周期", kind: "lifetime", min: 0.08, max: 8, step: 0.01 },
+    { key: "scale", label: "整体缩放", kind: "scale", min: 0.05, max: 6, step: 0.01 },
+    { key: "initialHeight", label: "初始高度", kind: "number", min: -0.5, max: 2, step: 0.01 },
+    { key: "color", label: "圆点颜色", kind: "color" },
+    { key: "opacity", label: "透明度", kind: "opacity", min: 0, max: 1, step: 0.01 },
+    { key: "particleCount", label: "粒子数量", kind: "number", min: 0, max: 240, step: 1 },
+    { key: "particleLife", label: "单点生命", kind: "number", min: 0.08, max: 4, step: 0.01 },
+    { key: "minSize", label: "最小大小", kind: "number", min: 5e-3, max: 1, step: 1e-3 },
+    { key: "maxSize", label: "最大大小", kind: "number", min: 5e-3, max: 1, step: 1e-3 },
+    { key: "directionX", label: "方向 X", kind: "number", min: -1, max: 1, step: 0.01 },
+    { key: "directionY", label: "方向 Y", kind: "number", min: -1, max: 1, step: 0.01 },
+    { key: "directionZ", label: "方向 Z", kind: "number", min: -1, max: 1, step: 0.01 },
+    { key: "riseSpeed", label: "发射速度", kind: "number", min: 0, max: 5, step: 0.01 },
+    { key: "drift", label: "方向扰动", kind: "number", min: 0, max: 2, step: 0.01 },
+    { key: "glowStrength", label: "光芒强度", kind: "number", min: 0.1, max: 8, step: 0.05 }
+  ],
+  create({ scene, root, position, params }) {
+    root.position.copyFrom(position).addInPlace(new Vector3(0, params.initialHeight, 0));
+    const system = createDotSystem(scene, root, params);
+    let disposed = false;
+    let stopTimer = null;
+    let disposeTimer = null;
+    system.start();
+    if (readEmitMode(params.emitMode) === "timed") {
+      stopTimer = window.setTimeout(() => system.stop(), Math.max(0.01, params.lifetime) * 1e3);
+      disposeTimer = window.setTimeout(
+        () => disposeAll(),
+        Math.max(0.05, params.lifetime + params.particleLife + 0.12) * 1e3
+      );
+    }
+    return {
+      root,
+      dispose() {
+        disposeAll();
+      }
+    };
+    function disposeAll() {
+      if (disposed) return;
+      disposed = true;
+      if (stopTimer !== null) window.clearTimeout(stopTimer);
+      if (disposeTimer !== null) window.clearTimeout(disposeTimer);
+      system.stop();
+      system.dispose(false);
+      root.dispose();
+    }
+  }
+};
+function createDotSystem(scene, root, params) {
+  const scale = Math.max(0.01, params.scale);
+  const particleCount = Math.max(0, Math.round(params.particleCount));
+  const particleLife = Math.max(0.04, params.particleLife);
+  const emitRate = particleCount / particleLife;
+  const capacity = Math.max(16, Math.ceil(particleCount * 2.4 + 16));
+  const system = new ParticleSystem("resource-collect-dots", capacity, scene);
+  const minSize = Math.max(1e-3, Math.min(params.minSize, params.maxSize) * scale);
+  const maxSize = Math.max(minSize, Math.max(params.minSize, params.maxSize) * scale);
+  configureVfxParticleSystem(system);
+  system.particleTexture = getDotTexture(scene);
+  system.emitter = root;
+  system.emitRate = emitRate;
+  system.updateSpeed = 1 / 60;
+  system.minLifeTime = particleLife * 0.9;
+  system.maxLifeTime = particleLife * 1.14;
+  system.minSize = minSize;
+  system.maxSize = maxSize;
+  system.minAngularSpeed = 0;
+  system.maxAngularSpeed = 0;
+  system.minEmitPower = 1;
+  system.maxEmitPower = 1;
+  system.gravity = Vector3.Zero();
+  system.blendMode = ParticleSystem.BLENDMODE_ADD;
+  const glow = Math.max(0.1, params.glowStrength);
+  system.color1 = tintColor(params.color, glow, 0.72 * params.opacity);
+  system.color2 = tintColor(params.color, glow * 1.18, 0.9 * params.opacity);
+  system.colorDead = tintColor(params.color, glow, 0);
+  system.addColorGradient(0, tintColor(params.color, glow * 0.65, 0));
+  system.addColorGradient(0.18, tintColor(params.color, glow * 1.28, 0.82 * params.opacity));
+  system.addColorGradient(0.72, tintColor(params.color, glow, 0.68 * params.opacity));
+  system.addColorGradient(1, tintColor(params.color, glow * 0.5, 0));
+  system.addVelocityGradient(0, 0.92);
+  system.addVelocityGradient(0.72, 1);
+  system.addVelocityGradient(1, 0.42);
+  system.addDragGradient(0, 0.08);
+  system.addDragGradient(1, 0.45);
+  let positionIndex = 0;
+  let directionIndex = 4096;
+  system.startPositionFunction = (worldMatrix, positionToUpdate, _particle, isLocal) => {
+    const index = positionIndex;
+    positionIndex += 1;
+    const local = sampleDotPosition(index, scale);
+    if (isLocal) positionToUpdate.copyFrom(local);
+    else Vector3.TransformCoordinatesToRef(local, worldMatrix, positionToUpdate);
+  };
+  system.startDirectionFunction = (worldMatrix, directionToUpdate, _particle, isLocal) => {
+    const index = directionIndex;
+    directionIndex += 1;
+    const baseDirection = getEmitDirection(params);
+    const drift = Math.max(0, params.drift) * scale;
+    const speed = Math.max(0, params.riseSpeed) * scale * lerp(0.78, 1.18, sequence01(index, 1));
+    const direction = baseDirection.scale(speed).addInPlace(new Vector3(
+      (sequence01(index, 0) - 0.5) * drift,
+      (sequence01(index, 3) - 0.5) * drift * 0.35,
+      (sequence01(index, 2) - 0.5) * drift
+    ));
+    if (isLocal) directionToUpdate.copyFrom(direction);
+    else Vector3.TransformNormalToRef(direction, worldMatrix, directionToUpdate);
+  };
+  return system;
+}
+function readEmitMode(value) {
+  return value === "timed" || value === "自定义时间" ? "timed" : "loop";
+}
+function getEmitDirection(params) {
+  const direction = new Vector3(params.directionX, params.directionY, params.directionZ);
+  if (direction.lengthSquared() < 1e-4) direction.set(0, 1, 0);
+  direction.normalize();
+  return direction;
+}
+function sampleDotPosition(index, scale) {
+  const radius = Math.sqrt(sequence01(index, 0)) * 0.34 * scale;
+  const angle = sequence01(index, 1) * Math.PI * 2;
+  const y = sequence01(index, 2) * 0.018 * scale;
+  return new Vector3(Math.cos(angle) * radius, y, Math.sin(angle) * radius);
+}
+function getDotTexture(scene) {
+  const key = "__vfx_resource_collect_dot_texture";
+  const metadata = scene.metadata && typeof scene.metadata === "object" ? scene.metadata : {};
+  scene.metadata = metadata;
+  const existing = metadata[key];
+  if (existing) return existing;
+  const texture = new DynamicTexture("resource_collect_dot_texture", { width: 64, height: 64 }, scene, true);
+  const context = texture.getContext();
+  context.fillStyle = "rgba(255, 255, 255, 0)";
+  context.fillRect(0, 0, 64, 64);
+  const dot = context.createRadialGradient(32, 32, 1, 32, 32, 30);
+  dot.addColorStop(0, "rgba(255, 255, 255, 1)");
+  dot.addColorStop(0.64, "rgba(255, 255, 255, 1)");
+  dot.addColorStop(0.84, "rgba(255, 255, 255, 0.82)");
+  dot.addColorStop(1, "rgba(255, 255, 255, 0)");
+  context.fillStyle = dot;
+  context.beginPath();
+  context.arc(32, 32, 30, 0, Math.PI * 2);
+  context.fill();
+  texture.hasAlpha = true;
+  texture.update(false);
+  metadata[key] = texture;
+  return texture;
+}
+function tintColor(color, brightness, alpha) {
+  return new Color4(
+    Math.max(0, color.r * brightness),
+    Math.max(0, color.g * brightness),
+    Math.max(0, color.b * brightness),
+    clamp01(alpha)
+  );
+}
+function lerp(min, max, t) {
+  return min + (max - min) * t;
+}
+function clamp01(value) {
+  return Math.min(1, Math.max(0, 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);
+}
+export {
+  resourceCollectSparklesEffectPackage
+};

package/dist/effects/run-footstep-dust/effect.json.d.ts

@@ -0,0 +1,186 @@
+declare const _default: {
+  "schemaVersion": "build.particle/v1",
+  "id": "build.particle.run_footstep_dust",
+  "effectId": "run_footstep_dust",
+  "displayName": {
+    "en": "Run Footstep Dust",
+    "zh": "跑动脚步烟尘"
+  },
+  "kind": "runFootstepDust",
+  "runtime": {
+    "runtimeId": "runFootstepDust/v1",
+    "path": "assets/runtime/runFootstepDust.v1.js",
+    "entry": "createRunFootstepDustRuntime"
+  },
+  "assets": {
+    "runtime": [
+      {
+        "id": "run_footstep_dust_runtime",
+        "packagePath": "assets/runtime/runFootstepDust.v1.js"
+      }
+    ],
+    "source": [
+      {
+        "kind": "typescript",
+        "id": "run_footstep_dust_source_ts",
+        "packagePath": "source/src/effects/runFootstepDust.ts",
+        "sourcePath": "D:/project/loy_babylon_particle_test/src/effects/runFootstepDust.ts"
+      }
+    ]
+  },
+  "emitters": [
+    {
+      "name": "run_footstep_dust",
+      "enabled": true,
+      "deterministic": true,
+      "type": "ParticleSystem",
+      "capacity": 64,
+      "count": 6,
+      "frequency": 4.5,
+      "particleColor": "#ffffff",
+      "spread": 0.3,
+      "lifeTime": 0.42,
+      "speed": 0.56,
+      "particleSize": 0.18,
+      "effectScale": 1,
+      "trailOffset": 0.22,
+      "emissionDirection": {
+        "x": 1,
+        "y": 0.2,
+        "z": 0
+      },
+      "gravity": {
+        "x": 0,
+        "y": -0.08,
+        "z": 0
+      },
+      "origin": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "runtime": {
+        "continuous": true,
+        "disposeOnComplete": false
+      }
+    }
+  ],
+  "parameters": [
+    {
+      "key": "count",
+      "label": "Count",
+      "type": "number",
+      "default": 6,
+      "min": 0,
+      "max": 999,
+      "step": 1,
+      "mapsTo": "emitters[0].count",
+      "note": "Particles emitted per dust burst behind the character."
+    },
+    {
+      "key": "frequency",
+      "label": "Frequency",
+      "type": "number",
+      "default": 4.5,
+      "min": 0,
+      "max": 30,
+      "step": 0.01,
+      "mapsTo": "emitters[0].frequency",
+      "note": "Dust bursts per second for continuous playback."
+    },
+    {
+      "key": "particleColor",
+      "label": "Color",
+      "type": "color",
+      "default": "#ffffff",
+      "mapsTo": "emitters[0].particleColor",
+      "note": "Base tint for the dust particles."
+    },
+    {
+      "key": "spread",
+      "label": "Spread",
+      "type": "number",
+      "default": 0.3,
+      "min": 0,
+      "max": 20,
+      "step": 0.01,
+      "mapsTo": "emitters[0].spread"
+    },
+    {
+      "key": "life",
+      "label": "Life",
+      "type": "number",
+      "default": 0.42,
+      "min": 0.01,
+      "max": 20,
+      "step": 0.01,
+      "mapsTo": "emitters[0].lifeTime"
+    },
+    {
+      "key": "speed",
+      "label": "Speed",
+      "type": "number",
+      "default": 0.56,
+      "min": 0,
+      "max": 20,
+      "step": 0.01,
+      "mapsTo": "emitters[0].speed"
+    },
+    {
+      "key": "size",
+      "label": "Size",
+      "type": "number",
+      "default": 1,
+      "min": 0,
+      "max": 20,
+      "step": 0.01,
+      "mapsTo": "emitters[0].particleSize",
+      "note": "Editor multiplies this by base particleSize 0.18."
+    },
+    {
+      "key": "scale",
+      "label": "Scale",
+      "type": "number",
+      "default": 1,
+      "min": 0.01,
+      "max": 20,
+      "step": 0.01,
+      "mapsTo": "emitters[0].effectScale"
+    },
+    {
+      "key": "dirX",
+      "label": "Dir X",
+      "type": "range",
+      "default": 100,
+      "min": -100,
+      "max": 100,
+      "mapsTo": "emitters[0].emissionDirection.x"
+    },
+    {
+      "key": "dirY",
+      "label": "Dir Y",
+      "type": "range",
+      "default": 20,
+      "min": 20,
+      "max": 120,
+      "mapsTo": "emitters[0].emissionDirection.y"
+    },
+    {
+      "key": "dirZ",
+      "label": "Dir Z",
+      "type": "range",
+      "default": 0,
+      "min": -100,
+      "max": 100,
+      "mapsTo": "emitters[0].emissionDirection.z"
+    }
+  ],
+  "notes": [
+    "Continuous Unity-style particle playback: the runtime emits deterministic cartoon dust puffs behind the character at the configured frequency.",
+    "Count controls particles per burst, not total lifetime particles.",
+    "Dust is spawned behind the emitter based on the current direction controls."
+  ]
+}
+;
+
+export default _default;

package/dist/effects/run-footstep-dust/index.d.ts

@@ -0,0 +1,23 @@
+import { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+interface RunFootstepDustParams extends VfxParamValues {
+    emitMode: string;
+    lifetime: number;
+    scale: number;
+    initialHeight: number;
+    color: VfxColorValue;
+    opacity: number;
+    count: number;
+    frequency: number;
+    emitInterval: number;
+    spread: number;
+    particleLife: number;
+    speed: number;
+    size: number;
+    trailOffset: number;
+    directionX: number;
+    directionZ: number;
+    lift: number;
+    gravity: number;
+}
+export declare const runFootstepDustEffectPackage: VfxEffectPackage<RunFootstepDustParams>;
+export {};