@fps-games/vfx 0.1.1

package/dist/effects/character-entrance/index.js

@@ -0,0 +1,271 @@
+import { Color3 } from "@babylonjs/core/Maths/math.color";
+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 { CreateTorus } from "@babylonjs/core/Meshes/Builders/torusBuilder";
+import { Mesh } from "@babylonjs/core/Meshes/mesh";
+import { V as VFX_RENDERING_GROUP_ID } from "../../chunks/rendering-CV3nhygX.js";
+const id = "character-entrance";
+const nameZh = "人物登场光柱";
+const source = "runtime-generated";
+const assets = [];
+const manifest = {
+  id,
+  nameZh,
+  source,
+  assets
+};
+const DEFAULT_PARAMS = {
+  lifetime: 2.2,
+  scale: 1,
+  initialHeight: 0.02,
+  offsetX: 0,
+  offsetZ: 0,
+  color: { r: 0.72, g: 0.96, b: 1 },
+  opacity: 0.82,
+  radius: 0.58,
+  height: 2.35,
+  beamWidth: 0.08,
+  riseSpeed: 0.9,
+  ringOpacity: 0.78,
+  fadeStart: 0.58
+};
+const characterEntranceEffectPackage = {
+  id: "character-entrance",
+  nameZh: "人物登场光柱",
+  manifest,
+  defaultParams: DEFAULT_PARAMS,
+  debugAnchor: "player",
+  debugParams: [
+    { key: "lifetime", label: "生命周期", kind: "lifetime", min: 0.4, max: 6, step: 0.01 },
+    { key: "scale", label: "整体缩放", kind: "scale", min: 0.1, max: 5, step: 0.01 },
+    { key: "color", label: "光柱颜色", kind: "color" },
+    { key: "opacity", label: "透明度", kind: "opacity", min: 0, max: 1, step: 0.01 },
+    { key: "radius", label: "光柱半径", kind: "number", min: 0.05, max: 3, step: 0.01 },
+    { key: "height", label: "光柱高度", kind: "number", min: 0.2, max: 8, step: 0.01 },
+    { key: "beamWidth", label: "杯壁厚度", kind: "number", min: 5e-3, max: 0.35, step: 1e-3 },
+    { key: "riseSpeed", label: "流动速度", kind: "number", min: 0, max: 5, step: 0.01 },
+    { key: "ringOpacity", label: "底部强度", kind: "opacity", min: 0, max: 1, step: 0.01 },
+    { key: "fadeStart", label: "淡出开始", kind: "number", min: 0.05, max: 0.95, step: 0.01 }
+  ],
+  create({ scene, root, position, params }) {
+    root.position.copyFrom(position);
+    const beam = createCupBeam(scene, root, params);
+    let disposed = false;
+    const disposeTimer = window.setTimeout(() => disposeAll(), Math.max(0.05, params.lifetime + 0.45) * 1e3);
+    beam.start();
+    return {
+      root,
+      dispose() {
+        disposeAll();
+      }
+    };
+    function disposeAll() {
+      if (disposed) return;
+      disposed = true;
+      window.clearTimeout(disposeTimer);
+      beam.dispose();
+      root.dispose();
+    }
+  }
+};
+function createCupBeam(scene, root, params) {
+  const scale = Math.max(0.05, params.scale);
+  const height = Math.max(0.05, params.height * scale);
+  const radius = Math.max(0.02, params.radius * scale);
+  const wallThickness = Math.max(6e-3, params.beamWidth * scale);
+  const shellAlpha = clamp01(params.opacity * 0.68);
+  const flowAlpha = clamp01(params.opacity * 0.78);
+  const rimAlpha = clamp01(params.opacity * params.ringOpacity * 1.18);
+  const shellMaterial = createCupBeamMaterial(scene, params, "shell", getCupBeamTexture(scene), shellAlpha);
+  const flowTexture = getCupFlowTexture(scene);
+  const flowMaterial = createCupBeamMaterial(scene, params, "flow", flowTexture, flowAlpha);
+  const rimMaterial = createCupBeamMaterial(scene, params, "bottom-rim", getBottomRimTexture(scene), rimAlpha);
+  const shell = createOpenCylinder(scene, "character-entrance.cup.shell");
+  const flow = createOpenCylinder(scene, "character-entrance.cup.flow");
+  const rim = CreateTorus("character-entrance.cup.bottom-rim", {
+    diameter: radius * 2,
+    thickness: Math.max(0.018, wallThickness * 0.9),
+    tessellation: 64,
+    sideOrientation: Mesh.DOUBLESIDE
+  }, scene);
+  const meshes = [
+    { mesh: shell, radius: radius + wallThickness * 1.6, material: shellMaterial, alpha: shellAlpha },
+    { mesh: flow, radius: radius + wallThickness * 0.55, material: flowMaterial, alpha: flowAlpha }
+  ];
+  let age = 0;
+  let observer = null;
+  let disposed = false;
+  for (const entry of meshes) {
+    entry.mesh.parent = root;
+    entry.mesh.position.y = 0;
+    entry.mesh.scaling.set(entry.radius, 1e-3, entry.radius);
+    entry.mesh.renderingGroupId = VFX_RENDERING_GROUP_ID;
+    entry.mesh.isPickable = false;
+    entry.mesh.material = entry.material;
+    entry.material.alpha = 0;
+  }
+  rim.parent = root;
+  rim.position.y = 0.025 * scale;
+  rim.renderingGroupId = VFX_RENDERING_GROUP_ID;
+  rim.isPickable = false;
+  rim.material = rimMaterial;
+  rimMaterial.alpha = 0;
+  return { start, dispose };
+  function start() {
+    if (observer) return;
+    observer = scene.onBeforeRenderObservable.add(() => {
+      if (disposed) return;
+      const deltaSeconds = Math.min(0.05, scene.getEngine().getDeltaTime() / 1e3);
+      age += deltaSeconds;
+      const t = Math.min(1, age / Math.max(0.01, params.lifetime));
+      const riseDuration = Math.max(0.1, Math.min(0.68, 0.55 / Math.max(0.2, params.riseSpeed)));
+      const rise = easeOutCubic(Math.min(1, t / riseDuration));
+      const fadeStart = Math.max(0.05, Math.min(0.95, params.fadeStart));
+      const fade = Math.max(0, 1 - Math.max(0, t - fadeStart) / Math.max(0.01, 1 - fadeStart));
+      const visibleHeight = Math.max(1e-3, height * rise);
+      const softPulse = 0.96 + Math.sin(age * 4.2) * 0.04;
+      flowTexture.vOffset -= deltaSeconds * Math.max(0, params.riseSpeed) * 0.34;
+      for (const entry of meshes) {
+        entry.mesh.scaling.y = visibleHeight;
+        entry.mesh.position.y = visibleHeight * 0.5;
+        entry.material.alpha = entry.alpha * fade * softPulse;
+      }
+      rim.scaling.setAll(1 + rise * 0.06);
+      rimMaterial.alpha = rimAlpha * fade * (0.82 + rise * 0.18);
+    });
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    if (observer) scene.onBeforeRenderObservable.remove(observer);
+    observer = null;
+    shell.dispose();
+    flow.dispose();
+    rim.dispose();
+    shellMaterial.dispose();
+    flowMaterial.dispose();
+    rimMaterial.dispose();
+  }
+}
+function createOpenCylinder(scene, name) {
+  return CreateCylinder(name, {
+    height: 1,
+    diameter: 2,
+    tessellation: 96,
+    subdivisions: 12,
+    cap: Mesh.NO_CAP,
+    sideOrientation: Mesh.DOUBLESIDE
+  }, scene);
+}
+function createCupBeamMaterial(scene, params, suffix, texture, alpha) {
+  const material = new StandardMaterial(`character-entrance.cup.${suffix}.material`, scene);
+  texture.hasAlpha = true;
+  material.diffuseTexture = texture;
+  material.opacityTexture = texture;
+  material.useAlphaFromDiffuseTexture = true;
+  material.emissiveColor = toColor3(params.color);
+  material.diffuseColor = toColor3(params.color);
+  material.alpha = alpha;
+  material.disableLighting = true;
+  material.backFaceCulling = false;
+  material.alphaMode = Constants.ALPHA_ADD;
+  return material;
+}
+function getCupBeamTexture(scene) {
+  const key = "__vfx_character_entrance_cup_beam_texture";
+  const metadata = scene.metadata && typeof scene.metadata === "object" ? scene.metadata : {};
+  scene.metadata = metadata;
+  const existing = metadata[key];
+  if (existing) return existing;
+  const texture = new DynamicTexture("character_entrance_cup_beam_texture", { width: 128, height: 256 }, scene, true);
+  const context = texture.getContext();
+  const composite = context;
+  context.clearRect(0, 0, 128, 256);
+  const side = context.createLinearGradient(0, 0, 128, 0);
+  side.addColorStop(0, "rgba(205, 250, 255, 0)");
+  side.addColorStop(0.22, "rgba(205, 250, 255, 0.42)");
+  side.addColorStop(0.5, "rgba(245, 255, 255, 0.82)");
+  side.addColorStop(0.78, "rgba(205, 250, 255, 0.42)");
+  side.addColorStop(1, "rgba(205, 250, 255, 0)");
+  const vertical = context.createLinearGradient(0, 0, 0, 256);
+  vertical.addColorStop(0, "rgba(210, 250, 255, 0)");
+  vertical.addColorStop(0.18, "rgba(210, 250, 255, 0.1)");
+  vertical.addColorStop(0.62, "rgba(185, 246, 255, 0.58)");
+  vertical.addColorStop(1, "rgba(245, 255, 255, 0.96)");
+  context.fillStyle = side;
+  context.fillRect(0, 0, 128, 256);
+  composite.globalCompositeOperation = "source-in";
+  context.fillStyle = vertical;
+  context.fillRect(0, 0, 128, 256);
+  composite.globalCompositeOperation = "source-over";
+  texture.hasAlpha = true;
+  texture.update(false);
+  return texture;
+}
+function getCupFlowTexture(scene) {
+  const key = "__vfx_character_entrance_cup_flow_texture";
+  const metadata = scene.metadata && typeof scene.metadata === "object" ? scene.metadata : {};
+  scene.metadata = metadata;
+  const existing = metadata[key];
+  if (existing) return existing;
+  const texture = new DynamicTexture("character_entrance_cup_flow_texture", { width: 128, height: 256 }, scene, true);
+  const context = texture.getContext();
+  const composite = context;
+  context.clearRect(0, 0, 128, 256);
+  const side = context.createLinearGradient(0, 0, 128, 0);
+  side.addColorStop(0, "rgba(255, 255, 255, 0)");
+  side.addColorStop(0.28, "rgba(255, 255, 255, 0.22)");
+  side.addColorStop(0.5, "rgba(255, 255, 255, 0.7)");
+  side.addColorStop(0.72, "rgba(255, 255, 255, 0.22)");
+  side.addColorStop(1, "rgba(255, 255, 255, 0)");
+  context.fillStyle = side;
+  context.fillRect(0, 0, 128, 256);
+  composite.globalCompositeOperation = "source-in";
+  for (let y = -48; y < 304; y += 56) {
+    const band = context.createLinearGradient(0, y, 0, y + 42);
+    band.addColorStop(0, "rgba(255, 255, 255, 0)");
+    band.addColorStop(0.48, "rgba(255, 255, 255, 0.92)");
+    band.addColorStop(1, "rgba(255, 255, 255, 0)");
+    context.fillStyle = band;
+    context.fillRect(0, y, 128, 42);
+  }
+  composite.globalCompositeOperation = "source-over";
+  texture.hasAlpha = true;
+  texture.vScale = 1.2;
+  texture.update(false);
+  return texture;
+}
+function getBottomRimTexture(scene) {
+  const key = "__vfx_character_entrance_bottom_rim_texture";
+  const metadata = scene.metadata && typeof scene.metadata === "object" ? scene.metadata : {};
+  scene.metadata = metadata;
+  const existing = metadata[key];
+  if (existing) return existing;
+  const texture = new DynamicTexture("character_entrance_bottom_rim_texture", { width: 64, height: 64 }, scene, true);
+  const context = texture.getContext();
+  context.clearRect(0, 0, 64, 64);
+  const glow = context.createRadialGradient(32, 32, 8, 32, 32, 31);
+  glow.addColorStop(0, "rgba(245, 255, 255, 0.96)");
+  glow.addColorStop(0.55, "rgba(185, 246, 255, 0.68)");
+  glow.addColorStop(1, "rgba(150, 230, 255, 0)");
+  context.fillStyle = glow;
+  context.fillRect(0, 0, 64, 64);
+  texture.hasAlpha = true;
+  texture.update(false);
+  return texture;
+}
+function toColor3(color) {
+  return new Color3(clamp01(color.r), clamp01(color.g), clamp01(color.b));
+}
+function clamp01(value) {
+  return Math.min(1, Math.max(0, value));
+}
+function easeOutCubic(value) {
+  const t = clamp01(value);
+  return 1 - Math.pow(1 - t, 3);
+}
+export {
+  characterEntranceEffectPackage
+};

package/dist/effects/coin-burst/index.d.ts

@@ -0,0 +1,6 @@
+import { VfxEffectPackage, VfxParamValues } from '../../types';
+interface CoinBurstParams extends VfxParamValues {
+    count: number;
+}
+export declare const coinBurstEffectPackage: VfxEffectPackage<CoinBurstParams>;
+export {};

package/dist/effects/coin-burst/index.js

@@ -0,0 +1,45 @@
+import { CreateCylinder } from "@babylonjs/core/Meshes/Builders/cylinderBuilder";
+import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial";
+import { Color3 } from "@babylonjs/core/Maths/math.color";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { F as FlyerPool } from "../../chunks/space-shared-BXV1hc0k.js";
+const DEFAULT_PARAMS = { count: 6 };
+const coinBurstEffectPackage = {
+  id: "coin-burst",
+  nameZh: "金币爆出",
+  debugAnchor: "playerRight",
+  defaultParams: DEFAULT_PARAMS,
+  debugParams: [
+    { key: "count", label: "金币数量", kind: "number", min: 0, max: 20, step: 1 }
+  ],
+  create({ scene, root, position, params }) {
+    root.position.copyFrom(position);
+    const pool = new FlyerPool(scene);
+    const coinMat = new StandardMaterial("vfx_coin_mat", scene);
+    coinMat.diffuseColor = new Color3(1, 0.78, 0.1);
+    coinMat.emissiveColor = new Color3(0.5, 0.36, 0.02);
+    coinMat.specularColor = new Color3(1, 0.9, 0.4);
+    for (let i = 0; i < Math.round(params.count); i++) {
+      const c = CreateCylinder("vfx_coin", { diameter: 0.8, height: 0.12, tessellation: 18 }, scene);
+      c.rotation.x = Math.random() * Math.PI;
+      c.material = coinMat;
+      pool.spawn(c, position, new Vector3((Math.random() - 0.5) * 6, Math.random() * 6 + 4, (Math.random() - 0.5) * 6), 9, 1.9);
+    }
+    let disposed = false;
+    const disposeTimer = window.setTimeout(() => disposeAll(), 2300);
+    function disposeAll() {
+      if (disposed) return;
+      disposed = true;
+      window.clearTimeout(disposeTimer);
+      pool.dispose();
+      coinMat.dispose();
+      root.dispose();
+    }
+    return { root, dispose() {
+      disposeAll();
+    } };
+  }
+};
+export {
+  coinBurstEffectPackage
+};

package/dist/effects/comet-trail-flame/index.d.ts

@@ -0,0 +1,11 @@
+import { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+interface CometTrailFlameParams extends VfxParamValues {
+    lifetimeMode: string;
+    lifetime: number;
+    width: number;
+    length: number;
+    fps: number;
+    tint: VfxColorValue;
+}
+export declare const cometTrailFlameEffectPackage: VfxEffectPackage<CometTrailFlameParams>;
+export {};