reze-engine 0.10.2 → 0.11.1

package/src/shaders/default.ts

@@ -0,0 +1,186 @@
+// Blender 3.6 Principled BSDF defaults + Filmic "Medium High Contrast" tone mapping.
+// Metallic=0, Specular=0.5 (F0=0.04), Roughness=0.5.
+// Tone mapping via LUT sampled from Blender's OCIO pipeline (exposure -0.3 baked in).
+
+export const DEFAULT_SHADER_WGSL = /* wgsl */ `
+
+const PI: f32 = 3.141592653589793;
+const F0_DIELECTRIC: f32 = 0.04;
+const ROUGHNESS: f32 = 0.5;
+
+struct CameraUniforms {
+  view: mat4x4f,
+  projection: mat4x4f,
+  viewPos: vec3f,
+  _padding: f32,
+};
+
+struct Light {
+  direction: vec4f,
+  color: vec4f,
+};
+
+struct LightUniforms {
+  ambientColor: vec4f,
+  lights: array<Light, 4>,
+};
+
+// Per-material uniforms. Add fields here only when a shader actually reads them;
+// preset-specific shaders (face.ts, future hair.ts) share this struct so the
+// engine can use one material bind-group layout.
+struct MaterialUniforms {
+  diffuseColor: vec3f,  // tint; multiplies sampled albedo (unused by current fs, reserved)
+  alpha: f32,            // 0 → discard; <1 → transparent draw call
+};
+
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) normal: vec3f,
+  @location(1) uv: vec2f,
+  @location(2) worldPos: vec3f,
+};
+
+struct LightVP { viewProj: mat4x4f, };
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(0) @binding(1) var<uniform> light: LightUniforms;
+@group(0) @binding(2) var diffuseSampler: sampler;
+@group(0) @binding(3) var shadowMap: texture_depth_2d;
+@group(0) @binding(4) var shadowSampler: sampler_comparison;
+@group(0) @binding(5) var<uniform> lightVP: LightVP;
+@group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
+@group(2) @binding(0) var diffuseTexture: texture_2d<f32>;
+@group(2) @binding(1) var<uniform> material: MaterialUniforms;
+
+// ─── GGX specular helpers ───────────────────────────────────────────
+
+fn ggx_d(ndoth: f32, a2: f32) -> f32 {
+  let denom = ndoth * ndoth * (a2 - 1.0) + 1.0;
+  return a2 / (PI * denom * denom);
+}
+
+fn smith_g1(ndotx: f32, a2: f32) -> f32 {
+  return 2.0 * ndotx / (ndotx + sqrt(a2 + (1.0 - a2) * ndotx * ndotx));
+}
+
+fn fresnel_schlick(cosTheta: f32, f0: f32) -> f32 {
+  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) ─────
+// View transform = Filmic, Look = Medium High Contrast, Exposure = -0.3.
+// 14 samples at integer log2 stops from -10 to +3 (inclusive).
+// Extracted via scripts/extract_filmic_lut.py → probe image through scene
+// color management. Input: linear scene-referred. Output: sRGB display.
+
+fn filmic(x: f32) -> f32 {
+  var lut = array<f32, 14>(
+    0.0067, 0.0141, 0.0272, 0.0499, 0.0885, 0.1512, 0.2462,
+    0.3753, 0.5273, 0.6776, 0.8031, 0.8929, 0.9495, 0.9814
+  );
+  let t = clamp(log2(max(x, 1e-10)) + 10.0, 0.0, 13.0);
+  let i = u32(t);
+  let j = min(i + 1u, 13u);
+  return mix(lut[i], lut[j], t - f32(i));
+}
+
+fn tonemap(hdr: vec3f) -> vec3f {
+  return vec3f(filmic(hdr.x), filmic(hdr.y), filmic(hdr.z));
+}
+
+// ─── 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 / 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 ──────────────────────────────────────────────
+
+@vertex fn vs(
+  @location(0) position: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) uv: vec2f,
+  @location(3) joints0: vec4<u32>,
+  @location(4) weights0: vec4<f32>
+) -> VertexOutput {
+  var output: VertexOutput;
+  let pos4 = vec4f(position, 1.0);
+  let weightSum = weights0.x + weights0.y + weights0.z + weights0.w;
+  let invWeightSum = select(1.0, 1.0 / weightSum, weightSum > 0.0001);
+  let nw = select(vec4f(1.0, 0.0, 0.0, 0.0), weights0 * invWeightSum, weightSum > 0.0001);
+  var skinnedPos = vec4f(0.0);
+  var skinnedNrm = vec3f(0.0);
+  for (var i = 0u; i < 4u; i++) {
+    let m = skinMats[joints0[i]];
+    let w = nw[i];
+    skinnedPos += (m * pos4) * w;
+    skinnedNrm += (mat3x3f(m[0].xyz, m[1].xyz, m[2].xyz) * normal) * w;
+  }
+  output.position = camera.projection * camera.view * vec4f(skinnedPos.xyz, 1.0);
+  // 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;
+}
+
+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; }
+
+  let n = normalize(input.normal);
+  let v = normalize(camera.viewPos - input.worldPos);
+  let albedo = textureSample(diffuseTexture, diffuseSampler, input.uv).rgb;
+
+  let l = -light.lights[0].direction.xyz;
+  let sunColor = light.lights[0].color.xyz * light.lights[0].color.w;
+  let h = normalize(l + v);
+
+  let ndotl = max(dot(n, l), 0.0);
+  let ndotv = max(dot(n, v), 0.001);
+  let ndoth = max(dot(n, h), 0.0);
+  let vdoth = max(dot(v, h), 0.0);
+
+  let a2 = ROUGHNESS * ROUGHNESS;
+  let D = ggx_d(ndoth, a2);
+  let G = smith_g1(ndotl, a2) * smith_g1(ndotv, a2);
+  let F = fresnel_schlick(vdoth, F0_DIELECTRIC);
+  let spec = (D * G * F) / max(4.0 * ndotl * ndotv, 0.001);
+
+  let shadow = sampleShadow(input.worldPos, n);
+  let kd = (1.0 - F) * albedo / PI;
+  let direct = (kd + spec) * sunColor * ndotl * shadow;
+  let ambient = albedo * light.ambientColor.xyz;
+
+  var out: FSOut;
+  out.color = vec4f(ambient + direct, alpha);
+  out.mask = 1.0;
+  return out;
+}
+
+`

package/src/shaders/dfg_lut.ts

@@ -0,0 +1,131 @@
+// 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.
+//
+// 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 {
+  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);
+}
+
+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));
+  let B = cross(N, T);
+  return mat2x3f(T, B);
+}
+
+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);
+  let Th = tb[0];
+  let Bh = tb[1];
+  let r = sqrt(rand.x);
+  let x = r * rand.y;
+  var y = r * rand.z;
+  let s = 0.5 * (1.0 + Vh.z);
+  y = (1.0 - s) * sqrt(1.0 - x * x) + s * y;
+  let z = sqrt(saturate(1.0 - x * x - y * y));
+  let Hh = x * Th + y * Bh + z * Vh;
+  return normalize(vec3f(alpha * Hh.xy, saturate(Hh.z)));
+}
+
+fn G1_Smith_GGX_opti(NX: f32, a2: f32) -> f32 {
+  return NX + sqrt(NX * (NX - NX * a2) + a2);
+}
+
+fn F_eta(eta: f32, cos_theta: f32) -> f32 {
+  let c = abs(cos_theta);
+  var g = eta * eta - 1.0 + c * c;
+  if (g > 0.0) {
+    g = sqrt(g);
+    let A = (g - c) / (g + c);
+    let B = (c * (g + c) - 1.0) / (c * (g - c) + 1.0);
+    return 0.5 * A * A * (1.0 + B * B);
+  }
+  return 1.0;
+}
+
+fn f0_from_ior(eta: f32) -> f32 {
+  let A = (eta - 1.0) / (eta + 1.0);
+  return A * A;
+}
+
+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) vec4f {
+  let y_uv = floor(frag.y) / (LUT_SIZE - 1.0);
+  let x_uv = floor(frag.x) / (LUT_SIZE - 1.0);
+
+  let NV = clamp(1.0 - y_uv * y_uv, 1e-4, 0.9999);
+  let a = x_uv * x_uv;
+  let a2 = clamp(a * a, 1e-4, 0.9999);
+
+  let V = vec3f(sqrt(1.0 - NV * NV), 0.0, NV);
+
+  let eta = (2.0 / (1.0 - sqrt(0.08 * 1.0))) - 1.0;
+
+  var brdf_accum = 0.0;
+  var fresnel_accum = 0.0;
+  let sc_f = f32(SAMPLE_COUNT);
+  for (var j: u32 = 0u; j < SAMPLE_COUNT; j = j + 1u) {
+    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;
+      let Xi = vec3f(ix, cos(iy * M_2PI), sin(iy * M_2PI));
+
+      let H = sample_ggx_vndf(Xi, a, V);
+      let L = -reflect(V, H);
+      let NL = L.z;
+      if (NL > 0.0) {
+        let NH = max(H.z, 0.0);
+        let VH = max(dot(V, H), 0.0);
+
+        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);
+
+        let brdf = (G_smith * VH) / (NH * NV);
+
+        let fresnel = F_eta(eta, VH);
+        let Fc = F_color_blend_zero(eta, fresnel);
+
+        brdf_accum = brdf_accum + (1.0 - Fc) * brdf;
+        fresnel_accum = fresnel_accum + Fc * brdf;
+      }
+    }
+  }
+  let n2 = sc_f * sc_f;
+  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);
+}
+`

package/src/shaders/eye.ts

@@ -0,0 +1,160 @@
+// Eye preset — default Principled BSDF (F0=0.04, Roughness=0.5) + Emission socket set to albedo × 1.5.
+// Matches the published preset's instruction: "keep eyes in the default nodegraph, add emission 1.5".
+// Blender's Principled BSDF Emission socket is added on top of the shaded output (pre-tonemap, feeds bloom).
+
+export const EYE_SHADER_WGSL = /* wgsl */ `
+
+const PI: f32 = 3.141592653589793;
+const F0_DIELECTRIC: f32 = 0.04;
+const ROUGHNESS: f32 = 0.5;
+const EYE_EMISSION_STRENGTH: f32 = 1.5;
+
+struct CameraUniforms {
+  view: mat4x4f,
+  projection: mat4x4f,
+  viewPos: vec3f,
+  _padding: f32,
+};
+
+struct Light {
+  direction: vec4f,
+  color: vec4f,
+};
+
+struct LightUniforms {
+  ambientColor: vec4f,
+  lights: array<Light, 4>,
+};
+
+struct MaterialUniforms {
+  diffuseColor: vec3f,
+  alpha: f32,
+};
+
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) normal: vec3f,
+  @location(1) uv: vec2f,
+  @location(2) worldPos: vec3f,
+};
+
+struct LightVP { viewProj: mat4x4f, };
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(0) @binding(1) var<uniform> light: LightUniforms;
+@group(0) @binding(2) var diffuseSampler: sampler;
+@group(0) @binding(3) var shadowMap: texture_depth_2d;
+@group(0) @binding(4) var shadowSampler: sampler_comparison;
+@group(0) @binding(5) var<uniform> lightVP: LightVP;
+@group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
+@group(2) @binding(0) var diffuseTexture: texture_2d<f32>;
+@group(2) @binding(1) var<uniform> material: MaterialUniforms;
+
+fn ggx_d(ndoth: f32, a2: f32) -> f32 {
+  let denom = ndoth * ndoth * (a2 - 1.0) + 1.0;
+  return a2 / (PI * denom * denom);
+}
+
+fn smith_g1(ndotx: f32, a2: f32) -> f32 {
+  return 2.0 * ndotx / (ndotx + sqrt(a2 + (1.0 - a2) * ndotx * ndotx));
+}
+
+fn fresnel_schlick(cosTheta: f32, f0: f32) -> f32 {
+  let m = 1.0 - cosTheta;
+  let m2 = m * m;
+  return f0 + (1.0 - f0) * (m2 * m2 * m);
+}
+
+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 / 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 fn vs(
+  @location(0) position: vec3f,
+  @location(1) normal: vec3f,
+  @location(2) uv: vec2f,
+  @location(3) joints0: vec4<u32>,
+  @location(4) weights0: vec4<f32>
+) -> VertexOutput {
+  var output: VertexOutput;
+  let pos4 = vec4f(position, 1.0);
+  let weightSum = weights0.x + weights0.y + weights0.z + weights0.w;
+  let invWeightSum = select(1.0, 1.0 / weightSum, weightSum > 0.0001);
+  let nw = select(vec4f(1.0, 0.0, 0.0, 0.0), weights0 * invWeightSum, weightSum > 0.0001);
+  var skinnedPos = vec4f(0.0);
+  var skinnedNrm = vec3f(0.0);
+  for (var i = 0u; i < 4u; i++) {
+    let m = skinMats[joints0[i]];
+    let w = nw[i];
+    skinnedPos += (m * pos4) * w;
+    skinnedNrm += (mat3x3f(m[0].xyz, m[1].xyz, m[2].xyz) * normal) * w;
+  }
+  output.position = camera.projection * camera.view * vec4f(skinnedPos.xyz, 1.0);
+  // 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;
+}
+
+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; }
+
+  let n = normalize(input.normal);
+  let v = normalize(camera.viewPos - input.worldPos);
+  let albedo = textureSample(diffuseTexture, diffuseSampler, input.uv).rgb;
+
+  let l = -light.lights[0].direction.xyz;
+  let sunColor = light.lights[0].color.xyz * light.lights[0].color.w;
+  let h = normalize(l + v);
+
+  let ndotl = max(dot(n, l), 0.0);
+  let ndotv = max(dot(n, v), 0.001);
+  let ndoth = max(dot(n, h), 0.0);
+  let vdoth = max(dot(v, h), 0.0);
+
+  let a2 = ROUGHNESS * ROUGHNESS;
+  let D = ggx_d(ndoth, a2);
+  let G = smith_g1(ndotl, a2) * smith_g1(ndotv, a2);
+  let F = fresnel_schlick(vdoth, F0_DIELECTRIC);
+  let spec = (D * G * F) / max(4.0 * ndotl * ndotv, 0.001);
+
+  let shadow = sampleShadow(input.worldPos, n);
+  let kd = (1.0 - F) * albedo / PI;
+  let direct = (kd + spec) * sunColor * ndotl * shadow;
+  let ambient = albedo * light.ambientColor.xyz;
+
+  // Principled Emission socket: emissive = emission_color × strength, added on top of shading.
+  let emission = albedo * EYE_EMISSION_STRENGTH;
+
+  var out: FSOut;
+  out.color = vec4f(ambient + direct + emission, alpha);
+  out.mask = 1.0;
+  return out;
+}
+
+`