use crate::asset;
use crate::content::material::{AlphaMode, NormalLayer, SurfaceMaterial};
use crate::scene::SceneError;
use crate::shading::bind::group2::MaterialMap;
use crate::shading::material::{MAX_LAYER_CYCLES, MaterialMaps, layer_cycles};
use gltf::texture::WrappingMode;
pub(super) fn validate_core(values: &SurfaceMaterial) -> Result<(), SceneError> {
let unit = |value: f32| (0.0..=1.0).contains(&value);
let nonnegative = |value: &f32| value.is_finite() && *value >= 0.;
if unit(values.metallic)
&& unit(values.roughness)
&& unit(values.clearcoat)
&& unit(values.coat_roughness)
&& values.base[..3].iter().all(nonnegative)
&& unit(values.base[3])
&& values.emission.iter().all(nonnegative)
&& nonnegative(&values.environment_scale)
&& values.normal_scale.is_finite()
&& values.coat_normal_scale.is_finite()
&& values.bump_scale.is_finite()
{
Ok(())
} else {
Err(SceneError::InvalidMaterialFactors)
}
}
pub(super) fn validate_anisotropy(
values: &SurfaceMaterial,
untangented: u32,
) -> Result<(), SceneError> {
if !asset::valid_anisotropy(values.anisotropy_strength, values.anisotropy_rotation) {
return Err(SceneError::InvalidAnisotropy);
}
if values.anisotropy_strength > 0. && untangented > 0 {
return Err(SceneError::MissingAnisotropyTangents);
}
Ok(())
}
pub(super) fn validate_alpha(values: &SurfaceMaterial) -> Result<(), SceneError> {
match values.alpha {
AlphaMode::Mask { cutoff } if !(cutoff.is_finite() && cutoff >= 0.) => {
Err(SceneError::InvalidAlphaCutoff)
}
_ => Ok(()),
}
}
pub(super) fn validate_reflectance(values: &SurfaceMaterial) -> Result<(), SceneError> {
if !(values.ior >= 1.
&& (0.0..=1.0).contains(&values.specular)
&& values
.specular_color
.iter()
.all(|channel| channel.is_finite() && *channel >= 0.))
{
return Err(SceneError::InvalidReflectance);
}
if !(0.0..=1.0).contains(&values.occlusion_strength) {
return Err(SceneError::InvalidOcclusion);
}
Ok(())
}
pub(super) fn validate_iridescence(values: &SurfaceMaterial) -> Result<(), SceneError> {
if (0.0..=1.0).contains(&values.iridescence)
&& values.iridescence_ior.is_finite()
&& values.iridescence_ior >= 1.
&& values
.iridescence_thickness
.iter()
.all(|thickness| thickness.is_finite() && *thickness >= 0.)
{
Ok(())
} else {
Err(SceneError::InvalidIridescence)
}
}
pub(super) fn validate_transmission(values: &SurfaceMaterial) -> Result<(), SceneError> {
let unit = |value: f32| (0.0..=1.0).contains(&value);
let nonnegative = |value: f32| value.is_finite() && value >= 0.;
if unit(values.transmission)
&& !(values.unlit && values.transmission > 0.)
&& nonnegative(values.thickness)
&& nonnegative(values.dispersion)
&& values.attenuation_distance > 0.
&& values
.attenuation_color
.iter()
.all(|&channel| unit(channel))
{
Ok(())
} else {
Err(SceneError::InvalidTransmission)
}
}
pub(super) fn validate_sheen(values: &SurfaceMaterial) -> Result<(), SceneError> {
let unit = |value: &f32| (0.0..=1.0).contains(value);
if values.sheen_color.iter().all(unit) && unit(&values.sheen_roughness) {
Ok(())
} else {
Err(SceneError::InvalidSheen)
}
}
pub(super) fn validate_diffuse_transmission(values: &SurfaceMaterial) -> Result<(), SceneError> {
if (0.0..=1.0).contains(&values.diffuse_transmission)
&& values
.diffuse_transmission_color
.iter()
.all(|channel| channel.is_finite() && *channel >= 0.)
{
Ok(())
} else {
Err(SceneError::InvalidDiffuseTransmission)
}
}
pub(super) fn validate_normal_layers(
values: &SurfaceMaterial,
maps: MaterialMaps,
wrap: [WrappingMode; 2],
) -> Result<(), SceneError> {
let Some(layers) = values.normal_layers else {
return Ok(());
};
let valid = |layer: &NormalLayer| {
layer.velocity.iter().all(|speed| speed.is_finite())
&& layer.scale.is_finite()
&& layer.scale > 0.
&& layer.strength.is_finite()
&& layer_cycles(layer)
.iter()
.all(|cycles| cycles.abs() <= MAX_LAYER_CYCLES)
};
if maps.contains(MaterialMap::Normal)
&& wrap == [WrappingMode::Repeat; 2]
&& layers.iter().all(valid)
{
Ok(())
} else {
Err(SceneError::InvalidNormalLayers)
}
}
pub(super) fn validate_shader(
values: &SurfaceMaterial,
shaders: &crate::scene::shaders::Shaders,
) -> Result<(), SceneError> {
let Some(shader) = values.shader else {
return Ok(());
};
shaders.get(shader.shader)?;
if !(shader.displacement_bound.is_finite() && shader.displacement_bound >= 0.) {
return Err(SceneError::InvalidDisplacementBound);
}
Ok(())
}