use crate::materials::{Material, PhysicalMaterial, StandardMaterial};
use crate::math::Color;
use super::parse::{UsdLayer, UsdPrim};
use super::value::UsdValue;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TextureSlot {
BaseColor,
Normal,
Roughness,
Metalness,
Emissive,
Occlusion,
Opacity,
Displacement,
}
#[derive(Debug, Clone)]
pub struct TextureRequest {
pub slot: TextureSlot,
pub file: String,
pub uv: String,
pub wrap_s: String,
pub wrap_t: String,
pub scale: [f32; 4],
pub bias: [f32; 4],
pub color_space: String,
}
#[derive(Debug, Clone)]
pub struct UsdMaterial {
pub material: Material,
pub textures: Vec<TextureRequest>,
}
pub fn bound_material_path(layer: &UsdLayer, prim_path: &str) -> Option<String> {
let mut path = prim_path.to_string();
loop {
if let Some(found) = layer
.prim_at(&path)
.and_then(|p| p.value("material:binding"))
.and_then(|v| v.as_str())
{
return Some(found.to_string());
}
match path.rfind('/') {
Some(0) | None => return None,
Some(at) => path.truncate(at),
}
}
}
fn split_connection(path: &str) -> (&str, &str) {
match path.rfind('.') {
Some(at) => (&path[..at], &path[at + 1..]),
None => (path, ""),
}
}
fn follow<'a>(layer: &'a UsdLayer, path: &str, depth: usize) -> Option<(&'a UsdPrim, String)> {
if depth > 16 {
return None;
}
let (prim_path, output) = split_connection(path);
let prim = layer.prim_at(prim_path)?;
if prim.type_name == "NodeGraph" || prim.value("info:id").is_none() {
if let Some(next) = prim.value(output).and_then(|v| v.as_str()) {
if next != path {
return follow(layer, next, depth + 1);
}
}
}
Some((prim, output.to_string()))
}
pub fn surface_shader<'a>(material: &'a UsdPrim, layer: &'a UsdLayer) -> Option<&'a UsdPrim> {
if let Some(path) = material.value("outputs:surface").and_then(|v| v.as_str()) {
if let Some((shader, _)) = follow(layer, path, 0) {
return Some(shader);
}
}
fn search(prim: &UsdPrim) -> Option<&UsdPrim> {
for child in &prim.children {
if child.value("info:id").and_then(|v| v.as_str()) == Some("UsdPreviewSurface") {
return Some(child);
}
if let Some(found) = search(child) {
return Some(found);
}
}
None
}
search(material).or_else(|| material.children.first())
}
enum Input<'a> {
Value(&'a UsdValue),
Texture(TextureRequest),
}
fn input<'a>(
shader: &'a UsdPrim,
name: &str,
slot: TextureSlot,
layer: &'a UsdLayer,
) -> Option<Input<'a>> {
let property = shader.property(&format!("inputs:{name}"))?;
if let UsdValue::Path(path) = &property.value {
let (source, _) = follow(layer, path, 0)?;
if source.value("info:id").and_then(|v| v.as_str()) == Some("UsdUVTexture") {
return Some(Input::Texture(texture_request(source, slot, layer)));
}
return None;
}
Some(Input::Value(&property.value))
}
fn texture_request(texture: &UsdPrim, slot: TextureSlot, layer: &UsdLayer) -> TextureRequest {
let text = |name: &str, fallback: &str| -> String {
texture
.value(&format!("inputs:{name}"))
.and_then(|v| v.as_str())
.unwrap_or(fallback)
.to_string()
};
let four = |name: &str, fallback: [f32; 4]| -> [f32; 4] {
let Some(value) = texture.value(&format!("inputs:{name}")) else {
return fallback;
};
let flat = value.flat_f32();
if flat.len() >= 4 {
[flat[0], flat[1], flat[2], flat[3]]
} else {
fallback
}
};
let uv = texture
.property("inputs:st")
.and_then(|p| match &p.value {
UsdValue::Path(path) => follow(layer, path, 0),
_ => None,
})
.and_then(|(reader, _)| reader.value("inputs:varname").and_then(|v| v.as_str()))
.unwrap_or("st")
.to_string();
TextureRequest {
slot,
file: text("file", ""),
uv,
wrap_s: text("wrapS", "repeat"),
wrap_t: text("wrapT", "repeat"),
scale: four("scale", [1.0; 4]),
bias: four("bias", [0.0; 4]),
color_space: text("sourceColorSpace", "auto"),
}
}
pub fn resolve(material: &UsdPrim, layer: &UsdLayer) -> UsdMaterial {
let mut standard = StandardMaterial::new(Color::new(0.8, 0.8, 0.8));
let mut textures = Vec::new();
let Some(shader) = surface_shader(material, layer) else {
return UsdMaterial {
material: standard.into(),
textures,
};
};
let mut colour = |name: &str, slot: TextureSlot, into: &mut Color| {
match input(shader, name, slot, layer) {
Some(Input::Value(value)) => {
let n = value.flat_f32();
if n.len() >= 3 {
*into = Color::new(n[0], n[1], n[2]);
}
}
Some(Input::Texture(request)) => textures.push(request),
None => {}
}
};
colour("diffuseColor", TextureSlot::BaseColor, &mut standard.color);
colour("emissiveColor", TextureSlot::Emissive, &mut standard.emissive);
let mut scalar = |name: &str, slot: TextureSlot, into: &mut f32| {
match input(shader, name, slot, layer) {
Some(Input::Value(value)) => {
if let Some(v) = value.as_f64() {
*into = v as f32;
}
}
Some(Input::Texture(request)) => textures.push(request),
None => {}
}
};
scalar("roughness", TextureSlot::Roughness, &mut standard.roughness);
scalar("metallic", TextureSlot::Metalness, &mut standard.metalness);
scalar("opacity", TextureSlot::Opacity, &mut standard.opacity);
scalar("occlusion", TextureSlot::Occlusion, &mut standard.ao_intensity);
for (name, slot) in [
("normal", TextureSlot::Normal),
("displacement", TextureSlot::Displacement),
] {
if let Some(Input::Texture(request)) = input(shader, name, slot, layer) {
textures.push(request);
}
}
let constant = |name: &str| match input(shader, name, TextureSlot::BaseColor, layer) {
Some(Input::Value(value)) => value.as_f64().map(|v| v as f32),
_ => None,
};
let ior = constant("ior");
let clearcoat = constant("clearcoat");
if ior.is_none() && clearcoat.is_none() {
return UsdMaterial {
material: standard.into(),
textures,
};
}
let physical = PhysicalMaterial {
color: standard.color,
emissive: standard.emissive,
roughness: standard.roughness,
metalness: standard.metalness,
opacity: standard.opacity,
ao_intensity: standard.ao_intensity,
side: standard.side,
ior: ior.unwrap_or(1.5),
clearcoat: clearcoat.unwrap_or(0.0),
clearcoat_roughness: constant("clearcoatRoughness").unwrap_or(0.0),
..Default::default()
};
UsdMaterial {
material: physical.into(),
textures,
}
}
#[derive(Debug, Clone)]
pub struct FaceSubset {
pub name: String,
pub faces: Vec<u32>,
pub material: Option<String>,
}
pub fn material_subsets(mesh: &UsdPrim) -> Vec<FaceSubset> {
mesh.children
.iter()
.filter(|child| child.type_name == "GeomSubset")
.filter(|child| {
child.value("familyName").and_then(|v| v.as_str()) == Some("materialBind")
})
.filter(|child| {
!matches!(
child.value("elementType").and_then(|v| v.as_str()),
Some(other) if other != "face"
)
})
.map(|child| FaceSubset {
name: child.name.clone(),
faces: child.value("indices").map(|v| v.flat_u32()).unwrap_or_default(),
material: child
.value("material:binding")
.and_then(|v| v.as_str())
.map(str::to_string),
})
.filter(|subset| !subset.faces.is_empty())
.collect()
}
pub fn unclaimed_faces(total: usize, subsets: &[FaceSubset]) -> Vec<u32> {
let mut claimed = vec![false; total];
for subset in subsets {
for face in &subset.faces {
if let Some(slot) = claimed.get_mut(*face as usize) {
*slot = true;
}
}
}
claimed
.iter()
.enumerate()
.filter(|(_, taken)| !**taken)
.map(|(i, _)| i as u32)
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use super::super::parse::parse;
use super::super::scene::to_scene;
fn layer() -> UsdLayer {
parse(include_str!("testdata/shade.usda")).expect("parses")
}
fn material_of(layer: &UsdLayer, prim: &str) -> UsdMaterial {
let path = bound_material_path(layer, prim).expect("a binding");
resolve(layer.prim_at(&path).expect("the material"), layer)
}
#[test]
fn the_surface_shader_is_the_one_the_connection_names() {
let layer = layer();
let material = layer.prim_at("/World/Materials/Textured").unwrap();
let shader = surface_shader(material, &layer).expect("a surface");
assert_eq!(shader.name, "Surface");
assert_eq!(
shader.value("info:id").and_then(|v| v.as_str()),
Some("UsdPreviewSurface")
);
}
#[test]
fn a_node_graph_is_followed_through() {
let layer = layer();
let material = layer.prim_at("/World/Materials/ViaGraph").unwrap();
let shader = surface_shader(material, &layer).expect("through the graph");
assert_eq!(shader.name, "Inner");
let resolved = resolve(material, &layer);
let Material::Standard(standard) = &resolved.material else {
panic!("standard");
};
assert!((standard.metalness - 0.8).abs() < 1e-5, "{}", standard.metalness);
assert!((standard.color.r - 1.0).abs() < 1e-5);
}
#[test]
fn connected_inputs_become_texture_requests() {
let layer = layer();
let resolved = material_of(&layer, "/World/Painted");
let mut slots: Vec<String> = resolved
.textures
.iter()
.map(|t| format!("{:?}", t.slot))
.collect();
slots.sort();
assert_eq!(slots, vec!["BaseColor", "Normal", "Roughness"]);
let albedo = resolved
.textures
.iter()
.find(|t| t.slot == TextureSlot::BaseColor)
.unwrap();
assert_eq!(albedo.file, "textures/albedo.png");
assert_eq!(albedo.wrap_s, "repeat");
assert_eq!(albedo.wrap_t, "clamp");
assert_eq!(albedo.uv, "st");
let Material::Standard(standard) = &resolved.material else {
panic!("standard");
};
assert!((standard.metalness - 0.25).abs() < 1e-5);
assert!((standard.emissive.r - 0.1).abs() < 1e-5);
}
#[test]
fn a_normal_map_keeps_its_scale_and_bias() {
let layer = layer();
let resolved = material_of(&layer, "/World/Painted");
let normal = resolved
.textures
.iter()
.find(|t| t.slot == TextureSlot::Normal)
.expect("a normal map");
assert_eq!(normal.scale, [2.0, 2.0, 2.0, 1.0]);
assert_eq!(normal.bias, [-1.0, -1.0, -1.0, 0.0]);
assert_eq!(normal.color_space, "raw", "a normal map is data, not colour");
}
#[test]
fn binding_is_inherited_down_the_namespace() {
let layer = layer();
assert_eq!(
bound_material_path(&layer, "/World/Group/NoBindingOfItsOwn").as_deref(),
Some("/World/Materials/Inherited"),
"should have picked up World's binding"
);
assert_eq!(
bound_material_path(&layer, "/World/Painted").as_deref(),
Some("/World/Materials/Textured")
);
let resolved = material_of(&layer, "/World/Group/NoBindingOfItsOwn");
let Material::Standard(standard) = &resolved.material else {
panic!("standard");
};
assert!((standard.color.b - 1.0).abs() < 1e-5, "the inherited blue");
assert!((standard.roughness - 0.9).abs() < 1e-5);
}
#[test]
fn the_scene_reports_its_textures() {
let scene = to_scene(&layer());
let painted = scene
.textures
.iter()
.find(|(name, _)| name == "Painted")
.expect("Painted asked for textures");
assert_eq!(painted.1.len(), 3);
assert!(scene.textures.iter().all(|(name, _)| name != "Graphed"));
}
#[test]
fn a_mesh_with_subsets_is_one_mesh_over_a_material_array() {
use crate::core::ObjectKind;
let layer = parse(include_str!("testdata/subset.usda")).unwrap();
let scene = to_scene(&layer);
let two_tone = scene
.arena
.nodes
.values()
.find(|n| n.name == "TwoTone")
.expect("the mesh");
let ObjectKind::Mesh(mesh) = &two_tone.kind else {
panic!("TwoTone should be a mesh");
};
assert!(two_tone.children.is_empty());
let groups: Vec<(u32, u32, u32)> = mesh
.geometry
.groups
.iter()
.map(|g| (g.start, g.count, g.material_index))
.collect();
assert_eq!(groups, [(0, 12, 0), (12, 12, 1)]);
let colour = |m: &Material| {
let Material::Standard(s) = m else { panic!("standard") };
[s.color.r, s.color.g, s.color.b]
};
assert_eq!(colour(&mesh.materials[0]), [0.0, 0.0, 1.0], "the subset's own material");
assert_eq!(colour(&mesh.materials[1]), [1.0, 0.0, 0.0], "the mesh's own material");
let p = &mesh.geometry.get_attribute("position").unwrap().array;
let index = mesh.geometry.index.as_ref().unwrap();
for &v in &index[..12] {
let x = p[v as usize * 3];
assert!((2.0..=3.0).contains(&x) || (6.0..=7.0).contains(&x), "{x}");
}
}
#[test]
fn each_part_gets_only_its_own_faces() {
use super::super::scene::mesh_geometry_of_faces;
let layer = parse(include_str!("testdata/subset.usda")).unwrap();
let mesh = layer.prim_at("/World/TwoTone").unwrap();
let subsets = material_subsets(mesh);
assert_eq!(subsets.len(), 1);
assert_eq!(subsets[0].faces, vec![1, 3]);
assert_eq!(unclaimed_faces(4, &subsets), vec![0, 2]);
let part = mesh_geometry_of_faces(mesh, 0, &subsets[0].faces).unwrap();
assert_eq!(part.index.as_ref().map(|i| i.len()), Some(12));
let rest = mesh_geometry_of_faces(mesh, 0, &unclaimed_faces(4, &subsets)).unwrap();
assert_eq!(rest.index.as_ref().map(|i| i.len()), Some(12));
}
#[test]
fn only_the_material_family_counts() {
let layer = parse(
r#"#usda 1.0
def Mesh "M"
{
int[] faceVertexCounts = [4, 4]
int[] faceVertexIndices = [0, 1, 2, 3, 4, 5, 6, 7]
point3f[] points = [
(0, 0, 0), (1, 0, 0), (1, 1, 0), (0, 1, 0),
(2, 0, 0), (3, 0, 0), (3, 1, 0), (2, 1, 0)
]
def GeomSubset "Selection"
{
uniform token elementType = "face"
uniform token familyName = "modellingSelection"
int[] indices = [0]
}
def GeomSubset "Points"
{
uniform token elementType = "point"
uniform token familyName = "materialBind"
int[] indices = [0, 1]
}
}
"#,
)
.unwrap();
let subsets = material_subsets(layer.prim_at("/M").unwrap());
assert!(
subsets.is_empty(),
"neither a different family nor a point subset assigns a material: {subsets:?}"
);
}
#[test]
fn the_binary_form_resolves_the_same_graph() {
let binary =
super::super::UsdLoader::parse_layer(include_bytes!("testdata/shade.usdc")).unwrap();
let resolved = material_of(&binary, "/World/Painted");
assert_eq!(resolved.textures.len(), 3);
assert_eq!(
resolved
.textures
.iter()
.find(|t| t.slot == TextureSlot::BaseColor)
.unwrap()
.file,
"textures/albedo.png"
);
}
}