@fps-games/vfx 0.1.1

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

@@ -0,0 +1,539 @@
+import { Color4, Color3 } 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 { ParticleSystem } from "@babylonjs/core/Particles/particleSystem";
+import { c as configureVfxParticleSystem, V as VFX_RENDERING_GROUP_ID } from "../../chunks/rendering-CV3nhygX.js";
+const id = "player-upgrade";
+const nameZh = "人物升级光效";
+const source = "runtime-generated";
+const assets = [];
+const manifest = {
+  id,
+  nameZh,
+  source,
+  assets
+};
+const strandTextureByScene = /* @__PURE__ */ new WeakMap();
+const glowTextureByScene = /* @__PURE__ */ new WeakMap();
+const haloTextureByScene = /* @__PURE__ */ new WeakMap();
+const DEFAULT_PARAMS = {
+  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
+};
+const playerUpgradeEffectPackage = {
+  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: 5e-3, max: 0.2, step: 1e-3 },
+    { 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: 5e-3, max: 0.3, step: 1e-3 },
+    { 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) * 1e3);
+    strands.start();
+    return {
+      root,
+      dispose() {
+        disposeAll();
+      }
+    };
+    function disposeAll() {
+      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) {
+  const target = root;
+  target.metadata = {
+    ...target.metadata ?? {},
+    disablePlanarShadow: true,
+    disablePostOutlineDepth: true
+  };
+}
+function prepareVfxMesh(mesh) {
+  mesh.isPickable = false;
+  mesh.checkCollisions = false;
+  mesh.receiveShadows = false;
+  mesh.metadata = {
+    ...mesh.metadata ?? {},
+    disablePlanarShadow: true,
+    disablePostOutlineDepth: true
+  };
+}
+function cleanupPlanarShadowArtifacts(scene) {
+  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, root, params) {
+  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 = [];
+  const materials = [];
+  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;
+    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;
+  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() / 1e3);
+    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() {
+    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, root, params) {
+  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(1e-3, 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;
+  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, 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) {
+  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(
+      `player-upgrade.expanding-ring.${index}`,
+      { diameter: 1, thickness, tessellation: 96 },
+      scene
+    );
+    prepareVfxMesh(mesh);
+    mesh.parent = root;
+    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() / 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 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() {
+    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) {
+  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) {
+  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;
+  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) {
+  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) {
+  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, ringDuration) {
+  return Math.max(0, Math.round(params.ringCount) - 1) * Math.max(0.02, params.ringInterval) + ringDuration;
+}
+function toColor4(color, alpha) {
+  return new Color4(clamp01(color.r), clamp01(color.g), clamp01(color.b), clamp01(alpha));
+}
+function toColor3(color) {
+  return new Color3(clamp01(color.r), clamp01(color.g), clamp01(color.b));
+}
+function toGlowColor3(color, intensity) {
+  return new Color3(
+    Math.max(0, color.r * intensity),
+    Math.max(0, color.g * intensity),
+    Math.max(0, color.b * intensity)
+  );
+}
+function configureGlowMaterial(material, color, intensity) {
+  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, color, texture, intensity) {
+  configureGlowMaterial(material, color, intensity);
+  material.diffuseTexture = texture;
+  material.opacityTexture = texture;
+  material.useAlphaFromDiffuseTexture = true;
+}
+function brighten(color, amount) {
+  return {
+    r: lerp(color.r, 1, amount),
+    g: lerp(color.g, 1, amount),
+    b: lerp(color.b, 1, amount)
+  };
+}
+function easeOutCubic(t) {
+  return 1 - (1 - t) ** 3;
+}
+function lerp(min, max, t) {
+  return min + (max - min) * t;
+}
+function clamp01(value) {
+  return Math.min(1, Math.max(0, value));
+}
+function fract(value) {
+  return value - Math.floor(value);
+}
+function sequence01(index, axis) {
+  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);
+}
+export {
+  playerUpgradeEffectPackage
+};

package/dist/effects/pulse-laser-volley/index.d.ts

@@ -0,0 +1,17 @@
+import { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+interface PulseLaserParams extends VfxParamValues {
+    lifetimeMode: string;
+    lifetime: number;
+    targetDistance: number;
+    volleyInterval: number;
+    boltSpeed: number;
+    boltsPerVolley: number;
+    boltSpacing: number;
+    boltLen: number;
+    boltColor: VfxColorValue;
+    boltCore: number;
+    boltCorePow: number;
+    boltBright: number;
+}
+export declare const pulseLaserVolleyEffectPackage: VfxEffectPackage<PulseLaserParams>;
+export {};