@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/posteffect/skinsss.js

@@ -1,11 +1,12 @@
-import { Vector4, Vector3, Vector2, DEPTH_FARTHEST } from '@zephyr3d/base';
+import { Vector2, Vector4, DEPTH_FARTHEST } from '@zephyr3d/base';
 import { ShaderHelper } from '../material/shader/helper.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
 import '../material/particle.js';
-import { SubsurfaceProfile } from '../material/subsurfaceprofile.js';
-import { SKIN_SSS_LDR_ENCODE_RANGE } from '../material/skin.js';
+import '../material/subsurfaceprofile.js';
+import { SSSProfile } from '../material/sssprofile.js';
+import '../material/skin.js';
 import '../material/eye.js';
 import '@zephyr3d/device';
 import '../values.js';
@@ -21,289 +22,247 @@ import '../material/pbrblueprint.js';
 import '../material/sprite.js';
 import '../material/sprite_std.js';
 import '../utility/blueprint/material/texture.js';
-import { burleyDiffusionWeight } from '../shaders/diffusion.js';
+import { hash21 } from '../shaders/noise.js';
 import { linearToGamma } from '../shaders/misc.js';
 import { fetchSampler } from '../utility/misc.js';
 import { AbstractPostEffect, PostEffectLayer } from './posteffect.js';
 
-/** Taps per side of the separable kernel. The full kernel is `2 * TAPS + 1` wide. */ const SKIN_SSS_TAPS = 8;
-/**
- * Stylized screen-space skin scattering pass.
- *
- * @remarks
- * {@link SkinMaterial} writes the diffusible part of its lit color - the stylized diffuse ramp
- * plus back-lit transmission, without specular - into a side buffer. This pass diffuses that
- * buffer with a channel-dependent kernel and swaps it back in:
- *
- * ```
- * result = base + (diffused - original) * scatterTint * strength + diffused * glow
- * ```
- *
- * Because the term added back replaces exactly the term subtracted, the redistribution is energy
- * conserving: light that appears on the dark side of the terminator is light that left the lit
- * side, rather than light invented on top of a finished image. With `scatterTint` white and
- * `glow` zero the total radiance is preserved to within the kernel's normalization error.
- *
- * Two things follow from that formulation and are worth knowing:
- *
- * - Nothing happens where the diffusion changes nothing, so a disabled or zero-radius pass is a
- *   true no-op, and quantization from an 8-bit side buffer largely cancels between the subtracted
- *   and added terms instead of banding across the whole face.
- * - `scatterTint` colors only the light that actually moved. Tinting the whole diffuse - what the
- *   material used to do with `scatterColor` - is what made the old look read as red haze.
- *
- * Stylization survives in two places. The material owns the direct lighting ramp (wrap, softness,
- * shadow tint, brightening) and this pass diffuses whatever ramp it produced; and {@link profile}
- * selects the channel radii, so the `wax` and `jade` presets are as reachable as `skin`.
- *
- * This is intentionally separate from the profile-based {@link SSS} pass, which supports per-pixel
- * profiles via a profile-slot MRT. Here a single global profile lives in uniforms.
- *
- * @public
+const SKIN_SSS_DEBUG_OUTPUTS = [
+    'none',
+    'diffusible',
+    'diffuseAmount',
+    'profileId',
+    'normal',
+    'diffusionDistance',
+    'sampleRadius',
+    'weight',
+    'acceptance',
+    'centerWeight',
+    'diffused',
+    'thickness'
+];
+/**
+ * Radial-disc sample count, matching UE5's `BURLEY_NUM_SAMPLES`.
+ *
+ * @remarks
+ * UE5 drives the count from a variance history and resolves the remainder
+ * temporally. Without that history every frame stands on its own, so the full
+ * count is used throughout.
+ */ const DEFAULT_SAMPLE_COUNT = 64;
+/**
+ * Screen-space skin scattering — 3-pass pipeline aligned with UE5.
+ *
+ * @remarks
+ * Pass 1 (Burley): Radial-disc Burley diffusion with Halton + inverse-CDF
+ *   importance sampling, 3D bilateral distance, per-channel kernel.
+ * Pass 2 (BVar): Luminance variance + depth gradient → transmission estimate.
+ * Pass 3 (Recombine): Specular/diffuse separation via SceneColor.a, then the
+ *   diffused half summed back with the specular remainder.
+ *
+ * The pass exposes no scattering parameters of its own — every one of them
+ * belongs to the {@link SSSProfile} the material points at, as in UE5.
+ *
+ * WebGPU only.
+ *
+ * @public
  */ class SkinSSS extends AbstractPostEffect {
-    static _blurProgram = null;
-    static _combineProgram = null;
-    _blurBindGroupH;
-    _blurBindGroupV;
-    _combineBindGroup;
+    static _burleyProgram = null;
+    static _bvarProgram = null;
+    static _recombineProgram = null;
+    _burleyBindGroup;
+    _bvarBindGroup;
+    _recombineBindGroup;
     _profile;
-    _strength;
-    _glow;
-    _opacity;
-    _sampleStep;
-    _depthScale;
-    _colorBoost;
-    _scatterRadius;
-    _smoothness;
-    _scatterTint;
-    _channelRadius;
-    _channelFalloff;
-    _blurDirection;
-    _radiusParams;
+    _debugOutput;
+    _debugExposure;
+    _sampleCount;
+    _projScale;
+    _profileParams;
     _targetSize;
     _cameraNearFar;
     constructor(){
         super();
         this._layer = PostEffectLayer.opaque;
-        this._blurBindGroupH = null;
-        this._blurBindGroupV = null;
-        this._combineBindGroup = null;
+        this._burleyBindGroup = null;
+        this._bvarBindGroup = null;
+        this._recombineBindGroup = null;
         this._profile = null;
-        this._strength = 1;
-        this._glow = 0;
-        this._opacity = 0.18;
-        this._sampleStep = 3;
-        this._depthScale = 80;
-        this._colorBoost = 1;
-        this._scatterRadius = 0.02;
-        this._smoothness = 0;
-        this._scatterTint = new Vector4(1, 1, 1, 1);
-        this._channelRadius = new Vector3(1, 1, 1);
-        this._channelFalloff = new Vector3(1, 1, 1);
-        this._blurDirection = new Vector2();
-        this._radiusParams = new Vector4();
+        this._debugOutput = 'none';
+        this._debugExposure = 1;
+        this._sampleCount = DEFAULT_SAMPLE_COUNT;
+        this._projScale = new Vector2();
+        this._profileParams = new Vector4();
         this._targetSize = new Vector4();
         this._cameraNearFar = new Vector2();
     }
-    /**
-   * Subsurface profile supplying the per-channel scatter radii and falloff.
-   *
-   * @remarks
-   * Defaults to {@link SubsurfaceProfile.getDefaultSkinProfile} when unset. Only the channel
-   * ratios of `scatterRadius` and the `falloffColor` are read; the absolute distance comes from
-   * {@link SkinSSS.scatterRadius}, so switching profiles changes the color of the bleed without
-   * changing how far it reaches.
-   *
-   * The channel ratios are what make skin read as skin - red travels several times further than
-   * blue, which is the red-to-orange-to-yellow gradient at the terminator. They are also the main
-   * stylization lever: the `wax` and `jade` presets are the same code path with different ratios.
+    /**
+   * Fallback profile for pixels whose id is not in the table.
+   *
+   * @remarks
+   * Scattering parameters normally come from the per-pixel profile id the skin
+   * material writes, so this only applies when that lookup misses.
+   *
+   * @public
    */ get profile() {
         return this._profile;
     }
     set profile(val) {
         this._profile = val ?? null;
     }
-    /** Final blend strength of the conserving redistribution. 1 fully diffuses the skin diffuse. */ get strength() {
-        return this._strength;
+    get sampleCount() {
+        return this._sampleCount;
     }
-    set strength(val) {
-        this._strength = Math.max(0, val ?? 0);
+    set sampleCount(val) {
+        this._sampleCount = Math.max(8, Math.min(64, Math.round(val ?? DEFAULT_SAMPLE_COUNT)));
     }
-    /**
-   * Additive, deliberately non-conserving bleed layered on top of the conserving result.
-   *
-   * @remarks
-   * 0 (the default) keeps the pass energy conserving. Raising it adds the diffused term a second
-   * time without subtracting anything, which is the glow-heavy look the pass produced before it
-   * conserved energy; around 1 approximates it. Use it when the art direction wants skin to read
-   * as lit from within rather than as a physical surface.
-   */ get glow() {
-        return this._glow;
+    /**
+   * Multiplier applied to whatever {@link SkinSSS.debugOutput} renders.
+   *
+   * @remarks
+   * Defaults to 1. Several intermediates sit in a narrow band that reads as a
+   * flat tone at unit exposure, so raising this is how "no variation" is told
+   * apart from "variation too small to see". No effect unless a debug output is
+   * selected.
+   *
+   * @public
+   */ get debugExposure() {
+        return this._debugExposure;
     }
-    set glow(val) {
-        this._glow = Math.max(0, val ?? 0);
+    set debugExposure(val) {
+        this._debugExposure = Math.max(0, val ?? 1);
     }
-    /**
-   * Tint applied to the redistributed light.
-   *
-   * @remarks
-   * White (the default) leaves the pass energy conserving. A warm tint pushes the classic reddish
-   * terminator further than the profile's channel radii do on their own. Because it multiplies
-   * only the difference between the diffused and original diffuse, it cannot wash the whole
-   * surface - only the light that moved.
-   */ get scatterTint() {
-        return this._scatterTint;
+    /**
+   * Intermediate quantity to render instead of the shaded result.
+   *
+   * @remarks
+   * Defaults to `'none'`. See {@link SkinSSSDebugOutput}.
+   *
+   * @public
+   */ get debugOutput() {
+        return this._debugOutput;
     }
-    set scatterTint(val) {
-        this._scatterTint.set(val);
-    }
-    /** Skin mask coverage threshold. Scattering fades in as the blurred mask coverage exceeds this. */ get opacity() {
-        return this._opacity;
-    }
-    set opacity(val) {
-        this._opacity = Math.max(0, Math.min(1, val ?? 0));
-    }
-    /**
-   * Maximum pixel spacing between blur taps. Caps the projected scatter radius for close-ups.
-   *
-   * @remarks
-   * With `SKIN_SSS_TAPS` taps per side the kernel reaches `sampleStep * SKIN_SSS_TAPS` pixels, so
-   * this is the real limit on scatter width. The separable form makes taps cheap enough that the
-   * default no longer has to be tight: the old single-pass 9x9 kernel capped out at 8 pixels, and
-   * a face in close-up projects a 2 cm scatter radius far past that - the shot that needs the most
-   * scattering used to get the least.
-   */ get sampleStep() {
-        return this._sampleStep;
-    }
-    set sampleStep(val) {
-        this._sampleStep = Math.max(0.25, Math.min(6, val ?? 0.25));
-    }
-    /** World-space scatter radius. The blur width shrinks with distance to keep this constant. */ get scatterRadius() {
-        return this._scatterRadius;
-    }
-    set scatterRadius(val) {
-        this._scatterRadius = Math.max(0, val ?? 0);
-    }
-    /**
-   * Skin smoothing amount ("beauty filter"). Blends the lit color toward a mask- and depth-weighted
-   * blur of itself on skin pixels, removing pore and albedo detail while facial features stay sharp
-   * wherever the skin mask excludes them (eyes, brows, lips). 0 disables smoothing.
-   *
-   * @remarks
-   * This is separate from the diffusion and stacks on top of it. The diffusion blurs *lighting*
-   * only; albedo detail such as pores and blemishes passes through it untouched, which is correct
-   * but is not what a beauty filter is for.
-   */ get smoothness() {
-        return this._smoothness;
-    }
-    set smoothness(val) {
-        this._smoothness = Math.max(0, Math.min(1, val ?? 0));
-    }
-    /** Depth rejection scale. The reference shader uses 80. */ get depthScale() {
-        return this._depthScale;
-    }
-    set depthScale(val) {
-        this._depthScale = Math.max(0, val ?? 0);
-    }
-    /** Multiplier applied to the diffused irradiance before compositing. */ get colorBoost() {
-        return this._colorBoost;
-    }
-    set colorBoost(val) {
-        this._colorBoost = Math.max(0, val ?? 0);
+    set debugOutput(val) {
+        this._debugOutput = SKIN_SSS_DEBUG_OUTPUTS.includes(val) ? val : 'none';
     }
     requireLinearDepthTexture() {
         return true;
     }
     apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
-        if (!ctx.SkinSSSTexture || this._strength <= 0) {
+        if (!ctx.SSSMaskTexture || !ctx.SSSProfileIdTexture || ctx.device.type !== 'webgpu') {
             this.passThrough(ctx, inputColorTexture, srgbOutput);
             return;
         }
         const device = ctx.device;
         const outputFramebuffer = device.getFramebuffer();
-        const skinTex = ctx.SkinSSSTexture;
-        if (!SkinSSS._blurProgram) {
-            SkinSSS._blurProgram = this.createBlurProgram(ctx);
+        const maskTex = ctx.SSSMaskTexture;
+        const profileIdTex = ctx.SSSProfileIdTexture;
+        const width = inputColorTexture.width;
+        const height = inputColorTexture.height;
+        const scatterFormat = ctx.colorFormat;
+        const profileTable = SSSProfile.getTable(device);
+        if (!profileTable) {
+            this.passThrough(ctx, inputColorTexture, srgbOutput);
+            return;
         }
-        if (!SkinSSS._combineProgram) {
-            SkinSSS._combineProgram = this.createCombineProgram(ctx);
+        const fallback = this._profile ?? SSSProfile.getDefault();
+        // Projection of a world-space length at unit depth into UV, per axis. Two
+        // factors, not one: `m00` and `m11` differ by the aspect ratio, so a single
+        // one turns the sampling disc into an ellipse. UE5 reaches the same pair by
+        // building x from m00 and correcting y by `Extent.x / Extent.y`.
+        const projMatrix = ctx.camera.getProjectionMatrix();
+        this._projScale.setXY(// x: world length at unit depth, in horizontal UV
+        0.5 * projMatrix.m00, // y: world length at unit depth, in vertical UV
+        0.5 * projMatrix.m11);
+        // Row of the fallback profile, used when a pixel's id is missing.
+        this._profileParams.setXYZW(fallback.encodedId, 1 / SSSProfile.tableColumns, 1 / SSSProfile.tableRows, SSSProfile.tableRows);
+        this._targetSize.setXYZW(width, height, 1 / width, 1 / height);
+        this._cameraNearFar.setXY(ctx.camera.getNearPlane(), ctx.camera.getFarPlane());
+        if (!SkinSSS._burleyProgram) {
+            SkinSSS._burleyProgram = this.createBurleyProgram(ctx);
         }
-        const blurProgram = SkinSSS._blurProgram;
-        const combineProgram = SkinSSS._combineProgram;
-        if (!this._blurBindGroupH) {
-            // Two bind groups rather than one program per direction: the only thing
-            // that differs is the step vector, and rewriting it between draws would
-            // race the first draw's read of it.
-            this._blurBindGroupH = device.createBindGroup(blurProgram.bindGroupLayouts[0]);
-            this._blurBindGroupV = device.createBindGroup(blurProgram.bindGroupLayouts[0]);
+        if (!SkinSSS._bvarProgram) {
+            SkinSSS._bvarProgram = this.createBVarProgram(ctx);
         }
-        if (!this._combineBindGroup) {
-            this._combineBindGroup = device.createBindGroup(combineProgram.bindGroupLayouts[0]);
+        if (!SkinSSS._recombineProgram) {
+            SkinSSS._recombineProgram = this.createRecombineProgram(ctx);
         }
-        const profile = this._profile ?? SubsurfaceProfile.getDefaultSkinProfile();
-        const radius = profile.scatterRadius;
-        const maxChannel = Math.max(radius.x, radius.y, radius.z, 1e-5);
-        this._channelRadius.setXYZ(radius.x / maxChannel, radius.y / maxChannel, radius.z / maxChannel);
-        const falloff = profile.falloffColor;
-        this._channelFalloff.setXYZ(falloff.x, falloff.y, falloff.z);
-        // Pixels per world unit at unit view depth. The shader divides by view depth
-        // so the footprint stays a constant world-space radius.
-        const projScale = 0.5 * inputColorTexture.height * ctx.camera.getProjectionMatrix().m11;
-        this._radiusParams.setXYZW(this._scatterRadius * projScale, ctx.camera.isPerspective() ? 1 : 0, this._sampleStep, this._depthScale);
-        this._targetSize.setXYZW(inputColorTexture.width, inputColorTexture.height, 1 / inputColorTexture.width, 1 / inputColorTexture.height);
-        this._cameraNearFar.setXY(ctx.camera.getNearPlane(), ctx.camera.getFarPlane());
-        const encodeScale = skinTex.format === 'rgba8unorm' ? SKIN_SSS_LDR_ENCODE_RANGE : 1;
-        const blurH = device.pool.fetchTemporalFramebuffer(false, skinTex.width, skinTex.height, skinTex.format, null, false);
-        const blurV = device.pool.fetchTemporalFramebuffer(false, skinTex.width, skinTex.height, skinTex.format, null, false);
-        device.setFramebuffer(blurH);
-        this.blur(ctx, blurProgram, this._blurBindGroupH, skinTex, sceneDepthTexture, true);
-        device.setFramebuffer(blurV);
-        this.blur(ctx, blurProgram, this._blurBindGroupV, blurH.getColorAttachments()[0], sceneDepthTexture, false);
+        const diffusedFB = device.pool.fetchTemporalFramebuffer(false, width, height, scatterFormat, null, false);
+        const bvarFB = device.pool.fetchTemporalFramebuffer(false, width, height, scatterFormat, null, false);
+        // --- Pass 1: Burley diffusion ---
+        device.pushDeviceStates();
+        try {
+            if (!this._burleyBindGroup) {
+                this._burleyBindGroup = device.createBindGroup(SkinSSS._burleyProgram.bindGroupLayouts[0]);
+            }
+            const bg = this._burleyBindGroup;
+            bg.setTexture('sceneTex', inputColorTexture, fetchSampler('clamp_linear'));
+            bg.setTexture('maskTex', maskTex, fetchSampler('clamp_linear'));
+            // Nearest only: the id is a table row, and an interpolated one addresses a
+            // profile neither neighbour has.
+            bg.setTexture('profileIdTex', profileIdTex, fetchSampler('clamp_nearest_nomip'));
+            bg.setTexture('depthTex', sceneDepthTexture, fetchSampler('clamp_nearest_nomip'));
+            bg.setValue('cameraNearFar', this._cameraNearFar);
+            bg.setValue('targetSize', this._targetSize);
+            bg.setValue('projScale', this._projScale);
+            bg.setValue('perspective', ctx.camera.isPerspective() ? 1 : 0);
+            bg.setValue('profileParams', this._profileParams);
+            bg.setTexture('profileTex', profileTable, fetchSampler('clamp_nearest_nomip'));
+            bg.setTexture('thicknessTex', ctx.transmissionThicknessTexture ?? ShaderHelper.getDummyTransmissionThickness(device), fetchSampler('clamp_nearest'));
+            bg.setValue('sampleCount', this._sampleCount);
+            bg.setValue('debugMode', SKIN_SSS_DEBUG_OUTPUTS.indexOf(this._debugOutput));
+            bg.setValue('debugExposure', this._debugExposure);
+            // Intermediate passes always render into a texture, so on WebGPU they flip
+            // unconditionally. `needFlip` cannot be used: it reports whatever target is
+            // bound at the time, and these values are set before the pass binds its own.
+            bg.setValue('flip', device.type === 'webgpu' ? 1 : 0);
+            device.setProgram(SkinSSS._burleyProgram);
+            device.setBindGroup(0, bg);
+            device.setFramebuffer(diffusedFB);
+            this.drawFullscreenQuad();
+        } finally{
+            device.popDeviceStates();
+        }
+        // --- Pass 2: BVar transmission ---
+        device.pushDeviceStates();
+        try {
+            if (!this._bvarBindGroup) {
+                this._bvarBindGroup = device.createBindGroup(SkinSSS._bvarProgram.bindGroupLayouts[0]);
+            }
+            const bg = this._bvarBindGroup;
+            bg.setTexture('diffusedTex', diffusedFB.getColorAttachments()[0], fetchSampler('clamp_linear'));
+            bg.setTexture('depthTex', sceneDepthTexture, fetchSampler('clamp_nearest_nomip'));
+            bg.setValue('targetSize', this._targetSize);
+            bg.setValue('cameraNearFar', this._cameraNearFar);
+            bg.setValue('flip', device.type === 'webgpu' ? 1 : 0);
+            device.setProgram(SkinSSS._bvarProgram);
+            device.setBindGroup(0, bg);
+            device.setFramebuffer(bvarFB);
+            this.drawFullscreenQuad();
+        } finally{
+            device.popDeviceStates();
+        }
+        // --- Pass 3: Recombine ---
         device.setFramebuffer(outputFramebuffer);
-        this.combine(ctx, combineProgram, inputColorTexture, skinTex, blurV.getColorAttachments()[0], sceneDepthTexture, encodeScale, srgbOutput);
-        device.pool.releaseFrameBuffer(blurH);
-        device.pool.releaseFrameBuffer(blurV);
-    }
-    blur(ctx, program, bindGroup, source, sceneDepthTexture, horizontal) {
-        const device = ctx.device;
-        this._blurDirection.setXY(horizontal ? 1 : 0, horizontal ? 0 : 1);
-        bindGroup.setTexture('skinTex', source, fetchSampler('clamp_linear'));
-        bindGroup.setTexture('depthTex', sceneDepthTexture, fetchSampler('clamp_nearest_nomip'));
-        bindGroup.setValue('cameraNearFar', this._cameraNearFar);
-        bindGroup.setValue('targetSize', this._targetSize);
-        bindGroup.setValue('radiusParams', this._radiusParams);
-        bindGroup.setValue('channelRadius', this._channelRadius);
-        bindGroup.setValue('channelFalloff', this._channelFalloff);
-        bindGroup.setValue('blurDirection', this._blurDirection);
-        bindGroup.setValue('flip', 0);
-        device.setProgram(program);
-        device.setBindGroup(0, bindGroup);
-        this.drawFullscreenQuad();
-    }
-    combine(ctx, program, colorTexture, skinTexture, blurredTexture, sceneDepthTexture, encodeScale, srgbOutput) {
-        const device = ctx.device;
-        const bindGroup = this._combineBindGroup;
-        bindGroup.setTexture('colorTex', colorTexture, fetchSampler('clamp_linear'));
-        bindGroup.setTexture('skinTex', skinTexture, fetchSampler('clamp_linear'));
-        bindGroup.setTexture('blurredTex', blurredTexture, fetchSampler('clamp_linear'));
-        bindGroup.setTexture('depthTex', sceneDepthTexture, fetchSampler('clamp_nearest_nomip'));
-        bindGroup.setValue('cameraNearFar', this._cameraNearFar);
-        bindGroup.setValue('targetSize', this._targetSize);
-        bindGroup.setValue('radiusParams', this._radiusParams);
-        bindGroup.setValue('scatterTint', this._scatterTint);
-        bindGroup.setValue('strength', this._strength);
-        bindGroup.setValue('glow', this._glow);
-        bindGroup.setValue('opacity', this._opacity);
-        bindGroup.setValue('colorBoost', this._colorBoost);
-        bindGroup.setValue('encodeScale', encodeScale);
-        bindGroup.setValue('smoothness', this._smoothness);
-        bindGroup.setValue('flip', this.needFlip(device) ? 1 : 0);
-        bindGroup.setValue('srgbOut', srgbOutput ? 1 : 0);
-        device.setProgram(program);
-        device.setBindGroup(0, bindGroup);
+        if (!this._recombineBindGroup) {
+            this._recombineBindGroup = device.createBindGroup(SkinSSS._recombineProgram.bindGroupLayouts[0]);
+        }
+        const rbg = this._recombineBindGroup;
+        rbg.setTexture('colorTex', inputColorTexture, fetchSampler('clamp_linear'));
+        rbg.setTexture('maskTex', maskTex, fetchSampler('clamp_linear'));
+        rbg.setTexture('bvarTex', bvarFB.getColorAttachments()[0], fetchSampler('clamp_linear'));
+        rbg.setTexture('depthTex', sceneDepthTexture, fetchSampler('clamp_nearest_nomip'));
+        rbg.setValue('cameraNearFar', this._cameraNearFar);
+        rbg.setValue('targetSize', this._targetSize);
+        rbg.setValue('debugMode', SKIN_SSS_DEBUG_OUTPUTS.indexOf(this._debugOutput));
+        rbg.setValue('flip', this.needFlip(device) ? 1 : 0);
+        rbg.setValue('srgbOut', srgbOutput ? 1 : 0);
+        device.setProgram(SkinSSS._recombineProgram);
+        device.setBindGroup(0, rbg);
         this.drawFullscreenQuad();
+        device.pool.releaseFrameBuffer(diffusedFB);
+        device.pool.releaseFrameBuffer(bvarFB);
     }
-    /** Shared fullscreen vertex stage for both passes. */ static fullscreenVertex(pb) {
+    static fullscreenVertex(pb) {
         pb.getGlobalScope().flip = pb.int().uniform(0);
         pb.getGlobalScope().$inputs.pos = pb.vec2().attrib('position');
         pb.getGlobalScope().$outputs.uv = pb.vec2();
@@ -315,109 +274,415 @@ import { AbstractPostEffect, PostEffectLayer } from './posteffect.js';
             });
         });
     }
-    createBlurProgram(ctx) {
+    createBurleyProgram(ctx) {
+        // WebGL1 has no texture array sampling. This effect is WebGPU-only at
+        // runtime, but its programs are still built for WebGL by the shader
+        // generation tests, so the thickness debug view has to compile out there.
+        const hasTextureArrays = ctx.device.type !== 'webgl';
         const program = ctx.device.buildRenderProgram({
             vertex (pb) {
                 SkinSSS.fullscreenVertex(pb);
             },
             fragment (pb) {
-                this.skinTex = pb.tex2D().uniform(0);
                 this.depthTex = pb.tex2D().sampleType('unfilterable-float').uniform(0);
+                this.sceneTex = pb.tex2D().uniform(0);
+                this.maskTex = pb.tex2D().uniform(0);
+                this.profileIdTex = pb.tex2D().uniform(0);
                 this.cameraNearFar = pb.vec2().uniform(0);
                 this.targetSize = pb.vec4().uniform(0);
-                // x: world scatter radius in pixels at unit depth, y: 1 for perspective,
-                // z: max tap spacing, w: depth rejection scale.
-                this.radiusParams = pb.vec4().uniform(0);
-                this.channelRadius = pb.vec3().uniform(0);
-                this.channelFalloff = pb.vec3().uniform(0);
-                this.blurDirection = pb.vec2().uniform(0);
+                this.projScale = pb.vec2().uniform(0);
+                this.perspective = pb.int().uniform(0);
+                this.profileParams = pb.vec4().uniform(0);
+                this.profileTex = pb.tex2D().uniform(0);
+                // Always declared so the cached program has one layout; a 1x1 dummy is
+                // bound on frames without a transmission pass. Only the debug view reads
+                // it — shading takes its thickness through the material, per light.
+                if (hasTextureArrays) {
+                    this.thicknessTex = pb.tex2DArray().uniform(0);
+                }
+                this.sampleCount = pb.int().uniform(0);
+                this.debugMode = pb.int().uniform(0);
+                this.debugExposure = pb.float().uniform(0);
                 this.$outputs.outColor = pb.vec4();
                 pb.func('readDepth01', [
                     pb.vec2('uv')
                 ], function() {
                     this.$return(ShaderHelper.sampleLinearDepth(this, this.depthTex, this.uv, 0));
                 });
+                // UE5's spec/diff separation (SSS::Setup): SceneColor.a holds the diffuse
+                // luminance, so the diffusible fraction is its ratio to the total.
+                //
+                // The skin mask comes from its own channel, never SceneColor.a, which
+                // every opaque material writes 1 to. The alpha returned here is UE5's
+                // subsurface Opacity, a continuous 0..1 scattering weight.
+                pb.func('readDiffusible', [
+                    pb.vec2('uv')
+                ], function() {
+                    this.$l.scene = pb.textureSampleLevel(this.sceneTex, this.uv, 0);
+                    this.$l.opacity = pb.clamp(pb.textureSampleLevel(this.maskTex, this.uv, 0).a, 0, 1);
+                    this.$l.lum = pb.dot(this.scene.rgb, pb.vec3(0.2126, 0.7152, 0.0722));
+                    // Below the floor the ratio tracks brightness rather than the split, so
+                    // treat those pixels as fully diffusible - one that dark has no specular
+                    // worth preserving.
+                    //
+                    // `pb.select(x, y, cond)` is `cond ? y : x`, following WGSL's builtin
+                    // where the *false* value comes first. It reads like a ternary and is
+                    // not one.
+                    this.$l.diffAmt = pb.select(pb.float(1), pb.clamp(pb.div(this.scene.a, pb.max(this.lum, 1e-4)), 0, 1), pb.greaterThan(this.lum, 1e-4));
+                    this.$return(pb.vec4(pb.mul(this.scene.rgb, this.diffAmt), this.opacity));
+                });
+                // Per-pixel profile id, from the depth prepass rather than the mask
+                // buffer. Keeping them apart is what lets the opacity above be
+                // continuous: one channel cannot carry a table row and a weight at once.
+                pb.func('readProfileId', [
+                    pb.vec2('uv')
+                ], function() {
+                    this.$return(pb.textureSampleLevel(this.profileIdTex, this.uv, 0).r);
+                });
+                // --- Burley diffusion, transcribed from UE5's BurleyNormalizedSSSCommon.ush ---
+                //
+                // Radii are in profile space and unbounded: the inverse CDF produces them
+                // directly and `burleyScale` converts them to a UV offset. There is
+                // deliberately no sampling disc to normalize against - one would couple
+                // the kernel shape to the mean free path.
+                // GetSearchLightDiffuseScalingFactor: s = 3.5 + 100 (A - 0.33)^4.
+                // This is the default of UE5's three scaling-factor variants.
+                pb.func('scalingFactor', [
+                    pb.float('a')
+                ], function() {
+                    this.$l.v = pb.sub(this.a, 0.33);
+                    this.$l.v2 = pb.mul(this.v, this.v);
+                    this.$return(pb.add(3.5, pb.mul(100, this.v2, this.v2)));
+                });
+                pb.func('scalingFactor3D', [
+                    pb.vec3('a')
+                ], function() {
+                    this.$l.v = pb.sub(this.a, pb.vec3(0.33));
+                    this.$l.v2 = pb.mul(this.v, this.v);
+                    this.$return(pb.add(pb.vec3(3.5), pb.mul(pb.vec3(100), this.v2, this.v2)));
+                });
+                // RadiusRootFindByApproximation: d ((2 - 2.6) xi - 2) ln(1 - xi).
+                pb.func('radiusRootApprox', [
+                    pb.float('d'),
+                    pb.float('xi')
+                ], function() {
+                    this.$l.x = pb.min(this.xi, 0.9999);
+                    this.$return(pb.mul(this.d, pb.sub(pb.mul(pb.sub(2, 2.6), this.x), 2), pb.log(pb.max(pb.sub(1, this.x), 1e-6))));
+                });
+                // GetCDFDeriv1: 0.25/d (e^{-r/d} + e^{-r/3d}), clamped as CLAMP_PDF does.
+                pb.func('burleyPdf', [
+                    pb.float('r'),
+                    pb.float('l'),
+                    pb.float('s')
+                ], function() {
+                    this.$l.d = pb.max(pb.div(this.l, this.s), 1e-6);
+                    this.$l.e1 = pb.exp(pb.neg(pb.min(pb.div(this.r, this.d), 40)));
+                    this.$l.e2 = pb.exp(pb.neg(pb.min(pb.div(this.r, pb.mul(this.d, 3)), 40)));
+                    this.$return(pb.max(pb.mul(pb.div(0.25, this.d), pb.add(this.e1, this.e2)), 1e-5));
+                });
+                // GetDiffuseReflectProfileWithDiffuseMeanFreePath: r R(r), per channel.
+                //   D = 1/s3d,  R = radius/L,  (e^{-R/D} + e^{-R/3D}) / (D L) / 8pi
+                pb.func('diffusionProfile', [
+                    pb.vec3('l'),
+                    pb.vec3('s3d'),
+                    pb.float('radius')
+                ], function() {
+                    this.$l.D = pb.div(pb.vec3(1), pb.max(this.s3d, pb.vec3(1e-6)));
+                    this.$l.L = pb.max(this.l, pb.vec3(1e-6));
+                    this.$l.R = pb.div(pb.vec3(this.radius), this.L);
+                    this.$l.negRD = pb.div(pb.neg(this.R), this.D);
+                    this.$l.e1 = pb.exp(pb.max(this.negRD, pb.vec3(-40)));
+                    this.$l.e2 = pb.exp(pb.max(pb.div(this.negRD, 3), pb.vec3(-40)));
+                    this.$return(pb.max(pb.div(pb.add(this.e1, this.e2), pb.mul(this.D, this.L, 8 * Math.PI)), pb.vec3(1e-12)));
+                });
+                // GetCDF with XI = 0, used to weight the centre sample.
+                pb.func('burleyCdf', [
+                    pb.float('d'),
+                    pb.float('x')
+                ], function() {
+                    this.$l.sd = pb.max(this.d, 1e-6);
+                    this.$return(pb.clamp(pb.sub(pb.sub(1, pb.mul(0.25, pb.exp(pb.neg(pb.min(pb.div(this.x, this.sd), 40))))), pb.mul(0.75, pb.exp(pb.neg(pb.min(pb.div(this.x, pb.mul(this.sd, 3)), 40))))), 0, 1));
+                });
+                // R2Sequence: the low-discrepancy pair UE5 samples radius and angle with.
+                // The index must stay an integer - offsetting it by a per-pixel fraction
+                // turns the sequence into a phase sweep correlated with pixel position,
+                // which shows up as banding.
+                pb.func('r2Sequence', [
+                    pb.int('i')
+                ], function() {
+                    this.$return(pb.fract(pb.mul(pb.vec2(0.7548776662466927, 0.5698402909980532), pb.float(this.i))));
+                });
+                // Fetch one parameter column of a profile row. `id` is the normalized
+                // per-pixel profile id; rows are addressed by it directly, as UE5 does
+                // with its SSProfiles table.
+                pb.func('readProfile', [
+                    pb.float('id'),
+                    pb.float('column')
+                ], function() {
+                    this.$l.u = pb.mul(pb.add(this.column, 0.5), this.profileParams.y);
+                    this.$l.v = pb.mul(pb.add(pb.mul(pb.clamp(this.id, 0, 1), 255), 0.5), this.profileParams.z);
+                    this.$return(pb.textureSampleLevel(this.profileTex, pb.vec2(this.u, this.v), 0));
+                });
+                pb.func('readNormal', [
+                    pb.vec2('uv')
+                ], function() {
+                    this.$return(pb.normalize(pb.sub(pb.mul(pb.textureSampleLevel(this.maskTex, this.uv, 0).rgb, 2), pb.vec3(1))));
+                });
                 pb.main(function() {
                     this.$l.uv = this.$inputs.uv;
-                    this.$l.center = pb.textureSampleLevel(this.skinTex, this.uv, 0);
+                    this.$l.center = this.readDiffusible(this.uv);
+                    this.$l.centerId = this.readProfileId(this.uv);
                     this.$l.centerDepth01 = this.readDepth01(this.uv);
                     this.$outputs.outColor = this.center;
-                    // Background, or a pixel no skin material wrote: nothing to diffuse.
-                    this.$if(pb.and(pb.lessThan(this.centerDepth01, 1), pb.greaterThan(this.center.a, 1e-4)), function() {
+                    // Two distinct tests: a pixel can carry a profile with zero opacity, or
+                    // an opacity with no profile where the prepass and the light pass
+                    // disagree about coverage. Neither scatters.
+                    this.$if(pb.and(pb.lessThan(this.centerDepth01, 1), pb.and(pb.greaterThan(this.center.a, 1e-4), pb.greaterThan(this.centerId, 0.5 / 255))), function() {
                         this.$l.centerDepth = pb.max(pb.mul(this.centerDepth01, this.cameraNearFar.y), 1e-4);
-                        // Per-channel radius in pixels. Red reaches several times further
-                        // than blue, which is the whole point - a shared radius is what
-                        // makes Gaussian SSS read as a flat haze.
-                        this.$l.viewScale = pb.max(pb.mix(pb.float(1), this.centerDepth, this.radiusParams.y), 1e-4);
-                        this.$l.radiusPx = pb.div(pb.mul(this.channelRadius, this.radiusParams.x), this.viewScale);
-                        // Burley shaping distance per channel; falloff tightens or widens
-                        // the profile without changing its reach.
-                        this.$l.shape = pb.vec3(pb.mix(0.72, 1.46, pb.clamp(this.channelFalloff.x, 0.05, 1)), pb.mix(0.72, 1.46, pb.clamp(this.channelFalloff.y, 0.05, 1)), pb.mix(0.72, 1.46, pb.clamp(this.channelFalloff.z, 0.05, 1)));
-                        this.$l.shapeDist = pb.max(pb.mul(this.radiusPx, this.shape), pb.vec3(1e-3));
-                        // Tap spacing follows the widest channel so the longest tail is
-                        // resolved; the narrower channels simply weight down sooner.
-                        this.$l.maxRadiusPx = pb.max(pb.max(this.radiusPx.x, this.radiusPx.y), this.radiusPx.z);
-                        this.$l.stepPx = pb.clamp(pb.div(this.maxRadiusPx, SKIN_SSS_TAPS), 0, this.radiusParams.z);
-                        this.$l.stepUV = pb.mul(this.blurDirection, this.stepPx, this.targetSize.zw);
-                        this.$l.sum = pb.vec3(0);
-                        this.$l.weightSum = pb.vec3(0);
-                        this.$l.coverage = pb.float(0);
-                        this.$l.coverageWeight = pb.float(0);
-                        this.$for(pb.int('i'), -8, SKIN_SSS_TAPS + 1, function() {
-                            this.$l.fi = pb.float(this.i);
-                            this.$l.sampleUV = pb.clamp(pb.add(this.uv, pb.mul(this.stepUV, this.fi)), pb.vec2(0), pb.vec2(1));
-                            this.$l.dist = pb.mul(pb.abs(this.fi), this.stepPx);
-                            this.$l.w = pb.vec3(burleyDiffusionWeight(this, this.dist, this.shapeDist.x), burleyDiffusionWeight(this, this.dist, this.shapeDist.y), burleyDiffusionWeight(this, this.dist, this.shapeDist.z));
+                        this.$l.centerNormal = this.readNormal(this.uv);
+                        this.$l.scaling = this.readProfile(this.centerId, 0);
+                        this.$l.albedo = this.readProfile(this.centerId, 1);
+                        this.$l.mfp = this.readProfile(this.centerId, 2);
+                        this.$l.boundaryBleed = this.readProfile(this.centerId, 3).rgb;
+                        this.$l.worldUnitScale = pb.max(this.scaling.x, 1e-3);
+                        // UE5 draws the radius from one representative channel
+                        // (SurfaceAlbedo.a / DiffuseMeanFreePath.a) and evaluates all three
+                        // channel kernels at those radii.
+                        this.$l.aForSampling = this.albedo.w;
+                        this.$l.lForSampling = pb.max(this.mfp.w, 1e-6);
+                        this.$l.S = this.scalingFactor(this.aForSampling);
+                        this.$l.S3D = this.scalingFactor3D(this.albedo.rgb);
+                        this.$l.dForSampling = pb.div(this.lForSampling, pb.max(this.S, 1e-6));
+                        // CalculateBurleyScale: profile space to UV. Purely unit conversion,
+                        // including the 1/depth perspective term - nothing here shapes the
+                        // kernel.
+                        // Perspective divides the world radius by the view depth so the disc
+                        // keeps a constant world size as the subject recedes; orthographic
+                        // has no such term and takes 1.
+                        this.$l.viewScale = pb.max(pb.select(this.centerDepth, pb.float(1), pb.equal(this.perspective, 0)), 1e-4);
+                        // The world unit scale is applied here and only here; the packed
+                        // mean free path leaves it out, as UE5 does. Applying it in both
+                        // places would make the diffusion scale with its square. UE5's
+                        // extra cm-to-mm cast has no counterpart in this metric engine.
+                        this.$l.burleyScale = pb.div(pb.mul(this.projScale, this.worldUnitScale), this.viewScale);
+                        // Centre-sample reweighting: the radius within one texel and the CDF
+                        // mass it accounts for. Sampling then covers only [cdf, 1] and the
+                        // centre is lerped back in at the end. Averaged over the two axes,
+                        // as UE5's CalculateCenterSampleRadiusInMM does, since they carry
+                        // different scales.
+                        this.$l.centerRadiusMM = pb.mul(0.5, pb.add(pb.div(this.targetSize.z, pb.max(this.burleyScale.x, 1e-9)), pb.div(this.targetSize.w, pb.max(this.burleyScale.y, 1e-9))));
+                        this.$l.centerCdf = this.burleyCdf(this.dForSampling, this.centerRadiusMM);
+                        // Per-channel diffusion distance, the same `d` the kernel below is
+                        // evaluated with. UE5's scalar DiffuseMeanFreePath works there
+                        // because its `.a` and `.rgb` are related by construction; here `.a`
+                        // is simply the widest channel, so substituting it would flatten the
+                        // channel ratio - and invert it, since a smaller `d` concentrates
+                        // more CDF mass inside one texel.
+                        this.$l.dPerChannel = pb.div(this.mfp.rgb, pb.max(this.S3D, pb.vec3(1e-6)));
+                        this.$l.centerWeight = pb.vec3(this.burleyCdf(this.dPerChannel.x, this.centerRadiusMM), this.burleyCdf(this.dPerChannel.y, this.centerRadiusMM), this.burleyCdf(this.dPerChannel.z, this.centerRadiusMM));
+                        // Integer sequence start, rebased per pixel so neighbours do not
+                        // draw the identical 64 taps. It must land on an integer to keep the
+                        // low-discrepancy spacing, as UE5's 16-bit `Rand3DPCG16` rebase does.
+                        //
+                        // UE5 also advances the seed per frame and leans on TAA to resolve
+                        // the remainder. Without that history a per-frame seed would read as
+                        // flicker, so this is held fixed and trades it for a stable error.
+                        this.$l.seedStart = pb.int(pb.mul(hash21(this, pb.mul(this.uv, this.targetSize.xy)), 65536));
+                        this.$l.radianceAccum = pb.vec3(0);
+                        this.$l.weightAccum = pb.vec3(0);
+                        this.$l.bleedAccum = pb.vec3(0);
+                        this.$l.acceptedCount = pb.float(0);
+                        this.$l.radiusSum = pb.float(0);
+                        this.$for(pb.int('i'), 0, DEFAULT_SAMPLE_COUNT, function() {
+                            this.$l.rand = this.r2Sequence(pb.add(this.seedStart, this.i));
+                            // Restrict the radius draw to the range the centre sample does not
+                            // already account for.
+                            this.$l.xi = pb.add(this.centerCdf, pb.mul(this.rand.x, pb.sub(1, this.centerCdf)));
+                            this.$l.radiusMM = pb.max(this.radiusRootApprox(this.dForSampling, this.xi), 1e-5);
+                            this.$l.pdf = this.burleyPdf(this.radiusMM, this.lForSampling, this.S);
+                            this.$l.theta = pb.mul(this.rand.y, 2 * Math.PI);
+                            this.$l.uvOffset = pb.mul(pb.vec2(pb.cos(this.theta), pb.sin(this.theta)), pb.mul(this.radiusMM, this.burleyScale));
+                            this.$l.sampleUV = pb.clamp(pb.add(this.uv, this.uvOffset), pb.vec2(0), pb.vec2(1));
+                            this.$l.tapSample = this.readDiffusible(this.sampleUV);
                             this.$l.sampleDepth01 = this.readDepth01(this.sampleUV);
                             this.$l.sampleDepth = pb.max(pb.mul(this.sampleDepth01, this.cameraNearFar.y), 1e-4);
-                            this.$l.depthWeight = pb.clamp(pb.sub(1, pb.div(pb.mul(pb.abs(pb.sub(this.centerDepth, this.sampleDepth)), this.radiusParams.w), this.centerDepth)), 0, 1);
-                            this.depthWeight = pb.mul(this.depthWeight, this.depthWeight, pb.sub(3, pb.mul(this.depthWeight, 2)));
-                            this.$l.tapWeight = pb.mul(this.w, this.depthWeight);
-                            this.$l.tapSample = pb.textureSampleLevel(this.skinTex, this.sampleUV, 0);
-                            // Non-skin taps are excluded from the numerator *and* the
-                            // denominator. Leaving them in the denominator - as this pass
-                            // used to - drags the diffuse toward zero near every silhouette,
-                            // which was a mild darkening under the old additive composite
-                            // but would eat real light now that the term is subtracted back
-                            // out of the base color.
-                            this.$l.isSkin = pb.float(pb.greaterThan(this.tapSample.a, 1e-4));
-                            this.sum = pb.add(this.sum, pb.mul(this.tapSample.rgb, this.tapWeight, this.isSkin));
-                            this.weightSum = pb.add(this.weightSum, pb.mul(this.tapWeight, this.isSkin));
-                            // Coverage keeps its own accumulator: it is the skin fraction of
-                            // the neighbourhood, so it must count every tap in the
-                            // denominator, skin or not.
-                            this.coverage = pb.add(this.coverage, pb.mul(this.tapWeight.x, this.isSkin, this.tapSample.a));
-                            this.coverageWeight = pb.add(this.coverageWeight, this.tapWeight.x);
+                            this.$l.tapNormal = this.readNormal(this.sampleUV);
+                            this.$l.normalWeight = pb.sqrt(pb.clamp(pb.add(pb.mul(pb.dot(this.tapNormal, this.centerNormal), 0.5), 0.5), 0, 1));
+                            // Bilateral term: the depth difference in the same millimetre
+                            // space as the radius, so a large world unit scale does not
+                            // over-penalize the sample. UE5 compares the two one-to-one.
+                            this.$l.deltaDepth = pb.div(pb.sub(this.sampleDepth, this.centerDepth), this.worldUnitScale);
+                            this.$l.radiusSampledMM = pb.sqrt(pb.add(pb.mul(this.radiusMM, this.radiusMM), pb.mul(this.deltaDepth, this.deltaDepth)));
+                            this.$l.profile = this.diffusionProfile(this.mfp.rgb, this.S3D, this.radiusSampledMM);
+                            this.$l.tapId = this.readProfileId(this.sampleUV);
+                            // The tap's own opacity, UE5's Opacity semantics: 0 contributes
+                            // nothing, 1 contributes fully, and the values between give the
+                            // smooth transition a painted mask is for.
+                            this.$l.tapOpacity = pb.select(pb.float(0), this.tapSample.a, pb.greaterThan(this.tapId, 0.5 / 255));
+                            // A tap that is not skin falls back to the centre pixel rather
+                            // than dropping out of the estimator, for two reasons.
+                            //
+                            // Variance: this is self-normalized, so a dropped tap leaves both
+                            // sums. Beside a large non-skin region most of the disc lands in
+                            // it, and since the per-pixel seed is fixed, neighbouring pixels
+                            // survive on different taps - spatial white noise.
+                            //
+                            // Numerics: importance sampling is exact only for the channel the
+                            // radii were drawn from, so `profile/pdf` is constant for red
+                            // while blue decays to ~7e-9 in the tail. Dropping the near taps
+                            // leaves blue's `weightAccum` on the order of the 1e-9 floor
+                            // below, which clamps it to zero.
+                            //
+                            // The substitution assumes the hole scatters like the pixel under
+                            // consideration - the same assumption the centre-weighted blend
+                            // already makes - and costs a slightly firmer edge at the hole.
+                            this.$l.tapColor = pb.mix(this.center.rgb, this.tapSample.rgb, this.tapOpacity);
+                            this.$l.sampleWeight = pb.mul(pb.div(this.profile, this.pdf), this.normalWeight);
+                            // Taps from another profile are tinted rather than dropped, so a
+                            // face/lip boundary softens instead of seaming. The comparison is
+                            // against the prepass id now; 0.002 is still half a step of the
+                            // 8-bit channel it rides in.
+                            this.$l.sameProfile = pb.float(pb.or(pb.lessThan(pb.abs(pb.sub(this.tapId, this.centerId)), 0.002), pb.lessThan(this.tapOpacity, 1e-4)));
+                            // Only taps that landed on skin contribute a bleed factor, and
+                            // both sides of the ratio carry the same opacity, so the mean
+                            // stays a tint in [bleed, 1]. Taps that fell back to the centre
+                            // are excluded: they carry the centre's own profile, so counting
+                            // them would dilute a real boundary tint towards white.
+                            this.bleedAccum = pb.add(this.bleedAccum, pb.mul(pb.mix(this.boundaryBleed, pb.vec3(1), this.sameProfile), this.tapOpacity));
+                            this.acceptedCount = pb.add(this.acceptedCount, this.tapOpacity);
+                            this.radianceAccum = pb.add(this.radianceAccum, pb.mul(this.sampleWeight, this.tapColor));
+                            this.weightAccum = pb.add(this.weightAccum, this.sampleWeight);
+                            this.radiusSum = pb.add(this.radiusSum, this.radiusMM);
+                        });
+                        // Energy normalization, matching UE5's 1/0.99995 compensation.
+                        this.$l.diffused = pb.mul(pb.div(this.radianceAccum, pb.max(this.weightAccum, pb.vec3(1e-9))), 1 / 0.99995);
+                        // Mean bleed over the taps that landed on skin: a tint in [bleed, 1],
+                        // never a gain. A branch rather than `max(acceptedCount, 1)`, which
+                        // would only be correct for an integer count - this is a sum of
+                        // opacities, so a half-masked neighbourhood would be darkened by
+                        // exactly its own mask on top of the fade applied below.
+                        this.$l.bleedTint = pb.vec3(1);
+                        this.$if(pb.greaterThan(this.acceptedCount, 1e-4), function() {
+                            this.bleedTint = pb.div(this.bleedAccum, this.acceptedCount);
+                        });
+                        this.diffused = pb.mul(this.diffused, this.bleedTint);
+                        // Blend the centre pixel back in with the CDF mass it represents.
+                        this.diffused = pb.mix(this.diffused, this.center.rgb, this.centerWeight);
+                        // Per channel: importance sampling is exact only for the one the
+                        // radii were drawn from, so the three weights differ by orders of
+                        // magnitude and a single scalar test cannot speak for all of them.
+                        // Built as a mask rather than a vector-conditioned select, which
+                        // has no legal GLSL form - the ternary there takes a scalar only.
+                        this.$l.weightValid = pb.vec3(pb.float(pb.greaterThan(this.weightAccum.x, 0)), pb.float(pb.greaterThan(this.weightAccum.y, 0)), pb.float(pb.greaterThan(this.weightAccum.z, 0)));
+                        this.diffused = pb.mix(this.center.rgb, this.diffused, this.weightValid);
+                        // The centre's own opacity fades the whole result back towards the
+                        // unscattered pixel. Taps were already weighted by *their* opacity,
+                        // which controls how much the neighbourhood contributes; this
+                        // controls how much this pixel accepts. UE5 applies the same value
+                        // at both ends, which is what makes a painted mask read as a
+                        // gradient in scattering strength rather than as an edge.
+                        this.diffused = pb.mix(this.center.rgb, this.diffused, this.center.a);
+                        // Alpha is unused downstream; Recombine reads its own mask.
+                        this.$outputs.outColor = pb.vec4(pb.max(this.diffused, pb.vec3(0)), this.center.a);
+                        this.$if(pb.notEqual(this.debugMode, 0), function() {
+                            this.$l.dbg = pb.vec3(0);
+                            this.$if(pb.equal(this.debugMode, 1), function() {
+                                this.dbg = this.center.rgb;
+                            });
+                            this.$if(pb.equal(this.debugMode, 2), function() {
+                                this.$l.lum = pb.dot(pb.textureSampleLevel(this.sceneTex, this.uv, 0).rgb, pb.vec3(0.2126, 0.7152, 0.0722));
+                                this.dbg = pb.vec3(pb.clamp(pb.div(pb.textureSampleLevel(this.sceneTex, this.uv, 0).a, pb.max(this.lum, 1e-4)), 0, 1));
+                            });
+                            this.$if(pb.equal(this.debugMode, 3), function() {
+                                this.dbg = pb.vec3(pb.mul(this.centerId, 255 / 8));
+                            });
+                            this.$if(pb.equal(this.debugMode, 4), function() {
+                                this.dbg = pb.add(pb.mul(this.centerNormal, 0.5), pb.vec3(0.5));
+                            });
+                            this.$if(pb.equal(this.debugMode, 5), function() {
+                                // d in millimetres of world space, so skin reads around 1.
+                                this.dbg = pb.mul(this.dPerChannel, 1000);
+                            });
+                            this.$if(pb.equal(this.debugMode, 6), function() {
+                                // Mean vertical sample radius in pixels, 32 px mapped to white.
+                                this.dbg = pb.vec3(pb.div(pb.mul(pb.div(this.radiusSum, DEFAULT_SAMPLE_COUNT), this.burleyScale.y, this.targetSize.y), 32));
+                            });
+                            this.$if(pb.equal(this.debugMode, 7), function() {
+                                this.dbg = this.weightAccum;
+                            });
+                            this.$if(pb.equal(this.debugMode, 8), function() {
+                                this.dbg = pb.vec3(pb.div(this.acceptedCount, DEFAULT_SAMPLE_COUNT));
+                            });
+                            this.$if(pb.equal(this.debugMode, 9), function() {
+                                this.dbg = this.centerWeight;
+                            });
+                            this.$if(pb.equal(this.debugMode, 10), function() {
+                                this.dbg = this.diffused;
+                            });
+                            if (hasTextureArrays) {
+                                this.$if(pb.equal(this.debugMode, 11), function() {
+                                    // Shown as optical depth (bright = thick), not the stored
+                                    // encoding. An unobstructed surface stores 0.92, close enough
+                                    // to the 1.0 of "no light wrote this" that blue calls the
+                                    // latter out separately. The minimum over layer 0's four
+                                    // channels shows whichever light sees the most material.
+                                    this.$l.th = pb.textureArraySampleLevel(this.thicknessTex, this.uv, 0, 0);
+                                    this.$l.enc = pb.min(pb.min(this.th.r, this.th.g), pb.min(this.th.b, this.th.a));
+                                    this.$if(pb.greaterThan(this.enc, 0.999), function() {
+                                        this.dbg = pb.vec3(0, 0, 1);
+                                    }).$else(function() {
+                                        this.dbg = pb.vec3(pb.sub(1, this.enc));
+                                    });
+                                });
+                            }
+                            this.$outputs.outColor = pb.vec4(pb.mul(this.dbg, this.debugExposure), this.center.a);
                         });
-                        this.$l.diffused = pb.div(this.sum, pb.max(this.weightSum, pb.vec3(1e-6)));
-                        this.$outputs.outColor = pb.vec4(this.diffused, pb.div(this.coverage, pb.max(this.coverageWeight, 1e-6)));
                     });
                 });
             }
         });
-        program.name = '@SkinSSSBlur';
+        program.name = '@SkinSSSBurley';
         return program;
     }
-    createCombineProgram(ctx) {
+    createBVarProgram(ctx) {
+        // Placeholder for UE5's `UpdateQualityVariance`, a luminance-residual history
+        // that drives the next frame's adaptive sample count. Without a history buffer
+        // there is nothing to accumulate, so this is a straight copy and the diffusion
+        // always runs at full sample count; the pass is the slot history would occupy.
+        const program = ctx.device.buildRenderProgram({
+            vertex (pb) {
+                SkinSSS.fullscreenVertex(pb);
+            },
+            fragment (pb) {
+                this.diffusedTex = pb.tex2D().uniform(0);
+                this.depthTex = pb.tex2D().sampleType('unfilterable-float').uniform(0);
+                this.targetSize = pb.vec4().uniform(0);
+                this.cameraNearFar = pb.vec2().uniform(0);
+                this.$outputs.outColor = pb.vec4();
+                pb.main(function() {
+                    this.$l.diffused = pb.textureSampleLevel(this.diffusedTex, this.$inputs.uv, 0);
+                    // Alpha is the subsurface opacity the diffusion wrote; it is passed
+                    // through unchanged rather than repurposed.
+                    this.$outputs.outColor = pb.vec4(this.diffused.rgb, this.diffused.a);
+                });
+            }
+        });
+        program.name = '@SkinSSSBVar';
+        return program;
+    }
+    createRecombineProgram(ctx) {
         const program = ctx.device.buildRenderProgram({
             vertex (pb) {
                 SkinSSS.fullscreenVertex(pb);
             },
             fragment (pb) {
                 this.colorTex = pb.tex2D().uniform(0);
-                this.skinTex = pb.tex2D().uniform(0);
-                this.blurredTex = pb.tex2D().uniform(0);
+                this.maskTex = pb.tex2D().uniform(0);
+                this.bvarTex = pb.tex2D().uniform(0);
                 this.depthTex = pb.tex2D().sampleType('unfilterable-float').uniform(0);
                 this.cameraNearFar = pb.vec2().uniform(0);
                 this.targetSize = pb.vec4().uniform(0);
-                this.radiusParams = pb.vec4().uniform(0);
-                this.scatterTint = pb.vec4().uniform(0);
-                this.strength = pb.float().uniform(0);
-                this.glow = pb.float().uniform(0);
-                this.opacity = pb.float().uniform(0);
-                this.colorBoost = pb.float().uniform(0);
-                this.encodeScale = pb.float().uniform(0);
-                this.smoothness = pb.float().uniform(0);
+                this.debugMode = pb.int().uniform(0);
                 this.srgbOut = pb.int().uniform(0);
                 this.$outputs.outColor = pb.vec4();
                 pb.func('readDepth01', [
@@ -429,52 +694,37 @@ import { AbstractPostEffect, PostEffectLayer } from './posteffect.js';
                     this.$l.uv = this.$inputs.uv;
                     this.$l.baseColor = pb.textureSampleLevel(this.colorTex, this.uv, 0);
                     this.$l.result = this.baseColor.rgb;
-                    this.$l.centerSkin = pb.textureSampleLevel(this.skinTex, this.uv, 0);
                     this.$l.centerDepth01 = this.readDepth01(this.uv);
-                    this.$if(pb.and(pb.lessThan(this.centerDepth01, 1), pb.greaterThan(this.centerSkin.a, 1e-4)), function() {
-                        this.$l.blurred = pb.textureSampleLevel(this.blurredTex, this.uv, 0);
-                        // Both buffers carry the same LDR encoding, so decode once here.
-                        this.$l.original = pb.mul(this.centerSkin.rgb, this.encodeScale);
-                        this.$l.diffused = pb.mul(this.blurred.rgb, this.encodeScale, this.colorBoost);
-                        this.$l.coverage = pb.smoothStep(this.opacity, pb.add(this.opacity, 0.35), this.blurred.a);
-                        // Energy conserving core: swap the original diffuse for the
-                        // diffused one. The added term is exactly the subtracted term, so
-                        // brightening the dark side of the terminator darkens the lit side
-                        // by the same amount rather than adding light to the frame.
-                        this.$l.redistributed = pb.mul(pb.sub(this.diffused, this.original), this.scatterTint.rgb, this.strength, this.coverage);
-                        this.result = pb.add(this.baseColor.rgb, this.redistributed);
-                        // Explicit, opt-in departure from conservation.
-                        this.$if(pb.greaterThan(this.glow, 0), function() {
-                            this.result = pb.add(this.result, pb.mul(this.diffused, this.scatterTint.rgb, this.glow, this.coverage));
-                        });
-                        // Beauty filter. Unlike the diffusion above this blurs the shaded
-                        // color itself, so it removes albedo detail (pores, blemishes)
-                        // that scattering physically leaves alone. Uniform branch: free
-                        // when disabled.
-                        this.$if(pb.greaterThan(this.smoothness, 0), function() {
-                            this.$l.centerDepth = pb.max(pb.mul(this.centerDepth01, this.cameraNearFar.y), 1e-4);
-                            this.$l.viewScale = pb.max(pb.mix(pb.float(1), this.centerDepth, this.radiusParams.y), 1e-4);
-                            this.$l.smoothStepPx = pb.clamp(pb.div(pb.mul(this.radiusParams.x, 0.5), this.viewScale), 0, this.radiusParams.z);
-                            this.$l.colorSum = pb.vec3(0);
-                            this.$l.colorWeight = pb.float(0);
-                            this.$for(pb.int('y'), -2, 3, function() {
-                                this.$for(pb.int('x'), -2, 3, function() {
-                                    this.$l.offset = pb.mul(pb.vec2(pb.float(this.x), pb.float(this.y)), this.smoothStepPx, this.targetSize.zw);
-                                    this.$l.sampleUV = pb.clamp(pb.add(this.uv, this.offset), pb.vec2(0), pb.vec2(1));
-                                    // The skin mask is the edge stop, so eyes, brows and lips
-                                    // (mask 0) never bleed onto the surrounding skin.
-                                    this.$l.maskSample = pb.textureSampleLevel(this.skinTex, this.sampleUV, 0).a;
-                                    this.$l.w = pb.float(pb.greaterThan(this.maskSample, 1e-4));
-                                    this.colorSum = pb.add(this.colorSum, pb.mul(pb.textureSampleLevel(this.colorTex, this.sampleUV, 0).rgb, this.w));
-                                    this.colorWeight = pb.add(this.colorWeight, this.w);
-                                });
-                            });
-                            this.$if(pb.greaterThan(this.colorWeight, 1e-4), function() {
-                                this.result = pb.mix(this.result, pb.div(this.colorSum, this.colorWeight), pb.mul(this.smoothness, this.coverage, this.centerSkin.a));
-                            });
-                        });
-                        // Precision can push the subtraction a hair below zero.
-                        this.result = pb.max(this.result, pb.vec3(0));
+                    // Subsurface opacity. A plain gate is right here: how strongly the
+                    // pixel scattered is already baked into the diffusion buffer, and
+                    // weighting by the opacity a second time would count it twice.
+                    this.$l.centerMask = pb.textureSampleLevel(this.maskTex, this.uv, 0).a;
+                    this.$if(pb.and(pb.equal(this.debugMode, 0), pb.and(pb.lessThan(this.centerDepth01, 1), pb.greaterThan(this.centerMask, 1e-4))), function() {
+                        // UE5 SSS::Recombine (lines 32-40): split the lit pixel into the
+                        // diffuse part that was allowed to scatter and the specular part
+                        // that must survive untouched, then swap the diffuse for the
+                        // diffused version.
+                        this.$l.lum = pb.dot(this.baseColor.rgb, pb.vec3(0.2126, 0.7152, 0.0722));
+                        // Must match Burley's split exactly: that pass diffused
+                        // `baseColor.rgb * diffAmt` and this one keeps the remainder, so a
+                        // disagreement leaves the halves not adding up to the original.
+                        this.$l.diffAmt = pb.select(pb.float(1), pb.clamp(pb.div(this.baseColor.a, pb.max(this.lum, 1e-4)), 0, 1), pb.greaterThan(this.lum, 1e-4));
+                        this.$l.specKeep = pb.mul(this.baseColor.rgb, pb.sub(1, this.diffAmt));
+                        // The diffusion buffer's alpha is the subsurface opacity, not a
+                        // transmission term - nothing in this pipeline produces one here.
+                        // UE5's transmission likewise comes from SubsurfaceProfileBxDF per
+                        // light, and the back-lit term on SSSMaterial that stands in for
+                        // it is already part of SceneColor.
+                        this.$l.diffused = pb.textureSampleLevel(this.bvarTex, this.uv, 0).rgb;
+                        // Straight sum, as UE5 does it. No blend weight or tint: how far and
+                        // in what colour the light travels is the profile's business, and a
+                        // second knob on top could only disagree with it.
+                        this.result = pb.max(pb.add(this.diffused, this.specKeep), pb.vec3(0));
+                    });
+                    // A debug channel must reach the screen unmodified, so recombination is
+                    // skipped and the diffusion buffer is shown as it was written.
+                    this.$if(pb.notEqual(this.debugMode, 0), function() {
+                        this.result = pb.textureSampleLevel(this.bvarTex, this.uv, 0).rgb;
                     });
                     this.$if(pb.equal(this.srgbOut, 0), function() {
                         this.$outputs.outColor = pb.vec4(this.result, this.baseColor.a);
@@ -484,7 +734,7 @@ import { AbstractPostEffect, PostEffectLayer } from './posteffect.js';
                 });
             }
         });
-        program.name = '@SkinSSSCombine';
+        program.name = '@SkinSSSRecombine';
         return program;
     }
 }