@fps-games/vfx 0.1.1

package/packages/effects/energy-shield/index.ts

@@ -0,0 +1,431 @@
+import { Constants } from '@babylonjs/core/Engines/constants';
+import { GlowLayer } from '@babylonjs/core/Layers/glowLayer';
+import { Effect } from '@babylonjs/core/Materials/effect';
+import { ShaderMaterial } from '@babylonjs/core/Materials/shaderMaterial';
+import { Color3 } from '@babylonjs/core/Maths/math.color';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import type { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import type { Scene } from '@babylonjs/core/scene';
+import { VFX_RENDERING_GROUP_ID } from '../../rendering';
+import type { VfxColorValue, VfxEffectHandle, VfxEffectPackage, VfxParamValues } from '../../types';
+
+export interface EnergyShieldParams extends VfxParamValues {
+  radius: number;
+  verticalScale: number;
+  color: VfxColorValue;
+  opacity: number;
+  fresnelPower: number;
+  fresnelStrength: number;
+  rimIntensity: number;
+  surfaceIntensity: number;
+  noiseScale: number;
+  noiseEdgeWidth: number;
+  noiseEdgeIntensity: number;
+  noiseEdgeSmoothness: number;
+  flowScale: number;
+  flowSpeed: number;
+  flowIntensity: number;
+  marbleContrast: number;
+  bloomIntensity: number;
+  bloomKernelSize: number;
+  segments: number;
+}
+
+export interface CreateEnergyShieldOptions {
+  root?: TransformNode;
+  target?: TransformNode | AbstractMesh;
+  position?: Vector3;
+  params?: Partial<EnergyShieldParams>;
+  renderingGroupId?: number;
+  disposeRoot?: boolean;
+}
+
+export interface EnergyShieldHandle extends VfxEffectHandle {
+  shield: Mesh;
+  material: ShaderMaterial;
+  glowLayer: GlowLayer | null;
+  update(params: Partial<EnergyShieldParams>): void;
+}
+
+const SHADER_NAME = 'vfxEnergyShield';
+
+const DEFAULT_PARAMS: EnergyShieldParams = {
+  radius: 3.18,
+  verticalScale: 1.02,
+  color: { r: 0.34902, g: 0.568627, b: 0.968627 },
+  opacity: 0.2,
+  fresnelPower: 1.8,
+  fresnelStrength: 0.66,
+  rimIntensity: 0.4,
+  surfaceIntensity: 0.3,
+  noiseScale: 1,
+  noiseEdgeWidth: 0.1,
+  noiseEdgeIntensity: 0.42,
+  noiseEdgeSmoothness: 0.5,
+  flowScale: 0.36,
+  flowSpeed: 0.25,
+  flowIntensity: 1.15,
+  marbleContrast: 0.67,
+  bloomIntensity: 0.45,
+  bloomKernelSize: 36,
+  segments: 64,
+};
+
+const VERTEX_SHADER = `
+precision highp float;
+
+attribute vec3 position;
+attribute vec3 normal;
+
+uniform mat4 world;
+uniform mat4 worldViewProjection;
+
+varying vec3 vObjPos;
+varying vec3 vWorldPos;
+varying vec3 vNormalW;
+
+void main(void) {
+  vObjPos = position;
+  vec4 worldPos = world * vec4(position, 1.0);
+  vWorldPos = worldPos.xyz;
+  vNormalW = normalize(mat3(world) * normal);
+  gl_Position = worldViewProjection * vec4(position, 1.0);
+}
+`;
+
+const FRAGMENT_SHADER = `
+precision highp float;
+
+uniform float uTime;
+uniform vec3 cameraPosition;
+uniform vec3 uColor;
+uniform float uOpacity;
+uniform float uFresnelPower;
+uniform float uFresnelStrength;
+uniform float uRimIntensity;
+uniform float uSurfaceIntensity;
+uniform float uNoiseScale;
+uniform float uNoiseEdgeWidth;
+uniform float uNoiseEdgeIntensity;
+uniform float uNoiseEdgeSmoothness;
+uniform float uFlowScale;
+uniform float uFlowSpeed;
+uniform float uFlowIntensity;
+uniform float uMarbleContrast;
+
+varying vec3 vObjPos;
+varying vec3 vWorldPos;
+varying vec3 vNormalW;
+
+vec3 mod289v3(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec4 mod289v4(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec4 permute(vec4 x) { return mod289v4(((x * 34.0) + 1.0) * x); }
+vec4 taylorInvSqrt(vec4 r) { return 1.79284291400159 - 0.85373472095314 * r; }
+
+float saturate(float v) { return clamp(v, 0.0, 1.0); }
+
+float snoise(vec3 v) {
+  const vec2 C = vec2(1.0 / 6.0, 1.0 / 3.0);
+  const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
+  vec3 i = floor(v + dot(v, C.yyy));
+  vec3 x0 = v - i + dot(i, C.xxx);
+  vec3 g = step(x0.yzx, x0.xyz);
+  vec3 l = 1.0 - g;
+  vec3 i1 = min(g.xyz, l.zxy);
+  vec3 i2 = max(g.xyz, l.zxy);
+  vec3 x1 = x0 - i1 + C.xxx;
+  vec3 x2 = x0 - i2 + C.yyy;
+  vec3 x3 = x0 - D.yyy;
+  i = mod289v3(i);
+  vec4 p = permute(permute(permute(
+    i.z + vec4(0.0, i1.z, i2.z, 1.0))
+    + i.y + vec4(0.0, i1.y, i2.y, 1.0))
+    + i.x + vec4(0.0, i1.x, i2.x, 1.0));
+  float n_ = 0.142857142857;
+  vec3 ns = n_ * D.wyz - D.xzx;
+  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);
+  vec4 x_ = floor(j * ns.z);
+  vec4 y_ = floor(j - 7.0 * x_);
+  vec4 x = x_ * ns.x + ns.yyyy;
+  vec4 y = y_ * ns.x + ns.yyyy;
+  vec4 h = 1.0 - abs(x) - abs(y);
+  vec4 b0 = vec4(x.xy, y.xy);
+  vec4 b1 = vec4(x.zw, y.zw);
+  vec4 s0 = floor(b0) * 2.0 + 1.0;
+  vec4 s1 = floor(b1) * 2.0 + 1.0;
+  vec4 sh = -step(h, vec4(0.0));
+  vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
+  vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
+  vec3 p0 = vec3(a0.xy, h.x);
+  vec3 p1 = vec3(a0.zw, h.y);
+  vec3 p2 = vec3(a1.xy, h.z);
+  vec3 p3 = vec3(a1.zw, h.w);
+  vec4 norm = taylorInvSqrt(vec4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+  p0 *= norm.x;
+  p1 *= norm.y;
+  p2 *= norm.z;
+  p3 *= norm.w;
+  vec4 m = max(0.6 - vec4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0);
+  m = m * m;
+  return 42.0 * dot(m * m, vec4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
+}
+
+float fbm(vec3 p) {
+  float total = 0.0;
+  float amp = 0.55;
+  total += snoise(p) * amp;
+  p = p * 2.03 + vec3(17.1, 3.7, 9.2);
+  amp *= 0.52;
+  total += snoise(p) * amp;
+  p = p * 2.11 + vec3(4.3, 13.9, 6.4);
+  amp *= 0.5;
+  total += snoise(p) * amp;
+  return total;
+}
+
+void main(void) {
+  vec3 normalW = normalize(vNormalW);
+  vec3 viewDir = normalize(cameraPosition - vWorldPos);
+  float ndv = saturate(dot(normalW, viewDir));
+  float fresnel = pow(1.0 - ndv, max(0.05, uFresnelPower)) * uFresnelStrength;
+
+  float t = uTime * uFlowSpeed;
+  vec3 spherePos = normalize(vObjPos + vec3(0.0001)) * max(0.05, uNoiseScale);
+  vec3 flowA = spherePos * uFlowScale + vec3(t, t * 0.62, t * 0.38);
+  vec3 flowB = spherePos * (uFlowScale * 1.91) + vec3(-t * 0.46, t * 0.82, -t * 0.27);
+  float n1 = fbm(flowA);
+  float n2 = fbm(flowB);
+  float cloud = saturate((n1 * 0.58 + n2 * 0.42) * 0.5 + 0.5);
+
+  float veinInput = spherePos.y * 0.92 + n1 * 1.65 + n2 * 0.74 + t * 0.13;
+  float ribbon = abs(sin(veinInput * 3.14159265));
+  float marble = pow(1.0 - ribbon, max(0.25, uMarbleContrast));
+  float nebula = saturate(mix(cloud, marble, 0.58) * uFlowIntensity * 0.34);
+
+  float edgeWidth = max(0.01, uNoiseEdgeWidth);
+  float edgeSoft = max(0.01, uNoiseEdgeSmoothness) * 0.22;
+  float noiseEdge = smoothstep(1.0 - edgeWidth - edgeSoft, 1.0 - edgeWidth * 0.22, nebula);
+
+  vec3 deepBlue = uColor * (0.12 + 0.42 * cloud);
+  vec3 marbleBlue = uColor * (0.34 + 0.9 * marble) * uSurfaceIntensity;
+  vec3 rimBlue = uColor * fresnel * uRimIntensity;
+  vec3 edgeBlue = uColor * noiseEdge * uNoiseEdgeIntensity;
+  vec3 color = min((deepBlue + marbleBlue + rimBlue + edgeBlue) * 0.72, vec3(1.12));
+
+  float alpha = uOpacity * (0.16 + 0.34 * cloud + 0.24 * marble);
+  alpha += fresnel * uOpacity * 0.58;
+  alpha += noiseEdge * uNoiseEdgeIntensity * 0.05;
+
+  gl_FragColor = vec4(color, saturate(alpha));
+}
+`;
+
+export const energyShieldEffectPackage: VfxEffectPackage<EnergyShieldParams> = {
+  id: 'energy-shield',
+  nameZh: '半球玻璃罩',
+  defaultParams: DEFAULT_PARAMS,
+  debugAnchor: 'player',
+  manifest: {
+    id: 'energy-shield',
+    nameZh: '半球玻璃罩',
+    source: 'https://github.com/cortiz2894/flow-shield-effect',
+  },
+  debugParams: [
+    { key: 'radius', label: '玻璃罩半径', kind: 'scale', min: 0.4, max: 10, step: 0.01 },
+    { key: 'verticalScale', label: '纵向缩放', kind: 'scale', min: 0.5, max: 1.8, step: 0.01 },
+    { key: 'color', label: '主体颜色', kind: 'color' },
+    { key: 'opacity', label: '透明度', kind: 'opacity', min: 0.02, max: 1, step: 0.01 },
+    { key: 'fresnelPower', label: '边缘曲线', kind: 'number', min: 0.2, max: 6, step: 0.01 },
+    { key: 'fresnelStrength', label: '边缘强度', kind: 'number', min: 0, max: 6, step: 0.01 },
+    { key: 'rimIntensity', label: '轮廓亮度', kind: 'number', min: 0, max: 4, step: 0.01 },
+    { key: 'surfaceIntensity', label: '表面亮度', kind: 'number', min: 0, max: 3, step: 0.01 },
+    { key: 'noiseScale', label: '噪声缩放', kind: 'number', min: 0.2, max: 5, step: 0.01 },
+    { key: 'noiseEdgeWidth', label: '噪声亮边宽度', kind: 'number', min: 0.01, max: 0.5, step: 0.01 },
+    { key: 'noiseEdgeIntensity', label: '噪声亮边强度', kind: 'number', min: 0, max: 4, step: 0.01 },
+    { key: 'noiseEdgeSmoothness', label: '噪声亮边柔和度', kind: 'number', min: 0.02, max: 1, step: 0.01 },
+    { key: 'flowScale', label: '纹路密度', kind: 'number', min: 0, max: 3, step: 0.01 },
+    { key: 'flowSpeed', label: '流动速度', kind: 'number', min: 0, max: 5, step: 0.01 },
+    { key: 'flowIntensity', label: '流动强度', kind: 'number', min: 0, max: 8, step: 0.01 },
+    { key: 'marbleContrast', label: '纹路锐度', kind: 'number', min: 0.25, max: 4, step: 0.01 },
+    { key: 'bloomIntensity', label: 'Bloom 强度', kind: 'number', min: 0, max: 4, step: 0.01 },
+    { key: 'bloomKernelSize', label: 'Bloom 半径', kind: 'number', min: 8, max: 128, step: 1 },
+  ],
+  create({ scene, root, position, renderingGroupId, params }) {
+    return createEnergyShield(scene, { root, position, renderingGroupId, params });
+  },
+};
+
+export default energyShieldEffectPackage;
+
+export function createEnergyShield(scene: Scene, options: CreateEnergyShieldOptions = {}): EnergyShieldHandle {
+  registerShaders();
+
+  let params = mergeParams(options.params);
+  const root = options.root ?? new TransformNode('vfx_energyShield_root', scene);
+  const disposeRoot = options.disposeRoot ?? true;
+  if (options.target) {
+    root.parent = options.target;
+    root.position.set(0, 0, 0);
+  } else {
+    root.position.copyFrom(options.position ?? Vector3.ZeroReadOnly);
+  }
+
+  const shield = MeshBuilder.CreateSphere(
+    'vfx_energyShield_hemisphere',
+    {
+      diameter: 2,
+      segments: Math.max(16, Math.round(params.segments)),
+      slice: 0.5,
+      updatable: false,
+    },
+    scene,
+  );
+  shield.parent = root;
+  shield.isPickable = false;
+  shield.alwaysSelectAsActiveMesh = true;
+  shield.renderingGroupId = options.renderingGroupId ?? VFX_RENDERING_GROUP_ID;
+  shield.alphaIndex = 20;
+
+  const material = createShieldMaterial(scene);
+  shield.material = material;
+
+  let glowLayer: GlowLayer | null = null;
+  if (params.bloomIntensity > 0) {
+    glowLayer = new GlowLayer(`vfx_energyShield_glow_${shield.uniqueId}`, scene, {
+      blurKernelSize: params.bloomKernelSize,
+      mainTextureRatio: 0.35,
+    });
+    glowLayer.intensity = params.bloomIntensity;
+    glowLayer.addIncludedOnlyMesh(shield);
+    glowLayer.referenceMeshToUseItsOwnMaterial(shield);
+  }
+
+  applyParams(material, shield, glowLayer, params);
+
+  let elapsed = 0;
+  const observer = scene.onBeforeRenderObservable.add(() => {
+    elapsed += Math.min(scene.getEngine().getDeltaTime() / 1000, 0.05);
+    material.setFloat('uTime', elapsed);
+  });
+
+  let disposed = false;
+  const dispose = (): void => {
+    if (disposed) return;
+    disposed = true;
+    scene.onBeforeRenderObservable.remove(observer);
+    glowLayer?.dispose();
+    shield.dispose(false, false);
+    material.dispose();
+    if (disposeRoot) root.dispose();
+  };
+
+  return {
+    root,
+    shield,
+    material,
+    glowLayer,
+    update(partial: Partial<EnergyShieldParams>) {
+      params = mergeParams(partial, params);
+      applyParams(material, shield, glowLayer, params);
+      if (!glowLayer && params.bloomIntensity > 0) {
+        glowLayer = new GlowLayer(`vfx_energyShield_glow_${shield.uniqueId}`, scene, {
+          blurKernelSize: params.bloomKernelSize,
+          mainTextureRatio: 0.35,
+        });
+        glowLayer.addIncludedOnlyMesh(shield);
+        glowLayer.referenceMeshToUseItsOwnMaterial(shield);
+        glowLayer.intensity = params.bloomIntensity;
+        applyParams(material, shield, glowLayer, params);
+        this.glowLayer = glowLayer;
+      }
+    },
+    dispose,
+  };
+}
+
+function createShieldMaterial(scene: Scene): ShaderMaterial {
+  const material = new ShaderMaterial(
+    'vfx_energyShield_material',
+    scene,
+    { vertex: SHADER_NAME, fragment: SHADER_NAME },
+    {
+      attributes: ['position', 'normal'],
+      uniforms: [
+        'world',
+        'worldViewProjection',
+        'cameraPosition',
+        'uTime',
+        'uColor',
+        'uOpacity',
+        'uFresnelPower',
+        'uFresnelStrength',
+        'uRimIntensity',
+        'uSurfaceIntensity',
+        'uNoiseScale',
+        'uNoiseEdgeWidth',
+        'uNoiseEdgeIntensity',
+        'uNoiseEdgeSmoothness',
+        'uFlowScale',
+        'uFlowSpeed',
+        'uFlowIntensity',
+        'uMarbleContrast',
+      ],
+      needAlphaBlending: true,
+    },
+  );
+  material.alphaMode = Constants.ALPHA_COMBINE;
+  material.backFaceCulling = false;
+  material.disableDepthWrite = true;
+  material.fogEnabled = false;
+  return material;
+}
+
+function applyParams(
+  material: ShaderMaterial,
+  shield: Mesh,
+  glowLayer: GlowLayer | null,
+  params: EnergyShieldParams,
+): void {
+  shield.scaling.set(params.radius, params.radius * params.verticalScale, params.radius);
+  material.setColor3('uColor', toColor3(params.color));
+  material.setFloat('uOpacity', params.opacity);
+  material.setFloat('uFresnelPower', params.fresnelPower);
+  material.setFloat('uFresnelStrength', params.fresnelStrength);
+  material.setFloat('uRimIntensity', params.rimIntensity);
+  material.setFloat('uSurfaceIntensity', params.surfaceIntensity);
+  material.setFloat('uNoiseScale', params.noiseScale);
+  material.setFloat('uNoiseEdgeWidth', params.noiseEdgeWidth);
+  material.setFloat('uNoiseEdgeIntensity', params.noiseEdgeIntensity);
+  material.setFloat('uNoiseEdgeSmoothness', params.noiseEdgeSmoothness);
+  material.setFloat('uFlowScale', params.flowScale);
+  material.setFloat('uFlowSpeed', params.flowSpeed);
+  material.setFloat('uFlowIntensity', params.flowIntensity);
+  material.setFloat('uMarbleContrast', params.marbleContrast);
+  if (glowLayer) {
+    glowLayer.intensity = params.bloomIntensity;
+    glowLayer.blurKernelSize = params.bloomKernelSize;
+  }
+}
+
+function mergeParams(
+  patch: Partial<EnergyShieldParams> | undefined,
+  base: EnergyShieldParams = DEFAULT_PARAMS,
+): EnergyShieldParams {
+  return {
+    ...base,
+    ...patch,
+    color: patch?.color ? { ...patch.color } : { ...base.color },
+  };
+}
+
+function toColor3(color: VfxColorValue): Color3 {
+  return new Color3(color.r, color.g, color.b);
+}
+
+function registerShaders(): void {
+  Effect.ShadersStore[`${SHADER_NAME}VertexShader`] = VERTEX_SHADER;
+  Effect.ShadersStore[`${SHADER_NAME}FragmentShader`] = FRAGMENT_SHADER;
+}

package/packages/effects/energy-shield/vfx-params.json

@@ -0,0 +1,29 @@
+{
+  "schemaVersion": "vfx-params/1.0",
+  "effectId": "energy-shield",
+  "params": {
+    "radius": 3.18,
+    "verticalScale": 1.02,
+    "color": {
+      "r": 0.34902,
+      "g": 0.568627,
+      "b": 0.968627
+    },
+    "opacity": 0.2,
+    "fresnelPower": 1.8,
+    "fresnelStrength": 0.66,
+    "rimIntensity": 0.4,
+    "surfaceIntensity": 0.3,
+    "noiseScale": 1,
+    "noiseEdgeWidth": 0.1,
+    "noiseEdgeIntensity": 0.42,
+    "noiseEdgeSmoothness": 0.5,
+    "flowScale": 0.36,
+    "flowSpeed": 0.25,
+    "flowIntensity": 1.15,
+    "marbleContrast": 0.67,
+    "bloomIntensity": 0.45,
+    "bloomKernelSize": 36,
+    "segments": 64
+  }
+}

package/packages/effects/explosion/index.ts

@@ -0,0 +1,114 @@
+// 爆炸(组合:闪光/光晕 #6 + 序列帧火花 #7 + 火花点 #9)。一次性爆点,参数分三段独立调。
+// 闪光段:2 billboard 面片 sqrt 缩放+淡出;序列帧段:5x5 火花 ADD;火花点段:lizi ADD 下落火星。
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { CreatePlane } from '@babylonjs/core/Meshes/Builders/planeBuilder';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+import { Texture } from '@babylonjs/core/Materials/Textures/texture';
+import { ParticleSystem } from '@babylonjs/core/Particles/particleSystem';
+import { Color3, Color4 } from '@babylonjs/core/Maths/math.color';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { Constants } from '@babylonjs/core/Engines/constants';
+import type { Scene } from '@babylonjs/core/scene';
+import type { Observer } from '@babylonjs/core/Misc/observable';
+import type { VfxEffectPackage, VfxParamValues } from '../../types';
+import { makeBurstPS } from '../space-shared';
+import baozhaUrl from './assets/textures/baozha29.webp?url';
+import glowUrl from './assets/textures/glow01.webp?url';
+import bombUrl from './assets/textures/xulie_lizibaozha02_5x5.webp?url';
+import liziUrl from './assets/textures/lizi01.webp?url';
+
+interface ExplosionParams extends VfxParamValues {
+  // 段1 闪光/光晕
+  flashRadius: number; flashBrightness: number;
+  // 段2 序列帧火花
+  sparksCount: number; sparksSize: number;
+  // 段3 火花点
+  embersCount: number; embersPower: number;
+}
+
+const DEFAULT_PARAMS: ExplosionParams = {
+  flashRadius: 1.8, flashBrightness: 1.0,
+  sparksCount: 4, sparksSize: 1,
+  embersCount: 24, embersPower: 14,
+};
+
+interface Flash { mesh: Mesh; mat: StandardMaterial; from: number; to: number; life: number; maxLife: number; }
+
+export const explosionEffectPackage: VfxEffectPackage<ExplosionParams> = {
+  id: 'explosion',
+  nameZh: '爆炸',
+  debugAnchor: 'playerRight',
+  defaultParams: DEFAULT_PARAMS,
+  debugParams: [
+    // 段1 · 闪光/光晕
+    { key: 'flashRadius', label: '闪光·半径', kind: 'scale', min: 0.5, max: 5, step: 0.1 },
+    { key: 'flashBrightness', label: '闪光·亮度', kind: 'number', min: 0.2, max: 3, step: 0.05 },
+    // 段2 · 序列帧火花
+    { key: 'sparksCount', label: '序列帧·数量', kind: 'number', min: 0, max: 30, step: 1 },
+    { key: 'sparksSize', label: '序列帧·尺寸', kind: 'scale', min: 0.2, max: 3, step: 0.05 },
+    // 段3 · 火花点
+    { key: 'embersCount', label: '火花点·数量', kind: 'number', min: 0, max: 80, step: 1 },
+    { key: 'embersPower', label: '火花点·速度', kind: 'number', min: 2, max: 30, step: 0.5 },
+  ],
+
+  create({ scene, root, position, params }) {
+    root.position.copyFrom(position);
+
+    // ── 段1 闪光/光晕 ──────────────────────────────────────────────────────────
+    const r = params.flashRadius, b = params.flashBrightness;
+    const flashes: Flash[] = [];
+    function flashPlane(url: string, from: number, to: number, maxLife: number, color: Color3, alphaFromRGB: boolean): void {
+      const m = CreatePlane('vfx_exp_flash', { size: 1 }, scene);
+      m.billboardMode = Mesh.BILLBOARDMODE_ALL; m.position.copyFrom(position); m.isPickable = false;
+      const tex = new Texture(url, scene); tex.hasAlpha = true; if (alphaFromRGB) tex.getAlphaFromRGB = true;
+      const mat = new StandardMaterial('vfx_exp_flashMat', scene);
+      mat.emissiveTexture = tex; mat.opacityTexture = tex; mat.emissiveColor = color.scale(b);
+      mat.disableLighting = true; mat.alphaMode = Constants.ALPHA_ADD;
+      m.material = mat; m.scaling.setAll(from);
+      flashes.push({ mesh: m, mat, from, to, life: 0, maxLife });
+    }
+    flashPlane(baozhaUrl, r * 1.5, r * 5.2, 0.4, new Color3(1.6, 1.2, 0.8), true);
+    flashPlane(glowUrl, r * 2, r * 7, 0.3, new Color3(1.2, 0.75, 0.35), false);
+
+    // ── 段2 序列帧火花 ─────────────────────────────────────────────────────────
+    const sparksPs = makeBurstPS('vfx_exp_sparks', scene, bombUrl, {
+      cap: 120, sheet: [75, 75, 25], size: [4.5, 7], life: [0.55, 0.7], power: [0, 0.6], gravity: new Vector3(0, 0, 0),
+      blend: ParticleSystem.BLENDMODE_ADD, c1: new Color4(1, 0.95, 0.85, 1), c2: new Color4(1, 0.8, 0.55, 1), cd: new Color4(1, 0.5, 0.2, 0),
+    });
+    sparksPs.minSize *= params.sparksSize; sparksPs.maxSize *= params.sparksSize;
+    (sparksPs.emitter as Vector3).copyFrom(position);
+    sparksPs.manualEmitCount += Math.round(params.sparksCount);
+
+    // ── 段3 火花点 ─────────────────────────────────────────────────────────────
+    const embersPs = makeBurstPS('vfx_exp_embers', scene, liziUrl, {
+      cap: 120, size: [0.25, 0.7], life: [0.3, 0.8], power: [params.embersPower * 0.43, params.embersPower], gravity: new Vector3(0, -9, 0),
+      blend: ParticleSystem.BLENDMODE_ADD, c1: new Color4(1, 0.85, 0.5, 1), c2: new Color4(1, 0.6, 0.25, 1), cd: new Color4(0.8, 0.3, 0.1, 0),
+    });
+    (embersPs.emitter as Vector3).copyFrom(position);
+    embersPs.manualEmitCount += Math.round(params.embersCount);
+
+    // 闪光 tween 每帧
+    const observer = scene.onBeforeRenderObservable.add(() => {
+      const dt = Math.min(scene.getEngine().getDeltaTime() / 1000, 0.05);
+      for (let i = flashes.length - 1; i >= 0; i--) {
+        const f = flashes[i]; f.life += dt; const k = Math.min(1, f.life / f.maxLife);
+        f.mesh.scaling.setAll(f.from + (f.to - f.from) * Math.sqrt(k));
+        f.mat.alpha = 1 - k;
+        if (k >= 1) { f.mesh.dispose(); f.mat.dispose(); flashes.splice(i, 1); }
+      }
+    });
+
+    let disposed = false;
+    const disposeTimer = window.setTimeout(() => disposeAll(), 1400);
+    function disposeAll(): void {
+      if (disposed) return; disposed = true;
+      window.clearTimeout(disposeTimer);
+      scene.onBeforeRenderObservable.remove(observer as Observer<Scene>);
+      for (const f of flashes) { f.mesh.dispose(); f.mat.dispose(); }
+      flashes.length = 0;
+      sparksPs.dispose(); embersPs.dispose();
+      root.dispose();
+    }
+    return { root, dispose() { disposeAll(); } };
+  },
+};

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

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

package/packages/effects/ground-tile-upgrade/effect.json

@@ -0,0 +1,6 @@
+{
+  "id": "ground-tile-upgrade",
+  "nameZh": "地块升级光效",
+  "source": "runtime-generated",
+  "assets": []
+}