use super::decal_atlas::{AtlasKey, AtlasLayout, DecalAtlas, Sampling};
use super::slots::Slots;
use super::{Scene, SceneError};
use crate::asset::Image;
use crate::content::decal::Decal;
use crate::content::identity::{DecalId, DecalImageId, Identity};
use crate::shading::decals::{DecalRecord, DecalRects};
const RECORD: u64 = std::mem::size_of::<DecalRecord>() as u64;
struct DecalImage {
texels: image::RgbaImage,
users: usize,
}
pub(crate) struct Decals {
images: Slots<DecalImageId, DecalImage>,
pub slots: Slots<DecalId, Decal>,
buffer: wgpu::Buffer,
pub atlas: DecalAtlas,
pending: Option<AtlasLayout>,
stale: bool,
pub sampler: wgpu::Sampler,
}
fn keys(decal: &Decal) -> impl Iterator<Item = AtlasKey> {
[
Some((decal.base_color, Sampling::Color)),
decal.normal.map(|image| (image, Sampling::Data)),
decal
.metallic_roughness
.map(|image| (image, Sampling::Data)),
]
.into_iter()
.flatten()
}
impl Decals {
pub fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Self {
Self {
images: Slots::default(),
slots: Slots::default(),
buffer: decal_buffer(device, 1),
atlas: DecalAtlas::empty(device, queue),
pending: None,
stale: false,
sampler: device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("decal atlas"),
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::MipmapFilterMode::Linear,
..Default::default()
}),
}
}
pub fn buffer(&self) -> &wgpu::Buffer {
&self.buffer
}
pub fn get(&self, id: DecalId) -> Result<&Decal, SceneError> {
self.slots.get(id).ok_or(SceneError::UnknownDecal)
}
pub fn is_empty(&self) -> bool {
self.slots.is_empty()
}
pub fn iter(&self) -> impl Iterator<Item = (DecalId, &Decal)> {
self.slots.iter()
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn packing(&self) -> bool {
self.pending.is_some()
}
fn layout(&self) -> &AtlasLayout {
self.pending.as_ref().unwrap_or(&self.atlas.layout)
}
fn record(&self, decal: &Decal) -> DecalRecord {
let rect = |key| {
self.layout()
.rect(key)
.expect("the layout holds every live decal's images")
};
DecalRecord::new(
decal,
DecalRects {
base_color: rect((decal.base_color, Sampling::Color)),
normal: decal.normal.map(|image| rect((image, Sampling::Data))),
metallic_roughness: decal
.metallic_roughness
.map(|image| rect((image, Sampling::Data))),
},
)
}
fn write(&self, queue: &wgpu::Queue, index: usize, decal: &Decal) {
if !self.stale {
crate::counters::write_buffer(
queue,
&self.buffer,
index as u64 * RECORD,
bytemuck::bytes_of(&self.record(decal)),
);
}
}
fn room(&self, device: &wgpu::Device, count: usize) -> Result<Option<u64>, SceneError> {
let capacity = self.buffer.size() / RECORD;
if count as u64 <= capacity {
return Ok(None);
}
let limits = device.limits();
let limit = limits
.max_storage_buffer_binding_size
.min(limits.max_buffer_size)
/ RECORD;
if count as u64 > limit {
return Err(SceneError::DeviceLimit);
}
Ok(Some((count as u64).max(capacity * 2).min(limit)))
}
fn place_for(
&self,
device: &wgpu::Device,
decal: &Decal,
replacing: Option<DecalId>,
) -> Result<Option<AtlasLayout>, SceneError> {
if keys(decal).all(|key| self.layout().rect(key).is_some()) {
return Ok(None);
}
let mut used: Vec<AtlasKey> = self
.slots
.iter()
.filter(|(id, _)| Some(*id) != replacing)
.flat_map(|(_, decal)| keys(decal))
.chain(keys(decal))
.collect();
used.sort_by_key(|(image, sampling)| (image.index(), *sampling == Sampling::Data));
used.dedup();
let images: Vec<(AtlasKey, [u32; 2])> = used
.into_iter()
.map(|key| {
let texels = &self.images.get(key.0).unwrap().texels;
(key, [texels.width(), texels.height()])
})
.collect();
AtlasLayout::place(&images, device.limits().max_texture_dimension_2d).map(Some)
}
fn repack(&mut self, layout: Option<AtlasLayout>) {
if let Some(layout) = layout {
self.pending = Some(layout);
self.stale = true;
}
}
fn upload(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) -> bool {
let packed = if let Some(layout) = self.pending.take() {
let images = &self.images;
self.atlas = DecalAtlas::fill(device, queue, layout, |(image, _)| {
images.get(image).map(|image| &image.texels)
});
true
} else {
false
};
if std::mem::take(&mut self.stale) {
for (id, decal) in self.slots.iter() {
self.write(queue, id.index(), decal);
}
}
packed
}
pub fn move_origin(&mut self, by: glam::Vec3) {
for (_, decal) in self.slots.iter_mut() {
decal.position -= by;
}
self.stale |= !self.slots.is_empty();
}
fn count_users(&mut self, decal: &Decal, more: bool) {
let mut images = vec![decal.base_color];
images.extend(decal.normal);
images.extend(decal.metallic_roughness);
images.sort_by_key(|image| image.index());
images.dedup();
for image in images {
let users = &mut self.images.get_mut(image).unwrap().users;
if more {
*users += 1;
} else {
*users -= 1;
}
}
}
fn validate(&self, decal: &Decal) -> Result<(), SceneError> {
if !valid(decal) {
return Err(SceneError::InvalidDecal);
}
if keys(decal).any(|(image, _)| self.images.get(image).is_none()) {
return Err(SceneError::UnknownDecalImage);
}
Ok(())
}
}
fn decal_buffer(device: &wgpu::Device, records: u64) -> wgpu::Buffer {
crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some("scene decals"),
size: records * RECORD,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
)
}
fn valid(decal: &Decal) -> bool {
let unit = |value: f32| (0. ..=1.).contains(&value);
let fade = |value: f32| value.is_finite() && value >= 0.;
decal.position.is_finite()
&& decal.rotation.is_finite()
&& decal.rotation.length_squared() > 0.
&& decal.rotation.normalize().is_finite()
&& decal.size.is_finite()
&& decal.size.min_element() > 0.
&& decal.color.iter().all(|&channel| unit(channel))
&& unit(decal.base_color_mix)
&& fade(decal.upper_fade)
&& fade(decal.lower_fade)
&& (0. ..1.).contains(&decal.normal_fade)
}
impl Scene {
pub fn add_decal_image(&mut self, image: Image) -> Result<DecalImageId, SceneError> {
self.edited();
if let Image::Compressed(compressed) = &image
&& !compressed.is_valid()
{
return Err(SceneError::InvalidCompressedImage);
}
let [width, height] = image.size();
if width == 0 || height == 0 {
return Err(SceneError::EmptyImage);
}
let texels = match image {
Image::Rgba8(texels) => texels,
compressed => compressed.texels().into_owned(),
};
Ok(self.decals.images.insert(DecalImage { texels, users: 0 }))
}
pub fn remove_decal_image(&mut self, id: DecalImageId) -> Result<(), SceneError> {
self.edited();
let image = self
.decals
.images
.get(id)
.ok_or(SceneError::UnknownDecalImage)?;
if image.users > 0 {
return Err(SceneError::DecalImageInUse);
}
self.decals.images.remove(id);
Ok(())
}
pub fn add_decal(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
decal: Decal,
) -> Result<DecalId, SceneError> {
self.edited();
let decals = &mut self.decals;
decals.validate(&decal)?;
let room = decals.room(device, decals.slots.next_index() + 1)?;
let layout = decals.place_for(device, &decal, None)?;
if let Some(records) = room {
decals.buffer = decal_buffer(device, records);
decals.stale = true;
self.resources = super::next_generation();
}
decals.repack(layout);
let id = decals.slots.insert(decal);
decals.count_users(&decal, true);
decals.write(queue, id.index(), &decal);
Ok(id)
}
pub fn decal(&self, id: DecalId) -> Result<&Decal, SceneError> {
self.decals.get(id)
}
pub fn set_decal(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
id: DecalId,
decal: Decal,
) -> Result<(), SceneError> {
if *self.decals.get(id)? != decal {
self.edited();
}
let decals = &mut self.decals;
let old = *decals.get(id)?;
decals.validate(&decal)?;
let layout = decals.place_for(device, &decal, Some(id))?;
decals.repack(layout);
decals.count_users(&old, false);
decals.count_users(&decal, true);
*decals.slots.get_mut(id).unwrap() = decal;
decals.write(queue, id.index(), &decal);
Ok(())
}
pub fn remove_decal(&mut self, id: DecalId) -> Result<(), SceneError> {
self.edited();
let decal = self
.decals
.slots
.remove(id)
.ok_or(SceneError::UnknownDecal)?;
self.decals.count_users(&decal, false);
Ok(())
}
pub(crate) fn upload_decals(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
if self.decals.upload(device, queue) {
self.resources = super::next_generation();
}
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests;