// The volumetric fog: the camera's froxel volume, lit and integrated each
// frame. Ported from Godot b130438's
// servers/rendering/renderer_rd/shaders/environment/volumetric_fog_process.glsl
// (MODE_DENSITY, the medium and the light it scatters in each froxel blended
// with the last frame's, MODE_FILTER, a Gaussian across each slice's x and
// then y, and MODE_FOG, the integration front to back),
// environment/volumetric_fog.glsl (a box FogVolume with
// scene/resources/3d/fog_material.cpp's FogMaterial) and environment/fog.cpp
// (volumetric_fog_update), MIT (src/LICENSE-godot.txt), after Hillaire 2015,
// "Physically Based and Unified Volumetric Rendering in Frostbite".
//
// Where it differs from Godot, and why:
// - A froxel reprojects into the last frame's volume through that volume's
// own length, so history carries across a change of covered length: the
// world point's view depth is placed among the slices that length spread
// (fog_volume_coordinate). Godot divides the previous view depth by the
// current length (prev_view.z /= -params.fog_frustum_end), which reads a
// stationary medium from the wrong slice while the length changes.
// - The froxel volume holds the quality's side across the geometric mean of
// the frame's sides (fog.rs froxels): square froxels, as many as Godot's
// split (side × r, side / r, r = width / mean side) gives, each side within
// the device's 3D texture limit, where Godot's are wider than tall and its
// height grows without bound as the frame narrows.
// - The frame's medium, Godot's environment fog, takes a FogMaterial's
// height falloff (uniform by default), so height fog needs no volume.
// - The frame's medium begins Fog::start metres from the eye: injection
// takes its density as zero at a froxel whose (jittered) sample lies
// nearer, so nothing nearer is fogged or scatters light; fog volumes are
// unaffected. SGL3D's own: Godot's volumetric fog has no start. Its depth
// fog's fog_depth_begin (scene_forward_clustered.glsl 1103-1106) ramps a
// non-volumetric fog by smoothstep, and Unreal documents a start distance
// for its height fog; here the density starts hard, since the volume
// integrates density along the ray and what a pixel sees,
// 1 - exp(-density (d - start)) for a uniform medium, already rises
// continuously from the start. A froxel straddling the start takes its
// share of the medium over the jitter cycle through the temporal blend.
// - A fog volume is a box with a FogMaterial's density, albedo and edge
// fade; emission (the frame medium's too), height falloff, density
// textures, negative density and other shapes are not ported. The box's
// 0.1 m cull fade applies under the edge fade too, where Godot drops it
// for a material that reads SDF, so a volume without edge fade still ends
// at its box, where Godot's pow(0, 0) is undefined.
// - Each froxel sums in f32, in the scene's order, the volumes whose froxel
// bounds hold it (fog.cpp's bounds, stages/fog/volume_froxels.rs), where
// Godot dispatches each volume over its bounds into fixed-point atomics:
// no clear, extra pass or packing. Godot's packing drops a volume's
// density at or below 0.001, truncates it to 1/1024, clamps its albedo
// weight to a density of 1 and its scattering to 1, and truncates that
// scattering to 11/11/10 bits (volumetric_fog.glsl's DENSITY_USED); here
// every medium scatters albedo × density, as Godot's environment medium
// does and Hillaire's albedo defines.
// - Albedos are linear RGB, where Godot's fog colours are sRGB it converts.
// - No GI injection: Godot injects VoxelGI and SDFGI, which SGL3D lacks.
// - The lights are SGL3D's, in its units and falloff: the frame's two
// directional lights, one with cascades, and the camera's clustered point,
// spot and rectangle lights, baked ones too, through their records.
// - The cascades take Godot's fog tap (directional_shadow.wgsl) without its
// fade to unshadowed toward the shadow distance: beyond the last cascade
// the medium is unshadowed, as surfaces are, whose cascades have no fade.
// - A local light's shadow is one hardware 2×2 comparison tap
// (shadow_sampling.wgsl), as Bevy's volumetric fog samples its shadow
// maps, without Godot's fade behind the occluder: not ported, as the
// atlas's perspective depth would need linearizing for its metres.
// - A rectangle scatters by the solid angle of its face, π times its form
// factor about the direction to its centre, where Godot's area light takes
// it about the direction to its nearest point and fades it in over 10 cm
// in front of the face. Bounded by π, it needs no 1 m distance clamp,
// which Godot gives area lights against jitter flicker.
// - A point or spot light's inverse square takes in its denominator the
// squared diagonal of the view-space box bounding the froxel the sample
// lies in (light_reach.wgsl), where Godot's omni and spot lights take
// 1/max(d, 0.0001)^attenuation unbounded. One jittered sample of a froxel
// metres deep cannot integrate 1/d² across it: landing centimetres from
// a light, it takes thousands of times the froxel's light, and the
// history holds each spike, so the fog about a still light pulses with
// the jitter and a moving light leaves puffs behind it
// (stevepryde/sgl#262; Hillaire 2015 leaves "moving lights leave trails"
// open). This is Unreal's practice: its volumetric fog adds a bias the
// size of its voxel to the inverse-squared falloff's denominator, which
// "effectively removes the spike from inverse squared falloff that causes
// extreme aliasing" (r.VolumetricFog.InverseSquaredLightDistanceBiasScale,
// 1 by default; practice only, no code). It agrees with the bounded
// falloff the MIT Unity VolumetricLighting sample gives its point lights
// in the fog (b5b0713, Assets/VolumetricFog/Shaders/
// InjectLightingAndDensity.compute PointLights, 1/(1 + 25 d²/range²)). A
// froxel far smaller than its distance to the light keeps the light's
// falloff; within about a froxel's diagonal of the light its fog falls
// short of the inverse square and holds steady, the more so where a long
// fog's slices are metres deep, as Unreal's bias trades it.
// - The ambient is the frame's hemisphere fill and environment diffuse
// averaged over the sphere, which an isotropic phase scatters, where Godot
// samples its sky upward, at a mip chosen by the density, and along the
// view, blended by |g|, mixed with its ambient colour by its sky
// contribution.
// - Froxels lie where the camera's unjittered projection puts them, and in
// the last frame's volume where its view-projection does, so a changing
// projection reprojects too, where Godot interpolates frustum sizes from
// the near plane and reprojects through the camera's transform alone.
// - A froxel without history (the first fog frame, a new size, the camera's
// reset) keeps none, where Godot blends from a cleared volume, so its fog
// fades in, and across a cut.
// - The history alternates two volumes instead of copying one: the filter's
// y pass writes the one the injection has just reprojected, so the history
// stays unfiltered, as Godot copies it before it filters. The filter skips
// froxels outside the volume, whose stores WGSL leaves undefined.
// - Each filter invocation filters a run of 8 froxels along its pass's axis
// from the 14 their taps reach, loading each once, where Godot's
// invocation filters one froxel from 7 loads: 1.75 loads per froxel per
// pass instead of 7.
// Its sums are Godot's, term for term, through the same RGBA16F volume
// between the passes. The runs are SGL3D's own sliding-window reuse of
// the taps neighbouring froxels share; no code is taken from another
// engine. Tiles in workgroup memory, as Godot's screen-space reflection
// filter and Wicked Engine's blur_gaussian_float4CS.hlsl use, measured
// slower than these runs on an Apple M5 (stevepryde/sgl#88).
// - The integration steps along the view ray through each slice, where
// Godot steps the slice's depth, so fog off the view's axis is as dense as
// on it.
// - Nothing fogs under an orthographic camera, which Godot's fog covers:
// froxels are placed by a perspective projection.
// The froxels, first to last, that the scene's fog volume at `volume` in
// fog_volumes reaches (stages/fog/volume_froxels.rs FogVolumeFroxels).
struct FogVolumeFroxels {
first:vec3<u32>,
volume:u32,
last:vec3<u32>,
}
// One frame's froxel volume (stages/fog.rs FroxelVolumeUniform).
struct FroxelVolume {
world_from_view:mat4x4<f32>,
// The last frame's unjittered view-projection.
previous_clip_from_world:mat4x4<f32>,
// The unjittered projection's x and y scales, then its x and y offsets:
// the view point at depth d under frame position ndc is
// ((ndc + offset) * d / scale, -d).
projection:vec4<f32>,
size:vec3<u32>,
// This frame's offset in FOG_HALTON.
frame:u32,
albedo:vec3<f32>,
density:f32,
render_size:vec2<f32>,
length:f32,
detail_spread:f32,
height:f32,
height_falloff:f32,
anisotropy:f32,
// The share of the last frame's volume a froxel keeps where it
// reprojects; 0 without history.
temporal_blend:f32,
// The share of the frame's ambient light the medium scatters.
ambient:f32,
// How many of fog_volume_froxels hold this frame's.
volume_count:u32,
// The view depth in metres the last frame's volume covered, which places
// a reprojected point among its slices.
previous_length:f32,
// How far from the eye the frame's medium begins, metres (Fog::start).
start:f32,
// The integrated volume's slices (shading/fog.wgsl), last.
@align(16) volume_layout:FogLayout,
}
// The most fog volumes a frame's fog sums
// (stages::fog::volume_froxels::MOST_VOLUMES).
const FOG_MOST_VOLUMES:u32=1024u;
// The most depth slices a froxel volume has (AR-12): the top of Godot's
// `rendering/environment/volumetric_fog/volume_depth` range
// (servers/rendering/rendering_server.cpp, revision
// ed1daf0bf001b61586d9930840f2f1394092c079), eight times its default of 64,
// which both of FogQuality's volumes take.
const FOG_MOST_SLICES:u32=512u;
@group(1) @binding(0) var<uniform> froxels:FroxelVolume;
// Injection: the last frame's froxels and the sampler that reprojects them,
// and this frame's.
@group(1) @binding(1) var previous_scattering:texture_3d<f32>;
@group(1) @binding(2) var history_sampler:sampler;
@group(1) @binding(3) var scattering:texture_storage_3d<rgba16float,write>;
@group(1) @binding(6) var<storage,read> fog_volumes:array<FogVolumeRecord>;
@group(1) @binding(9) var<storage,read> fog_volume_froxels:array<FogVolumeFroxels>;
// Filter: the froxels one pass reads and writes, and Godot's params.filter_axis
// (0 x, 1 y) it filters along.
@group(1) @binding(7) var source_map:texture_3d<f32>;
@group(1) @binding(8) var dest_map:texture_storage_3d<rgba16float,write>;
override filter_axis:u32=0u;
// Integration: this frame's froxels and the volume it integrates them into,
// and the sky stage's aerial volume (stages/sky/aerial_view_lut.wgsl) and its
// sampler, which it composes the fog over while aerial perspective is in
// effect.
@group(1) @binding(4) var integrate_scattering:texture_3d<f32>;
@group(1) @binding(5) var integrated:texture_storage_3d<rgba16float,write>;
@group(1) @binding(10) var aerial_volume:texture_3d<f32>;
@group(1) @binding(11) var aerial_sampler:sampler;
// Godot's halton_map: where in its froxel each frame samples while the
// froxel reprojects.
const FOG_HALTON:array<vec3<f32>,16>=array(
vec3(.5,.33333333,.2),
vec3(.25,.66666667,.4),
vec3(.75,.11111111,.6),
vec3(.125,.44444444,.8),
vec3(.625,.77777778,.04),
vec3(.375,.22222222,.24),
vec3(.875,.55555556,.44),
vec3(.0625,.88888889,.64),
vec3(.5625,.03703704,.84),
vec3(.3125,.37037037,.08),
vec3(.8125,.7037037,.28),
vec3(.1875,.14814815,.48),
vec3(.6875,.48148148,.68),
vec3(.4375,.81481481,.88),
vec3(.9375,.25925926,.12),
vec3(.03125,.59259259,.32),
);
// The fog energy at or below which Godot leaves a light out of the medium,
// shadow lookup and all (volumetric_fog_process.glsl's light loops).
const FOG_ENERGY_CUTOFF:f32=.001;
fn henyey_greenstein(cos_theta:f32,g:f32)->f32 {
// 1 / (4 * PI)
let k=.0795774715459;
return k*(1.-g*g)/pow(1.+g*g-2.*g*cos_theta,1.5);
}
// shading/fog.wgsl's column ray through this frame's projection.
fn froxel_view_position(ndc:vec2<f32>,depth:f32)->vec3<f32> {
return fog_froxel_view_position(froxels.projection,ndc,depth);
}
// The world position at a froxel's unit coordinates.
fn froxel_world(unit:vec3<f32>)->vec3<f32> {
let depth=fog_slice_depth(unit.z,froxels.length,froxels.detail_spread);
return (froxels.world_from_view*vec4(froxel_view_position(fog_froxel_ndc(unit.xy),depth),1.)).xyz;
}
// The frame's ambient light that an isotropic medium scatters: the mean of
// the radiance from every direction. The hemisphere fill and environment
// diffuse each give a surface's diffuse radiance for its normal, so the mean
// of an upward and a downward one's is the sphere's for light that varies
// with height alone.
fn fog_ambient()->vec3<f32> {
let up=vec3(0.,1.,0.);
let sky=frame.hemisphere_sky_color;
let ground=frame.hemisphere_ground_color;
let intensity=frame.hemisphere_intensity;
let hemisphere=(pbr_hemisphere(up,sky,ground,intensity)+pbr_hemisphere(-up,sky,ground,intensity))/(2.*3.14159265359);
return hemisphere+(diffuse_environment(up)+diffuse_environment(-up))*.5;
}
// The solid angle of rectangle `rect`'s face from a point `toward` its
// centre: the face's form factor about that direction, times PI.
fn fog_rect_solid_angle(rect:Light,position:vec3<f32>,toward:vec3<f32>)->f32 {
let identity=mat3x3(vec3(1.,0.,0.),vec3(0.,1.,0.),vec3(0.,0.,1.));
let face=rect_light_frame(toward,toward,rect.position-position,rect.half_width,light_rect_half_height(rect));
return 3.14159265359*ltc_integrate_quad(face,identity);
}
// The density fog volume `volume` adds at `position`: Godot's box FogVolume
// (its signed distance and cull mask) with its FogMaterial's edge fade.
fn fog_volume_density(volume:FogVolumeRecord,position:vec3<f32>)->f32 {
let offset=position-volume.center;
if dot(offset,offset)>volume.radius_squared {
return 0.;
}
let local=(volume.local_from_world*vec4(position,1.)).xyz;
let q=abs(local)-volume.half_size;
let sdf=length(max(q,vec3(0.)))+min(max(q.x,max(q.y,q.z)),0.);
var density=volume.density*(1.-smoothstep(-.1,0.,sdf));
if volume.edge_fade>0. {
let side=min(volume.half_size.x,min(volume.half_size.y,volume.half_size.z));
density*=pow(clamp(-sdf/side,0.,1.),volume.edge_fade);
}
return density;
}
// What scene light `index` scatters toward the camera, along `view_ray`,
// per unit of scattering at a point in the medium of a froxel whose squared
// diagonal is `froxel_square` and whose extent across the frame is
// `froxel_dx` and `froxel_dy` (world metres), which select a spot cookie's
// level as a surface's screen derivatives do: none, without a shadow
// lookup, at a fog energy Godot skips.
fn fog_scene_light(index:u32,position:vec3<f32>,view_ray:vec3<f32>,pixel:vec2<f32>,froxel_square:f32,froxel_dx:vec3<f32>,froxel_dy:vec3<f32>)->vec3<f32> {
let fog_energy=lights[index].fog_energy;
if fog_energy<=FOG_ENERGY_CUTOFF {
return vec3(0.);
}
let sample=scene_light_sample(index,position,vec3(0.),vec3(0.),vec3(0.),pixel,SHADOW_RECEIVER_MEDIUM,false,position,froxel_square,froxel_dx,froxel_dy);
if sample.visibility<=0. {
return vec3(0.);
}
var light=sample.radiance*sample.visibility;
if sample.rect!=NO_RECT_LIGHT {
light*=fog_rect_solid_angle(lights[sample.rect],position,sample.direction);
}
return light*henyey_greenstein(dot(view_ray,sample.direction),froxels.anisotropy)*fog_energy;
}
// The ambient light the medium scatters, the same at every froxel: one
// invocation of each workgroup samples it.
var<workgroup> fog_ambient_light:vec3<f32>;
// Each froxel's extinction (a) and the light its medium scatters toward the
// camera per metre (rgb), blended with where it was in the last frame's.
@compute @workgroup_size(4,4,4) fn inject(@builtin(global_invocation_id) id:vec3<u32>,@builtin(local_invocation_index) local:u32) {
if local==0u {
fog_ambient_light=fog_ambient()*froxels.ambient;
}
workgroupBarrier();
if any(id>=froxels.size) {
return;
}
let size=vec3<f32>(froxels.size);
var unit=(vec3<f32>(id)+vec3(.5))/size;
var reprojected=vec4(0.);
var reproject_amount=0.;
if froxels.temporal_blend>0. {
let previous=froxels.previous_clip_from_world*vec4(froxel_world(unit),1.);
// The last frame's clip w is its view depth.
if previous.w>0. {
let previous_uv=vec2(previous.x,-previous.y)/previous.w*.5+vec2(.5);
let previous_unit=fog_froxel_coordinate(previous_uv,previous.w,1./froxels.previous_length,1./froxels.detail_spread);
if all(previous_unit>vec3(0.)) && all(previous_unit<vec3(1.)) {
reprojected=textureSampleLevel(previous_scattering,history_sampler,previous_unit,0.);
reproject_amount=froxels.temporal_blend;
// Only a froxel that reprojects jitters.
unit=(vec3<f32>(id)+FOG_HALTON[froxels.frame])/size;
}
}
}
let position=froxel_world(unit);
let view_ray=normalize(position-view.eye);
let pixel=unit.xy*froxels.render_size;
// The frame's medium, absent nearer the eye than its start.
let medium=select(froxels.density,0.,distance(position,view.eye)<froxels.start);
var density=medium*clamp(exp2(-froxels.height_falloff*(position.y-froxels.height)),0.,1.);
// The scattering: each medium's albedo weighted by its density, as Godot
// weights its environment medium's.
var albedo=froxels.albedo*density;
// At most FOG_MOST_VOLUMES, all within the bound list, so the loop ends
// whatever the count says (AR-12).
let volume_count=min(min(froxels.volume_count,FOG_MOST_VOLUMES),arrayLength(&fog_volume_froxels));
for(var index=0u;index<volume_count;index++) {
let reached=fog_volume_froxels[index];
if any(id<reached.first) || any(id>reached.last) {
continue;
}
let volume=fog_volumes[reached.volume];
let added=fog_volume_density(volume,position);
density+=added;
albedo+=volume.albedo*added;
}
var light=vec3(0.);
if density>.00005 {
for(var index=0u;index<FRAME_DIRECTIONAL_LIGHTS;index++) {
let directional=frame.directional_lights[index];
if directional.illuminance<=0. || directional.fog_energy<=FOG_ENERGY_CUTOFF {
continue;
}
let toward=normalize(directional.direction_to_light);
let shadow=directional_light_shadow(index,position,vec3(0.),pixel,SHADOW_RECEIVER_MEDIUM,false);
light+=directional.color*directional.illuminance*shadow*henyey_greenstein(dot(view_ray,toward),froxels.anisotropy)*directional.fog_energy;
}
light+=fog_ambient_light;
// The squared diagonal of the froxel's bounding box in view space: its
// depth between its slice's ends, and across the frame, on each axis, the
// extent of its corners at both ends, which the frustum shears apart off
// its axis, so the bias is as large wherever the froxel lies on screen.
let z0=fog_slice_depth(f32(id.z)/size.z,froxels.length,froxels.detail_spread);
let z1=fog_slice_depth(f32(id.z+1u)/size.z,froxels.length,froxels.detail_spread);
let n0=fog_froxel_ndc(vec2<f32>(id.xy)/size.xy)+froxels.projection.zw;
let n1=fog_froxel_ndc(vec2<f32>(id.xy+vec2(1u))/size.xy)+froxels.projection.zw;
let high=max(max(n0*z0,n0*z1),max(n1*z0,n1*z1));
let low=min(min(n0*z0,n0*z1),min(n1*z0,n1*z1));
let lateral=(high-low)/froxels.projection.xy;
let froxel_square=dot(lateral,lateral)+(z1-z0)*(z1-z0);
// Its extent across the frame at the point's depth, along the view's
// right and up, in the world: a spot cookie's footprint, so the level it
// samples matches the froxel.
let extent=abs(n1-n0)*fog_slice_depth(unit.z,froxels.length,froxels.detail_spread)/froxels.projection.xy;
let froxel_dx=(froxels.world_from_view*vec4(extent.x,0.,0.,0.)).xyz;
let froxel_dy=(froxels.world_from_view*vec4(0.,extent.y,0.,0.)).xyz;
let range=cluster_range(position,pixel);
let end=range.first+range.live+range.baked;
for(var at=range.first;at<end;at++) {
light+=fog_scene_light(cluster_item(at),position,view_ray,pixel,froxel_square,froxel_dx,froxel_dy);
}
}
var froxel=vec4(light*albedo,density);
if !all_finite(froxel) {
froxel=select(vec4(0.),reprojected,all_finite(reprojected));
} else if all_finite(reprojected) {
froxel=mix(froxel,reprojected,reproject_amount);
}
textureStore(scattering,id,clamp(froxel,vec4(0.),vec4(65504.)));
}
// Godot's MODE_FILTER sum: the 7-tap Gaussian of the froxels from three
// before a froxel along filter_axis to three after it, in Godot's order.
fn filter_gauss(t0:vec4<f32>,t1:vec4<f32>,t2:vec4<f32>,t3:vec4<f32>,t4:vec4<f32>,t5:vec4<f32>,t6:vec4<f32>) -> vec4<f32> {
const gauss=array<f32,7>(.071303,.131514,.189879,.214607,.189879,.131514,.071303);
var accum=vec4(0.);
accum+=t0*gauss[0];
accum+=t1*gauss[1];
accum+=t2*gauss[2];
accum+=t3*gauss[3];
accum+=t4*gauss[4];
accum+=t5*gauss[5];
accum+=t6*gauss[6];
return accum;
}
// Godot's MODE_FILTER: each froxel's 7-tap Gaussian along filter_axis of
// this frame's froxels, clamped to the volume's edges. Each invocation
// filters the 8 froxels from pos along the axis (stages/fog.rs FILTER_RUN)
// from the 14 their taps reach, each loaded once. The taps are written out:
// a loop over an array of them measured nearly 3× slower. Each tap clamps
// to the volume itself, the far edge too: an out-of-range textureLoad
// returns zero or an implementation-defined texel on Vulkan, D3D12 and
// WebGPU, and only Metal (naga's Restrict policy) clamps it.
@compute @workgroup_size(8,8,1) fn filter_froxels(@builtin(global_invocation_id) id:vec3<u32>) {
const filter_dir=array(vec3(1,0,0),vec3(0,1,0),vec3(0,0,1));
let offset=filter_dir[filter_axis];
let last=vec3<i32>(froxels.size)-vec3(1);
let pos=vec3<i32>(id)*(vec3(1)+offset*7);
if any(pos>last) {
return;
}
let t0=textureLoad(source_map,clamp(pos-offset*3,vec3(0),last),0);
let t1=textureLoad(source_map,clamp(pos-offset*2,vec3(0),last),0);
let t2=textureLoad(source_map,clamp(pos-offset,vec3(0),last),0);
let t3=textureLoad(source_map,pos,0);
let t4=textureLoad(source_map,clamp(pos+offset,vec3(0),last),0);
let t5=textureLoad(source_map,clamp(pos+offset*2,vec3(0),last),0);
let t6=textureLoad(source_map,clamp(pos+offset*3,vec3(0),last),0);
let t7=textureLoad(source_map,clamp(pos+offset*4,vec3(0),last),0);
let t8=textureLoad(source_map,clamp(pos+offset*5,vec3(0),last),0);
let t9=textureLoad(source_map,clamp(pos+offset*6,vec3(0),last),0);
let t10=textureLoad(source_map,clamp(pos+offset*7,vec3(0),last),0);
let t11=textureLoad(source_map,clamp(pos+offset*8,vec3(0),last),0);
let t12=textureLoad(source_map,clamp(pos+offset*9,vec3(0),last),0);
let t13=textureLoad(source_map,clamp(pos+offset*10,vec3(0),last),0);
// The run stops at the volume's edge.
let run=min(dot(last-pos,offset)+1,8);
textureStore(dest_map,pos,filter_gauss(t0,t1,t2,t3,t4,t5,t6));
if run>1 {
textureStore(dest_map,pos+offset,filter_gauss(t1,t2,t3,t4,t5,t6,t7));
}
if run>2 {
textureStore(dest_map,pos+offset*2,filter_gauss(t2,t3,t4,t5,t6,t7,t8));
}
if run>3 {
textureStore(dest_map,pos+offset*3,filter_gauss(t3,t4,t5,t6,t7,t8,t9));
}
if run>4 {
textureStore(dest_map,pos+offset*4,filter_gauss(t4,t5,t6,t7,t8,t9,t10));
}
if run>5 {
textureStore(dest_map,pos+offset*5,filter_gauss(t5,t6,t7,t8,t9,t10,t11));
}
if run>6 {
textureStore(dest_map,pos+offset*6,filter_gauss(t6,t7,t8,t9,t10,t11,t12));
}
if run>7 {
textureStore(dest_map,pos+offset*7,filter_gauss(t7,t8,t9,t10,t11,t12,t13));
}
}
// Each column's light scattered toward the camera (rgb) and transmittance
// (a) from the camera to each slice's centre.
// The fog composed over the air: `fog` (in-scatter rgb, transmittance a)
// lies nearer the camera than all of `air`, as Wicked Engine 4323a33 places
// its fog over its aerial perspective (WickedEngine/shaders/
// aerialPerspectiveCS.hlsl 82-83, MIT, src/LICENSE-wicked.txt):
// (I_fog + T_fog × I_air, T_fog × T_air).
fn fog_over_air(fog:vec4<f32>,air:vec4<f32>)->vec4<f32> {
return vec4(fog.rgb+fog.a*air.rgb,fog.a*air.a);
}
// One slice of the integrated volume, bounded as the volume stores it.
fn store_integrated(position:vec3<u32>,value:vec4<f32>) {
textureStore(integrated,position,select(vec4(0.),clamp(value,vec4(0.),vec4(65504.)),all_finite(value)));
}
// Each column front to back into the frame's one fog volume (shading/fog.wgsl
// FogLayout): the fog's slices, each the fog to its depth, and while aerial
// perspective is in effect the fog over the air to it; then the aerial
// slices, the whole fog over the air to each; then the fog alone, which the
// sky takes. Without aerial slices the fog's slices are as they always were.
@compute @workgroup_size(8,8,1) fn integrate(@builtin(global_invocation_id) id:vec3<u32>) {
if any(id.xy>=froxels.size.xy) {
return;
}
let unit=(vec2<f32>(id.xy)+vec2(.5))/vec2<f32>(froxels.size.xy);
// Metres along the column's view ray per metre of depth.
let ray_scale=length(froxel_view_position(fog_froxel_ndc(unit),1.));
let volume_layout=froxels.volume_layout;
let aerial=volume_layout.aerial_slices>0u;
var accumulated=vec4(0.,0.,0.,1.);
var previous_depth=0.;
// At most FOG_MOST_SLICES and the volume's own, so the loop ends whatever
// the size says (AR-12); none while the fog does not run.
let slices=min(min(froxels.size.z,FOG_MOST_SLICES),textureDimensions(integrate_scattering).z);
for(var z=0u;z<slices;z++) {
let position=vec3(id.xy,z);
let froxel=textureLoad(integrate_scattering,position,0);
let depth=fog_slice_depth((f32(z)+.5)/f32(froxels.size.z),froxels.length,froxels.detail_spread);
// Beer-Lambert over the step, and the light scattered within it,
// integrated against its own extinction (Hillaire 2015).
let transmittance=exp(-(depth-previous_depth)*ray_scale*froxel.a);
accumulated=vec4(accumulated.rgb+(froxel.rgb-froxel.rgb*transmittance)/max(froxel.a,.00001)*accumulated.a,accumulated.a*transmittance);
previous_depth=depth;
if aerial {
store_integrated(position,fog_over_air(accumulated,sample_aerial_volume(aerial_volume,aerial_sampler,unit,depth*ray_scale)));
} else {
store_integrated(position,accumulated);
}
}
if !aerial {
return;
}
// The aerial slices, at most AERIAL_SLICES (AR-12), then the fog alone.
let aerial_slices=min(volume_layout.aerial_slices,AERIAL_SLICES);
for(var k=0u;k<aerial_slices;k++) {
let depth=fog_layout_aerial_depth(k,volume_layout);
let air=sample_aerial_volume(aerial_volume,aerial_sampler,unit,depth*ray_scale);
store_integrated(vec3(id.xy,slices+k),fog_over_air(accumulated,air));
}
store_integrated(vec3(id.xy,slices+aerial_slices),accumulated);
}