use super::{Scene, SceneError};
use crate::content::irradiance_volume::{IrradianceCell, IrradianceVolume};
use crate::static_lighting::irradiance_half;
use glam::{DVec3, I64Vec3, Vec3};
const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
const TEXEL_BYTES: u32 = 8;
const STRIPE: u32 = 16;
fn texture_size(cells: [u32; 3]) -> [u64; 3] {
[
u64::from(cells[0]),
2 * u64::from(cells[1]),
3 * u64::from(cells[2]),
]
}
fn face_texel(face: usize, cell: [u32; 3], cells: [u32; 3]) -> wgpu::Origin3d {
let negative = (face % 2) as u32;
let axis = (face / 2) as u32;
wgpu::Origin3d {
x: cell[0],
y: cell[1] + negative * cells[1],
z: cell[2] + axis * cells[2],
}
}
fn zeroed(
device: &wgpu::Device,
label: &str,
[width, height, depth]: [u32; 3],
usage: wgpu::TextureUsages,
) -> wgpu::Texture {
device.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: depth,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D3,
format: FORMAT,
usage,
view_formats: &[],
})
}
fn texture(device: &wgpu::Device, cells: [u32; 3]) -> wgpu::Texture {
let size = texture_size(cells).map(|side| side as u32);
let usage = wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::COPY_SRC
| wgpu::TextureUsages::COPY_DST;
zeroed(device, "irradiance volume", size, usage)
}
struct Stripe {
staging: wgpu::Texture,
zero: wgpu::Texture,
thickness: u32,
}
impl Stripe {
fn new(device: &wgpu::Device, cells: [u32; 3], axis: usize) -> Self {
let mut size = cells;
size[axis] = cells[axis].min(STRIPE);
let copy = wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::COPY_DST;
Self {
staging: zeroed(device, "irradiance volume scroll", size, copy),
zero: zeroed(
device,
"irradiance volume zeros",
size,
wgpu::TextureUsages::COPY_SRC,
),
thickness: size[axis],
}
}
}
#[derive(Clone)]
pub struct PreparedIrradianceRegion {
corner: Vec3,
cells: [u32; 3],
texels: Vec<u16>,
}
const _: () = {
const fn send<T: Send>() {}
send::<PreparedIrradianceRegion>();
};
impl std::fmt::Debug for PreparedIrradianceRegion {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PreparedIrradianceRegion")
.field("corner", &self.corner)
.field("cells", &self.cells)
.field("texels", &(self.texels.len() / 4))
.finish()
}
}
impl PreparedIrradianceRegion {
pub fn new(
corner: Vec3,
cells: [u32; 3],
values: &[IrradianceCell],
) -> Result<Self, SceneError> {
let count = cells
.iter()
.try_fold(1usize, |count, &n| count.checked_mul(n as usize));
if !corner.is_finite()
|| cells.contains(&0)
|| count != Some(values.len())
|| !values.iter().all(IrradianceCell::valid)
{
return Err(SceneError::InvalidIrradianceRegion);
}
let mut texels = Vec::with_capacity(values.len() * 24);
for face in 0..6 {
for cell in values {
let [r, g, b] = cell.irradiance.irradiance[face];
let occlusion = 1. - cell.sky_visibility[face];
texels.extend([r, g, b, occlusion].map(irradiance_half));
}
}
Ok(Self {
corner,
cells,
texels,
})
}
}
struct Placement {
origin: DVec3,
cell_size: Vec3,
cells: [u32; 3],
texture: wgpu::Texture,
stripes: [Option<Stripe>; 3],
}
impl Placement {
fn cells_to(&self, at: DVec3, given: Vec3) -> Option<I64Vec3> {
super::lattice::steps(self.origin, self.cell_size, at, given)
}
}
pub(crate) struct IrradianceCells {
placement: Option<Placement>,
stand_in: wgpu::TextureView,
view: wgpu::TextureView,
}
impl IrradianceCells {
pub fn new(device: &wgpu::Device) -> Self {
let stand_in = texture(device, [1; 3]).create_view(&Default::default());
Self {
placement: None,
view: stand_in.clone(),
stand_in,
}
}
pub fn view(&self) -> &wgpu::TextureView {
&self.view
}
fn set(&mut self, placement: Option<Placement>) {
self.view = placement
.as_ref()
.map_or(self.stand_in.clone(), |placement| {
placement.texture.create_view(&Default::default())
});
self.placement = placement;
}
}
impl Scene {
pub fn set_irradiance_volume(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
volume: Option<IrradianceVolume>,
) -> Result<(), SceneError> {
self.edited();
let Some(volume) = volume else {
if self.irradiance_cells.placement.is_some() {
self.irradiance_cells.set(None);
self.resources = super::next_generation();
}
return Ok(());
};
if !volume.valid() {
return Err(SceneError::InvalidIrradianceVolume);
}
let limit = u64::from(device.limits().max_texture_dimension_3d);
if texture_size(volume.cells).iter().any(|&side| side > limit) {
return Err(SceneError::DeviceLimit);
}
let origin = volume.origin.as_dvec3() + self.origin();
let shift = self
.irradiance_cells
.placement
.as_ref()
.and_then(|current| {
let lattice =
current.cell_size == volume.cell_size && current.cells == volume.cells;
lattice
.then(|| current.cells_to(origin, volume.origin))
.flatten()
});
if let (Some(current), Some(shift)) = (&mut self.irradiance_cells.placement, shift) {
if shift != I64Vec3::ZERO {
scroll(device, queue, current, shift);
}
return Ok(());
}
let placement = Placement {
origin,
cell_size: volume.cell_size,
cells: volume.cells,
texture: texture(device, volume.cells),
stripes: [None, None, None],
};
self.irradiance_cells.set(Some(placement));
self.resources = super::next_generation();
Ok(())
}
pub fn irradiance_volume(&self) -> Option<IrradianceVolume> {
self.irradiance_cells
.placement
.as_ref()
.map(|placement| IrradianceVolume {
origin: (placement.origin - self.origin()).as_vec3(),
cell_size: placement.cell_size,
cells: placement.cells,
})
}
pub fn write_irradiance_cells(
&mut self,
queue: &wgpu::Queue,
region: &PreparedIrradianceRegion,
) -> Result<(), SceneError> {
self.edited();
let placement = self
.irradiance_cells
.placement
.as_ref()
.ok_or(SceneError::IrradianceRegionOutside)?;
let corner = region.corner.as_dvec3() + self.origin();
let first = placement
.cells_to(corner, region.corner)
.ok_or(SceneError::IrradianceRegionOutside)?;
let inside = (0..3).all(|axis| {
first[axis] >= 0
&& first[axis] + i64::from(region.cells[axis]) <= i64::from(placement.cells[axis])
});
if !inside {
return Err(SceneError::IrradianceRegionOutside);
}
let first = first.to_array().map(|cell| cell as u32);
let [width, height, depth] = region.cells;
let face_texels = region.texels.len() / 6;
for (face, texels) in region.texels.chunks_exact(face_texels).enumerate() {
crate::counters::write_texture(
queue,
wgpu::TexelCopyTextureInfo {
texture: &placement.texture,
mip_level: 0,
origin: face_texel(face, first, placement.cells),
aspect: wgpu::TextureAspect::All,
},
bytemuck::cast_slice(texels),
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(width * TEXEL_BYTES),
rows_per_image: Some(height),
},
wgpu::Extent3d {
width,
height,
depth_or_array_layers: depth,
},
);
}
Ok(())
}
}
fn scroll(device: &wgpu::Device, queue: &wgpu::Queue, placement: &mut Placement, shift: I64Vec3) {
let cells = placement.cells;
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("irradiance volume scroll"),
});
let whole = (0..3).find(|&axis| shift[axis].unsigned_abs() >= u64::from(cells[axis]));
let axes = whole.map_or(0..3, |axis| axis..axis + 1);
for axis in axes {
let by = shift[axis];
if by == 0 {
continue;
}
let entering = by.unsigned_abs().min(u64::from(cells[axis])) as u32;
let kept = cells[axis] - entering;
let stripe =
placement.stripes[axis].get_or_insert_with(|| Stripe::new(device, cells, axis));
let texture = &placement.texture;
let extent = |depth: u32| {
let mut size = cells;
size[axis] = depth;
wgpu::Extent3d {
width: size[0],
height: size[1],
depth_or_array_layers: size[2],
}
};
let face_at = |face: usize, at: u32| {
let mut cell = [0; 3];
cell[axis] = at;
wgpu::TexelCopyTextureInfo {
texture,
mip_level: 0,
origin: face_texel(face, cell, cells),
aspect: wgpu::TextureAspect::All,
}
};
for face in 0..6 {
let mut moved = 0;
while moved < kept {
let depth = (kept - moved).min(stripe.thickness);
let to = if by > 0 {
moved
} else {
cells[axis] - moved - depth
};
let from = if by > 0 { to + entering } else { to - entering };
encoder.copy_texture_to_texture(
face_at(face, from),
stripe.staging.as_image_copy(),
extent(depth),
);
encoder.copy_texture_to_texture(
stripe.staging.as_image_copy(),
face_at(face, to),
extent(depth),
);
moved += depth;
}
let first = if by > 0 { kept } else { 0 };
let mut cleared = 0;
while cleared < entering {
let depth = (entering - cleared).min(stripe.thickness);
encoder.copy_texture_to_texture(
stripe.zero.as_image_copy(),
face_at(face, first + cleared),
extent(depth),
);
cleared += depth;
}
}
}
queue.submit([encoder.finish()]);
placement.origin += shift.as_dvec3() * placement.cell_size.as_dvec3();
}
#[cfg(all(test, not(target_arch = "wasm32")))]
#[path = "irradiance_volume_tests.rs"]
mod tests;