@forgeax/engine-shader 0.1.2

package/src/atmosphere-cubemap.wgsl

@@ -0,0 +1,72 @@
+#define_import_path forgeax_environment::cubemap
+
+// @forgeax/engine-shader - atmosphere-cubemap.wgsl
+//
+// The sole production caller of preetham_sky_radiance. Background and IBL
+// consumers sample this generated cube; neither owns another evaluator.
+
+#import forgeax_environment::preetham::{preetham_sky_radiance}
+
+struct AtmosphereCubeParams {
+  sunDirection: vec3<f32>,
+  sunIlluminance: f32,
+  sunColor: vec3<f32>,
+  _sunColorPad: f32,
+  turbidity: f32,
+  rayleigh: f32,
+  mieCoefficient: f32,
+  mieDirectionalG: f32,
+  sunAngularRadius: f32,
+  sunDiscEnabled: f32,
+  _tailPad: vec2<f32>,
+};
+
+struct AtmosphereCubeVsIn {
+  // xy is clip-space; z is a one-based cube-face tag supplied by the
+  // producer's six fullscreen triangles.
+  @location(0) faceVertex: vec3<f32>,
+};
+
+struct AtmosphereCubeVsOut {
+  @builtin(position) clip: vec4<f32>,
+  @location(0) direction: vec3<f32>,
+};
+
+@group(0) @binding(0) var<uniform> atmosphere: AtmosphereCubeParams;
+
+@vertex
+fn atmosphere_cubemap_vs(input: AtmosphereCubeVsIn) -> AtmosphereCubeVsOut {
+  var output: AtmosphereCubeVsOut;
+  let face = u32(input.faceVertex.z) - 1u;
+  let x = input.faceVertex.x;
+  let y = input.faceVertex.y;
+  output.clip = vec4<f32>(x, y, 0.5, 1.0);
+  switch face {
+    case 0u: { output.direction = vec3<f32>(1.0, -y, -x); }
+    case 1u: { output.direction = vec3<f32>(-1.0, -y, x); }
+    // Cube consumers negate Y for the shared OpenGL-authored convention.
+    // Clip-space Y is also inverted by the attachment viewport. The four
+    // side faces already compose both transforms through `-y`; the Y-axis
+    // faces must encode their world sign and Z orientation explicitly.
+    case 2u: { output.direction = vec3<f32>(x, -1.0, -y); }
+    case 3u: { output.direction = vec3<f32>(x, 1.0, y); }
+    case 4u: { output.direction = vec3<f32>(x, -y, 1.0); }
+    default: { output.direction = vec3<f32>(-x, -y, -1.0); }
+  }
+  return output;
+}
+
+@fragment
+fn atmosphere_cubemap_fs(input: AtmosphereCubeVsOut) -> @location(0) vec4<f32> {
+  let radiance = preetham_sky_radiance(
+    normalize(input.direction),
+    atmosphere.sunDirection,
+    atmosphere.sunColor,
+    atmosphere.sunIlluminance,
+    atmosphere.turbidity,
+    atmosphere.rayleigh,
+    atmosphere.mieCoefficient,
+    atmosphere.mieDirectionalG,
+  );
+  return vec4<f32>(radiance, 1.0);
+}

package/src/atmosphere-ibl.wgsl

@@ -0,0 +1,127 @@
+#define_import_path forgeax_environment::ibl
+
+// @forgeax/engine-shader - atmosphere-ibl.wgsl
+//
+// The analytic atmosphere evaluator writes only the sky cube. Diffuse and
+// specular consumers derive their own products from that cube here, keeping
+// the Sun disc out of every IBL payload and preventing a second direct-Sun
+// injection. The graph selects one entry point per producer kind.
+
+#import forgeax_pbr::ibl_shared::{PI, hammersley, importanceSampleGGX}
+
+struct AtmosphereIblParams {
+  sunDirection: vec3<f32>,
+  sunIlluminance: f32,
+  sunColor: vec3<f32>,
+  _sunColorPad: f32,
+  turbidity: f32,
+  rayleigh: f32,
+  mieCoefficient: f32,
+  mieDirectionalG: f32,
+  sunAngularRadius: f32,
+  sunDiscEnabled: f32,
+  prefilterRoughness: f32,
+  producerKind: f32,
+};
+
+struct AtmosphereIblVsIn {
+  // xy is clip-space; z is the one-based cube-face tag supplied by the
+  // producer's six fullscreen triangles.
+  @location(0) faceVertex: vec3<f32>,
+};
+
+struct AtmosphereIblVsOut {
+  @builtin(position) clip: vec4<f32>,
+  @location(0) direction: vec3<f32>,
+};
+
+@group(0) @binding(0) var<uniform> atmosphere: AtmosphereIblParams;
+@group(1) @binding(0) var sky: texture_cube<f32>;
+@group(1) @binding(1) var skySampler: sampler;
+
+@vertex
+fn atmosphere_ibl_vs(input: AtmosphereIblVsIn) -> AtmosphereIblVsOut {
+  var output: AtmosphereIblVsOut;
+  let face = u32(input.faceVertex.z) - 1u;
+  let x = input.faceVertex.x;
+  let y = input.faceVertex.y;
+  output.clip = vec4<f32>(x, y, 0.5, 1.0);
+  switch face {
+    case 0u: { output.direction = vec3<f32>(1.0, -y, -x); }
+    case 1u: { output.direction = vec3<f32>(-1.0, -y, x); }
+    case 2u: { output.direction = vec3<f32>(x, -1.0, -y); }
+    case 3u: { output.direction = vec3<f32>(x, 1.0, y); }
+    case 4u: { output.direction = vec3<f32>(x, -y, 1.0); }
+    default: { output.direction = vec3<f32>(-x, -y, -1.0); }
+  }
+  return output;
+}
+
+fn atmosphere_ibl_tangent_frame(normal: vec3<f32>) -> mat3x3<f32> {
+  let up = select(
+    vec3<f32>(0.0, 1.0, 0.0),
+    vec3<f32>(1.0, 0.0, 0.0),
+    abs(normal.y) > 0.999,
+  );
+  let tangent = normalize(cross(up, normal));
+  let bitangent = normalize(cross(normal, tangent));
+  return mat3x3<f32>(tangent, bitangent, normal);
+}
+
+@fragment
+fn atmosphere_irradiance_fs(input: AtmosphereIblVsOut) -> @location(0) vec4<f32> {
+  let normal = normalize(input.direction);
+  let frame = atmosphere_ibl_tangent_frame(normal);
+  var irradiance = vec3<f32>(0.0);
+  var sampleCount: f32 = 0.0;
+  var phiIndex: u32 = 0u;
+  while (phiIndex < 16u) {
+    let phi = 2.0 * PI * f32(phiIndex) / 16.0;
+    var thetaIndex: u32 = 0u;
+    while (thetaIndex < 8u) {
+      let theta = 0.5 * PI * (f32(thetaIndex) + 0.5) / 8.0;
+      let tangentSample = vec3<f32>(
+        sin(theta) * cos(phi),
+        sin(theta) * sin(phi),
+        cos(theta),
+      );
+      let sampleDirection = frame * tangentSample;
+      let weight = cos(theta) * sin(theta);
+      let cubeSampleDirection = vec3<f32>(
+        sampleDirection.x,
+        -sampleDirection.y,
+        sampleDirection.z,
+      );
+      irradiance += textureSampleLevel(sky, skySampler, cubeSampleDirection, 0.0).rgb * weight;
+      sampleCount += 1.0;
+      thetaIndex = thetaIndex + 1u;
+    }
+    phiIndex = phiIndex + 1u;
+  }
+  return vec4<f32>(PI * irradiance / max(sampleCount, 1.0), 1.0);
+}
+
+@fragment
+fn atmosphere_prefilter_fs(input: AtmosphereIblVsOut) -> @location(0) vec4<f32> {
+  let normal = normalize(input.direction);
+  let viewDirection = normal;
+  let roughness = clamp(atmosphere.prefilterRoughness, 0.04, 1.0);
+  var prefiltered = vec3<f32>(0.0);
+  var totalWeight: f32 = 0.0;
+  const sampleCount: u32 = 64u;
+  for (var index: u32 = 0u; index < sampleCount; index = index + 1u) {
+    let halfVector = importanceSampleGGX(hammersley(index, sampleCount), normal, roughness);
+    let lightDirection = normalize(2.0 * dot(viewDirection, halfVector) * halfVector - viewDirection);
+    let normalLight = max(dot(normal, lightDirection), 0.0);
+    if (normalLight > 0.0) {
+      let cubeLightDirection = vec3<f32>(
+        lightDirection.x,
+        -lightDirection.y,
+        lightDirection.z,
+      );
+      prefiltered += textureSampleLevel(sky, skySampler, cubeLightDirection, 0.0).rgb * normalLight;
+      totalWeight += normalLight;
+    }
+  }
+  return vec4<f32>(prefiltered / max(totalWeight, 0.001), 1.0);
+}

package/src/atmosphere-preetham.wgsl

@@ -0,0 +1,214 @@
+#define_import_path forgeax_environment::preetham
+
+// @forgeax/engine-shader - atmosphere-preetham.wgsl
+//
+// Build-time Preetham/Perez daylight evaluator. The cubemap producer is the
+// only caller. Background composition owns the sun disc separately so this
+// module cannot accidentally bake the disc into sky or IBL radiance.
+
+const PREETHAM_ALGORITHM_REVISION : u32 = 1999u;
+const PREETHAM_PI : f32 = 3.14159265359;
+const PREETHAM_YXY_EPSILON : f32 = 1e-5;
+const PREETHAM_RADIANCE_MAX : f32 = 65504.0;
+
+// Each vec2 stores the turbidity slope and intercept for Perez A/B/C/D/E.
+// Keeping Y, x and y independent is essential: they are three distributions,
+// not one luminance curve followed by invented chromaticity.
+const PREETHAM_PEREZ_Y_COEFFICIENTS : array<vec2<f32>, 5> = array<vec2<f32>, 5>(
+  vec2<f32>(0.1787, -1.4630),
+  vec2<f32>(-0.3554, 0.4275),
+  vec2<f32>(-0.0227, 5.3251),
+  vec2<f32>(0.1206, -2.5771),
+  vec2<f32>(-0.0670, 0.3703),
+);
+
+const PREETHAM_PEREZ_X_COEFFICIENTS : array<vec2<f32>, 5> = array<vec2<f32>, 5>(
+  vec2<f32>(-0.0193, -0.2592),
+  vec2<f32>(-0.0665, 0.0008),
+  vec2<f32>(-0.0004, 0.2125),
+  vec2<f32>(-0.0641, -0.8989),
+  vec2<f32>(-0.0033, 0.0452),
+);
+
+const PREETHAM_PEREZ_SMALL_Y_COEFFICIENTS : array<vec2<f32>, 5> = array<vec2<f32>, 5>(
+  vec2<f32>(-0.0167, -0.2608),
+  vec2<f32>(-0.0950, 0.0092),
+  vec2<f32>(-0.0079, 0.2102),
+  vec2<f32>(-0.0441, -1.6537),
+  vec2<f32>(-0.0109, 0.0529),
+);
+
+struct PreethamPerezCoefficients {
+  a: f32,
+  b: f32,
+  c: f32,
+  d: f32,
+  e: f32,
+};
+
+fn preetham_finite_guard(value: vec3<f32>) -> vec3<f32> {
+  // Inputs are validated before the producer reaches this module. Clamp the
+  // output to the finite half-float domain as a second shader-side guard.
+  return clamp(value, vec3<f32>(0.0), vec3<f32>(PREETHAM_RADIANCE_MAX));
+}
+
+fn preetham_yxy_to_linear_srgb(yxy: vec3<f32>) -> vec3<f32> {
+  let Y = max(yxy.x, 0.0);
+  let x = clamp(yxy.y, 0.0, 1.0);
+  let y = clamp(yxy.z, PREETHAM_YXY_EPSILON, 1.0);
+  let X = Y * x / y;
+  let Z = Y * max(1.0 - x - y, 0.0) / y;
+  let linear = vec3<f32>(
+    3.2406 * X - 1.5372 * Y - 0.4986 * Z,
+    -0.9689 * X + 1.8758 * Y + 0.0415 * Z,
+    0.0557 * X - 0.2040 * Y + 1.0570 * Z,
+  );
+  return preetham_finite_guard(max(linear, vec3<f32>(0.0)));
+}
+
+fn preetham_fit(fit: vec2<f32>, turbidity: f32) -> f32 {
+  return fit.x * turbidity + fit.y;
+}
+
+fn preetham_y_coefficients(turbidity: f32) -> PreethamPerezCoefficients {
+  return PreethamPerezCoefficients(
+    preetham_fit(PREETHAM_PEREZ_Y_COEFFICIENTS[0], turbidity),
+    preetham_fit(PREETHAM_PEREZ_Y_COEFFICIENTS[1], turbidity),
+    preetham_fit(PREETHAM_PEREZ_Y_COEFFICIENTS[2], turbidity),
+    preetham_fit(PREETHAM_PEREZ_Y_COEFFICIENTS[3], turbidity),
+    preetham_fit(PREETHAM_PEREZ_Y_COEFFICIENTS[4], turbidity),
+  );
+}
+
+fn preetham_x_coefficients(turbidity: f32) -> PreethamPerezCoefficients {
+  return PreethamPerezCoefficients(
+    preetham_fit(PREETHAM_PEREZ_X_COEFFICIENTS[0], turbidity),
+    preetham_fit(PREETHAM_PEREZ_X_COEFFICIENTS[1], turbidity),
+    preetham_fit(PREETHAM_PEREZ_X_COEFFICIENTS[2], turbidity),
+    preetham_fit(PREETHAM_PEREZ_X_COEFFICIENTS[3], turbidity),
+    preetham_fit(PREETHAM_PEREZ_X_COEFFICIENTS[4], turbidity),
+  );
+}
+
+fn preetham_small_y_coefficients(turbidity: f32) -> PreethamPerezCoefficients {
+  return PreethamPerezCoefficients(
+    preetham_fit(PREETHAM_PEREZ_SMALL_Y_COEFFICIENTS[0], turbidity),
+    preetham_fit(PREETHAM_PEREZ_SMALL_Y_COEFFICIENTS[1], turbidity),
+    preetham_fit(PREETHAM_PEREZ_SMALL_Y_COEFFICIENTS[2], turbidity),
+    preetham_fit(PREETHAM_PEREZ_SMALL_Y_COEFFICIENTS[3], turbidity),
+    preetham_fit(PREETHAM_PEREZ_SMALL_Y_COEFFICIENTS[4], turbidity),
+  );
+}
+
+fn preetham_perez(
+  theta: f32,
+  gamma: f32,
+  coefficients: PreethamPerezCoefficients,
+) -> f32 {
+  let safeCosTheta = max(cos(theta), 0.01);
+  let cosGamma = cos(max(gamma, 0.0));
+  let horizon = 1.0 + coefficients.a * exp(coefficients.b / safeCosTheta);
+  let circumsolar = 1.0 + coefficients.c * exp(coefficients.d * max(gamma, 0.0)) +
+    coefficients.e * cosGamma * cosGamma;
+  return max(horizon * circumsolar, PREETHAM_YXY_EPSILON);
+}
+
+fn preetham_relative_perez(
+  theta: f32,
+  gamma: f32,
+  sunTheta: f32,
+  coefficients: PreethamPerezCoefficients,
+) -> f32 {
+  let numerator = preetham_perez(theta, gamma, coefficients);
+  let zenith = preetham_perez(0.0, sunTheta, coefficients);
+  return numerator / max(zenith, PREETHAM_YXY_EPSILON);
+}
+
+fn preetham_zenith_yxy(sunTheta: f32, turbidity: f32) -> vec3<f32> {
+  let theta2 = sunTheta * sunTheta;
+  let theta3 = theta2 * sunTheta;
+  let turbidity2 = turbidity * turbidity;
+  let chi = (4.0 / 9.0 - turbidity / 120.0) * (PREETHAM_PI - 2.0 * sunTheta);
+  let Y = (4.0453 * turbidity - 4.9710) * tan(chi) -
+    0.2155 * turbidity + 2.4192;
+  let x =
+    (0.00165 * theta3 - 0.00374 * theta2 + 0.00208 * sunTheta) * turbidity2 +
+    (-0.02902 * theta3 + 0.06377 * theta2 - 0.03202 * sunTheta + 0.00394) * turbidity +
+    (0.11693 * theta3 - 0.21196 * theta2 + 0.06052 * sunTheta + 0.25885);
+  let y =
+    (0.00275 * theta3 - 0.00610 * theta2 + 0.00316 * sunTheta) * turbidity2 +
+    (-0.04214 * theta3 + 0.08970 * theta2 - 0.04153 * sunTheta + 0.00515) * turbidity +
+    (0.15346 * theta3 - 0.26756 * theta2 + 0.06669 * sunTheta + 0.26688);
+  return vec3<f32>(max(Y, 0.0), clamp(x, 0.0, 1.0), clamp(y, PREETHAM_YXY_EPSILON, 1.0));
+}
+
+// Evaluate one HDR sky direction. Preetham Y is kcd/m2, so the 0.01 factor
+// maps it to renderer radiance per a 100,000-lux daylight reference. The
+// authoring Rayleigh/Mie controls remain bounded relative gains around the
+// complete Perez Y/x/y distribution instead of replacing its chromaticity.
+fn preetham_sky_radiance(
+  viewDirection: vec3<f32>,
+  sunDirection: vec3<f32>,
+  sunColor: vec3<f32>,
+  sunIlluminance: f32,
+  turbidity: f32,
+  rayleigh: f32,
+  mieCoefficient: f32,
+  mieDirectionalG: f32,
+) -> vec3<f32> {
+  let horizonClampedView = vec3<f32>(
+    viewDirection.x,
+    max(viewDirection.y, 0.0),
+    viewDirection.z,
+  );
+  let view = horizonClampedView /
+    max(length(horizonClampedView), PREETHAM_YXY_EPSILON);
+  let sun = sunDirection / max(length(sunDirection), PREETHAM_YXY_EPSILON);
+  let theta = acos(clamp(view.y, 0.0, 1.0));
+  let sunTheta = acos(clamp(sun.y, 0.0, 1.0));
+  let sunAlignment = clamp(dot(view, sun), -1.0, 1.0);
+  let gamma = acos(sunAlignment);
+  let safeTurbidity = clamp(turbidity, 1.0, 20.0);
+  let zenithYxy = preetham_zenith_yxy(sunTheta, safeTurbidity);
+  let relativeY = preetham_relative_perez(
+    theta,
+    gamma,
+    sunTheta,
+    preetham_y_coefficients(safeTurbidity),
+  );
+  let relativeX = preetham_relative_perez(
+    theta,
+    gamma,
+    sunTheta,
+    preetham_x_coefficients(safeTurbidity),
+  );
+  let relativeSmallY = preetham_relative_perez(
+    theta,
+    gamma,
+    sunTheta,
+    preetham_small_y_coefficients(safeTurbidity),
+  );
+  let forward = pow(max(sunAlignment, 0.0), mix(2.0, 32.0, clamp(mieDirectionalG, 0.0, 0.999)));
+  let mediumGain = max(rayleigh, 0.0) + max(mieCoefficient, 0.0) * 40.0 * (0.25 + forward);
+  let luminance = zenithYxy.x * relativeY * max(sunIlluminance, 0.0) * 0.01 * mediumGain;
+  let yxy = vec3<f32>(
+    max(luminance, 0.0),
+    clamp(zenithYxy.y * relativeX, 0.0, 1.0),
+    clamp(zenithYxy.z * relativeSmallY, PREETHAM_YXY_EPSILON, 1.0),
+  );
+  let tintStrength = 0.08 + 0.32 * pow(max(sunAlignment, 0.0), 4.0);
+  let skyTint = mix(
+    vec3<f32>(1.0),
+    max(sunColor, vec3<f32>(0.0)),
+    tintStrength,
+  );
+  let daylight = preetham_yxy_to_linear_srgb(yxy) * skyTint;
+  // Preetham is a daylight model. Below the civil-twilight boundary, blend to
+  // a bounded blue night gradient instead of extrapolating Perez into the
+  // characteristic green/purple failure that the model cannot represent.
+  let daylightWeight = smoothstep(-0.12, 0.02, sun.y);
+  let nightHorizon = vec3<f32>(0.008, 0.012, 0.024);
+  let nightZenith = vec3<f32>(0.0015, 0.004, 0.016);
+  let night = mix(nightHorizon, nightZenith, pow(clamp(view.y, 0.0, 1.0), 0.35));
+  return preetham_finite_guard(mix(night, daylight, daylightWeight));
+}

package/src/bloom-blur.wgsl

@@ -0,0 +1,89 @@
+#define_import_path forgeax_view::bloom_blur
+
+// @forgeax/engine-shader - bloom-blur.wgsl
+// (feat-20260531-bloom-first-declarative-render-graph-pass / w7).
+//
+// Fragment-stage separable Gaussian blur: 5-weight kernel (radius 4,
+// 9 taps per pass -- centre + 4 left + 4 right) sampled via
+// textureSampleLevel(tex, samp, uv, 0.0) for uniform-control-flow safety.
+//
+// Design (plan-strategy D-1, D-4): NO if(horizontal) branch in this
+// shader. The axis direction is baked per-pipeline at assembly by the
+// host: the H-pipeline passes texelSize=(1/textureW, 0), the V-pipeline
+// passes texelSize=(0, 1/textureH). The shader always applies the same
+// offset loop -- the direction emerges from the UBO texelSize parameter.
+//
+// Kernel weights (LO 5.7, radius 4, sigma ~1.0):
+//   centre: 0.227027
+//   +-1:    0.1945946
+//   +-2:    0.1216216
+//   +-3:    0.054054
+//   +-4:    0.016216
+//   Sum: ~0.99854 (truncated Gaussian slight darkening is normal).
+//
+// The radius parameter (1.0-4.0 clamped) controls how many taps are
+// active: floor-clamp(radius) selects the range index [1,4], with the
+// centre weight renormalised to keep the sum near 1.0.
+//
+// Vertex stage: imports the SSOT fullscreen_triangle() from
+// forgeax_view::common (single large triangle).
+//
+// Bindings (group 0):
+//   @binding(0) src    : texture_2d<f32>   -- sampled input texture
+//   @binding(1) samp   : sampler           -- filterable sampler
+//   @binding(2) params : BloomBlurParams (UBO) -- texelSize + radius (16B std140)
+//
+// Content marker (marker triage): bloomBlurDir
+// linearHdrColorDomain: bloom samples and writes linear HDR values only.
+
+#import forgeax_view::common::FullscreenOutput
+#import forgeax_view::common::fullscreen_triangle
+
+struct BloomBlurParams {
+  texelSizeX : f32,
+  texelSizeY : f32,
+  radius     : f32,
+  pad0       : f32,
+};
+
+@group(0) @binding(0) var src  : texture_2d<f32>;
+@group(0) @binding(1) var samp : sampler;
+@group(0) @binding(2) var<uniform> params : BloomBlurParams;
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertex_index : u32) -> FullscreenOutput {
+  return fullscreen_triangle(vertex_index);
+}
+
+@fragment
+fn fs_main(in : FullscreenOutput) -> @location(0) vec4<f32> {
+  let texelSize : vec2<f32> = vec2<f32>(params.texelSizeX, params.texelSizeY);
+  let r : f32 = clamp(params.radius, 1.0, 4.0);
+  let center : vec3<f32> = textureSampleLevel(src, samp, in.uv, 0.0).rgb;
+  var result : vec3<f32> = center * 0.227027;
+  // bloomBlurDir
+  result += textureSampleLevel(src, samp, in.uv + texelSize * 1.0, 0.0).rgb * 0.1945946;
+  result += textureSampleLevel(src, samp, in.uv - texelSize * 1.0, 0.0).rgb * 0.1945946;
+  if r >= 2.0 {
+    result += textureSampleLevel(src, samp, in.uv + texelSize * 2.0, 0.0).rgb * 0.1216216;
+    result += textureSampleLevel(src, samp, in.uv - texelSize * 2.0, 0.0).rgb * 0.1216216;
+  } else {
+    result += center * 0.1216216;
+    result += center * 0.1216216;
+  }
+  if r >= 3.0 {
+    result += textureSampleLevel(src, samp, in.uv + texelSize * 3.0, 0.0).rgb * 0.054054;
+    result += textureSampleLevel(src, samp, in.uv - texelSize * 3.0, 0.0).rgb * 0.054054;
+  } else {
+    result += center * 0.054054;
+    result += center * 0.054054;
+  }
+  if r >= 4.0 {
+    result += textureSampleLevel(src, samp, in.uv + texelSize * 4.0, 0.0).rgb * 0.016216;
+    result += textureSampleLevel(src, samp, in.uv - texelSize * 4.0, 0.0).rgb * 0.016216;
+  } else {
+    result += center * 0.016216;
+    result += center * 0.016216;
+  }
+  return vec4<f32>(result, 1.0);
+}

package/src/bloom-bright.wgsl

@@ -0,0 +1,50 @@
+#define_import_path forgeax_view::bloom_bright
+
+// @forgeax/engine-shader - bloom-bright.wgsl
+// (feat-20260531-bloom-first-declarative-render-graph-pass / w6).
+//
+// Fragment-stage bright-pass: extracts pixels whose Rec.709 relative
+// luminance exceeds the threshold parameter, outputting to a 1/2-res
+// rgba16float intermediate texture. Pixels below threshold are zeroed.
+//
+// Vertex stage: imports the SSOT fullscreen_triangle() from
+// forgeax_view::common (single large triangle).
+//
+// Fragment stage: computes Rec.709 luminance via
+//   L = dot(rgb, vec3(0.2126, 0.7152, 0.0722))
+// and outputs rgb when L > threshold else vec3(0).
+//
+// Bindings (group 0):
+//   @binding(0) hdrColor : texture_2d<f32>   -- sampled HDR color attachment
+//   @binding(1) samp     : sampler           -- filterable sampler
+//   @binding(2) params   : BloomBrightParams (UBO) -- threshold + pad (16B std140)
+//
+// Content marker (marker triage): bloomBrightExtract
+
+#import forgeax_view::common::FullscreenOutput
+#import forgeax_view::common::fullscreen_triangle
+
+struct BloomBrightParams {
+  threshold : f32,
+  pad0      : f32,
+  pad1      : f32,
+  pad2      : f32,
+};
+
+@group(0) @binding(0) var hdrColor : texture_2d<f32>;
+@group(0) @binding(1) var samp     : sampler;
+@group(0) @binding(2) var<uniform> params : BloomBrightParams;
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertex_index : u32) -> FullscreenOutput {
+  return fullscreen_triangle(vertex_index);
+}
+
+@fragment
+fn fs_main(in : FullscreenOutput) -> @location(0) vec4<f32> {
+  let color : vec3<f32> = textureSampleLevel(hdrColor, samp, in.uv, 0.0).rgb;
+  let luma : f32 = dot(color, vec3<f32>(0.2126, 0.7152, 0.0722));
+  // bloomBrightExtract
+  let bright : vec3<f32> = select(vec3<f32>(0.0), color, luma > params.threshold);
+  return vec4<f32>(bright, 1.0);
+}

package/src/bloom-composite.wgsl

@@ -0,0 +1,54 @@
+#define_import_path forgeax_view::bloom_composite
+
+// @forgeax/engine-shader - bloom-composite.wgsl
+// (feat-20260531-bloom-first-declarative-render-graph-pass / w8).
+//
+// Fragment-stage additive HDR composite: blends the blurred bloom result
+// back onto the original HDR scene color before tone mapping.
+//
+// Formula (LO 5.7 + intensity parameter):
+//   hdrOut = hdrScene + intensity * bloomBlurV
+//
+// This pass runs at full resolution. The blurred bloom texture is at 1/2
+// resolution but textureSampleLevel with bilinear filtering naturally
+// upsamples to the full-resolution render target.
+//
+// Vertex stage: imports the SSOT fullscreen_triangle() from
+// forgeax_view::common (single large triangle).
+//
+// Bindings (group 0):
+//   @binding(0) hdrColor   : texture_2d<f32>   -- original HDR scene color
+//   @binding(1) bloomBlurV : texture_2d<f32>   -- blurred bloom (V-pass output)
+//   @binding(2) samp       : sampler           -- filterable sampler
+//   @binding(3) params     : BloomCompositeParams (UBO) -- intensity + pad (16B std140)
+//
+// Content marker (marker triage): bloomComposite
+
+#import forgeax_view::common::FullscreenOutput
+#import forgeax_view::common::fullscreen_triangle
+
+struct BloomCompositeParams {
+  intensity : f32,
+  pad0      : f32,
+  pad1      : f32,
+  pad2      : f32,
+};
+
+@group(0) @binding(0) var hdrColor   : texture_2d<f32>;
+@group(0) @binding(1) var bloomBlurV : texture_2d<f32>;
+@group(0) @binding(2) var samp       : sampler;
+@group(0) @binding(3) var<uniform> params : BloomCompositeParams;
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertex_index : u32) -> FullscreenOutput {
+  return fullscreen_triangle(vertex_index);
+}
+
+@fragment
+fn fs_main(in : FullscreenOutput) -> @location(0) vec4<f32> {
+  let scene : vec3<f32> = textureSampleLevel(hdrColor, samp, in.uv, 0.0).rgb;
+  let bloom : vec3<f32> = textureSampleLevel(bloomBlurV, samp, in.uv, 0.0).rgb;
+  // bloomComposite
+  let result : vec3<f32> = scene + params.intensity * bloom;
+  return vec4<f32>(result, 1.0);
+}

package/src/brdf.wgsl

@@ -0,0 +1,25 @@
+#define_import_path forgeax_pbr::brdf
+
+// @forgeax/engine-shader - brdf.wgsl (M5 T-18 feat-20260512-naga-oil-composition-hmr).
+//
+// Cook-Torrance BRDF helpers (D_GGX + V_SmithCorrelated + F_Schlick)
+// extracted from pbr.wgsl via naga_oil #define_import_path / #import
+// (D-04 moduleId convention). Pure helpers, no bindings, no state -
+// safe to reuse from any material shader that needs microfacet specular.
+
+fn d_ggx(nDotH : f32, a : f32) -> f32 {
+  let a2 = a * a;
+  let f = (nDotH * a2 - nDotH) * nDotH + 1.0;
+  return a2 / (3.14159265 * f * f);
+}
+
+fn v_smith(nDotV : f32, nDotL : f32, a : f32) -> f32 {
+  let a2 = a * a;
+  let gv = nDotL * sqrt(nDotV * nDotV * (1.0 - a2) + a2);
+  let gl = nDotV * sqrt(nDotL * nDotL * (1.0 - a2) + a2);
+  return 0.5 / max(gv + gl, 1e-5);
+}
+
+fn f_schlick(vDotH : f32, f0 : vec3<f32>) -> vec3<f32> {
+  return f0 + (vec3<f32>(1.0) - f0) * pow(1.0 - vDotH, 5.0);
+}