reze-engine 0.11.0 → 0.11.1

package/src/shaders/body.ts

@@ -48,19 +48,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_B: f32 = 3.141592653589793;
@@ -72,6 +78,8 @@ const BODY_RIM2_POW: f32 = 1.4300000667572021;
 const BODY_RIM2_BG: vec3f = vec3f(1.0, 0.4303792119026184, 0.3315804898738861);
 const BODY_WARM_AO_MUL: f32 = 0.30000001192092896;
 const BODY_MIX_NPR: f32 = 0.5;
+// EEVEE Light Clamp equivalent — caps firefly specular from noise-bumped NDF aliasing.
+const BODY_SPEC_CLAMP: f32 = 10.0;
 
 fn ggx_d_body(ndoth: f32, a2: f32) -> f32 {
   let denom = ndoth * ndoth * (a2 - 1.0) + 1.0;
@@ -83,7 +91,9 @@ fn smith_g1_body(ndotx: f32, a2: f32) -> f32 {
 }
 
 fn fresnel_schlick_body(cosTheta: f32, f0: f32) -> f32 {
-  return f0 + (1.0 - f0) * pow(1.0 - cosTheta, 5.0);
+  let m = 1.0 - cosTheta;
+  let m2 = m * m;
+  return f0 + (1.0 - f0) * (m2 * m2 * m);
 }
 
 // smoothstep-based ramp: t*t*(3-2*t) between two color stops
@@ -114,13 +124,19 @@ fn ramp_ease(f: f32, p0: f32, c0: vec4f, p1: f32, c1: vec4f) -> vec4f {
     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 alpha = material.alpha;
   if (alpha < 0.001) { discard; }
 
@@ -137,13 +153,13 @@ fn ramp_ease(f: f32, p0: f32, c0: vec4f, p1: f32, c1: vec4f) -> vec4f {
   let toon = ramp_constant(ndotl_raw, 0.0, vec4f(0,0,0,1), 0.2966, vec4f(1,1,1,1)).r;
 
   // ═══ TOON COLOR: Mix.004 A=HueSat, B=HueSat.001, Fac=ramp.008 (R) ═══
-  let shadow_tint = hue_sat(0.5, 2.0, 0.3499999940395355, 1.0, tex_color);
-  let lit_tint = hue_sat(0.5, 1.5, 1.0, 1.0, tex_color);
+  let shadow_tint = hue_sat_id(2.0, 0.3499999940395355, 1.0, tex_color);
+  let lit_tint = hue_sat_id(1.5, 1.0, 1.0, tex_color);
   let toon_color = mix_blend(toon, shadow_tint, lit_tint);
   let bc = bright_contrast(toon_color, 0.1, 0.2);
 
   // ═══ AO CHAIN: AO → ramp CONSTANT [0→white, 0.5995→black] → Mix.003 ═══
-  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 = ramp_constant(ao, 0.0, vec4f(1,1,1,1), 0.5995, vec4f(0,0,0,1)).r;
   let ao_mixed = mix_blend(ao_ramp, bc, vec3f(0.8301780223846436, 0.3345769941806793, 0.27946099638938904));
 
@@ -174,16 +190,16 @@ fn ramp_ease(f: f32, p0: f32, c0: vec4f, p1: f32, c1: vec4f) -> vec4f {
   let npr_stack = add0 + warm_emission;
 
   // ═══ PRINCIPLED BSDF: noise bump, GGX specular, SSS from AO ═══
-  let gen = mapping_point(input.worldPos, vec3f(0.0), vec3f(0.0), vec3f(1.0, 1.0, 1.5));
-  let noise_val = tex_noise(gen, 1.0, 2.0, 0.5, 0.0);
+  // Mapping loc=rot=0 → plain scale multiply, inline.
+  let noise_val = tex_noise_d2(input.worldPos * vec3f(1.0, 1.0, 1.5), 1.0);
   let noise_ramp = ramp_linear(noise_val, 0.0, vec4f(0,0,0,1), 1.0, vec4f(1,1,1,1)).r;
   let bumped_n = bump_lh(0.324644535779953, noise_ramp, n, input.worldPos);
 
   let principled_base = mix_blend(noise_ramp, bc, vec3f(0.6831911206245422, 0.19474034011363983, 0.13732507824897766));
   let p_emission = bc * 0.2;
 
-  let ao2 = ao_fake(n, v);
-  let sss = ramp_linear(ao2, 0.003, vec4f(0,0,0,1), 1.0, vec4f(0.0786, 0.0786, 0.0786, 1.0)).r;
+  // Reuse 'ao' (ao_fake(n, v) above) — identical inputs, avoid a second procedural AO pass.
+  let sss = ramp_linear(ao, 0.003, vec4f(0,0,0,1), 1.0, vec4f(0.0786, 0.0786, 0.0786, 1.0)).r;
 
   let p_ndotl = max(dot(bumped_n, l), 0.0);
   let p_ndotv = max(dot(bumped_n, v), 0.001);
@@ -194,9 +210,13 @@ fn ramp_ease(f: f32, p0: f32, c0: vec4f, p1: f32, c1: vec4f) -> vec4f {
   let D = ggx_d_body(p_ndoth, a2);
   let G = smith_g1_body(p_ndotl, a2) * smith_g1_body(p_ndotv, a2);
   let F = fresnel_schlick_body(p_vdoth, F0_BODY);
-  let spec = (D * G * F) / max(4.0 * p_ndotl * p_ndotv, 0.001) * ltc_brdf_scale(p_ndotv, BODY_ROUGHNESS);
+  let brdf_lut = brdf_lut_sample(p_ndotv, BODY_ROUGHNESS);
+  let spec = (D * G * F) / max(4.0 * p_ndotl * p_ndotv, 0.001) * ltc_brdf_scale_from_lut(brdf_lut);
   let kd = (1.0 - F) * principled_base / PI_B;
-  let direct = (kd + spec) * sun * p_ndotl * shadow;
+  // Split so we can clamp only the spec firefly contribution (EEVEE Light Clamp).
+  let spec_radiance = vec3f(spec) * sun * p_ndotl * shadow;
+  let spec_clamped = min(spec_radiance, vec3f(BODY_SPEC_CLAMP));
+  let direct = kd * sun * p_ndotl * shadow + spec_clamped;
   // Indirect diffuse = base_color × L_w per Blender closure_eval_surface_lib.glsl line 302;
   // probe_evaluate_world_diff returns radiance (SH-projected, not cosine-convolved).
   let ambient = principled_base * light.ambientColor.xyz;
@@ -205,7 +225,10 @@ fn ramp_ease(f: f32, p0: f32, c0: vec4f, p1: f32, c1: vec4f) -> vec4f {
   // 混合着色器.001: Shader=相加着色器.001, Shader_001=原理化BSDF
   let final_color = mix(npr_stack, principled, BODY_MIX_NPR);
 
-  return vec4f(final_color, alpha);
+  var out: FSOut;
+  out.color = vec4f(final_color, alpha);
+  out.mask = 1.0;
+  return out;
 }
 
 `

package/src/shaders/cloth_rough.ts

@@ -49,19 +49,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_CR: f32 = 3.141592653589793;
@@ -73,6 +79,8 @@ const CLOTH_R_EMIT_STR: f32 = 18.200000762939453;
 const CLOTH_R_MIX_SHADER_FAC: f32 = 0.8999999761581421;
 const CLOTH_R_NOISE_SCALE: f32 = 17.7;
 const CLOTH_R_BUMP_STR: f32 = 1.0;
+// EEVEE Light Clamp equivalent — caps firefly specular from noise-bumped NDF aliasing.
+const CLOTH_R_SPEC_CLAMP: f32 = 10.0;
 
 @vertex fn vs(
   @location(0) position: vec3f,
@@ -95,13 +103,19 @@ const CLOTH_R_BUMP_STR: f32 = 1.0;
     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;
@@ -121,7 +135,7 @@ const CLOTH_R_BUMP_STR: f32 = 1.0;
   let mix04_fac = math_multiply(toon_r, CLOTH_R_MIX04_MUL);
 
   // 混合.004: A=色相/饱和度/明度.002(Hue=0.5 Sat=1.0 Val=0.2), B=纹理
-  let dark_tex = hue_sat(0.5, 1.0, 0.19999998807907104, 1.0, tex_rgb);
+  let dark_tex = hue_sat_id(1.0, 0.19999998807907104, 1.0, tex_rgb);
   let mix04 = mix_blend(mix04_fac, dark_tex, tex_rgb);
 
   // 倒角.001.Z → 混合.003: A=混合.004, B=色相/饱和度/明度.002
@@ -129,34 +143,35 @@ const CLOTH_R_BUMP_STR: f32 = 1.0;
   let mix03 = mix_blend(bevel_z, mix04, dark_tex);
 
   // 环境光遮蔽 → 颜色渐变.001 LINEAR → 混合.001 (white/black) → 混合.002 OVERLAY Fac
-  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 mix01_fac = ao_ramp_c.r;
   let mix01_rgb = mix(vec3f(1.0), vec3f(0.0), mix01_fac);
 
   // 混合.002 OVERLAY: Fac=混合.001, A=混合.003, B=色相/饱和度/明度.004
-  let hue004 = hue_sat(0.5, 0.800000011920929, 2.0, 1.0, mix03);
+  let hue004 = hue_sat_id(0.800000011920929, 2.0, 1.0, mix03);
   let overlay_fac = mix01_rgb.r;
   let npr_rgb = mix_overlay(overlay_fac, mix03, hue004);
   let npr_emission = npr_rgb * CLOTH_R_EMIT_STR;
 
   // 噪波→渐变→凹凸 (LIVE in M_Rough_Cloth — unlike Smooth Cloth): Strength=1.0, noise Scale=17.7.
-  let noise_uv = mapping_point(input.worldPos, vec3f(0.0), vec3f(0.0), vec3f(1.0));
-  let noise_val = tex_noise(noise_uv, CLOTH_R_NOISE_SCALE, 2.0, 0.5, 0.0);
+  // mapping scale=(1,1,1), loc=rot=0 → identity; use worldPos directly.
+  let noise_val = tex_noise_d2(input.worldPos, CLOTH_R_NOISE_SCALE);
   let noise_ramp = ramp_linear(noise_val, 0.0, vec4f(0,0,0,1), 1.0, vec4f(1,1,1,1)).r;
   let bumped_n = bump_lh(CLOTH_R_BUMP_STR, noise_ramp, n, input.worldPos);
 
   // 原理化BSDF (EEVEE port): metallic=0, specular=0.8, roughness=0.8187, specular_tint=0.
-  let principled_base = hue_sat(0.5, 1.0, 0.800000011920929, 1.0, tex_rgb);
+  let principled_base = hue_sat_id(1.0, 0.800000011920929, 1.0, tex_rgb);
   let NL = max(dot(bumped_n, l), 0.0);
   let NV = max(dot(bumped_n, v), 1e-4);
 
   let f0 = vec3f(0.08 * CLOTH_R_SPECULAR);
   let f90 = mix(f0, vec3f(1.0), sqrt(CLOTH_R_SPECULAR));
-  let split_sum = brdf_lut_baked(NV, CLOTH_R_ROUGHNESS);
-  let reflection_color = F_brdf_multi_scatter(f0, f90, split_sum);
+  let brdf_lut = brdf_lut_sample(NV, CLOTH_R_ROUGHNESS);
+  let reflection_color = F_brdf_multi_scatter(f0, f90, brdf_lut.xy);
 
-  let spec_direct = bsdf_ggx(bumped_n, l, v, CLOTH_R_ROUGHNESS) * sun * shadow * ltc_brdf_scale(NV, CLOTH_R_ROUGHNESS);
+  let spec_direct_raw = bsdf_ggx(bumped_n, l, v, NL, NV, CLOTH_R_ROUGHNESS) * sun * shadow * ltc_brdf_scale_from_lut(brdf_lut);
+  let spec_direct = min(spec_direct_raw, vec3f(CLOTH_R_SPEC_CLAMP));
   let spec_indirect = amb;
   let spec_radiance = (spec_direct + spec_indirect) * reflection_color;
 
@@ -168,7 +183,10 @@ const CLOTH_R_BUMP_STR: f32 = 1.0;
   // 混合着色器.001 Fac=0.9: Shader=自发光.005, Shader_001=原理化BSDF
   let final_color = mix(npr_emission, principled, CLOTH_R_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/cloth_smooth.ts

@@ -48,19 +48,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_C: f32 = 3.141592653589793;
@@ -92,13 +98,19 @@ const NPR_MIX_SHADER_FAC: f32 = 0.8999999761581421;
     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;
@@ -119,7 +131,7 @@ const NPR_MIX_SHADER_FAC: f32 = 0.8999999761581421;
   let mix04_fac = math_multiply(toon_r, CLOTH_MIX04_MUL);
 
   // 混合.004: A=色相/饱和度/明度.002, B=纹理
-  let dark_tex = hue_sat(0.5, 1.0, 0.19999998807907104, 1.0, tex_rgb);
+  let dark_tex = hue_sat_id(1.0, 0.19999998807907104, 1.0, tex_rgb);
   let mix04 = mix_blend(mix04_fac, dark_tex, tex_rgb);
 
   // 倒角.001→Z → 混合.003 Factor; A=混合.004, B=色相/饱和度/明度.002
@@ -127,32 +139,32 @@ const NPR_MIX_SHADER_FAC: f32 = 0.8999999761581421;
   let mix03 = mix_blend(bevel_z, mix04, dark_tex);
 
   // 环境光遮蔽 → 颜色渐变.001 LINEAR → 混合.001 (白/黑) → 混合.002 OVERLAY Fac
-  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 mix01_fac = ao_ramp_c.r;
   let mix01_rgb = mix(vec3f(1.0), vec3f(0.0), mix01_fac);
 
   // 混合.002 OVERLAY: Fac=混合.001, A=混合.003, B=色相/饱和度/明度.004
-  let hue004 = hue_sat(0.5, 0.800000011920929, 2.0, 1.0, mix03);
+  let hue004 = hue_sat_id(0.800000011920929, 2.0, 1.0, mix03);
   let overlay_fac = mix01_rgb.r;
   let npr_rgb = mix_overlay(overlay_fac, mix03, hue004);
   let npr_emission = npr_rgb * NPR_EMIT_STR;
 
   // 原理化BSDF (EEVEE port): metallic=0, specular=0.8, roughness=0.5, specular_tint=0.
   // Bump subtree is dead in the Blender graph (噪波→凹凸 not linked to Principled.Normal).
-  let principled_base = hue_sat(0.5, 1.0, 0.800000011920929, 1.0, tex_rgb);
+  let principled_base = hue_sat_id(1.0, 0.800000011920929, 1.0, tex_rgb);
   let NL = max(dot(n, l), 0.0);
   let NV = max(dot(n, v), 1e-4);
 
   // f0/f90 per gpu_shader_material_principled.glsl — specular_tint=0 → dielectric_f0_color=white.
   let f0 = vec3f(0.08 * CLOTH_SPECULAR);
   let f90 = mix(f0, vec3f(1.0), sqrt(CLOTH_SPECULAR));
-  let split_sum = brdf_lut_baked(NV, CLOTH_ROUGHNESS);
-  let reflection_color = F_brdf_multi_scatter(f0, f90, split_sum);
+  let brdf_lut = brdf_lut_sample(NV, CLOTH_ROUGHNESS);
+  let reflection_color = F_brdf_multi_scatter(f0, f90, brdf_lut.xy);
 
   // Direct glossy — bsdf_ggx already includes NL; no F applied here (tinted after accum).
   // ltc_brdf_scale: EEVEE direct path uses LTC; split-sum LUT path is rescaled to match.
-  let spec_direct = bsdf_ggx(n, l, v, CLOTH_ROUGHNESS) * sun * shadow * ltc_brdf_scale(NV, CLOTH_ROUGHNESS);
+  let spec_direct = bsdf_ggx(n, l, v, NL, NV, CLOTH_ROUGHNESS) * sun * shadow * ltc_brdf_scale_from_lut(brdf_lut);
   // Indirect glossy — flat world probe (solid color). Phase 2 adds cubemap.
   let spec_indirect = amb;
   let spec_radiance = (spec_direct + spec_indirect) * reflection_color;
@@ -167,7 +179,10 @@ const NPR_MIX_SHADER_FAC: f32 = 0.8999999761581421;
   // 混合着色器.001: Shader=自发光.005, Shader_001=原理化BSDF, Fac=0.9
   let final_color = mix(npr_emission, principled, NPR_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/default.ts

@@ -64,7 +64,9 @@ fn smith_g1(ndotx: f32, a2: f32) -> f32 {
 }
 
 fn fresnel_schlick(cosTheta: f32, f0: f32) -> f32 {
-  return f0 + (1.0 - f0) * pow(1.0 - cosTheta, 5.0);
+  let m = 1.0 - cosTheta;
+  let m2 = m * m;
+  return f0 + (1.0 - f0) * (m2 * m2 * m);
 }
 
 // ─── Filmic tone mapping (LUT extracted from Blender 3.6 OCIO) ─────
@@ -91,19 +93,25 @@ fn tonemap(hdr: vec3f) -> vec3f {
 // ─── Shadow sampling (3×3 PCF) ──────────────────────────────────────
 
 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);
 }
 
 // ─── Vertex / Fragment ──────────────────────────────────────────────
@@ -129,13 +137,19 @@ fn sampleShadow(worldPos: vec3f, n: vec3f) -> 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) mask: f32,
+};
+
+@fragment fn fs(input: VertexOutput) -> FSOut {
   let alpha = material.alpha;
   if (alpha < 0.001) { discard; }
 
@@ -163,7 +177,10 @@ fn sampleShadow(worldPos: vec3f, n: vec3f) -> f32 {
   let direct = (kd + spec) * sunColor * ndotl * shadow;
   let ambient = albedo * light.ambientColor.xyz;
 
-  return vec4f(ambient + direct, alpha);
+  var out: FSOut;
+  out.color = vec4f(ambient + direct, alpha);
+  out.mask = 1.0;
+  return out;
 }
 
 `

package/src/shaders/dfg_lut.ts

@@ -1,29 +1,37 @@
-// One-shot bake pass that precomputes EEVEE's BRDF split-sum DFG LUT.
-// Direct WGSL port of Blender 3.6 source/blender/draw/engines/eevee/shaders/
-//   bsdf_lut_frag.glsl + bsdf_sampling_lib.glsl (VNDF GGX branch).
+// One-shot bake pass that produces the combined EEVEE BRDF LUT.
+// Output: 64×64 rgba8unorm — .rg = split-sum DFG (Blender bsdf_lut_frag.glsl,
+// Karis convention: tint = f0·x + f90·y), .ba = Heitz 2016 LTC magnitude
+// (ltc_mag_ggx from eevee_lut.c), sampled from a temp rg16float source texture
+// passed in at bake time.
 //
-// Output texture: 64×64 rg16float, written once at engine init.
-//   R = (1 - Fc) × BRDF integrated over GGX VNDF — scales f0
-//   G = Fc × BRDF integrated over GGX VNDF — scales f90
-// Runtime sampler: see brdf_lut_baked() in nodes.ts. Plug into
-// F_brdf_single_scatter / F_brdf_multi_scatter verbatim.
-
-export const DFG_LUT_SIZE = 64
-export const DFG_LUT_SAMPLE_COUNT = 32
-
-export const DFG_LUT_WGSL = /* wgsl */ `
-const LUT_SIZE: f32 = ${DFG_LUT_SIZE}.0;
-const SAMPLE_COUNT: u32 = ${DFG_LUT_SAMPLE_COUNT}u;
+// Packing both LUTs into one texture lets runtime shaders do a SINGLE texture
+// fetch per fragment to get everything needed for F_brdf_multi_scatter AND
+// ltc_brdf_scale. Was 3 taps (dfg in brdf_lut_baked + dfg+ltc in ltc_brdf_scale);
+// now 1. Big win on Apple GPUs where fragment-stage texture fetches are the
+// dominant cost with MSAA.
+//
+// rgba8unorm (vs rgba16float) is a deliberate precision drop: DFG values live in
+// [0,1], LTC magnitude in [0,1], 1/255 quantization is below the perceptual
+// threshold for direct-spec energy compensation. Halves bandwidth per sample.
+
+export const BRDF_LUT_SIZE = 64
+const BAKE_SAMPLE_COUNT = 32
+
+export const BRDF_LUT_BAKE_WGSL = /* wgsl */ `
+const LUT_SIZE: f32 = ${BRDF_LUT_SIZE}.0;
+const SAMPLE_COUNT: u32 = ${BAKE_SAMPLE_COUNT}u;
 const M_2PI: f32 = 6.283185307179586;
 
+// Temp LTC magnitude source (rg16float, uploaded from eevee_lut.c ltc_mag_ggx).
+// Sampled 1:1 by pixel — bake coord mapping matches runtime sample coord mapping.
+@group(0) @binding(0) var ltcSrc: texture_2d<f32>;
+
 @vertex fn vs(@builtin(vertex_index) vid: u32) -> @builtin(position) vec4f {
-  // Full-screen triangle covering [-1,1]² in NDC.
   let x = f32((vid << 1u) & 2u) * 2.0 - 1.0;
   let y = f32(vid & 2u) * 2.0 - 1.0;
   return vec4f(x, y, 0.0, 1.0);
 }
 
-// common_math_geom_lib.glsl:165 — make_orthonormal_basis.
 fn orthonormal_basis(N: vec3f) -> mat2x3f {
   let up = select(vec3f(1.0, 0.0, 0.0), vec3f(0.0, 0.0, 1.0), abs(N.z) < 0.99999);
   let T = normalize(cross(up, N));
@@ -31,7 +39,6 @@ fn orthonormal_basis(N: vec3f) -> mat2x3f {
   return mat2x3f(T, B);
 }
 
-// bsdf_sampling_lib.glsl:27 — Heitz 2018 VNDF sampling in tangent space.
 fn sample_ggx_vndf(rand: vec3f, alpha: f32, Vt: vec3f) -> vec3f {
   let Vh = normalize(vec3f(alpha * Vt.xy, Vt.z));
   let tb = orthonormal_basis(Vh);
@@ -47,12 +54,10 @@ fn sample_ggx_vndf(rand: vec3f, alpha: f32, Vt: vec3f) -> vec3f {
   return normalize(vec3f(alpha * Hh.xy, saturate(Hh.z)));
 }
 
-// bsdf_common_lib.glsl:105 — G1 Smith GGX (Brian Karis opti form).
 fn G1_Smith_GGX_opti(NX: f32, a2: f32) -> f32 {
   return NX + sqrt(NX * (NX - NX * a2) + a2);
 }
 
-// bsdf_common_lib.glsl:50 — exact dielectric Fresnel (monochromatic).
 fn F_eta(eta: f32, cos_theta: f32) -> f32 {
   let c = abs(cos_theta);
   var g = eta * eta - 1.0 + c * c;
@@ -62,7 +67,7 @@ fn F_eta(eta: f32, cos_theta: f32) -> f32 {
     let B = (c * (g + c) - 1.0) / (c * (g - c) + 1.0);
     return 0.5 * A * A * (1.0 + B * B);
   }
-  return 1.0; // total internal reflection
+  return 1.0;
 }
 
 fn f0_from_ior(eta: f32) -> f32 {
@@ -70,13 +75,12 @@ fn f0_from_ior(eta: f32) -> f32 {
   return A * A;
 }
 
-// F_color_blend(eta, fresnel, vec3(0)).r — blend factor only.
 fn F_color_blend_zero(eta: f32, fresnel: f32) -> f32 {
   let f0 = f0_from_ior(eta);
   return saturate((fresnel - f0) / (1.0 - f0));
 }
 
-@fragment fn fs(@builtin(position) frag: vec4f) -> @location(0) vec2f {
+@fragment fn fs(@builtin(position) frag: vec4f) -> @location(0) vec4f {
   let y_uv = floor(frag.y) / (LUT_SIZE - 1.0);
   let x_uv = floor(frag.x) / (LUT_SIZE - 1.0);
 
@@ -86,7 +90,6 @@ fn F_color_blend_zero(eta: f32, fresnel: f32) -> f32 {
 
   let V = vec3f(sqrt(1.0 - NV * NV), 0.0, NV);
 
-  // principled specular=1.0 — max value, matches bsdf_lut_frag.glsl:41.
   let eta = (2.0 / (1.0 - sqrt(0.08 * 1.0))) - 1.0;
 
   var brdf_accum = 0.0;
@@ -96,7 +99,6 @@ fn F_color_blend_zero(eta: f32, fresnel: f32) -> f32 {
     for (var i: u32 = 0u; i < SAMPLE_COUNT; i = i + 1u) {
       let ix = (f32(i) + 0.5) / sc_f;
       let iy = (f32(j) + 0.5) / sc_f;
-      // Xi.x = radial, Xi.yz = (cos, sin) of azimuth — bsdf_lut_frag.glsl:22.
       let Xi = vec3f(ix, cos(iy * M_2PI), sin(iy * M_2PI));
 
       let H = sample_ggx_vndf(Xi, a, V);
@@ -106,7 +108,6 @@ fn F_color_blend_zero(eta: f32, fresnel: f32) -> f32 {
         let NH = max(H.z, 0.0);
         let VH = max(dot(V, H), 0.0);
 
-        // G_smith (divided form): 4·NV·NL / (G1_v·G1_l). See bsdf_common_lib.glsl:105.
         let G1v = G1_Smith_GGX_opti(NV, a2);
         let G1l = G1_Smith_GGX_opti(NL, a2);
         let G_smith = 4.0 * NV * NL / (G1v * G1l);
@@ -122,6 +123,9 @@ fn F_color_blend_zero(eta: f32, fresnel: f32) -> f32 {
     }
   }
   let n2 = sc_f * sc_f;
-  return vec2f(brdf_accum / n2, fresnel_accum / n2);
+  let dfg = vec2f(brdf_accum / n2, fresnel_accum / n2);
+  // Pack preloaded LTC magnitude at matching (roughness, sqrt(1-NV)) pixel.
+  let ltc = textureLoad(ltcSrc, vec2i(i32(frag.x), i32(frag.y)), 0).rg;
+  return vec4f(dfg, ltc);
 }
 `