@fps-games/vfx 0.1.1

package/dist/effects/run-footstep-dust/index.js

@@ -0,0 +1,343 @@
+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 { V as VFX_RENDERING_GROUP_ID } from "../../chunks/rendering-CV3nhygX.js";
+const 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
+    }
+  }
+];
+const sourceManifest = {
+  emitters
+};
+const RUN_FOOTSTEP_DUST_RENDERING_GROUP_ID = VFX_RENDERING_GROUP_ID;
+const SOURCE_EMITTER = readSourceEmitter();
+const BASE_PARTICLE_SIZE = readNumber(SOURCE_EMITTER.particleSize, 0.18);
+const EFFECT_MANIFEST = {
+  id: "build.particle.run_footstep_dust",
+  nameZh: "跑动脚步烟尘",
+  assets: [
+    "assets/runtime/runFootstepDust.v1.js"
+  ],
+  source: "run_footstep_dust.json"
+};
+const DEFAULT_PARAMS = {
+  emitMode: "timed",
+  lifetime: 1.35,
+  scale: readNumber(SOURCE_EMITTER.effectScale, 1),
+  initialHeight: 0.04,
+  color: readColor(SOURCE_EMITTER.particleColor, { r: 1, g: 1, b: 1 }),
+  opacity: 1,
+  count: readNumber(SOURCE_EMITTER.count, 6),
+  frequency: readNumber(SOURCE_EMITTER.frequency, 4.5),
+  emitInterval: 1 / Math.max(0.01, readNumber(SOURCE_EMITTER.frequency, 4.5)),
+  spread: readNumber(SOURCE_EMITTER.spread, 0.3),
+  particleLife: readNumber(SOURCE_EMITTER.lifeTime, 0.42),
+  speed: readNumber(SOURCE_EMITTER.speed, 0.56),
+  size: 1,
+  trailOffset: readNumber(SOURCE_EMITTER.trailOffset, 0.22),
+  directionX: readNumber(SOURCE_EMITTER.emissionDirection?.x, 1),
+  directionZ: readNumber(SOURCE_EMITTER.emissionDirection?.z, 0),
+  lift: readNumber(SOURCE_EMITTER.emissionDirection?.y, 0.2),
+  gravity: Math.abs(readNumber(SOURCE_EMITTER.gravity?.y, -0.08))
+};
+const runFootstepDustEffectPackage = {
+  id: "run-footstep-dust",
+  nameZh: "跑动脚步烟尘",
+  manifest: EFFECT_MANIFEST,
+  defaultParams: DEFAULT_PARAMS,
+  debugAnchor: "player",
+  debugParams: [
+    {
+      key: "emitMode",
+      label: "发射模式",
+      kind: "enum",
+      options: [
+        { value: "loop", label: "持续发射" },
+        { value: "timed", label: "自定义时间" }
+      ]
+    },
+    { key: "lifetime", label: "生命周期", kind: "lifetime", min: 0.08, max: 6, step: 0.01 },
+    { key: "emitInterval", label: "发射间隔", kind: "number", min: 0.01, max: 5, 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: "count", label: "每步粒子数", kind: "number", min: 0, max: 80, step: 1 },
+    { key: "frequency", label: "脚步频率", kind: "number", min: 0, max: 20, step: 0.01 },
+    { key: "spread", label: "散开范围", kind: "number", min: 0, max: 4, step: 0.01 },
+    { key: "particleLife", label: "单粒生命周期", kind: "number", min: 0.04, max: 3, step: 0.01 },
+    { key: "speed", label: "飘散速度", kind: "number", min: 0, max: 5, step: 0.01 },
+    { key: "size", label: "烟尘大小", kind: "number", min: 0.05, max: 6, step: 0.01 },
+    { key: "trailOffset", label: "身后偏移", kind: "number", min: 0, max: 2, step: 0.01 },
+    { key: "directionX", label: "方向 X", kind: "number", min: -1, max: 1, step: 0.01 },
+    { key: "directionZ", label: "方向 Z", kind: "number", min: -1, max: 1, step: 0.01 },
+    { key: "lift", label: "上扬力度", kind: "number", min: 0, max: 2, step: 0.01 },
+    { key: "gravity", label: "下沉重力", kind: "number", min: 0, max: 3, step: 0.01 }
+  ],
+  create({ scene, root, position, renderingGroupId, params }) {
+    root.position.copyFrom(position).addInPlace(new Vector3(0, params.initialHeight, 0));
+    const system = createFootstepDustSystem(scene, root, params, renderingGroupId);
+    const runner = createStepEmitter(scene, system, params);
+    let disposed = false;
+    let stopTimer = null;
+    let disposeTimer = null;
+    system.start();
+    runner.start();
+    if (readEmitMode(params.emitMode) === "timed") {
+      stopTimer = window.setTimeout(() => runner.stop(), Math.max(0.01, params.lifetime) * 1e3);
+      disposeTimer = window.setTimeout(
+        () => disposeAll(),
+        Math.max(0.05, params.lifetime + params.particleLife + 0.25) * 1e3
+      );
+    }
+    return {
+      root,
+      dispose() {
+        disposeAll();
+      }
+    };
+    function disposeAll() {
+      if (disposed) return;
+      disposed = true;
+      if (stopTimer !== null) window.clearTimeout(stopTimer);
+      if (disposeTimer !== null) window.clearTimeout(disposeTimer);
+      runner.dispose();
+      system.dispose(false);
+      root.dispose();
+    }
+  }
+};
+function createFootstepDustSystem(scene, root, params, renderingGroupId) {
+  const count = Math.max(0, Math.round(params.count));
+  const capacity = Math.max(48, Math.round(readNumber(SOURCE_EMITTER.capacity, count * Math.max(6, params.frequency * params.particleLife * 3))));
+  const system = new ParticleSystem("run-footstep-dust", capacity, scene);
+  const effectScale = Math.max(0.01, params.scale);
+  const particleSize = Math.max(1e-3, BASE_PARTICLE_SIZE * params.size * effectScale);
+  const dustColor = params.color;
+  const movementDirection = new Vector3(params.directionX, 0, params.directionZ);
+  if (movementDirection.lengthSquared() < 1e-4) movementDirection.set(1, 0, 0);
+  movementDirection.normalize();
+  const sideDirection = new Vector3(-movementDirection.z, 0, movementDirection.x);
+  const backwardDirection = movementDirection.scale(-1);
+  const spread = Math.max(0, params.spread) * effectScale;
+  const speed = Math.max(0, params.speed) * effectScale;
+  const trailOffset = Math.max(0, params.trailOffset) * effectScale;
+  system.renderingGroupId = renderingGroupId ?? RUN_FOOTSTEP_DUST_RENDERING_GROUP_ID;
+  system.particleTexture = getFootstepDustTexture(scene);
+  system.emitter = root;
+  system.emitRate = 0;
+  system.manualEmitCount = 0;
+  system.updateSpeed = 1 / 60;
+  system.minLifeTime = Math.max(0.03, params.particleLife);
+  system.maxLifeTime = Math.max(system.minLifeTime, params.particleLife);
+  system.minSize = particleSize;
+  system.maxSize = particleSize;
+  system.minEmitPower = speed;
+  system.maxEmitPower = speed;
+  system.minAngularSpeed = 0;
+  system.maxAngularSpeed = 0;
+  system.gravity = new Vector3(0, -Math.max(0, params.gravity) * effectScale, 0);
+  system.blendMode = ParticleSystem.BLENDMODE_STANDARD;
+  system.color1 = tintColor(dustColor, 1.04, 0.58 * params.opacity);
+  system.color2 = tintColor(dustColor, 0.78, 0.4 * params.opacity);
+  system.colorDead = tintColor(dustColor, 0.52, 0);
+  system.addColorGradient(0, tintColor(dustColor, 1.04, 0));
+  system.addColorGradient(0.12, tintColor(dustColor, 1.04, 0.6 * params.opacity));
+  system.addColorGradient(0.58, tintColor(dustColor, 0.86, 0.42 * params.opacity));
+  system.addColorGradient(1, tintColor(dustColor, 0.58, 0));
+  system.addSizeGradient(0, particleSize * 0.5);
+  system.addSizeGradient(0.28, particleSize * 1.18);
+  system.addSizeGradient(0.72, particleSize * 1.65);
+  system.addSizeGradient(1, particleSize * 1.95);
+  system.addVelocityGradient(0, 1);
+  system.addVelocityGradient(0.35, 0.34);
+  system.addVelocityGradient(1, 0.03);
+  system.addDragGradient(0, 0.85);
+  system.addDragGradient(1, 1.9);
+  let positionIndex = 0;
+  let directionIndex = 0;
+  system.startPositionFunction = (worldMatrix, positionToUpdate, _particle, isLocal) => {
+    const index = positionIndex;
+    positionIndex += 1;
+    const sideJitter = (sequence01(index, 1) - 0.5) * spread * 0.55;
+    const backwardJitter = sequence01(index, 2) * spread * 0.75;
+    const lift = sequence01(index, 3) * 0.012 * effectScale;
+    const x = backwardDirection.x * (trailOffset + backwardJitter) + sideDirection.x * sideJitter;
+    const z = backwardDirection.z * (trailOffset + backwardJitter) + sideDirection.z * sideJitter;
+    if (isLocal) positionToUpdate.set(x, lift, z);
+    else Vector3.TransformCoordinatesFromFloatsToRef(x, lift, z, worldMatrix, positionToUpdate);
+  };
+  system.startDirectionFunction = (worldMatrix, directionToUpdate, _particle, isLocal) => {
+    const index = directionIndex;
+    directionIndex += 1;
+    const backward = backwardDirection.scale(0.28 + sequence01(index, 4) * 0.26);
+    const sideways = sideDirection.scale((sequence01(index, 5) - 0.5) * 0.28);
+    const x = backward.x + sideways.x;
+    const y = Math.max(0, params.lift) * (0.4 + sequence01(index, 6) * 0.5);
+    const z = backward.z + sideways.z;
+    if (isLocal) directionToUpdate.set(x, y, z);
+    else Vector3.TransformNormalFromFloatsToRef(x, y, z, worldMatrix, directionToUpdate);
+  };
+  return system;
+}
+function createStepEmitter(scene, system, params) {
+  let observer = null;
+  let timeToNextStep = 0;
+  const particlesPerStep = Math.max(0, Math.round(params.count));
+  const emitMode = readEmitMode(params.emitMode);
+  const interval = emitMode === "loop" ? Math.max(0.01, readNumber(params.emitInterval, DEFAULT_PARAMS.emitInterval)) : params.frequency > 0 ? 1 / params.frequency : Number.POSITIVE_INFINITY;
+  return { start, stop, dispose: stop };
+  function start() {
+    if (observer) return;
+    observer = scene.onBeforeRenderObservable.add(() => {
+      if (particlesPerStep <= 0 || !Number.isFinite(interval)) return;
+      timeToNextStep -= scene.getEngine().getDeltaTime() / 1e3;
+      while (timeToNextStep <= 0) {
+        system.manualEmitCount += particlesPerStep;
+        timeToNextStep += interval;
+      }
+    });
+  }
+  function stop() {
+    if (observer) scene.onBeforeRenderObservable.remove(observer);
+    observer = null;
+    system.stop();
+  }
+}
+function readEmitMode(value) {
+  return value === "loop" || value === "持续发射" ? "loop" : "timed";
+}
+function getFootstepDustTexture(scene) {
+  const key = "__vfx_run_footstep_dust_texture";
+  const metadata = scene.metadata && typeof scene.metadata === "object" ? scene.metadata : {};
+  scene.metadata = metadata;
+  const existing = metadata[key];
+  if (existing && !isTextureDisposed(existing)) return existing;
+  if (existing && isTextureDisposed(existing)) delete metadata[key];
+  const texture = new DynamicTexture("run_footstep_dust_texture", { width: 128, height: 128 }, scene, true);
+  const context = texture.getContext();
+  context.clearRect(0, 0, 128, 128);
+  for (const puff of [
+    { x: 48, y: 69, radius: 34, alpha: 0.72 },
+    { x: 70, y: 60, radius: 31, alpha: 0.64 },
+    { x: 86, y: 76, radius: 27, alpha: 0.5 }
+  ]) {
+    const shadow = context.createRadialGradient(puff.x, puff.y + 2, puff.radius * 0.22, puff.x, puff.y + 2, puff.radius + 5);
+    shadow.addColorStop(0, `rgba(86, 78, 64, ${puff.alpha * 0.22})`);
+    shadow.addColorStop(1, "rgba(86, 78, 64, 0)");
+    context.fillStyle = shadow;
+    context.beginPath();
+    context.arc(puff.x, puff.y + 2, puff.radius + 5, 0, Math.PI * 2);
+    context.fill();
+  }
+  for (const puff of [
+    { x: 48, y: 69, radius: 34, alpha: 0.72 },
+    { x: 70, y: 60, radius: 31, alpha: 0.64 },
+    { x: 86, y: 76, radius: 27, alpha: 0.5 }
+  ]) {
+    const core = context.createRadialGradient(puff.x, puff.y, puff.radius * 0.12, puff.x, puff.y, puff.radius);
+    core.addColorStop(0, `rgba(255, 255, 255, ${puff.alpha})`);
+    core.addColorStop(0.58, `rgba(235, 229, 210, ${puff.alpha * 0.52})`);
+    core.addColorStop(1, "rgba(220, 212, 188, 0)");
+    context.fillStyle = core;
+    context.beginPath();
+    context.arc(puff.x, puff.y, puff.radius, 0, Math.PI * 2);
+    context.fill();
+  }
+  texture.hasAlpha = true;
+  texture.update(false);
+  metadata[key] = texture;
+  texture.onDisposeObservable.addOnce(() => {
+    if (metadata[key] === texture) delete metadata[key];
+  });
+  return texture;
+}
+function readSourceEmitter() {
+  const source = sourceManifest;
+  return source.emitters?.[0] ?? {};
+}
+function isTextureDisposed(texture) {
+  return Boolean(texture.isDisposed?.());
+}
+function readColor(value, fallback) {
+  if (typeof value === "string") {
+    const match = /^#?([0-9a-f]{6})$/i.exec(value);
+    if (match) {
+      const hex = match[1];
+      return {
+        r: parseInt(hex.slice(0, 2), 16) / 255,
+        g: parseInt(hex.slice(2, 4), 16) / 255,
+        b: parseInt(hex.slice(4, 6), 16) / 255
+      };
+    }
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const color = value;
+    return {
+      r: readNumber(color.r, fallback.r),
+      g: readNumber(color.g, fallback.g),
+      b: readNumber(color.b, fallback.b)
+    };
+  }
+  return fallback;
+}
+function tintColor(color, brightness, alpha) {
+  return new Color4(
+    clamp01(color.r * brightness),
+    clamp01(color.g * brightness),
+    clamp01(color.b * brightness),
+    clamp01(alpha)
+  );
+}
+function readNumber(value, fallback) {
+  const next = Number(value);
+  return Number.isFinite(next) ? next : fallback;
+}
+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 {
+  runFootstepDustEffectPackage
+};

package/dist/effects/space-shared.d.ts

@@ -0,0 +1,44 @@
+import { ParticleSystem } from '@babylonjs/core/Particles/particleSystem';
+import { DynamicTexture } from '@babylonjs/core/Materials/Textures/dynamicTexture';
+import { Color4 } from '@babylonjs/core/Maths/math.color';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { Scene } from '@babylonjs/core/scene';
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { VfxColorValue, VfxParamDefinition } from '../types';
+export declare const LIFETIME_DEBUG_PARAMS: VfxParamDefinition[];
+export declare const LIFETIME_DEFAULTS: {
+    lifetimeMode: string;
+    lifetime: number;
+};
+export declare function scheduleLifetime(params: {
+    lifetimeMode?: string;
+    lifetime?: number;
+}, dispose: () => void): number;
+export declare function excludeFromGlow(scene: Scene, mesh: AbstractMesh): void;
+export declare function makeFlareTexture(scene: Scene, name?: string, inner?: string, outer?: string): DynamicTexture;
+export interface BurstPSOptions {
+    cap: number;
+    sheet?: [number, number, number];
+    size: [number, number];
+    life: [number, number];
+    power: [number, number];
+    gravity: Vector3;
+    blend: number;
+    c1: Color4;
+    c2: Color4;
+    cd: Color4;
+}
+export declare function makeBurstPS(name: string, scene: Scene, texUrl: string, opts: BurstPSOptions): ParticleSystem;
+export declare class FlyerPool {
+    private readonly scene;
+    private readonly flyers;
+    private readonly observer;
+    private disposed;
+    constructor(scene: Scene);
+    spawn(mesh: Mesh, origin: Vector3, vel: Vector3, gravity: number, maxLife: number): void;
+    get activeCount(): number;
+    private update;
+    dispose(): void;
+}
+export declare function colorVec4(c: VfxColorValue, a?: number): Color4;

package/dist/effects/thruster-flame/index.d.ts

@@ -0,0 +1,15 @@
+import { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+type EngineMode = 'ion' | 'chem' | 'plasma';
+interface ThrusterFlameParams extends VfxParamValues {
+    lifetimeMode: string;
+    lifetime: number;
+    throttle: number;
+    flow: number;
+    afterburner: number;
+    mode: EngineMode;
+    rootColor: VfxColorValue;
+    tipColor: VfxColorValue;
+    coreColor: VfxColorValue;
+}
+export declare const thrusterFlameEffectPackage: VfxEffectPackage<ThrusterFlameParams>;
+export {};