use super::candidates::CandidateMesh;
use super::rays::{MaterialTextures, SceneRays};
use super::slots::Slots;
use super::textures::{self, Textures};
use super::{Scene, SceneError, buffer};
use crate::asset::{Image, Material as AuthoredMaterial};
use crate::content::identity::{MaterialId, ModelId};
use crate::content::material::{AlphaMode, SurfaceMaterial};
use crate::shading::material::{MaterialMaps, MaterialUniform};
use group::{Bound, Groups};
use std::collections::HashMap;
use std::ops::Range;
use validate::{validate_alpha, validate_anisotropy, validate_normal_layers};
pub(crate) struct Material {
pub values: SurfaceMaterial,
maps: MaterialMaps,
pub group: wgpu::BindGroup,
bound: Bound,
buffer: wgpu::Buffer,
baked: wgpu::Buffer,
casts_directional_shadow: bool,
textures: Vec<usize>,
record: Range<u32>,
pub users: HashMap<ModelId, u32>,
pub untangented: u32,
}
impl Material {
pub fn word(&self) -> u32 {
self.record.start
}
pub fn enabled(&self, mask: Option<u32>) -> bool {
mask.is_none_or(|mask| {
let group = self.values.visibility_group;
group & mask == group
})
}
fn uniform(&self) -> MaterialUniform {
MaterialUniform::new(&self.values, self.maps)
}
pub fn surface_moves(&self) -> bool {
self.uniform().surface_moves()
}
pub fn casts_directional_shadow(&self, mask: u32) -> bool {
self.casts_directional_shadow && self.enabled(Some(mask))
}
pub fn casts_directional_shadows(&self) -> bool {
self.casts_directional_shadow
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn uniform_buffer(&self) -> &wgpu::Buffer {
&self.buffer
}
}
pub(crate) struct Materials {
pub slots: Slots<MaterialId, Material>,
pub casters: u64,
masked: usize,
blended: usize,
receivers: usize,
moving: usize,
textures: Textures,
groups: Groups,
}
fn maps(material: &AuthoredMaterial) -> [(Option<usize>, bool); 6] {
[
(material.base_texture, true),
(material.emissive_texture, true),
(material.mr_texture, false),
(material.normal_texture, false),
(material.bump_texture, false),
(material.anisotropy_texture, false),
]
}
fn authored_maps(material: &AuthoredMaterial) -> MaterialMaps {
MaterialMaps::new(
material.normal_texture.is_some(),
material.bump_texture.is_some(),
material.anisotropy_texture.is_some(),
)
}
impl Materials {
pub fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Self {
Self {
slots: Slots::default(),
casters: 0,
masked: 0,
blended: 0,
receivers: 0,
moving: 0,
textures: Textures::default(),
groups: Groups::new(device, queue),
}
}
pub fn holds_masked(&self) -> bool {
self.masked > 0
}
pub fn holds_blended(&self) -> bool {
self.blended > 0
}
pub fn holds_receivers(&self) -> bool {
self.receivers > 0
}
pub fn holds_moving_surfaces(&self) -> bool {
self.moving > 0
}
fn count(&mut self, alpha: AlphaMode, moves: bool, by: isize) {
let add = |count: &mut usize| *count = count.checked_add_signed(by).unwrap();
if moves && !matches!(alpha, AlphaMode::Blend { .. }) {
add(&mut self.moving);
}
match alpha {
AlphaMode::Opaque => {}
AlphaMode::Mask { .. } => add(&mut self.masked),
AlphaMode::Blend {
receives_screen_space_reflections,
} => {
add(&mut self.blended);
if receives_screen_space_reflections {
add(&mut self.receivers);
}
}
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn texture(&self, index: usize) -> &textures::Texture {
self.textures.get(index)
}
pub fn get(&self, id: MaterialId) -> Result<&Material, SceneError> {
self.slots.get(id).ok_or(SceneError::UnknownMaterial)
}
pub fn get_mut(&mut self, id: MaterialId) -> Result<&mut Material, SceneError> {
self.slots.get_mut(id).ok_or(SceneError::UnknownMaterial)
}
fn validate(
device: &wgpu::Device,
materials: &[AuthoredMaterial],
images: &[Image],
) -> Result<(), SceneError> {
for material in materials {
for (index, _) in maps(material) {
if let Some(index) = index {
textures::validate(device, images.get(index).ok_or(SceneError::MissingImage)?)?;
}
}
let values = SurfaceMaterial::authored(material);
validate_anisotropy(&values, 0)?;
validate_alpha(&values)?;
validate_normal_layers(&values, authored_maps(material), material.wrap)?;
}
Ok(())
}
pub fn add(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
rays: &mut SceneRays,
materials: &[AuthoredMaterial],
images: &[Image],
) -> Result<Vec<MaterialId>, SceneError> {
Self::validate(device, materials, images)?;
let mut uses = vec![[false; 2]; images.len()];
for material in materials {
for (index, colour) in maps(material) {
if let Some(index) = index {
uses[index][usize::from(!colour)] = true;
}
}
}
for (image, &use_as) in images.iter().zip(&uses) {
textures::validate_uses(device, image, use_as)?;
}
let mut uploaded = vec![None; images.len()];
let mut added = Vec::new();
let result = self.upload(
device,
queue,
rays,
(materials, images),
&uses,
(&mut uploaded, &mut added),
);
if result.is_err() {
for &id in &added {
self.remove(rays, id)
.expect("a material just added has no users");
}
}
for texture in uploaded.into_iter().flatten() {
self.textures.free_unused(rays, texture);
}
result.map(|()| added)
}
fn upload(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
rays: &mut SceneRays,
(materials, images): (&[AuthoredMaterial], &[Image]),
uses: &[[bool; 2]],
(uploaded, added): (&mut [Option<usize>], &mut Vec<MaterialId>),
) -> Result<(), SceneError> {
for (index, (image, &use_as)) in images.iter().zip(uses).enumerate() {
if use_as != [false; 2] {
uploaded[index] = Some(self.textures.add(device, queue, rays, image, use_as)?);
}
}
for material in materials {
added.push(self.add_one(device, queue, rays, material, uploaded)?);
}
Ok(())
}
fn add_one(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
rays: &mut SceneRays,
material: &AuthoredMaterial,
uploaded: &[Option<usize>],
) -> Result<MaterialId, SceneError> {
let texture = |index: Option<usize>| index.map(|index| uploaded[index].unwrap());
let ray_word = |index: Option<usize>| {
texture(index).map_or(0, |texture| self.textures.get(texture).ray.start)
};
let values = SurfaceMaterial::authored(material);
let map_bits = authored_maps(material);
let uniform = MaterialUniform::new(&values, map_bits);
let record = rays.add_material(
device,
queue,
&uniform,
MaterialTextures {
base: ray_word(material.base_texture),
metallic_roughness: ray_word(material.mr_texture),
emission: ray_word(material.emissive_texture),
normal: ray_word(material.normal_texture),
bump: ray_word(material.bump_texture),
anisotropy: ray_word(material.anisotropy_texture),
},
material.wrap,
)?;
let values_buffer = buffer(
device,
"material",
bytemuck::bytes_of(&uniform),
wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
);
let baked = buffer(
device,
"baked material eligibility",
bytemuck::cast_slice(&[0u32; 4]),
wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
);
let bound = Bound {
base: texture(material.base_texture),
emission: texture(material.emissive_texture),
metallic_roughness: texture(material.mr_texture),
normal: texture(material.normal_texture),
bump: texture(material.bump_texture),
anisotropy: texture(material.anisotropy_texture),
wrap: material.wrap,
};
let group = self
.groups
.group(device, &self.textures, &bound, &values_buffer, &baked);
let mut distinct: Vec<usize> = maps(material)
.into_iter()
.filter_map(|(index, _)| texture(index))
.collect();
distinct.sort_unstable();
distinct.dedup();
for &texture in &distinct {
self.textures.use_texture(texture);
}
self.count(values.alpha, uniform.surface_moves(), 1);
Ok(self.slots.insert(Material {
values,
maps: map_bits,
group,
bound,
buffer: values_buffer,
baked,
casts_directional_shadow: material.casts_directional_shadow,
textures: distinct,
record,
users: HashMap::new(),
untangented: 0,
}))
}
pub fn set_anisotropy(&mut self, device: &wgpu::Device, anisotropy: u16) {
if self.groups.anisotropy == anisotropy {
return;
}
self.groups.anisotropy = anisotropy;
let remade: Vec<_> = self
.slots
.iter()
.map(|(id, material)| {
let bound = &material.bound;
let (buffer, baked) = (&material.buffer, &material.baked);
let group = self
.groups
.group(device, &self.textures, bound, buffer, baked);
(id, group)
})
.collect();
for (id, group) in remade {
self.slots.get_mut(id).expect("a live material").group = group;
}
}
pub fn set(
&mut self,
queue: &wgpu::Queue,
rays: &SceneRays,
id: MaterialId,
values: SurfaceMaterial,
) -> Result<(), SceneError> {
let material = self.slots.get_mut(id).ok_or(SceneError::UnknownMaterial)?;
validate_anisotropy(&values, material.untangented)?;
validate_alpha(&values)?;
validate_normal_layers(&values, material.maps, material.bound.wrap)?;
if material.values != values {
if material.values.caster_values() != values.caster_values() {
self.casters = super::next_generation();
}
let old = (material.values.alpha, material.surface_moves());
material.values = values;
let uniform = material.uniform();
crate::counters::write_buffer(queue, &material.buffer, 0, bytemuck::bytes_of(&uniform));
rays.write_material(queue, material.word(), &uniform);
self.count(old.0, old.1, -1);
self.count(values.alpha, uniform.surface_moves(), 1);
}
Ok(())
}
pub fn set_baked(&self, queue: &wgpu::Queue, rays: &SceneRays, id: MaterialId, baked: bool) {
let material = self.slots.get(id).expect("a live material");
crate::counters::write_buffer(
queue,
&material.baked,
0,
bytemuck::cast_slice(&[u32::from(baked), 0, 0, 0]),
);
rays.write_baked(queue, material.word(), baked);
}
pub fn remove(&mut self, rays: &mut SceneRays, id: MaterialId) -> Result<(), SceneError> {
if !self.get(id)?.users.is_empty() {
return Err(SceneError::MaterialInUse);
}
let material = self.slots.remove(id).unwrap();
self.count(material.values.alpha, material.surface_moves(), -1);
rays.free(material.record);
for texture in material.textures {
self.textures.release(rays, texture);
}
Ok(())
}
}
impl Scene {
pub fn add_materials(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
materials: &[AuthoredMaterial],
images: &[Image],
) -> Result<Vec<MaterialId>, SceneError> {
self.edited();
let ids = self
.materials
.add(device, queue, &mut self.rays, materials, images);
self.refresh_scene_group(device);
ids
}
pub fn material(&self, id: MaterialId) -> Result<SurfaceMaterial, SceneError> {
Ok(self.materials.get(id)?.values)
}
pub fn set_material(
&mut self,
queue: &wgpu::Queue,
id: MaterialId,
values: SurfaceMaterial,
) -> Result<(), SceneError> {
let alpha = self.materials.get(id)?.values.alpha;
if self.materials.get(id)?.values != values {
self.edited();
}
let blending = matches!(alpha, AlphaMode::Blend { .. }) != values.blended();
let users: Vec<ModelId> = self.materials.get(id)?.users.keys().copied().collect();
if blending {
let meshes: Vec<Vec<CandidateMesh>> = users
.iter()
.map(|&model| {
let mut meshes = self.candidate_meshes(model, self.drawn_model(model));
let owner = &self.drawn_model(model).meshes;
for (mesh, shape) in owner.iter().zip(&mut meshes) {
if mesh.material == id {
shape.blended = values.blended();
}
}
meshes
})
.collect();
let plan: Vec<_> = users
.iter()
.zip(&meshes)
.map(|(&model, meshes)| (model, meshes.as_slice(), None))
.collect();
if !self.candidates_fit(&plan) {
return Err(SceneError::DeviceLimit);
}
}
self.materials.set(queue, &self.rays, id, values)?;
if std::mem::discriminant(&alpha) != std::mem::discriminant(&values.alpha) {
self.models.classify_users(id, &self.materials);
}
if blending {
self.place_candidates_of(&users);
}
self.candidates
.material_changed(id, super::candidates::look(self.materials.get(id)?));
Ok(())
}
pub fn remove_material(&mut self, id: MaterialId) -> Result<(), SceneError> {
self.edited();
self.materials.remove(&mut self.rays, id)
}
}
mod group;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod normal_layer_tests;
mod validate;