@fps-games/vfx 0.3.16 → 0.3.18

package/CHANGELOG.md

@@ -12,6 +12,16 @@
 
 <!-- release.mjs 在此行下方插入新版本区块 -->
 
+## v0.3.18 — 2026-07-14
+
+### 改动
+- fix(tooling): support validation on Windows
+- feat(energy-shield): align dome shader rendering
+- feat(energy-shield): refine glass shield rendering
+
+### 特效
+- 无新增 / 删除(仍 41 个)。
+
 ## v0.3.16 — 2026-07-08
 
 ### 改动

package/dist/EffectPackageService.d.ts

@@ -1,16 +1,18 @@
 import { Vector3 } from '@babylonjs/core/Maths/math.vector';
 import { Scene } from '@babylonjs/core/scene';
 import { VfxRegistry } from './registry';
-import { VfxDebugAnchor, VfxEffectHandle, VfxEffectPackage, VfxParamValues, VfxSpawnTransform } from './types';
+import { VfxDebugAnchor, VfxEffectHandle, VfxEffectPackage, VfxParamValues, VfxRuntimeResources, VfxSpawnTransform } from './types';
 export interface EffectPackageServiceOptions {
     /** 注入的注册表(由项目侧 glob + buildRegistry 构建);库不直接引用项目注册表 */
     registry: VfxRegistry;
     getDebugAnchorPosition?: (anchor: VfxDebugAnchor) => Vector3 | null;
+    runtime?: VfxRuntimeResources;
 }
 export declare class EffectPackageService {
     private readonly scene;
     private readonly registry;
     private readonly getDebugAnchorPosition?;
+    private readonly runtime?;
     private readonly activeHandles;
     private readonly savedParams;
     constructor(scene: Scene, options: EffectPackageServiceOptions);

package/dist/SceneVfxService.d.ts

@@ -1,7 +1,7 @@
 import { Scene } from '@babylonjs/core/scene';
 import { Vector3 } from '@babylonjs/core/Maths/math.vector';
 import { VfxRegistry } from './registry';
-import { VfxDebugAnchor, VfxEffectHandle, VfxEffectPackage, VfxParamValues, VfxSpawnTransform } from './types';
+import { VfxDebugAnchor, VfxEffectHandle, VfxEffectPackage, VfxParamValues, VfxRuntimeResources, VfxSpawnTransform } from './types';
 import { EffectPackageService } from './EffectPackageService';
 export interface SceneVfxWarmupEntry {
     effectId: string;
@@ -12,6 +12,7 @@ export interface SceneVfxServiceOptions {
     /** 注入的注册表(项目侧 glob + buildRegistry 构建) */
     registry: VfxRegistry;
     getDebugAnchorPosition?: (anchor: VfxDebugAnchor) => Vector3 | null;
+    runtime?: VfxRuntimeResources;
 }
 export declare class SceneVfxService {
     private effectPackageService;

package/dist/effects/energy-shield/index.d.ts

@@ -1,3 +1,4 @@
+import { GlowLayer } from '@babylonjs/core/Layers/glowLayer';
 import { ShaderMaterial } from '@babylonjs/core/Materials/shaderMaterial';
 import { Vector3 } from '@babylonjs/core/Maths/math.vector';
 import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
@@ -9,10 +10,18 @@ export interface EnergyShieldParams extends VfxParamValues {
     radius: number;
     verticalScale: number;
     color: VfxColorValue;
+    baseColor: VfxColorValue;
     opacity: number;
     fresnelPower: number;
     fresnelStrength: number;
     rimIntensity: number;
+    baseGlowStrength: number;
+    baseGlowHeight: number;
+    surfaceVariation: number;
+    backRimStrength: number;
+    backGlowStrength: number;
+    backGlowHeight: number;
+    showSurfaceFlow: boolean;
     surfaceIntensity: number;
     noiseScale: number;
     noiseEdgeWidth: number;
@@ -23,6 +32,8 @@ export interface EnergyShieldParams extends VfxParamValues {
     flowIntensity: number;
     marbleContrast: number;
     bloomIntensity: number;
+    bloomKernelSize: number;
+    showGlowLayer: boolean;
     haloScale: number;
     showHalo: boolean;
     segments: number;
@@ -33,11 +44,15 @@ export interface CreateEnergyShieldOptions {
     position?: Vector3;
     params?: Partial<EnergyShieldParams>;
     renderingGroupId?: number;
+    glowLayer?: GlowLayer | null;
     disposeRoot?: boolean;
 }
 export interface EnergyShieldHandle extends VfxEffectHandle {
     shield: Mesh;
     material: ShaderMaterial;
+    backShield: Mesh;
+    backMaterial: ShaderMaterial;
+    glowLayer: GlowLayer | null;
     update(params: Partial<EnergyShieldParams>): void;
 }
 export declare const energyShieldEffectPackage: VfxEffectPackage<EnergyShieldParams>;

package/dist/effects/energy-shield/index.js

@@ -1,4 +1,5 @@
 import { Constants } from "@babylonjs/core/Engines/constants";
+import { GlowLayer } from "@babylonjs/core/Layers/glowLayer";
 import { Effect } from "@babylonjs/core/Materials/effect";
 import { ShaderMaterial } from "@babylonjs/core/Materials/shaderMaterial";
 import { Color3 } from "@babylonjs/core/Maths/math.color";
@@ -8,27 +9,36 @@ import { TransformNode } from "@babylonjs/core/Meshes/transformNode";
 import { V as VFX_RENDERING_GROUP_ID } from "../../chunks/rendering-CV3nhygX.js";
 const SHADER_NAME = "vfxEnergyShield";
 const HALO_ALPHA_SCALE_MAX = 0.3;
-const HALO_FEATHER_ALPHA_RATIO = 0.72;
-const HALO_FEATHER_SCALE_OFFSET = 0.018;
+const SHIELD_SLICE = 0.5;
 const DEFAULT_PARAMS = {
   radius: 3.18,
-  verticalScale: 1.02,
-  color: { r: 0.34902, g: 0.568627, b: 0.968627 },
-  opacity: 0.2,
-  fresnelPower: 1.8,
-  fresnelStrength: 0.66,
-  rimIntensity: 0.4,
-  surfaceIntensity: 0.3,
-  noiseScale: 1,
-  noiseEdgeWidth: 0.1,
-  noiseEdgeIntensity: 0.42,
-  noiseEdgeSmoothness: 0.5,
-  flowScale: 0.36,
-  flowSpeed: 0.25,
-  flowIntensity: 1.15,
-  marbleContrast: 0.67,
-  bloomIntensity: 0.45,
-  haloScale: 1.018,
+  verticalScale: 1,
+  color: { r: 0.28627451, g: 0.50980392, b: 1 },
+  baseColor: { r: 0.28627451, g: 0.50980392, b: 1 },
+  opacity: 0.02,
+  fresnelPower: 2,
+  fresnelStrength: 1,
+  rimIntensity: 1,
+  baseGlowStrength: 0.32,
+  baseGlowHeight: 0.46,
+  surfaceVariation: 0,
+  backRimStrength: 1,
+  backGlowStrength: 0.36,
+  backGlowHeight: 0.49,
+  showSurfaceFlow: false,
+  surfaceIntensity: 0.04,
+  noiseScale: 0.9,
+  noiseEdgeWidth: 0.08,
+  noiseEdgeIntensity: 0.62,
+  noiseEdgeSmoothness: 0.3,
+  flowScale: 2.15,
+  flowSpeed: 0.18,
+  flowIntensity: 0.2,
+  marbleContrast: 1,
+  bloomIntensity: 0.4,
+  bloomKernelSize: 36,
+  showGlowLayer: false,
+  haloScale: 1.006,
   showHalo: false,
   segments: 64
 };
@@ -58,11 +68,16 @@ precision highp float;
 
 uniform float uTime;
 uniform vec3 cameraPosition;
-uniform vec3 uColor;
+uniform vec3 uTopColor;
+uniform vec3 uBaseColor;
 uniform float uOpacity;
 uniform float uFresnelPower;
-uniform float uFresnelStrength;
+uniform float uRimStrength;
 uniform float uRimIntensity;
+uniform float uHorizonStrength;
+uniform float uHorizonHeight;
+uniform float uSurfaceVariation;
+uniform float uSurfaceFlowEnabled;
 uniform float uSurfaceIntensity;
 uniform float uNoiseScale;
 uniform float uNoiseEdgeWidth;
@@ -72,137 +87,68 @@ uniform float uFlowScale;
 uniform float uFlowSpeed;
 uniform float uFlowIntensity;
 uniform float uMarbleContrast;
-uniform float uHaloAlphaScale;
-uniform float uHaloMode;
+uniform float uAlphaScale;
 
 varying vec3 vObjPos;
 varying vec3 vWorldPos;
 varying vec3 vNormalW;
 
-vec3 mod289v3(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
-vec4 mod289v4(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
-vec4 permute(vec4 x) { return mod289v4(((x * 34.0) + 1.0) * x); }
-vec4 taylorInvSqrt(vec4 r) { return 1.79284291400159 - 0.85373472095314 * r; }
-
-float saturate(float v) { return clamp(v, 0.0, 1.0); }
-
-float snoise(vec3 v) {
-  const vec2 C = vec2(1.0 / 6.0, 1.0 / 3.0);
-  const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
-  vec3 i = floor(v + dot(v, C.yyy));
-  vec3 x0 = v - i + dot(i, C.xxx);
-  vec3 g = step(x0.yzx, x0.xyz);
-  vec3 l = 1.0 - g;
-  vec3 i1 = min(g.xyz, l.zxy);
-  vec3 i2 = max(g.xyz, l.zxy);
-  vec3 x1 = x0 - i1 + C.xxx;
-  vec3 x2 = x0 - i2 + C.yyy;
-  vec3 x3 = x0 - D.yyy;
-  i = mod289v3(i);
-  vec4 p = permute(permute(permute(
-    i.z + vec4(0.0, i1.z, i2.z, 1.0))
-    + i.y + vec4(0.0, i1.y, i2.y, 1.0))
-    + i.x + vec4(0.0, i1.x, i2.x, 1.0));
-  float n_ = 0.142857142857;
-  vec3 ns = n_ * D.wyz - D.xzx;
-  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);
-  vec4 x_ = floor(j * ns.z);
-  vec4 y_ = floor(j - 7.0 * x_);
-  vec4 x = x_ * ns.x + ns.yyyy;
-  vec4 y = y_ * ns.x + ns.yyyy;
-  vec4 h = 1.0 - abs(x) - abs(y);
-  vec4 b0 = vec4(x.xy, y.xy);
-  vec4 b1 = vec4(x.zw, y.zw);
-  vec4 s0 = floor(b0) * 2.0 + 1.0;
-  vec4 s1 = floor(b1) * 2.0 + 1.0;
-  vec4 sh = -step(h, vec4(0.0));
-  vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
-  vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
-  vec3 p0 = vec3(a0.xy, h.x);
-  vec3 p1 = vec3(a0.zw, h.y);
-  vec3 p2 = vec3(a1.xy, h.z);
-  vec3 p3 = vec3(a1.zw, h.w);
-  vec4 norm = taylorInvSqrt(vec4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
-  p0 *= norm.x;
-  p1 *= norm.y;
-  p2 *= norm.z;
-  p3 *= norm.w;
-  vec4 m = max(0.6 - vec4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0);
-  m = m * m;
-  return 42.0 * dot(m * m, vec4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
+float hash(vec3 position) {
+  position = fract(position * 0.3183099 + 0.1);
+  position *= 17.0;
+  return fract(position.x * position.y * position.z * (position.x + position.y + position.z));
 }
 
-float fbm(vec3 p) {
-  float total = 0.0;
-  float amp = 0.55;
-  total += snoise(p) * amp;
-  p = p * 2.03 + vec3(17.1, 3.7, 9.2);
-  amp *= 0.52;
-  total += snoise(p) * amp;
-  p = p * 2.11 + vec3(4.3, 13.9, 6.4);
-  amp *= 0.5;
-  total += snoise(p) * amp;
-  return total;
+float valueNoise(vec3 position) {
+  vec3 cell = floor(position);
+  vec3 local = fract(position);
+  local = local * local * (3.0 - 2.0 * local);
+
+  return mix(
+    mix(
+      mix(hash(cell), hash(cell + vec3(1.0, 0.0, 0.0)), local.x),
+      mix(hash(cell + vec3(0.0, 1.0, 0.0)), hash(cell + vec3(1.0, 1.0, 0.0)), local.x),
+      local.y
+    ),
+    mix(
+      mix(hash(cell + vec3(0.0, 0.0, 1.0)), hash(cell + vec3(1.0, 0.0, 1.0)), local.x),
+      mix(hash(cell + vec3(0.0, 1.0, 1.0)), hash(cell + vec3(1.0, 1.0, 1.0)), local.x),
+      local.y
+    ),
+    local.z
+  );
 }
 
 void main(void) {
-  vec3 normalW = normalize(vNormalW);
   vec3 viewDir = normalize(cameraPosition - vWorldPos);
-  float ndv = saturate(dot(normalW, viewDir));
-  float viewRim = saturate(1.0 - ndv);
-  float fresnel = pow(viewRim, max(0.05, uFresnelPower)) * uFresnelStrength;
-
-  float t = uTime * uFlowSpeed;
-  vec3 spherePos = normalize(vObjPos + vec3(0.0001)) * max(0.05, uNoiseScale);
-  vec3 flowA = spherePos * uFlowScale + vec3(t, t * 0.62, t * 0.38);
-  vec3 flowB = spherePos * (uFlowScale * 1.91) + vec3(-t * 0.46, t * 0.82, -t * 0.27);
-  float n1 = fbm(flowA);
-  float n2 = fbm(flowB);
-  float cloud = saturate((n1 * 0.58 + n2 * 0.42) * 0.5 + 0.5);
-
-  float veinInput = spherePos.y * 0.92 + n1 * 1.65 + n2 * 0.74 + t * 0.13;
-  float ribbon = abs(sin(veinInput * 3.14159265));
-  float marble = pow(1.0 - ribbon, max(0.25, uMarbleContrast));
-  float nebula = saturate(mix(cloud, marble, 0.58) * uFlowIntensity * 0.34);
+  float facing = abs(dot(normalize(vNormalW), viewDir));
+  float rim = pow(1.0 - facing, max(0.05, uFresnelPower));
+  float horizon = pow(1.0 - clamp(vObjPos.y / max(0.001, uHorizonHeight), 0.0, 1.0), 2.5);
+  float heightFactor = smoothstep(0.0, 0.92, vObjPos.y);
 
-  float edgeWidth = max(0.01, uNoiseEdgeWidth);
-  float edgeSoft = max(0.01, uNoiseEdgeSmoothness) * 0.22;
-  float noiseEdge = smoothstep(1.0 - edgeWidth - edgeSoft, 1.0 - edgeWidth * 0.22, nebula);
-
-  vec3 deepBlue = uColor * (0.12 + 0.42 * cloud);
-  vec3 marbleBlue = uColor * (0.34 + 0.9 * marble) * uSurfaceIntensity;
-  vec3 rimBlue = uColor * fresnel * uRimIntensity;
-  vec3 edgeBlue = uColor * noiseEdge * uNoiseEdgeIntensity;
-  vec3 color = min((deepBlue + marbleBlue + rimBlue + edgeBlue) * 0.72, vec3(1.12));
-
-  float alpha = uOpacity * (0.16 + 0.34 * cloud + 0.24 * marble);
-  alpha += fresnel * uOpacity * 0.58;
-  alpha += noiseEdge * uNoiseEdgeIntensity * 0.05;
-
-  if (uHaloMode > 1.5) {
-    float haloRim = pow(viewRim, max(0.28, uFresnelPower * 0.44));
-    float featherIn = smoothstep(0.1, 0.46, haloRim);
-    float featherOut = 1.0 - smoothstep(0.72, 1.0, haloRim);
-    float featherRim = featherIn * featherOut;
-    float outerFade = 1.0 - smoothstep(0.88, 1.0, haloRim);
-    color = uColor * (0.2 + featherRim * 0.24 + cloud * 0.04);
-    alpha = featherRim * 0.58 * outerFade;
-  } else if (uHaloMode > 0.5) {
-    float haloRim = pow(viewRim, max(0.3, uFresnelPower * 0.48));
-    float bodyIn = smoothstep(0.34, 0.68, haloRim);
-    float bodyOut = 1.0 - smoothstep(0.72, 1.0, haloRim);
-    float bodyRim = bodyIn * bodyOut;
-    float featherIn = smoothstep(0.12, 0.44, haloRim);
-    float featherOut = 1.0 - smoothstep(0.48, 1.0, haloRim);
-    float featherRim = featherIn * featherOut;
-    float outerFade = 1.0 - smoothstep(0.86, 1.0, haloRim);
-    color = uColor * (0.24 + bodyRim * 0.34 + featherRim * 0.12 + cloud * 0.05);
-    alpha = (bodyRim * 0.5 + featherRim * 0.14 + noiseEdge * 0.01) * outerFade;
+  vec3 motion = vec3(0.0);
+  if (uSurfaceFlowEnabled > 0.5) {
+    motion = vec3(uTime * uFlowSpeed, -uTime * uFlowSpeed * 0.62, uTime * uFlowSpeed * 0.38);
   }
+  float cloud = valueNoise(vObjPos * max(0.05, uNoiseScale)) * 0.65;
+  cloud += valueNoise(vObjPos * max(0.05, uFlowScale) + motion) * 0.35;
+  float shapedCloud = pow(clamp(cloud, 0.0, 1.0), max(0.25, uMarbleContrast));
+  float variation = mix(1.0 - uSurfaceVariation, 1.0 + uSurfaceVariation, shapedCloud);
+  float cloudShade = mix(0.92, 1.08, shapedCloud);
+  rim *= cloudShade;
 
-  alpha *= uHaloAlphaScale;
+  float edgeWidth = max(0.005, uNoiseEdgeWidth);
+  float edgeSoftness = max(0.005, uNoiseEdgeSmoothness * 0.2);
+  float flowBand = 1.0 - smoothstep(edgeWidth, edgeWidth + edgeSoftness, abs(shapedCloud - 0.5));
+  float flowGlow = flowBand * uFlowIntensity * uNoiseEdgeIntensity * uSurfaceFlowEnabled;
 
-  gl_FragColor = vec4(color, saturate(alpha));
+  float alpha = uOpacity * variation + rim * uRimStrength + horizon * uHorizonStrength * variation;
+  alpha += flowGlow * uOpacity * 0.5;
+  vec3 gradientColor = mix(uBaseColor, uTopColor, heightFactor);
+  vec3 color = gradientColor * (0.25 + rim * 1.3 + horizon * 0.85) * cloudShade * uRimIntensity;
+  color += gradientColor * flowGlow * uSurfaceIntensity;
+
+  gl_FragColor = vec4(color, clamp(alpha * uAlphaScale, 0.0, 0.88));
 }
 `;
 const energyShieldEffectPackage = {
@@ -219,11 +165,19 @@ const energyShieldEffectPackage = {
   debugParams: [
     { key: "radius", label: "玻璃罩半径", kind: "scale", min: 0.4, max: 10, step: 0.01 },
     { key: "verticalScale", label: "纵向缩放", kind: "scale", min: 0.5, max: 1.8, step: 0.01 },
-    { key: "color", label: "主体颜色", kind: "color" },
-    { key: "opacity", label: "透明度", kind: "opacity", min: 0.02, max: 1, step: 0.01 },
-    { key: "fresnelPower", label: "边缘曲线", kind: "number", min: 0.2, max: 6, step: 0.01 },
-    { key: "fresnelStrength", label: "边缘强度", kind: "number", min: 0, max: 6, step: 0.01 },
+    { key: "color", label: "顶部颜色", kind: "color" },
+    { key: "baseColor", label: "底部颜色", kind: "color" },
+    { key: "opacity", label: "球壳透明度", kind: "opacity", min: 0, max: 1, step: 0.01 },
+    { key: "fresnelPower", label: "轮廓衰减", kind: "number", min: 0.2, max: 8, step: 0.01 },
+    { key: "fresnelStrength", label: "正面轮廓强度", kind: "number", min: 0, max: 2.5, step: 0.01 },
     { key: "rimIntensity", label: "轮廓亮度", kind: "number", min: 0, max: 4, step: 0.01 },
+    { key: "baseGlowStrength", label: "正面底部辉光", kind: "number", min: 0, max: 1, step: 0.01 },
+    { key: "baseGlowHeight", label: "正面辉光高度", kind: "number", min: 0.04, max: 1, step: 0.01 },
+    { key: "surfaceVariation", label: "表面明暗变化", kind: "number", min: 0, max: 0.6, step: 0.01 },
+    { key: "backRimStrength", label: "背面轮廓强度", kind: "number", min: 0, max: 1.5, step: 0.01 },
+    { key: "backGlowStrength", label: "背面底部辉光", kind: "number", min: 0, max: 1, step: 0.01 },
+    { key: "backGlowHeight", label: "背面辉光高度", kind: "number", min: 0.04, max: 1, step: 0.01 },
+    { key: "showSurfaceFlow", label: "显示表面流动", kind: "boolean" },
     { key: "surfaceIntensity", label: "表面亮度", kind: "number", min: 0, max: 3, step: 0.01 },
     { key: "noiseScale", label: "噪声缩放", kind: "number", min: 0.2, max: 5, step: 0.01 },
     { key: "noiseEdgeWidth", label: "噪声亮边宽度", kind: "number", min: 0.01, max: 0.5, step: 0.01 },
@@ -234,11 +188,19 @@ const energyShieldEffectPackage = {
     { key: "flowIntensity", label: "流动强度", kind: "number", min: 0, max: 8, step: 0.01 },
     { key: "marbleContrast", label: "纹路锐度", kind: "number", min: 0.25, max: 4, step: 0.01 },
     { key: "bloomIntensity", label: "Bloom 强度", kind: "number", min: 0, max: 4, step: 0.01 },
-    { key: "haloScale", label: "外层光晕缩放", kind: "scale", min: 1, max: 1.08, step: 1e-3 },
-    { key: "showHalo", label: "显示外层光晕", kind: "boolean" }
+    { key: "bloomKernelSize", label: "Bloom/Glow 半径", kind: "number", min: 8, max: 128, step: 1 },
+    { key: "showGlowLayer", label: "显示 Bloom/Glow", kind: "boolean" },
+    { key: "haloScale", label: "Halo 缩放", kind: "scale", min: 1, max: 1.08, step: 1e-3 },
+    { key: "showHalo", label: "显示额外 Halo", kind: "boolean" }
   ],
-  create({ scene, root, position, renderingGroupId, params }) {
-    return createEnergyShield(scene, { root, position, renderingGroupId, params });
+  create({ scene, root, position, renderingGroupId, params, runtime }) {
+    return createEnergyShield(scene, {
+      root,
+      position,
+      renderingGroupId,
+      params,
+      glowLayer: runtime?.glowLayer ?? runtime?.getGlowLayer?.() ?? null
+    });
   }
 };
 function createEnergyShield(scene, options = {}) {
@@ -257,7 +219,7 @@ function createEnergyShield(scene, options = {}) {
     {
       diameter: 2,
       segments: Math.max(16, Math.round(params.segments)),
-      slice: 0.5,
+      slice: SHIELD_SLICE,
       updatable: false
     },
     scene
@@ -267,21 +229,79 @@ function createEnergyShield(scene, options = {}) {
   shield.alwaysSelectAsActiveMesh = true;
   shield.renderingGroupId = options.renderingGroupId ?? VFX_RENDERING_GROUP_ID;
   shield.alphaIndex = 20;
-  const material = createShieldMaterial(scene);
+  const material = createShieldMaterial(scene, { face: "front" });
   shield.material = material;
+  const backShield = MeshBuilder.CreateSphere(
+    "vfx_energyShield_back_hemisphere",
+    {
+      diameter: 2,
+      segments: Math.max(16, Math.round(params.segments)),
+      slice: SHIELD_SLICE,
+      updatable: false
+    },
+    scene
+  );
+  backShield.parent = root;
+  backShield.isPickable = false;
+  backShield.alwaysSelectAsActiveMesh = true;
+  backShield.renderingGroupId = shield.renderingGroupId;
+  backShield.alphaIndex = shield.alphaIndex - 1;
+  const backMaterial = createShieldMaterial(scene, {
+    name: "vfx_energyShield_back_material",
+    alphaMode: Constants.ALPHA_ADD,
+    face: "back"
+  });
+  backShield.material = backMaterial;
+  const sharedGlowLayer = options.glowLayer ?? null;
+  let glowLayer = null;
+  let ownsGlowLayer = false;
+  let glowMeshIncluded = false;
   let halo = null;
   let haloMaterial = null;
-  let haloFeather = null;
-  let haloFeatherMaterial = null;
   const disposeHalo = () => {
     halo?.dispose(false, false);
     haloMaterial?.dispose();
-    haloFeather?.dispose(false, false);
-    haloFeatherMaterial?.dispose();
     halo = null;
     haloMaterial = null;
-    haloFeather = null;
-    haloFeatherMaterial = null;
+  };
+  const addGlowMesh = () => {
+    if (!glowLayer || glowMeshIncluded) return;
+    glowLayer.addIncludedOnlyMesh(shield);
+    glowLayer.referenceMeshToUseItsOwnMaterial(shield);
+    glowMeshIncluded = true;
+  };
+  const removeGlowMesh = () => {
+    if (!glowLayer || !glowMeshIncluded) return;
+    glowLayer.removeIncludedOnlyMesh(shield);
+    glowMeshIncluded = false;
+  };
+  const disposeGlowLayer = () => {
+    removeGlowMesh();
+    if (ownsGlowLayer) glowLayer?.dispose();
+    glowLayer = null;
+    ownsGlowLayer = false;
+  };
+  const ensureGlowLayer = () => {
+    if (!params.showGlowLayer || params.bloomIntensity <= 1e-3) {
+      disposeGlowLayer();
+      return;
+    }
+    if (!glowLayer) {
+      if (sharedGlowLayer) {
+        glowLayer = sharedGlowLayer;
+      } else {
+        glowLayer = new GlowLayer(`vfx_energyShield_glow_${shield.uniqueId}`, scene, {
+          blurKernelSize: params.bloomKernelSize,
+          mainTextureRatio: 0.35
+        });
+        ownsGlowLayer = true;
+      }
+      addGlowMesh();
+    }
+    if (ownsGlowLayer) {
+      glowLayer.intensity = params.bloomIntensity;
+      glowLayer.blurKernelSize = params.bloomKernelSize;
+    }
   };
   const ensureHalo = () => {
     if (!params.showHalo || params.bloomIntensity <= 1e-3) {
@@ -294,7 +314,7 @@ function createEnergyShield(scene, options = {}) {
         {
           diameter: 2,
           segments: Math.max(16, Math.round(params.segments)),
-          slice: 0.5,
+          slice: SHIELD_SLICE,
           updatable: false
         },
         scene
@@ -307,49 +327,31 @@ function createEnergyShield(scene, options = {}) {
       halo.scaling.setAll(Math.max(1, params.haloScale));
       haloMaterial = createShieldMaterial(scene, {
         name: "vfx_energyShield_halo_material",
-        alphaMode: Constants.ALPHA_ADD
+        alphaMode: Constants.ALPHA_ADD,
+        face: "front"
       });
       halo.material = haloMaterial;
     }
-    if (!haloFeather || !haloFeatherMaterial) {
-      haloFeather = MeshBuilder.CreateSphere(
-        "vfx_energyShield_halo_feather",
-        {
-          diameter: 2,
-          segments: Math.max(16, Math.round(params.segments)),
-          slice: 0.5,
-          updatable: false
-        },
-        scene
-      );
-      haloFeather.parent = shield;
-      haloFeather.isPickable = false;
-      haloFeather.alwaysSelectAsActiveMesh = true;
-      haloFeather.renderingGroupId = shield.renderingGroupId;
-      haloFeather.alphaIndex = shield.alphaIndex + 2;
-      haloFeather.scaling.setAll(getHaloFeatherScale(params));
-      haloFeatherMaterial = createShieldMaterial(scene, {
-        name: "vfx_energyShield_halo_feather_material",
-        alphaMode: Constants.ALPHA_ADD
-      });
-      haloFeather.material = haloFeatherMaterial;
-    }
   };
+  ensureGlowLayer();
   ensureHalo();
-  applyParams(material, shield, halo, haloMaterial, haloFeather, haloFeatherMaterial, params);
+  applyParams(material, shield, backMaterial, backShield, halo, haloMaterial, params);
   let elapsed = 0;
   const observer = scene.onBeforeRenderObservable.add(() => {
     elapsed += Math.min(scene.getEngine().getDeltaTime() / 1e3, 0.05);
     material.setFloat("uTime", elapsed);
+    backMaterial.setFloat("uTime", elapsed);
     haloMaterial?.setFloat("uTime", elapsed);
-    haloFeatherMaterial?.setFloat("uTime", elapsed);
   });
   let disposed = false;
   const dispose = () => {
     if (disposed) return;
     disposed = true;
     scene.onBeforeRenderObservable.remove(observer);
+    disposeGlowLayer();
     disposeHalo();
+    backShield.dispose(false, false);
+    backMaterial.dispose();
     shield.dispose(false, false);
     material.dispose();
     if (disposeRoot) root.dispose();
@@ -358,10 +360,16 @@ function createEnergyShield(scene, options = {}) {
     root,
     shield,
     material,
+    backShield,
+    backMaterial,
+    get glowLayer() {
+      return glowLayer;
+    },
     update(partial) {
       params = mergeParams(partial, params);
+      ensureGlowLayer();
       ensureHalo();
-      applyParams(material, shield, halo, haloMaterial, haloFeather, haloFeatherMaterial, params);
+      applyParams(material, shield, backMaterial, backShield, halo, haloMaterial, params);
     },
     dispose
   };
@@ -378,11 +386,16 @@ function createShieldMaterial(scene, options = {}) {
         "worldViewProjection",
         "cameraPosition",
         "uTime",
-        "uColor",
+        "uTopColor",
+        "uBaseColor",
         "uOpacity",
         "uFresnelPower",
-        "uFresnelStrength",
+        "uRimStrength",
         "uRimIntensity",
+        "uHorizonStrength",
+        "uHorizonHeight",
+        "uSurfaceVariation",
+        "uSurfaceFlowEnabled",
         "uSurfaceIntensity",
         "uNoiseScale",
         "uNoiseEdgeWidth",
@@ -392,49 +405,68 @@ function createShieldMaterial(scene, options = {}) {
         "uFlowSpeed",
         "uFlowIntensity",
         "uMarbleContrast",
-        "uHaloAlphaScale",
-        "uHaloMode"
+        "uAlphaScale"
       ],
       needAlphaBlending: true
     }
   );
   material.alphaMode = options.alphaMode ?? Constants.ALPHA_COMBINE;
-  material.backFaceCulling = false;
+  material.backFaceCulling = true;
+  material.cullBackFaces = options.face !== "back";
   material.disableDepthWrite = true;
   material.fogEnabled = false;
   return material;
 }
-function applyParams(material, shield, halo, haloMaterial, haloFeather, haloFeatherMaterial, params) {
+function applyParams(material, shield, backMaterial, backShield, halo, haloMaterial, params) {
   shield.scaling.set(params.radius, params.radius * params.verticalScale, params.radius);
-  applyMaterialParams(material, params, params.opacity, 1, 0);
-  const haloAlphaScale = Math.min(HALO_ALPHA_SCALE_MAX, params.opacity * Math.min(1, params.bloomIntensity));
+  backShield.scaling.copyFrom(shield.scaling);
+  applyMaterialParams(material, params, {
+    opacity: params.opacity,
+    rimStrength: params.fresnelStrength,
+    horizonStrength: params.baseGlowStrength,
+    horizonHeight: params.baseGlowHeight,
+    alphaScale: 1
+  });
+  applyMaterialParams(backMaterial, params, {
+    opacity: 0,
+    rimStrength: params.backRimStrength,
+    horizonStrength: params.backGlowStrength,
+    horizonHeight: params.backGlowHeight,
+    alphaScale: 1
+  });
+  const haloAlphaScale = Math.min(
+    HALO_ALPHA_SCALE_MAX,
+    Math.max(
+      params.opacity * Math.min(1, params.bloomIntensity),
+      Math.min(1, params.fresnelStrength) * 0.2
+    )
+  );
   if (halo && haloMaterial) {
     halo.scaling.setAll(Math.max(1, params.haloScale));
     applyMaterialParams(
       haloMaterial,
       params,
-      1,
-      haloAlphaScale,
-      1
-    );
-  }
-  if (haloFeather && haloFeatherMaterial) {
-    haloFeather.scaling.setAll(getHaloFeatherScale(params));
-    applyMaterialParams(
-      haloFeatherMaterial,
-      params,
-      1,
-      haloAlphaScale * HALO_FEATHER_ALPHA_RATIO,
-      2
+      {
+        opacity: 0,
+        rimStrength: params.fresnelStrength,
+        horizonStrength: 0,
+        horizonHeight: params.baseGlowHeight,
+        alphaScale: haloAlphaScale
+      }
     );
   }
 }
-function applyMaterialParams(material, params, opacity, haloAlphaScale, haloMode) {
-  material.setColor3("uColor", toColor3(params.color));
-  material.setFloat("uOpacity", opacity);
+function applyMaterialParams(material, params, settings) {
+  material.setColor3("uTopColor", toColor3(params.color));
+  material.setColor3("uBaseColor", toColor3(params.baseColor));
+  material.setFloat("uOpacity", settings.opacity);
   material.setFloat("uFresnelPower", params.fresnelPower);
-  material.setFloat("uFresnelStrength", params.fresnelStrength);
+  material.setFloat("uRimStrength", settings.rimStrength);
   material.setFloat("uRimIntensity", params.rimIntensity);
+  material.setFloat("uHorizonStrength", settings.horizonStrength);
+  material.setFloat("uHorizonHeight", settings.horizonHeight);
+  material.setFloat("uSurfaceVariation", params.surfaceVariation);
+  material.setFloat("uSurfaceFlowEnabled", params.showSurfaceFlow ? 1 : 0);
   material.setFloat("uSurfaceIntensity", params.surfaceIntensity);
   material.setFloat("uNoiseScale", params.noiseScale);
   material.setFloat("uNoiseEdgeWidth", params.noiseEdgeWidth);
@@ -444,21 +476,18 @@ function applyMaterialParams(material, params, opacity, haloAlphaScale, haloMode
   material.setFloat("uFlowSpeed", params.flowSpeed);
   material.setFloat("uFlowIntensity", params.flowIntensity);
   material.setFloat("uMarbleContrast", params.marbleContrast);
-  material.setFloat("uHaloAlphaScale", haloAlphaScale);
-  material.setFloat("uHaloMode", haloMode);
+  material.setFloat("uAlphaScale", settings.alphaScale);
 }
 function mergeParams(patch, base = DEFAULT_PARAMS) {
   return {
     ...base,
     ...patch,
-    color: patch?.color ? { ...patch.color } : { ...base.color }
+    color: patch?.color ? { ...patch.color } : { ...base.color },
+    baseColor: patch?.baseColor ? { ...patch.baseColor } : { ...base.baseColor }
   };
 }
 function toColor3(color) {
-  return new Color3(color.r, color.g, color.b);
-}
-function getHaloFeatherScale(params) {
-  return Math.max(1, params.haloScale + HALO_FEATHER_SCALE_OFFSET);
+  return new Color3(color.r, color.g, color.b).toLinearSpace();
 }
 function registerShaders() {
   Effect.ShadersStore[`${SHADER_NAME}VertexShader`] = VERTEX_SHADER;

package/dist/effects/treasure-attention/index.js

@@ -76,8 +76,15 @@ const treasureAttentionEffectPackage = {
     { key: "bloomKernelSize", label: "Bloom 半径", kind: "number", min: 8, max: 96, step: 1 },
     { key: "showGlowLayer", label: "显示 GlowLayer", kind: "boolean" }
   ],
-  create({ scene, root, position, renderingGroupId, params }) {
-    return createTreasureAttentionFx(scene, { root, position, renderingGroupId, params, serviceOwnedRoot: true });
+  create({ scene, root, position, renderingGroupId, params, runtime }) {
+    return createTreasureAttentionFx(scene, {
+      root,
+      position,
+      renderingGroupId,
+      params,
+      glowLayer: runtime?.glowLayer ?? runtime?.getGlowLayer?.() ?? null,
+      serviceOwnedRoot: true
+    });
   }
 };
 function createTreasureAttentionFx(scene, options = {}) {

package/dist/index.js

@@ -75,6 +75,7 @@ class EffectPackageService {
     this.scene = scene;
     this.registry = options.registry;
     this.getDebugAnchorPosition = options.getDebugAnchorPosition;
+    this.runtime = options.runtime;
     this.savedParams = cloneOverrideMap(options.registry.savedParams);
   }
   getEffectPackages() {
@@ -127,7 +128,8 @@ class EffectPackageService {
         renderingGroupId: spawn.renderingGroupId,
         params: runtimeParams,
         scale: spawn.scale,
-        inputs: spawn.inputs
+        inputs: spawn.inputs,
+        runtime: this.runtime
       });
       applySpawnToRoot(root, spawn, applyRootScale);
     } catch (error) {
@@ -315,7 +317,8 @@ class SceneVfxService {
   constructor(scene, options) {
     this.effectPackageService = new EffectPackageService(scene, {
       registry: options.registry,
-      getDebugAnchorPosition: options.getDebugAnchorPosition
+      getDebugAnchorPosition: options.getDebugAnchorPosition,
+      runtime: options.runtime
     });
   }
   getEffectPackageService() {

package/dist/types.d.ts

@@ -2,6 +2,7 @@ import { Scene } from '@babylonjs/core/scene';
 import { Vector3 } from '@babylonjs/core/Maths/math.vector';
 import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
 import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { GlowLayer } from '@babylonjs/core/Layers/glowLayer';
 export type VfxDebugAnchor = 'playerRight' | 'player';
 export type VfxInput<T> = T | (() => T);
 export type VfxInputKey = 'aim' | 'normal' | 'endpoints' | 'target' | 'reference';
@@ -24,6 +25,11 @@ export interface VfxResolvedInputs {
     reference?: () => Vector3;
     scalars?: Record<string, () => number>;
 }
+/** 运行时共享资源:不可序列化,由项目/游戏层注入,与可保存 params 分开。 */
+export interface VfxRuntimeResources {
+    glowLayer?: GlowLayer | null;
+    getGlowLayer?: () => GlowLayer | null;
+}
 export type VfxParamValue = number | string | boolean | VfxColorValue;
 export type VfxParamValues = Record<string, VfxParamValue>;
 export interface VfxColorValue {
@@ -74,6 +80,8 @@ export interface VfxEffectPackageContext<PParams extends VfxParamValues = VfxPar
     scale: Vector3;
     /** 运行时外部信息(已归一化为访问器)。link/target/定向武器/活改标量等按 required/optionalInputs 读取。 */
     inputs?: VfxResolvedInputs;
+    /** 运行时共享资源(如 scene 级共享 GlowLayer)。 */
+    runtime?: VfxRuntimeResources;
 }
 export interface VfxEffectHandle {
     root: TransformNode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fps-games/vfx",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "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/energy-shield/vfx-params.json

@@ -3,27 +3,41 @@
   "effectId": "energy-shield",
   "params": {
     "radius": 3.18,
-    "verticalScale": 1.02,
+    "verticalScale": 1,
     "color": {
-      "r": 0.34902,
-      "g": 0.568627,
-      "b": 0.968627
+      "r": 0.28627451,
+      "g": 0.50980392,
+      "b": 1
     },
-    "opacity": 0.2,
-    "fresnelPower": 1.8,
-    "fresnelStrength": 0.66,
-    "rimIntensity": 0.4,
-    "surfaceIntensity": 0.3,
-    "noiseScale": 1,
-    "noiseEdgeWidth": 0.1,
-    "noiseEdgeIntensity": 0.42,
-    "noiseEdgeSmoothness": 0.5,
-    "flowScale": 0.36,
-    "flowSpeed": 0.25,
-    "flowIntensity": 1.15,
-    "marbleContrast": 0.67,
-    "bloomIntensity": 0.45,
-    "haloScale": 1.018,
+    "baseColor": {
+      "r": 0.28627451,
+      "g": 0.50980392,
+      "b": 1
+    },
+    "opacity": 0.02,
+    "fresnelPower": 2,
+    "fresnelStrength": 1,
+    "rimIntensity": 1,
+    "baseGlowStrength": 0.32,
+    "baseGlowHeight": 0.46,
+    "surfaceVariation": 0,
+    "backRimStrength": 1,
+    "backGlowStrength": 0.36,
+    "backGlowHeight": 0.49,
+    "showSurfaceFlow": false,
+    "surfaceIntensity": 0.04,
+    "noiseScale": 0.9,
+    "noiseEdgeWidth": 0.08,
+    "noiseEdgeIntensity": 0.62,
+    "noiseEdgeSmoothness": 0.3,
+    "flowScale": 2.15,
+    "flowSpeed": 0.18,
+    "flowIntensity": 0.2,
+    "marbleContrast": 1,
+    "bloomIntensity": 0.4,
+    "bloomKernelSize": 36,
+    "showGlowLayer": false,
+    "haloScale": 1.006,
     "showHalo": false,
     "segments": 64
   }