use super::super::super::asset::Result;
use super::{GLTF_PROPERTY_KEYS, extension_texture};
fn number(
value: &serde_json::Value,
key: &str,
default: f64,
valid: impl Fn(f64) -> bool,
error: &dyn Fn(&str) -> String,
) -> Result<f32> {
let number = value
.get(key)
.map_or(Some(default), serde_json::Value::as_f64);
match number {
Some(number) if valid(number) => Ok(number as f32),
_ => Err(error(&format!("{key} is out of range")).into()),
}
}
fn known_properties(
value: &serde_json::Value,
known: &[&str],
error: &dyn Fn(&str) -> String,
) -> Result<()> {
let object = value
.as_object()
.ok_or_else(|| error("extension must be an object"))?;
match object
.keys()
.find(|key| !GLTF_PROPERTY_KEYS.contains(&key.as_str()) && !known.contains(&key.as_str()))
{
Some(key) => Err(error(&format!("unsupported property {key}")).into()),
None => Ok(()),
}
}
pub(super) struct Transmission<'a> {
pub factor: f32,
pub texture: Option<gltf::Texture<'a>>,
}
pub(super) fn read_transmission<'a>(
material: &gltf::Material<'a>,
document: &'a gltf::Document,
) -> Result<Transmission<'a>> {
let Some(value) = material.extension_value("KHR_materials_transmission") else {
return Ok(Transmission {
factor: 0.,
texture: None,
});
};
let name = material.name().unwrap_or("unnamed/default");
let error = |message: &str| format!("material {name}: transmission {message}");
known_properties(
value,
&["transmissionFactor", "transmissionTexture"],
&error,
)?;
if material.unlit() {
return Err(error("cannot be combined with KHR_materials_unlit").into());
}
Ok(Transmission {
factor: number(
value,
"transmissionFactor",
0.,
|v| (0.0..=1.0).contains(&v),
&error,
)?,
texture: extension_texture(value, "transmissionTexture", document, &error)?,
})
}
pub(super) struct Volume<'a> {
pub thickness: f32,
pub thickness_texture: Option<gltf::Texture<'a>>,
pub attenuation_distance: f32,
pub attenuation_color: [f32; 3],
}
pub(super) fn read_volume<'a>(
material: &gltf::Material<'a>,
document: &'a gltf::Document,
) -> Result<Volume<'a>> {
let Some(value) = material.extension_value("KHR_materials_volume") else {
return Ok(Volume {
thickness: 0.,
thickness_texture: None,
attenuation_distance: f32::INFINITY,
attenuation_color: [1.; 3],
});
};
let name = material.name().unwrap_or("unnamed/default");
let error = |message: &str| format!("material {name}: volume {message}");
known_properties(
value,
&[
"thicknessFactor",
"thicknessTexture",
"attenuationDistance",
"attenuationColor",
],
&error,
)?;
let attenuation_color = match value.get("attenuationColor") {
None => [1.; 3],
Some(color) => color
.as_array()
.filter(|channels| channels.len() == 3)
.and_then(|channels| {
let channels: Option<Vec<f32>> = channels
.iter()
.map(|v| {
v.as_f64()
.filter(|v| (0.0..=1.0).contains(v))
.map(|v| v as f32)
})
.collect();
channels.map(|c| [c[0], c[1], c[2]])
})
.ok_or_else(|| error("attenuationColor must be three numbers in 0..1"))?,
};
Ok(Volume {
thickness: number(
value,
"thicknessFactor",
0.,
|v| v >= 0. && (v as f32).is_finite(),
&error,
)?,
thickness_texture: extension_texture(value, "thicknessTexture", document, &error)?,
attenuation_distance: number(
value,
"attenuationDistance",
f64::INFINITY,
|v| v > 0. && !v.is_nan(),
&error,
)?,
attenuation_color,
})
}
pub(super) fn read_dispersion(material: &gltf::Material<'_>) -> Result<f32> {
let Some(value) = material.extension_value("KHR_materials_dispersion") else {
return Ok(0.);
};
let name = material.name().unwrap_or("unnamed/default");
let error = |message: &str| format!("material {name}: dispersion {message}");
known_properties(value, &["dispersion"], &error)?;
number(
value,
"dispersion",
0.,
|v| v >= 0. && (v as f32).is_finite(),
&error,
)
}