@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/material/skin.js

@@ -1,245 +1,219 @@
-import { Vector4 } from '@zephyr3d/base';
+import { Vector3, Vector2 } from '@zephyr3d/base';
 import { applyMaterialMixins, MeshMaterial } from './meshmaterial.js';
 import { mixinLight } from './mixins/lit.js';
 import { mixinVertexColor } from './mixins/vertexcolor.js';
 import { mixinTextureProps } from './mixins/texture.js';
 import { ShaderHelper } from './shader/helper.js';
-import { RENDER_PASS_TYPE_LIGHT, LIGHT_TYPE_POINT, MaterialVaryingFlags } from '../values.js';
+import { RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_DEPTH, LIGHT_TYPE_POINT, MaterialVaryingFlags } from '../values.js';
+import { skinDualSpecularRoughness, skinSpecularEnergyTerms, skinDiffuseBRDF, skinTransmission, skinDualLobeSpecular } from '../shaders/skin_brdf.js';
+import { SSSProfile } from './sssprofile.js';
+import { fetchSampler } from '../utility/misc.js';
 
-/**
- * HDR range packed into the SkinSSS side buffer when the render graph falls
- * back to an 8-bit format. The material divides the scatter irradiance by this
- * factor on write and {@link SkinSSS} multiplies it back after the blur.
- * @public
+/**
+ * HDR range that used to be packed into the PostSSS side buffer when the render
+ * graph fell back to an 8-bit format.
+ *
+ * @deprecated The skin scattering source is now recovered from `SceneColor` via
+ * the diffuse luminance stored in its alpha channel (matching UE5), so no side
+ * buffer and no LDR encoding is involved. Kept for source compatibility; it has
+ * no effect on rendering.
+ *
+ * @public
  */ const SKIN_SSS_LDR_ENCODE_RANGE = 4;
-/**
- * Stylized realtime skin material.
- *
- * @remarks
- * This material is designed for the {@link SkinSSS} post effect. It renders a regular lit color
- * and, when `camera.skinSSS` is enabled, writes the *diffusible* part of that color - the stylized
- * diffuse ramp plus back-lit transmission, without specular - into the `SkinSSSTexture` MRT.
- *
- * The side buffer holds exactly the same term that is already in the lit color, untinted and
- * unscaled. {@link SkinSSS} subtracts it and adds back a channel-dependent diffused version, so
- * the redistribution is energy conserving by construction and disabling the effect leaves the
- * image unchanged. Scatter tint, strength and radius therefore live on the post effect, not here.
- *
- * Stylization is split from diffusion on purpose. {@link SkinMaterial.diffuseWrap},
- * {@link SkinMaterial.diffuseSoftness}, {@link SkinMaterial.shadowTint} and
- * {@link SkinMaterial.brightening} shape the direct lighting ramp; the post effect then diffuses
- * whatever ramp they produced. A stylized ramp stays stylized after scattering rather than being
- * averaged away.
- *
- * The optional `subsurfaceTexture` uses R as skin mask, G as local softness and B as thickness
- * for the back-lit transmission term (thin regions such as ears and nostrils glow when lit from
- * behind; enable it by setting {@link SkinMaterial.transmissionStrength}).
- *
- * @public
- */ class SkinMaterial extends applyMaterialMixins(MeshMaterial, mixinLight, mixinVertexColor, mixinTextureProps('subsurface')) {
+/**
+ * Physically-based skin material aligned with UE5's SubsurfaceProfile shading model.
+ *
+ * @remarks
+ * Uses a pre-integrated curvature-dependent diffuse BRDF and dual-lobe GGX specular
+ * driven by subsurface profile parameters. The **diffuse** luminance is written to
+ * `SceneColor.a` so the {@link PostSSS} post effect can recover the diffusible
+ * fraction as `saturate(SceneColor.a / luma(SceneColor.rgb))` — the same spec/diff
+ * separation UE5 performs in its SSS Setup and Recombine passes.
+ *
+ * The optional `subsurfaceTexture` uses R as the skin mask, which gates both the
+ * screen-space diffusion and the dual specular lobe. Its other channels are
+ * unused: transmission thickness is measured against the light's shadow map by
+ * the transmission thickness pass rather than painted, and curvature is not part
+ * of this path.
+ *
+ * @public
+ */ class SSSMaterial extends applyMaterialMixins(MeshMaterial, mixinLight, mixinVertexColor, mixinTextureProps('subsurface')) {
     static FEATURE_VERTEX_NORMAL = this.defineFeature();
     static FEATURE_VERTEX_TANGENT = this.defineFeature();
-    _shininess;
-    _specularStrength;
-    _diffuseWrap;
-    _diffuseSoftness;
-    _scatterWrap;
-    _scatterStrength;
-    _scatterColor;
+    _roughness;
+    _specularF0;
     _transmissionStrength;
-    _transmissionPower;
-    _shadowTint;
-    _brightening;
+    _profile;
+    _subsurfaceProfileChanged;
+    _lobeParams;
+    _profileTexelSize;
     constructor(){
         super();
-        this._shininess = 72;
-        this._specularStrength = 1;
-        this._diffuseWrap = 0.28;
-        this._diffuseSoftness = 0.45;
-        this._scatterWrap = 0.65;
-        this._scatterStrength = 1.5;
-        this._scatterColor = new Vector4(1, 0.42, 0.28, 1);
-        this._transmissionStrength = 0;
-        this._transmissionPower = 4;
-        this._shadowTint = new Vector4(0, 0, 0, 1);
-        this._brightening = 0;
-        this.useFeature(SkinMaterial.FEATURE_VERTEX_NORMAL, true);
-    }
-    /** Marker used by the forward render graph to allocate the SkinSSS MRT. */ get skinSSS() {
+        this._subsurfaceProfileChanged = ()=>this.uniformChanged();
+        // Created here and released in onDispose: the profile holds a row of a
+        // 256-entry GPU table, and tying its life to the material's is what keeps
+        // those rows from accumulating.
+        this._profile = SSSProfile.createOwned();
+        this._profile.addChangeListener(this._subsurfaceProfileChanged);
+        this._lobeParams = new Vector3();
+        this._profileTexelSize = new Vector2();
+        this._roughness = 0.5;
+        this._specularF0 = 0.04;
+        this._transmissionStrength = 1;
+        this.useFeature(SSSMaterial.FEATURE_VERTEX_NORMAL, true);
+    }
+    /** Releases the profile's table row along with the material. */ onDispose() {
+        super.onDispose();
+        this._profile.removeChangeListener(this._subsurfaceProfileChanged);
+        this._profile.dispose();
+    }
+    /**
+   * Marker used by the forward render graph to enable the PostSSS post effect.
+   *
+   * @remarks
+   * This no longer allocates a side buffer: the scattering source is recovered
+   * from `SceneColor` and its diffuse-luminance alpha.
+   */ get postSSS() {
         return true;
     }
+    /**
+   * The profile driving this material's subsurface scattering.
+   *
+   * @remarks
+   * Read-only and never null: the material creates one in its constructor and
+   * owns it for life, so edit it in place rather than assigning a new one.
+   *
+   * ```ts
+   * material.subsurfaceProfile.preset = 'jade';
+   * material.subsurfaceProfile.meanFreePathDistance = 0.03;
+   * ```
+   *
+   * Per-material ownership is what lets face, ears and lips scatter differently
+   * in a single screen-space pass: the material writes its profile's id per pixel
+   * and the diffusion looks the parameters up from there. Profiles are therefore
+   * not shared - to transfer a look, use {@link SSSProfile.copyFrom}.
+   *
+   * @public
+   */ get subsurfaceProfile() {
+        return this._profile;
+    }
+    /**
+   * Keeps the diffuse luminance written to `SceneColor.a` instead of letting the
+   * opaque path overwrite it with 1. {@link PostSSS} needs it to separate the
+   * diffusible energy from the specular it must leave untouched.
+   */ preservesOpaqueAlpha(ctx) {
+        return ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT;
+    }
+    /**
+   * Keeps `SceneColor.a` additive across the multi-pass light loop.
+   *
+   * @remarks
+   * The base implementation uses `zero/one` for alpha so that additive light
+   * passes preserve whatever the base pass wrote. That is wrong here: the alpha
+   * carries the diffuse luminance of the accumulated RGB, so it has to be summed
+   * alongside it — otherwise `SceneColor.a / luma(SceneColor.rgb)` under-reports
+   * the diffusible fraction as soon as a second light contributes, and the SSS
+   * passes would scatter only the first light's diffuse energy.
+   */ updateRenderStates(pass, stateSet, ctx) {
+        super.updateRenderStates(pass, stateSet, ctx);
+        if (ctx.lightBlending && ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+            const blendingState = stateSet.useBlendingState();
+            if (blendingState.enabled) {
+                blendingState.setBlendFuncAlpha('one', 'one');
+            }
+        }
+    }
     clone() {
-        const other = new SkinMaterial();
+        const other = new SSSMaterial();
         other.copyFrom(this);
         return other;
     }
     copyFrom(other) {
         super.copyFrom(other);
+        // The values, not the profile: a clone owns its own row of the table, so
+        // that disposing either material cannot pull the parameters out from under
+        // the other.
+        this._profile.copyFrom(other._profile);
         this.vertexNormal = other.vertexNormal;
         this.vertexTangent = other.vertexTangent;
-        this.shininess = other.shininess;
-        this.specularStrength = other.specularStrength;
-        this.diffuseWrap = other.diffuseWrap;
-        this.diffuseSoftness = other.diffuseSoftness;
-        this.scatterWrap = other.scatterWrap;
-        this.scatterStrength = other.scatterStrength;
-        this.scatterColor = other.scatterColor;
+        this.roughness = other.roughness;
+        this.specularF0 = other.specularF0;
         this.transmissionStrength = other.transmissionStrength;
-        this.transmissionPower = other.transmissionPower;
-        this.shadowTint = other.shadowTint;
-        this.brightening = other.brightening;
     }
-    /** true if vertex normal attribute presents */ get vertexNormal() {
-        return this.featureUsed(SkinMaterial.FEATURE_VERTEX_NORMAL);
+    get vertexNormal() {
+        return this.featureUsed(SSSMaterial.FEATURE_VERTEX_NORMAL);
     }
     set vertexNormal(val) {
-        this.useFeature(SkinMaterial.FEATURE_VERTEX_NORMAL, !!val);
+        this.useFeature(SSSMaterial.FEATURE_VERTEX_NORMAL, !!val);
     }
-    /** true if vertex tangent attribute presents */ get vertexTangent() {
-        return this.featureUsed(SkinMaterial.FEATURE_VERTEX_TANGENT);
+    get vertexTangent() {
+        return this.featureUsed(SSSMaterial.FEATURE_VERTEX_TANGENT);
     }
     set vertexTangent(val) {
-        this.useFeature(SkinMaterial.FEATURE_VERTEX_TANGENT, !!val);
-    }
-    /** Blinn specular exponent. Higher values produce smaller highlights. */ get shininess() {
-        return this._shininess;
-    }
-    set shininess(val) {
-        const next = Math.max(1, val ?? 1);
-        if (next !== this._shininess) {
-            this._shininess = next;
-            this.uniformChanged();
-        }
-    }
-    /** Direct specular strength. Keep this restrained for soft skin. */ get specularStrength() {
-        return this._specularStrength;
-    }
-    set specularStrength(val) {
-        const next = Math.max(0, val ?? 0);
-        if (next !== this._specularStrength) {
-            this._specularStrength = next;
-            this.uniformChanged();
-        }
-    }
-    /** Wrap amount for visible diffuse lighting. */ get diffuseWrap() {
-        return this._diffuseWrap;
-    }
-    set diffuseWrap(val) {
-        const next = Math.max(0, val ?? 0);
-        if (next !== this._diffuseWrap) {
-            this._diffuseWrap = next;
+        this.useFeature(SSSMaterial.FEATURE_VERTEX_TANGENT, !!val);
+    }
+    /**
+   * GGX base roughness the two specular lobes are derived from.
+   *
+   * @remarks
+   * Defaults to UE5's material default of 0.5. The profile then tightens the
+   * narrow lobe and broadens the wide one around this value, so it is the centre
+   * of the dual-lobe highlight rather than the roughness of either lobe.
+   */ get roughness() {
+        return this._roughness;
+    }
+    set roughness(val) {
+        const next = Math.max(0.045, Math.min(1, val ?? 0.5));
+        if (next !== this._roughness) {
+            this._roughness = next;
             this.uniformChanged();
         }
     }
-    /** Blend from hard Lambert lighting to wrapped diffuse lighting. */ get diffuseSoftness() {
-        return this._diffuseSoftness;
-    }
-    set diffuseSoftness(val) {
-        const next = Math.max(0, Math.min(1, val ?? 0));
-        if (next !== this._diffuseSoftness) {
-            this._diffuseSoftness = next;
-            this.uniformChanged();
-        }
-    }
-    /**
-   * Wider wrap that used to shape the post-process scattering source.
-   *
-   * @deprecated No longer has any effect. The side buffer now carries the real
-   * diffuse term rather than a hand-built difference that was nonzero only near
-   * the terminator, so there is nothing for a second wrap to shape. Use
-   * {@link SkinSSS.scatterRadius} and the profile's channel radii to control how
-   * far light travels, and {@link SkinMaterial.diffuseWrap} to shape the ramp.
-   */ get scatterWrap() {
-        return this._scatterWrap;
-    }
-    set scatterWrap(val) {
-        const next = Math.max(0, val ?? 0);
-        if (next !== this._scatterWrap) {
-            this._scatterWrap = next;
-            this.uniformChanged();
-        }
-    }
-    /**
-   * Strength of the multiplier written into the SkinSSS side buffer.
-   *
-   * @deprecated No longer has any effect. Scaling the side buffer would break
-   * the identity that makes the diffusion energy conserving - it must equal the
-   * diffusible term already present in the lit color. Use
-   * {@link SkinSSS.strength} for the overall amount and {@link SkinSSS.glow} for
-   * an additive, non-conserving bleed on top.
-   */ get scatterStrength() {
-        return this._scatterStrength;
-    }
-    set scatterStrength(val) {
-        const next = Math.max(0, val ?? 0);
-        if (next !== this._scatterStrength) {
-            this._scatterStrength = next;
+    /**
+   * Fresnel reflectance at normal incidence.
+   *
+   * @remarks
+   * Defaults to 0.04, what UE5's default `Specular` of 0.5 gives through
+   * `F0 = 0.08 * Specular`; to port a UE5 material, use that conversion. This is
+   * the only control over highlight strength, since a post-multiplier would skew
+   * the grazing end of the Fresnel curve and bypass the energy terms, so the
+   * specular would stop paying for itself out of the diffuse.
+   *
+   * The profile's IOR does not feed this: that drives transmission's refraction,
+   * while the specular Fresnel stays on the dielectric mapping.
+   */ get specularF0() {
+        return this._specularF0;
+    }
+    set specularF0(val) {
+        const next = Math.max(0, Math.min(0.2, val ?? 0.04));
+        if (next !== this._specularF0) {
+            this._specularF0 = next;
             this.uniformChanged();
         }
     }
-    /**
-   * Strength of the back-lit transmission term. Requires a `subsurfaceTexture`
-   * with thickness in the B channel; 0 (the default) disables transmission.
+    /**
+   * Overall multiplier on the back-lit transmission.
+   *
+   * @remarks
+   * UE5 has no equivalent - its transmission is fully determined by the profile
+   * and the measured thickness - so 1 is the faithful value and this exists only
+   * to dial the effect back or push it further.
+   *
+   * Transmission additionally requires {@link PunctualLight.transmission} on at
+   * least one shadow-casting light, since the thickness it needs is measured
+   * against that light's shadow map. With no such light this has no effect.
+   *
+   * @public
    */ get transmissionStrength() {
         return this._transmissionStrength;
     }
     set transmissionStrength(val) {
-        const next = Math.max(0, val ?? 0);
+        const next = Math.max(0, val ?? 1);
         if (next !== this._transmissionStrength) {
             this._transmissionStrength = next;
             this.uniformChanged();
         }
     }
-    /** Exponent of the back-lit transmission falloff. Higher values tighten the glow. */ get transmissionPower() {
-        return this._transmissionPower;
-    }
-    set transmissionPower(val) {
-        const next = Math.max(1, val ?? 1);
-        if (next !== this._transmissionPower) {
-            this._transmissionPower = next;
-            this.uniformChanged();
-        }
-    }
-    /**
-   * Warm tint for the blurred skin lighting contribution.
-   *
-   * @deprecated No longer has any effect; moved to {@link SkinSSS.scatterTint}.
-   * Tinting here would tint the diffuse in the lit color too, which is what made
-   * the old look read as a red haze over the whole face. On the post effect the
-   * tint applies only to the light that actually moved, and per-channel scatter
-   * radii from the profile already produce the red bleed on their own.
-   */ get scatterColor() {
-        return this._scatterColor;
-    }
-    set scatterColor(val) {
-        if (!val.equalsTo(this._scatterColor)) {
-            this._scatterColor.set(val);
-            this.uniformChanged();
-        }
-    }
-    /**
-   * NPR-style shadow tint: the dark end of the diffuse ramp lifts toward this
-   * color instead of black (black, the default, reproduces plain wrapped
-   * lambert). A rosy/lavender tint gives the stylized beauty-shot shadow look.
-   */ get shadowTint() {
-        return this._shadowTint;
-    }
-    set shadowTint(val) {
-        if (!val.equalsTo(this._shadowTint)) {
-            this._shadowTint.set(val);
-            this.uniformChanged();
-        }
-    }
-    /** Whitening gain applied to the whole diffuse response. 0 (the default) is neutral. */ get brightening() {
-        return this._brightening;
-    }
-    set brightening(val) {
-        const next = Math.max(0, val ?? 0);
-        if (next !== this._brightening) {
-            this._brightening = next;
-            this.uniformChanged();
-        }
-    }
     vertexShader(scope) {
         super.vertexShader(scope);
         const pb = scope.$builder;
@@ -260,20 +234,30 @@ import { RENDER_PASS_TYPE_LIGHT, LIGHT_TYPE_POINT, MaterialVaryingFlags } from '
         super.fragmentShader(scope);
         const pb = scope.$builder;
         const that = this;
+        const lightPass = this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT;
+        // Declared outside `needFragmentColorInput` deliberately: that predicate is
+        // false in the prepass for an ordinary opaque material, so a declaration
+        // inside it would leave the uniform undefined and the prepass would write id
+        // 0 for every skin pixel.
+        const depthPassProfileId = this.drawContext.renderPass.type === RENDER_PASS_TYPE_DEPTH && this.drawContext.sssProfileId;
+        if (lightPass || depthPassProfileId) {
+            scope.zSSSProfileId = pb.float().uniform(2);
+        }
         if (this.needFragmentColorInput()) {
-            if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
-                scope.zSkinShininess = pb.float().uniform(2);
-                scope.zSkinSpecularStrength = pb.float().uniform(2);
-                scope.zSkinDiffuseWrap = pb.float().uniform(2);
-                scope.zSkinDiffuseSoftness = pb.float().uniform(2);
-                scope.zSkinShadowTint = pb.vec4().uniform(2);
-                scope.zSkinBrightening = pb.float().uniform(2);
-                // Encodes HDR scatter irradiance into the SkinSSS buffer range when the
-                // render graph falls back to rgba8unorm (see getSSSLightingTextureFormat).
-                scope.zSkinScatterEncodeScale = pb.float().uniform(2);
-                if (this.subsurfaceTexture) {
-                    scope.zSkinTransmissionStrength = pb.float().uniform(2);
-                    scope.zSkinTransmissionPower = pb.float().uniform(2);
+            if (lightPass) {
+                scope.zSSSRoughness = pb.float().uniform(2);
+                scope.zSSSSpecularF0 = pb.float().uniform(2);
+                scope.zSSSLobeParams = pb.vec3().uniform(2);
+                // Transmission is compiled in only when the thickness it needs exists.
+                // The flag is part of the shader's cache key (render/lightpass.ts), and
+                // it also guards against the per-light additive path, which has no
+                // thickness texture and hands the BxDF a placeholder.
+                if (this.drawContext.transmissionThickness) {
+                    scope.zSSSTransmissionStrength = pb.float().uniform(2);
+                    // rgba32f, so WebGPU will only accept a non-filtering sampler here;
+                    // the transmission profile is interpolated by hand for that reason.
+                    scope.zSSSProfileTex = pb.tex2D().sampleType('unfilterable-float').uniform(2);
+                    scope.zSSSProfileTexelSize = pb.vec2().uniform(2);
                 }
             }
             scope.$l.albedo = this.calculateAlbedoColor(scope);
@@ -282,34 +266,53 @@ import { RENDER_PASS_TYPE_LIGHT, LIGHT_TYPE_POINT, MaterialVaryingFlags } from '
             }
             if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
                 const baseLightPass = !this.drawContext.lightBlending;
-                // TBN[2] is the pre-normal-map geometric normal, needed for shadow
-                // normal offset bias. Feeding the normal mapped shading normal instead
-                // would displace the shadow lookup along pore detail.
                 scope.$l.normalInfo = this.calculateNormalAndTBN(scope, scope.$inputs.worldPos, scope.$inputs.wNorm, scope.$inputs.wTangent, scope.$inputs.wBinormal);
                 scope.$l.normal = scope.normalInfo.normal;
                 scope.$l.viewVec = this.calculateViewVector(scope, scope.$inputs.worldPos);
-                scope.$l.roughness = pb.sqrt(pb.div(2, pb.add(scope.zSkinShininess, 2)));
+                scope.$l.roughness = scope.zSSSRoughness;
                 scope.$l.skinMask = pb.float(1);
-                scope.$l.skinSoftness = pb.float(0);
-                scope.$l.skinThickness = pb.float(0);
                 if (this.subsurfaceTexture) {
                     scope.$l.subsurfaceTexel = this.sampleSubsurfaceTexture(scope);
                     scope.skinMask = pb.clamp(scope.subsurfaceTexel.r, 0, 1);
-                    scope.skinSoftness = pb.clamp(scope.subsurfaceTexel.g, 0, 1);
-                    scope.skinThickness = pb.clamp(scope.subsurfaceTexel.b, 0, 1);
                 }
                 scope.$l.diffuseLighting = pb.vec3(0);
                 scope.$l.transmissionLighting = pb.vec3(0);
                 scope.$l.specularLighting = pb.vec3(0);
-                scope.$l.NoV = pb.clamp(pb.dot(scope.normal, scope.viewVec), 0, 1);
+                scope.$l.envSpecular = pb.vec3(0);
+                scope.$l.NoV = pb.clamp(pb.dot(scope.normal, scope.viewVec), 0.0001, 1);
+                // The lobe roughnesses depend only on the material and profile, so they
+                // are resolved once rather than per light. The skin mask stands in for
+                // UE5's per-pixel subsurface opacity, which is what fades the dual lobe
+                // out where the surface stops being skin.
+                scope.$l.lobeRoughness = skinDualSpecularRoughness(scope, scope.roughness, scope.skinMask, scope.zSSSLobeParams.x, scope.zSSSLobeParams.y);
+                // Multiple-scattering compensation. UE5 takes the average lobe roughness
+                // here rather than computing a term per lobe, and applies the result to
+                // both the direct and the ambient contribution.
+                scope.$l.avgLobeRoughness = pb.mix(scope.lobeRoughness.x, scope.lobeRoughness.y, scope.zSSSLobeParams.z);
+                scope.$l.energyTerms = skinSpecularEnergyTerms(scope, scope.avgLobeRoughness, scope.NoV, scope.zSSSSpecularF0);
+                // x scales specular back up to unit albedo; 1 - y is the energy left for
+                // the diffuse underneath.
+                scope.$l.energyConservation = scope.energyTerms.x;
+                scope.$l.energyPreservation = pb.sub(1, scope.energyTerms.y);
+                // --- Environment lighting ---
                 if (this.needCalculateEnvLight() && baseLightPass) {
                     scope.$l.envDiffuse = this.getEnvLightIrradiance(scope, scope.normal);
                     scope.diffuseLighting = pb.add(scope.diffuseLighting, scope.envDiffuse);
                     scope.$l.reflectVec = this.calculateReflectionVector(scope, scope.normal, scope.viewVec);
-                    scope.$l.envFresnel = pb.add(0.028, pb.mul(0.972, pb.pow(pb.sub(1, scope.NoV), 5)));
-                    scope.specularLighting = pb.add(scope.specularLighting, pb.mul(this.getEnvLightRadiance(scope, scope.reflectVec, scope.roughness), scope.envFresnel, scope.zSkinSpecularStrength));
+                    // UE5's ReflectionEnvironment:
+                    //
+                    //   EnergyTerms = ComputeGGXSpecEnergyTerms(GBuffer.Roughness, NoV, SpecularColor)
+                    //   Color.rgb   = GatherRadiance(R, GBuffer.Roughness) * EnergyTerms.E
+                    //
+                    // Two consequences. The roughness is the raw **material** value, since
+                    // UE5 applies the dual lobe only in the direct BxDF. And the weight is
+                    // the directional albedo `E` - the split-sum DFG with multiple-scattering
+                    // folded in, not a bare Fresnel - which already carries the multi-scatter
+                    // gain, so it must not also be multiplied by the direct path's `W`.
+                    scope.$l.envEnergyTerms = skinSpecularEnergyTerms(scope, scope.roughness, scope.NoV, scope.zSSSSpecularF0);
+                    scope.envSpecular = pb.mul(this.getEnvLightRadiance(scope, scope.reflectVec, scope.roughness), scope.envEnergyTerms.y);
                 }
-                this.forEachLight(scope, function(type, posRange, dirCutoff, colorIntensity, extra, shadow) {
+                this.forEachLight(scope, function(type, posRange, dirCutoff, colorIntensity, extra, shadow, thickness) {
                     this.$l.diffuseScale = pb.float(1);
                     this.$l.specularScale = pb.float(1);
                     this.$l.sourceRadiusFactor = pb.float(0);
@@ -320,76 +323,88 @@ import { RENDER_PASS_TYPE_LIGHT, LIGHT_TYPE_POINT, MaterialVaryingFlags } from '
                     });
                     this.$l.lightAtten = that.calculateLightAttenuation(this, type, this.$inputs.worldPos, posRange, dirCutoff, extra);
                     this.$l.lightDir = that.calculateLightDirection(this, type, this.$inputs.worldPos, posRange, dirCutoff);
-                    this.$l.rawNoL = pb.dot(this.normal, this.lightDir);
-                    this.$l.NoL = pb.clamp(this.rawNoL, 0, 1);
-                    this.$l.NoLWrap = pb.clamp(pb.div(pb.add(this.rawNoL, this.zSkinDiffuseWrap), pb.add(1, this.zSkinDiffuseWrap)), 0, 1);
-                    // calculateShadow() samples with implicit derivatives (dpdx); WGSL
-                    // requires the call to stay in uniform control flow, so never wrap
-                    // it in a dynamic branch such as NoLWrap > 0.
-                    //
-                    // Diffuse and specular share this term unmodified. An earlier version
-                    // faded it toward 1 around the terminator to hide shadow map acne
-                    // there, but that released the shadow in the wrong band (only ~9% at
-                    // NdotL = 0, by which point the acne is at its worst) and made cast
-                    // shadows dissolve wherever a surface turned away from the light.
-                    // Normal offset bias removes the acne at the source instead.
-                    this.$l.shadowTerm = shadow ? that.calculateShadow(this, this.$inputs.worldPos, scope.normalInfo.TBN[2], pb.max(this.NoL, 1e-5)) : pb.float(1);
+                    this.$l.rawNdotL = pb.dot(this.normal, this.lightDir);
+                    this.$l.NoL = pb.clamp(this.rawNdotL, 0, 1);
+                    this.$l.VdotL = pb.dot(this.viewVec, this.lightDir);
+                    // Shadow: pre-integrated BRDF handles NdotL internally, so pass a
+                    // fixed bias to keep normal-offset stable at the terminator.
+                    this.$l.shadowTerm = shadow ? that.calculateShadow(this, this.$inputs.worldPos, scope.normalInfo.TBN[2], pb.float(0.5)) : pb.float(1);
                     this.$l.lightColor = pb.mul(colorIntensity.rgb, colorIntensity.a, this.lightAtten);
-                    this.$l.diffuseLightColor = pb.mul(this.lightColor, this.shadowTerm);
                     this.$l.halfVec = pb.normalize(pb.add(this.viewVec, this.lightDir));
                     this.$l.NoH = pb.clamp(pb.dot(this.normal, this.halfVec), 0, 1);
-                    this.$l.LoH = pb.clamp(pb.dot(this.lightDir, this.halfVec), 0, 1);
-                    this.$l.pointShininess = pb.max(pb.div(this.zSkinShininess, pb.add(1, pb.mul(this.sourceRadiusFactor, 32))), 1);
-                    this.$l.softness = pb.clamp(pb.add(this.zSkinDiffuseSoftness, pb.mul(this.skinSoftness, 0.35)), 0, 1);
-                    this.$l.NoLVis = pb.mix(this.NoL, this.NoLWrap, this.softness);
-                    // NPR-style diffuse ramp: the dark end lifts toward the shadow tint
-                    // instead of black. A black tint reproduces plain wrapped lambert.
-                    this.$l.diffuseRamp = pb.mix(this.zSkinShadowTint.rgb, pb.vec3(1), this.NoLVis);
-                    this.diffuseLighting = pb.add(this.diffuseLighting, pb.mul(this.diffuseLightColor, this.diffuseRamp, this.diffuseScale, 1 / Math.PI));
-                    if (that.subsurfaceTexture) {
-                        // Back-lit transmission: thin regions (B channel of the subsurface
-                        // texture) glow when the light faces the camera through the
-                        // surface.
-                        //
-                        // This deliberately uses the unshadowed lightColor. A back-lit
-                        // fragment is self-shadowed by definition - its own front face is
-                        // the occluder - so multiplying by the shadow term would cancel
-                        // exactly the case the term exists to model. The cost is that an
-                        // external caster does not block the glow, which a shadow map
-                        // cannot distinguish from self occlusion anyway.
-                        this.$l.transmission = pb.mul(pb.pow(pb.clamp(pb.dot(pb.neg(this.lightDir), this.viewVec), 0, 1), this.zSkinTransmissionPower), this.skinThickness, this.zSkinTransmissionStrength);
-                        this.transmissionLighting = pb.add(this.transmissionLighting, pb.mul(this.lightColor, this.transmission, this.diffuseScale, 1 / Math.PI));
+                    this.$l.VoH = pb.clamp(pb.dot(this.viewVec, this.halfVec), 0, 1);
+                    // Burley diffuse with the NoL cosine, as UE5's SubsurfaceProfileBxDF
+                    // evaluates it. The soft terminator is the screen-space diffusion's job;
+                    // bending this term to fake it double-counts the effect.
+                    this.$l.skinDiff = skinDiffuseBRDF(this, this.NoV, this.NoL, this.VoH, this.roughness);
+                    this.diffuseLighting = pb.add(this.diffuseLighting, pb.mul(this.lightColor, this.shadowTerm, this.skinDiff, this.NoL, this.diffuseScale));
+                    // Back-lit transmission, after UE5's SubsurfaceProfileBxDF. UE5
+                    // attenuates by the *transmission* shadow, which is the encoded
+                    // optical depth itself - so the same value both indexes the profile
+                    // and scales it, which is why `thickness` appears twice.
+                    //
+                    // No surface shadow and no NoL: the light arrives from behind, so the
+                    // camera-facing surface is shadowed and turned away from it by
+                    // construction. Applying either would zero out exactly the pixels
+                    // this term exists for.
+                    if (that.drawContext.transmissionThickness) {
+                        this.$l.transmission = skinTransmission(this, this.zSSSProfileTex, this.zSSSProfileTexelSize, this.zSSSProfileId, thickness, this.normal, this.viewVec, this.lightDir);
+                        this.transmissionLighting = pb.add(this.transmissionLighting, pb.mul(this.lightColor, this.transmission, thickness, this.zSSSTransmissionStrength, this.diffuseScale));
                     }
-                    // Normalized Blinn with Schlick Fresnel (skin F0 = 0.028). Specular
-                    // keeps the unfaded shadow term and hard NoL masking.
-                    this.$l.specNormalization = pb.div(pb.add(this.pointShininess, 8), 8 * Math.PI);
-                    this.$l.specFresnel = pb.add(0.028, pb.mul(0.972, pb.pow(pb.sub(1, this.LoH), 5)));
-                    this.$l.specular = pb.mul(this.lightColor, this.shadowTerm, pb.pow(this.NoH, this.pointShininess), this.specNormalization, this.specFresnel, this.zSkinSpecularStrength, this.specularScale, this.NoL);
-                    this.specularLighting = pb.add(this.specularLighting, this.specular);
+                    // Dual-lobe GGX specular, with the NoL cosine UE5 applies alongside it.
+                    this.$l.spec = skinDualLobeSpecular(this, this.NoH, this.NoV, this.NoL, this.VoH, this.lobeRoughness, this.zSSSLobeParams.z, this.zSSSSpecularF0);
+                    this.specularLighting = pb.add(this.specularLighting, pb.mul(this.lightColor, this.shadowTerm, this.spec, this.NoL, this.specularScale));
                 });
-                // Whitening: lift the whole diffuse response (direct and ambient).
-                scope.diffuseLighting = pb.mul(scope.diffuseLighting, pb.add(1, scope.zSkinBrightening));
-                // Everything that scatters through the surface: the stylized diffuse
-                // ramp plus back-lit transmission. Specular stays out - it reflects off
-                // the oil layer and never enters the skin.
-                scope.$l.diffusible = pb.mul(scope.albedo.rgb, pb.add(scope.diffuseLighting, scope.transmissionLighting));
+                // --- Assemble ---
+                //
+                // UE5 applies the energy terms to the accumulated lighting rather than per
+                // light: the diffuse loses what the specular layer above it reflected, and
+                // the specular gains back the energy single-scattering GGX dropped. The
+                // transmission is left alone, since it enters from behind the surface and
+                // never passes through that specular layer.
+                //
+                // The environment specular stays outside that multiply: it was already
+                // weighted by the directional albedo `E` when gathered, which carries the
+                // multiple-scattering gain, so applying `W` on top would count it twice.
+                // UE5 keeps the same split.
+                //
+                // The albedo multiply has to cover the transmission as well, because the
+                // baked profile carries only the falloff shape - UE5 supplies the base
+                // colour in its recombine pass instead, and this engine supplies it here.
+                //
+                // The transmission then rides into `diffLum` below and so is diffused
+                // along with the rest. That is deliberate: UE5 passes it as the
+                // `ScatterableLight` argument of `LightAccumulator_AddSplit`, the same
+                // slot the diffuse uses.
+                scope.$l.diffusible = pb.mul(scope.albedo.rgb, pb.add(pb.mul(scope.diffuseLighting, scope.energyPreservation), scope.transmissionLighting));
+                scope.specularLighting = pb.add(pb.mul(scope.specularLighting, scope.energyConservation), scope.envSpecular);
                 scope.$l.litColor = pb.add(scope.diffusible, scope.specularLighting);
-                // The SkinSSS side buffer carries exactly the diffusible term that is
-                // also in litColor - untinted and unscaled. That identity is what lets
-                // the post effect subtract it and add back a diffused version, which is
-                // energy conserving by construction and leaves the image untouched when
-                // the effect is disabled. Tinting or scaling here would break it; those
-                // controls live on SkinSSS instead.
+                // SceneColor.a = diffuse luminance, UE5's spec/diff separation mechanism:
+                // the SSS passes recover the diffusible fraction as
+                // `saturate(SceneColor.a / luma(SceneColor.rgb))`, so the alpha must carry
+                // the *diffuse* luminance, not the total.
+                scope.$l.diffLum = pb.dot(scope.diffusible, pb.vec3(0.2126, 0.7152, 0.0722));
+                // Surface data for the SSS passes: rgb = world normal, a = subsurface
+                // opacity.
+                //
+                // SceneColor.a cannot serve as the mask: every opaque material writes 1
+                // there, so gating on it would make the diffusion treat the background and
+                // the eyes as skin.
+                //
+                // The normal rides along so the diffusion can weight taps by how far the
+                // surface has turned away. Carrying it here rather than reading SceneNormal
+                // makes scattering independent of whether that optional MRT is enabled.
                 //
-                // Base and additive light passes both write their own contribution; the
-                // additive blend (RGB one/one, alpha zero/one) accumulates RGB and keeps
-                // the mask written by the base pass in alpha.
-                scope.$l.skinSSS = pb.vec4(pb.mul(scope.diffusible, scope.zSkinScatterEncodeScale), scope.skinMask);
+                // The alpha is UE5's Opacity input unmodified - a continuous 0..1 mask
+                // where 0 is no scattering and 1 is full. The profile id travels
+                // separately, out of the depth prepass, since one channel cannot carry a
+                // table row and a weight at once.
+                scope.$l.postSSSMask = pb.vec4(pb.add(pb.mul(scope.normal, 0.5), pb.vec3(0.5)), scope.skinMask);
                 if (this.drawContext.materialFlags & (MaterialVaryingFlags.SCENE_STORE_ROUGHNESS | MaterialVaryingFlags.SCENE_STORE_NORMAL)) {
-                    scope.$l.outRoughness = pb.vec4(pb.mul(scope.albedo.rgb, pb.sub(1, scope.roughness), scope.zSkinSpecularStrength), pb.mul(scope.roughness, ShaderHelper.getCameraRoughnessFactor(scope)));
-                    this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a), scope.outRoughness, pb.vec4(pb.add(pb.mul(scope.normal, 0.5), pb.vec3(0.5)), 1), undefined, undefined, undefined, undefined, false, scope.skinSSS);
+                    scope.$l.outRoughness = pb.vec4(pb.mul(scope.albedo.rgb, pb.sub(1, scope.roughness)), pb.mul(scope.roughness, ShaderHelper.getCameraRoughnessFactor(scope)));
+                    this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.diffLum), scope.outRoughness, pb.vec4(pb.add(pb.mul(scope.normal, 0.5), pb.vec3(0.5)), 1), undefined, undefined, undefined, undefined, false, scope.skinSSSMask);
                 } else {
-                    this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a), undefined, undefined, undefined, undefined, undefined, undefined, false, scope.skinSSS);
+                    this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.diffLum), undefined, undefined, undefined, undefined, undefined, undefined, false, scope.skinSSSMask);
                 }
             } else {
                 this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.albedo);
@@ -398,24 +413,43 @@ import { RENDER_PASS_TYPE_LIGHT, LIGHT_TYPE_POINT, MaterialVaryingFlags } from '
             this.outputFragmentColor(scope, scope.$inputs.worldPos, null);
         }
     }
+    /**
+   * The profile id the depth prepass writes for this material.
+   *
+   * @remarks
+   * Overrides {@link MeshMaterial.getDepthPassProfileId}. The uniform is declared
+   * in {@link SSSMaterial.fragmentShader} for the prepass as well as the light
+   * pass, and bound below.
+   */ getDepthPassProfileId(scope) {
+        return scope.zSSSProfileId;
+    }
     applyUniformValues(bindGroup, ctx, pass) {
         super.applyUniformValues(bindGroup, ctx, pass);
-        if (this.needFragmentColor(ctx) && ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
-            bindGroup.setValue('zSkinShininess', this._shininess);
-            bindGroup.setValue('zSkinSpecularStrength', this._specularStrength);
-            bindGroup.setValue('zSkinDiffuseWrap', this._diffuseWrap);
-            bindGroup.setValue('zSkinDiffuseSoftness', this._diffuseSoftness);
-            bindGroup.setValue('zSkinShadowTint', this._shadowTint);
-            bindGroup.setValue('zSkinBrightening', this._brightening);
-            const ldrSkinSSS = ctx.SkinSSSTexture && ctx.SkinSSSTexture.format === 'rgba8unorm';
-            bindGroup.setValue('zSkinScatterEncodeScale', ldrSkinSSS ? 1 / SKIN_SSS_LDR_ENCODE_RANGE : 1);
-            if (this.subsurfaceTexture) {
-                bindGroup.setValue('zSkinTransmissionStrength', this._transmissionStrength);
-                bindGroup.setValue('zSkinTransmissionPower', this._transmissionPower);
+        const lightPass = ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT;
+        const depthPassProfileId = ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH && ctx.sssProfileId;
+        // Not gated on needFragmentColor: the prepass declares this uniform for
+        // every skin material, including the opaque ones that predicate excludes.
+        if (lightPass || depthPassProfileId) {
+            bindGroup.setValue('zSSSProfileId', this._profile.encodedId);
+        }
+        if (!this.needFragmentColor(ctx) || !lightPass) {
+            return;
+        }
+        bindGroup.setValue('zSSSRoughness', this._roughness);
+        bindGroup.setValue('zSSSSpecularF0', this._specularF0);
+        const profile = this._profile;
+        bindGroup.setValue('zSSSLobeParams', this._lobeParams.setXYZ(profile.roughness0, profile.roughness1, profile.lobeMix));
+        if (ctx.transmissionThickness) {
+            bindGroup.setValue('zSSSTransmissionStrength', this._transmissionStrength);
+            const table = SSSProfile.getTable(ctx.device);
+            if (table) {
+                bindGroup.setTexture('zSSSProfileTex', table, fetchSampler('clamp_nearest_nomip'));
+                this._profileTexelSize.setXY(1 / SSSProfile.tableColumns, 1 / SSSProfile.tableRows);
+                bindGroup.setValue('zSSSProfileTexelSize', this._profileTexelSize);
             }
         }
     }
 }
 
-export { SKIN_SSS_LDR_ENCODE_RANGE, SkinMaterial };
+export { SKIN_SSS_LDR_ENCODE_RANGE, SSSMaterial };
 //# sourceMappingURL=skin.js.map