@fps-games/vfx 0.3.11 → 0.3.14

package/dist/effects/golden-bubble-pop/effect.json.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+  "id": "golden-bubble-pop",
+  "nameZh": "金色泡泡炸开"
+}
+;
+
+export default _default;

package/dist/effects/golden-bubble-pop/index.d.ts

@@ -0,0 +1,25 @@
+import { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+interface GoldenBubblePopParams extends VfxParamValues {
+    lifetime: number;
+    emitRate: number;
+    spawnRadius: number;
+    spawnHeight: number;
+    spawnHeightRandom: number;
+    bubbleMinSize: number;
+    bubbleMaxSize: number;
+    growTime: number;
+    growCurve: number;
+    wobbleAmount: number;
+    wobbleSpeed: number;
+    popSparkCount: number;
+    popRadius: number;
+    popDuration: number;
+    popDropletSize: number;
+    popGravity: number;
+    popFlashStrength: number;
+    color: VfxColorValue;
+    opacity: number;
+    glowStrength: number;
+}
+export declare const goldenBubblePopEffectPackage: VfxEffectPackage<GoldenBubblePopParams>;
+export default goldenBubblePopEffectPackage;

package/dist/effects/golden-bubble-pop/index.js

@@ -0,0 +1,323 @@
+import { Constants } from "@babylonjs/core/Engines/constants";
+import { Material } from "@babylonjs/core/Materials/material";
+import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial";
+import { DynamicTexture } from "@babylonjs/core/Materials/Textures/dynamicTexture";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture";
+import { Color3 } from "@babylonjs/core/Maths/math.color";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { Mesh } from "@babylonjs/core/Meshes/mesh";
+import { MeshBuilder } from "@babylonjs/core/Meshes/meshBuilder";
+import { V as VFX_RENDERING_GROUP_ID } from "../../chunks/rendering-CV3nhygX.js";
+const id = "golden-bubble-pop";
+const nameZh = "金色泡泡炸开";
+const manifest = {
+  id,
+  nameZh
+};
+const DEFAULT_PARAMS = {
+  lifetime: 2.5,
+  emitRate: 8,
+  spawnRadius: 0.6,
+  spawnHeight: 0,
+  spawnHeightRandom: 0,
+  bubbleMinSize: 0.05,
+  bubbleMaxSize: 0.42,
+  growTime: 0.75,
+  growCurve: 1.35,
+  wobbleAmount: 0.025,
+  wobbleSpeed: 3.2,
+  popSparkCount: 5,
+  popRadius: 0.38,
+  popDuration: 0.42,
+  popDropletSize: 0.12,
+  popGravity: 3.2,
+  popFlashStrength: 0.75,
+  color: { r: 1, g: 0.78, b: 0.18 },
+  opacity: 0.72,
+  glowStrength: 0.9
+};
+const goldenBubblePopEffectPackage = {
+  id: "golden-bubble-pop",
+  nameZh: "金色泡泡炸开",
+  placement: "socket",
+  geometrySpace: "local",
+  debugAnchor: "playerRight",
+  manifest,
+  defaultParams: DEFAULT_PARAMS,
+  debugParams: [
+    { key: "lifetime", label: "生成时长", kind: "lifetime", min: 0.1, max: 8, step: 0.01 },
+    { key: "emitRate", label: "生成速度", kind: "number", min: 0, max: 40, step: 0.1 },
+    { key: "spawnRadius", label: "生成半径", kind: "scale", min: 0, max: 4, step: 0.01 },
+    { key: "spawnHeight", label: "生成平面高度", kind: "scale", min: -2, max: 2, step: 0.01 },
+    { key: "spawnHeightRandom", label: "生成高度随机", kind: "scale", min: 0, max: 2, step: 0.01 },
+    { key: "bubbleMinSize", label: "泡泡初始大小", kind: "scale", min: 5e-3, max: 1.5, step: 5e-3 },
+    { key: "bubbleMaxSize", label: "泡泡最大大小", kind: "scale", min: 0.02, max: 2.5, step: 0.01 },
+    { key: "growTime", label: "泡泡生长时间", kind: "lifetime", min: 0.05, max: 3, step: 0.01 },
+    { key: "growCurve", label: "生长曲线", kind: "number", min: 0.3, max: 3, step: 0.01 },
+    { key: "wobbleAmount", label: "原地微抖", kind: "scale", min: 0, max: 0.3, step: 1e-3 },
+    { key: "wobbleSpeed", label: "微抖速度", kind: "number", min: 0, max: 12, step: 0.05 },
+    { key: "popSparkCount", label: "炸开碎光数量", kind: "number", min: 0, max: 20, step: 1 },
+    { key: "popRadius", label: "碎光飞散范围", kind: "scale", min: 0, max: 2.5, step: 0.01 },
+    { key: "popDuration", label: "碎光淡出时长", kind: "lifetime", min: 0.05, max: 1.5, step: 0.01 },
+    { key: "popDropletSize", label: "碎光大小", kind: "scale", min: 0.01, max: 1, step: 5e-3 },
+    { key: "popGravity", label: "碎光重力", kind: "number", min: 0, max: 12, step: 0.05 },
+    { key: "popFlashStrength", label: "破裂亮度", kind: "number", min: 0, max: 2, step: 0.01 },
+    { key: "color", label: "泡泡颜色", kind: "color" },
+    { key: "opacity", label: "透明度", kind: "opacity", min: 0, max: 1.5, step: 0.01 },
+    { key: "glowStrength", label: "发光强度", kind: "number", min: 0.1, max: 5, step: 0.05 }
+  ],
+  create({ scene, root, params, renderingGroupId }) {
+    const textures = [
+      makeTexture(scene, "vfx_goldenBubblePop_bubbleTex", 128, (context, size) => drawBubbleTexture(context, size, params.color)),
+      makeTexture(scene, "vfx_goldenBubblePop_sparkTex", 64, (context, size) => drawSparkTexture(context, size, params.color))
+    ];
+    const bubbleMat = makeMaterial(scene, "vfx_goldenBubblePop_bubbleMat", textures[0], params.opacity, params.glowStrength);
+    const dropletMat = makeMaterial(scene, "vfx_goldenBubblePop_dropletMat", textures[1], params.opacity, params.glowStrength * params.popFlashStrength);
+    const materials = [bubbleMat, dropletMat];
+    const bubbles = [];
+    const pops = [];
+    const groupId = renderingGroupId ?? VFX_RENDERING_GROUP_ID;
+    const growTime = Math.max(0.03, params.growTime);
+    const emitDuration = Math.max(0, params.lifetime);
+    const disposeAfter = emitDuration + growTime + Math.max(0.05, params.popDuration) + 0.2;
+    let elapsed = 0;
+    let emitCarry = 0;
+    let disposed = false;
+    const observer = scene.onBeforeRenderObservable.add(() => {
+      const dt = Math.min(0.05, scene.getEngine().getDeltaTime() / 1e3);
+      elapsed += dt;
+      if (elapsed <= emitDuration) {
+        emitCarry += Math.max(0, params.emitRate) * dt;
+        const emitCount = Math.floor(emitCarry);
+        emitCarry -= emitCount;
+        for (let i = 0; i < emitCount; i += 1) spawnBubble();
+      }
+      updateBubbles(dt);
+      updatePops(dt);
+      if (elapsed > disposeAfter && bubbles.length === 0 && pops.length === 0) disposeAll();
+    });
+    function spawnBubble() {
+      const maxSize = randomRange(
+        Math.min(params.bubbleMinSize, params.bubbleMaxSize),
+        Math.max(params.bubbleMinSize, params.bubbleMaxSize)
+      );
+      const mesh = MeshBuilder.CreatePlane("vfx_goldenBubblePop_bubble", { size: 1 }, scene);
+      mesh.parent = root;
+      mesh.billboardMode = Mesh.BILLBOARDMODE_ALL;
+      mesh.material = bubbleMat;
+      mesh.renderingGroupId = groupId;
+      mesh.isPickable = false;
+      mesh.alphaIndex = 20;
+      const position = sampleSpawnPosition(params.spawnRadius, params.spawnHeight, params.spawnHeightRandom);
+      mesh.position.copyFrom(position);
+      mesh.scaling.setAll(Math.max(1e-3, params.bubbleMinSize));
+      bubbles.push({
+        mesh,
+        age: 0,
+        lifetime: growTime,
+        seed: Math.random() * Math.PI * 2,
+        basePosition: position,
+        maxSize
+      });
+    }
+    function updateBubbles(dt) {
+      for (let i = bubbles.length - 1; i >= 0; i -= 1) {
+        const bubble = bubbles[i];
+        bubble.age += dt;
+        const t = clamp01(bubble.age / bubble.lifetime);
+        const eased = Math.pow(t, Math.max(0.05, params.growCurve));
+        const size = lerp(Math.max(1e-3, params.bubbleMinSize), bubble.maxSize, eased);
+        const pulse = 1 + Math.sin((bubble.age * params.wobbleSpeed + bubble.seed) * 1.7) * 0.035;
+        const wobble = Math.max(0, params.wobbleAmount);
+        bubble.mesh.position.set(
+          bubble.basePosition.x + Math.sin(bubble.age * params.wobbleSpeed + bubble.seed) * wobble,
+          bubble.basePosition.y,
+          bubble.basePosition.z + Math.cos(bubble.age * params.wobbleSpeed + bubble.seed * 1.37) * wobble
+        );
+        bubble.mesh.scaling.setAll(size * pulse);
+        bubbleMat.alpha = params.opacity * (0.34 + 0.66 * (1 - t * 0.24));
+        if (t >= 1) {
+          spawnPop(bubble.mesh.position, bubble.maxSize);
+          bubble.mesh.dispose();
+          bubbles.splice(i, 1);
+        }
+      }
+    }
+    function spawnPop(position, bubbleSize) {
+      const duration = Math.max(0.03, params.popDuration);
+      const dropletCount = Math.max(0, Math.round(params.popSparkCount));
+      const droplets = [];
+      const radius = Math.max(0, params.popRadius);
+      for (let i = 0; i < dropletCount; i += 1) {
+        const droplet = MeshBuilder.CreatePlane("vfx_goldenBubblePop_droplet", { size: 1 }, scene);
+        droplet.parent = root;
+        droplet.billboardMode = Mesh.BILLBOARDMODE_ALL;
+        droplet.material = dropletMat;
+        droplet.renderingGroupId = groupId;
+        droplet.isPickable = false;
+        droplet.position.copyFrom(position);
+        droplet.alphaIndex = 31;
+        const direction = sampleBurstDirection(i, dropletCount);
+        const travel = radius * randomRange(0.62, 1.1);
+        droplets.push({
+          mesh: droplet,
+          velocity: new Vector3(
+            direction.x * travel / duration,
+            randomRange(0.06, 0.18) + Math.max(0, direction.y) * travel / duration,
+            direction.z * travel / duration
+          ),
+          size: Math.max(1e-3, params.popDropletSize) * randomRange(0.72, 1.32) + bubbleSize * 0.05,
+          seed: Math.random() * Math.PI * 2
+        });
+      }
+      pops.push({
+        origin: position.clone(),
+        droplets,
+        age: 0,
+        duration
+      });
+    }
+    function updatePops(dt) {
+      for (let i = pops.length - 1; i >= 0; i -= 1) {
+        const pop = pops[i];
+        pop.age += dt;
+        const t = clamp01(pop.age / pop.duration);
+        const fade = 1 - smoothstep(0.48, 1, t);
+        const appear = smoothstep(0, 0.18, t);
+        dropletMat.alpha = params.opacity * params.popFlashStrength * fade;
+        for (const droplet of pop.droplets) {
+          const gravity = Math.max(0, params.popGravity);
+          droplet.mesh.position.set(
+            pop.origin.x + droplet.velocity.x * pop.age,
+            pop.origin.y + droplet.velocity.y * pop.age - 0.5 * gravity * pop.age * pop.age,
+            pop.origin.z + droplet.velocity.z * pop.age
+          );
+          droplet.mesh.scaling.setAll(droplet.size * appear * (1 - t * 0.35));
+          droplet.mesh.rotation.z = droplet.seed + pop.age * 6;
+        }
+        if (t >= 1) {
+          for (const droplet of pop.droplets) droplet.mesh.dispose();
+          pops.splice(i, 1);
+        }
+      }
+    }
+    function disposeAll() {
+      if (disposed) return;
+      disposed = true;
+      if (observer) scene.onBeforeRenderObservable.remove(observer);
+      for (const bubble of bubbles) bubble.mesh.dispose();
+      for (const pop of pops) {
+        for (const droplet of pop.droplets) droplet.mesh.dispose();
+      }
+      for (const material of materials) material.dispose();
+      for (const texture of textures) texture.dispose();
+      root.dispose();
+    }
+    return {
+      root,
+      dispose() {
+        disposeAll();
+      }
+    };
+  }
+};
+function makeMaterial(scene, name, texture, opacity, glowStrength) {
+  const material = new StandardMaterial(name, scene);
+  const brightness = Math.max(0.1, glowStrength);
+  material.diffuseTexture = texture;
+  material.emissiveTexture = texture;
+  material.diffuseColor = Color3.White();
+  material.emissiveColor = Color3.White().scale(brightness);
+  material.specularColor = Color3.Black();
+  material.alpha = opacity;
+  material.disableLighting = true;
+  material.backFaceCulling = false;
+  material.useAlphaFromDiffuseTexture = true;
+  material.transparencyMode = Material.MATERIAL_ALPHABLEND;
+  material.alphaMode = Constants.ALPHA_ADD;
+  material.disableDepthWrite = true;
+  return material;
+}
+function makeTexture(scene, name, size, draw) {
+  const texture = new DynamicTexture(name, { width: size, height: size }, scene, true);
+  texture.wrapU = Texture.CLAMP_ADDRESSMODE;
+  texture.wrapV = Texture.CLAMP_ADDRESSMODE;
+  const context = texture.getContext();
+  context.clearRect(0, 0, size, size);
+  draw(context, size);
+  texture.update(false);
+  return texture;
+}
+function drawBubbleTexture(context, size, color) {
+  const center = size * 0.5;
+  const radius = size * 0.42;
+  const fill = context.createRadialGradient(center, center, radius * 0.08, center, center, radius);
+  fill.addColorStop(0, colorRgba(color, 0.1, 1.18));
+  fill.addColorStop(0.68, colorRgba(color, 0.06, 1.08));
+  fill.addColorStop(0.82, colorRgba(color, 0.68, 1.18));
+  fill.addColorStop(0.95, colorRgba(color, 0.9, 1.28));
+  fill.addColorStop(1, colorRgba(color, 0, 1.28));
+  context.fillStyle = fill;
+  context.beginPath();
+  context.arc(center, center, radius, 0, Math.PI * 2);
+  context.fill();
+  const highlight = context.createRadialGradient(size * 0.34, size * 0.3, 1, size * 0.34, size * 0.3, size * 0.16);
+  highlight.addColorStop(0, colorRgba(color, 0.72, 1.6));
+  highlight.addColorStop(0.55, colorRgba(color, 0.28, 1.4));
+  highlight.addColorStop(1, colorRgba(color, 0, 1.4));
+  context.fillStyle = highlight;
+  context.beginPath();
+  context.arc(size * 0.34, size * 0.3, size * 0.16, 0, Math.PI * 2);
+  context.fill();
+}
+function drawSparkTexture(context, size, color) {
+  const center = size * 0.5;
+  const spark = context.createRadialGradient(center, center, 1, center, center, size * 0.45);
+  spark.addColorStop(0, colorRgba(color, 0.98, 1.5));
+  spark.addColorStop(0.34, colorRgba(color, 0.82, 1.22));
+  spark.addColorStop(0.78, colorRgba(color, 0.32, 1));
+  spark.addColorStop(1, colorRgba(color, 0, 1));
+  context.fillStyle = spark;
+  context.beginPath();
+  context.arc(center, center, size * 0.45, 0, Math.PI * 2);
+  context.fill();
+}
+function sampleSpawnPosition(radius, height, heightRandom) {
+  const r = Math.sqrt(Math.random()) * Math.max(0, radius);
+  const a = Math.random() * Math.PI * 2;
+  return new Vector3(
+    Math.cos(a) * r,
+    height + (Math.random() - 0.5) * Math.max(0, heightRandom),
+    Math.sin(a) * r
+  );
+}
+function sampleBurstDirection(index, count) {
+  const angle = (index + Math.random() * 0.35) / Math.max(1, count) * Math.PI * 2;
+  const y = (Math.random() - 0.5) * 0.36;
+  const direction = new Vector3(Math.cos(angle), y, Math.sin(angle));
+  direction.normalize();
+  return direction;
+}
+function randomRange(min, max) {
+  return min + Math.random() * (max - min);
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function smoothstep(edge0, edge1, value) {
+  const t = clamp01((value - edge0) / (edge1 - edge0));
+  return t * t * (3 - 2 * t);
+}
+function colorRgba(color, alpha, boost) {
+  const r = Math.round(clamp01(color.r * boost) * 255);
+  const g = Math.round(clamp01(color.g * boost) * 255);
+  const b = Math.round(clamp01(color.b * boost) * 255);
+  return `rgba(${r}, ${g}, ${b}, ${clamp01(alpha)})`;
+}
+export {
+  goldenBubblePopEffectPackage as default,
+  goldenBubblePopEffectPackage
+};

package/dist/effects/magnet-suction/index.js

@@ -20,12 +20,13 @@ const manifest = {
   assets,
   source
 };
+const BOLT_SEGMENTS = 6;
 const DEFAULT_PARAMS = {
   lifetimeMode: "infinite",
   lifetime: 2.5,
   scale: 1.15,
   initialHeight: 0,
-  color: { r: 0.82, g: 0.95, b: 1 },
+  color: { r: 0.48, g: 0.9, b: 1 },
   opacity: 1,
   intensity: 1,
   forwardOffset: 0,
@@ -37,18 +38,18 @@ const DEFAULT_PARAMS = {
   fadeDistance: 0.58,
   spawnFade: 0.45,
   suctionSpeed: 1.65,
-  lineCount: 32,
+  lineCount: 0,
   lineLength: 0.46,
-  lineWidth: 0.045,
+  lineWidth: 0.052,
   lineOpacity: 1,
   lineSpread: 1,
   lineTwist: 0,
-  particleCount: 14,
-  particleSize: 0.032,
-  particleSpeed: 2.15,
+  particleCount: 5,
+  particleSize: 0.036,
+  particleSpeed: 1.65,
   particleDrift: 0,
   particleOuterOffset: 0,
-  particleOpacity: 0.55,
+  particleOpacity: 0.68,
   directionX: 0,
   directionZ: -1
 };
@@ -79,16 +80,14 @@ const magnetSuctionEffectPackage = {
     { key: "mouthPadding", label: "入口保护距离", kind: "number", min: 0.01, max: 2, step: 0.01 },
     { key: "fadeDistance", label: "入口淡出距离", kind: "number", min: 0.01, max: 3, step: 0.01 },
     { key: "spawnFade", label: "外侧淡入距离", kind: "number", min: 0.01, max: 3, step: 0.01 },
-    { key: "suctionSpeed", label: "线条速度", kind: "number", min: 0, max: 8, step: 0.01 },
-    { key: "lineCount", label: "白线数量", kind: "number", min: 0, max: 96, step: 1 },
-    { key: "lineLength", label: "白线长度", kind: "number", min: 0.02, max: 2, step: 0.01 },
-    { key: "lineWidth", label: "白线尾宽", kind: "number", min: 2e-3, max: 0.18, step: 1e-3 },
-    { key: "lineOpacity", label: "白线透明度", kind: "opacity", min: 0, max: 1.5, step: 0.01 },
+    { key: "lineLength", label: "电弧长度", kind: "number", min: 0.02, max: 2, step: 0.01 },
+    { key: "lineWidth", label: "电弧宽度", kind: "number", min: 2e-3, max: 0.18, step: 1e-3 },
+    { key: "lineOpacity", label: "电弧透明度", kind: "opacity", min: 0, max: 1.5, step: 0.01 },
     { key: "lineSpread", label: "散布缩放", kind: "number", min: 0.1, max: 2, step: 0.01 },
-    { key: "particleCount", label: "粒子数量", kind: "number", min: 0, max: 80, step: 1 },
-    { key: "particleSize", label: "粒子大小", kind: "number", min: 5e-3, max: 0.3, step: 1e-3 },
-    { key: "particleSpeed", label: "粒子速度", kind: "number", min: 0, max: 10, step: 0.01 },
-    { key: "particleOpacity", label: "粒子透明度", kind: "opacity", min: 0, max: 1, step: 0.01 },
+    { key: "particleCount", label: "电弧数量", kind: "number", min: 0, max: 24, step: 1 },
+    { key: "particleSize", label: "电弧抖动大小", kind: "number", min: 5e-3, max: 0.3, step: 1e-3 },
+    { key: "particleSpeed", label: "电弧吸入速度", kind: "number", min: 0, max: 8, step: 0.01 },
+    { key: "particleOpacity", label: "电弧闪烁强度", kind: "opacity", min: 0, max: 1, 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 }
   ],
@@ -139,26 +138,15 @@ function createMagnetSuctionField(scene, root, params, renderingGroupId) {
   }
 }
 function createSuctionMesh(scene, root, params, material, renderingGroupId) {
-  const lineCount = Math.max(0, Math.round(params.lineCount));
-  const particleCount = Math.max(0, Math.round(params.particleCount));
-  const lineVertexCount = lineCount * 3;
-  const particleVertexCount = particleCount * 4;
-  const totalVertexCount = lineVertexCount + particleVertexCount;
+  const boltCount = Math.max(0, Math.round(params.particleCount));
+  const boltVertexCount = boltCount * BOLT_SEGMENTS * 4;
+  const totalVertexCount = boltVertexCount;
   const positions = new Float32Array(totalVertexCount * 3);
   const colors = new Float32Array(totalVertexCount * 4);
   const indices = [];
-  const lines = [];
-  const particles = [];
-  let resetIndex = 1;
-  for (let index = 0; index < lineCount; index += 1) {
-    const base = index * 3;
-    indices.push(base, base + 1, base + 2);
-    lines.push(resetLine({}, true));
-  }
-  for (let index = 0; index < particleCount; index += 1) {
-    const base = lineVertexCount + index * 4;
-    indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
-    particles.push(resetParticle({}, true));
+  let time = 0;
+  for (let base = 0; base < totalVertexCount; base += 4) {
+    pushQuadIndices(indices, base);
   }
   const mesh = new Mesh("magnet-suction.mesh", scene);
   mesh.parent = root;
@@ -176,15 +164,7 @@ function createSuctionMesh(scene, root, params, material, renderingGroupId) {
   writeGeometry();
   return { update, dispose };
   function update(deltaSeconds) {
-    const basis = createSuctionBasis(params);
-    for (const line of lines) {
-      line.d -= line.speed * deltaSeconds;
-      if (line.d < basis.mouthPadding) resetLine(line, false);
-    }
-    for (const particle of particles) {
-      particle.d -= particle.speed * deltaSeconds;
-      if (particle.d < basis.mouthPadding) resetParticle(particle, false);
-    }
+    time += deltaSeconds;
     writeGeometry();
   }
   function dispose() {
@@ -193,10 +173,12 @@ function createSuctionMesh(scene, root, params, material, renderingGroupId) {
   function writeGeometry() {
     const basis = createSuctionBasis(params);
     const cameraBasis = createCameraBasis(scene, root, basis);
-    const color = toColor3(params.color);
+    const suctionColor = toColor3(params.color);
+    const electric = new Color3(0.82, 0.98, 1);
+    const boltBlue = new Color3(0.25, 0.62, 1);
     const alphaScale = clamp01(params.opacity) * Math.max(0, params.intensity);
     let vertexIndex = 0;
-    const putVertex = (position, alpha, brightness = 1) => {
+    const putVertex = (position, color, alpha, brightness = 1) => {
       const positionOffset = vertexIndex * 3;
       const colorOffset = vertexIndex * 4;
       positions[positionOffset] = position.x;
@@ -208,61 +190,67 @@ function createSuctionMesh(scene, root, params, material, renderingGroupId) {
       colors[colorOffset + 3] = clamp01(alpha * alphaScale);
       vertexIndex += 1;
     };
-    for (const line of lines) {
-      const alpha = lineFade(line.d, basis) * params.lineOpacity * line.alphaMul;
-      const headD = Math.max(basis.mouthPadding, line.d);
-      const tailD = Math.min(basis.length, line.d + line.len);
-      const head = suctionPosition(headD, line.u, line.v, basis);
-      const tail = suctionPosition(tailD, line.u, line.v, basis);
-      const shrink = Math.max(lateralScale(headD, basis), 0.18);
-      const half = cameraBasis.ribbonSide.scale(line.width * shrink * 0.5);
-      putVertex(tail.subtract(half), alpha, line.brightness);
-      putVertex(tail.add(half), alpha * 0.92, line.brightness);
-      putVertex(head, alpha * 0.22, line.brightness);
-    }
-    for (const particle of particles) {
-      const alpha = lineFade(particle.d, basis) * params.particleOpacity * particle.alphaMul;
-      const center = suctionPosition(particle.d, particle.u, particle.v, basis);
-      const shrink = Math.max(lateralScale(particle.d, basis), 0.22);
-      const right = cameraBasis.particleRight.scale(particle.size * shrink);
-      const up = cameraBasis.particleUp.scale(particle.size * shrink * 0.7);
-      putVertex(center.subtract(right).subtractInPlace(up), alpha, particle.brightness);
-      putVertex(center.add(right).subtractInPlace(up), alpha, particle.brightness);
-      putVertex(center.add(right).addInPlace(up), alpha * 0.8, particle.brightness);
-      putVertex(center.subtract(right).addInPlace(up), alpha * 0.8, particle.brightness);
+    const putQuad = (a, b, c, d, color, alpha, brightness = 1) => {
+      putVertex(a, color, alpha, brightness);
+      putVertex(b, color, alpha, brightness);
+      putVertex(c, color, alpha, brightness);
+      putVertex(d, color, alpha, brightness);
+    };
+    const putRibbon = (a, b, width, color, alpha, brightness = 1) => {
+      const segment = b.subtract(a);
+      let side = Vector3.Cross(segment, basis.axis);
+      if (side.lengthSquared() < 1e-4) side = cameraBasis.ribbonSide.clone();
+      side.normalize();
+      const half = side.scale(width * 0.5);
+      putQuad(a.subtract(half), a.add(half), b.add(half), b.subtract(half), color, alpha, brightness);
+    };
+    writeBolts(basis, electric, boltBlue, putRibbon);
+    while (vertexIndex < totalVertexCount) {
+      putVertex(Vector3.Zero(), suctionColor, 0);
     }
     mesh.updateVerticesData(VertexBuffer.PositionKind, positions, false, false);
     mesh.updateVerticesData(VertexBuffer.ColorKind, colors, false, false);
-  }
-  function resetLine(line, initial) {
-    const basis = createSuctionBasis(params);
-    line.d = initial ? randomRange(basis.mouthPadding + 0.05, basis.length) : basis.length + randomRange(0, basis.spawnFade);
-    line.u = randomRange(-basis.spreadX * 0.5, basis.spreadX * 0.5);
-    line.v = randomRange(-basis.spreadY * 0.5, basis.spreadY * 0.5);
-    line.len = randomRange(basis.lineLength * 0.65, basis.lineLength * 1.35);
-    line.width = randomRange(basis.lineWidth * 0.65, basis.lineWidth * 1.35);
-    line.speed = Math.max(0, params.suctionSpeed * Math.max(0.01, params.scale)) * randomRange(0.78, 1.25);
-    line.alphaMul = randomRange(0.65, 1);
-    line.brightness = randomRange(0.82, 1);
-    return line;
-  }
-  function resetParticle(particle, initial) {
-    const basis = createSuctionBasis(params);
-    particle.d = initial ? randomRange(basis.mouthPadding + 0.05, basis.length) : basis.length + randomRange(0, basis.spawnFade);
-    particle.u = randomRange(-basis.spreadX * 0.55, basis.spreadX * 0.55);
-    particle.v = randomRange(-basis.spreadY * 0.55, basis.spreadY * 0.55);
-    particle.size = randomRange(basis.particleSize * 0.45, basis.particleSize * 1.15);
-    particle.speed = Math.max(0, params.particleSpeed * Math.max(0.01, params.scale)) * randomRange(0.75, 1.35);
-    particle.alphaMul = randomRange(0.35, 0.9);
-    particle.brightness = randomRange(0.75, 1);
-    return particle;
-  }
-  function randomRange(min, max) {
-    const id2 = resetIndex;
-    resetIndex += 1;
-    return lerp(min, max, sequence01(id2, resetIndex % 8));
+    function writeBolts(currentBasis, boltColor, edgeColor, writeRibbon) {
+      for (let bolt = 0; bolt < boltCount; bolt += 1) {
+        const seed = sequence01(bolt + 7, bolt % 8);
+        const speedScale = Math.max(0, params.particleSpeed) / DEFAULT_PARAMS.particleSpeed;
+        const cycle = (time * speedScale * (1.45 + seed * 0.55) + seed) % 1;
+        const flicker = sequence01(bolt * 17 + Math.floor(time * 20), bolt % 8);
+        const active = flicker > 0.28 ? 1 : 0.18;
+        const angle = bolt * 2.399 + time * (1.7 + seed * 0.9);
+        const lengthScale = Math.max(0.04, params.lineLength / DEFAULT_PARAMS.lineLength);
+        const boltLength = lerp(currentBasis.length * 0.16, currentBasis.length * 0.28, seed) * lengthScale;
+        const headDistance = lerp(currentBasis.length * 0.92, currentBasis.mouthPadding * 1.15, cycle);
+        let previousDistance = Math.min(currentBasis.length, headDistance + boltLength);
+        let previous = suctionPosition(
+          previousDistance,
+          Math.cos(angle) * currentBasis.spreadX * 0.5 * lateralScale(previousDistance, currentBasis),
+          Math.sin(angle * 1.3) * currentBasis.spreadY * 0.5 * lateralScale(previousDistance, currentBasis),
+          currentBasis
+        );
+        for (let segment = 0; segment < BOLT_SEGMENTS; segment += 1) {
+          const t = (segment + 1) / BOLT_SEGMENTS;
+          const distance = Math.max(currentBasis.mouthPadding * 1.08, lerp(previousDistance, headDistance, t));
+          const suckScale = lateralScale(distance, currentBasis);
+          const jitter = (sequence01(bolt * 19 + segment + Math.floor(time * 18), segment) - 0.5) * 0.34 * currentBasis.spreadX * suckScale;
+          const curl = angle + t * (2.6 + seed * 1.8) + Math.sin(time * 4 + bolt) * 0.35;
+          const next = suctionPosition(
+            distance,
+            Math.cos(curl) * currentBasis.spreadX * suckScale * (1 - t * 0.45) + jitter,
+            Math.sin(curl * 1.25) * currentBasis.spreadY * suckScale * (1 - t * 0.5),
+            currentBasis
+          );
+          const mouthFade = smoothstep(0.04, 0.18, cycle) * (1 - smoothstep(0.88, 1, cycle));
+          writeRibbon(previous, next, basis.lineWidth * 0.58, segment % 2 === 0 ? boltColor : edgeColor, 0.38 * params.lineOpacity * active * mouthFade, 1.85);
+          previous = next;
+        }
+      }
+    }
   }
 }
+function pushQuadIndices(indices, base) {
+  indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+}
 function createSuctionBasis(params) {
   const scale = Math.max(0.01, params.scale);
   const axis = new Vector3(params.directionX, 0, params.directionZ);
@@ -360,7 +348,7 @@ function createSuctionMaterial(scene) {
   });
   material.backFaceCulling = false;
   material.transparencyMode = Material.MATERIAL_ALPHABLEND;
-  material.alphaMode = Constants.ALPHA_COMBINE;
+  material.alphaMode = Constants.ALPHA_ADD;
   material.disableDepthWrite = true;
   return material;
 }
@@ -389,12 +377,6 @@ function registerSuctionShaders() {
     `;
   }
 }
-function lineFade(distance, basis) {
-  const mouthFade = smoothstep(basis.mouthPadding, basis.mouthPadding + basis.fadeDistance, distance);
-  const clampedDistance = Math.min(distance, basis.length);
-  const outerFade = smoothstep(0, basis.spawnFade, basis.length - clampedDistance);
-  return mouthFade * outerFade;
-}
 function toColor3(color) {
   return new Color3(clamp01(color.r), clamp01(color.g), clamp01(color.b));
 }

package/dist/effects/player-upgrade/index.js

@@ -3,12 +3,10 @@ import { Vector3 } from "@babylonjs/core/Maths/math.vector";
 import { Constants } from "@babylonjs/core/Engines/constants";
 import { DynamicTexture } from "@babylonjs/core/Materials/Textures/dynamicTexture";
 import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial";
-import { CreateCylinder } from "@babylonjs/core/Meshes/Builders/cylinderBuilder";
 import { CreateDisc } from "@babylonjs/core/Meshes/Builders/discBuilder";
 import { CreatePlane } from "@babylonjs/core/Meshes/Builders/planeBuilder";
-import { CreateTorus } from "@babylonjs/core/Meshes/Builders/torusBuilder";
 import { ParticleSystem } from "@babylonjs/core/Particles/particleSystem";
-import { c as configureVfxParticleSystem, V as VFX_RENDERING_GROUP_ID } from "../../chunks/rendering-CV3nhygX.js";
+import { c as configureVfxParticleSystem } from "../../chunks/rendering-CV3nhygX.js";
 const id = "player-upgrade";
 const nameZh = "人物升级光效";
 const source = "runtime-generated";
@@ -22,6 +20,7 @@ const manifest = {
 const strandTextureByScene = /* @__PURE__ */ new WeakMap();
 const glowTextureByScene = /* @__PURE__ */ new WeakMap();
 const haloTextureByScene = /* @__PURE__ */ new WeakMap();
+const ringTextureByScene = /* @__PURE__ */ new WeakMap();
 const DEFAULT_PARAMS = {
   lifetime: 2.4,
   scale: 1,
@@ -73,13 +72,13 @@ const playerUpgradeEffectPackage = {
     { key: "glowHeight", label: "光柱高度", kind: "number", min: 0.2, max: 5, step: 0.01 },
     { key: "glowWidth", label: "光柱宽度", kind: "number", min: 0.1, max: 4, step: 0.01 }
   ],
-  create({ scene, root, position, params }) {
+  create({ scene, root, position, params, renderingGroupId, scale }) {
     markVfxRoot(root);
     root.position.copyFrom(position);
-    const strands = createStrandSystem(scene, root, params);
-    const strandMeshes = createStrandMeshes(scene, root, params);
-    const rings = createExpandingRings(scene, root, params);
-    const glowAura = createGlowAura(scene, root, params);
+    const groupId = renderingGroupId ?? 0;
+    const strands = createStrandSystem(scene, root, params, groupId, scale);
+    const rings = createExpandingRings(scene, root, params, groupId);
+    const glowAura = createGlowAura(scene, root, params, groupId);
     let disposed = false;
     const disposeTimer = window.setTimeout(() => disposeAll(), getDisposeDelaySeconds(params) * 1e3);
     strands.start();
@@ -95,7 +94,6 @@ const playerUpgradeEffectPackage = {
       window.clearTimeout(disposeTimer);
       strands.stop();
       strands.dispose(false);
-      strandMeshes.dispose();
       rings.dispose();
       glowAura.dispose();
       cleanupPlanarShadowArtifacts(scene);
@@ -133,7 +131,7 @@ function cleanupPlanarShadowArtifacts(scene) {
     }
   }
 }
-function createGlowAura(scene, root, params) {
+function createGlowAura(scene, root, params, renderingGroupId) {
   const effectScale = Math.max(0.05, params.scale);
   const color = params.color;
   const glowHeight = Math.max(0.1, params.glowHeight) * effectScale;
@@ -148,7 +146,7 @@ function createGlowAura(scene, root, params) {
     mesh.position.y = glowHeight * 0.48;
     mesh.rotation.y = index * Math.PI / 3;
     mesh.scaling.set(glowWidth, glowHeight, 1);
-    mesh.renderingGroupId = VFX_RENDERING_GROUP_ID;
+    mesh.renderingGroupId = renderingGroupId;
     const material = new StandardMaterial(`player-upgrade.soft-glow-column-material.${index}`, scene);
     configureTexturedGlowMaterial(material, color, getGlowTexture(scene), 2.8);
     material.alpha = 0;
@@ -162,7 +160,7 @@ function createGlowAura(scene, root, params) {
   halo.position.y = 0.025 * effectScale;
   halo.rotation.x = Math.PI / 2;
   halo.scaling.set(glowWidth * 1.12, glowWidth * 1.12, 1);
-  halo.renderingGroupId = VFX_RENDERING_GROUP_ID;
+  halo.renderingGroupId = renderingGroupId;
   const haloMaterial = new StandardMaterial("player-upgrade.ground-halo-material", scene);
   configureTexturedGlowMaterial(haloMaterial, color, getHaloTexture(scene), 2.4);
   haloMaterial.alpha = 0;
@@ -198,19 +196,23 @@ function createGlowAura(scene, root, params) {
   }
   return { dispose };
 }
-function createStrandSystem(scene, root, params) {
+function createStrandSystem(scene, root, params, renderingGroupId, spawnScale) {
   const effectScale = Math.max(0.05, params.scale);
+  const spawnHorizontalScale = getHorizontalScale(spawnScale);
+  const spawnVerticalScale = Math.max(0.01, Math.abs(spawnScale.y));
   const count = Math.max(0, Math.round(params.strandCount));
   const color = params.color;
   const bright = brighten(color, 0.72);
-  const strandLength = Math.max(0.05, params.strandLength) * effectScale;
+  const strandLength = Math.max(0.05, params.strandLength) * effectScale * spawnVerticalScale;
   const strandRadius = Math.max(0, params.strandRadius) * effectScale;
-  const strandWidth = Math.max(1e-3, params.strandWidth) * effectScale;
+  const strandWidth = Math.max(1e-3, params.strandWidth) * effectScale * spawnHorizontalScale;
   const system = new ParticleSystem("player-upgrade.gold-strands", Math.max(1, count), scene);
   configureVfxParticleSystem(system);
+  system.renderingGroupId = renderingGroupId;
   system.particleTexture = getStrandTexture(scene);
   system.particleTexture.hasAlpha = true;
   system.emitter = root;
+  system.isLocal = true;
   system.manualEmitCount = count;
   system.emitRate = count * 60;
   system.targetStopDuration = 0.05;
@@ -224,9 +226,9 @@ function createStrandSystem(scene, root, params) {
   system.maxScaleX = strandWidth * 1.8;
   system.minScaleY = 1;
   system.maxScaleY = 1.6;
-  system.minEmitPower = Math.max(0.01, params.riseSpeed * effectScale * 0.55);
-  system.maxEmitPower = Math.max(system.minEmitPower, params.riseSpeed * effectScale * 1.28);
-  system.gravity = new Vector3(0, 0.34 * effectScale, 0);
+  system.minEmitPower = Math.max(0.01, params.riseSpeed * effectScale * spawnVerticalScale * 0.55);
+  system.maxEmitPower = Math.max(system.minEmitPower, params.riseSpeed * effectScale * spawnVerticalScale * 1.28);
+  system.gravity = new Vector3(0, 0.34 * effectScale * spawnVerticalScale, 0);
   system.updateSpeed = 1 / 60;
   system.color1 = toColor4(color, params.opacity * 0.72);
   system.color2 = toColor4(bright, params.opacity);
@@ -267,102 +269,28 @@ function createStrandSystem(scene, root, params) {
   };
   return system;
 }
-function createStrandMeshes(scene, root, params) {
-  const effectScale = Math.max(0.05, params.scale);
-  const count = Math.min(90, Math.max(0, Math.round(params.strandCount * 0.62)));
-  const color = params.color;
-  const radius = Math.max(0.04, params.strandRadius * effectScale);
-  const strandLength = Math.max(0.05, params.strandLength * effectScale);
-  const riseHeight = Math.max(0.1, params.strandHeight * effectScale);
-  const width = Math.max(5e-3, params.strandWidth * effectScale * 1.25);
-  const speedScale = Math.max(0.2, params.riseSpeed / DEFAULT_PARAMS.riseSpeed);
-  const duration = Math.max(0.22, params.lifetime * 0.72 / speedScale);
-  const states = [];
-  for (let index = 0; index < count; index += 1) {
-    const angle = sequence01(index, 0) * Math.PI * 2;
-    const localRadius = radius * lerp(0.42, 1.08, sequence01(index, 1));
-    const mesh = CreateCylinder(
-      `player-upgrade.gold-strand-mesh.${index}`,
-      { height: 1, diameter: width, tessellation: 6 },
-      scene
-    );
-    prepareVfxMesh(mesh);
-    mesh.parent = root;
-    mesh.position.x = Math.cos(angle) * localRadius;
-    mesh.position.z = Math.sin(angle) * localRadius;
-    mesh.position.y = 0;
-    mesh.renderingGroupId = VFX_RENDERING_GROUP_ID;
-    mesh.isVisible = false;
-    const material = new StandardMaterial(`player-upgrade.gold-strand-mesh-material.${index}`, scene);
-    configureGlowMaterial(material, color, 2.8);
-    material.alpha = 0;
-    mesh.material = material;
-    states.push({
-      mesh,
-      material,
-      height: strandLength * lerp(0.68, 1.18, sequence01(index, 2)),
-      startDelay: sequence01(index, 3) * Math.min(0.34, params.lifetime * 0.18),
-      duration: duration * lerp(0.78, 1.12, sequence01(index, 4))
-    });
-  }
-  let age = 0;
-  let disposed = false;
-  const observer = scene.onBeforeRenderObservable.add(() => {
-    if (disposed) return;
-    const deltaSeconds = Math.min(0.05, scene.getEngine().getDeltaTime() / 1e3);
-    age += deltaSeconds;
-    for (const state of states) {
-      const localAge = age - state.startDelay;
-      if (localAge < 0 || localAge > state.duration) {
-        state.mesh.isVisible = false;
-        state.material.alpha = 0;
-        continue;
-      }
-      const t = Math.min(1, localAge / state.duration);
-      const grow = Math.min(1, t / 0.32);
-      const fadeOut = Math.max(0, 1 - Math.max(0, t - 0.66) / 0.34);
-      const alpha = params.opacity * fadeOut * Math.min(1, t / 0.12);
-      const currentHeight = state.height * grow;
-      state.mesh.isVisible = alpha > 0.01;
-      state.mesh.scaling.set(1, currentHeight, 1);
-      state.mesh.position.y = currentHeight * 0.5 + riseHeight * easeOutCubic(t);
-      state.material.alpha = Math.min(1, alpha * 1.35);
-    }
-    if (age >= params.lifetime + 0.45) dispose();
-  });
-  function dispose() {
-    if (disposed) return;
-    disposed = true;
-    scene.onBeforeRenderObservable.remove(observer);
-    for (const state of states) {
-      state.mesh.dispose();
-      state.material.dispose();
-    }
-  }
-  return { dispose };
-}
-function createExpandingRings(scene, root, params) {
+function createExpandingRings(scene, root, params, renderingGroupId) {
   const effectScale = Math.max(0.05, params.scale);
   const ringCount = Math.max(0, Math.round(params.ringCount));
   const ringDuration = Math.max(0.18, Math.min(0.9, params.lifetime * 0.38));
   const minRadius = 0.14 * effectScale;
   const maxRadius = Math.max(minRadius + 0.01, params.ringMaxRadius * effectScale);
-  const thickness = Math.max(2e-3, params.ringThickness * effectScale);
   const color = params.color;
   const states = [];
   for (let index = 0; index < ringCount; index += 1) {
-    const mesh = CreateTorus(
+    const mesh = CreatePlane(
       `player-upgrade.expanding-ring.${index}`,
-      { diameter: 1, thickness, tessellation: 96 },
+      { size: 2 },
       scene
     );
     prepareVfxMesh(mesh);
     mesh.parent = root;
     mesh.position.y = 0.03 * effectScale + index * 0.012 * effectScale;
-    mesh.renderingGroupId = VFX_RENDERING_GROUP_ID;
+    mesh.rotation.x = Math.PI / 2;
+    mesh.renderingGroupId = renderingGroupId;
     mesh.isVisible = false;
     const material = new StandardMaterial(`player-upgrade.ring-material.${index}`, scene);
-    configureGlowMaterial(material, color, 2.4);
+    configureTexturedGlowMaterial(material, color, getRingTexture(scene), 2.4);
     material.alpha = 0;
     mesh.material = material;
     states.push({
@@ -390,7 +318,7 @@ function createExpandingRings(scene, root, params) {
       const radius = lerp(minRadius, maxRadius, eased);
       const alpha = params.ringOpacity * (1 - t) * Math.min(1, t / 0.12);
       state.mesh.isVisible = alpha > 0.01;
-      state.mesh.scaling.set(radius, radius, radius);
+      state.mesh.scaling.set(radius, radius, 1);
       const ringColor = brighten(color, 0.1 + 0.08 * (1 - t));
       state.material.diffuseColor = toColor3(ringColor);
       state.material.emissiveColor = toGlowColor3(ringColor, 3.4);
@@ -477,6 +405,45 @@ function getHaloTexture(scene) {
   haloTextureByScene.set(scene, texture);
   return texture;
 }
+function getRingTexture(scene) {
+  const existing = ringTextureByScene.get(scene);
+  if (existing) return existing;
+  const size = 256;
+  const texture = new DynamicTexture("player_upgrade_expanding_ring_texture", { width: size, height: size }, scene, true);
+  const context = texture.getContext();
+  const canvasContext = context;
+  context.clearRect(0, 0, size, size);
+  const center = size / 2;
+  const radius = size * 0.39;
+  const strokeWidth = size * 0.105;
+  canvasContext.lineCap = "round";
+  canvasContext.lineJoin = "round";
+  const outerGlow = context.createRadialGradient(center, center, radius - strokeWidth * 1.1, center, center, radius + strokeWidth * 1.8);
+  outerGlow.addColorStop(0, "rgba(255,255,255,0)");
+  outerGlow.addColorStop(0.38, "rgba(255,255,255,0.28)");
+  outerGlow.addColorStop(0.58, "rgba(255,255,255,0.34)");
+  outerGlow.addColorStop(1, "rgba(255,255,255,0)");
+  context.strokeStyle = outerGlow;
+  context.lineWidth = strokeWidth * 2.6;
+  context.beginPath();
+  context.arc(center, center, radius, 0, Math.PI * 2);
+  context.stroke();
+  const core = context.createRadialGradient(center, center, radius - strokeWidth * 0.85, center, center, radius + strokeWidth * 0.85);
+  core.addColorStop(0, "rgba(255,255,255,0)");
+  core.addColorStop(0.42, "rgba(255,255,255,0.72)");
+  core.addColorStop(0.5, "rgba(255,255,255,1)");
+  core.addColorStop(0.62, "rgba(255,255,255,0.62)");
+  core.addColorStop(1, "rgba(255,255,255,0)");
+  context.strokeStyle = core;
+  context.lineWidth = strokeWidth;
+  context.beginPath();
+  context.arc(center, center, radius, 0, Math.PI * 2);
+  context.stroke();
+  texture.hasAlpha = true;
+  texture.update(false);
+  ringTextureByScene.set(scene, texture);
+  return texture;
+}
 function getDisposeDelaySeconds(params) {
   const ringDuration = Math.max(0.18, Math.min(0.9, params.lifetime * 0.38));
   return Math.max(0.2, params.lifetime) + getLastRingEndTime(params, ringDuration) + 0.35;
@@ -484,6 +451,9 @@ function getDisposeDelaySeconds(params) {
 function getLastRingEndTime(params, ringDuration) {
   return Math.max(0, Math.round(params.ringCount) - 1) * Math.max(0.02, params.ringInterval) + ringDuration;
 }
+function getHorizontalScale(scale) {
+  return Math.max(0.01, (Math.abs(scale.x) + Math.abs(scale.z)) * 0.5);
+}
 function toColor4(color, alpha) {
   return new Color4(clamp01(color.r), clamp01(color.g), clamp01(color.b), clamp01(alpha));
 }

package/index.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": "vfx-index/1.0",
-  "count": 39,
+  "count": 40,
   "effects": [
     {
       "id": "build.particle.lumber_debris_scatter",
@@ -147,6 +147,16 @@
       "media": {},
       "path": "packages/effects/explosion"
     },
+    {
+      "id": "golden-bubble-pop",
+      "dir": "golden-bubble-pop",
+      "nameZh": "金色泡泡炸开",
+      "kind": "code",
+      "category": "golden-bubble-pop",
+      "tags": [],
+      "media": {},
+      "path": "packages/effects/golden-bubble-pop"
+    },
     {
       "id": "ground-tile-upgrade",
       "dir": "ground-tile-upgrade",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fps-games/vfx",
-  "version": "0.3.11",
+  "version": "0.3.14",
   "type": "module",
   "description": "Shared VFX library for Playable projects: engine-injected effect packages + runtime. Project-pure (no imports of host project code).",
   "publishConfig": {

package/packages/effects/golden-bubble-pop/vfx-params.json

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