pub(crate) mod aerial;
pub(crate) mod environment;
use crate::FrameInput;
use crate::content::lighting::{DirectionalLight, FrameEnvironment, Sky as SkyLook};
use crate::shading::sky::SkyAtmosphereUniform;
use crate::view::frame::FrameContext;
use aerial::{AerialPipeline, AerialVolume, SkyAerialUniform};
use environment::{AtlasCycle, EnvironmentAtlas, EnvironmentPipelines};
use glam::Vec3;
use std::ops::Range;
pub(crate) static SKY_COMMON: crate::shading::Module = crate::shading::Module {
name: "sky_common",
source: include_str!("sky/common.wgsl"),
deps: &[&crate::shading::sky::SKY, &crate::shading::UNIFORMS],
};
pub(crate) static TRANSMITTANCE: crate::shading::Module = crate::shading::Module {
name: "sky_transmittance",
source: include_str!("sky/transmittance_lut.wgsl"),
deps: &[&SKY_COMMON],
};
pub(crate) static MULTISCATTERING: crate::shading::Module = crate::shading::Module {
name: "sky_multiscattering",
source: include_str!("sky/multiscattering_lut.wgsl"),
deps: &[&SKY_COMMON],
};
pub(crate) static SKY_VIEW: crate::shading::Module = crate::shading::Module {
name: "sky_view",
source: include_str!("sky/sky_view_lut.wgsl"),
deps: &[&SKY_COMMON],
};
pub(crate) const TRANSMITTANCE_ENTRY: &str = "transmittance_lut_main";
pub(crate) const MULTISCATTERING_ENTRY: &str = "multiscattering_lut_main";
pub(crate) const SKY_VIEW_ENTRY: &str = "sky_view_lut_main";
pub(crate) const TRANSMITTANCE_SIZE: [u32; 2] = [256, 128];
pub(crate) const MULTISCATTERING_SIZE: u32 = 32;
pub(crate) const SKY_VIEW_SIZE: [u32; 2] = [400, 200];
const WORKGROUP: u32 = 16;
const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
pub(crate) struct SkyLightUniform {
pub direction_to_light: [f32; 3],
pub padding_direction: f32,
pub color: [f32; 3],
pub padding_color: f32,
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
pub(crate) struct SkyUniform {
pub atmosphere: SkyAtmosphereUniform,
pub lights: [SkyLightUniform; 2],
pub camera_radius: f32,
pub padding: [f32; 3],
}
impl SkyUniform {
fn of(sky: &SkyLook, input: &FrameInput, eye: Vec3) -> Self {
let lights = input.directional_lights.map(|light| {
light
.filter(DirectionalLight::is_on)
.map_or(SkyLightUniform::zeroed_up(), |light| SkyLightUniform {
direction_to_light: (-light.direction.normalize()).to_array(),
padding_direction: 0.,
color: light.color.map(|channel| channel * light.illuminance),
padding_color: 0.,
})
});
Self {
atmosphere: SkyAtmosphereUniform::of(sky),
lights,
camera_radius: crate::shading::sky::camera_radius(sky, eye),
padding: [0.; 3],
}
}
}
impl SkyLightUniform {
fn zeroed_up() -> Self {
Self {
direction_to_light: [0., 1., 0.],
..bytemuck::Zeroable::zeroed()
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(crate) struct Computed {
pub transmittance: bool,
pub multiscattering: bool,
pub sky_view: bool,
}
struct Pipelines {
transmittance: wgpu::ComputePipeline,
multiscattering: wgpu::ComputePipeline,
sky_view: wgpu::ComputePipeline,
layouts: [wgpu::BindGroupLayout; 3],
sampler: wgpu::Sampler,
environment: EnvironmentPipelines,
}
impl Pipelines {
fn new(device: &wgpu::Device) -> Self {
let entry = |binding, ty| wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty,
count: None,
};
let uniform = entry(
0,
wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: wgpu::BufferSize::new(size_of::<SkyUniform>() as u64),
},
);
let table = |binding| {
entry(
binding,
wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
)
};
let sampler = entry(
3,
wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
);
let output = entry(
4,
wgpu::BindingType::StorageTexture {
access: wgpu::StorageTextureAccess::WriteOnly,
format: FORMAT,
view_dimension: wgpu::TextureViewDimension::D2,
},
);
let layout = |label, entries: &[wgpu::BindGroupLayoutEntry]| {
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some(label),
entries,
})
};
let layouts = [
layout("sky transmittance", &[uniform, output]),
layout("sky multiscattering", &[uniform, table(1), sampler, output]),
layout("sky view", &[uniform, table(1), table(2), sampler, output]),
];
let pipeline = |module: &'static crate::shading::Module, entry, layout| {
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some(module.name),
source: wgpu::ShaderSource::Wgsl(crate::shading::compose(&[module]).into()),
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some(module.name),
bind_group_layouts: &[Some(layout)],
immediate_size: 0,
});
device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some(module.name),
layout: Some(&pipeline_layout),
module: &shader,
entry_point: Some(entry),
compilation_options: Default::default(),
cache: None,
})
};
Self {
transmittance: pipeline(&TRANSMITTANCE, TRANSMITTANCE_ENTRY, &layouts[0]),
multiscattering: pipeline(&MULTISCATTERING, MULTISCATTERING_ENTRY, &layouts[1]),
sky_view: pipeline(&SKY_VIEW, SKY_VIEW_ENTRY, &layouts[2]),
sampler: device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("sky tables"),
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
..Default::default()
}),
layouts,
environment: EnvironmentPipelines::new(device),
}
}
}
struct Tables {
uniform: wgpu::Buffer,
#[cfg_attr(not(test), allow(dead_code))]
transmittance: wgpu::Texture,
#[cfg_attr(not(test), allow(dead_code))]
multiscattering: wgpu::Texture,
#[cfg_attr(not(test), allow(dead_code))]
sky_view: wgpu::Texture,
sky_view_view: wgpu::TextureView,
table_views: [wgpu::TextureView; 2],
groups: [wgpu::BindGroup; 3],
environment: EnvironmentAtlas,
}
impl Tables {
fn new(device: &wgpu::Device, pipelines: &Pipelines) -> Self {
let table = |label, [width, height]: [u32; 2]| {
device.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: FORMAT,
usage: wgpu::TextureUsages::STORAGE_BINDING
| wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
})
};
let transmittance = table("sky transmittance table", TRANSMITTANCE_SIZE);
let multiscattering = table("sky multiscattering table", [MULTISCATTERING_SIZE; 2]);
let sky_view = table("sky view table", SKY_VIEW_SIZE);
let uniform = crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some("sky"),
size: size_of::<SkyUniform>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
);
let views = [&transmittance, &multiscattering, &sky_view]
.map(|texture| texture.create_view(&Default::default()));
let view = |binding, view| wgpu::BindGroupEntry {
binding,
resource: wgpu::BindingResource::TextureView(view),
};
let uniform_entry = wgpu::BindGroupEntry {
binding: 0,
resource: uniform.as_entire_binding(),
};
let sampler = wgpu::BindGroupEntry {
binding: 3,
resource: wgpu::BindingResource::Sampler(&pipelines.sampler),
};
let group = |label, layout, entries: &[wgpu::BindGroupEntry]| {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some(label),
layout,
entries,
})
};
let [transmittance_view, multiscattering_view, sky_view_view] = views;
let groups = [
group(
"sky transmittance",
&pipelines.layouts[0],
&[uniform_entry.clone(), view(4, &transmittance_view)],
),
group(
"sky multiscattering",
&pipelines.layouts[1],
&[
uniform_entry.clone(),
view(1, &transmittance_view),
sampler.clone(),
view(4, &multiscattering_view),
],
),
group(
"sky view",
&pipelines.layouts[2],
&[
uniform_entry,
view(1, &transmittance_view),
view(2, &multiscattering_view),
sampler,
view(4, &sky_view_view),
],
),
];
let environment = EnvironmentAtlas::new(
device,
&pipelines.environment,
(&uniform, &sky_view_view, &pipelines.sampler),
);
Self {
uniform,
transmittance,
multiscattering,
sky_view,
sky_view_view,
table_views: [transmittance_view, multiscattering_view],
groups,
environment,
}
}
}
#[derive(Default)]
struct Held {
medium: Option<SkyAtmosphereUniform>,
view: Option<SkyUniform>,
rendered: Option<(SkyUniform, Computed)>,
}
impl Held {
fn computes(&self, inputs: &SkyUniform) -> Computed {
let medium = self.medium != Some(inputs.atmosphere);
Computed {
transmittance: medium,
multiscattering: medium,
sky_view: medium || self.view.as_ref() != Some(inputs),
}
}
fn leave(&mut self, inputs: SkyUniform, computed: Computed) {
self.rendered = Some((inputs, computed));
}
fn settle(&mut self, finished: bool) {
let Some((inputs, computed)) = self.rendered.take() else {
return;
};
if finished {
self.medium = Some(inputs.atmosphere);
self.view = Some(inputs);
return;
}
if computed.transmittance || computed.multiscattering {
self.medium = None;
}
if computed.sky_view {
self.view = None;
}
}
}
#[derive(Clone)]
struct Plan {
inputs: SkyUniform,
computed: Computed,
steps: Range<usize>,
aerial: Option<SkyAerialUniform>,
}
#[derive(Default)]
pub(crate) struct Sky {
pipelines: Option<Pipelines>,
tables: Option<Tables>,
held: Held,
cycle: AtlasCycle,
aerial_pipeline: Option<AerialPipeline>,
aerial: Option<AerialVolume>,
plan: Option<Plan>,
}
impl Sky {
pub fn prepare(
&mut self,
device: &wgpu::Device,
input: &FrameInput,
eye: Vec3,
(restart, aerial): (bool, bool),
) {
self.plan = None;
let FrameEnvironment::Sky(sky) = &input.environment else {
self.aerial = None;
if self.tables.take().is_some() {
self.held = Held::default();
self.cycle.forget();
}
return;
};
let pipelines = self.pipelines.get_or_insert_with(|| Pipelines::new(device));
if self.tables.is_none() {
self.tables = Some(Tables::new(device, pipelines));
self.held = Held::default();
self.cycle.forget();
self.aerial = None;
}
let tables = self.tables.as_ref().unwrap();
let aerial = aerial.then(|| {
let pipeline = self
.aerial_pipeline
.get_or_insert_with(|| AerialPipeline::new(device));
if self.aerial.is_none() {
let [transmittance, multiscattering] = &tables.table_views;
self.aerial = Some(AerialVolume::new(
device,
pipeline,
(
&tables.uniform,
[transmittance, multiscattering],
&pipelines.sampler,
),
));
}
let camera = input.camera;
SkyAerialUniform::new(
camera.view,
camera.projection,
sky.resolved().aerial_perspective,
)
});
if aerial.is_none() {
self.aerial = None;
}
let inputs = SkyUniform::of(sky, input, eye);
let computed = self.held.computes(&inputs);
self.held.leave(inputs, computed);
let steps = self.cycle.plan(computed.sky_view, restart);
self.plan = Some(Plan {
inputs,
computed,
steps,
aerial,
});
}
pub fn aerial_volume(&self) -> Option<&wgpu::TextureView> {
self.aerial.as_ref().map(|aerial| &aerial.view)
}
pub fn views(&self) -> Option<[&wgpu::TextureView; 2]> {
self.tables
.as_ref()
.map(|tables| [&tables.sky_view_view, &tables.environment.view])
}
pub fn environment_revision(&self) -> u64 {
self.tables.as_ref().map_or(0, |_| self.cycle.revision())
}
pub fn encode(&mut self, ctx: &mut FrameContext<'_>) {
self.encode_planned((ctx.queue, ctx.encoder), ctx.timing);
}
pub fn encode_planned(
&mut self,
(queue, encoder): (&wgpu::Queue, &mut wgpu::CommandEncoder),
timing: Option<&crate::timing::GpuTiming>,
) {
let (Some(pipelines), Some(tables), Some(plan)) =
(&self.pipelines, &self.tables, self.plan.clone())
else {
return;
};
let Plan {
inputs,
computed,
steps,
aerial,
} = plan;
if computed != Computed::default() {
crate::counters::write_buffer(queue, &tables.uniform, 0, bytemuck::bytes_of(&inputs));
}
let mut pass = |name, pipeline, group, [x, y]: [u32; 2]| {
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some(name),
timestamp_writes: timing.and_then(|timing| timing.compute_pass(name)),
});
pass.set_pipeline(pipeline);
pass.set_bind_group(0, group, &[]);
pass.dispatch_workgroups(x, y, 1);
};
let workgroups = |size: [u32; 2]| size.map(|side| side.div_ceil(WORKGROUP));
if computed.transmittance {
pass(
"sky transmittance",
&pipelines.transmittance,
&tables.groups[0],
workgroups(TRANSMITTANCE_SIZE),
);
}
if computed.multiscattering {
pass(
"sky multiscattering",
&pipelines.multiscattering,
&tables.groups[1],
[MULTISCATTERING_SIZE; 2],
);
}
if computed.sky_view {
pass(
"sky view",
&pipelines.sky_view,
&tables.groups[2],
workgroups(SKY_VIEW_SIZE),
);
}
if let (Some(uniform), Some(volume), Some(pipeline)) =
(aerial, &self.aerial, &self.aerial_pipeline)
{
volume.encode(pipeline, (queue, encoder), &uniform, timing);
}
tables
.environment
.encode(&pipelines.environment, encoder, steps, timing);
}
pub fn settle(&mut self, finished: bool) {
self.held.settle(finished);
self.cycle.settle(finished);
}
#[cfg_attr(not(test), allow(dead_code))]
pub fn computed(&self) -> Computed {
self.plan
.as_ref()
.map_or_else(Computed::default, |plan| plan.computed)
}
#[cfg(test)]
pub fn aerial_texture(&self) -> Option<&wgpu::Texture> {
self.aerial.as_ref().map(AerialVolume::texture)
}
#[cfg(test)]
pub fn atlas(&self) -> Option<&wgpu::Texture> {
self.tables
.as_ref()
.map(|tables| tables.environment.texture())
}
#[cfg(test)]
pub fn tables(&self) -> Option<[&wgpu::Texture; 3]> {
self.tables.as_ref().map(|tables| {
[
&tables.transmittance,
&tables.multiscattering,
&tables.sky_view,
]
})
}
}
#[cfg(test)]
pub(crate) fn mirrors() -> Vec<crate::shading::layout_tests::Mirror> {
use crate::shading::layout_tests::mirror;
vec![
mirror!(
"sky_view",
"SkyLight",
SkyLightUniform,
[direction_to_light, color]
),
mirror!(
"sky_view",
"SkyUniform",
SkyUniform,
[atmosphere, lights, camera_radius]
),
]
}
#[cfg(test)]
pub(crate) fn constants() -> Vec<crate::shading::layout_tests::Constant> {
use crate::shading::layout_tests::Constant;
let u = |program, name, value| Constant::new(program, name, naga::Literal::U32(value));
vec![
u(
"sky_transmittance",
"SKY_TRANSMITTANCE_WIDTH",
TRANSMITTANCE_SIZE[0],
),
u(
"sky_transmittance",
"SKY_TRANSMITTANCE_HEIGHT",
TRANSMITTANCE_SIZE[1],
),
u(
"sky_multiscattering",
"SKY_MULTISCATTERING_SIZE",
MULTISCATTERING_SIZE,
),
u("sky_view", "SKY_VIEW_WIDTH", SKY_VIEW_SIZE[0]),
u("sky_view", "SKY_VIEW_HEIGHT", SKY_VIEW_SIZE[1]),
]
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests;