use crate::content::transient::HeatDistortion;
use crate::scene::transient::Transient;
use crate::shading::gbuffer::COLOR as HDR;
use crate::shading::vertex::{VertexLayout, vertex_layout};
use crate::view::targets::{attachment, hold, target};
pub(crate) static HEAT: crate::shading::Module = crate::shading::Module {
name: "heat_distortion",
source: include_str!("heat.wgsl"),
deps: &[],
};
pub(crate) const VS_ENTRY: &str = "vs";
pub(crate) const FS_ENTRY: &str = "fs";
pub(crate) const HEAT_LAYOUT: VertexLayout =
vertex_layout!(HeatDistortion, [position, displacement, weight]);
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct View {
camera: [[f32; 4]; 4],
render_per_scene: [f32; 2],
_pad: [f32; 2],
}
pub(crate) struct Heat {
pipeline: wgpu::RenderPipeline,
layout: wgpu::BindGroupLayout,
view: wgpu::Buffer,
source: Option<wgpu::TextureView>,
}
impl Heat {
pub fn new(device: &wgpu::Device) -> Self {
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("heat snapshot layout"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: false },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Depth,
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
],
});
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("bounded heat shimmer"),
source: wgpu::ShaderSource::Wgsl(crate::shading::compose(&[&HEAT]).into()),
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: None,
bind_group_layouts: &[Some(&layout)],
immediate_size: 0,
});
let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("bounded heat shimmer"),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some(VS_ENTRY),
compilation_options: Default::default(),
buffers: &[Some(HEAT_LAYOUT.buffer)],
},
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some(FS_ENTRY),
compilation_options: Default::default(),
targets: &[Some(wgpu::ColorTargetState {
format: HDR,
blend: None,
write_mask: wgpu::ColorWrites::ALL,
})],
}),
primitive: Default::default(),
depth_stencil: None,
multisample: Default::default(),
multiview_mask: None,
cache: None,
});
Self {
pipeline,
layout,
view: crate::counters::buffer_init(
device,
&wgpu::util::BufferInitDescriptor {
label: Some("heat stable camera"),
contents: bytemuck::bytes_of(&View {
camera: glam::Mat4::IDENTITY.to_cols_array_2d(),
render_per_scene: [1.; 2],
_pad: [0.; 2],
}),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
},
),
source: None,
}
}
#[allow(clippy::too_many_arguments)]
pub fn encode(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
transient: &Transient,
matrix: &[[f32; 4]; 4],
scene: [u32; 2],
color: &wgpu::TextureView,
depth: &wgpu::TextureView,
timing: Option<&crate::timing::GpuTiming>,
) {
if transient.heat_count == 0 {
return;
}
let size = [color.texture().width(), color.texture().height()];
let source = hold(
&mut self.source,
wgpu::TextureView::texture,
color.texture().size(),
|| target(device, "immutable heat source", size, HDR),
);
let view = View {
camera: *matrix,
render_per_scene: [0, 1].map(|axis| size[axis] as f32 / scene[axis] as f32),
_pad: [0.; 2],
};
crate::counters::write_buffer(queue, &self.view, 0, bytemuck::bytes_of(&view));
encoder.copy_texture_to_texture(
color.texture().as_image_copy(),
source.texture().as_image_copy(),
color.texture().size(),
);
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("heat current source and depth"),
layout: &self.layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: self.view.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(source),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::TextureView(depth),
},
],
});
let mut attachment = attachment(color).unwrap();
attachment.ops.load = wgpu::LoadOp::Load;
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("camera heat before bloom and HUD"),
color_attachments: &[Some(attachment)],
timestamp_writes: timing.and_then(|t| t.render_pass("heat distortion")),
..Default::default()
});
pass.set_pipeline(&self.pipeline);
pass.set_bind_group(0, &group, &[]);
pass.set_vertex_buffer(0, transient.heat.slice(..));
pass.draw(0..transient.heat_count, 0..1);
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests {
use super::*;
use crate::content::transient::MAX_VERTICES;
#[test]
fn bounded_sampling() {
let Some((device, queue)) = crate::test_support::device() else {
return;
};
pollster::block_on(async {
let mut heat = Heat::new(&device);
let mut transient = Transient::new(&device);
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: None, source: wgpu::ShaderSource::Wgsl("@vertex fn vs(@builtin(vertex_index) i:u32)->@builtin(position) vec4<f32> {let p=vec2(f32((i<<1u)&2u),f32(i&2u));return vec4(p*2.-1.,.75,1.);}".into()) });
let depth_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: None,
layout: None,
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("vs"),
compilation_options: Default::default(),
buffers: &[],
},
fragment: None,
primitive: Default::default(),
depth_stencil: Some(wgpu::DepthStencilState {
format: wgpu::TextureFormat::Depth32Float,
depth_write_enabled: Some(true),
depth_compare: Some(wgpu::CompareFunction::Always),
stencil: Default::default(),
bias: Default::default(),
}),
multisample: Default::default(),
multiview_mask: None,
cache: None,
});
for size in [[32, 16], [48, 24]] {
let color = target(&device, "ramp", size, HDR);
let depth = target(
&device,
"foreground stripe",
size,
wgpu::TextureFormat::Depth32Float,
);
let pixels: Vec<u16> = (0..size[1])
.flat_map(|y| {
(0..size[0]).flat_map(move |x| {
[0x3c00 + x as u16 * 16, 0x3c00 + y as u16 * 16, 0, 0x3c00]
})
})
.collect();
for (offset, weight, clear) in [
([2.5_f32, 1.5_f32], 1., false),
([-2.5, -1.5], 1., false),
([0., 0.], 1., false),
([2.5, 1.5], 0., false),
([32., 32.], 1., false),
([2.5, 1.5], 1., true),
] {
queue.write_texture(
color.texture().as_image_copy(),
bytemuck::cast_slice(&pixels),
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(size[0] * 8),
rows_per_image: Some(size[1]),
},
color.texture().size(),
);
let vertices = [
[-1., -0.5, 0.5],
[0.5, -0.5, 0.5],
[-1., 0.5, 0.5],
[-1., 0.5, 0.5],
[0.5, -0.5, 0.5],
[0.5, 0.5, 0.5],
]
.map(|position| HeatDistortion {
position,
displacement: offset,
weight,
});
transient.update_heat(&queue, &vertices).unwrap();
assert!(
transient
.update_heat(&queue, &vec![vertices[0]; MAX_VERTICES + 3])
.is_err()
);
if clear {
transient.update_heat(&queue, &[]).unwrap();
}
let mut encoder = device.create_command_encoder(&Default::default());
{
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
color_attachments: &[],
depth_stencil_attachment: Some(
wgpu::RenderPassDepthStencilAttachment {
view: &depth,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(0.2),
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
},
),
..Default::default()
});
pass.set_pipeline(&depth_pipeline);
pass.set_scissor_rect(10, 0, 1, size[1]);
pass.draw(0..3, 0..1);
}
heat.encode(
&device,
&queue,
&mut encoder,
&transient,
&glam::Mat4::IDENTITY.to_cols_array_2d(),
size,
&color,
&depth,
None,
);
queue.submit([encoder.finish()]);
let actual = crate::test_support::read(&device, &queue, color.texture(), 8);
for y in 0..size[1] {
for x in 0..size[0] {
let i = ((y * size[0] + x) * 8) as usize;
let changed = weight > 0.
&& !clear
&& offset[0].abs() == 2.5
&& x < size[0] * 3 / 4
&& y >= size[1] / 4
&& y < size[1] * 3 / 4
&& x != 10
&& if offset[0] > 0. {
x != 7 && x != 8
} else {
x >= 3 && x != 12 && x != 13
};
if changed {
let red = crate::test_support::half(&actual[i..]);
let green = crate::test_support::half(&actual[i + 2..]);
assert!(
(red - (1. + (x as f32 + offset[0]) / 64.)).abs() < 0.001,
"red ({x},{y}): {red}"
);
assert!(
(green - (1. + (y as f32 + offset[1]) / 64.)).abs() < 0.001,
"green ({x},{y}): {green}"
);
} else {
assert_eq!(
&actual[i..i + 8],
&bytemuck::cast_slice::<_, u8>(&pixels)[i..i + 8],
"preserve ({x},{y}) offset {offset:?} weight {weight}"
);
}
}
}
}
transient.update_heat(&queue, &[]).unwrap();
}
});
}
#[test]
fn heat_warps_the_composite_after_its_transparent_draws() {
use crate::settings::Antialiasing;
let Some((device, queue)) = crate::test_support::fsr2_device() else {
return;
};
let render = [32, 24];
warps_by(&device, &queue, render, Antialiasing::Off, 2);
warps_by(
&device,
&queue,
render.map(|x| x * 2),
Antialiasing::Fsr2,
1,
);
}
fn warps_by(
device: &wgpu::Device,
queue: &wgpu::Queue,
size: [u32; 2],
antialiasing: crate::settings::Antialiasing,
shift: u32,
) {
use crate::effects::Glow;
use crate::settings::{Bloom, Fsr2Quality, SceneResolution, Settings};
use crate::{Camera, FrameInput, Mist, Renderer, Scene};
use glam::{Mat4, Vec3};
let mut scene = Scene::new(device, queue);
let glow = [
([-20., -20., -2.], 0.),
([60., -20., -2.], 4.),
([-20., 60., -2.], 0.),
]
.map(|(position, red)| Glow {
position,
color: [red, 0., 0., 1.],
..Glow::default()
});
scene.update_effects(device, queue, &glow).unwrap();
scene.update_mist(device, queue, &[[0., 0., -2.]]).unwrap();
let heat = [[-10., -10., -1.], [30., -10., -1.], [-10., 30., -1.]].map(|position| {
HeatDistortion {
position,
displacement: [2., 0.],
weight: 1.,
}
});
scene.update_heat_distortion(queue, &heat).unwrap();
let mut input = FrameInput::new(Camera {
view: Mat4::IDENTITY,
projection: crate::perspective(
std::f32::consts::FRAC_PI_2,
size[0] as f32 / size[1] as f32,
0.1,
),
eye: Vec3::ZERO,
});
input.camera_cut = true;
input.atmosphere = true;
input.mist = Mist {
thin_color: [0., 0., 1.],
dense_color: [0., 4., 0.],
opacity: 1.,
width: 3.,
height: 3.,
..Mist::default()
};
let settings = Settings {
scene_resolution: SceneResolution::Full,
antialiasing,
fsr2_quality: Fsr2Quality::Performance,
bloom: Bloom::Off,
..Settings::default()
};
let output = crate::view::targets::target(
device,
"caller output",
size,
crate::shading::gbuffer::COLOR,
);
let mut composite = |heat_distortion| {
let settings = Settings {
heat_distortion,
..settings
};
let mut renderer = Renderer::for_test(device, queue, size, &settings);
if renderer.antialiasing_in_effect(&settings) != antialiasing {
eprintln!(
"skipping {antialiasing:?}: it does not run here: {:?}",
renderer.fsr2_error()
);
return None;
}
let mut encoder = device.create_command_encoder(&Default::default());
renderer.render(
device,
queue,
&mut encoder,
&mut scene,
&input,
&settings,
&output,
None,
);
queue.submit([encoder.finish()]);
renderer.finish_frame(&mut scene);
let composite = renderer.targets().composite.texture();
Some((
[composite.width(), composite.height()],
crate::test_support::read(device, queue, composite, 8),
))
};
let Some((render, unwarped)) = composite(false) else {
return;
};
let (_, warped) = composite(true).unwrap();
assert_eq!(render, [32, 24], "the composite is at the render size");
let texel = |frame: &[u8], x: u32, y: u32| {
let i = ((y * render[0] + x) * 8) as usize;
frame[i..i + 8].to_vec()
};
let channel = |x, channel: usize| {
crate::test_support::half(&texel(&unwarped, x, render[1] / 2)[channel * 2..])
};
assert!(
channel(4, 0) < channel(28, 0),
"the glow must brighten to the right"
);
assert!(channel(16, 1) > 0., "the mist must show");
for y in 0..render[1] {
for x in 0..render[0] {
let source = if x + shift < render[0] { x + shift } else { x };
assert_eq!(
texel(&warped, x, y),
texel(&unwarped, source, y),
"{antialiasing:?}: ({x},{y}) is not the unwarped frame's ({source},{y})"
);
}
}
}
}