@fps-games/vfx 0.1.1

package/dist/chunks/wood-sawdust-effect-factory-DlETNaBn.js

@@ -0,0 +1,129 @@
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { s as startLegacyParticleRuntime, c as cloneLegacyEmitters, f as findEmitter, a as setNestedValue } from "./legacy-particle-runtime-CbJYVxdd.js";
+function createWoodSawdustEffectPackage(config) {
+  return {
+    id: config.id,
+    nameZh: config.nameZh,
+    manifest: config.manifest,
+    defaultParams: config.defaultParams,
+    debugAnchor: "playerRight",
+    debugParams: [
+      { key: "lifetime", label: "生命周期", kind: "lifetime", min: 0.08, max: 4, step: 0.01 },
+      { key: "scale", label: "整体缩放", kind: "scale", min: 0.1, max: 4, step: 0.01 },
+      { key: "initialHeight", label: "初始高度", kind: "number", min: -1, max: 3, step: 0.01 },
+      { key: "dustCount", label: "木粉数量", kind: "number", min: 1, max: 180, step: 1 },
+      { key: "fragmentCount", label: config.fragmentCountLabel, kind: "number", min: 0, max: 90, step: 1 },
+      { key: "dustColor", label: "木粉颜色", kind: "color" },
+      { key: "fragmentColor", label: config.fragmentColorLabel, kind: "color" },
+      { key: "dustSize", label: "木粉大小", kind: "number", min: 0.2, max: 4, step: 0.01 },
+      { key: "fragmentSize", label: config.fragmentSizeLabel, kind: "number", min: 0.2, max: 4, step: 0.01 },
+      { key: "dustLifetime", label: "木粉生命周期", kind: "lifetime", min: 0.08, max: 3, step: 0.01 },
+      { key: "fragmentLifetime", label: `${config.fragmentLabel}生命周期`, kind: "lifetime", min: 0.08, max: 2, step: 0.01 },
+      { key: "dustSpeed", label: "木粉喷散速度", kind: "number", min: 0, max: 4, step: 0.01 },
+      { key: "fragmentSpeed", label: config.fragmentSpeedLabel, kind: "number", min: 0, max: 8, step: 0.01 },
+      { key: "fragmentSpread", label: config.fragmentSpreadLabel, kind: "number", min: 0, max: 4, step: 0.01 }
+    ],
+    create({ scene, root, position, params }) {
+      root.position.copyFrom(position).addInPlace(new Vector3(0, params.initialHeight, 0));
+      const emitters = buildEmitters(config, params, root.position);
+      const runtime = startLegacyParticleRuntime({
+        scene,
+        runtimeUrl: config.runtimeUrl,
+        emitters,
+        assetUrls: config.assetUrls,
+        onError: (error) => console.error(`[VFX:${config.id}] legacy particle runtime failed`, error)
+      });
+      let disposed = false;
+      const disposeDelay = getDisposeDelaySeconds(params);
+      const disposeTimer = window.setTimeout(() => disposeAll(), disposeDelay * 1e3);
+      return {
+        root,
+        dispose() {
+          disposeAll();
+        }
+      };
+      function disposeAll() {
+        if (disposed) return;
+        disposed = true;
+        window.clearTimeout(disposeTimer);
+        runtime.dispose();
+        root.dispose();
+      }
+    }
+  };
+}
+function buildEmitters(config, params, origin) {
+  const emitters = cloneLegacyEmitters(config.sourceEmitters);
+  const dust = findEmitter(emitters, config.dustEmitterName);
+  const fragment = findEmitter(emitters, config.fragmentEmitterName);
+  if (dust) {
+    applyCommonEmitterParams(dust, origin, params.scale, params.lifetime);
+    setNestedValue(dust, "manualEmitCount", Math.round(params.dustCount));
+    setNestedValue(dust, "renderColor.color", toLegacyColor(params.dustColor));
+    scaleEmitterSize(dust, params.dustSize);
+    scaleMaxLifetime(dust, params.dustLifetime);
+    setNestedValue(dust, "maxEmitPower", params.dustSpeed);
+  }
+  if (fragment) {
+    applyCommonEmitterParams(fragment, origin, params.scale, params.lifetime);
+    setNestedValue(fragment, "manualEmitCount", Math.round(params.fragmentCount));
+    setNestedValue(fragment, "renderColor.color", toLegacyColor(params.fragmentColor));
+    scaleEmitterSize(fragment, params.fragmentSize);
+    scaleMaxLifetime(fragment, params.fragmentLifetime);
+    setNestedValue(fragment, "maxEmitPower", params.fragmentSpeed);
+    scaleShapeSpread(fragment, params.fragmentSpread);
+  }
+  return emitters;
+}
+function applyCommonEmitterParams(emitter, origin, scale, lifetime) {
+  setNestedValue(emitter, "origin", { x: origin.x, y: origin.y, z: origin.z });
+  setNestedValue(emitter, "effectScale", scale);
+  setNestedValue(emitter, "runtime.stopAfterSeconds", Math.max(0.08, lifetime));
+}
+function scaleEmitterSize(emitter, sizeScale) {
+  const baseMin = readNumber(emitter.minSize, 0.05);
+  const baseMax = readNumber(emitter.maxSize, baseMin);
+  emitter.minSize = baseMin * sizeScale;
+  emitter.maxSize = baseMax * sizeScale;
+}
+function scaleMaxLifetime(emitter, maxLifeTime) {
+  const baseMin = readNumber(emitter.minLifeTime, maxLifeTime * 0.55);
+  const baseMax = Math.max(baseMin, readNumber(emitter.maxLifeTime, maxLifeTime));
+  const ratio = baseMax > 0 ? baseMin / baseMax : 0.55;
+  emitter.minLifeTime = Math.max(0.02, maxLifeTime * ratio);
+  emitter.maxLifeTime = Math.max(emitter.minLifeTime, maxLifeTime);
+}
+function scaleShapeSpread(emitter, spread) {
+  scaleVectorAxes(emitter, "shape.direction1", spread);
+  scaleVectorAxes(emitter, "shape.direction2", spread);
+}
+function scaleVectorAxes(emitter, path, scale) {
+  const vector = readNestedObject(emitter, path);
+  if (!vector) return;
+  setNestedValue(emitter, path, {
+    ...vector,
+    x: readNumber(vector.x, 0) * scale,
+    z: readNumber(vector.z, 0) * scale
+  });
+}
+function readNestedObject(target, path) {
+  let cursor = target;
+  for (const part of path.split(".")) {
+    if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) return null;
+    cursor = cursor[part];
+  }
+  return cursor && typeof cursor === "object" && !Array.isArray(cursor) ? cursor : null;
+}
+function toLegacyColor(color) {
+  return { r: color.r, g: color.g, b: color.b, a: 1 };
+}
+function getDisposeDelaySeconds(params) {
+  return Math.max(0.08, params.lifetime) + Math.max(0.08, params.dustLifetime, params.fragmentLifetime) + 0.3;
+}
+function readNumber(value, fallback) {
+  const next = Number(value);
+  return Number.isFinite(next) ? next : fallback;
+}
+export {
+  createWoodSawdustEffectPackage as c
+};

package/dist/effects/building-upgrade/effect.json.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+  "id": "building-upgrade",
+  "nameZh": "建筑升级金光",
+  "source": "runtime-generated",
+  "assets": []
+}
+;
+
+export default _default;

package/dist/effects/building-upgrade/index.d.ts

@@ -0,0 +1,20 @@
+import { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+interface BuildingUpgradeParams extends VfxParamValues {
+    lifetime: number;
+    scale: number;
+    initialHeight: number;
+    color: VfxColorValue;
+    opacity: number;
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+    centerCount: number;
+    outlineCount: number;
+    strandWidth: number;
+    riseSpeed: number;
+    centerSpread: number;
+    outlineThickness: number;
+    glowOpacity: number;
+}
+export declare const buildingUpgradeEffectPackage: VfxEffectPackage<BuildingUpgradeParams>;
+export {};

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

@@ -0,0 +1,337 @@
+import { Color4 } from "@babylonjs/core/Maths/math.color";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { DynamicTexture } from "@babylonjs/core/Materials/Textures/dynamicTexture";
+import { ParticleSystem } from "@babylonjs/core/Particles/particleSystem";
+import { c as configureVfxParticleSystem } from "../../chunks/rendering-CV3nhygX.js";
+const id = "building-upgrade";
+const nameZh = "建筑升级金光";
+const source = "runtime-generated";
+const assets = [];
+const manifest = {
+  id,
+  nameZh,
+  source,
+  assets
+};
+const BASE_FOOTPRINT_X = 3.2;
+const BASE_FOOTPRINT_Z = 2.6;
+const BASE_CENTER_HEIGHT = 2.2;
+const BASE_OUTLINE_HEIGHT = 3.1;
+const BASE_GLOW_THICKNESS = 0.38;
+const DEFAULT_PARAMS = {
+  lifetime: 1.8,
+  scale: 1,
+  initialHeight: 0.02,
+  color: { r: 1, g: 0.84, b: 0.12 },
+  opacity: 1,
+  scaleX: 1,
+  scaleY: 1,
+  scaleZ: 1,
+  centerCount: 46,
+  outlineCount: 150,
+  strandWidth: 0.035,
+  riseSpeed: 1.15,
+  centerSpread: 0.92,
+  outlineThickness: 0.18,
+  glowOpacity: 0.62
+};
+const buildingUpgradeEffectPackage = {
+  id: "building-upgrade",
+  nameZh: "建筑升级金光",
+  manifest,
+  defaultParams: DEFAULT_PARAMS,
+  debugAnchor: "playerRight",
+  debugParams: [
+    { key: "lifetime", label: "生命周期", kind: "lifetime", min: 0.2, max: 6, step: 0.01 },
+    { key: "scale", label: "整体缩放", kind: "scale", min: 0.1, max: 6, 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: "scaleX", label: "X 轴缩放", kind: "number", min: 0.1, max: 6, step: 0.01 },
+    { key: "scaleY", label: "Y 轴缩放", kind: "number", min: 0.1, max: 6, step: 0.01 },
+    { key: "scaleZ", label: "Z 轴缩放", kind: "number", min: 0.1, max: 6, step: 0.01 },
+    { key: "centerCount", label: "中心金丝数量", kind: "number", min: 0, max: 240, step: 1 },
+    { key: "outlineCount", label: "轮廓金丝数量", kind: "number", min: 0, max: 420, step: 1 },
+    { key: "strandWidth", label: "金丝粗细", kind: "number", min: 5e-3, max: 0.2, step: 1e-3 },
+    { key: "riseSpeed", label: "上升速度", kind: "number", min: 0, max: 5, step: 0.01 },
+    { key: "centerSpread", label: "中心散布", kind: "number", min: 0, max: 1.5, step: 0.01 },
+    { key: "outlineThickness", label: "轮廓厚度", kind: "number", min: 0, max: 1, step: 0.01 },
+    { key: "glowOpacity", label: "光芒强度", kind: "opacity", min: 0, max: 1, step: 0.01 }
+  ],
+  create({ scene, root, position, params }) {
+    root.position.copyFrom(position).addInPlace(new Vector3(0, params.initialHeight, 0));
+    const centerStrands = createStrandSystem(scene, root, params, "center");
+    const outlineStrands = createStrandSystem(scene, root, params, "outline");
+    const glow = createOutlineGlow(scene, root, params);
+    const disposeTimer = window.setTimeout(
+      () => disposeAll(),
+      Math.max(0.05, params.lifetime + getMaxStrandHeight(params) / Math.max(0.1, params.riseSpeed) * 0.18 + 0.45) * 1e3
+    );
+    let disposed = false;
+    centerStrands.start();
+    outlineStrands.start();
+    glow.start();
+    return {
+      root,
+      dispose() {
+        disposeAll();
+      }
+    };
+    function disposeAll() {
+      if (disposed) return;
+      disposed = true;
+      window.clearTimeout(disposeTimer);
+      centerStrands.dispose(false);
+      outlineStrands.dispose(false);
+      glow.dispose(false);
+      root.dispose();
+    }
+  }
+};
+function createStrandSystem(scene, root, params, mode) {
+  const count = Math.max(0, Math.round(mode === "center" ? params.centerCount : params.outlineCount));
+  const system = new ParticleSystem(`building-upgrade.${mode}-strands`, Math.max(1, count), scene);
+  const color = params.color;
+  const height = mode === "center" ? getCenterHeight(params) : getOutlineHeight(params);
+  const width = params.strandWidth * getHorizontalScale(params) * (mode === "center" ? 1.35 : 0.92);
+  configureVfxParticleSystem(system);
+  system.particleTexture = getGoldStrandTexture(scene);
+  system.emitter = root;
+  system.manualEmitCount = count;
+  system.emitRate = count * 60;
+  system.targetStopDuration = 0.04;
+  system.disposeOnStop = false;
+  system.updateSpeed = 1 / 60;
+  system.minLifeTime = Math.max(0.12, params.lifetime * (mode === "center" ? 0.48 : 0.62));
+  system.maxLifeTime = Math.max(system.minLifeTime + 0.01, params.lifetime * (mode === "center" ? 0.86 : 1.08));
+  system.minSize = Math.max(0.01, height * 0.34);
+  system.maxSize = Math.max(system.minSize, height * (mode === "center" ? 0.72 : 0.98));
+  system.minScaleX = Math.max(0.02, width);
+  system.maxScaleX = Math.max(system.minScaleX, width * 1.8);
+  system.minScaleY = 1;
+  system.maxScaleY = mode === "center" ? 1.45 : 1.75;
+  system.minEmitPower = Math.max(0.01, params.riseSpeed * getVerticalScale(params) * (mode === "center" ? 0.5 : 0.7));
+  system.maxEmitPower = Math.max(system.minEmitPower, params.riseSpeed * getVerticalScale(params) * (mode === "center" ? 1.15 : 1.65));
+  system.gravity = new Vector3(0, 0.38 * getVerticalScale(params), 0);
+  system.blendMode = ParticleSystem.BLENDMODE_ADD;
+  system.color1 = toColor4(color, params.opacity * (mode === "center" ? 0.72 : 0.86));
+  system.color2 = toColor4({ r: 1, g: 0.98, b: 0.52 }, params.opacity);
+  system.colorDead = toColor4(color, 0);
+  system.addColorGradient(0, toColor4(color, 0));
+  system.addColorGradient(0.12, toColor4({ r: 1, g: 0.96, b: 0.42 }, params.opacity));
+  system.addColorGradient(0.72, toColor4(color, params.opacity * 0.62));
+  system.addColorGradient(1, toColor4(color, 0));
+  system.addVelocityGradient(0, 1);
+  system.addVelocityGradient(0.65, 0.55);
+  system.addVelocityGradient(1, 0.12);
+  let positionIndex = 0;
+  let directionIndex = 0;
+  system.startPositionFunction = (worldMatrix, positionToUpdate, particle, isLocal) => {
+    const index = particle.id + positionIndex;
+    positionIndex += 1;
+    const local = mode === "center" ? sampleCenterPosition(index, params) : sampleOutlinePosition(index, params);
+    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 = (mode === "center" ? 0.22 : 0.12) * getHorizontalScale(params);
+    const local = new Vector3(
+      (sequence01(index, 4) - 0.5) * sway,
+      0.8 + sequence01(index, 5) * 0.65,
+      (sequence01(index, 6) - 0.5) * sway
+    );
+    if (isLocal) directionToUpdate.copyFrom(local);
+    else Vector3.TransformNormalToRef(local, worldMatrix, directionToUpdate);
+  };
+  return system;
+}
+function createOutlineGlow(scene, root, params) {
+  const count = Math.max(1, Math.round(params.outlineCount * 0.82));
+  const system = new ParticleSystem("building-upgrade.outline-glow-rays", count, scene);
+  const height = getOutlineHeight(params) * 1.06;
+  const glowWidth = Math.max(0.04, BASE_GLOW_THICKNESS * getHorizontalScale(params));
+  const alpha = params.glowOpacity * params.opacity;
+  configureVfxParticleSystem(system);
+  system.particleTexture = getOutlineGlowTexture(scene);
+  system.emitter = root;
+  system.manualEmitCount = count;
+  system.emitRate = count * 60;
+  system.targetStopDuration = 0.04;
+  system.disposeOnStop = false;
+  system.updateSpeed = 1 / 60;
+  system.minLifeTime = Math.max(0.12, params.lifetime * 0.62);
+  system.maxLifeTime = Math.max(system.minLifeTime + 0.01, params.lifetime * 1.08);
+  system.minSize = Math.max(0.01, height * 0.42);
+  system.maxSize = Math.max(system.minSize, height * 1.08);
+  system.minScaleX = glowWidth * 0.42;
+  system.maxScaleX = glowWidth * 1.18;
+  system.minScaleY = 1.05;
+  system.maxScaleY = 1.75;
+  system.minEmitPower = Math.max(0.01, params.riseSpeed * getVerticalScale(params) * 0.58);
+  system.maxEmitPower = Math.max(system.minEmitPower, params.riseSpeed * getVerticalScale(params) * 1.38);
+  system.gravity = new Vector3(0, 0.3 * getVerticalScale(params), 0);
+  system.blendMode = ParticleSystem.BLENDMODE_ADD;
+  system.color1 = toColor4(params.color, alpha * 0.62);
+  system.color2 = toColor4({ r: 1, g: 0.98, b: 0.58 }, alpha * 0.86);
+  system.colorDead = toColor4(params.color, 0);
+  system.addColorGradient(0, toColor4(params.color, 0));
+  system.addColorGradient(0.1, toColor4({ r: 1, g: 0.96, b: 0.48 }, alpha * 0.82));
+  system.addColorGradient(0.56, toColor4(params.color, alpha * 0.52));
+  system.addColorGradient(1, toColor4(params.color, 0));
+  system.addVelocityGradient(0, 1);
+  system.addVelocityGradient(0.65, 0.52);
+  system.addVelocityGradient(1, 0.12);
+  let positionIndex = 0;
+  let directionIndex = 0;
+  system.startPositionFunction = (worldMatrix, positionToUpdate, particle, isLocal) => {
+    const index = particle.id + positionIndex + 31;
+    positionIndex += 1;
+    const local = sampleOutlinePosition(index, params);
+    if (isLocal) positionToUpdate.copyFrom(local);
+    else Vector3.TransformCoordinatesToRef(local, worldMatrix, positionToUpdate);
+  };
+  system.startDirectionFunction = (worldMatrix, directionToUpdate, particle, isLocal) => {
+    const index = particle.id + directionIndex + 31;
+    directionIndex += 1;
+    const sway = 0.08 * getHorizontalScale(params);
+    const local = new Vector3(
+      (sequence01(index, 4) - 0.5) * sway,
+      0.82 + sequence01(index, 5) * 0.58,
+      (sequence01(index, 6) - 0.5) * sway
+    );
+    if (isLocal) directionToUpdate.copyFrom(local);
+    else Vector3.TransformNormalToRef(local, worldMatrix, directionToUpdate);
+  };
+  return system;
+}
+function sampleCenterPosition(index, params) {
+  const angle = sequence01(index, 0) * Math.PI * 2;
+  const radius = Math.sqrt(0.16 + sequence01(index, 1) * 0.84);
+  const xRadius = getFootprintX(params) * 0.5 * params.centerSpread;
+  const zRadius = getFootprintZ(params) * 0.5 * params.centerSpread;
+  const jitterX = (sequence01(index, 7) - 0.5) * xRadius * 0.18;
+  const jitterZ = (sequence01(index, 8) - 0.5) * zRadius * 0.18;
+  const x = Math.cos(angle) * radius * xRadius + jitterX;
+  const z = Math.sin(angle) * radius * zRadius + jitterZ;
+  const y = sequence01(index, 2) * 0.12 * getVerticalScale(params);
+  return new Vector3(x, y, z);
+}
+function sampleOutlinePosition(index, params) {
+  const width = getFootprintX(params);
+  const depth = getFootprintZ(params);
+  const perimeter = Math.max(1e-3, width * 2 + depth * 2);
+  const distance = sequence01(index, 0) * perimeter;
+  const jitter = (sequence01(index, 1) - 0.5) * params.outlineThickness * getHorizontalScale(params);
+  const y = sequence01(index, 2) * 0.16 * getVerticalScale(params);
+  if (distance < width) return new Vector3(-width * 0.5 + distance, y, -depth * 0.5 + jitter);
+  if (distance < width + depth) return new Vector3(width * 0.5 + jitter, y, -depth * 0.5 + distance - width);
+  if (distance < width * 2 + depth) return new Vector3(width * 0.5 - (distance - width - depth), y, depth * 0.5 + jitter);
+  return new Vector3(-width * 0.5 + jitter, y, depth * 0.5 - (distance - width * 2 - depth));
+}
+function getFootprintX(params) {
+  return BASE_FOOTPRINT_X * Math.max(0.05, params.scale) * Math.max(0.05, params.scaleX);
+}
+function getFootprintZ(params) {
+  return BASE_FOOTPRINT_Z * Math.max(0.05, params.scale) * Math.max(0.05, params.scaleZ);
+}
+function getVerticalScale(params) {
+  return Math.max(0.05, params.scale) * Math.max(0.05, params.scaleY);
+}
+function getHorizontalScale(params) {
+  return Math.max(0.05, params.scale) * Math.max(0.05, (params.scaleX + params.scaleZ) * 0.5);
+}
+function getCenterHeight(params) {
+  return BASE_CENTER_HEIGHT * getVerticalScale(params);
+}
+function getOutlineHeight(params) {
+  return BASE_OUTLINE_HEIGHT * getVerticalScale(params);
+}
+function getMaxStrandHeight(params) {
+  return Math.max(getCenterHeight(params), getOutlineHeight(params));
+}
+function getGoldStrandTexture(scene) {
+  const key = "__vfx_building_upgrade_gold_strand_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("building_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, 250, 156, 0)");
+  glow.addColorStop(0.18, "rgba(255, 239, 84, 0.92)");
+  glow.addColorStop(0.62, "rgba(255, 210, 28, 0.52)");
+  glow.addColorStop(1, "rgba(255, 181, 0, 0)");
+  context.fillStyle = glow;
+  context.fillRect(19, 0, 10, 192);
+  context.fillStyle = "rgba(255, 255, 225, 0.95)";
+  context.fillRect(23, 8, 2, 168);
+  const halo = context.createRadialGradient(24, 64, 0, 24, 64, 24);
+  halo.addColorStop(0, "rgba(255, 239, 96, 0.5)");
+  halo.addColorStop(1, "rgba(255, 199, 0, 0)");
+  context.fillStyle = halo;
+  context.fillRect(0, 16, 48, 96);
+  texture.hasAlpha = true;
+  texture.update(false);
+  metadata[key] = texture;
+  return texture;
+}
+function getOutlineGlowTexture(scene) {
+  const key = "__vfx_building_upgrade_outline_glow_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("building_upgrade_outline_glow_texture", { width: 96, height: 192 }, scene, true);
+  const context = texture.getContext();
+  const compositeContext = context;
+  context.clearRect(0, 0, 96, 192);
+  const sideFade = context.createLinearGradient(0, 0, 96, 0);
+  sideFade.addColorStop(0, "rgba(255, 204, 0, 0)");
+  sideFade.addColorStop(0.28, "rgba(255, 220, 38, 0.36)");
+  sideFade.addColorStop(0.5, "rgba(255, 246, 142, 0.78)");
+  sideFade.addColorStop(0.72, "rgba(255, 220, 38, 0.36)");
+  sideFade.addColorStop(1, "rgba(255, 204, 0, 0)");
+  const verticalFade = context.createLinearGradient(0, 0, 0, 192);
+  verticalFade.addColorStop(0, "rgba(255, 244, 115, 0)");
+  verticalFade.addColorStop(0.16, "rgba(255, 236, 72, 0.65)");
+  verticalFade.addColorStop(0.55, "rgba(255, 212, 22, 0.46)");
+  verticalFade.addColorStop(1, "rgba(255, 174, 0, 0)");
+  context.fillStyle = sideFade;
+  context.fillRect(0, 0, 96, 192);
+  compositeContext.globalCompositeOperation = "source-in";
+  context.fillStyle = verticalFade;
+  context.fillRect(0, 0, 96, 192);
+  compositeContext.globalCompositeOperation = "source-over";
+  const core = context.createLinearGradient(0, 0, 0, 192);
+  core.addColorStop(0, "rgba(255, 255, 214, 0)");
+  core.addColorStop(0.22, "rgba(255, 255, 214, 0.64)");
+  core.addColorStop(0.66, "rgba(255, 231, 82, 0.28)");
+  core.addColorStop(1, "rgba(255, 185, 0, 0)");
+  context.fillStyle = core;
+  context.fillRect(44, 8, 8, 166);
+  texture.hasAlpha = true;
+  texture.update(false);
+  metadata[key] = texture;
+  return texture;
+}
+function toColor4(color, alpha) {
+  return new Color4(clamp01(color.r), clamp01(color.g), clamp01(color.b), clamp01(alpha));
+}
+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 {
+  buildingUpgradeEffectPackage
+};

package/dist/effects/character-entrance/effect.json.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+  "id": "character-entrance",
+  "nameZh": "人物登场光柱",
+  "source": "runtime-generated",
+  "assets": []
+}
+;
+
+export default _default;

package/dist/effects/character-entrance/index.d.ts

@@ -0,0 +1,18 @@
+import { VfxColorValue, VfxEffectPackage, VfxParamValues } from '../../types';
+interface CharacterEntranceParams extends VfxParamValues {
+    lifetime: number;
+    scale: number;
+    initialHeight: number;
+    offsetX: number;
+    offsetZ: number;
+    color: VfxColorValue;
+    opacity: number;
+    radius: number;
+    height: number;
+    beamWidth: number;
+    riseSpeed: number;
+    ringOpacity: number;
+    fadeStart: number;
+}
+export declare const characterEntranceEffectPackage: VfxEffectPackage<CharacterEntranceParams>;
+export {};