@fps-games/vfx 0.1.1

package/packages/effects/pulse-laser-volley/index.ts

@@ -0,0 +1,204 @@
+// 脉冲激光齐射(移植自 babylon-laser pulseSystem, 特效#12)。
+// ShaderMaterial 乘色范式(复刻 Unity Particle Add):贴图中性白+alpha,颜色全由 shader tint 决定。
+// 自包含库版:沿 root 局部 +Z 朝距离 targetDistance 的虚拟目标自动整排齐射光弹池 + 发射点白球。
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+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 type { Mesh } from '@babylonjs/core/Meshes/mesh';
+import type { Scene } from '@babylonjs/core/scene';
+import type { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import type { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+import boltTextureUrl from './assets/textures/bolt_guangshu.webp?url';
+import { LIFETIME_DEBUG_PARAMS, LIFETIME_DEFAULTS, scheduleLifetime } from '../space-shared';
+
+interface PulseLaserParams extends VfxParamValues {
+  lifetimeMode: string; lifetime: number;
+  targetDistance: number;
+  volleyInterval: number;
+  boltSpeed: number;
+  boltsPerVolley: number;
+  boltSpacing: number;
+  boltLen: number;
+  boltColor: VfxColorValue;
+  boltCore: number;
+  boltCorePow: number;
+  boltBright: number;
+}
+
+const DEFAULT_PARAMS: PulseLaserParams = {
+  ...LIFETIME_DEFAULTS,
+  targetDistance: 12,
+  volleyInterval: 0.22,
+  boltSpeed: 26,
+  boltsPerVolley: 6,
+  boltSpacing: 0.5,
+  boltLen: 1.0,
+  boltColor: { r: 0.071, g: 0.408, b: 1.0 }, // #1268ff
+  boltCore: 0.3,
+  boltCorePow: 3.0,
+  boltBright: 1.3,
+};
+
+const BOLT_LEN = 2.0, 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); }`;
+
+// 乘色:col = mix(tint, white, pow(a,corePow)*coreStr) * bright;  配 ALPHA_ADD
+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(): void {
+  if (shadersRegistered) return;
+  Effect.ShadersStore['vfxPulseBoltVertexShader'] = BOLT_VERTEX;
+  Effect.ShadersStore['vfxPulseBoltFragmentShader'] = BOLT_FRAGMENT;
+  shadersRegistered = true;
+}
+
+function colorVec(c: VfxColorValue): Color3 { return new Color3(c.r, c.g, c.b); }
+
+function excludeFromGlow(scene: Scene, mesh: AbstractMesh): void {
+  for (const layer of scene.effectLayers ?? []) {
+    const add = (layer as unknown as { addExcludedMesh?: (m: AbstractMesh) => void }).addExcludedMesh;
+    if (typeof add === 'function') add.call(layer, mesh);
+  }
+}
+
+interface Bolt { mesh: Mesh; left: number; }
+
+export const pulseLaserVolleyEffectPackage: VfxEffectPackage<PulseLaserParams> = {
+  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);
+
+    // 对象池:单面片,长轴沿局部 +Z,均为 root 子节点(在 root 局部空间飞行)
+    const pool: Bolt[] = [];
+    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 });
+    }
+
+    // 发射点白球(不排除辉光,吃 bloom)
+    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(): void {
+      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);                  // 沿局部 X 横向排开,从根部出发
+        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() / 1000, 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;     // 沿局部 +Z 匀速飞行
+        if (b.left <= 0) b.mesh.setEnabled(false);
+      }
+    });
+
+    let disposed = false;
+    let ltTimer = 0;
+    const dispose = (): void => {
+      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 };
+  },
+};

package/packages/effects/pulse-laser-volley/vfx-params.json

@@ -0,0 +1,5 @@
+{
+  "schemaVersion": "vfx-params/1.0",
+  "effectId": "pulse-laser-volley",
+  "params": {}
+}

package/packages/effects/resource-collect-sparkles/effect.json

@@ -0,0 +1,6 @@
+{
+  "id": "resource-collect-sparkles",
+  "nameZh": "资源持续收集圆点",
+  "assets": [],
+  "source": "procedural"
+}

package/packages/effects/resource-collect-sparkles/index.ts

@@ -0,0 +1,254 @@
+import { Color4 } from '@babylonjs/core/Maths/math.color';
+import { Matrix, Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { DynamicTexture } from '@babylonjs/core/Materials/Textures/dynamicTexture';
+import { ParticleSystem } from '@babylonjs/core/Particles/particleSystem';
+import type { Particle } from '@babylonjs/core/Particles/particle';
+import type { Scene } from '@babylonjs/core/scene';
+import type { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import type { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+import { configureVfxParticleSystem } from '../../rendering';
+import manifest from './effect.json';
+
+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;
+}
+
+const DEFAULT_PARAMS: ResourceCollectSparklesParams = {
+  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,
+};
+
+export const resourceCollectSparklesEffectPackage: VfxEffectPackage<ResourceCollectSparklesParams> = {
+  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: 0.005, max: 1, step: 0.001 },
+    { key: 'maxSize', label: '最大大小', kind: 'number', min: 0.005, max: 1, step: 0.001 },
+    { 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: number | null = null;
+    let disposeTimer: number | null = null;
+
+    system.start();
+    if (readEmitMode(params.emitMode) === 'timed') {
+      stopTimer = window.setTimeout(() => system.stop(), Math.max(0.01, params.lifetime) * 1000);
+      disposeTimer = window.setTimeout(
+        () => disposeAll(),
+        Math.max(0.05, params.lifetime + params.particleLife + 0.12) * 1000,
+      );
+    }
+
+    return {
+      root,
+      dispose() {
+        disposeAll();
+      },
+    };
+
+    function disposeAll(): void {
+      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: Scene, root: TransformNode, params: ResourceCollectSparklesParams): ParticleSystem {
+  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(0.001, 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 as any;
+  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: Matrix, positionToUpdate: Vector3, _particle: Particle, isLocal: boolean) => {
+    const index = positionIndex;
+    positionIndex += 1;
+    const local = sampleDotPosition(index, scale);
+    if (isLocal) positionToUpdate.copyFrom(local);
+    else Vector3.TransformCoordinatesToRef(local, worldMatrix, positionToUpdate);
+  };
+  system.startDirectionFunction = (worldMatrix: Matrix, directionToUpdate: Vector3, _particle: Particle, isLocal: boolean) => {
+    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: string): 'loop' | 'timed' {
+  return value === 'timed' || value === '自定义时间' ? 'timed' : 'loop';
+}
+
+function getEmitDirection(params: ResourceCollectSparklesParams): Vector3 {
+  const direction = new Vector3(params.directionX, params.directionY, params.directionZ);
+  if (direction.lengthSquared() < 0.0001) direction.set(0, 1, 0);
+  direction.normalize();
+  return direction;
+}
+
+function sampleDotPosition(index: number, scale: number): Vector3 {
+  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: Scene): DynamicTexture {
+  const key = '__vfx_resource_collect_dot_texture';
+  const metadata = scene.metadata && typeof scene.metadata === 'object' ? scene.metadata as Record<string, unknown> : {};
+  scene.metadata = metadata;
+  const existing = metadata[key] as DynamicTexture | undefined;
+  if (existing) return existing;
+
+  const texture = new DynamicTexture('resource_collect_dot_texture', { width: 64, height: 64 }, scene, true);
+  const context = texture.getContext() as unknown as CanvasRenderingContext2D;
+  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: VfxColorValue, brightness: number, alpha: number): Color4 {
+  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: number, max: number, t: number): number {
+  return min + (max - min) * t;
+}
+
+function clamp01(value: number): number {
+  return Math.min(1, Math.max(0, value));
+}
+
+function fract(value: number): number {
+  return value - Math.floor(value);
+}
+
+function sequence01(index: number, axis: number): number {
+  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);
+}

package/packages/effects/resource-collect-sparkles/vfx-params.json

@@ -0,0 +1,25 @@
+{
+  "__generation.offsetX": 0,
+  "__generation.offsetY": 0,
+  "__generation.offsetZ": 0,
+  "emitMode": "timed",
+  "lifetime": 0.1,
+  "scale": 3,
+  "initialHeight": 0.035,
+  "color": {
+    "r": 0.984313725490196,
+    "g": 1,
+    "b": 0
+  },
+  "opacity": 1,
+  "particleCount": 10,
+  "particleLife": 0.3,
+  "minSize": 0.045,
+  "maxSize": 0.06,
+  "directionX": 0,
+  "directionY": 1,
+  "directionZ": 0,
+  "riseSpeed": 2,
+  "drift": 1,
+  "glowStrength": 6
+}