@forgeax/engine-shader 0.1.19 → 0.1.20

package/src/unlit.wgsl

@@ -1,7 +1,6 @@
 #define_import_path forgeax_material::unlit
-#import forgeax_view::common::{View, FogViewParams, FogRay, Mesh, InstanceData, view, meshes, instances, sampleMaterialTextureLinear}
+#import forgeax_view::common::{View, Mesh, InstanceData, view, meshes, instances, sampleMaterialTextureLinear}
 #import forgeax_scene_temporal::{packSceneTemporalV1}
-#import forgeax_view::fog::{apply_fog}
 
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
 #pragma variant_axis VERTEX_COLOR_AVAILABLE
@@ -101,22 +100,6 @@ fn materialVertexColor(in : VsOut) -> vec4<f32> {
 #endif
 }
 
-fn applySceneFog(viewParams : View, color : vec3<f32>, alpha : f32, worldPos : vec3<f32>) -> vec4<f32> {
-  var origin = viewParams.cameraPos;
-  var direction = normalize(worldPos - origin);
-  var rayDistance = length(worldPos - origin);
-  if (viewParams.temporalProjection.z >= 0.5) {
-    let nearH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 0.0, 1.0);
-    let farH = viewParams.inverseViewProj * vec4<f32>(0.0, 0.0, 1.0, 1.0);
-    let nearPoint = nearH.xyz / nearH.w;
-    let farPoint = farH.xyz / farH.w;
-    direction = normalize(farPoint - nearPoint);
-    origin = worldPos - direction * dot(worldPos - viewParams.cameraPos, direction);
-    rayDistance = max(dot(worldPos - origin, direction), 0.0);
-  }
-  return apply_fog(viewParams.fog, FogRay(origin, direction, rayDistance), vec4<f32>(color, alpha));
-}
-
 @fragment
 fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   let texSample = sampleMaterialTextureLinear(baseColorTexture, baseColorSampler, in.uv, material.baseColorTextureCoordinatesMetadata.zw);
@@ -125,12 +108,7 @@ fn fs_main(in : VsOut) -> @location(0) vec4<f32> {
   if (material.alphaCutoff > 0.0 && alpha < material.alphaCutoff) {
     discard;
   }
-  return applySceneFog(
-    view,
-    material.baseColor.rgb * texSample.rgb * vertexColor.rgb,
-    alpha,
-    in.worldPos,
-  );
+  return vec4<f32>(material.baseColor.rgb * texSample.rgb * vertexColor.rgb, alpha);
 }
 
 struct TemporalVsOut {

package/src/volume/volume-composite.wgsl

@@ -0,0 +1,113 @@
+#define_import_path forgeax_view::volume_composite
+// This is a view-UBO projection, not a second matrix source. The fields and
+// padding preserve common::View camera/inverse-projection byte offsets.
+struct VolumeDepthView {
+  _prefix : array<vec4<f32>, 6>,
+  cameraPos : vec4<f32>,
+  _lightViewProjA : mat4x4<f32>,
+  inverseViewProj : mat4x4<f32>,
+};
+
+struct VolumeOutput {
+  @builtin(position) position : vec4<f32>,
+  @location(0) uv : vec2<f32>,
+};
+
+@group(0) @binding(0) var resolved_volume : texture_2d<f32>;
+@group(0) @binding(1) var volume_sampler : sampler;
+@group(0) @binding(2) var scene_depth : texture_depth_2d;
+@group(0) @binding(3) var<uniform> volume_view : VolumeDepthView;
+
+@vertex
+fn volume_vs(@builtin(vertex_index) index : u32) -> VolumeOutput {
+  var positions = array<vec2<f32>, 3>(
+    vec2<f32>(-1.0, -1.0),
+    vec2<f32>(3.0, -1.0),
+    vec2<f32>(-1.0, 3.0),
+  );
+  var output : VolumeOutput;
+  output.position = vec4<f32>(positions[index], 0.0, 1.0);
+  output.uv = vec2<f32>(
+    positions[index].x * 0.5 + 0.5,
+    0.5 - positions[index].y * 0.5,
+  );
+  return output;
+}
+
+fn composite_resolved_volume(sample : vec4<f32>) -> vec4<f32> {
+  let transmittance = clamp(sample.a, 0.0, 1.0);
+  return vec4<f32>(sample.rgb, 1.0 - transmittance);
+}
+
+fn linear_scene_depth(uv : vec2<f32>) -> f32 {
+  let dimensions = max(vec2<f32>(textureDimensions(scene_depth)), vec2<f32>(1.0));
+  let pixel = vec2<i32>(clamp(uv * dimensions, vec2<f32>(0.0), dimensions - vec2<f32>(1.0)));
+  let device_depth = textureLoad(scene_depth, pixel, 0);
+  // WebGPU's framebuffer Y is opposite the view UBO's NDC Y.
+  let clip = vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, device_depth, 1.0);
+  let world = volume_view.inverseViewProj * clip;
+  let world_position = world.xyz / max(abs(world.w), 1e-5);
+  return distance(world_position, volume_view.cameraPos.xyz);
+}
+
+fn radiance_luma(sample : vec4<f32>) -> f32 {
+  return max(dot(sample.rgb, vec3<f32>(0.2126, 0.7152, 0.0722)), 0.0);
+}
+
+fn radiance_luma_weight(center : vec4<f32>, neighbor : vec4<f32>) -> f32 {
+  let center_luma = radiance_luma(center);
+  let neighbor_luma = radiance_luma(neighbor);
+  let relative_luma = abs(neighbor_luma - center_luma) /
+    max(max(neighbor_luma, center_luma), 1e-4);
+  return exp(-relative_luma * 8.0);
+}
+
+fn edge_aware_resolved_volume(uv : vec2<f32>) -> vec4<f32> {
+  let dimensions = max(vec2<f32>(textureDimensions(resolved_volume)), vec2<f32>(1.0));
+  let texel = 1.0 / dimensions;
+  let center = textureSampleLevel(resolved_volume, volume_sampler, uv, 0.0);
+  let center_depth = linear_scene_depth(uv);
+  var accumulated = center * 4.0;
+  var total_weight = 4.0;
+  let offsets = array<vec2<f32>, 8>(
+    vec2<f32>(texel.x, 0.0),
+    vec2<f32>(-texel.x, 0.0),
+    vec2<f32>(0.0, texel.y),
+    vec2<f32>(0.0, -texel.y),
+    vec2<f32>(texel.x, texel.y),
+    vec2<f32>(-texel.x, texel.y),
+    vec2<f32>(texel.x, -texel.y),
+    vec2<f32>(-texel.x, -texel.y),
+  );
+  let spatial_weights = array<f32, 8>(2.0, 2.0, 2.0, 2.0, 1.0, 1.0, 1.0, 1.0);
+  for (var index = 0u; index < 8u; index += 1u) {
+    let neighbor_uv = clamp(uv + offsets[index], vec2<f32>(0.0), vec2<f32>(1.0));
+    let neighbor = textureSampleLevel(
+      resolved_volume,
+      volume_sampler,
+      neighbor_uv,
+      0.0,
+    );
+    let neighbor_depth = linear_scene_depth(neighbor_uv);
+    // Relative view-depth rejection keeps the silhouette transition local;
+    // a fixed world-unit threshold creates halos at far occluders.
+    let depth_weight = select(0.0, exp(-abs(neighbor_depth - center_depth) * 0.08),
+      abs(neighbor_depth - center_depth) <= max(center_depth * 0.08, 0.25));
+    // Transmittance is the available edge signal: retain hard depth/occluder
+    // boundaries while reconstructing smooth low-frequency scattering.
+    let edge_weight = spatial_weights[index] * depth_weight * exp(-abs(neighbor.a - center.a) * 6.0) *
+      radiance_luma_weight(center, neighbor);
+    accumulated += neighbor * edge_weight;
+    total_weight += edge_weight;
+  }
+  return accumulated / max(total_weight, 1e-5);
+}
+
+@fragment
+fn volume_fs(input : VolumeOutput) -> @location(0) vec4<f32> {
+  // Injection zeroes samples behind the observed scene depth. Sampling the
+  // cumulative far slice therefore applies the full ray integral while the
+  // depth test remains owned by the injection path.
+  let sample = edge_aware_resolved_volume(input.uv);
+  return composite_resolved_volume(sample);
+}

package/src/volume/volume-inject.wgsl

@@ -0,0 +1,249 @@
+#define_import_path forgeax_view::volume_inject
+#import forgeax_pbr::shadow_pcf::{sample_shadow_2d_kernel}
+#import forgeax_pbr::lighting_attenuation::{projectSpotUv}
+// forgeax_pbr::lighting_punctual exports the surface-equivalent
+// evalVolumePoint and evalVolumeSpot contract; this stage consumes their
+// shared projector and shadow visibility facts without a second light owner.
+
+struct View {
+  worldViewProj : mat4x4<f32>, lightDir : vec3<f32>, lightColor : vec3<f32>, cameraPos : vec3<f32>,
+  lightViewProj_A : mat4x4<f32>, inverseViewProj : mat4x4<f32>, lightViewProj_B : mat4x4<f32>,
+  lightViewProj_C : mat4x4<f32>, lightViewProj_D : mat4x4<f32>, splitPlanes : array<vec4<f32>,4>,
+  cascadeCount : f32, cascadeBlend : f32, depthBias : f32, normalBias : f32, pcfKernelSize : f32,
+  spotLightViewProj : array<mat4x4<f32>,4>, temporalCurrentViewProj : mat4x4<f32>,
+  temporalPreviousViewProj : mat4x4<f32>, temporalProjection : vec4<f32>, temporalPreviousCameraPos : vec4<f32>,
+};
+
+@group(0) @binding(3) var shadowMap : texture_depth_2d;
+@group(0) @binding(4) var shadowSampler : sampler_comparison;
+
+struct VolumeParams {
+  bounds_min : vec4<f32>,
+  bounds_max : vec4<f32>,
+  extinction : vec4<f32>,
+  albedo : vec4<f32>,
+  emission : vec4<f32>,
+  light_direction : vec4<f32>,
+  light_color : vec4<f32>,
+  optics : vec4<f32>,
+};
+
+struct SpotLight {
+  position : vec3<f32>,
+  invRangeSquared : f32,
+  colorTimesIntensity : vec3<f32>,
+  cosInner : f32,
+  direction : vec3<f32>,
+  cosOuter : f32,
+  depthBias : f32,
+  normalBias : f32,
+  pcfKernelSize : f32,
+  shadowAtlasTile : i32,
+  shadowIntensity : f32,
+};
+
+struct SpotLightsArray {
+  count : u32,
+  slots : array<SpotLight, 4>,
+};
+
+struct PointLight {
+  position : vec3<f32>,
+  invRangeSquared : f32,
+  colorTimesIntensity : vec3<f32>,
+  shadowAtlasLayer : i32,
+};
+
+struct PointLightsArray {
+  count : u32,
+  slots : array<PointLight, 4>,
+};
+
+@group(0) @binding(5) var<uniform> volume_params : VolumeParams;
+@group(0) @binding(6) var volume_froxel : texture_storage_2d_array<rgba8unorm, write>;
+@group(0) @binding(7) var<storage, read> spotLightsBuffer : SpotLightsArray;
+@group(0) @binding(8) var<storage, read> pointLightsBuffer : PointLightsArray;
+@group(0) @binding(0) var<uniform> view : View;
+
+fn reconstruct_world(uv : vec2<f32>, depth : f32) -> vec3<f32> {
+  // WebGPU NDC depth is already [0, 1]; only XY needs the [-1, 1] remap.
+  let ndc = vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, depth, 1.0);
+  let world = view.inverseViewProj * ndc;
+  return world.xyz / max(abs(world.w), 1e-5);
+}
+
+fn ray_box_interval(
+  origin : vec3<f32>,
+  direction : vec3<f32>,
+  box_min : vec3<f32>,
+  box_max : vec3<f32>,
+) -> vec2<f32> {
+  let safe_direction = select(direction, vec3<f32>(1e-5), abs(direction) < vec3<f32>(1e-5));
+  let reciprocal = 1.0 / safe_direction;
+  let near_point = (box_min - origin) * reciprocal;
+  let far_point = (box_max - origin) * reciprocal;
+  let near_distance = max(max(min(near_point.x, far_point.x), min(near_point.y, far_point.y)), min(near_point.z, far_point.z));
+  let far_distance = min(min(max(near_point.x, far_point.x), max(near_point.y, far_point.y)), max(near_point.z, far_point.z));
+  return vec2<f32>(max(near_distance, 0.0), max(far_distance, near_distance));
+}
+
+fn hash32(value : u32) -> u32 {
+  var hash = value;
+  hash = (hash ^ 61u) ^ (hash >> 16u);
+  hash = hash + (hash << 3u);
+  hash = hash ^ (hash >> 4u);
+  hash = hash * 668265261u;
+  hash = hash ^ (hash >> 15u);
+  return hash;
+}
+
+fn froxel_seed(id : vec3<u32>, salt : u32) -> u32 {
+  return hash32(id.x * 73856093u ^ id.y * 19349663u ^ id.z * 83492791u ^ salt);
+}
+
+fn stratified32(seed : u32, frame_index : u32, odd_stride : u32) -> f32 {
+  let bin = (hash32(seed) + (frame_index & 31u) * odd_stride) & 31u;
+  return (f32(bin) + 0.5) / 32.0;
+}
+
+fn dither_unorm8(value : f32, noise : f32) -> f32 {
+  return clamp(value + (noise - 0.5) / 255.0, 0.0, 1.0);
+}
+
+fn camera_view_depth(world_position : vec3<f32>) -> f32 {
+  let clip = view.temporalCurrentViewProj * vec4<f32>(world_position, 1.0);
+  let ndc_depth = clip.z / max(abs(clip.w), 1e-5);
+  let orthographic_depth = view.temporalProjection.x +
+    ndc_depth * (view.temporalProjection.y - view.temporalProjection.x);
+  return select(max(clip.w, 0.0), max(orthographic_depth, 0.0), view.temporalProjection.z >= 0.5);
+}
+
+fn volume_cascade(world_position : vec3<f32>, view_depth : f32) -> f32 {
+  if (view.cascadeCount < 1.0) { return 1.0; }
+  let count = u32(max(view.cascadeCount, 1.0));
+  if (view_depth > view.splitPlanes[count - 1u].x) { return 1.0; }
+  var layer = count - 1u;
+  for (var index = 0u; index < count - 1u; index = index + 1u) {
+    if (view_depth < view.splitPlanes[index].x) { layer = index; break; }
+  }
+  var light_matrix = view.lightViewProj_D;
+  switch (layer) {
+    case 0u: { light_matrix = view.lightViewProj_A; }
+    case 1u: { light_matrix = view.lightViewProj_B; }
+    case 2u: { light_matrix = view.lightViewProj_C; }
+    default: { }
+  }
+  let clip = light_matrix * vec4<f32>(world_position, 1.0);
+  let projected = clip.xyz / max(abs(clip.w), 1e-5);
+  let columns = select(2u, 1u, count <= 1u);
+  let rows = (count + columns - 1u) / columns;
+  let tile = vec2<u32>(layer % columns, layer / columns);
+  let tile_scale = vec2<f32>(1.0) / vec2<f32>(f32(columns), f32(rows));
+  let tile_uv = vec2<f32>(projected.x * 0.5 + 0.5, -projected.y * 0.5 + 0.5);
+  if (!(tile_uv.x >= 0.0 && tile_uv.x <= 1.0 && tile_uv.y >= 0.0 && tile_uv.y <= 1.0 && projected.z <= 1.0)) { return 1.0; }
+  let uv = tile_uv * tile_scale + vec2<f32>(tile) * tile_scale;
+  let shadow_size = vec2<f32>(textureDimensions(shadowMap));
+  return sample_shadow_2d_kernel(
+    shadowMap, shadowSampler, uv, 1.0 / shadow_size, projected.z,
+    0.0, view.depthBias, 1.0, view.pcfKernelSize,
+  );
+}
+
+fn spot_shadow_visibility_at(world_position : vec3<f32>) -> f32 {
+  let slot = u32(clamp(round(volume_params.light_color.w), 0.0, 3.0));
+  if (slot >= spotLightsBuffer.count) { return 0.0; }
+  let light = spotLightsBuffer.slots[slot];
+  if (light.shadowAtlasTile < 0) { return 1.0; }
+  let tile = u32(light.shadowAtlasTile);
+  let projectorUv = projectSpotUv(view.spotLightViewProj[tile], world_position);
+  // The accepted projector tuple is sampled with textureSampleLevel by the
+  // surface and volume owners when a projector texture is present.
+  let projectorRevision = volume_params.light_color.w;
+  let clip = view.spotLightViewProj[tile] * vec4<f32>(world_position, 1.0);
+  // Shadow filtering is fail-open outside the light frustum. The map owns
+  // occlusion inside its tile; it must not darken samples behind the light or
+  // beyond the far plane, matching the surface SpotLight shadow contract.
+  if (clip.w <= 1e-5) { return 1.0; }
+  let projected = clip.xyz / clip.w;
+  let local_uv = vec2<f32>(projected.x * 0.5 + 0.5, -projected.y * 0.5 + 0.5);
+  if (any(projectorUv < vec2<f32>(0.0)) || any(projectorUv > vec2<f32>(1.0))) { return 1.0; }
+  if (any(local_uv < vec2<f32>(0.0)) || any(local_uv > vec2<f32>(1.0)) || projected.z > 1.0) {
+    return 1.0;
+  }
+  let atlas_uv = local_uv * 0.5 + vec2<f32>(f32(tile & 1u), f32(tile >> 1u)) * 0.5;
+  let shadow_size = vec2<f32>(textureDimensions(shadowMap));
+  return sample_shadow_2d_kernel(
+    shadowMap, shadowSampler, atlas_uv, 1.0 / shadow_size, projected.z,
+    light.normalBias, light.depthBias, 1.0, light.pcfKernelSize,
+  );
+}
+
+fn shadow_visibility_at(ray_origin : vec3<f32>, ray_direction : vec3<f32>, slice : f32) -> f32 {
+  let interval = ray_box_interval(
+    ray_origin,
+    ray_direction,
+    volume_params.bounds_min.xyz,
+    volume_params.bounds_max.xyz,
+  );
+  let ray_near = interval.x;
+  let ray_limit = max(ray_near, min(interval.y, volume_params.optics.x));
+  let ray_t = mix(ray_near, ray_limit, slice);
+  let world_position = ray_origin + ray_direction * ray_t;
+  let in_bounds = all(world_position >= volume_params.bounds_min.xyz) &&
+    all(world_position <= volume_params.bounds_max.xyz) && ray_limit > ray_near;
+  let view_depth = camera_view_depth(world_position);
+  return select(0.0, volume_cascade(world_position, view_depth), in_bounds);
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn volume_inject(@builtin(global_invocation_id) id : vec3<u32>) {
+  let volume_size = textureDimensions(volume_froxel);
+  if (id.x >= volume_size.x || id.y >= volume_size.y) { return; }
+  let froxel_size = vec2<f32>(textureDimensions(volume_froxel).xy);
+  let frame_phase = volume_params.light_direction.w;
+  let frame_index = u32(max(frame_phase, 0.0));
+  let xy_noise = vec2<f32>(
+    stratified32(froxel_seed(id, 2654435761u), frame_index, 5u),
+    stratified32(froxel_seed(id, 2246822519u), frame_index, 11u),
+  ) - vec2<f32>(0.5);
+  let depth_uv = clamp(
+    (vec2<f32>(id.xy) + vec2<f32>(0.5) + xy_noise * 0.75) / froxel_size,
+    vec2<f32>(0.0),
+    vec2<f32>(1.0),
+  );
+  let ray_origin = reconstruct_world(depth_uv, 0.0);
+  let ray_endpoint = reconstruct_world(depth_uv, 1.0);
+  let ray_direction = normalize(ray_endpoint - ray_origin);
+  let interval = ray_box_interval(
+    ray_origin,
+    ray_direction,
+    volume_params.bounds_min.xyz,
+    volume_params.bounds_max.xyz,
+  );
+  let ray_near = interval.x;
+  let ray_limit = max(ray_near, min(interval.y, volume_params.optics.x));
+  let logical_depth = max(textureNumLayers(volume_froxel) * 4u, 1u);
+  var visibility = vec4<f32>(0.0);
+  for (var channel = 0u; channel < 4u; channel = channel + 1u) {
+    let logical_slice = id.z * 4u + channel;
+    if (logical_slice >= logical_depth) { continue; }
+    let slice = clamp((f32(logical_slice) + 0.5) / f32(logical_depth), 0.0, 1.0);
+    let slice_world = ray_origin + ray_direction * mix(ray_near, ray_limit, slice);
+    // A paired Point+Spot volume owns two radiance terms. The spot shadow is
+    // stored for the spot term; the integrate stage applies it only to that
+    // term so PointLight radiance remains visible outside the spot cone.
+    let mode = u32(round(volume_params.optics.z));
+    visibility[channel] = select(
+      shadow_visibility_at(ray_origin, ray_direction, slice),
+      spot_shadow_visibility_at(slice_world),
+      mode == 2u || mode == 3u,
+    );
+  }
+  let visibility_noise = stratified32(froxel_seed(id, 3812015801u), frame_index, 11u);
+  visibility = vec4<f32>(
+    dither_unorm8(visibility.x, visibility_noise),
+    dither_unorm8(visibility.y, visibility_noise),
+    dither_unorm8(visibility.z, visibility_noise),
+    dither_unorm8(visibility.w, visibility_noise));
+  textureStore(volume_froxel, id.xy, id.z, visibility);
+}