@fps-games/vfx 0.3.11 → 0.3.13

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/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.13",
   "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": {}
+}