use crate::frame_input::{
AutoExposure, CompensationCurve, Exposure as AuthoredExposure, MeteringMask,
};
use crate::view::frame::FrameContext;
pub(crate) static EXPOSURE: crate::shading::Module = crate::shading::Module {
name: "exposure",
source: include_str!("exposure.wgsl"),
deps: &[&crate::shading::LUMINANCE],
};
pub(crate) const COMPUTE_HISTOGRAM_ENTRY: &str = "compute_histogram";
pub(crate) const COMPUTE_AVERAGE_ENTRY: &str = "compute_average";
const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::R32Float;
const MIN_LOG_LUMINANCE: f32 = -8.;
const MAX_LOG_LUMINANCE: f32 = 8.;
const FILTER_LOW: f32 = 0.1;
const FILTER_HIGH: f32 = 0.9;
const EXPONENTIAL_TRANSITION_DISTANCE: f32 = 1.5;
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, bytemuck::Pod, bytemuck::Zeroable)]
pub(crate) struct AutoExposureUniform {
min_log_lum: f32,
inv_log_lum_range: f32,
log_lum_range: f32,
low_percent: f32,
high_percent: f32,
speed_up: f32,
speed_down: f32,
exponential_transition_distance: f32,
correction_min: f32,
correction_max: f32,
delta_time: f32,
stops: f32,
reset: u32,
compensation_points: u32,
_padding: [u32; 2],
compensation: [[f32; 4]; CompensationCurve::MAX_POINTS / 2],
}
impl AutoExposureUniform {
fn new(automatic: &AutoExposure, stops: f32, delta_time: f32, reset: bool) -> Self {
let log_lum_range = MAX_LOG_LUMINANCE - MIN_LOG_LUMINANCE;
let (correction_min, correction_max) = if automatic.correction_min.is_finite()
&& automatic.correction_max.is_finite()
&& automatic.correction_min <= automatic.correction_max
{
(automatic.correction_min, automatic.correction_max)
} else {
(f32::MIN, f32::MAX)
};
let points = automatic.compensation.points();
let mut compensation = [[0.; 4]; CompensationCurve::MAX_POINTS / 2];
for (index, point) in points.iter().enumerate() {
compensation[index / 2][index % 2 * 2..index % 2 * 2 + 2].copy_from_slice(point);
}
Self {
min_log_lum: MIN_LOG_LUMINANCE,
inv_log_lum_range: log_lum_range.recip(),
log_lum_range,
low_percent: FILTER_LOW,
high_percent: FILTER_HIGH,
speed_up: automatic.speed_brighten,
speed_down: automatic.speed_darken,
exponential_transition_distance: EXPONENTIAL_TRANSITION_DISTANCE,
correction_min,
correction_max,
delta_time,
stops,
reset: u32::from(reset),
compensation_points: points.len() as u32,
_padding: [0; 2],
compensation,
}
}
}
#[cfg(test)]
pub(crate) fn mirrors() -> Vec<crate::shading::layout_tests::Mirror> {
use crate::shading::layout_tests::mirror;
vec![mirror!(
"exposure",
"AutoExposure",
AutoExposureUniform,
[
min_log_lum,
inv_log_lum_range,
log_lum_range,
low_percent,
high_percent,
speed_up,
speed_down,
exponential_transition_distance,
correction_min,
correction_max,
delta_time,
stops,
reset,
compensation_points,
compensation,
]
)]
}
#[cfg(test)]
pub(crate) fn constants() -> [crate::shading::layout_tests::Constant; 1] {
[crate::shading::layout_tests::Constant::new(
"exposure",
"EXPOSURE_COMPENSATION_POINTS",
naga::Literal::U32(CompensationCurve::MAX_POINTS as u32),
)]
}
#[derive(Clone, Copy)]
struct Metering<'a> {
automatic: &'a AutoExposure,
stops: f32,
delta_time: f32,
reset: bool,
}
pub(crate) struct Exposure {
histogram_pipeline: wgpu::ComputePipeline,
average_pipeline: wgpu::ComputePipeline,
layout: wgpu::BindGroupLayout,
settings: wgpu::Buffer,
histogram: wgpu::Buffer,
correction: wgpu::Buffer,
mask: wgpu::Texture,
mask_weights: Option<MeteringMask>,
exposure: wgpu::Texture,
exposure_view: wgpu::TextureView,
fixed: Option<f32>,
groups: Vec<(wgpu::TextureView, wgpu::BindGroup)>,
}
impl Exposure {
pub fn new(device: &wgpu::Device) -> Self {
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("auto exposure"),
source: wgpu::ShaderSource::Wgsl(crate::shading::compose(&[&EXPOSURE]).into()),
});
let texture = |binding| wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: false },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
};
let buffer = |binding, ty| wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
};
let storage = wgpu::BufferBindingType::Storage { read_only: false };
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("auto exposure"),
entries: &[
buffer(0, wgpu::BufferBindingType::Uniform),
texture(1),
texture(2),
buffer(3, storage),
buffer(4, storage),
wgpu::BindGroupLayoutEntry {
binding: 5,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::StorageTexture {
access: wgpu::StorageTextureAccess::WriteOnly,
format: FORMAT,
view_dimension: wgpu::TextureViewDimension::D2,
},
count: None,
},
],
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("auto exposure"),
bind_group_layouts: &[Some(&layout)],
immediate_size: 0,
});
let pipeline = |entry| {
device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some(entry),
layout: Some(&pipeline_layout),
module: &shader,
entry_point: Some(entry),
compilation_options: Default::default(),
cache: None,
})
};
let texture = |label, size: u32, format, usage| {
device.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width: size,
height: size,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST | usage,
view_formats: &[],
})
};
let exposure = texture(
"frame exposure",
1,
FORMAT,
wgpu::TextureUsages::STORAGE_BINDING | wgpu::TextureUsages::COPY_SRC,
);
Self {
histogram_pipeline: pipeline(COMPUTE_HISTOGRAM_ENTRY),
average_pipeline: pipeline(COMPUTE_AVERAGE_ENTRY),
settings: crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some("auto exposure settings"),
size: size_of::<AutoExposureUniform>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
),
histogram: crate::counters::buffer_init(
device,
&wgpu::util::BufferInitDescriptor {
label: Some("auto exposure histogram"),
contents: &[0; 64 * 4],
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
},
),
correction: crate::counters::buffer_init(
device,
&wgpu::util::BufferInitDescriptor {
label: Some("auto exposure correction"),
contents: &[0; 4],
usage: wgpu::BufferUsages::STORAGE,
},
),
mask: texture(
"metering mask",
16,
wgpu::TextureFormat::R8Unorm,
wgpu::TextureUsages::empty(),
),
mask_weights: None,
exposure_view: exposure.create_view(&Default::default()),
exposure,
fixed: None,
layout,
groups: Vec::new(),
}
}
pub fn texture(&self) -> &wgpu::Texture {
&self.exposure
}
pub fn view(&self) -> &wgpu::TextureView {
&self.exposure_view
}
pub fn forget_inputs(&mut self) {
self.groups.clear();
}
pub fn encode(&mut self, ctx: &mut FrameContext<'_>, frame: &wgpu::TextureView) {
let AuthoredExposure { stops, automatic } = ctx.input.exposure;
let Some(automatic) = automatic else {
if self.fixed != Some(stops) {
crate::counters::write_texture(
ctx.queue,
self.exposure.as_image_copy(),
bytemuck::bytes_of(&stops.exp2()),
wgpu::TexelCopyBufferLayout::default(),
self.exposure.size(),
);
self.fixed = Some(stops);
}
return;
};
let reset = !ctx.history.valid || self.fixed.take().is_some();
self.meter(
ctx.device,
ctx.queue,
ctx.encoder,
frame,
Metering {
automatic: &automatic,
stops,
delta_time: ctx.input.frame_time_ms.max(0.) / 1000.,
reset,
},
ctx.timing,
);
}
fn meter(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
frame: &wgpu::TextureView,
metering: Metering<'_>,
timing: Option<&crate::timing::GpuTiming>,
) {
self.upload(queue, metering);
let group = self.group(device, frame);
let size = frame.texture().size();
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("auto exposure"),
timestamp_writes: timing.and_then(|t| t.compute_pass("exposure")),
});
pass.set_bind_group(0, &group, &[]);
pass.set_pipeline(&self.histogram_pipeline);
pass.dispatch_workgroups(size.width.div_ceil(16), size.height.div_ceil(16), 1);
pass.set_pipeline(&self.average_pipeline);
pass.dispatch_workgroups(1, 1, 1);
}
fn upload(&mut self, queue: &wgpu::Queue, metering: Metering<'_>) {
let automatic = metering.automatic;
let uniform = AutoExposureUniform::new(
automatic,
metering.stops,
metering.delta_time,
metering.reset,
);
crate::counters::write_buffer(queue, &self.settings, 0, bytemuck::bytes_of(&uniform));
if self.mask_weights != Some(automatic.metering_mask) {
crate::counters::write_texture(
queue,
self.mask.as_image_copy(),
automatic.metering_mask.weights.as_flattened(),
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(16),
rows_per_image: None,
},
self.mask.size(),
);
self.mask_weights = Some(automatic.metering_mask);
}
}
fn group(&mut self, device: &wgpu::Device, frame: &wgpu::TextureView) -> wgpu::BindGroup {
if let Some((_, group)) = self.groups.iter().find(|(view, _)| view == frame) {
return group.clone();
}
let mask = self.mask.create_view(&Default::default());
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("auto exposure"),
layout: &self.layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: self.settings.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(frame),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::TextureView(&mask),
},
wgpu::BindGroupEntry {
binding: 3,
resource: self.histogram.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 4,
resource: self.correction.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 5,
resource: wgpu::BindingResource::TextureView(&self.exposure_view),
},
],
});
self.groups.push((frame.clone(), group.clone()));
group
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests;