reze-engine 0.11.0 → 0.11.2

package/src/shaders/metal.ts

@@ -51,19 +51,25 @@ struct LightVP { viewProj: mat4x4f, };
 @group(2) @binding(1) var<uniform> material: MaterialUniforms;
 
 fn sampleShadow(worldPos: vec3f, n: vec3f) -> f32 {
+  // Back-facing to key light: direct contribution is zero anyway, skip 9 texture samples.
+  if (dot(n, -light.lights[0].direction.xyz) <= 0.0) { return 0.0; }
   let biasedPos = worldPos + n * 0.08;
   let lclip = lightVP.viewProj * vec4f(biasedPos, 1.0);
   let ndc = lclip.xyz / max(lclip.w, 1e-6);
   let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
   let cmpZ = ndc.z - 0.001;
-  let ts = 1.0 / 4096.0;
-  var vis = 0.0;
-  for (var y = -1; y <= 1; y++) {
-    for (var x = -1; x <= 1; x++) {
-      vis += textureSampleCompare(shadowMap, shadowSampler, suv + vec2f(f32(x), f32(y)) * ts, cmpZ);
-    }
-  }
-  return vis / 9.0;
+  let ts = 1.0 / 2048.0;
+  // 3x3 PCF unrolled — Safari's Metal backend doesn't unroll nested shadow loops reliably.
+  let s00 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(-ts, -ts), cmpZ);
+  let s10 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(0.0, -ts), cmpZ);
+  let s20 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f( ts, -ts), cmpZ);
+  let s01 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(-ts, 0.0), cmpZ);
+  let s11 = textureSampleCompareLevel(shadowMap, shadowSampler, suv, cmpZ);
+  let s21 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f( ts, 0.0), cmpZ);
+  let s02 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(-ts,  ts), cmpZ);
+  let s12 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(0.0,  ts), cmpZ);
+  let s22 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f( ts,  ts), cmpZ);
+  return (s00 + s10 + s20 + s01 + s11 + s21 + s02 + s12 + s22) * (1.0 / 9.0);
 }
 
 const PI_M: f32 = 3.141592653589793;
@@ -98,13 +104,19 @@ const METAL_VORONOI_SCALE: f32 = 4.3;
     skinnedNrm += (mat3x3f(m[0].xyz, m[1].xyz, m[2].xyz) * normal) * w;
   }
   output.position = camera.projection * camera.view * vec4f(skinnedPos.xyz, 1.0);
-  output.normal = normalize(skinnedNrm);
+  // Skip VS normalize — interpolation denormalizes anyway, and FS always does normalize(input.normal).
+  output.normal = skinnedNrm;
   output.uv = uv;
   output.worldPos = skinnedPos.xyz;
   return output;
 }
 
-@fragment fn fs(input: VertexOutput) -> @location(0) vec4f {
+struct FSOut {
+  @location(0) color: vec4f,
+  @location(1) mask: f32,
+};
+
+@fragment fn fs(input: VertexOutput) -> FSOut {
   let n = normalize(input.normal);
   let v = normalize(camera.viewPos - input.worldPos);
   let l = -light.lights[0].direction.xyz;
@@ -118,23 +130,23 @@ const METAL_VORONOI_SCALE: f32 = 4.3;
   if (out_alpha < 0.001) { discard; }
 
   // ═══ NPR toon stack (图像 → HSV.007 Val=0.8 → 转接点.001) ═══
-  let tex_tint = hue_sat(0.5, 1.0, 0.800000011920929, 1.0, tex_rgb);
+  let tex_tint = hue_sat_id(1.0, 0.800000011920929, 1.0, tex_rgb);
   let lum_shade = shader_to_rgb_diffuse(n, l, sun, amb, shadow);
   let ramp008 = ramp_constant_edge_aa(lum_shade, METAL_TOON_EDGE, vec4f(0,0,0,1), vec4f(1,1,1,1));
   let mix04_fac = math_multiply(ramp008.r, METAL_MIX04_MUL);
 
   // 混合.004: A=HSV.002(Val=0.2 dark), B=tex_tint
-  let dark_tex = hue_sat(0.5, 1.0, 0.19999998807907104, 1.0, tex_tint);
+  let dark_tex = hue_sat_id(1.0, 0.19999998807907104, 1.0, tex_tint);
   let mix04 = mix_blend(mix04_fac, dark_tex, tex_tint);
 
   // AO white/black ramp → 混合.002 factor
-  let ao = ao_fake(n, v);
+  let ao = 1.0; // ao_fake(n, v) — no SSAO yet; inline 1.0 so the ramp/mix chain folds at compile time.
   let ao_ramp_c = ramp_linear(ao, 0.0, vec4f(1,1,1,1), 0.8808, vec4f(0,0,0,1));
   let overlay_fac = mix(1.0, 0.0, ao_ramp_c.r);
 
   // 混合.002 OVERLAY: A=HSV.008(Val=1.0 identity) ← mix04, B=HSV.004(Val=2.0 bright) ← mix04
   let hue008 = mix04; // identity HSV
-  let hue004 = hue_sat(0.5, 1.0, 2.0, 1.0, mix04);
+  let hue004 = hue_sat_id(1.0, 2.0, 1.0, mix04);
   let npr_rgb = mix_overlay(overlay_fac, hue008, hue004);
   let npr_emission = npr_rgb * METAL_EMIT_STR;
 
@@ -145,7 +157,7 @@ const METAL_VORONOI_SCALE: f32 = 4.3;
   let voro = tex_voronoi_f1(refl_dir, METAL_VORONOI_SCALE);
   let voro_ramp = ramp_linear(voro, 0.0, vec4f(0,0,0,1), 1.0, vec4f(1,1,1,1)).r;
   // 混合.005: Fac=voro_ramp, A=voro_color(grayscale), B=HSV.006(Hue=0.5 Sat=1.5 Val=1.3)
-  let hue006 = hue_sat(0.5, 1.5, 1.2999999523162842, 1.0, tex_tint);
+  let hue006 = hue_sat_id(1.5, 1.2999999523162842, 1.0, tex_tint);
   let albedo = mix_blend(voro_ramp, vec3f(voro_ramp), hue006);
 
   // 原理化BSDF (EEVEE port): metallic=1.0, specular=1.0, roughness=0.3.
@@ -153,11 +165,12 @@ const METAL_VORONOI_SCALE: f32 = 4.3;
   // metallic=1 this is just albedo (specular_tint is dielectric-only and ignored here).
   let f0 = albedo;
   let f90 = mix(f0, vec3f(1.0), sqrt(METAL_SPECULAR));
+  let NL = max(dot(n, l), 0.0);
   let NV = max(dot(n, v), 1e-4);
-  let split_sum = brdf_lut_baked(NV, METAL_ROUGHNESS);
-  let reflection_color = F_brdf_multi_scatter(f0, f90, split_sum);
+  let brdf_lut = brdf_lut_sample(NV, METAL_ROUGHNESS);
+  let reflection_color = F_brdf_multi_scatter(f0, f90, brdf_lut.xy);
 
-  let spec_direct = bsdf_ggx(n, l, v, METAL_ROUGHNESS) * sun * shadow * ltc_brdf_scale(NV, METAL_ROUGHNESS);
+  let spec_direct = bsdf_ggx(n, l, v, NL, NV, METAL_ROUGHNESS) * sun * shadow * ltc_brdf_scale_from_lut(brdf_lut);
   let spec_indirect = amb;
   let spec_radiance = (spec_direct + spec_indirect) * reflection_color;
 
@@ -167,7 +180,10 @@ const METAL_VORONOI_SCALE: f32 = 4.3;
   // 混合着色器.001 Fac=0.6967: Shader=npr_emission, Shader_001=principled
   let final_color = mix(npr_emission, principled, METAL_MIX_SHADER_FAC);
 
-  return vec4f(final_color, out_alpha);
+  var out: FSOut;
+  out.color = vec4f(final_color, out_alpha);
+  out.mask = 1.0;
+  return out;
 }
 
 `

package/src/shaders/nodes.ts

@@ -4,16 +4,13 @@
 
 export const NODES_WGSL = /* wgsl */ `
 
-// Baked 64×64 rg16float DFG LUT — created once at engine init by dfg_lut.ts.
-// Paired with group(0) binding(2) diffuseSampler (linear filter, clamp implicit
-// via the half-texel bias inside brdf_lut_baked). Bound by the main per-frame
-// bind group to every material pipeline that includes this module.
-@group(0) @binding(9) var dfgLut: texture_2d<f32>;
-
-// Baked 64×64 rg16float LTC GGX magnitude LUT — ltc_mag_ggx from Blender eevee_lut.c.
-// Heitz 2016 LTC fit amplitude — same UV addressing as dfgLut.
-// Used for direct-specular energy compensation (ltc_brdf_scale in closure_eval_glossy_lib.glsl).
-@group(0) @binding(10) var ltcMag: texture_2d<f32>;
+// Baked 64×64 rgba8unorm combined BRDF LUT — created once at engine init by dfg_lut.ts.
+//   .rg = split-sum DFG (Karis: tint = f0·x + f90·y)  → F_brdf_*_scatter
+//   .ba = Heitz 2016 LTC magnitude (ltc_mag_ggx)       → ltc_brdf_scale_from_lut
+// Paired with group(0) binding(2) diffuseSampler (linear filter). Sample once per
+// fragment via brdf_lut_sample() — callers feed .rg and the whole vec4 into the
+// helpers below, halving LUT taps on the default Principled path.
+@group(0) @binding(9) var brdfLut: texture_2d<f32>;
 
 // ─── RGB ↔ HSV ──────────────────────────────────────────────────────
 
@@ -71,6 +68,23 @@ fn hue_sat(hue: f32, saturation: f32, value: f32, fac: f32, color: vec3f) -> vec
   return mix(color, hsv_to_rgb(hsv), fac);
 }
 
+// hue_sat specialization for hue=0.5 (identity hue shift — fract(h + 0.5 - 0.5) = h).
+// Branchless equivalent that skips the rgb_to_hsv → hsv_to_rgb roundtrip: WebKit's
+// Metal backend serializes the 3-way if chain in rgb_to_hsv and the 6-way switch in
+// hsv_to_rgb, where this form compiles to linear SIMD ops + a single select.
+fn hue_sat_id(saturation: f32, value: f32, fac: f32, color: vec3f) -> vec3f {
+  let m = max(max(color.r, color.g), color.b);
+  let n = min(min(color.r, color.g), color.b);
+  // Unclamped (sat*old_s ≤ 1): reproj = mix(vec3f(m), color, saturation).
+  // Clamped (saturated to 1):   reproj = (color - n) * m / (m - n).
+  let range = max(m - n, 1e-6);
+  let unclamped = mix(vec3f(m), color, saturation);
+  let clamped = (color - vec3f(n)) * m / range;
+  let needs_clamp = (m - n) * saturation >= m;
+  let reproj = select(unclamped, clamped, needs_clamp);
+  return mix(color, reproj * value, fac);
+}
+
 // ─── BRIGHTCONTRAST node ────────────────────────────────────────────
 
 fn bright_contrast(color: vec3f, bright: f32, contrast: f32) -> vec3f {
@@ -122,6 +136,13 @@ fn math_multiply(a: f32, b: f32) -> f32 { return a * b; }
 fn math_power(a: f32, b: f32) -> f32 { return pow(max(a, 0.0), b); }
 fn math_greater_than(a: f32, b: f32) -> f32 { return select(0.0, 1.0, a > b); }
 
+// Blender's implicit Color → Float socket conversion uses BT.601 grayscale
+// (rgb_to_grayscale in blenkernel/intern/node.cc). When a material graph plugs a
+// Color output into a Math node's Value input, this is the scalar it actually sees.
+fn color_to_value(c: vec3f) -> f32 {
+  return 0.299 * c.r + 0.587 * c.g + 0.114 * c.b;
+}
+
 // ─── MIX node (blend_type variants) ────────────────────────────────
 
 fn mix_blend(fac: f32, a: vec3f, b: vec3f) -> vec3f {
@@ -157,18 +178,26 @@ fn luminance_rec709_linear(c: vec3f) -> f32 {
 // Schlick approximation matching Blender's Fresnel node
 
 fn fresnel(ior: f32, n: vec3f, v: vec3f) -> f32 {
-  let f0 = pow((ior - 1.0) / (ior + 1.0), 2.0);
+  let r = (ior - 1.0) / (ior + 1.0);
+  let f0 = r * r;
   let cos_theta = clamp(dot(n, v), 0.0, 1.0);
-  return f0 + (1.0 - f0) * pow(1.0 - cos_theta, 5.0);
+  let m = 1.0 - cos_theta;
+  let m2 = m * m;
+  let m5 = m2 * m2 * m;
+  return f0 + (1.0 - f0) * m5;
 }
 
 // ─── LAYER_WEIGHT node ──────────────────────────────────────────────
 
 fn layer_weight_fresnel(blend: f32, n: vec3f, v: vec3f) -> f32 {
   let eta = max(1.0 - blend, 1e-4);
-  let f0 = pow((1.0 - eta) / (1.0 + eta), 2.0);
+  let r = (1.0 - eta) / (1.0 + eta);
+  let f0 = r * r;
   let cos_theta = clamp(abs(dot(n, v)), 0.0, 1.0);
-  return f0 + (1.0 - f0) * pow(1.0 - cos_theta, 5.0);
+  let m = 1.0 - cos_theta;
+  let m2 = m * m;
+  let m5 = m2 * m2 * m;
+  return f0 + (1.0 - f0) * m5;
 }
 
 fn layer_weight_facing(blend: f32, n: vec3f, v: vec3f) -> f32 {
@@ -227,13 +256,18 @@ fn bump_lh(strength: f32, height: f32, normal: vec3f, world_pos: vec3f) -> vec3f
 // ─── NOISE texture (Perlin-style) ───────────────────────────────────
 // Simplified gradient noise matching Blender's default noise output.
 
+// PCG-style integer hash. Replaces the classic 'fract(sin(q) * LARGE)' trick because
+// WebKit's Metal backend compiles 'sin' to a full transcendental op (slow), while
+// Safari's Apple-GPU scalar ALU handles int muls/xors near free. Inputs arrive as
+// integer-valued floats (floor(p) + unit offsets) from _noise3, so vec3i cast is exact.
 fn _hash33(p: vec3f) -> vec3f {
-  var q = vec3f(
-    dot(p, vec3f(127.1, 311.7, 74.7)),
-    dot(p, vec3f(269.5, 183.3, 246.1)),
-    dot(p, vec3f(113.5, 271.9, 124.6))
-  );
-  return fract(sin(q) * 43758.5453123) * 2.0 - 1.0;
+  var h = vec3u(vec3i(p) + vec3i(32768));
+  h = h * vec3u(1664525u, 1013904223u, 2654435761u);
+  h = (h.yzx ^ h) * vec3u(2246822519u, 3266489917u, 668265263u);
+  h = h ^ (h >> vec3u(16u));
+  // Mask to 24 bits — above that f32 loses precision on the u32→f32 convert.
+  let hm = h & vec3u(16777215u);
+  return vec3f(hm) * (2.0 / 16777216.0) - 1.0;
 }
 
 fn _noise3(p: vec3f) -> f32 {
@@ -276,6 +310,15 @@ fn tex_noise(p: vec3f, scale: f32, detail: f32, roughness: f32, distortion: f32)
   return value / max(total_amp, 1e-6) * 0.5 + 0.5;
 }
 
+// tex_noise specialization: detail=2.0 (3 octaves), roughness=0.5, distortion=0.
+// WebKit can't unroll tex_noise's for-loop because 'octaves' is a runtime value;
+// this variant is fully unrolled with constants folded (total_amp = 1.75).
+fn tex_noise_d2(p: vec3f, scale: f32) -> f32 {
+  let c = p * scale;
+  let v = _noise3(c) + 0.5 * _noise3(c * 2.0) + 0.25 * _noise3(c * 4.0);
+  return v * (1.0 / 1.75) * 0.5 + 0.5;
+}
+
 // ─── TEX_GRADIENT (linear) ──────────────────────────────────────────
 // Used by Stockings preset. Maps the input vector's X to a 0–1 gradient.
 
@@ -349,13 +392,15 @@ const EEVEE_PI: f32 = 3.141592653589793;
 
 // Fused analytic GGX specular (direct lights). Returns BRDF × NL.
 // 4·NL·NV is cancelled via G1_Smith reciprocal form — see bsdf_common_lib.glsl:115.
-fn bsdf_ggx(N: vec3f, L: vec3f, V: vec3f, roughness: f32) -> f32 {
+// Caller passes NL, NV (already computed for diffuse + brdf_lut_sample) so WebKit
+// can reuse them instead of recomputing dot products across the function boundary.
+fn bsdf_ggx(N: vec3f, L: vec3f, V: vec3f, NL_in: f32, NV_in: f32, roughness: f32) -> f32 {
   let a = max(roughness, 1e-4);
   let a2 = a * a;
   let H = normalize(L + V);
   let NH = max(dot(N, H), 1e-8);
-  let NL = max(dot(N, L), 1e-8);
-  let NV = max(dot(N, V), 1e-8);
+  let NL = max(NL_in, 1e-8);
+  let NV = max(NV_in, 1e-8);
   // G1_Smith_GGX_opti reciprocal form — denominator piece only.
   let G1L = NL + sqrt(NL * (NL - NL * a2) + a2);
   let G1V = NV + sqrt(NV * (NV - NV * a2) + a2);
@@ -376,15 +421,16 @@ fn brdf_lut_approx(NV: f32, roughness: f32) -> vec2f {
   return vec2f(-1.04, 1.04) * a004 + r.zw;
 }
 
-// Baked 64×64 EEVEE split-sum LUT — exact port of bsdf_lut_frag.glsl.
+// Baked combined BRDF LUT — exact port of Blender bsdf_lut_frag.glsl packed with
+// ltc_mag_ggx from eevee_lut.c. Single sample returns DFG (.rg) and LTC mag (.ba).
 // Addressed as Blender's common_utiltex_lib.glsl:lut_coords:
 //   coords = (roughness, sqrt(1 - NV)), then half-texel bias for filtering.
-// Requires group(0) binding(9) dfgLut + binding(2) diffuseSampler in the host shader.
-fn brdf_lut_baked(NV: f32, roughness: f32) -> vec2f {
+// Requires group(0) binding(9) brdfLut + binding(2) diffuseSampler in the host shader.
+fn brdf_lut_sample(NV: f32, roughness: f32) -> vec4f {
   let LUT_SIZE: f32 = 64.0;
   var uv = vec2f(saturate(roughness), sqrt(saturate(1.0 - NV)));
   uv = uv * ((LUT_SIZE - 1.0) / LUT_SIZE) + 0.5 / LUT_SIZE;
-  return textureSampleLevel(dfgLut, diffuseSampler, uv, 0.0).rg;
+  return textureSampleLevel(brdfLut, diffuseSampler, uv, 0.0);
 }
 
 fn F_brdf_single_scatter(f0: vec3f, f90: vec3f, lut: vec2f) -> vec3f {
@@ -403,16 +449,12 @@ fn F_brdf_multi_scatter(f0: vec3f, f90: vec3f, lut: vec2f) -> vec3f {
 
 // EEVEE direct-specular energy compensation factor — closure_eval_glossy_lib.glsl:79-81:
 //   ltc_brdf_scale = (ltc.x + ltc.y) / (split_sum.x + split_sum.y)
-// Because Blender evaluates direct lights via LTC (Heitz 2016) but indirect via split-sum,
-// direct radiance is rescaled so total-energy matches what the split-sum LUT expects.
-// Sample both LUTs at identical lut_coords and return the ratio.
-fn ltc_brdf_scale(NV: f32, roughness: f32) -> f32 {
-  let LUT_SIZE: f32 = 64.0;
-  var uv = vec2f(saturate(roughness), sqrt(saturate(1.0 - NV)));
-  uv = uv * ((LUT_SIZE - 1.0) / LUT_SIZE) + 0.5 / LUT_SIZE;
-  let ltc = textureSampleLevel(ltcMag, diffuseSampler, uv, 0.0).rg;
-  let dfg = textureSampleLevel(dfgLut, diffuseSampler, uv, 0.0).rg;
-  return (ltc.x + ltc.y) / max(dfg.x + dfg.y, 1e-6);
+// Blender evaluates direct lights via LTC (Heitz 2016) but indirect via split-sum;
+// direct radiance is rescaled so total-energy matches the split-sum LUT.
+// Takes a pre-sampled vec4f from brdf_lut_sample() to share the fetch with
+// F_brdf_multi_scatter on the same fragment.
+fn ltc_brdf_scale_from_lut(lut: vec4f) -> f32 {
+  return (lut.z + lut.w) / max(lut.x + lut.y, 1e-6);
 }
 
 // Luminance-normalized hue extraction — Blender tint_from_color (isolates hue+sat).

package/src/shaders/stockings.ts

@@ -51,19 +51,25 @@ struct LightVP { viewProj: mat4x4f, };
 @group(2) @binding(1) var<uniform> material: MaterialUniforms;
 
 fn sampleShadow(worldPos: vec3f, n: vec3f) -> f32 {
+  // Back-facing to key light: direct contribution is zero anyway, skip 9 texture samples.
+  if (dot(n, -light.lights[0].direction.xyz) <= 0.0) { return 0.0; }
   let biasedPos = worldPos + n * 0.08;
   let lclip = lightVP.viewProj * vec4f(biasedPos, 1.0);
   let ndc = lclip.xyz / max(lclip.w, 1e-6);
   let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
   let cmpZ = ndc.z - 0.001;
-  let ts = 1.0 / 4096.0;
-  var vis = 0.0;
-  for (var y = -1; y <= 1; y++) {
-    for (var x = -1; x <= 1; x++) {
-      vis += textureSampleCompare(shadowMap, shadowSampler, suv + vec2f(f32(x), f32(y)) * ts, cmpZ);
-    }
-  }
-  return vis / 9.0;
+  let ts = 1.0 / 2048.0;
+  // 3x3 PCF unrolled — Safari's Metal backend doesn't unroll nested shadow loops reliably.
+  let s00 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(-ts, -ts), cmpZ);
+  let s10 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(0.0, -ts), cmpZ);
+  let s20 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f( ts, -ts), cmpZ);
+  let s01 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(-ts, 0.0), cmpZ);
+  let s11 = textureSampleCompareLevel(shadowMap, shadowSampler, suv, cmpZ);
+  let s21 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f( ts, 0.0), cmpZ);
+  let s02 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(-ts,  ts), cmpZ);
+  let s12 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(0.0,  ts), cmpZ);
+  let s22 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f( ts,  ts), cmpZ);
+  return (s00 + s10 + s20 + s01 + s11 + s21 + s02 + s12 + s22) * (1.0 / 9.0);
 }
 
 const PI_S: f32 = 3.141592653589793;
@@ -144,13 +150,19 @@ fn ramp_ease_s(f: f32, p0: f32, p1: f32) -> f32 {
     skinnedNrm += (mat3x3f(m[0].xyz, m[1].xyz, m[2].xyz) * normal) * w;
   }
   output.position = camera.projection * camera.view * vec4f(skinnedPos.xyz, 1.0);
-  output.normal = normalize(skinnedNrm);
+  // Skip VS normalize — interpolation denormalizes anyway, and FS always does normalize(input.normal).
+  output.normal = skinnedNrm;
   output.uv = uv;
   output.worldPos = skinnedPos.xyz;
   return output;
 }
 
-@fragment fn fs(input: VertexOutput) -> @location(0) vec4f {
+struct FSOut {
+  @location(0) color: vec4f,
+  @location(1) bloom_mask: f32,
+};
+
+@fragment fn fs(input: VertexOutput) -> FSOut {
   let n = normalize(input.normal);
   let v = normalize(camera.viewPos - input.worldPos);
   let l = -light.lights[0].direction.xyz;
@@ -194,7 +206,7 @@ fn ramp_ease_s(f: f32, p0: f32, p1: f32) -> f32 {
 
   // ═══ EMISSION SHADER ═══
   // Hue=0.5 (identity rotation), Sat=1.0, Val=5.0 (5× brightness boost), Fac=1; Strength=1
-  let emission = hue_sat(0.5, 1.0, 5.0, 1.0, tex_rgb);
+  let emission = hue_sat_id(1.0, 5.0, 1.0, tex_rgb);
 
   // ═══ PRINCIPLED BSDF (EEVEE port) ═══
   // base_color_tint, metallic f0, sheen coarse approx (scales diffuse radiance).
@@ -205,10 +217,10 @@ fn ramp_ease_s(f: f32, p0: f32, p1: f32) -> f32 {
   let dielectric_f0 = vec3f(0.08 * STOCK_SPECULAR);
   let f0 = mix(dielectric_f0, tex_rgb, STOCK_METALLIC);
   let f90 = mix(f0, vec3f(1.0), sqrt(STOCK_SPECULAR));
-  let split_sum = brdf_lut_baked(NV, STOCK_ROUGHNESS);
-  let reflection_color = F_brdf_multi_scatter(f0, f90, split_sum);
+  let brdf_lut = brdf_lut_sample(NV, STOCK_ROUGHNESS);
+  let reflection_color = F_brdf_multi_scatter(f0, f90, brdf_lut.xy);
 
-  let spec_direct = bsdf_ggx(n, l, v, STOCK_ROUGHNESS) * sun * shadow * ltc_brdf_scale(NV, STOCK_ROUGHNESS);
+  let spec_direct = bsdf_ggx(n, l, v, NL, NV, STOCK_ROUGHNESS) * sun * shadow * ltc_brdf_scale_from_lut(brdf_lut);
   let spec_indirect = amb;
   let spec_radiance = (spec_direct + spec_indirect) * reflection_color;
 
@@ -225,7 +237,10 @@ fn ramp_ease_s(f: f32, p0: f32, p1: f32) -> f32 {
   // ═══ MIX SHADER: Shader=Emission, Shader_001=Principled, Fac=mask ═══
   let final_color = mix(emission, principled, mask);
 
-  return vec4f(final_color, out_alpha);
+  var out: FSOut;
+  out.color = vec4f(final_color, out_alpha);
+  out.bloom_mask = 1.0;
+  return out;
 }
 
 `