/**
 * ThreeGeospatialPipeline - 精炼版体积云 + Bruneton 大气 + 空中透视一体化管线。
 *
 * 渲染顺序（与 three-geospatial 对齐）：
 *  1. PostProcessStage: 体积云 raymarch（含 BSM 采样、shadowLength、haze）
 *  2. PostProcessStage: AtmospherePostProcess 天空
 *  3. PostProcessStage: AerialPerspectiveEffect 几何透视 + tonemap
 *
 * BSM（Beer Shadow Map）和 TAA 通过原生 WebGL 在 preRender/postRender 执行。
 * BSM 数据通过 setCloudShadow 同步到大气和 Aerial 两侧，实现丁达尔与地面云影。
 */

import * as dat from "dat.gui";
import { AtmosphereParameters, PRECOMPUTE_CONSTANTS, getPrecomputeDefines, flattenAtmosphereUniform } from "./AtmosphereFromThreeGeospatial/AtmosphereParameters.js";
import { AtmospherePostProcess } from "./AtmosphereFromThreeGeospatial/AtmospherePostProcess.js";
import { AerialPerspectiveEffect } from "./AtmosphereFromThreeGeospatial/AerialPerspectiveEffect.js";
import { loadBinThreeGeospatial, bindData3DTextureToCesiumContext } from "./loadBinThreeGeospatial.js";
import { loadShaderSource } from "./shaderLoader.js";
import {
  DEFAULT_CLOUDS_ASSETS_BASE,
  DEFAULT_BRUNETON_SHADER_BASE,
  DEFAULT_BLUE_NOISE_URL,
  DEFAULT_ATMOSPHERE_ASSETS_BASE,
  DEFAULT_ATMOSPHERE_SHADER_BASE,
} from "./assetPaths.js";

const SHADOW_MAP_SIZE = 1024;
const SHADOW_CASCADE_COUNT = 4;
const SHADOW_RAY_FAR = 500000.0;
const BSM_BLIT_SIZE = 1024;

// ─── Cloud fragment shader (Bruneton integrated, no debug branches) ────────

function getCloudFragmentShader() {
  return /* glsl */ `
const float RECIPROCAL_PI4 = 0.07957747154594767;
const float EVOLUTION_SCALE = 2e4;

uniform sampler2D colorTexture;
uniform sampler2D depthTexture;
uniform sampler3D u_shapeTexture;
uniform sampler3D u_shapeDetailTexture;
uniform sampler3D u_stbnTexture;
uniform sampler2D u_weatherTexture;
uniform sampler2D u_turbulenceTexture;
uniform sampler2D u_blueNoise;
uniform float u_blueNoiseScale;
uniform float u_jitterStrength;

uniform vec3 u_cameraPosition;
uniform vec3 u_altitudeCorrection;
uniform float u_cameraHeight;
uniform float u_bottomRadius;
uniform float u_minHeight;
uniform float u_maxHeight;
uniform vec4 u_minLayerHeights;
uniform vec4 u_maxLayerHeights;
uniform vec4 u_densityScales;
uniform vec4 u_shapeAmounts;
uniform vec4 u_shapeDetailAmounts;
uniform vec4 u_weatherExponents;
uniform vec4 u_shapeAlteringBiases;
uniform vec4 u_coverageFilterWidths;
uniform float u_maxSteps;
uniform float u_maxStepsToSun;
uniform float u_minStepSize;
uniform float u_maxStepSize;
uniform float u_maxRayDistance;
uniform float u_cameraNear;
uniform float u_shadowTopHeight;
uniform int u_shadowLengthEnabled;
uniform int u_hazeEnabled;
uniform int u_maxShadowLengthIterationCount;
uniform float u_minShadowLengthStepSize;
uniform float u_maxShadowLengthRayDistance;
uniform float u_hazeDensityScale;
uniform float u_hazeExponent;
uniform float u_hazeScatteringCoefficient;
uniform float u_hazeAbsorptionCoefficient;
uniform sampler2D u_shadowBuffer;
uniform vec2 u_shadowTexelSize;
uniform vec2 u_shadowIntervals[4];
uniform mat4 u_shadowMatrices[4];
uniform float u_shadowFar;
uniform float u_maxShadowFilterRadius;
uniform int u_useShadowBuffer;
uniform float u_skyLightScale;
uniform float u_weatherRepeat;
uniform vec2 u_localWeatherOffset;
uniform float u_shapeRepeat;
uniform vec3 u_shapeOffset;
uniform float u_shapeDetailRepeat;
uniform vec3 u_shapeDetailOffset;
uniform float u_turbulenceRepeat;
uniform float u_turbulenceDisplacement;
uniform vec4 u_coverages;
uniform float u_coverageHaze;
uniform float u_scatteringCoefficient;
uniform float u_absorptionCoefficient;
uniform float u_scatterG1;
uniform float u_scatterG2;
uniform float u_scatterMix;
uniform float u_sunIntensity;
uniform float u_skyToSunRatio;
uniform float u_powderScale;
uniform float u_powderExponent;
uniform float u_aerialPerspectiveScale;
uniform float u_cloudExposure;
uniform float u_magentaFixStrength;
uniform float u_edgeAlphaCutoff;
uniform vec2 u_resolution;
uniform float u_mipLevelScale;
uniform float u_perspectiveStepScale;
uniform float u_minDensity;
uniform float u_minExtinction;
uniform float u_minTransmittance;
// 远处云密度距离衰减：从 u_distFadeStart（米）开始线性降到0，到 u_distFadeEnd 完全消失
// 消除天际线附近云"堆在一起"的视觉拥挤
uniform float u_distFadeStart;
uniform float u_distFadeEnd;
uniform float u_minSecondaryStepSize;
uniform float u_secondaryStepScale;
uniform int u_multiScatteringOctaves;
uniform float u_lowLayerDensityBoost;
uniform vec4 u_densityProfileExpTerms;
uniform vec4 u_densityProfileExponents;
uniform vec4 u_densityProfileLinearTerms;
uniform vec4 u_densityProfileConstantTerms;
uniform vec3 u_minIntervalHeights;
uniform vec3 u_maxIntervalHeights;

uniform sampler2D u_historyTexture;
uniform mat4 u_prevViewProjection;
uniform float u_temporalAlpha;
uniform int u_temporalEnabled;
uniform int u_frame;

in vec2 v_textureCoordinates;

vec3 ACESFilmic(vec3 x) {
  float a = 2.51, b = 0.03, c = 2.43, d = 0.59, e = 0.14;
  return clamp((x * (a * x + b)) / (x * (c * x + d) + e), 0.0, 1.0);
}

float saturate(float x) { return clamp(x, 0.0, 1.0); }
vec4 saturate(vec4 x) { return clamp(x, 0.0, 1.0); }
float remap(float v, float a, float b, float c, float d) { return c + (v - a) * (d - c) / (b - a); }
float remapClamped(float v, float a, float b, float c, float d) { return clamp(remap(v, a, b, c, d), min(c, d), max(c, d)); }
float remapClamped(float v, float a, float b) { return clamp((v - a) / (b - a), 0.0, 1.0); }
vec4 remap(vec4 v, vec4 a, vec4 b, vec4 c, vec4 d) { return c + (v - a) * (d - c) / (b - a); }
vec4 remapClamped(vec4 v, vec4 a, vec4 b, vec4 c, vec4 d) { return clamp(remap(v, a, b, c, d), min(c, d), max(c, d)); }
vec4 remapClamped(vec4 v, vec4 a, vec4 b) { return clamp((v - a) / (b - a), 0.0, 1.0); }

vec3 reduceMagenta(vec3 color, float strength) {
  float magenta = max(0.0, min(color.r, color.b) - color.g);
  float fix = clamp(magenta * 5.0 * max(strength, 0.0), 0.0, 1.0);
  float target = color.g;
  color.r = mix(color.r, target, fix);
  color.b = mix(color.b, target, fix);
  return color;
}

vec2 raySphereIntersect(vec3 ro, vec3 rd, float radius) {
  float b = dot(ro, rd);
  float c = dot(ro, ro) - radius * radius;
  float h = b * b - c;
  if (h < 0.0) return vec2(-1.0);
  h = sqrt(h);
  return vec2(-b - h, -b + h);
}

void reconstructRay(out vec3 ro, out vec3 rd) {
  ro = u_cameraPosition + u_altitudeCorrection;
  vec2 uv = v_textureCoordinates * 2.0 - 1.0;
  vec4 clipPos = vec4(uv, 1.0, 1.0);
  vec4 viewPos = czm_inverseProjection * clipPos;
  viewPos /= viewPos.w;
  vec4 worldPos4 = czm_inverseView * viewPos;
  vec3 worldPos = worldPos4.xyz + u_altitudeCorrection;
  rd = normalize(worldPos - ro);
}

float getSTBN() {
  // 与 three-geospatial 一致：按帧在 3D STBN 的 z 维切片轮换
  ivec3 size = textureSize(u_stbnTexture, 0);
  vec3 scale = 1.0 / vec3(size);
  return texture(
    u_stbnTexture,
    vec3(gl_FragCoord.xy, float(u_frame % size.z)) * scale
  ).r;
}

vec2 getCubeSphereUv(vec3 position) {
  vec3 n = normalize(position);
  vec3 f = abs(n);
  vec3 c = n / max(f.x, max(f.y, f.z));
  vec2 m;
  if (f.y >= f.x && f.y >= f.z) { m = c.y > 0.0 ? vec2(-n.x, n.z) : n.xz; }
  else if (f.x >= f.y && f.x >= f.z) { m = c.x > 0.0 ? n.yz : vec2(-n.y, n.z); }
  else { m = c.z > 0.0 ? n.xy : vec2(n.x, -n.y); }
  vec2 m2 = m * m;
  float q = dot(m2.xy, vec2(-2.0, 2.0)) - 3.0;
  float q2 = q * q;
  vec2 uv;
  uv.x = sqrt(1.5 + m2.x - m2.y - 0.5 * sqrt(max(0.0, -24.0 * m2.x + q2))) * (m.x > 0.0 ? 1.0 : -1.0);
  uv.y = sqrt(6.0 / max(0.001, 3.0 - uv.x * uv.x)) * m.y;
  return uv * 0.5 + 0.5;
}
vec2 getGlobeUv(vec3 position) { return getCubeSphereUv(position); }

float getMipLevel(vec2 uv) {
  vec2 coord = uv * u_resolution;
  vec2 ddx_v = dFdx(coord);
  vec2 ddy_v = dFdy(coord);
  float deltaMaxSqr = max(dot(ddx_v, ddx_v), dot(ddy_v, ddy_v)) * 0.1;
  return max(0.0, 0.5 * log2(max(1.0, deltaMaxSqr)));
}

bool inEmptySpace(float height) {
  bvec3 gt = greaterThan(vec3(height), u_minIntervalHeights);
  bvec3 lt = lessThan(vec3(height), u_maxIntervalHeights);
  return gt.x && lt.x || gt.y && lt.y || gt.z && lt.z;
}

vec4 getLayerDensity(vec4 hf) {
  return u_densityProfileExpTerms * exp(u_densityProfileExponents * hf) + u_densityProfileLinearTerms * hf + u_densityProfileConstantTerms;
}

vec4 getHeightFractions(float height) {
  vec4 range = u_maxLayerHeights - u_minLayerHeights;
  return clamp((vec4(height) - u_minLayerHeights) / max(range, vec4(0.0001)), 0.0, 1.0);
}

struct WeatherSample { vec4 heightFraction; vec4 density; };
struct MediaSample { float density; vec4 weight; float scattering; float extinction; };

vec4 shapeAlteringFunction(vec4 hf, vec4 bias) {
  vec4 biased = pow(hf, bias);
  vec4 x = clamp(biased * 2.0 - 1.0, -1.0, 1.0);
  return 1.0 - x * x;
}

WeatherSample sampleWeather(vec2 uv, float height, float mipLevel) {
  WeatherSample w;
  w.heightFraction = getHeightFractions(height);
  vec2 wUv = uv * u_weatherRepeat + u_localWeatherOffset;
  vec4 localW = pow(textureLod(u_weatherTexture, wUv, mipLevel).rgba, u_weatherExponents);
  vec4 hs = shapeAlteringFunction(w.heightFraction, u_shapeAlteringBiases);
  vec4 factor = 1.0 - u_coverages * hs;
  w.density = remapClamped(mix(localW, vec4(1.0), u_coverageFilterWidths), factor, factor + u_coverageFilterWidths);
  return w;
}

MediaSample sampleMedia(WeatherSample weather, vec3 position, vec2 uv, float mipLevel, float jitter) {
  vec4 density = weather.density;
  vec3 sn = normalize(position);
  vec3 evolution = -sn * length(u_localWeatherOffset) * EVOLUTION_SCALE;
  vec2 tUv = uv * u_weatherRepeat * u_turbulenceRepeat;
  vec3 turb = u_turbulenceDisplacement * (texture(u_turbulenceTexture, tUv).rgb * 2.0 - 1.0)
      * dot(density, remapClamped(weather.heightFraction, vec4(0.3), vec4(0.0)));
  vec3 sp = (position + evolution + turb) * u_shapeRepeat + u_shapeOffset;
  float shapeTex = texture(u_shapeTexture, fract(sp)).r;
  density = remapClamped(density, vec4(1.0 - shapeTex) * u_shapeAmounts, vec4(1.0));
  if (mipLevel * 0.5 + (jitter - 0.5) * 0.5 < 0.5) {
    vec3 dp = (position + turb) * u_shapeDetailRepeat + u_shapeDetailOffset;
    float detail = texture(u_shapeDetailTexture, dp).r;
    vec4 modifier = mix(vec4(pow(detail, 6.0)), vec4(1.0 - detail),
        remapClamped(weather.heightFraction, vec4(0.2), vec4(0.4), vec4(0.0), vec4(1.0)));
    modifier = mix(vec4(0.0), modifier, u_shapeDetailAmounts);
    density = remapClamped(density * 2.0, vec4(modifier * 0.5), vec4(1.0));
  }
  density = saturate(density * u_densityScales * getLayerDensity(weather.heightFraction));
  float ds = density.x + density.y + density.z + density.w;
  MediaSample m;
  m.density = ds;
  m.weight = density / max(ds, 1e-7);
  m.scattering = ds * u_scatteringCoefficient;
  m.extinction = ds * u_absorptionCoefficient + m.scattering;
  return m;
}

float henyeyGreenstein(float g, float cosTheta) {
  float g2 = g * g;
  return RECIPROCAL_PI4 * (1.0 - g2) / pow(1.0 + g2 - 2.0 * g * cosTheta, 1.5);
}

float phaseFunction(float cosTheta, float attenuation) {
  return mix(henyeyGreenstein(u_scatterG1 * attenuation, cosTheta),
             henyeyGreenstein(u_scatterG2 * attenuation, cosTheta), u_scatterMix);
}

float approximateMultipleScattering(float opticalDepth, float cosTheta) {
  vec3 coeffs = vec3(1.0);
  const vec3 attenuation = vec3(0.5);
  float scattering = 0.0;
  for (int i = 0; i < 12; i++) {
    if (i >= u_multiScatteringOctaves) break;
    scattering += coeffs.x * exp(-opticalDepth * coeffs.y) * phaseFunction(cosTheta, coeffs.z);
    coeffs *= attenuation;
  }
  return scattering;
}

float marchOpticalDepthToSun(vec3 rayOrigin, vec3 rayDirection, float mipLevel, float jitter, out float sunRayDist) {
  float iterCount = max(0.0, remap(mipLevel, 0.0, 1.0, float(u_maxStepsToSun) + 1.0, 1.0) - jitter);
  int ic = int(iterCount);
  if (ic == 0) return 0.5;
  float stepSize = u_minSecondaryStepSize / iterCount;
  float nextDist = stepSize * jitter;
  float od = 0.0;
  sunRayDist = 0.0;
  for (int i = 0; i < 8; i++) {
    if (i >= ic) break;
    sunRayDist = nextDist;
    vec3 pos = rayDirection * nextDist + rayOrigin;
    vec2 uv = getGlobeUv(pos);
    float h = length(pos) - u_bottomRadius;
    WeatherSample ws = sampleWeather(uv, h, mipLevel);
    MediaSample ms = sampleMedia(ws, pos, uv, mipLevel, jitter);
    od += ms.extinction * stepSize;
    nextDist += stepSize;
    stepSize *= u_secondaryStepScale;
  }
  return od;
}

bool rayIntersectsGround(vec3 camPos, vec3 rd) {
  float r = length(camPos);
  float mu = dot(camPos, rd) / r;
  return mu < 0.0 && r * r * (mu * mu - 1.0) + u_bottomRadius * u_bottomRadius >= 0.0;
}

void raySphereIntersections(vec3 origin, vec3 direction, vec4 radius, out vec4 i1, out vec4 i2) {
  float b = 2.0 * dot(direction, origin);
  vec4 c = dot(origin, origin) - radius * radius;
  vec4 disc = b * b - 4.0 * c;
  vec4 mask = step(disc, vec4(0.0));
  vec4 Q = sqrt(max(vec4(0.0), disc));
  i1 = mix((-b - Q) * 0.5, vec4(-1.0), mask);
  i2 = mix((-b + Q) * 0.5, vec4(-1.0), mask);
}

void getIntersections(vec3 camPos, vec3 rd, out bool ground, out vec4 first, out vec4 second) {
  ground = rayIntersectsGround(camPos, rd);
  vec4 radii = u_bottomRadius + vec4(0.0, u_minHeight, u_maxHeight, u_shadowTopHeight);
  raySphereIntersections(camPos, rd, radii, first, second);
}

vec2 getRayNearFar(bool ground, vec4 first, vec4 second) {
  vec2 nearFar;
  if (u_cameraHeight < u_minHeight) {
     if (ground) {
        nearFar = vec2(-1.0);
    } else {
        nearFar = vec2(second.y, second.z);
        nearFar.y = min(nearFar.y, u_maxRayDistance);
    }
  } else if (u_cameraHeight < u_maxHeight) {
      if (ground) {
          // 地面相交时，采样从相机近裁面到云层下边界
          nearFar = vec2(u_cameraNear, first.y);
          if (nearFar.y <= nearFar.x) nearFar = vec2(-1.0);
      } else {
          float farExit = max(max(first.y, second.y), max(first.z, second.z));
          if (farExit <= 0.0) {
          // 无有效远边界时，强制采样到最大射线距离
          farExit = u_maxRayDistance;
          }
          farExit = min(farExit, u_maxRayDistance);
          farExit = max(farExit, u_cameraNear + u_minStepSize * 0.5);
          nearFar = vec2(u_cameraNear, farExit);
      }
  } else {
      float farExit = max(max(first.y, second.y), max(first.z, second.z));
      if (farExit > 0.0) {
          farExit = min(farExit, u_maxRayDistance);
          farExit = max(farExit, u_cameraNear + u_minStepSize * 0.5);
          nearFar = vec2(u_cameraNear, farExit);
      }
  }
  return nearFar;
}

vec2 getShadowRayNearFar(bool ground, vec4 first, vec4 second) {
  vec2 nf;
  if (u_cameraHeight < u_shadowTopHeight) {
    nf = ground ? vec2(u_cameraNear, first.x) : vec2(u_cameraNear, second.w);
  } else {
    nf = vec2(first.w, second.w);
    if (ground) nf.y = first.x;
  }
  nf.y = min(nf.y, u_maxShadowLengthRayDistance);
  return nf;
}

vec2 getHazeRayNearFar(bool ground, vec4 first, vec4 second) {
  vec2 nf;
  if (u_cameraHeight < u_maxHeight) {
    nf = ground ? vec2(u_cameraNear, first.x) : vec2(u_cameraNear, second.z);
  } else {
    nf = vec2(u_cameraNear, second.z);
    if (ground) nf.y = first.x;
  }
  return nf;
}

// ── BSM sampling ──
float sampleShadowOpticalDepth(vec3 rayPosition, float distanceOffset, float radius, float jitter);

float getDistanceToShadowTop(vec3 rayPos) {
  vec3 rd = czm_sunDirectionWC;
  float R = u_bottomRadius + u_shadowTopHeight;
  float b = dot(rayPos, rd);
  float c = dot(rayPos, rayPos) - R * R;
  float h = b * b - c;
  if (h < 0.0) return -1.0;
  return -b + sqrt(h);
}

// three.js / CloudShadowPass intervals=(d-near)/(far-near) 一致
float viewZToOrthographicDepth(float viewZ, float near, float far) {
  return (viewZ + near) / (near - far);
}

int getFadedCascadeIndex(mat4 viewMat, vec3 worldPos, vec2 intervals[4], float near, float far, float jitter) {
  vec4 vp = viewMat * vec4(worldPos, 1.0);
  float depth = viewZToOrthographicDepth(vp.z, near, far);
  int nextIndex = -1, prevIndex = -1;
  float alpha = 1.0;
  for (int i = 0; i < 4; ++i) {
    vec2 interval = intervals[i];
    float intervalCenter = (interval.x + interval.y) * 0.5;
    float closestEdge = depth < intervalCenter ? interval.x : interval.y;
    float margin = closestEdge * closestEdge * 0.5;
    interval += margin * vec2(-0.5, 0.5);
    if (i < 3) {
      if (depth >= interval.x && depth < interval.y) { prevIndex = nextIndex; nextIndex = i; alpha = saturate(min(depth - interval.x, interval.y - depth) / max(margin, 1e-6)); }
    } else {
      if (depth >= interval.x) { prevIndex = nextIndex; nextIndex = i; alpha = saturate((depth - interval.x) / max(margin, 1e-6)); }
    }
  }
  return jitter <= alpha ? nextIndex : prevIndex;
}

vec2 getShadowUv(vec3 pos, int ci) { vec4 clip = u_shadowMatrices[ci] * vec4(pos, 1.0); clip /= clip.w; return clip.xy * 0.5 + 0.5; }
vec2 getShadowAtlasOffset(int ci) { return vec2(mod(float(ci), 2.0) * 0.5, (ci < 2) ? 0.5 : 0.0); }

float readShadowOpticalDepth(vec2 uv, int ci, float distToTop, float distOff) {
  if (u_useShadowBuffer == 0) return 0.0;
  vec2 atlasUv = getShadowAtlasOffset(ci) + uv * 0.5;
  vec4 shadow = texture(u_shadowBuffer, atlasUv);
  float distToFront = max(0.0, distToTop - distOff - shadow.r);
  return min(shadow.b + shadow.a, shadow.g * distToFront);
}

float interleavedGradientNoise(vec2 coord) {
  const vec3 magic = vec3(0.06711056, 0.00583715, 52.9829189);
  return fract(magic.z * fract(dot(coord, magic.xy)));
}

vec2 vogelDisk(int index, int count, float phi) {
  const float goldenAngle = 2.39996322972865332;
  float r = sqrt(float(index) + 0.5) / sqrt(float(count));
  float theta = float(index) * goldenAngle + phi;
  return r * vec2(cos(theta), sin(theta));
}

float sampleShadowOpticalDepthPCF(vec3 worldPos, float distToTop, float distOff, float radius, int ci) {
  vec2 uv = getShadowUv(worldPos, ci);
  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) return 0.0;
  if (radius < 0.1) return readShadowOpticalDepth(uv, ci, distToTop, distOff);
  float sum = 0.0;
  float phi = interleavedGradientNoise(gl_FragCoord.xy) * 3.14159265 * 2.0;
  for (int i = 0; i < 16; ++i) sum += readShadowOpticalDepth(uv + vogelDisk(i, 16, phi) * radius * u_shadowTexelSize, ci, distToTop, distOff);
  return sum / 16.0;
}

float sampleShadowOpticalDepth(vec3 rayPos, float distOff, float radius, float jitter) {
  float distToTop = getDistanceToShadowTop(rayPos);
  if (distToTop <= 0.0) return 0.0;
  int ci = getFadedCascadeIndex(czm_view, rayPos, u_shadowIntervals, u_cameraNear, u_shadowFar, jitter);
  return ci >= 0 ? sampleShadowOpticalDepthPCF(rayPos, distToTop, distOff, radius, ci) : 0.0;
}

float marchShadowLength(vec3 rayOrigin, vec3 rayDir, vec2 rayNearFar, float jitter) {
  float shadowLen = 0.0;
  float maxDist = rayNearFar.y - rayNearFar.x;
  float stepSize = u_minShadowLengthStepSize;
  float rayDist = stepSize * jitter;
  for (int i = 0; i < 512; i++) {
    if (float(i) >= float(u_maxShadowLengthIterationCount)) break;
    if (rayDist > maxDist) break;
    vec3 pos = rayDir * rayDist + rayOrigin;
    float od = sampleShadowOpticalDepth(pos, 0.0, 0.0, jitter);
    shadowLen += (1.0 - exp(-od)) * stepSize;
    stepSize *= u_perspectiveStepScale;
    rayDist += stepSize;
  }
  return shadowLen;
}

#ifdef USE_ATMOSPHERE_IRRADIANCE
void applyAerialPerspective(vec3 camPos, vec3 frontPos, float dist, float shadowLen, inout vec4 color) {
  vec3 transmittance;
  vec3 inscatter = GetSkyRadianceToPoint(camPos * METER_TO_LENGTH_UNIT, frontPos * METER_TO_LENGTH_UNIT, shadowLen * METER_TO_LENGTH_UNIT, sunDirection, transmittance);
  float horizonBias = smoothstep(20.0, 80.0, dist * METER_TO_LENGTH_UNIT);
  // 【新增】根据太阳高度计算可见度，晚上太阳沉下地平线时 sunVis 为 0
  float sunVis = smoothstep(-0.02, 0.05, dot(normalize(camPos), sunDirection));
  vec3 fakeHorizonColor = vec3(0.5, 0.6, 0.8) * 0.2 * sunVis;
  inscatter = mix(inscatter, inscatter * 0.4 + fakeHorizonColor, horizonBias);
  color.rgb = color.rgb * transmittance + inscatter * color.a * u_aerialPerspectiveScale;
}
#else
void applyAerialPerspective(vec3 camPos, vec3 frontPos, float dist, float shadowLen, inout vec4 color) {
  vec3 rayleigh = vec3(0.005802, 0.013558, 0.033100) * 0.001;
  float h = length(frontPos) - u_bottomRadius;
  float density = exp(-h / 8000.0);
  vec3 transmittance = exp(-dist * rayleigh * density * u_aerialPerspectiveScale);
  // 【新增】太阳可见度衰减
  float sunVis = smoothstep(-0.05, 0.1, dot(normalize(camPos), sunDirection));
  vec3 skyColor = vec3(0.4, 0.6, 1.0) * u_sunIntensity * 0.02 * sunVis;
  color.rgb = color.rgb * transmittance + skyColor * (1.0 - transmittance) * color.a;
}
#endif

vec4 approximateHaze(vec3 ro, vec3 rd, float maxDist, float cosTheta, float shadowLen) {
  float modulation = remapClamped(u_coverageHaze, 0.2, 0.4);
  if (u_cameraHeight * modulation < 0.0) return vec4(0.0);
  float density = modulation * u_hazeDensityScale * exp(-u_cameraHeight * u_hazeExponent);
  if (density < 1e-7) return vec4(0.0);
  vec3 nOrigin = normalize(ro);
  float sunHeight = dot(nOrigin, sunDirection);
  float sunVis = smoothstep(-0.02, 0.05, sunHeight);
  float viewZenith = abs(rd.y);
  float horizonTaming = smoothstep(0.0, 0.15, viewZenith);
  // 即使在天际线，也要保留一点点基础亮度，但不能是 1.0
  horizonTaming = mix(0.3, 1.0, horizonTaming);
  vec3 nHoriz = (ro - dot(ro, rd) * rd) / u_bottomRadius;
  float alpha = remapClamped(dot(nOrigin, nHoriz), 0.9, 1.0);
  vec3 normal = mix(nOrigin, nHoriz, alpha);
  float angle = max(dot(normal, rd), 1e-5);
  float exponent = angle * u_hazeExponent;
  float linearTerm = density / u_hazeExponent / angle;
  float expTerm = 1.0 - exp(-maxDist * exponent);
  float shadowExpTerm = 1.0 - exp(-min(maxDist, shadowLen) * exponent);
  float opticalDepth = expTerm * linearTerm;
  float shadowOD = max((expTerm - shadowExpTerm) * linearTerm, 0.0);
  float transmittance = saturate(1.0 - exp(-opticalDepth));
  float shadowTransmittance = saturate(1.0 - exp(-shadowOD));
  // 【修改】将硬编码的光源强度乘以太阳可见度
  vec3 skyIrradiance = vec3(0.4, 0.6, 1.0) * u_sunIntensity * 0.04 * sunVis * horizonTaming;
  vec3 sunIrradiance = vec3(1.0, 0.95, 0.9) * u_sunIntensity * sunVis;
  float ph = henyeyGreenstein(u_scatterG1, cosTheta) * (1.0 - u_scatterMix) + henyeyGreenstein(u_scatterG2, cosTheta) * u_scatterMix;
  vec3 inscatter = sunIrradiance * ph * shadowTransmittance + skyIrradiance * RECIPROCAL_PI4 * u_skyLightScale * transmittance;
  inscatter *= u_hazeScatteringCoefficient / (u_hazeAbsorptionCoefficient + u_hazeScatteringCoefficient);
  return vec4(inscatter, transmittance);
}

// ── Main raymarch ──
vec4 marchClouds(vec3 rayOrigin, vec3 rd, vec2 rayNearFar, float cosTheta, float jitter, float rayStartTexels, out float frontDepth) {
  float maxDist = min(rayNearFar.y - rayNearFar.x, u_maxRayDistance);
  vec3 radInt = vec3(0.0);
  float transInt = 1.0, wdSum = 0.0, tSum = 0.0;
  float perspDist = min(rayNearFar.x, 3000.0);
  float stepSize = u_minStepSize + (u_perspectiveStepScale - 1.0) * perspDist;
  float rayDist = stepSize * jitter * 2.0;
  #ifdef USE_ATMOSPHERE_IRRADIANCE
  float refRadius = u_bottomRadius;
  #else
  vec3 sunColorBase = vec3(1.0, 0.95, 0.9) * u_sunIntensity;
  vec3 skyColorBase = vec3(0.4, 0.6, 1.0) * u_sunIntensity * u_skyToSunRatio;
  float refRadius = u_bottomRadius;
  vec3 sunDirection = czm_sunDirectionWC;
  #endif

  for (int i = 0; i < 512; i++) {
    if (float(i) >= u_maxSteps) break;
    if (rayDist > maxDist) break;
    if (transInt <= u_minTransmittance) break;
    vec3 position = rayOrigin + rd * rayDist;
    float height = length(position) - refRadius;
    float mipLevel = log2(max(1.0, rayStartTexels + rayDist * 1e-5));
    if (inEmptySpace(height)) { stepSize *= u_perspectiveStepScale; rayDist += mix(stepSize, u_maxStepSize, min(1.0, mipLevel)); continue; }
    vec2 uv = getGlobeUv(position);
    WeatherSample weather = sampleWeather(uv, height, mipLevel);
    if (!any(greaterThan(weather.density, vec4(u_minDensity)))) { stepSize *= u_perspectiveStepScale; rayDist += mix(stepSize, u_maxStepSize, min(1.0, mipLevel)); continue; }
    weather.density.xy *= u_lowLayerDensityBoost;
    MediaSample media = sampleMedia(weather, position, uv, mipLevel, jitter);
    if (media.extinction > u_minExtinction) {
      #ifdef USE_ATMOSPHERE_IRRADIANCE
      vec3 skyIrradiance;
      vec3 sunIrradiance = GetSunAndSkyScalarIrradiance(position * METER_TO_LENGTH_UNIT, sunDirection, skyIrradiance);
      float skyGradient = dot(weather.heightFraction * 0.5 + 0.5, media.weight);
      vec3 sunColor = sunIrradiance * u_sunIntensity;
      vec3 skyColor = skyIrradiance * u_sunIntensity * u_skyToSunRatio;
      #else
      float heightAlpha = clamp((height - u_minHeight) / max(u_maxHeight - u_minHeight, 1.0), 0.0, 1.0);
      vec3 sunColor = mix(sunColorBase * 0.85, sunColorBase, heightAlpha);
      vec3 skyColor = mix(skyColorBase * 0.6, skyColorBase, heightAlpha);
      float skyGradient = dot(weather.heightFraction * 0.5 + 0.5, media.weight);
      #endif
      float sunRayDist;
      float opticalDepth = marchOpticalDepthToSun(position, sunDirection, mipLevel, jitter, sunRayDist);
      if (length(position) - refRadius < u_shadowTopHeight && u_useShadowBuffer == 1) {
        vec3 sn = normalize(position);
        float r = u_maxShadowFilterRadius * remapClamped(dot(sunDirection, sn), 0.1, 0.0);
        opticalDepth += sampleShadowOpticalDepth(position, sunRayDist, r, jitter);
      }
      vec3 radiance = sunColor * approximateMultipleScattering(opticalDepth, cosTheta);
      radiance += skyColor * RECIPROCAL_PI4 * skyGradient * u_skyLightScale;
      radiance *= media.scattering * (1.0 - u_powderScale * exp(-media.extinction * u_powderExponent));
      float transmittance = exp(-media.extinction * stepSize);
      vec3 scatInt = (radiance - radiance * transmittance) / max(media.extinction, 1e-7);
      radInt += transInt * scatInt;
      transInt *= transmittance;
      wdSum += rayDist * transInt;
      tSum += transInt;
    }
    stepSize *= u_perspectiveStepScale;
    rayDist += stepSize;
  }
  frontDepth = tSum > 0.0 ? wdSum / tSum : -1.0;
  float alpha = saturate(remapClamped(transInt, 1.0, u_minTransmittance));
  return vec4(radInt, alpha);
}

void main() {
  vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
  float depth = czm_readDepth(depthTexture, v_textureCoordinates);
  vec3 ro, rd;
  reconstructRay(ro, rd);
  #ifndef USE_ATMOSPHERE_IRRADIANCE
  vec3 sunDirection = czm_sunDirectionWC;
  #endif
  float jitter = getSTBN();
  bool ground; vec4 first, second;
  getIntersections(ro, rd, ground, first, second);
  vec2 rayNearFar = getRayNearFar(ground, first, second);
  vec2 shadowNF = vec2(-1.0), hazeNF = vec2(-1.0);
  if (u_shadowLengthEnabled == 1) shadowNF = getShadowRayNearFar(ground, first, second);
  if (u_hazeEnabled == 1) hazeNF = getHazeRayNearFar(ground, first, second);

  // depthTestAgainstTerrain 只影响 Globe/贴地物体与地形网格的深度关系，不能替后处理修正「沿像素射线」的距离。
  // 此处必须用 inverseView 还原命中点，再沿 rd 求距离；用 -viewZ/dot(rd, forward) 在离轴像素上会偏大 → 云压在地形前。
  float rayDistToScene = 0.0;
  if (depth < 1.0 - 1e-7) {
    vec4 eyePos = czm_windowToEyeCoordinates(vec4(gl_FragCoord.xy, depth, 1.0));
    if (abs(eyePos.w) > 1e-6) {
      eyePos /= eyePos.w;
      if (eyePos.z < 0.0) {
        vec4 worldPos4 = czm_inverseView * eyePos;
        vec3 worldHit = worldPos4.xyz + u_altitudeCorrection;
        rayDistToScene = max(0.0, dot(worldHit - ro, rd));
      }
    }
  }
  float tMax = rayNearFar.y;
  // 原逻辑：低于云层且 !ground 时跳过深度钳位 —— 平视/看山体时 ground 常为 false，会整屏不钳位 → 云盖住地形。
  // 仅当该像素无场景深度（天空）时才允许跳过；有地形/几何时必须用 rayDistToScene 截断射线。
  const float DEPTH_SKY = 1.0 - 1e-7;
  bool skipDepthClamp =
    (depth >= DEPTH_SKY) && (u_cameraHeight < u_minHeight) && (!ground);
  if (rayDistToScene > 0.0 && !skipDepthClamp) {
    tMax = min(tMax, rayDistToScene);
    if (u_shadowLengthEnabled == 1 && shadowNF.y > 0.0) shadowNF.y = min(shadowNF.y, rayDistToScene);
    if (u_hazeEnabled == 1 && hazeNF.y > 0.0) hazeNF.y = min(hazeNF.y, rayDistToScene);
  }
  if (rayNearFar.x >= tMax) { gl_FragColor = sceneColor; return; }

  float frontDepth;
  float cosTheta = dot(rd, sunDirection);
  vec2 globeUv = getGlobeUv(ro + rd * rayNearFar.x);
  float mipLevel = getMipLevel(globeUv * u_weatherRepeat) * u_mipLevelScale;
  mipLevel = mix(0.0, mipLevel, min(1.0, 0.2 * u_cameraHeight / max(u_maxHeight, 1.0)));
  vec4 cloudColor = marchClouds(ro + rd * rayNearFar.x, rd, vec2(rayNearFar.x, tMax), cosTheta, jitter, pow(2.0, mipLevel), frontDepth);

  // 远处云透明度距离衰减：用"相机到云层入口距离"（rayNearFar.x）衰减 alpha，
  // 而非云内穿行距离。天顶云入口近不衰减，天际线云入口远衰减——只压远处透明度，不影响各层密度。
  // 这解决斜射时云层路径长导致 alpha 堆积的问题，且不误伤高空稀疏层（层2 近处不衰减）。
  float entryFade = 1.0 - smoothstep(u_distFadeStart, u_distFadeEnd, rayNearFar.x);
  cloudColor.a *= entryFade;
  cloudColor.rgb *= entryFade;

  float shadowLen = 0.0;
  bool hitClouds = frontDepth > 0.0 && cloudColor.a > max(u_edgeAlphaCutoff, 0.02);
  float rayFrontT = rayNearFar.x + frontDepth;

  if (hitClouds) {
    if (u_shadowLengthEnabled == 1 && all(greaterThanEqual(shadowNF, vec2(0.0)))) {
      shadowNF.y = mix(shadowNF.y, min(rayFrontT, shadowNF.y), cloudColor.a);
      shadowLen = marchShadowLength(ro + rd * shadowNF.x, rd, shadowNF, jitter);
    }
    if (u_hazeEnabled == 1 && all(greaterThanEqual(hazeNF, vec2(0.0))))
      hazeNF.y = mix(hazeNF.y, min(rayFrontT, hazeNF.y), cloudColor.a);
      applyAerialPerspective(ro, ro + rd * rayFrontT, rayFrontT, shadowLen, cloudColor);
    } else if (u_shadowLengthEnabled == 1 && all(greaterThanEqual(shadowNF, vec2(0.0)))) {
    shadowLen = marchShadowLength(ro + rd * shadowNF.x, rd, shadowNF, jitter);
  }

  if (u_hazeEnabled == 1) {
    float hazeDist = all(greaterThanEqual(hazeNF, vec2(0.0))) ? (hazeNF.y - hazeNF.x) : 0.0;
    vec4 haze = approximateHaze(ro, rd, hazeDist, cosTheta, shadowLen);
    cloudColor.rgb = mix(cloudColor.rgb, haze.rgb, haze.a);
    cloudColor.a = cloudColor.a * (1.0 - haze.a) + haze.a;
  }

  // 边缘裁剪：低 alpha 区域直接清零，避免云边缘细碎噪点与闪烁
  if (cloudColor.a < u_edgeAlphaCutoff) {
    cloudColor = vec4(0.0);
  }
  // 边缘裁剪后再判一次：防止“已被裁掉的薄云像素”仍进入 TAA，导致底层模型抖动
  hitClouds = hitClouds && (cloudColor.a > max(u_edgeAlphaCutoff, 0.02));

  // 边缘稳噪：低 alpha 处直接除以 alpha 会把随机误差放大成亮点/闪点
  float edgeSafeAlpha = max(cloudColor.a, 0.08);
  vec3 cloudActual = cloudColor.rgb / edgeSafeAlpha;
  cloudActual = ACESFilmic(cloudActual * u_cloudExposure);
  cloudActual = pow(cloudActual, vec3(1.0 / 2.2));

  vec4 composited = vec4(
    sceneColor.rgb * (1.0 - cloudColor.a) + cloudActual * cloudColor.a,
    // 让 history.a 表示“云覆盖度”，用于后续 TAA 历史有效性判定
    cloudColor.a
  );
  // 在最终云合成色上去品红，按云覆盖度加权，确保无云区域不受影响
  vec3 compositedNoMagenta = reduceMagenta(composited.rgb, u_magentaFixStrength);
  float cloudW = smoothstep(0.02, 0.3, cloudColor.a);
  composited.rgb = mix(composited.rgb, compositedNoMagenta, cloudW);

  if (u_temporalEnabled > 0 && hitClouds) {
    vec3 worldPos = ro + rd * rayFrontT - u_altitudeCorrection;
    vec4 prevClip = u_prevViewProjection * vec4(worldPos, 1.0);
    vec2 prevUv = (prevClip.xy / prevClip.w) * 0.5 + 0.5;
    if (prevUv.x >= 0.0 && prevUv.x <= 1.0 && prevUv.y >= 0.0 && prevUv.y <= 1.0) {
      vec4 history = texture(u_historyTexture, prevUv);
      // TAA 仅对“云增量”做融合，底层模型保持当前帧，减少模型虚影
      vec3 deltaNow = composited.rgb - sceneColor.rgb;
      vec3 deltaHist = history.rgb - sceneColor.rgb;
      float maxDiff = max(abs(deltaHist.r - deltaNow.r), max(abs(deltaHist.g - deltaNow.g), abs(deltaHist.b - deltaNow.b)));
      float reject = max(
        smoothstep(0.35, 0.75, maxDiff),
        smoothstep(0.004, 0.03, length(prevUv - v_textureCoordinates))
      );
      // 让低透明边缘也参与历史融合，抑制云边缘噪点“跳闪”
      float opacityW = smoothstep(0.015, 0.25, cloudColor.a);
      float a = mix(1.0, mix(u_temporalAlpha, 1.0, reject), opacityW);
      // 仅当“当前与历史”都存在足够云覆盖时才使用历史，避免把模型底色抖动带入
      float historyCloudW = smoothstep(0.02, 0.12, history.a);
      float currentCloudW = smoothstep(0.02, 0.12, cloudColor.a);
      float cloudHistoryValidity = min(historyCloudW, currentCloudW);
      a = mix(1.0, a, cloudHistoryValidity);
      vec3 deltaFiltered = mix(deltaHist, deltaNow, a);
      composited.rgb = sceneColor.rgb + deltaFiltered;
      composited.a = cloudColor.a;
    }
  }
  gl_FragColor = composited;
}
`;
}

// ─── Helper: compile & link GL program ─────────────────────────────────────

function createGLProgram(gl, vsSource, fsSource, label) {
  const vs = gl.createShader(gl.VERTEX_SHADER);
  gl.shaderSource(vs, vsSource);
  gl.compileShader(vs);
  if (!gl.getShaderParameter(vs, gl.COMPILE_STATUS)) { console.error(`[${label}] VS:`, gl.getShaderInfoLog(vs)); gl.deleteShader(vs); return null; }
  const fs = gl.createShader(gl.FRAGMENT_SHADER);
  gl.shaderSource(fs, fsSource);
  gl.compileShader(fs);
  if (!gl.getShaderParameter(fs, gl.COMPILE_STATUS)) { console.error(`[${label}] FS:`, gl.getShaderInfoLog(fs)); gl.deleteShader(vs); gl.deleteShader(fs); return null; }
  const prog = gl.createProgram();
  gl.attachShader(prog, vs); gl.attachShader(prog, fs); gl.linkProgram(prog);
  gl.deleteShader(vs); gl.deleteShader(fs);
  if (!gl.getProgramParameter(prog, gl.LINK_STATUS)) { console.error(`[${label}] link:`, gl.getProgramInfoLog(prog)); gl.deleteProgram(prog); return null; }
  return prog;
}

// ─── Main pipeline class ──────────────────────────────────────────────────

export class ThreeGeospatialPipeline {
  constructor(viewer, options = {}) {
    this.viewer = viewer;
    this.atmosphereParams = options.atmosphereParams ?? new AtmosphereParameters();
    this._frameCount = 0;
    this._gui = null;

    // 可配置的资源/shader 根路径（均带默认值，便于在任意部署路径下使用）
    this.assetsBase = options.cloudsAssetsBase ?? DEFAULT_CLOUDS_ASSETS_BASE;
    this.brunetonShaderBase = options.brunetonShaderBase ?? DEFAULT_BRUNETON_SHADER_BASE;
    this.blueNoiseUrl = options.blueNoiseUrl ?? DEFAULT_BLUE_NOISE_URL;
    this.atmosphereAssetsBase = options.atmosphereAssetsBase ?? DEFAULT_ATMOSPHERE_ASSETS_BASE;
    this.atmosphereShaderBase = options.atmosphereShaderBase ?? DEFAULT_ATMOSPHERE_SHADER_BASE;

    this.params = {
      cloudsVisible: true,
      bottomRadius: 6371860,
      layers: [
        { channel: 'r', altitude: 1800, height: 650, densityScale: 0.2, shapeAmount: 1.0, shapeDetailAmount: 1.0, weatherExponent: 1.0, shapeAlteringBias: 0.35, coverageFilterWidth: 0.6, coverage: 0.3, densityProfile: { expTerm: 0, exponent: 0, linearTerm: 0.75, constantTerm: 0.25 } },
        { channel: 'g', altitude: 2400, height: 1200, densityScale: 0.2, shapeAmount: 1.0, shapeDetailAmount: 1.0, weatherExponent: 1.0, shapeAlteringBias: 0.35, coverageFilterWidth: 0.6, coverage: 0.3, densityProfile: { expTerm: 0, exponent: 0, linearTerm: 0.75, constantTerm: 0.25 } },
        { channel: 'b', altitude: 7500, height: 500, densityScale: 0.003, shapeAmount: 0.4, shapeDetailAmount: 0.0, weatherExponent: 1.0, shapeAlteringBias: 0.35, coverageFilterWidth: 0.5, coverage: 0.3, densityProfile: { expTerm: 0, exponent: 0, linearTerm: 0.75, constantTerm: 0.25 } },
        { channel: 'a' }
      ],
      maxSteps: 500, maxStepsToSun: 8, minStepSize: 20.0, maxStepSize: 1000.0, maxRayDistance: 200000.0,
      perspectiveStepScale: 1.005, minDensity: 1e-5, minExtinction: 1e-5, minTransmittance: 0.01,
      // 远处云距离衰减（米）：天际线附近射线斜穿云层累积过密，从 distFadeStart 起线性衰减到 distFadeEnd 完全消失
      distFadeStart: 11000.0, distFadeEnd: 51000.0,
      minSecondaryStepSize: 100.0, secondaryStepScale: 2.0, multiScatteringOctaves: 8, lowLayerDensityBoost: 1.0,
      shadowLengthEnabled: true, useShadowBuffer: true, hazeEnabled: false,
      maxShadowLengthIterationCount: 500, minShadowLengthStepSize: 50.0, maxShadowLengthRayDistance: 200000.0,
      hazeDensityScale: 3e-5, hazeExponent: 1e-3, hazeScatteringCoefficient: 0.9, hazeAbsorptionCoefficient: 0.5,
      weatherRepeat: 100.0, shapeRepeat: 4.1, shapeDetailRepeat: 0.0005,
      turbulenceRepeat: 2.0, turbulenceDisplacement: 400.0,
      scatteringCoefficient: 1.0, absorptionCoefficient: 0.0,
      scatterG1: 0.7, scatterG2: -0.2, scatterMix: 0.5,
      sunIntensity: 20.0, skyLightScale: 1.0, skyToSunRatio: 0.28,
      powderScale: 0.8, powderExponent: 150.0,
      aerialPerspectiveScale: 1.3, cloudExposure: 3.0, magentaFixStrength: 2.0, edgeAlphaCutoff: 0.0, mipLevelScale: 0.35,
      windSpeed: 0.0, evolutionSpeed: 0.005,
      temporalEnabled: false, temporalAlpha: 0.1,
      blueNoiseScale: 1.0, jitterStrength: 1.0,
      // BSM cascade 几何：shadowFar 控制覆盖最远距离，splitLambda 控制近处分配，fadeScale 扩大 ortho radius 防切割
      // fadeScale 提高以扩大 ortho 覆盖，避免 cascade 矩形外硬切；不再依赖 UV edgeFade
      shadowFar: 40000, shadowSplitLambda: 1.0, shadowFadeScale: 5.0,
    };

    this.atmosphere = null;
    this.aerial = null;
    this.cloudStage = null;
    this.textures = null;
    this._ready = null;

    // BSM state
    this._bsm = { pass: null, resolve: null, blitFbo: null, blitProg: null, blitVbo: null };
    // TAA state
    this._taa = { texA: null, texB: null, current: 0, pbo: null, pboReady: false, w: 0, h: 0, frameCount: 0, prevVP: null, curVP: null };
    // Wind offsets
    this._weatherOffsetX = 0; this._weatherOffsetY = 0;
    this._shapeOffsetX = 0; this._shapeOffsetY = 0; this._shapeOffsetZ = 0;
    this._shapeDetailOffsetX = 0; this._shapeDetailOffsetY = 0; this._shapeDetailOffsetZ = 0;
    this._lastFrameTime = undefined;
    this._listeners = [];

    // 原始 WebGL2 云渲染状态
    this._raw = {
      prog: null,        // 云渲染着色器程序
      vao: null,         // 全屏四边形 VAO
      vbo: null,         // 全屏四边形 VBO
      sceneColor: null,  // 场景颜色拷贝纹理
      depthTex: null,    // 场景深度拷贝纹理
      depthFbo: null,    // 深度拷贝用 FBO
      depthW: 0,
      depthH: 0,
      texUnits: {},      // 纹理 uniform 到纹理单元映射
    };
  }

  // ── Raw WebGL2 云渲染片段着色器（czm_* 替换为原始 uniform）────────────

  /**
   * 返回一个自包含的 GLSL #version 100 片段着色器。
   * 将 Cesium PostProcessStage 中的 czm_* 内置变量替换为显式 uniform，
   * 移除了 USE_ATMOSPHERE_IRRADIANCE（改用简化 Rayleigh 天光模型）。
   * 输出使用 gl_FragColor。
   */
  _getRawCloudFragmentShader() {
    let src = getCloudFragmentShader();

    // #version 100 兼容：in → varying
    src = src.replace('in vec2 v_textureCoordinates;', 'varying vec2 v_textureCoordinates;');

    // 在文件头部插入 extension 声明 + 新增 uniform
    const header = `#extension GL_OES_texture_3D : enable
precision highp float;
precision highp sampler2D;
precision highp sampler3D;

uniform mat4 u_inverseProjection;
uniform mat4 u_inverseView;
uniform mat4 u_viewMatrix;
uniform vec3 u_sunDirection;

`;
    // 找到第一个非注释行（跳过开头的 const 声明、main 之前的代码）
    // 直接在所有代码之前插入 header
    // getCloudFragmentShader() 以模板字面量 \` 开始，内容以 const float 开头
    // 我们先移除 precision 和 extension 行（如果有的话），再插入
    // 但原始 shader 在 _buildCloudFragmentShader 里才加 precision，这里裸的 getCloudFragmentShader 没有 precision 行
    // 直接在开头插入即可

    // 在第一个非空白、非注释行之前插入 header
    // getCloudFragmentShader() 第一行是 `\nconst float RECIPROCAL_PI4...`
    // 我们把 header 插在 const float RECIPROCAL_PI4 之前
    src = header + src;

    // #define USE_ATMOSPHERE_IRRADIANCE 相关代码不再需要，但 shader 默认没有 #define USE_ATMOSPHERE_IRRADIANCE
    // （它仅在 _buildCloudFragmentShader 中被定义），所以 else 分支会走简化 Rayleigh 模型。
    // 不需要额外操作。

    // 替换 czm_* 为 uniform
    // 注意替换顺序：先长后短，避免部分匹配
    src = src.replace(/czm_windowToEyeCoordinates\(vec4\(gl_FragCoord\.xy,\s*depth,\s*1\.0\)\)/g,
      '(u_inverseProjection * vec4(gl_FragCoord.x * 2.0 / u_resolution.x - 1.0, gl_FragCoord.y * 2.0 / u_resolution.y - 1.0, depth * 2.0 - 1.0, 1.0))');
    src = src.replace(/czm_inverseProjection/g, 'u_inverseProjection');
    src = src.replace(/czm_inverseView/g, 'u_inverseView');
    src = src.replace(/czm_sunDirectionWC/g, 'u_sunDirection');
    src = src.replace(/czm_view/g, 'u_viewMatrix');
    src = src.replace(/czm_readDepth\(depthTexture,\s*v_textureCoordinates\)/g,
      'texture2D(depthTexture, v_textureCoordinates).r');

    return src;
  }

  // ── Texture loading ────────────────────────────────────────────────────

  async _load3DTexture(url, size) {
    const data3D = await loadBinThreeGeospatial(url, size);
    return bindData3DTextureToCesiumContext(this.viewer, data3D, Cesium);
  }

  async _load3DTextureWHD(url, width, height, depth) {
    const arrayBuffer = await Cesium.Resource.fetchArrayBuffer(url);
    const raw = new Uint8Array(arrayBuffer);
    const context = this.viewer.scene.context;
    const gl = context._gl;
    try {
      return new Cesium.Texture3D({
        context,
        width,
        height,
        depth,
        pixelFormat: Cesium.PixelFormat.RED,
        pixelDatatype: Cesium.PixelDatatype.UNSIGNED_BYTE,
        source: {
          arrayBufferView: raw,
          width,
          height,
          depth,
        },
        sampler: new Cesium.Sampler({
          minificationFilter: Cesium.TextureMinificationFilter.LINEAR,
          magnificationFilter: Cesium.TextureMagnificationFilter.LINEAR,
          wrapS: Cesium.TextureWrap.REPEAT,
          wrapT: Cesium.TextureWrap.REPEAT,
          wrapR: Cesium.TextureWrap.REPEAT,
        }),
      });
    } catch (e) {
      console.warn('[Pipeline] Cesium.Texture3D 失败，使用原生 WebGL2 回退:', e.message);
      const tex = gl.createTexture();
      gl.bindTexture(gl.TEXTURE_3D, tex);
      gl.texImage3D(gl.TEXTURE_3D, 0, gl.R8, width, height, depth, 0, gl.RED, gl.UNSIGNED_BYTE, raw);
      gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
      gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
      gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_S, gl.REPEAT);
      gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_T, gl.REPEAT);
      gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_R, gl.REPEAT);
      gl.bindTexture(gl.TEXTURE_3D, null);
      return {
        _texture: tex,
        _textureTarget: gl.TEXTURE_3D,
        _target: gl.TEXTURE_3D,
        width, height, depth,
        bind: function(textureUnit) {
          gl.activeTexture(gl.TEXTURE0 + textureUnit);
          gl.bindTexture(gl.TEXTURE_3D, tex);
        },
        destroy: function() { gl.deleteTexture(tex); }
      };
    }
  }

  async _load2DTexture(url) {
    const img = await Cesium.Resource.fetchImage(url);
    if (!img || img.width <= 2 || img.height <= 2) throw new Error(`Invalid image: ${url}`);
    return new Cesium.Texture({
      context: this.viewer.scene.context, source: img,
      sampler: new Cesium.Sampler({ minificationFilter: Cesium.TextureMinificationFilter.LINEAR, magnificationFilter: Cesium.TextureMagnificationFilter.LINEAR, wrapS: Cesium.TextureWrap.REPEAT, wrapT: Cesium.TextureWrap.REPEAT })
    });
  }

  async _loadTextures() {
    const bp = this.assetsBase;
    const [shape, detail, stbn, weather, turb, noise] = await Promise.all([
      this._load3DTexture(bp + "shape.bin", 128).catch(() => null),
      this._load3DTexture(bp + "shape_detail.bin", 32).catch(() => null),
      this._load3DTextureWHD(bp + "stbn.bin", 128, 128, 64).catch(() => null),
      this._load2DTexture(bp + "local_weather.png").catch(() => null),
      this._load2DTexture(bp + "turbulence.png").catch(() => null),
      this._load2DTexture(this.blueNoiseUrl).catch(() => null),
    ]);
    this.textures = { shape, shapeDetail: detail, stbn, weather, turbulence: turb, blueNoise: noise };
    console.log("[Pipeline] textures:", Object.fromEntries(Object.entries(this.textures).map(([k, v]) => [k, !!v])));
  }

  // ── Shader loading for Bruneton prefix ─────────────────────────────────

  async _loadShader(name) {
    return loadShaderSource(name, { shaderBaseUrl: this.brunetonShaderBase });
  }

  async _buildCloudFragmentShader() {
    const provider = this.atmosphere.getAtmosphereForClouds();
    const [definitions, common, runtime] = await Promise.all([
      this._loadShader("definitions.glsl"),
      this._loadShader("common.glsl"),
      this._loadShader("runtime.glsl"),
    ]);
    const defines = "precision highp float;\nprecision highp sampler2D;\nprecision highp sampler3D;\n"
      + provider.constants.getShaderDefines()
      + "\n#define METER_TO_LENGTH_UNIT 0.001\n#define USE_ATMOSPHERE_IRRADIANCE\n";
    const globalU = `
uniform vec3 sunDirection;
uniform AtmosphereParameters ATMOSPHERE;
uniform vec3 SUN_SPECTRAL_RADIANCE_TO_LUMINANCE;
uniform vec3 SKY_SPECTRAL_RADIANCE_TO_LUMINANCE;
uniform sampler2D transmittance_texture;
uniform sampler3D scattering_texture;
uniform sampler3D single_mie_scattering_texture;
uniform sampler2D irradiance_texture;
`;
    return defines + definitions + "\n" + common + "\n" + globalU + "\n" + runtime + "\n" + getCloudFragmentShader();
  }

  // ── Wind animation ─────────────────────────────────────────────────────

  _advanceOffsets() {
    const now = performance.now() / 1000;
    if (this._lastFrameTime !== undefined) {
      const dt = now - this._lastFrameTime;
      this._weatherOffsetX += (this.params.windSpeed || 0) * dt;
      this._shapeOffsetX += (this.params.evolutionSpeed || 0) * dt;
      this._shapeDetailOffsetX += (this.params.evolutionSpeed || 0) * 2 * dt;
    }
    this._lastFrameTime = now;
  }

  // ── Helpers ────────────────────────────────────────────────────────────

  _getDensityProfileVec4(key) {
    const ls = this.params.layers, def = k => k === "linearTerm" ? 0.75 : k === "constantTerm" ? 0.25 : 0;
    return new Cesium.Cartesian4(...[0,1,2,3].map(i => {
      const val = ls[i]?.densityProfile?.[key];
      return val !== undefined ? Number(val) : def(key);
    }));
  }

  _getIntervalHeights() {
    const ls = this.params.layers, entries = [];
    for (let i = 0; i < 4; i++) { const a = Number(ls[i]?.altitude) || 0, h = Number(ls[i]?.height) || 0; entries.push({ v: a, flag: 0 }, { v: a + h, flag: 1 }); }
    entries.sort((a, b) => a.v !== b.v ? a.v - b.v : a.flag - b.flag);
    const intervals = [{ min: 0, max: 0 }, { min: 0, max: 0 }, { min: 0, max: 0 }];
    let idx = 0, balance = 0;
    for (let i = 0; i < entries.length; i++) { if (balance === 0 && i > 0) { intervals[idx] = { min: entries[i - 1].v, max: entries[i].v }; idx++; } balance += entries[i].flag === 0 ? 1 : -1; }
    return { min: new Cesium.Cartesian3(intervals[0].min, intervals[1].min, intervals[2].min), max: new Cesium.Cartesian3(intervals[0].max, intervals[1].max, intervals[2].max) };
  }

  _getLayerVec4(key, fallback = 0) {
    const ls = this.params.layers;
    return new Cesium.Cartesian4(...[0,1,2,3].map(i => {
      const val = ls[i]?.[key];
      return val !== undefined ? Number(val) : fallback;
    }));
  }

  _getAltitudeCorrectionOffset(bottomRadius) {
    const ellipsoid = this.viewer?.scene?.globe?.ellipsoid;
    const cameraPos = this.viewer?.camera?.positionWC;
    if (!ellipsoid || !cameraPos) return Cesium.Cartesian3.ZERO.clone();
    const carto = Cesium.Cartographic.fromCartesian(cameraPos, ellipsoid);
    if (!carto) return Cesium.Cartesian3.ZERO.clone();
    const surface = Cesium.Cartesian3.fromRadians(
      carto.longitude,
      carto.latitude,
      0.0,
      ellipsoid
    );
    const normal = ellipsoid.geodeticSurfaceNormal(surface, new Cesium.Cartesian3());
    const center = Cesium.Cartesian3.subtract(
      surface,
      Cesium.Cartesian3.multiplyByScalar(normal, Number(bottomRadius) || 0, new Cesium.Cartesian3()),
      new Cesium.Cartesian3()
    );
    return Cesium.Cartesian3.negate(center, new Cesium.Cartesian3());
  }

  _getMinHeight() { const ls = this.params.layers; let m = Infinity; for (let i = 0; i < 4; i++) { if ((Number(ls[i]?.height) || 0) > 0) m = Math.min(m, Number(ls[i]?.altitude) || 0); } return Number.isFinite(m) ? m : 0; }
  _getMaxHeight() { const ls = this.params.layers; let m = 0; for (let i = 0; i < 4; i++) { const h = Number(ls[i]?.height) || 0; if (h > 0) m = Math.max(m, (Number(ls[i]?.altitude) || 0) + h); } return m; }

  // ── Cloud PostProcessStage uniform map ─────────────────────────────────

  _buildCloudUniforms() {
    const self = this, p = () => self.params, tex = () => self.textures;
    const provider = this.atmosphere.getAtmosphereForClouds();
    const atm = provider.getUniforms();
    const u = {
      u_shapeTexture: () => tex()?.shape,
      u_shapeDetailTexture: () => tex()?.shapeDetail,
      u_stbnTexture: () => tex()?.stbn || tex()?.shape,
      u_weatherTexture: () => tex()?.weather,
      u_turbulenceTexture: () => tex()?.turbulence,
      u_blueNoise: () => tex()?.blueNoise,
      u_blueNoiseScale: () => p().blueNoiseScale ?? 1.0,
      u_jitterStrength: () => p().jitterStrength ?? 1.0,
      u_cameraPosition: () => self.viewer.camera.positionWC,
      u_altitudeCorrection: () => {
        const br = Number(atm.bottomRadius()) || Number(p().bottomRadius) || 0;
        return self._getAltitudeCorrectionOffset(br);
      },
      u_cameraHeight: () => {
        const corr = u.u_altitudeCorrection();
        const pos = Cesium.Cartesian3.add(self.viewer.camera.positionWC, corr, new Cesium.Cartesian3());
        const br = Number(atm.bottomRadius()) || Number(p().bottomRadius) || 0;
        return Math.max(0, Cesium.Cartesian3.magnitude(pos) - br);
      },
      u_bottomRadius: () => Number(p().bottomRadius),
      u_minHeight: () => self._getMinHeight(),
      u_maxHeight: () => self._getMaxHeight(),
      u_minLayerHeights: () => self._getLayerVec4("altitude", 0),
      u_maxLayerHeights: () => { const ls = p().layers; return new Cesium.Cartesian4(...[0,1,2,3].map(i => (Number(ls[i]?.altitude)||0)+(Number(ls[i]?.height)||0))); },
      u_densityScales: () => self._getLayerVec4("densityScale", 0),
      u_shapeAmounts: () => self._getLayerVec4("shapeAmount", 0),
      u_shapeDetailAmounts: () => self._getLayerVec4("shapeDetailAmount", 0),
      u_weatherExponents: () => self._getLayerVec4("weatherExponent", 1),
      u_shapeAlteringBiases: () => self._getLayerVec4("shapeAlteringBias", 0.35),
      u_coverageFilterWidths: () => self._getLayerVec4("coverageFilterWidth", 0.6),
      u_maxSteps: () => p().maxSteps, u_maxStepsToSun: () => p().maxStepsToSun,
      u_minStepSize: () => p().minStepSize, u_maxStepSize: () => p().maxStepSize,
      u_maxRayDistance: () => p().maxRayDistance,
      u_distFadeStart: () => Number(p().distFadeStart) || 30000.0,
      u_distFadeEnd: () => Number(p().distFadeEnd) || 150000.0,
      u_cameraNear: () => Number(self.viewer.camera.frustum?.near) || 0,
      u_shadowTopHeight: () => self._getMaxHeight(),
      u_shadowLengthEnabled: () => p().shadowLengthEnabled ? 1 : 0,
      u_hazeEnabled: () => p().hazeEnabled ? 1 : 0,
      u_maxShadowLengthIterationCount: () => p().maxShadowLengthIterationCount,
      u_minShadowLengthStepSize: () => p().minShadowLengthStepSize,
      u_maxShadowLengthRayDistance: () => p().maxShadowLengthRayDistance,
      u_hazeDensityScale: () => p().hazeDensityScale, u_hazeExponent: () => p().hazeExponent,
      u_hazeScatteringCoefficient: () => p().hazeScatteringCoefficient,
      u_hazeAbsorptionCoefficient: () => p().hazeAbsorptionCoefficient,
      u_shadowBuffer: () => {
        if (p().useShadowBuffer && self._bsm.resolve) { 
          const t = self._bsmResolveGetTexture(); // 直接调用对象的原生方法
          if (t) return t; 
        }
        return tex()?.weather;
      },
      u_shadowTexelSize: () => { const tile = self._bsm.pass ? Math.floor(SHADOW_MAP_SIZE / 2) : 512; return new Cesium.Cartesian2(1 / tile, 1 / tile); },
      u_shadowIntervals: () => { if (p().useShadowBuffer && self._bsm.pass) { 
        const iv = self._bsm.pass.getShadowIntervals(); // 使用 Getter
        return iv.map(a => new Cesium.Cartesian2(a[0], a[1])); 
      } 
      return Array(4).fill(null).map(() => new Cesium.Cartesian2(0, 0)); },
      u_shadowMatrices: () => { if (p().useShadowBuffer && self._bsm.pass) return self._bsm.pass._shadowMatrices.map(m => Cesium.Matrix4.fromArray(m)); return Array(4).fill(null).map(() => Cesium.Matrix4.IDENTITY.clone()); },
      u_shadowFar: () => self._bsm.pass ? self._bsm.pass._shadowFar : p().maxShadowLengthRayDistance,
      u_maxShadowFilterRadius: () => 2.0,
      u_useShadowBuffer: () => p().useShadowBuffer ? 1 : 0,
      u_skyLightScale: () => p().skyLightScale,
      u_weatherRepeat: () => p().weatherRepeat,
      u_localWeatherOffset: () => { self._advanceOffsets(); return new Cesium.Cartesian2(self._weatherOffsetX, self._weatherOffsetY); },
      u_shapeRepeat: () => (Number(p().shapeRepeat) || 3) / 1e4,
      u_shapeOffset: () => { self._advanceOffsets(); return new Cesium.Cartesian3(self._shapeOffsetX, self._shapeOffsetY, self._shapeOffsetZ); },
      u_shapeDetailRepeat: () => p().shapeDetailRepeat,
      u_shapeDetailOffset: () => { self._advanceOffsets(); return new Cesium.Cartesian3(self._shapeDetailOffsetX, self._shapeDetailOffsetY, self._shapeDetailOffsetZ); },
      u_turbulenceRepeat: () => p().turbulenceRepeat, u_turbulenceDisplacement: () => p().turbulenceDisplacement,
      u_coverages: () => self._getLayerVec4("coverage", 0.3),
      u_coverageHaze: () => { const ls = p().layers; return Math.max(Number(ls[0]?.coverage) ?? 0.3, Number(ls[1]?.coverage) ?? 0.3, Number(ls[2]?.coverage) ?? 0.3); },
      u_scatteringCoefficient: () => p().scatteringCoefficient, u_absorptionCoefficient: () => p().absorptionCoefficient,
      u_scatterG1: () => p().scatterG1, u_scatterG2: () => p().scatterG2, u_scatterMix: () => p().scatterMix,
      u_sunIntensity: () => p().sunIntensity, u_skyToSunRatio: () => p().skyToSunRatio,
      u_powderScale: () => p().powderScale, u_powderExponent: () => p().powderExponent,
      u_aerialPerspectiveScale: () => p().aerialPerspectiveScale, u_cloudExposure: () => p().cloudExposure,
      u_magentaFixStrength: () => p().magentaFixStrength ?? 0.8,
      u_edgeAlphaCutoff: () => p().edgeAlphaCutoff ?? 0.03,
      u_resolution: () => { const ctx = self.viewer.scene.context; return new Cesium.Cartesian2(ctx.drawingBufferWidth || 1, ctx.drawingBufferHeight || 1); },
      u_mipLevelScale: () => Number(p().mipLevelScale) || 1.0,
      u_perspectiveStepScale: () => p().perspectiveStepScale ?? 1.01,
      u_minDensity: () => p().minDensity ?? 1e-5, u_minExtinction: () => p().minExtinction ?? 1e-5,
      u_minTransmittance: () => p().minTransmittance ?? 0.01,
      u_minSecondaryStepSize: () => p().minSecondaryStepSize ?? 100, u_secondaryStepScale: () => p().secondaryStepScale ?? 2,
      u_multiScatteringOctaves: () => Math.min(12, Math.max(1, p().multiScatteringOctaves ?? 8)),
      u_lowLayerDensityBoost: () => p().lowLayerDensityBoost ?? 1.0,
      u_densityProfileExpTerms: () => self._getDensityProfileVec4("expTerm"),
      u_densityProfileExponents: () => self._getDensityProfileVec4("exponent"),
      u_densityProfileLinearTerms: () => self._getDensityProfileVec4("linearTerm"),
      u_densityProfileConstantTerms: () => self._getDensityProfileVec4("constantTerm"),
      u_minIntervalHeights: () => self._getIntervalHeights().min,
      u_maxIntervalHeights: () => self._getIntervalHeights().max,
      u_historyTexture: () => { const t = self._taaGetHistoryTexture(); return t || tex()?.blueNoise; },
      u_prevViewProjection: () => self._taa.prevVP || Cesium.Matrix4.IDENTITY,
      u_temporalAlpha: () => p().temporalAlpha ?? 0.1,
      u_temporalEnabled: () => (p().temporalEnabled && self._taa.frameCount > 2 && self._taa.prevVP) ? 1 : 0,
      u_frame: () => self._frameCount || 0,
    };

    Object.assign(u, atm);
    u.u_cameraPosition = atm.cameraPosition;
    u.u_bottomRadius = atm.bottomRadius;
    return u;
  }

  // ── 原始 WebGL2 云渲染初始化 ────────────────────────────────────────────

  /**
   * 初始化原始 WebGL2 全屏四边形渲染管线。
   * @param {WebGL2RenderingContext} gl
   * @returns {boolean} 是否成功
   */
  _initRawWebGL(gl) {
    // 顶点着色器（#version 100，兼容 gl_FragColor）
    const vsSrc = `
attribute vec2 a_position;
varying vec2 v_textureCoordinates;
void main() {
    v_textureCoordinates = a_position * 0.5 + 0.5;
    gl_Position = vec4(a_position, 0.0, 1.0);
}`;

    const fsSrc = this._getRawCloudFragmentShader();

    this._raw.prog = createGLProgram(gl, vsSrc, fsSrc, 'RawCloud');
    if (!this._raw.prog) {
      console.error('[Pipeline] 原始 WebGL 云渲染程序编译失败');
      return false;
    }

    // 全屏四边形 VAO
    this._raw.vao = gl.createVertexArray();
    gl.bindVertexArray(this._raw.vao);

    this._raw.vbo = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, this._raw.vbo);
    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW);

    const posLoc = gl.getAttribLocation(this._raw.prog, 'a_position');
    if (posLoc >= 0) {
      gl.enableVertexAttribArray(posLoc);
      gl.vertexAttribPointer(posLoc, 2, gl.FLOAT, false, 0, 0);
    }

    gl.bindVertexArray(null);
    gl.bindBuffer(gl.ARRAY_BUFFER, null);

    // 场景颜色拷贝纹理
    this._raw.sceneColor = gl.createTexture();
    gl.bindTexture(gl.TEXTURE_2D, this._raw.sceneColor);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
    gl.bindTexture(gl.TEXTURE_2D, null);

    // 深度拷贝纹理 + FBO
    this._raw.depthTex = gl.createTexture();
    gl.bindTexture(gl.TEXTURE_2D, this._raw.depthTex);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
    gl.bindTexture(gl.TEXTURE_2D, null);

    this._raw.depthFbo = gl.createFramebuffer();

    // 建立纹理 uniform → 纹理单元映射表
    this._raw.texUnits = {
      colorTexture: 0,
      depthTexture: 1,
      u_shapeTexture: 2,
      u_shapeDetailTexture: 3,
      u_stbnTexture: 4,
      u_weatherTexture: 5,
      u_turbulenceTexture: 6,
      u_blueNoise: 7,
      u_shadowBuffer: 8,
      u_historyTexture: 9,
    };

    return true;
  }

  /**
   * 为原始 WebGL 云渲染设置所有 uniform。
   * 使用 _buildCloudUniforms() 获取值与 Cesium 一致的参数值。
   */
  _setRawCloudUniforms(gl, w, h) {
    const prog = this._raw.prog;
    if (!prog) return;

    const u = this._buildCloudUniforms();

    // 工具：尝试获取 uniform 位置，不存在时返回 -1
    const uloc = (name) => gl.getUniformLocation(prog, name);

    // ── 纹理绑定 ──
    const texUnits = this._raw.texUnits;

    // 场景颜色（从拷贝纹理读取）
    gl.activeTexture(gl.TEXTURE0 + texUnits.colorTexture);
    gl.bindTexture(gl.TEXTURE_2D, this._raw.sceneColor);
    const locColor = uloc('colorTexture');
    if (locColor) gl.uniform1i(locColor, texUnits.colorTexture);

    // 场景深度（从拷贝纹理读取）
    gl.activeTexture(gl.TEXTURE0 + texUnits.depthTexture);
    gl.bindTexture(gl.TEXTURE_2D, this._raw.depthTex);
    const locDepth = uloc('depthTexture');
    if (locDepth) gl.uniform1i(locDepth, texUnits.depthTexture);

    // 云 3D 纹理 + 2D 纹理
    const texBindings = [
      { name: 'u_shapeTexture', getter: u.u_shapeTexture, unit: texUnits.u_shapeTexture },
      { name: 'u_shapeDetailTexture', getter: u.u_shapeDetailTexture, unit: texUnits.u_shapeDetailTexture },
      { name: 'u_stbnTexture', getter: u.u_stbnTexture, unit: texUnits.u_stbnTexture },
      { name: 'u_weatherTexture', getter: u.u_weatherTexture, unit: texUnits.u_weatherTexture },
      { name: 'u_turbulenceTexture', getter: u.u_turbulenceTexture, unit: texUnits.u_turbulenceTexture },
      { name: 'u_blueNoise', getter: u.u_blueNoise, unit: texUnits.u_blueNoise },
      { name: 'u_shadowBuffer', getter: u.u_shadowBuffer, unit: texUnits.u_shadowBuffer },
      { name: 'u_historyTexture', getter: u.u_historyTexture, unit: texUnits.u_historyTexture },
    ];

    for (const tb of texBindings) {
      const texVal = tb.getter();
      const loc = uloc(tb.name);
      if (loc && texVal) {
        gl.activeTexture(gl.TEXTURE0 + tb.unit);
        if (texVal.bind) {
          texVal.bind(tb.unit);
        } else if (texVal._texture) {
          const target = texVal._target || gl.TEXTURE_2D;
          gl.bindTexture(target, texVal._texture);
        }
        gl.uniform1i(loc, tb.unit);
      }
    }

    // ── 数值/向量 uniform ──
    const uniformSetters = [
      { name: 'u_cameraPosition', getter: u.u_cameraPosition },
      { name: 'u_altitudeCorrection', getter: u.u_altitudeCorrection },
      { name: 'u_cameraHeight', getter: u.u_cameraHeight },
      { name: 'u_bottomRadius', getter: u.u_bottomRadius },
      { name: 'u_minHeight', getter: u.u_minHeight },
      { name: 'u_maxHeight', getter: u.u_maxHeight },
      { name: 'u_minLayerHeights', getter: u.u_minLayerHeights },
      { name: 'u_maxLayerHeights', getter: u.u_maxLayerHeights },
      { name: 'u_densityScales', getter: u.u_densityScales },
      { name: 'u_shapeAmounts', getter: u.u_shapeAmounts },
      { name: 'u_shapeDetailAmounts', getter: u.u_shapeDetailAmounts },
      { name: 'u_weatherExponents', getter: u.u_weatherExponents },
      { name: 'u_shapeAlteringBiases', getter: u.u_shapeAlteringBiases },
      { name: 'u_coverageFilterWidths', getter: u.u_coverageFilterWidths },
      { name: 'u_maxSteps', getter: u.u_maxSteps },
      { name: 'u_maxStepsToSun', getter: u.u_maxStepsToSun },
      { name: 'u_minStepSize', getter: u.u_minStepSize },
      { name: 'u_maxStepSize', getter: u.u_maxStepSize },
      { name: 'u_maxRayDistance', getter: u.u_maxRayDistance },
      { name: 'u_distFadeStart', getter: u.u_distFadeStart },
      { name: 'u_distFadeEnd', getter: u.u_distFadeEnd },
      { name: 'u_cameraNear', getter: u.u_cameraNear },
      { name: 'u_shadowTopHeight', getter: u.u_shadowTopHeight },
      { name: 'u_shadowLengthEnabled', getter: u.u_shadowLengthEnabled },
      { name: 'u_hazeEnabled', getter: u.u_hazeEnabled },
      { name: 'u_maxShadowLengthIterationCount', getter: u.u_maxShadowLengthIterationCount },
      { name: 'u_minShadowLengthStepSize', getter: u.u_minShadowLengthStepSize },
      { name: 'u_maxShadowLengthRayDistance', getter: u.u_maxShadowLengthRayDistance },
      { name: 'u_hazeDensityScale', getter: u.u_hazeDensityScale },
      { name: 'u_hazeExponent', getter: u.u_hazeExponent },
      { name: 'u_hazeScatteringCoefficient', getter: u.u_hazeScatteringCoefficient },
      { name: 'u_hazeAbsorptionCoefficient', getter: u.u_hazeAbsorptionCoefficient },
      { name: 'u_shadowTexelSize', getter: u.u_shadowTexelSize },
      { name: 'u_shadowFar', getter: u.u_shadowFar },
      { name: 'u_maxShadowFilterRadius', getter: () => 2.0 },
      { name: 'u_useShadowBuffer', getter: u.u_useShadowBuffer },
      { name: 'u_skyLightScale', getter: u.u_skyLightScale },
      { name: 'u_weatherRepeat', getter: u.u_weatherRepeat },
      { name: 'u_localWeatherOffset', getter: u.u_localWeatherOffset },
      { name: 'u_shapeRepeat', getter: u.u_shapeRepeat },
      { name: 'u_shapeOffset', getter: u.u_shapeOffset },
      { name: 'u_shapeDetailRepeat', getter: u.u_shapeDetailRepeat },
      { name: 'u_shapeDetailOffset', getter: u.u_shapeDetailOffset },
      { name: 'u_turbulenceRepeat', getter: u.u_turbulenceRepeat },
      { name: 'u_turbulenceDisplacement', getter: u.u_turbulenceDisplacement },
      { name: 'u_coverages', getter: u.u_coverages },
      { name: 'u_coverageHaze', getter: u.u_coverageHaze },
      { name: 'u_scatteringCoefficient', getter: u.u_scatteringCoefficient },
      { name: 'u_absorptionCoefficient', getter: u.u_absorptionCoefficient },
      { name: 'u_scatterG1', getter: u.u_scatterG1 },
      { name: 'u_scatterG2', getter: u.u_scatterG2 },
      { name: 'u_scatterMix', getter: u.u_scatterMix },
      { name: 'u_sunIntensity', getter: u.u_sunIntensity },
      { name: 'u_skyToSunRatio', getter: u.u_skyToSunRatio },
      { name: 'u_powderScale', getter: u.u_powderScale },
      { name: 'u_powderExponent', getter: u.u_powderExponent },
      { name: 'u_aerialPerspectiveScale', getter: u.u_aerialPerspectiveScale },
      { name: 'u_cloudExposure', getter: u.u_cloudExposure },
      { name: 'u_magentaFixStrength', getter: u.u_magentaFixStrength },
      { name: 'u_edgeAlphaCutoff', getter: u.u_edgeAlphaCutoff },
      { name: 'u_resolution', getter: () => new Cesium.Cartesian2(w, h) },
      { name: 'u_mipLevelScale', getter: u.u_mipLevelScale },
      { name: 'u_perspectiveStepScale', getter: u.u_perspectiveStepScale },
      { name: 'u_minDensity', getter: u.u_minDensity },
      { name: 'u_minExtinction', getter: u.u_minExtinction },
      { name: 'u_minTransmittance', getter: u.u_minTransmittance },
      { name: 'u_minSecondaryStepSize', getter: u.u_minSecondaryStepSize },
      { name: 'u_secondaryStepScale', getter: u.u_secondaryStepScale },
      { name: 'u_multiScatteringOctaves', getter: u.u_multiScatteringOctaves },
      { name: 'u_lowLayerDensityBoost', getter: u.u_lowLayerDensityBoost },
      { name: 'u_densityProfileExpTerms', getter: u.u_densityProfileExpTerms },
      { name: 'u_densityProfileExponents', getter: u.u_densityProfileExponents },
      { name: 'u_densityProfileLinearTerms', getter: u.u_densityProfileLinearTerms },
      { name: 'u_densityProfileConstantTerms', getter: u.u_densityProfileConstantTerms },
      { name: 'u_minIntervalHeights', getter: u.u_minIntervalHeights },
      { name: 'u_maxIntervalHeights', getter: u.u_maxIntervalHeights },
      { name: 'u_prevViewProjection', getter: u.u_prevViewProjection },
      { name: 'u_temporalAlpha', getter: u.u_temporalAlpha },
      { name: 'u_temporalEnabled', getter: u.u_temporalEnabled },
      { name: 'u_frame', getter: u.u_frame },
      { name: 'u_blueNoiseScale', getter: u.u_blueNoiseScale },
      { name: 'u_jitterStrength', getter: u.u_jitterStrength },
      // 新增原始 uniform（替代 czm_* 内置变量）
      { name: 'u_inverseProjection', getter: () => {
        const p = this.viewer.camera.frustum;
        const m = p.infiniteProjectionMatrix || p.projectionMatrix;
        const inv = new Cesium.Matrix4();
        return Cesium.Matrix4.inverse(m, inv) || Cesium.Matrix4.IDENTITY;
      }},
      { name: 'u_inverseView', getter: () => this.viewer.camera.inverseViewMatrix },
      { name: 'u_viewMatrix', getter: () => this.viewer.camera.viewMatrix },
      { name: 'u_sunDirection', getter: () => {
        // czm_sunDirectionWC 等价于从相机到太阳的归一化方向
        const sunPos = this.viewer.scene.sunPosition;
        if (!sunPos) return new Cesium.Cartesian3(0.577, 0.577, 0.577);
        return Cesium.Cartesian3.normalize(sunPos, new Cesium.Cartesian3());
      }},
    ];

    // 处理 shadowIntervals（数组）和 shadowMatrices（数组）
    // 特别注意 czm_view 和 czm_sunDirectionWC 已替换为 u_viewMatrix / u_sunDirection

    for (const s of uniformSetters) {
      const loc = uloc(s.name);
      if (!loc) continue;

      let val;
      try {
        val = s.getter();
      } catch (e) {
        // uniform getter 可能依赖未就绪的状态（如 TAA history），跳过
        continue;
      }
      if (val === null || val === undefined) continue;

      this._setRawGLUniform(gl, loc, val);
    }

    // ── 数组 uniform ──
    // u_shadowIntervals: uniform vec2[4]
    const locSI = uloc('u_shadowIntervals');
    if (locSI) {
      const intervals = u.u_shadowIntervals();
      if (intervals && intervals.length === 4) {
        const flat = [];
        for (let i = 0; i < 4; i++) {
          const iv = intervals[i];
          if (iv && iv.x !== undefined) { flat.push(iv.x, iv.y); }
          else { flat.push(0, 0); }
        }
        gl.uniform2fv(locSI, flat);
      }
    }

    // u_shadowMatrices: uniform mat4[4]
    const locSM = uloc('u_shadowMatrices');
    if (locSM) {
      const mats = u.u_shadowMatrices();
      if (mats && mats.length === 4) {
        for (let i = 0; i < 4; i++) {
          const m = mats[i];
          if (m && m.values) {
            gl.uniformMatrix4fv(uloc(`u_shadowMatrices[${i}]`) || locSM, false, m.values);
          }
        }
      }
    }
  }

  /**
   * 将 Cesium 类型值转换为原始 WebGL uniform 调用。
   */
  _setRawGLUniform(gl, loc, val) {
    if (val === null || val === undefined) return;

    // Cesium 类型判断
    const isCesiumObj = val.constructor && typeof val.constructor.name === 'string';
    const typeName = val.constructor?.name;

    if (typeof val === 'number') {
      gl.uniform1f(loc, val);
    } else if (typeof val === 'boolean') {
      gl.uniform1i(loc, val ? 1 : 0);
    } else if (typeName === 'Cartesian2' || (val.x !== undefined && val.y !== undefined && val.z === undefined && val.w === undefined)) {
      gl.uniform2f(loc, Number(val.x), Number(val.y));
    } else if (typeName === 'Cartesian3' || (val.x !== undefined && val.y !== undefined && val.z !== undefined && val.w === undefined)) {
      gl.uniform3f(loc, Number(val.x), Number(val.y), Number(val.z));
    } else if (typeName === 'Cartesian4' || (val.x !== undefined && val.y !== undefined && val.z !== undefined && val.w !== undefined)) {
      gl.uniform4f(loc, Number(val.x), Number(val.y), Number(val.z), Number(val.w));
    } else if (typeName === 'Matrix4') {
      gl.uniformMatrix4fv(loc, false, val.values);
    } else if (typeName === 'Matrix3') {
      gl.uniformMatrix3fv(loc, false, val.values);
    } else if (typeName === 'Matrix2') {
      gl.uniformMatrix2fv(loc, false, val.values);
    } else if (Array.isArray(val)) {
      if (val.length === 2) gl.uniform2fv(loc, val);
      else if (val.length === 3) gl.uniform3fv(loc, val);
      else if (val.length === 4) gl.uniform4fv(loc, val);
      else if (val.length === 9) gl.uniformMatrix3fv(loc, false, val);
      else if (val.length === 16) gl.uniformMatrix4fv(loc, false, val);
      else if (val.length === 1) gl.uniform1f(loc, val[0]);
    } else if (val._texture) {
      // 纹理 uniform 已在 _setRawCloudUniforms 中单独处理
    } else if (typeof val === 'object' && val !== null) {
      // 尝试作为 Cartesian 兼容对象处理
      const keys = Object.keys(val).filter(k => !isNaN(Number(k)));
      if (keys.length > 0) {
        const arr = keys.map(k => Number(val[k]));
        if (arr.length <= 4) {
          if (arr.length === 1) gl.uniform1f(loc, arr[0]);
          else if (arr.length === 2) gl.uniform2fv(loc, arr);
          else if (arr.length === 3) gl.uniform3fv(loc, arr);
          else if (arr.length === 4) gl.uniform4fv(loc, arr);
        }
      }
    }
  }

  /**
   * 在 postRender 中执行原始 WebGL2 云渲染。
   * 拷贝当前帧缓冲区的颜色和深度，然后渲染全屏四边形。
   */
  _renderRawClouds(gl) {
    if (!this._raw.prog || !this._raw.vao) return;

    const canvas = this.viewer.scene.canvas;
    const w = canvas.width;
    const h = canvas.height;
    if (w < 2 || h < 2) return;

    // 如果画布尺寸变化，重新分配纹理
    if (this._raw.depthW !== w || this._raw.depthH !== h) {
      gl.bindTexture(gl.TEXTURE_2D, this._raw.depthTex);
      gl.texImage2D(gl.TEXTURE_2D, 0, gl.DEPTH_COMPONENT24, w, h, 0, gl.DEPTH_COMPONENT, gl.UNSIGNED_INT, null);
      gl.bindTexture(gl.TEXTURE_2D, null);

      gl.bindTexture(gl.TEXTURE_2D, this._raw.sceneColor);
      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, w, h, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
      gl.bindTexture(gl.TEXTURE_2D, null);

      gl.bindFramebuffer(gl.FRAMEBUFFER, this._raw.depthFbo);
      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, this._raw.depthTex, 0);
      // 深度拷贝 FBO 仅有深度附着，无颜色附着——需设置 NONE 以避免 FRAMEBUFFER_INCOMPLETE
      gl.drawBuffers([gl.NONE]);
      gl.readBuffer(gl.NONE);
      gl.bindFramebuffer(gl.FRAMEBUFFER, null);

      this._raw.depthW = w;
      this._raw.depthH = h;
    }

    // 保存 GL 状态
    const prevFbo = gl.getParameter(gl.FRAMEBUFFER_BINDING);
    const prevVp = gl.getParameter(gl.VIEWPORT);
    const prevBlend = gl.getParameter(gl.BLEND);
    const prevDepthTest = gl.getParameter(gl.DEPTH_TEST);
    const prevCullFace = gl.getParameter(gl.CULL_FACE);
    const prevProg = gl.getParameter(gl.CURRENT_PROGRAM);
    const prevVAO = gl.getParameter(gl.VERTEX_ARRAY_BINDING);

    // 1. 拷贝场景颜色到纹理
    gl.bindTexture(gl.TEXTURE_2D, this._raw.sceneColor);
    gl.copyTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 0, 0, w, h);

    // 2. 拷贝场景深度到纹理
    gl.bindFramebuffer(gl.READ_FRAMEBUFFER, prevFbo ? prevFbo : null);
    gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, this._raw.depthFbo);
    try {
      gl.blitFramebuffer(0, 0, w, h, 0, 0, w, h, gl.DEPTH_BUFFER_BIT, gl.NEAREST);
    } catch (e) {
      // 深度拷贝可能因 FBO 不兼容而失败，静默忽略
    }

    // 3. 渲染云层到当前帧缓冲
    gl.bindFramebuffer(gl.FRAMEBUFFER, prevFbo ? prevFbo : null);
    gl.viewport(0, 0, w, h);

    gl.disable(gl.BLEND);
    gl.disable(gl.DEPTH_TEST);
    gl.disable(gl.CULL_FACE);

    gl.useProgram(this._raw.prog);
    gl.bindVertexArray(this._raw.vao);

    this._setRawCloudUniforms(gl, w, h);

    gl.drawArrays(gl.TRIANGLES, 0, 3);

    // 4. 恢复状态
    gl.bindVertexArray(prevVAO);
    gl.useProgram(prevProg);
    if (prevBlend) gl.enable(gl.BLEND); else gl.disable(gl.BLEND);
    if (prevDepthTest) gl.enable(gl.DEPTH_TEST); else gl.disable(gl.DEPTH_TEST);
    if (prevCullFace) gl.enable(gl.CULL_FACE); else gl.disable(gl.CULL_FACE);
    gl.viewport(prevVp[0], prevVp[1], prevVp[2], prevVp[3]);
  }

  // ── BSM helpers ─────────────────────────────────────────────────────────

  _bsmResolveGetTexture() {
    const r = this._bsm.resolve;
    const tex = r ? r._historyTex : (this._bsm.pass ? this._bsm.pass._colorTexture : null);
    if (!tex) return null;
    const gl = this.viewer.scene.context._gl;
    return { 
      _texture: tex, 
      _textureTarget: gl.TEXTURE_2D, 
      _target: gl.TEXTURE_2D,
      // 【关键注入】Cesium 必须调用此方法才能把纹理挂载到 GPU
      bind: function(textureUnit) {
          gl.activeTexture(gl.TEXTURE0 + textureUnit);
          gl.bindTexture(gl.TEXTURE_2D, this._texture);
      }
    };
  }

  _taaGetHistoryTexture() {
    const gl = this.viewer.scene.context?._gl;
    if (!gl) return null;
    const tex = this._taa.current === 0 ? this._taa.texA : this._taa.texB;
    if (!tex) return null;
    return { _texture: tex, _textureTarget: gl.TEXTURE_2D, _target: gl.TEXTURE_2D };
  }

  // ── BSM blit to Cesium.Texture ─────────────────────────────────────────

  _blitBSM(sourceTex, targetCesiumTex, scale) {
    const gl = this.viewer.scene.context?._gl;
    if (!gl || !sourceTex?._texture || !targetCesiumTex?._texture) return;
    if (!this._bsm.blitFbo) {
      this._bsm.blitFbo = gl.createFramebuffer();
      this._bsm.blitProg = createGLProgram(gl,
        `#version 300 es\nin vec2 a_pos;\nout vec2 v_uv;\nvoid main(){v_uv=a_pos*0.5+0.5;gl_Position=vec4(a_pos,0,1);}`,
        `#version 300 es\nprecision highp float;\nuniform sampler2D u_src;\nuniform float u_scale;\nin vec2 v_uv;\nout vec4 o;\nvoid main(){vec4 raw=texture(u_src,v_uv);\n  // 编码：rgba *= scale。HALF_FLOAT(scale=1)等价透传；RGBA8(scale=0.02)压到0..1，消费端 /scale 还原。\n  o=vec4(raw.rgb*u_scale, raw.a*u_scale);}`,
        "BSMBlit");
      const vbo = gl.createBuffer();
      gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
      gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1,-1, 3,-1, -1,3]), gl.STATIC_DRAW);
      this._bsm.blitVbo = vbo;
    }
    const prevFbo = gl.getParameter(gl.FRAMEBUFFER_BINDING), prevVp = gl.getParameter(gl.VIEWPORT);
    gl.bindFramebuffer(gl.FRAMEBUFFER, this._bsm.blitFbo);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, targetCesiumTex._texture, 0);
    if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE) { gl.bindFramebuffer(gl.FRAMEBUFFER, prevFbo); gl.viewport(...prevVp); return; }
    gl.viewport(0, 0, BSM_BLIT_SIZE, BSM_BLIT_SIZE);
    gl.useProgram(this._bsm.blitProg);
    gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D, sourceTex._texture);
    gl.uniform1i(gl.getUniformLocation(this._bsm.blitProg, "u_src"), 0);
    gl.uniform1f(gl.getUniformLocation(this._bsm.blitProg, "u_scale"), scale);
    gl.bindBuffer(gl.ARRAY_BUFFER, this._bsm.blitVbo);
    const aloc = gl.getAttribLocation(this._bsm.blitProg, "a_pos");
    if (aloc >= 0) { gl.enableVertexAttribArray(aloc); gl.vertexAttribPointer(aloc, 2, gl.FLOAT, false, 0, 0); }
    gl.drawArrays(gl.TRIANGLES, 0, 3);
    if (aloc >= 0) gl.disableVertexAttribArray(aloc);
    gl.bindFramebuffer(gl.FRAMEBUFFER, prevFbo); gl.viewport(prevVp[0], prevVp[1], prevVp[2], prevVp[3]);
  }

  // ── BSM sync to Atmosphere + Aerial ────────────────────────────────────

  _syncBSM() {
    const sp = this._bsm.pass;
    if (!sp || !this.params.useShadowBuffer) {
      this.atmosphere?.setCloudShadow?.({ enabled: false });
      this.aerial?.setCloudShadow?.({ enabled: false });
      return;
    }
    sp.updateDynamicParams({
      localWeatherOffset: [this._weatherOffsetX || 0, this._weatherOffsetY || 0],
      shapeOffset: [this._shapeOffsetX || 0, this._shapeOffsetY || 0, this._shapeOffsetZ || 0],
      shapeDetailOffset: [this._shapeDetailOffsetX || 0, this._shapeDetailOffsetY || 0, this._shapeDetailOffsetZ || 0],
      bottomRadius: this.params.bottomRadius,
      // 每帧同步 shadow cascade far，限制到云层相关距离（避免 Cesium frustum.far~8e8 导致矩阵 NaN）
      shadowFar: Number(this.params.shadowFar) || Number(this.params.maxShadowLengthRayDistance) || 200000.0,
      maxShadowLengthRayDistance: Number(this.params.maxShadowLengthRayDistance) || 200000.0,
      shadowSplitLambda: Number(this.params.shadowSplitLambda) || 0.5,
      shadowFadeScale: Number(this.params.shadowFadeScale) || 1.0,
      // 同步 layer 参数（coverage/densityScale 等），否则 GUI 调 coverage 只影响主云，BSM 阴影不变
      // 用普通数组（非 Cartesian4），因为 BSM 的 set4f 走原生 gl.uniform4fv 只接受数组/Float32Array
      coverages: [0,1,2,3].map(i => { const v = this.params.layers[i]?.coverage; return v !== undefined ? Number(v) : 0.3; }),
      densityScales: [0,1,2,3].map(i => { const v = this.params.layers[i]?.densityScale; return v !== undefined ? Number(v) : 0; }),
      shapeAmounts: [0,1,2,3].map(i => { const v = this.params.layers[i]?.shapeAmount; return v !== undefined ? Number(v) : 0; }),
      shapeDetailAmounts: [0,1,2,3].map(i => { const v = this.params.layers[i]?.shapeDetailAmount; return v !== undefined ? Number(v) : 0; }),
      weatherExponents: [0,1,2,3].map(i => { const v = this.params.layers[i]?.weatherExponent; return v !== undefined ? Number(v) : 1; }),
      shapeAlteringBiases: [0,1,2,3].map(i => { const v = this.params.layers[i]?.shapeAlteringBias; return v !== undefined ? Number(v) : 0.35; }),
      coverageFilterWidths: [0,1,2,3].map(i => { const v = this.params.layers[i]?.coverageFilterWidth; return v !== undefined ? Number(v) : 0.6; }),
      scatteringCoefficient: Number(this.params.scatteringCoefficient) ?? 0.9,
      absorptionCoefficient: Number(this.params.absorptionCoefficient) ?? 1.0,
    });

    let tex = this._bsm.resolve ? this._bsmResolveGetTexture() : null;
    if (!tex) tex = sp.getTexture();
    if (!tex) { this.atmosphere?.setCloudShadow?.({ enabled: false }); this.aerial?.setCloudShadow?.({ enabled: false }); return; }

    const provider = this.atmosphere?.getAtmosphereForClouds?.();
    const targetTex = provider?.getCloudShadowTargetTexture?.();
    const clamp01 = provider?.getCloudShadowClamp01?.() ?? true;
    const scaleToPass = clamp01 ? 200.0 : 1.0;
    let textureToPass = tex;

    if (targetTex && tex._texture) { this._blitBSM(tex, targetTex, scaleToPass); textureToPass = targetTex; }

    const intervals = sp.getShadowIntervals();
    const mats = sp.getShadowMatrices();
    const tile = sp.getTileSize?.() || Math.floor(SHADOW_MAP_SIZE / 2);
    // 远距几何误差修正：相机越高/越远，越把 BSM 采样点拉向稳定球面（对齐 three-geospatial correctGeometricError）
    const camH = this.viewer.camera.positionCartographic?.height ?? 0;
    const geoAmt = Math.min(1, Math.max(0, (camH - 2000) / 25000));
    const opts = {
      enabled: true, texture: textureToPass, scale: scaleToPass,
      decode: { x: 1, y: 1, z: 1, w: 1 },
      near: sp.getShadowNear?.() ?? (Number(this.viewer.camera.frustum?.near) || 0.1),
      far: sp.getShadowFar(),
      topHeight: this._getMaxHeight(), bottomRadius: Number(this.params.bottomRadius) || 6371000,
      intervals: intervals.map(a => new Cesium.Cartesian2(a[0], a[1])),
      matrices: mats.map(m => Cesium.Matrix4.fromArray(m)),
      texelSize: { x: 1 / tile, y: 1 / tile },
      geometricErrorCorrectionAmount: geoAmt,
    };
    this.atmosphere?.setCloudShadow?.(opts);
    this.aerial?.setCloudShadow?.(opts);
  }

  // ── TAA (inline CloudsResolvePass) ─────────────────────────────────────

  _taaCapture() {
    const gl = this.viewer.scene.context?._gl;
    if (!gl) return;
    const canvas = this.viewer.scene.canvas;
    const w = canvas.width, h = canvas.height;
    if (w !== this._taa.w || h !== this._taa.h) {
      if (this._taa.texA) gl.deleteTexture(this._taa.texA);
      if (this._taa.texB) gl.deleteTexture(this._taa.texB);
      if (this._taa.pbo) gl.deleteBuffer(this._taa.pbo);
      const mkTex = () => { const t = gl.createTexture(); gl.bindTexture(gl.TEXTURE_2D, t); gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, w, h, 0, gl.RGBA, gl.UNSIGNED_BYTE, null); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); gl.bindTexture(gl.TEXTURE_2D, null); return t; };
      this._taa.texA = mkTex(); this._taa.texB = mkTex();
      this._taa.pbo = gl.createBuffer(); gl.bindBuffer(gl.PIXEL_PACK_BUFFER, this._taa.pbo); gl.bufferData(gl.PIXEL_PACK_BUFFER, w * h * 4, gl.STREAM_READ); gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
      this._taa.w = w; this._taa.h = h; this._taa.frameCount = 0; this._taa.pboReady = false;
    }
    const writeTex = this._taa.current === 0 ? this._taa.texB : this._taa.texA;
    if (this._taa.pboReady) {
      const prevTex = gl.getParameter(gl.TEXTURE_BINDING_2D);
      const flipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL), premul = gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);
      if (flipY) gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
      if (premul) gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
      gl.bindBuffer(gl.PIXEL_UNPACK_BUFFER, this._taa.pbo);
      gl.bindTexture(gl.TEXTURE_2D, writeTex);
      gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, 0);
      gl.bindTexture(gl.TEXTURE_2D, prevTex);
      gl.bindBuffer(gl.PIXEL_UNPACK_BUFFER, null);
      if (flipY) gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
      if (premul) gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
      this._taa.current = 1 - this._taa.current;
      this._taa.frameCount++;
    }
    const prevFbo = gl.getParameter(gl.FRAMEBUFFER_BINDING);
    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
    gl.bindBuffer(gl.PIXEL_PACK_BUFFER, this._taa.pbo);
    gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, 0);
    gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
    if (prevFbo) gl.bindFramebuffer(gl.FRAMEBUFFER, prevFbo);
    this._taa.pboReady = true;
  }

  _taaUpdateVP() {
    this._taa.prevVP = this._taa.curVP;
    const cam = this.viewer.camera;
    this._taa.curVP = Cesium.Matrix4.multiply(cam.frustum.projectionMatrix, cam.viewMatrix, new Cesium.Matrix4());
  }

  // ── GUI ────────────────────────────────────────────────────────────────

  _setupGUI() {
    if (this._gui) return;
    this._gui = new dat.GUI({ name: "体积云管线" });
    const p = this.params, ls = p.layers;
    const f = this._gui.addFolder("云层");
    f.add(ls[0], "altitude", 0, 20000, 50).name("层0底高(m)");
    f.add(ls[0], "height", 0, 10000, 50).name("层0厚度(m)");
    f.add(ls[0], "coverage", 0, 1, 0.01).name("层0覆盖度");
    f.add(ls[1], "altitude", 0, 20000, 50).name("层1底高(m)");
    f.add(ls[1], "height", 0, 10000, 50).name("层1厚度(m)");
    f.add(ls[1], "coverage", 0, 1, 0.01).name("层1覆盖度");
    f.add(ls[2], "altitude", 0, 20000, 50).name("层2底高(m)");
    f.add(ls[2], "height", 0, 10000, 50).name("层2厚度(m)");
    f.add(ls[2], "coverage", 0, 1, 0.01).name("层2覆盖度");
    // 降高频相关参数（用于抑制边缘噪点/闪烁）
    f.add(p, "shapeRepeat", 1.0, 8.0, 0.1).name("主体噪声频率");
    f.add(p, "shapeDetailRepeat", 0.0005, 0.02, 0.0001).name("细节噪声频率");
    f.add(ls[0], "shapeDetailAmount", 0.0, 1.5, 0.01).name("层0细节权重");
    f.add(ls[1], "shapeDetailAmount", 0.0, 1.5, 0.01).name("层1细节权重");
    f.add(ls[2], "shapeDetailAmount", 0.0, 1.5, 0.01).name("层2细节权重");
    f.add(ls[0], "weatherExponent", 0.2, 2.0, 0.01).name("层0天气指数");
    f.add(ls[1], "weatherExponent", 0.2, 2.0, 0.01).name("层1天气指数");
    f.add(ls[2], "weatherExponent", 0.2, 2.0, 0.01).name("层2天气指数");
    f.add(ls[0], "coverageFilterWidth", 0.1, 1.0, 0.01).name("层0覆盖过滤宽度");
    f.add(ls[1], "coverageFilterWidth", 0.1, 1.0, 0.01).name("层1覆盖过滤宽度");
    f.add(ls[2], "coverageFilterWidth", 0.1, 1.0, 0.01).name("层2覆盖过滤宽度");
    f.open();
    const l = this._gui.addFolder("光照");
    l.add(p, "sunIntensity", 0, 150, 5).name("太阳强度");
    l.add(p, "skyToSunRatio", 0.05, 0.6, 0.01).name("天空/太阳比");
    l.add(p, "cloudExposure", 0.1, 5.0, 0.1).name("云曝光");
    l.add(p, "magentaFixStrength", 0.0, 2.0, 0.05).name("落日去品红强度");
    l.add(p, "edgeAlphaCutoff", 0.0, 0.2, 0.005).name("边缘Alpha裁剪");
    l.add(p, "aerialPerspectiveScale", 0, 3, 0.1).name("大气透视");
    const s = this._gui.addFolder("散射");
    s.add(p, "scatterG1", 0, 0.99, 0.01).name("前向散射G");
    s.add(p, "scatterG2", -0.99, 0, 0.01).name("后向散射G");
    s.add(p, "multiScatteringOctaves", 1, 12, 1).name("多散射阶数");
    const a = this._gui.addFolder("动画");
    a.add(p, "windSpeed", 0, 1, 0.0001).name("风速");
    a.add(p, "evolutionSpeed", 0, 0.0001, 0.000001).name("演化速度");
    // 远处云距离衰减：调小 distFadeStart 让衰减更早开始（远处更疏），调大 distFadeEnd 让衰减更平缓
    a.add(p, "distFadeStart", 5000, 100000, 1000).name("远处衰减起点(m)");
    a.add(p, "distFadeEnd", 20000, 200000, 1000).name("远处衰减终点(m)");
    const o = this._gui.addFolder("开关");
    o.add(p, "cloudsVisible").name("显示云").onChange((v) => {
      if (this.cloudStage) this.cloudStage.enabled = v;
    });
    o.add(p, "useShadowBuffer").name("BSM(云阴影)");
    o.add(p, "shadowLengthEnabled").name("阴影长度(丁达尔)");
    o.add(p, "hazeEnabled").name("雾效(HAZE)");
    o.add(p, "temporalEnabled").name("TAA");
    o.add(p, "maxSteps", 64, 1200, 1).name("主采样步数");
    o.add(p, "minStepSize", 5.0, 200.0, 1.0).name("最小步长");
    o.add(p, "blueNoiseScale", 0.25, 4.0, 0.05).name("噪声采样缩放");
    o.add(p, "jitterStrength", 0.0, 1.0, 0.01).name("抖动强度");

    // BSM OD 缩放联动：地面阴影实际在 AerialPerspectiveEffect stage 渲染，
    // 但原 GUI 只绑了 AtmospherePostProcess 实例，调不动。这里统一驱动两侧。
    const bsm = this._gui.addFolder("BSM 缩放");
    const syncBsmScale = (key, val) => {
      if (this.atmosphere) this.atmosphere[`_${key}`] = val;
      if (this.aerial) this.aerial[`_${key}`] = val;
    };
    // 用 params 上的占位属性承载 GUI 值，初始与两侧默认(1.0)对齐
    p._bsmGroundScale = 0.3; p._bsmTyndallScale = 1.0;
    bsm.add(p, "_bsmGroundScale", 0.1, 20.0, 0.1).name("OD缩放(地面)").onChange((v) => syncBsmScale("bsmGroundOpticalDepthScale", v));
    bsm.add(p, "_bsmTyndallScale", 0.1, 20.0, 0.1).name("OD缩放(光柱)").onChange((v) => syncBsmScale("bsmTyndallOpticalDepthScale", v));
    // cascade 几何：调这三个解决"近处阴影被切割"。shadowFar=覆盖最远距离，splitLambda=近处分配(越大近处越多)，fadeScale=ortho扩展
    bsm.add(p, "shadowFar", 20000, 500000, 5000).name("阴影覆盖距离");
    bsm.add(p, "shadowSplitLambda", 0.0, 1.0, 0.05).name("近处分配");
    bsm.add(p, "shadowFadeScale", 0.0, 5.0, 0.1).name("边缘扩展");
    // 关键：占位初始值不会自动触发 onChange，这里手动同步一次，否则启动时两侧 scale 仍是构造默认(1.0)
    syncBsmScale("bsmGroundOpticalDepthScale", p._bsmGroundScale);
    syncBsmScale("bsmTyndallOpticalDepthScale", p._bsmTyndallScale);
  }

  // ── BSM ShadowPass params (for CloudShadowPass) ────────────────────────

  _getShadowPassParams() {
    const ls = this.params.layers;
    const minLayerHeights = [], maxLayerHeights = [], densityProfileLinear = [], densityProfileConstant = [];
    const densityScales = [], shapeAmounts = [], shapeDetailAmounts = [], weatherExponents = [];
    const shapeAlteringBiases = [], coverageFilterWidths = [], coverages = [];
    let minAlt = 1e9, maxAltH = 0;
    for (let i = 0; i < 4; i++) {
      const a = Number(ls[i]?.altitude) || 0, h = Number(ls[i]?.height) || 0;
      if (a + h > 0) { minAlt = Math.min(minAlt, a); maxAltH = Math.max(maxAltH, a + h); }
      minLayerHeights[i] = a; maxLayerHeights[i] = a + h;
      densityProfileLinear[i] = Number(ls[i]?.densityProfile?.linearTerm) ?? 0.75;
      densityProfileConstant[i] = Number(ls[i]?.densityProfile?.constantTerm) ?? 0.25;
      densityScales[i] = Number(ls[i]?.densityScale) || 0;
      shapeAmounts[i] = Number(ls[i]?.shapeAmount) ?? 1;
      shapeDetailAmounts[i] = Number(ls[i]?.shapeDetailAmount) ?? 1;
      weatherExponents[i] = Number(ls[i]?.weatherExponent) ?? 1;
      shapeAlteringBiases[i] = Number(ls[i]?.shapeAlteringBias) ?? 0.35;
      coverageFilterWidths[i] = Number(ls[i]?.coverageFilterWidth) ?? 0.6;
      coverages[i] = Number(ls[i]?.coverage) ?? 0.3;
    }
    const iv = this._getIntervalHeights();
    const cBottom = Number.isFinite(minAlt) ? minAlt : 750;
    return {
      bottomRadius: Number(this.params.bottomRadius) || 6378137,
      cloudBottomHeight: cBottom, cloudTopHeight: Math.max(0, maxAltH - cBottom) || 1500,
      shadowBottomHeight: cBottom, shadowTopHeight: maxAltH || (cBottom + 1500),
      // shadow cascade far 必须限制到云层相关距离，否则会取 Cesium 相机 frustum.far（~8e8），
      // 导致 ortho proj radius 爆炸、数值精度崩坏产生 NaN、矩阵不可逆、BSM 全失效。
      shadowFar: Number(this.params.shadowFar) || Number(this.params.maxShadowLengthRayDistance) || 200000.0,
      maxShadowLengthRayDistance: Number(this.params.maxShadowLengthRayDistance) || 200000.0,
      shadowSplitLambda: Number(this.params.shadowSplitLambda) || 0.5,
      shadowFadeScale: Number(this.params.shadowFadeScale) || 1.0,
      weatherRepeat: Number(this.params.weatherRepeat) || 100, windSpeed: Number(this.params.windSpeed) || 0,
      shapeRepeat: (Number(this.params.shapeRepeat) || 3) / 1e4,
      shapeDetailRepeat: Number(this.params.shapeDetailRepeat) || 0.006,
      turbulenceRepeat: Number(this.params.turbulenceRepeat) || 2,
      turbulenceDisplacement: Number(this.params.turbulenceDisplacement) || 400,
      coverage: Math.max(...coverages), densityScale: Math.max(...densityScales),
      scatteringCoefficient: Number(this.params.scatteringCoefficient) ?? 0.9,
      absorptionCoefficient: Number(this.params.absorptionCoefficient) ?? 1.0,
      startTime: performance.now() / 1000, evolutionSpeed: Number(this.params.evolutionSpeed) || 0.005,
      maxSteps: this.params.maxSteps, minStepSize: this.params.minStepSize,
      minDensity: this.params.minDensity ?? 1e-5, minExtinction: this.params.minExtinction ?? 1e-5,
      minTransmittance: this.params.minTransmittance ?? 0.01, opticalDepthTailScale: 1.0,
      minLayerHeights, maxLayerHeights, densityProfileLinear, densityProfileConstant,
      densityProfileExpTerms: [0,0,0,0], densityProfileExponents: [0,0,0,0],
      densityScales, shapeAmounts, shapeDetailAmounts, weatherExponents,
      shapeAlteringBiases, coverageFilterWidths, coverages,
      minIntervalHeights: [iv.min.x, iv.min.y, iv.min.z],
      maxIntervalHeights: [iv.max.x, iv.max.y, iv.max.z],
      localWeatherOffset: [0, 0], shapeOffset: [0, 0, 0], shapeDetailOffset: [0, 0, 0],
    };
  }

  // ── Init ───────────────────────────────────────────────────────────────

  async init() {
    if (this._ready) return this._ready;
    this._ready = (async () => {
      const viewer = this.viewer;
      viewer.scene.globe.depthTestAgainstTerrain = true;

      // 1. Atmosphere
      this.atmosphere = new AtmospherePostProcess(viewer, {
        atmosphereParams: this.atmosphereParams, renderSky: true,
        applyGroundAtmosphere: false, autoAddStage: false,
        assetsBaseUrl: this.atmosphereAssetsBase, shaderBaseUrl: this.atmosphereShaderBase,
      });
      await this.atmosphere.init();

      // 2. Aerial
      this.aerial = new AerialPerspectiveEffect(viewer, {
        atmosphereParams: this.atmosphereParams, autoAddStage: false,
        assetsBaseUrl: this.atmosphereAssetsBase, shaderBaseUrl: this.atmosphereShaderBase,
      });

      // 3. Load cloud textures + build shader
      await this._loadTextures();
      const fragmentShader = await this._buildCloudFragmentShader();

      // 4. BSM passes (import dynamically to avoid circular deps)
      const { CloudShadowPass } = await import("./CloudShadowPass.js");
      const { ShadowResolvePass } = await import("./ShadowResolvePass.js");
      if (this.params.useShadowBuffer && this.textures) {
        this._bsm.pass = new CloudShadowPass(viewer, { textures: this.textures, params: this._getShadowPassParams() });
        this._bsm.pass.init();
        // 静止 temporalAlpha 对齐 three-geospatial≈0.01；运动时 ShadowResolvePass 内会抬高 alpha
        this._bsm.resolve = new ShadowResolvePass(viewer, { size: SHADOW_MAP_SIZE, temporalAlpha: 0.01 });
        this._bsm.resolve.setInputTextures(this._bsm.pass.getTexture(), this._bsm.pass.getDepthVelocityTexture());
        this._bsm.resolve.init();
      }

      // 5. Aerial init
      await this.aerial.init();

      // 6. 初始化原始 WebGL2 云渲染管线
      // 注意：大气/空中透视仍使用 Cesium PostProcessStage（提供天空背景），
      // 但它们的 sampler3D uniform 在 Cesium binding 中可能失败。
      // 因此这里不注册任何 PostProcessStage，只渲染云层。
      const gl = viewer.scene.context._gl;
      const rawOk = gl ? this._initRawWebGL(gl) : false;
      if (!rawOk) {
        console.warn('[Pipeline] 原始 WebGL2 云渲染初始化失败，回退使用 Cesium PostProcessStage');
        // 回退：使用原来的 PostProcessStage（但 sampler3D 可能失败）
        const uniforms = this._buildCloudUniforms();
        this.cloudStage = new Cesium.PostProcessStage({
          name: "GeospatialVolumetricClouds", fragmentShader, uniforms,
        });
        this.cloudStage.enabled = this.params.cloudsVisible;
        const stages = viewer.scene.postProcessStages;
        if (this.atmosphere.stage) stages.add(this.atmosphere.stage);
        if (this.aerial.stage) stages.add(this.aerial.stage);
        stages.add(this.cloudStage);
      } else {
        console.log('[Pipeline] 使用原始 WebGL2 渲染云层（跳过 PostProcessStage）');
        // 仅用 Cesium 的默认 skyBox 作为背景
      }

      // 7. preRender: BSM sync
      this._listeners.push(viewer.scene.preRender.addEventListener(() => this._syncBSM()));

      // 8. postRender: TAA capture + frame count + 原始 WebGL2 云渲染
      this._listeners.push(viewer.scene.postRender.addEventListener(() => {
        this._taaUpdateVP();
        if (this.params.temporalEnabled) this._taaCapture();
        this._frameCount++;
        // 如果使用原始 WebGL2 渲染，在 postRender 中执行
        if (rawOk && this.params.cloudsVisible) {
          try { this._renderRawClouds(gl); } catch (e) {
            console.warn('[Pipeline] 原始 WebGL2 云渲染失败:', e.message);
          }
        }
      }));
      this._listeners.push(viewer.camera.changed.addEventListener(() => {
        const c = Cesium.Cartographic.fromCartesian(
          viewer.camera.positionWC,
          viewer.scene.globe.ellipsoid
        );
        const ellipsoidHeight = Number(c?.height) || 0;
        const atmBottomRadius = Number(
          this.atmosphere?.getAtmosphereForClouds?.()?.getUniforms?.()?.bottomRadius?.() ?? NaN
        );
        const usedBottomRadius = Number.isFinite(atmBottomRadius)
          ? atmBottomRadius
          : (Number(this.params.bottomRadius) || 0);
        const corr = this._getAltitudeCorrectionOffset(usedBottomRadius);
        const correctedPos = Cesium.Cartesian3.add(
          viewer.camera.positionWC,
          corr,
          new Cesium.Cartesian3()
        );
        const correctedHeight = Math.max(
          0,
          Cesium.Cartesian3.magnitude(correctedPos) - usedBottomRadius
        );
      }));

      this._setupGUI();
      console.log("[Pipeline] ready: Cloud -> Atmosphere -> Aerial");
    })();
    return this._ready;
  }

  // ── Destroy ────────────────────────────────────────────────────────────

  destroy() {
    for (const remove of this._listeners) if (typeof remove === "function") remove();
    this._listeners = [];
    const stages = this.viewer?.scene?.postProcessStages;
    if (stages && this.cloudStage) { try { stages.remove(this.cloudStage); } catch {} }
    this.cloudStage = null;
    try { this.aerial?.destroy(); } catch {} this.aerial = null;
    try { this.atmosphere?.destroy(); } catch {} this.atmosphere = null;
    try { this._bsm.pass?.destroy(); } catch {} this._bsm.pass = null;
    try { this._bsm.resolve?.destroy(); } catch {} this._bsm.resolve = null;
    const gl = this.viewer?.scene?.context?._gl;
    if (gl) {
      // 清理 BSM 资源
      if (this._bsm.blitFbo) gl.deleteFramebuffer(this._bsm.blitFbo);
      if (this._bsm.blitProg) gl.deleteProgram(this._bsm.blitProg);
      if (this._bsm.blitVbo) gl.deleteBuffer(this._bsm.blitVbo);
      // 清理 TAA 资源
      if (this._taa.texA) gl.deleteTexture(this._taa.texA);
      if (this._taa.texB) gl.deleteTexture(this._taa.texB);
      if (this._taa.pbo) gl.deleteBuffer(this._taa.pbo);
      // 清理原始 WebGL2 云渲染资源
      if (this._raw.prog) gl.deleteProgram(this._raw.prog);
      if (this._raw.vao) gl.deleteVertexArray(this._raw.vao);
      if (this._raw.vbo) gl.deleteBuffer(this._raw.vbo);
      if (this._raw.sceneColor) gl.deleteTexture(this._raw.sceneColor);
      if (this._raw.depthTex) gl.deleteTexture(this._raw.depthTex);
      if (this._raw.depthFbo) gl.deleteFramebuffer(this._raw.depthFbo);
    }
    this._bsm = { pass: null, resolve: null, blitFbo: null, blitProg: null, blitVbo: null };
    this._taa = { texA: null, texB: null, current: 0, pbo: null, pboReady: false, w: 0, h: 0, frameCount: 0, prevVP: null, curVP: null };
    this._raw = { prog: null, vao: null, vbo: null, sceneColor: null, depthTex: null, depthFbo: null, depthW: 0, depthH: 0, texUnits: {} };
    if (this.textures) { for (const k in this.textures) { try { this.textures[k]?.destroy?.(); } catch {} } this.textures = null; }
    if (this._gui) { this._gui.destroy(); this._gui = null; }
    this._ready = null;
  }
}