@fps-games/vfx 0.1.1

package/packages/effects/player-upgrade/index.ts

@@ -0,0 +1,635 @@
+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 { 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 type { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { ParticleSystem } from '@babylonjs/core/Particles/particleSystem';
+import type { Scene } from '@babylonjs/core/scene';
+import type { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+import { configureVfxParticleSystem, VFX_RENDERING_GROUP_ID } from '../../rendering';
+import manifest from './effect.json';
+
+interface PlayerUpgradeParams extends VfxParamValues {
+  lifetime: number;
+  scale: number;
+  initialHeight: number;
+  color: VfxColorValue;
+  opacity: number;
+  strandCount: number;
+  strandLength: number;
+  strandHeight: number;
+  strandRadius: number;
+  strandWidth: number;
+  riseSpeed: number;
+  ringCount: number;
+  ringMaxRadius: number;
+  ringThickness: number;
+  ringInterval: number;
+  ringOpacity: number;
+  glowIntensity: number;
+  glowHeight: number;
+  glowWidth: number;
+}
+
+interface RingState {
+  mesh: Mesh;
+  material: StandardMaterial;
+  startDelay: number;
+  duration: number;
+}
+
+interface StrandMeshState {
+  mesh: Mesh;
+  material: StandardMaterial;
+  height: number;
+  startDelay: number;
+  duration: number;
+}
+
+const strandTextureByScene = new WeakMap<Scene, DynamicTexture>();
+const glowTextureByScene = new WeakMap<Scene, DynamicTexture>();
+const haloTextureByScene = new WeakMap<Scene, DynamicTexture>();
+
+const DEFAULT_PARAMS: PlayerUpgradeParams = {
+  lifetime: 2.4,
+  scale: 1,
+  initialHeight: 0.02,
+  color: { r: 1, g: 0.78, b: 0.08 },
+  opacity: 1,
+  strandCount: 120,
+  strandLength: 0.72,
+  strandHeight: 1.55,
+  strandRadius: 0.58,
+  strandWidth: 0.075,
+  riseSpeed: 1.45,
+  ringCount: 4,
+  ringMaxRadius: 2.15,
+  ringThickness: 0.09,
+  ringInterval: 0.28,
+  ringOpacity: 1,
+  glowIntensity: 1.85,
+  glowHeight: 2.15,
+  glowWidth: 1.08,
+};
+
+export const playerUpgradeEffectPackage: VfxEffectPackage<PlayerUpgradeParams> = {
+  id: 'player-upgrade',
+  nameZh: '人物&NPC升级',
+  manifest,
+  defaultParams: DEFAULT_PARAMS,
+  debugAnchor: 'player',
+  debugParams: [
+    { key: 'lifetime', label: '生命周期', kind: 'lifetime', min: 0.2, max: 6, step: 0.01 },
+    { key: 'scale', label: '整体缩放', kind: 'scale', min: 0.1, max: 5, step: 0.01 },
+    { key: 'initialHeight', label: '初始高度', kind: 'number', min: -1, max: 3, step: 0.01 },
+    { key: 'color', label: '金光颜色', kind: 'color' },
+    { key: 'opacity', label: '金丝透明度', kind: 'opacity', min: 0, max: 1, step: 0.01 },
+    { key: 'strandCount', label: '金丝数量', kind: 'number', min: 0, max: 240, step: 1 },
+    { key: 'strandLength', label: '金丝长度', kind: 'number', min: 0.05, max: 3, step: 0.01 },
+    { key: 'strandHeight', label: '金丝上升高度', kind: 'number', min: 0.2, max: 5, step: 0.01 },
+    { key: 'strandRadius', label: '金丝包围半径', kind: 'number', min: 0.05, max: 2, step: 0.01 },
+    { key: 'strandWidth', label: '金丝粗细', kind: 'number', min: 0.005, max: 0.2, step: 0.001 },
+    { key: 'riseSpeed', label: '金丝上升速度', kind: 'number', min: 0.05, max: 6, step: 0.01 },
+    { key: 'ringCount', label: '亮环次数', kind: 'number', min: 0, max: 10, step: 1 },
+    { key: 'ringMaxRadius', label: '亮环最大半径', kind: 'number', min: 0.1, max: 5, step: 0.01 },
+    { key: 'ringThickness', label: '亮环粗细', kind: 'number', min: 0.005, max: 0.3, step: 0.001 },
+    { key: 'ringInterval', label: '亮环间隔', kind: 'number', min: 0.02, max: 1.2, step: 0.01 },
+    { key: 'ringOpacity', label: '亮环透明度', kind: 'opacity', min: 0, max: 1, step: 0.01 },
+    { key: 'glowIntensity', label: '光芒强度', kind: 'number', min: 0, max: 3, step: 0.01 },
+    { 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 }) {
+    const effectScale = Math.max(0.05, params.scale);
+    markVfxRoot(root);
+    root.position.copyFrom(position).addInPlace(new Vector3(0, params.initialHeight * effectScale, 0));
+    const strands = createStrandSystem(scene, root, params);
+    const strandMeshes = createStrandMeshes(scene, root, params);
+    const rings = createExpandingRings(scene, root, params);
+    const glowAura = createGlowAura(scene, root, params);
+    let disposed = false;
+    const disposeTimer = window.setTimeout(() => disposeAll(), getDisposeDelaySeconds(params) * 1000);
+
+    strands.start();
+
+    return {
+      root,
+      dispose() {
+        disposeAll();
+      },
+    };
+
+    function disposeAll(): void {
+      if (disposed) return;
+      disposed = true;
+      window.clearTimeout(disposeTimer);
+      strands.stop();
+      strands.dispose();
+      strandMeshes.dispose();
+      rings.dispose();
+      glowAura.dispose();
+      cleanupPlanarShadowArtifacts(scene);
+      root.dispose();
+    }
+  },
+};
+
+function markVfxRoot(root: unknown): void {
+  const target = root as { metadata?: Record<string, unknown> | null };
+  target.metadata = {
+    ...(target.metadata ?? {}),
+    disablePlanarShadow: true,
+    disablePostOutlineDepth: true,
+  };
+}
+
+function prepareVfxMesh(mesh: Mesh): void {
+  mesh.isPickable = false;
+  mesh.checkCollisions = false;
+  mesh.receiveShadows = false;
+  mesh.metadata = {
+    ...((mesh.metadata as Record<string, unknown> | null) ?? {}),
+    disablePlanarShadow: true,
+    disablePostOutlineDepth: true,
+  };
+}
+
+function cleanupPlanarShadowArtifacts(scene: Scene): void {
+  for (const mesh of [...scene.meshes]) {
+    if (mesh.name.startsWith('player-upgrade.') && mesh.name.includes('_planarShadow')) {
+      mesh.dispose();
+    }
+  }
+
+  for (const node of [...scene.transformNodes]) {
+    if (node.name.startsWith('player-upgrade.') && node.name.includes('_shadow_root')) {
+      node.dispose();
+    }
+  }
+}
+
+function createGlowAura(scene: Scene, root: { getAbsolutePosition(): Vector3 }, params: PlayerUpgradeParams): { dispose(): void } {
+  const effectScale = Math.max(0.05, params.scale);
+  const color = params.color;
+  const glowHeight = Math.max(0.1, params.glowHeight) * effectScale;
+  const glowWidth = Math.max(0.05, params.glowWidth) * effectScale;
+  const glowIntensity = Math.max(0, params.glowIntensity);
+  const meshes: Mesh[] = [];
+  const materials: StandardMaterial[] = [];
+
+  for (let index = 0; index < 3; index += 1) {
+    const mesh = CreatePlane(`player-upgrade.soft-glow-column.${index}`, { size: 1 }, scene);
+    prepareVfxMesh(mesh);
+    mesh.parent = root as any;
+    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;
+
+    const material = new StandardMaterial(`player-upgrade.soft-glow-column-material.${index}`, scene);
+    configureTexturedGlowMaterial(material, color, getGlowTexture(scene), 2.8);
+    material.alpha = 0;
+    mesh.material = material;
+
+    meshes.push(mesh);
+    materials.push(material);
+  }
+
+  const halo = CreateDisc('player-upgrade.ground-halo', { radius: 1, tessellation: 96 }, scene);
+  prepareVfxMesh(halo);
+  halo.parent = root as any;
+  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;
+
+  const haloMaterial = new StandardMaterial('player-upgrade.ground-halo-material', scene);
+  configureTexturedGlowMaterial(haloMaterial, color, getHaloTexture(scene), 2.4);
+  haloMaterial.alpha = 0;
+  halo.material = haloMaterial;
+  meshes.push(halo);
+  materials.push(haloMaterial);
+
+  let age = 0;
+  let disposed = false;
+  const observer = scene.onBeforeRenderObservable.add(() => {
+    if (disposed) return;
+    const deltaSeconds = Math.min(0.05, scene.getEngine().getDeltaTime() / 1000);
+    age += deltaSeconds;
+    const lifetime = Math.max(0.2, params.lifetime);
+    const t = Math.min(1, age / lifetime);
+    const fadeIn = Math.min(1, t / 0.12);
+    const fadeOut = Math.max(0, 1 - Math.max(0, t - 0.72) / 0.28);
+    const pulse = 0.86 + Math.sin(age * 13) * 0.1 + Math.sin(age * 23) * 0.04;
+    const columnAlpha = Math.min(1, glowIntensity * params.opacity * 0.56 * fadeIn * fadeOut * pulse);
+    const haloAlpha = Math.min(1, glowIntensity * params.ringOpacity * 0.68 * fadeIn * fadeOut);
+
+    for (let index = 0; index < materials.length; index += 1) {
+      materials[index].alpha = index === materials.length - 1 ? haloAlpha : columnAlpha;
+    }
+
+    const haloRadius = glowWidth * 1.12 * (1 + easeOutCubic(t) * 0.34);
+    halo.scaling.set(haloRadius, haloRadius, 1);
+
+    if (age >= lifetime + 0.35) dispose();
+  });
+
+  function dispose(): void {
+    if (disposed) return;
+    disposed = true;
+    scene.onBeforeRenderObservable.remove(observer);
+    for (const mesh of meshes) mesh.dispose();
+    for (const material of materials) material.dispose();
+  }
+
+  return { dispose };
+}
+
+function createStrandSystem(scene: Scene, root: { getAbsolutePosition(): Vector3 }, params: PlayerUpgradeParams): ParticleSystem {
+  const effectScale = Math.max(0.05, params.scale);
+  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 strandRadius = Math.max(0, params.strandRadius) * effectScale;
+  const strandWidth = Math.max(0.001, params.strandWidth) * effectScale;
+
+  const system = new ParticleSystem('player-upgrade.gold-strands', Math.max(1, count), scene);
+  configureVfxParticleSystem(system);
+  system.particleTexture = getStrandTexture(scene);
+  system.particleTexture.hasAlpha = true;
+  system.emitter = root as any;
+  system.manualEmitCount = count;
+  system.emitRate = count * 60;
+  system.targetStopDuration = 0.05;
+  system.disposeOnStop = false;
+  system.blendMode = ParticleSystem.BLENDMODE_ADD;
+  system.minLifeTime = Math.max(0.12, params.lifetime * 0.52);
+  system.maxLifeTime = Math.max(system.minLifeTime + 0.01, params.lifetime * 0.95);
+  system.minSize = Math.max(0.04, strandLength * 0.42);
+  system.maxSize = Math.max(system.minSize, strandLength * 0.9);
+  system.minScaleX = strandWidth;
+  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.updateSpeed = 1 / 60;
+  system.color1 = toColor4(color, params.opacity * 0.72);
+  system.color2 = toColor4(bright, params.opacity);
+  system.colorDead = toColor4(color, 0);
+  system.addColorGradient(0, toColor4(color, 0));
+  system.addColorGradient(0.13, toColor4(bright, params.opacity));
+  system.addColorGradient(0.72, toColor4(color, params.opacity * 0.58));
+  system.addColorGradient(1, toColor4(color, 0));
+  system.addVelocityGradient(0, 1);
+  system.addVelocityGradient(0.66, 0.62);
+  system.addVelocityGradient(1, 0.16);
+
+  let positionIndex = 0;
+  let directionIndex = 0;
+  system.startPositionFunction = (worldMatrix, positionToUpdate, particle, isLocal) => {
+    const index = particle.id + positionIndex;
+    positionIndex += 1;
+    const angle = sequence01(index, 0) * Math.PI * 2;
+    const radius = Math.sqrt(sequence01(index, 1)) * strandRadius;
+    const local = new Vector3(
+      Math.cos(angle) * radius,
+      sequence01(index, 2) * 0.08 * effectScale,
+      Math.sin(angle) * radius,
+    );
+    if (isLocal) positionToUpdate.copyFrom(local);
+    else Vector3.TransformCoordinatesToRef(local, worldMatrix, positionToUpdate);
+  };
+  system.startDirectionFunction = (worldMatrix, directionToUpdate, particle, isLocal) => {
+    const index = particle.id + directionIndex;
+    directionIndex += 1;
+    const sway = strandRadius * 0.16;
+    const local = new Vector3(
+      (sequence01(index, 3) - 0.5) * sway,
+      0.86 + sequence01(index, 4) * 0.52,
+      (sequence01(index, 5) - 0.5) * sway,
+    );
+    if (isLocal) directionToUpdate.copyFrom(local);
+    else Vector3.TransformNormalToRef(local, worldMatrix, directionToUpdate);
+  };
+
+  return system;
+}
+
+function createStrandMeshes(scene: Scene, root: { getAbsolutePosition(): Vector3 }, params: PlayerUpgradeParams): { dispose(): void } {
+  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(0.005, 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: StrandMeshState[] = [];
+
+  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 as any;
+    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() / 1000);
+    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(): void {
+    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: Scene, root: { getAbsolutePosition(): Vector3 }, params: PlayerUpgradeParams): { dispose(): void } {
+  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(0.002, params.ringThickness * effectScale);
+  const color = params.color;
+  const states: RingState[] = [];
+
+  for (let index = 0; index < ringCount; index += 1) {
+    const mesh = CreateTorus(
+      `player-upgrade.expanding-ring.${index}`,
+      { diameter: 1, thickness, tessellation: 96 },
+      scene,
+    );
+    prepareVfxMesh(mesh);
+    mesh.parent = root as any;
+    mesh.position.y = 0.03 * effectScale + index * 0.012 * effectScale;
+    mesh.renderingGroupId = VFX_RENDERING_GROUP_ID;
+    mesh.isVisible = false;
+
+    const material = new StandardMaterial(`player-upgrade.ring-material.${index}`, scene);
+    configureGlowMaterial(material, color, 2.4);
+    material.alpha = 0;
+    mesh.material = material;
+
+    states.push({
+      mesh,
+      material,
+      startDelay: index * Math.max(0.02, params.ringInterval),
+      duration: ringDuration,
+    });
+  }
+
+  let age = 0;
+  let disposed = false;
+  const observer = scene.onBeforeRenderObservable.add(() => {
+    if (disposed) return;
+    const deltaSeconds = Math.min(0.05, scene.getEngine().getDeltaTime() / 1000);
+    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 eased = easeOutCubic(t);
+      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);
+      const ringColor = brighten(color, 0.1 + 0.08 * (1 - t));
+      state.material.diffuseColor = toColor3(ringColor);
+      state.material.emissiveColor = toGlowColor3(ringColor, 3.4);
+      state.material.alpha = Math.min(1, alpha * 1.45);
+    }
+    if (age >= getLastRingEndTime(params, ringDuration) + 0.1) dispose();
+  });
+
+  function dispose(): void {
+    if (disposed) return;
+    disposed = true;
+    scene.onBeforeRenderObservable.remove(observer);
+    for (const state of states) {
+      state.mesh.dispose();
+      state.material.dispose();
+    }
+  }
+
+  return { dispose };
+}
+
+function getStrandTexture(scene: Scene): DynamicTexture {
+  const existing = strandTextureByScene.get(scene);
+  if (existing) return existing;
+  const texture = new DynamicTexture('player_upgrade_gold_strand_texture', { width: 48, height: 192 }, scene, true);
+  const context = texture.getContext();
+  context.clearRect(0, 0, 48, 192);
+  const glow = context.createLinearGradient(0, 0, 0, 192);
+  glow.addColorStop(0, 'rgba(255,255,255,0)');
+  glow.addColorStop(0.18, 'rgba(255,255,255,0.9)');
+  glow.addColorStop(0.62, 'rgba(255,255,255,0.5)');
+  glow.addColorStop(1, 'rgba(255,255,255,0)');
+  context.fillStyle = glow;
+  context.fillRect(19, 0, 10, 192);
+  context.fillStyle = 'rgba(255,255,255,0.95)';
+  context.fillRect(23, 8, 2, 168);
+  texture.hasAlpha = true;
+  texture.update(false);
+  strandTextureByScene.set(scene, texture);
+  return texture;
+}
+
+function getGlowTexture(scene: Scene): DynamicTexture {
+  const existing = glowTextureByScene.get(scene);
+  if (existing) return existing;
+
+  const texture = new DynamicTexture('player_upgrade_soft_glow_texture', { width: 256, height: 512 }, scene, true);
+  const context = texture.getContext();
+  context.clearRect(0, 0, 256, 512);
+
+  const vertical = context.createLinearGradient(0, 0, 0, 512);
+  vertical.addColorStop(0, 'rgba(255,255,255,0)');
+  vertical.addColorStop(0.16, 'rgba(255,255,255,0.28)');
+  vertical.addColorStop(0.46, 'rgba(255,255,255,0.72)');
+  vertical.addColorStop(0.78, 'rgba(255,255,255,0.22)');
+  vertical.addColorStop(1, 'rgba(255,255,255,0)');
+  context.fillStyle = vertical;
+  context.fillRect(0, 0, 256, 512);
+
+  const radial = context.createRadialGradient(128, 262, 6, 128, 262, 120);
+  radial.addColorStop(0, 'rgba(255,255,255,1)');
+  radial.addColorStop(0.18, 'rgba(255,255,255,0.76)');
+  radial.addColorStop(0.48, 'rgba(255,255,255,0.22)');
+  radial.addColorStop(1, 'rgba(255,255,255,0)');
+  const compositeContext = context as unknown as CanvasRenderingContext2D;
+  compositeContext.globalCompositeOperation = 'destination-in';
+  context.fillStyle = radial;
+  context.fillRect(0, 0, 256, 512);
+  compositeContext.globalCompositeOperation = 'source-over';
+
+  texture.hasAlpha = true;
+  texture.update(false);
+  glowTextureByScene.set(scene, texture);
+  return texture;
+}
+
+function getHaloTexture(scene: Scene): DynamicTexture {
+  const existing = haloTextureByScene.get(scene);
+  if (existing) return existing;
+
+  const texture = new DynamicTexture('player_upgrade_ground_halo_texture', { width: 256, height: 256 }, scene, true);
+  const context = texture.getContext();
+  context.clearRect(0, 0, 256, 256);
+
+  const halo = context.createRadialGradient(128, 128, 18, 128, 128, 128);
+  halo.addColorStop(0, 'rgba(255,255,255,0.74)');
+  halo.addColorStop(0.34, 'rgba(255,255,255,0.42)');
+  halo.addColorStop(0.58, 'rgba(255,255,255,0.16)');
+  halo.addColorStop(0.76, 'rgba(255,255,255,0.04)');
+  halo.addColorStop(1, 'rgba(255,255,255,0)');
+  context.fillStyle = halo;
+  context.fillRect(0, 0, 256, 256);
+
+  texture.hasAlpha = true;
+  texture.update(false);
+  haloTextureByScene.set(scene, texture);
+  return texture;
+}
+
+function getDisposeDelaySeconds(params: PlayerUpgradeParams): number {
+  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;
+}
+
+function getLastRingEndTime(params: PlayerUpgradeParams, ringDuration: number): number {
+  return Math.max(0, Math.round(params.ringCount) - 1) * Math.max(0.02, params.ringInterval) + ringDuration;
+}
+
+function toColor4(color: VfxColorValue, alpha: number): Color4 {
+  return new Color4(clamp01(color.r), clamp01(color.g), clamp01(color.b), clamp01(alpha));
+}
+
+function toColor3(color: VfxColorValue): Color3 {
+  return new Color3(clamp01(color.r), clamp01(color.g), clamp01(color.b));
+}
+
+function toGlowColor3(color: VfxColorValue, intensity: number): Color3 {
+  return new Color3(
+    Math.max(0, color.r * intensity),
+    Math.max(0, color.g * intensity),
+    Math.max(0, color.b * intensity),
+  );
+}
+
+function configureGlowMaterial(material: StandardMaterial, color: VfxColorValue, intensity: number): void {
+  material.disableLighting = true;
+  material.backFaceCulling = false;
+  material.diffuseColor = toColor3(color);
+  material.emissiveColor = toGlowColor3(color, intensity);
+  material.specularColor = Color3.Black();
+  material.alphaMode = Constants.ALPHA_ADD;
+  material.transparencyMode = StandardMaterial.MATERIAL_ALPHABLEND;
+}
+
+function configureTexturedGlowMaterial(
+  material: StandardMaterial,
+  color: VfxColorValue,
+  texture: DynamicTexture,
+  intensity: number,
+): void {
+  configureGlowMaterial(material, color, intensity);
+  material.diffuseTexture = texture;
+  material.opacityTexture = texture;
+  material.useAlphaFromDiffuseTexture = true;
+}
+
+function brighten(color: VfxColorValue, amount: number): VfxColorValue {
+  return {
+    r: lerp(color.r, 1, amount),
+    g: lerp(color.g, 1, amount),
+    b: lerp(color.b, 1, amount),
+  };
+}
+
+function easeOutCubic(t: number): number {
+  return 1 - (1 - t) ** 3;
+}
+
+function lerp(min: number, max: number, t: number): number {
+  return min + (max - min) * t;
+}
+
+function clamp01(value: number): number {
+  return Math.min(1, Math.max(0, value));
+}
+
+function fract(value: number): number {
+  return value - Math.floor(value);
+}
+
+function sequence01(index: number, axis: number): number {
+  if (index === 0) return 0.5;
+  const strides = [0.618033988749895, 0.414213562373095, 0.732050807568877, 0.324717957244746, 0.754877666246693, 0.569840290998053];
+  return fract(0.5 + index * strides[axis % strides.length] + axis * 0.173205080756888);
+}

package/packages/effects/player-upgrade/vfx-params.json

@@ -0,0 +1,28 @@
+{
+  "__generation.offsetX": 0,
+  "__generation.offsetY": 0,
+  "__generation.offsetZ": 0,
+  "lifetime": 1,
+  "scale": 1,
+  "initialHeight": 0.02,
+  "color": {
+    "r": 1,
+    "g": 0.7803921568627451,
+    "b": 0.0784313725490196
+  },
+  "opacity": 1,
+  "strandCount": 120,
+  "strandLength": 1,
+  "strandHeight": 1.55,
+  "strandRadius": 0.58,
+  "strandWidth": 0.03,
+  "riseSpeed": 5,
+  "ringCount": 2,
+  "ringMaxRadius": 2.15,
+  "ringThickness": 0.05,
+  "ringInterval": 0.28,
+  "ringOpacity": 1,
+  "glowIntensity": 1.85,
+  "glowHeight": 2.15,
+  "glowWidth": 2
+}