use super::candidates::CandidateMesh;
use super::rays::SceneRays;
use super::shaders::Shaders;
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::bind::group2::MaterialMap;
use crate::shading::material::{MaterialMaps, MaterialUniform};
use group::{Bound, Groups};
use maps::{InEffect, authored, authored_maps};
use params::ParamBlock;
use std::collections::HashMap;
use std::ops::Range;
use validate::{
validate_alpha, validate_anisotropy, validate_core, validate_diffuse_transmission,
validate_iridescence, validate_normal_layers, validate_reflectance, validate_shader,
validate_sheen, validate_transmission,
};
fn params_block(
device: &wgpu::Device,
shaders: &Shaders,
values: &SurfaceMaterial,
) -> Option<ParamBlock> {
let shader = values.shader?;
let size = shaders
.get(shader.shader)
.expect("a validated material's shader lives")
.layout
.size;
Some(ParamBlock::new(device, size))
}
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,
params: Option<ParamBlock>,
pub parameters: u64,
}
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.bound.maps.maps())
}
pub fn parameters_changed(&self) -> bool {
self.params.as_ref().is_some_and(ParamBlock::changed)
}
pub fn record_moves(&self) -> bool {
self.uniform().surface_moves()
}
pub fn coverage_moves(&self) -> bool {
matches!(self.values.alpha, AlphaMode::Mask { .. }) && self.uniform().normal_layers_move()
}
pub fn displacement_bound(&self) -> f32 {
self.values
.shader
.map_or(0., |shader| shader.displacement_bound)
}
pub fn casts_local_shadow(&self, mask: Option<u32>) -> bool {
!self.values.blended() && self.enabled(mask)
}
pub fn shader_casts(&self) -> bool {
self.casts_local_shadow(None)
&& self.values.shader.is_some_and(|shader| {
shader.displacement_bound > 0.
|| matches!(self.values.alpha, AlphaMode::Mask { .. })
})
}
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,
blended: usize,
receivers: usize,
moving: usize,
moving_records: usize,
films: usize,
sheens: usize,
diffuse_transmission: usize,
transmissive: usize,
textures: Textures,
groups: Groups,
}
impl Materials {
pub fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Self {
Self {
slots: Slots::default(),
casters: 0,
blended: 0,
receivers: 0,
moving: 0,
moving_records: 0,
films: 0,
sheens: 0,
diffuse_transmission: 0,
transmissive: 0,
textures: Textures::default(),
groups: Groups::new(device, queue),
}
}
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
}
pub fn holds_moving_records(&self) -> bool {
self.moving_records > 0
}
pub fn tier(&self) -> crate::shading::bind::BindingTier {
self.groups.tier
}
pub fn shader_casts(&self) -> bool {
self.slots
.iter()
.any(|(_, material)| material.shader_casts())
}
pub fn set_parameters(&mut self, queue: &wgpu::Queue, id: MaterialId, bytes: &[u8]) {
let material = self.slots.get_mut(id).expect("a live material");
let changed = material
.params
.as_mut()
.expect("a material with a shader")
.set(queue, bytes);
if changed {
material.parameters = super::next_generation();
}
}
pub fn prepare_frame(&mut self, queue: &wgpu::Queue) {
for (_, material) in self.slots.iter_mut() {
if let Some(params) = &mut material.params {
params.prepare_frame(queue);
}
}
}
pub fn finish_frame(&mut self) {
for (_, material) in self.slots.iter_mut() {
if let Some(params) = &mut material.params {
params.finish_frame();
}
}
}
pub fn holds_films(&self) -> bool {
self.films > 0
}
pub fn holds_sheens(&self) -> bool {
self.sheens > 0
}
pub fn holds_diffuse_transmission(&self) -> bool {
self.diffuse_transmission > 0
}
pub fn holds_transmissive(&self) -> bool {
self.transmissive > 0
}
fn count(&mut self, values: &SurfaceMaterial, record_moves: bool, by: isize) {
let add = |count: &mut usize| *count = count.checked_add_signed(by).unwrap();
if values.iridescence > 0. {
add(&mut self.films);
}
if values.sheen_color.iter().any(|&channel| channel > 0.) {
add(&mut self.sheens);
}
if values.diffuse_transmission > 0. {
add(&mut self.diffuse_transmission);
}
if values.transmissive() {
add(&mut self.transmissive);
}
if values.blended() {
add(&mut self.blended);
if values.receives_screen_space_reflections() {
add(&mut self.receivers);
}
return;
}
if record_moves || values.shader.is_some() {
add(&mut self.moving);
}
if record_moves {
add(&mut self.moving_records);
}
}
#[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 map in MaterialMap::ALL {
if let Some(index) = authored(material, map) {
textures::validate(device, images.get(index).ok_or(SceneError::MissingImage)?)?;
}
}
let values = SurfaceMaterial::authored(material);
validate_core(&values)?;
validate_anisotropy(&values, 0)?;
validate_alpha(&values)?;
validate_reflectance(&values)?;
validate_iridescence(&values)?;
validate_transmission(&values)?;
validate_sheen(&values)?;
validate_diffuse_transmission(&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 in_effect: Vec<_> = materials
.iter()
.map(|material| InEffect::of(material, self.groups.tier))
.collect();
let mut uses = vec![[false; 2]; images.len()];
for (index, colour) in in_effect.iter().flat_map(InEffect::images) {
uses[index][usize::from(!colour)] = true;
}
for (image, &use_as) in images.iter().zip(&uses) {
textures::validate_uses(device, image, use_as)?;
if use_as != [false; 2] && rays.ray_data() == super::RayData::Enabled {
textures::validate_cpu_texels(image)?;
}
}
let mut uploaded = vec![None; images.len()];
let mut added = Vec::new();
let result = self.upload(
device,
queue,
rays,
(materials, &in_effect, 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, in_effect, images): (&[AuthoredMaterial], &[InEffect], &[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, &maps) in materials.iter().zip(in_effect) {
let maps = maps.map(|index| uploaded[index].expect("a map in effect is uploaded"));
added.push(self.add_one(device, queue, rays, material, maps)?);
}
Ok(())
}
fn add_one(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
rays: &mut SceneRays,
material: &AuthoredMaterial,
maps: InEffect,
) -> Result<MaterialId, SceneError> {
let values = SurfaceMaterial::authored(material);
let uniform = MaterialUniform::new(&values, maps.maps());
let record = rays.add_material(
device,
queue,
&uniform,
maps.ray_textures(|texture| self.textures.get(texture).ray.start),
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 {
maps,
wrap: material.wrap,
};
let group = self.groups.group(
device,
&self.textures,
&bound,
[&values_buffer, &baked],
None,
);
let mut distinct: Vec<usize> = maps.images().map(|(texture, _)| texture).collect();
distinct.sort_unstable();
distinct.dedup();
for &texture in &distinct {
self.textures.use_texture(texture);
}
self.count(&values, uniform.surface_moves(), 1);
Ok(self.slots.insert(Material {
values,
maps: authored_maps(material),
group,
bound,
buffer: values_buffer,
baked,
casts_directional_shadow: material.casts_directional_shadow,
textures: distinct,
record,
users: HashMap::new(),
untangented: 0,
parameters: 0,
params: None,
}))
}
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 buffers = [&material.buffer, &material.baked];
let group = self.groups.group(
device,
&self.textures,
bound,
buffers,
material.params.as_ref(),
);
(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, shaders): (&SceneRays, &Shaders),
id: MaterialId,
values: SurfaceMaterial,
) -> Result<(), SceneError> {
validate_shader(&values, shaders)?;
let material = self.slots.get_mut(id).ok_or(SceneError::UnknownMaterial)?;
validate_core(&values)?;
validate_anisotropy(&values, material.untangented)?;
validate_alpha(&values)?;
validate_reflectance(&values)?;
validate_iridescence(&values)?;
validate_transmission(&values)?;
validate_sheen(&values)?;
validate_diffuse_transmission(&values)?;
validate_normal_layers(&values, material.maps, material.bound.wrap)?;
if material.values != values {
if material.values.draws_other_geometry(&values) {
self.casters = super::next_generation();
}
let old = (material.values, material.record_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);
let shader = |values: &SurfaceMaterial| values.shader.map(|shader| shader.shader);
if shader(&old.0) != shader(&values) {
let device = &self.groups.device;
material.params = params_block(device, shaders, &values);
material.group = self.groups.group(
device,
&self.textures,
&material.bound,
[&material.buffer, &material.baked],
material.params.as_ref(),
);
}
self.count(&old.0, old.1, -1);
self.count(&values, 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, material.record_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> {
let ids = self
.materials
.add(device, queue, &mut self.rays, materials, images);
if ids.is_ok() {
self.edited();
}
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 old = self.materials.get(id)?.values;
if old != values {
self.edited();
}
let blending = old.blended() != 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, &self.shaders), id, values)?;
let shader = |values: &SurfaceMaterial| values.shader.map(|shader| shader.shader);
self.shaders.count(shader(&old), -1);
self.shaders.count(shader(&values), 1);
if blending || std::mem::discriminant(&old.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)?));
if old.draws_other_geometry(&values) {
for &model in &users {
self.instances.geometry_changed(model);
}
}
Ok(())
}
pub fn remove_material(&mut self, id: MaterialId) -> Result<(), SceneError> {
self.edited();
let shader = self.materials.get(id)?.values.shader;
self.materials.remove(&mut self.rays, id)?;
self.shaders.count(shader.map(|shader| shader.shader), -1);
Ok(())
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
impl Materials {
pub fn parameter_blocks(&self, id: MaterialId) -> Option<[&wgpu::Buffer; 2]> {
let params = self.slots.get(id)?.params.as_ref()?;
Some([¶ms.current, ¶ms.previous])
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod coat_film_tests;
mod group;
pub(crate) mod maps;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod normal_layer_tests;
mod params;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod sheen_transmission_tests;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tier_tests;
mod validate;