use std::collections::{HashMap, HashSet};
use std::rc::Rc;
use super::clips;
use super::expr;
use super::parse::{Specifier, UsdLayer, UsdPrim, UsdProperty};
use super::value::{UsdReference, UsdValue};
use super::UsdError;
pub trait AssetResolver {
fn resolve(&self, anchor: &str, path: &str) -> Option<Vec<u8>>;
}
#[cfg(not(target_arch = "wasm32"))]
pub struct FileResolver;
#[cfg(not(target_arch = "wasm32"))]
impl AssetResolver for FileResolver {
fn resolve(&self, anchor: &str, path: &str) -> Option<Vec<u8>> {
std::fs::read(resolve_path(anchor, path)).ok()
}
}
#[derive(Default)]
pub struct MemoryResolver {
layers: HashMap<String, Vec<u8>>,
}
impl MemoryResolver {
pub fn new() -> Self {
Self::default()
}
pub fn insert(&mut self, name: impl Into<String>, data: impl Into<Vec<u8>>) -> &mut Self {
self.layers.insert(name.into(), data.into());
self
}
}
impl AssetResolver for MemoryResolver {
fn resolve(&self, anchor: &str, path: &str) -> Option<Vec<u8>> {
self.layers
.get(path)
.or_else(|| self.layers.get(&resolve_path(anchor, path)))
.cloned()
}
}
impl AssetResolver for super::UsdzArchive {
fn resolve(&self, anchor: &str, path: &str) -> Option<Vec<u8>> {
let resolved = resolve_path(anchor, path);
self.entries
.iter()
.find(|e| e.name == path || e.name == resolved)
.map(|e| e.data.clone())
}
}
pub fn resolve_path(anchor: &str, path: &str) -> String {
if path.starts_with('/') || anchor.is_empty() {
return path.to_string();
}
let directory = match anchor.rfind('/') {
Some(at) => &anchor[..at + 1],
None => return path.to_string(),
};
let joined_raw = format!("{directory}{path}");
let mut parts: Vec<&str> = Vec::new();
for part in joined_raw.split('/') {
match part {
"." | "" => {}
".." => {
parts.pop();
}
other => parts.push(other),
}
}
let joined = parts.join("/");
if directory.starts_with('/') {
format!("/{joined}")
} else {
joined
}
}
pub struct ComposeOptions {
pub load_payloads: bool,
pub variant_fallbacks: Vec<(String, String)>,
pub max_depth: usize,
}
impl Default for ComposeOptions {
fn default() -> Self {
Self {
load_payloads: true,
variant_fallbacks: Vec::new(),
max_depth: 64,
}
}
}
pub fn compose(
root: &UsdLayer,
root_name: &str,
resolver: &dyn AssetResolver,
options: &ComposeOptions,
) -> Result<UsdLayer, UsdError> {
let mut engine = Engine {
resolver,
options,
cache: HashMap::new(),
stacks: HashMap::new(),
variables: expr::Variables::new(),
};
let stack = engine.stack_for(root, root_name);
for layer in stack.iter().rev() {
engine
.variables
.extend(expr::variables_of(&layer.layer.metadata));
}
let mut out = UsdLayer::default();
for layer in stack.iter() {
for (key, value) in &layer.layer.metadata {
if matches!(bare_key(key), "subLayers" | "subLayerOffsets") {
continue;
}
if !out.metadata.iter().any(|(k, _)| k == key) {
out.metadata.push((key.clone(), value.clone()));
}
}
}
let relocations = relocations_of(&stack);
let names = ordered_names(stack.iter().map(|l| &l.layer.prims));
for name in names {
let sources: Vec<Source> = stack
.iter()
.filter_map(|l| {
l.layer.prims.iter().find(|p| p.name == name).map(|prim| {
let mut prim = prim.clone();
if !l.time.is_identity() {
shift_times(&mut prim, l.time);
}
Source {
prim,
anchor: l.name.clone(),
stack: stack.clone(),
time: l.time,
}
})
})
.collect();
if let Some(prim) = engine.compose_prim(&name, &sources, &mut HashSet::new(), 0) {
out.prims.push(prim);
}
}
for (from, to) in &relocations {
relocate(&mut out, from, to);
}
Ok(out)
}
fn relocations_of(stack: &[StackLayer]) -> Vec<(String, String)> {
let mut out: Vec<(String, String)> = Vec::new();
for layer in stack {
let Some(UsdValue::Dict(entries)) = layer.layer.meta("relocates") else {
continue;
};
for (from, to) in entries {
let Some(to) = to.as_str() else { continue };
if !out.iter().any(|(have, _)| have == from) {
out.push((from.clone(), to.to_string()));
}
}
}
out
}
fn relocate(layer: &mut UsdLayer, from: &str, to: &str) {
let (from_parent, from_name) = match from.rsplit_once('/') {
Some(split) => split,
None => return,
};
let (to_parent, to_name) = match to.rsplit_once('/') {
Some(split) => split,
None => return,
};
if from_parent != to_parent {
return;
}
let siblings = if from_parent.is_empty() {
&mut layer.prims
} else {
match prim_at_mut(layer, from_parent) {
Some(parent) => &mut parent.children,
None => return,
}
};
if let Some(prim) = siblings.iter_mut().find(|p| p.name == from_name) {
prim.name = to_name.to_string();
}
}
fn prim_at_mut<'a>(layer: &'a mut UsdLayer, path: &str) -> Option<&'a mut UsdPrim> {
let mut parts = path.trim_start_matches('/').split('/').filter(|p| !p.is_empty());
let first = parts.next()?;
let mut current = layer.prims.iter_mut().find(|p| p.name == first)?;
for part in parts {
current = current.children.iter_mut().find(|p| p.name == part)?;
}
Some(current)
}
struct StackLayer {
layer: UsdLayer,
name: String,
time: LayerOffset,
}
#[derive(Clone)]
struct Source {
prim: UsdPrim,
anchor: String,
stack: Rc<Vec<StackLayer>>,
time: LayerOffset,
}
#[derive(Clone, Copy, Debug, PartialEq)]
struct LayerOffset {
offset: f64,
scale: f64,
}
impl Default for LayerOffset {
fn default() -> Self {
Self {
offset: 0.0,
scale: 1.0,
}
}
}
impl LayerOffset {
fn is_identity(&self) -> bool {
self.offset == 0.0 && self.scale == 1.0
}
fn apply(&self, time: f64) -> f64 {
time * self.scale + self.offset
}
fn then(&self, inner: LayerOffset) -> LayerOffset {
LayerOffset {
offset: inner.offset * self.scale + self.offset,
scale: inner.scale * self.scale,
}
}
}
fn shift_times(prim: &mut UsdPrim, by: LayerOffset) {
for property in &mut prim.properties {
if let UsdValue::TimeSamples(samples) = &mut property.value {
for (time, _) in samples.iter_mut() {
*time = by.apply(*time);
}
}
}
for set in &mut prim.variant_sets {
for (_, body) in &mut set.variants {
shift_times(body, by);
}
}
for child in &mut prim.children {
shift_times(child, by);
}
}
struct Engine<'a> {
resolver: &'a dyn AssetResolver,
options: &'a ComposeOptions,
cache: HashMap<String, UsdLayer>,
stacks: HashMap<String, Rc<Vec<StackLayer>>>,
variables: expr::Variables,
}
impl Engine<'_> {
fn layer(&mut self, anchor: &str, path: &str) -> Option<UsdLayer> {
let path = &expr::evaluate(path, &self.variables)?;
let key = resolve_path(anchor, path);
if let Some(found) = self.cache.get(&key) {
return Some(found.clone());
}
let bytes = self.resolver.resolve(anchor, path)?;
let layer = super::UsdLoader::parse_layer(&bytes).ok()?;
self.cache.insert(key, layer.clone());
Some(layer)
}
fn layer_stack(
&mut self,
layer: &UsdLayer,
name: &str,
seen: &mut HashSet<String>,
depth: usize,
) -> Vec<StackLayer> {
if depth > self.options.max_depth || !seen.insert(resolve_path("", name)) {
return Vec::new();
}
let mut out = vec![StackLayer {
layer: layer.clone(),
name: name.to_string(),
time: LayerOffset::default(),
}];
for (key, value) in &layer.metadata {
if bare_key(key) != "subLayers" {
continue;
}
for (sub, offset) in sublayers_of(value) {
let Some(opened) = self.layer(name, &sub) else {
continue;
};
let resolved = resolve_path(name, &sub);
for mut inner in self.layer_stack(&opened, &resolved, seen, depth + 1) {
inner.time = offset.then(inner.time);
out.push(inner);
}
}
}
out
}
fn stack_for(&mut self, layer: &UsdLayer, name: &str) -> Rc<Vec<StackLayer>> {
let key = resolve_path("", name);
if let Some(found) = self.stacks.get(&key) {
return found.clone();
}
let built = Rc::new(self.layer_stack(layer, name, &mut HashSet::new(), 0));
self.stacks.insert(key, built.clone());
built
}
fn compose_prim(
&mut self,
name: &str,
sources: &[Source],
visiting: &mut HashSet<String>,
depth: usize,
) -> Option<UsdPrim> {
if sources.is_empty() || depth > self.options.max_depth {
return None;
}
let mut selections: Vec<(String, String)> = Vec::new();
for source in sources {
for (set, choice) in selections_of(&source.prim) {
let Some(choice) = expr::evaluate(&choice, &self.variables) else {
continue;
};
if !selections.iter().any(|(s, _)| *s == set) {
selections.push((set, choice));
}
}
}
for (set, choice) in &self.options.variant_fallbacks {
if !selections.iter().any(|(s, _)| s == set) {
selections.push((set.clone(), choice.clone()));
}
}
let mut opinions: Vec<Source> = sources.to_vec();
self.expand_arcs(sources, &selections, &mut opinions, visiting, depth);
if !opinions.iter().any(|o| o.prim.specifier == Specifier::Def) {
return None;
}
if let Some(UsdValue::Bool(false)) = opinions.iter().find_map(|o| o.prim.meta("active")) {
return None;
}
let specifier = opinions
.iter()
.map(|o| o.prim.specifier)
.find(|s| *s != Specifier::Over)
.unwrap_or(Specifier::Def);
let mut prim = UsdPrim {
specifier,
type_name: opinions
.iter()
.map(|o| o.prim.type_name.as_str())
.find(|t| !t.is_empty())
.unwrap_or_default()
.to_string(),
name: name.to_string(),
metadata: Vec::new(),
properties: Vec::new(),
children: Vec::new(),
variant_sets: Vec::new(),
};
for opinion in &opinions {
for (key, value) in &opinion.prim.metadata {
if is_arc_field(key) {
continue;
}
if !prim.metadata.iter().any(|(k, _)| k == key) {
prim.metadata.push((key.clone(), value.clone()));
}
}
for property in &opinion.prim.properties {
match prim.properties.iter_mut().find(|p| p.name == property.name) {
Some(existing) => fill_in(existing, property),
None => prim.properties.push(property.clone()),
}
}
}
if let Some(order) = opinions
.iter()
.find_map(|o| o.prim.meta_exact("reorder properties"))
.map(UsdValue::flat_tokens)
{
prim.properties.sort_by_key(|property| {
order
.iter()
.position(|o| *o == property.name.as_str())
.unwrap_or(usize::MAX)
});
}
self.apply_clips(&mut prim, sources);
let mut names = ordered_names(opinions.iter().map(|o| &o.prim.children));
if let Some(order) = opinions
.iter()
.find_map(|o| o.prim.meta_exact("reorder nameChildren"))
.map(UsdValue::flat_tokens)
{
names.sort_by_key(|name| {
order
.iter()
.position(|o| *o == name.as_str())
.unwrap_or(usize::MAX)
});
}
for child_name in names {
let child_sources: Vec<Source> = opinions
.iter()
.filter_map(|o| {
o.prim
.children
.iter()
.find(|c| c.name == child_name)
.map(|prim| Source {
prim: prim.clone(),
anchor: o.anchor.clone(),
stack: o.stack.clone(),
time: o.time,
})
})
.collect();
if let Some(child) = self.compose_prim(&child_name, &child_sources, visiting, depth + 1)
{
prim.children.push(child);
}
}
Some(prim)
}
fn apply_clips(&mut self, prim: &mut UsdPrim, sources: &[Source]) {
let sets = clips::sets_of(prim);
if sets.is_empty() {
return;
}
let anchor = sources
.first()
.map(|s| s.anchor.clone())
.unwrap_or_default();
for set in sets {
if set.assets.is_empty() || set.prim_path.is_empty() {
continue;
}
let manifest = (!set.manifest.is_empty())
.then(|| self.layer(&anchor, &set.manifest))
.flatten();
let names = clips::animated_names(manifest.as_ref(), &set.prim_path, prim);
let layers: Vec<Option<UsdLayer>> = set
.assets
.iter()
.map(|asset| self.layer(&anchor, asset))
.collect();
for name in names {
let schedule = clips::sample_times(&set, |index| {
layers
.get(index)
.and_then(|l| l.as_ref())
.and_then(|l| l.prim_at(&set.prim_path))
.and_then(|p| p.value(&name))
.and_then(|v| v.samples().map(|s| s.iter().map(|(t, _)| *t).collect()))
.unwrap_or_default()
});
if schedule.is_empty() {
continue;
}
let mut samples = Vec::with_capacity(schedule.len());
for (stage_time, clip_time) in schedule {
let Some(index) = set.clip_at(stage_time) else {
continue;
};
let Some(value) = layers
.get(index)
.and_then(|l| l.as_ref())
.and_then(|l| l.prim_at(&set.prim_path))
.and_then(|p| p.value(&name))
else {
continue;
};
samples.push((stage_time, value.at_time(clip_time)));
}
if samples.is_empty() {
continue;
}
if let Some(property) = prim.properties.iter_mut().find(|p| p.name == name) {
property.value = UsdValue::TimeSamples(samples);
}
}
}
}
fn expand_arcs(
&mut self,
sources: &[Source],
selections: &[(String, String)],
out: &mut Vec<Source>,
visiting: &mut HashSet<String>,
depth: usize,
) {
if depth > self.options.max_depth {
return;
}
for (arc, origin) in combine_arcs(sources, "inherits") {
self.follow(&sources[origin], &arc, selections, out, visiting, depth);
}
for source in sources {
for set in source.prim.variant_sets.clone() {
let chosen = selections
.iter()
.find(|(s, _)| *s == set.name)
.map(|(_, c)| c.clone())
.or_else(|| set.variants.first().map(|(n, _)| n.clone()));
let Some(body) = chosen.as_deref().and_then(|c| set.get(c)) else {
continue;
};
let inner = Source {
prim: body.clone(),
anchor: source.anchor.clone(),
stack: source.stack.clone(),
time: source.time,
};
out.push(inner.clone());
self.expand_arcs(
std::slice::from_ref(&inner),
selections,
out,
visiting,
depth + 1,
);
}
}
for field in ["references", "payload", "specializes"] {
if field == "payload" && !self.options.load_payloads {
continue;
}
for (arc, origin) in combine_arcs(sources, field) {
self.follow(&sources[origin], &arc, selections, out, visiting, depth);
}
}
}
fn follow(
&mut self,
source: &Source,
arc: &UsdReference,
selections: &[(String, String)],
out: &mut Vec<Source>,
visiting: &mut HashSet<String>,
depth: usize,
) {
let key = format!(
"{}|{}",
resolve_path(&source.anchor, &arc.asset),
arc.prim_path
);
if !visiting.insert(key.clone()) {
return;
}
let (stack, anchor) = if arc.is_internal() {
(source.stack.clone(), source.anchor.clone())
} else {
let Some(opened) = self.layer(&source.anchor, &arc.asset) else {
visiting.remove(&key);
return;
};
let anchor = resolve_path(&source.anchor, &arc.asset);
(self.stack_for(&opened, &anchor), anchor)
};
let target_path = if !arc.prim_path.is_empty() {
arc.prim_path.clone()
} else {
match stack.first().map(|l| &l.layer).and_then(default_prim_of) {
Some(name) => format!("/{name}"),
None => {
visiting.remove(&key);
return;
}
}
};
let time = source.time.then(LayerOffset {
offset: arc.offset,
scale: arc.scale,
});
let found: Vec<UsdPrim> = stack
.iter()
.filter_map(|l| l.layer.prim_at(&target_path).cloned())
.collect();
for mut target in found {
if !time.is_identity() {
shift_times(&mut target, time);
}
let inner = Source {
prim: target,
anchor: anchor.clone(),
stack: stack.clone(),
time,
};
let mut inner_selections = selections.to_vec();
for (set, choice) in selections_of(&inner.prim) {
let Some(choice) = expr::evaluate(&choice, &self.variables) else {
continue;
};
match inner_selections.iter().position(|(s, _)| *s == set) {
None => inner_selections.push((set, choice)),
Some(i) if self.is_fallback(&inner_selections[i]) => {
inner_selections[i] = (set, choice);
}
Some(_) => {}
}
}
out.push(inner.clone());
self.expand_arcs(
std::slice::from_ref(&inner),
&inner_selections,
out,
visiting,
depth + 1,
);
}
visiting.remove(&key);
}
fn is_fallback(&self, selection: &(String, String)) -> bool {
self.options.variant_fallbacks.iter().any(|f| f == selection)
}
}
fn selections_of(prim: &UsdPrim) -> Vec<(String, String)> {
let mut out = Vec::new();
for (key, value) in &prim.metadata {
if bare_key(key) != "variants" {
continue;
}
if let UsdValue::Dict(entries) = value {
for (set, choice) in entries {
if let Some(choice) = choice.as_str() {
out.push((set.clone(), choice.to_string()));
}
}
}
}
out
}
fn bare_key(key: &str) -> &str {
key.trim_start_matches("prepend ")
.trim_start_matches("append ")
.trim_start_matches("delete ")
.trim_start_matches("add ")
}
fn default_prim_of(layer: &UsdLayer) -> Option<String> {
layer
.meta("defaultPrim")
.and_then(|v| v.as_str())
.map(str::to_string)
.or_else(|| layer.prims.first().map(|p| p.name.clone()))
}
fn is_arc_field(key: &str) -> bool {
let bare = key
.trim_start_matches("prepend ")
.trim_start_matches("append ")
.trim_start_matches("delete ")
.trim_start_matches("add ");
matches!(
bare,
"references" | "payload" | "inherits" | "specializes" | "variants" | "variantSets"
)
}
fn combine_arcs(sources: &[Source], field: &str) -> Vec<(UsdReference, usize)> {
let mut out: Vec<(UsdReference, usize)> = Vec::new();
for (index, source) in sources.iter().enumerate().rev() {
let prim = &source.prim;
let of = |key: &str| -> Vec<UsdReference> {
let mut found = Vec::new();
if let Some(value) = prim.meta_exact(key) {
collect_arcs(value, &mut found);
}
found
};
let explicit = of(field);
let unqualified_is_explicit = prim.meta_exact(field).is_some();
if unqualified_is_explicit {
out = explicit.into_iter().map(|arc| (arc, index)).collect();
}
for arc in of(&format!("delete {field}")) {
out.retain(|(have, _)| have.asset != arc.asset || have.prim_path != arc.prim_path);
}
let prepended = of(&format!("prepend {field}"));
for arc in prepended.into_iter().rev() {
out.retain(|(have, _)| have.asset != arc.asset || have.prim_path != arc.prim_path);
out.insert(0, (arc, index));
}
for arc in of(&format!("append {field}"))
.into_iter()
.chain(of(&format!("add {field}")))
{
out.retain(|(have, _)| have.asset != arc.asset || have.prim_path != arc.prim_path);
out.push((arc, index));
}
let order = of(&format!("reorder {field}"));
if !order.is_empty() {
out.sort_by_key(|(arc, _)| {
order
.iter()
.position(|o| o.asset == arc.asset && o.prim_path == arc.prim_path)
.unwrap_or(usize::MAX)
});
}
}
out
}
fn collect_arcs(value: &UsdValue, out: &mut Vec<UsdReference>) {
match value {
UsdValue::Reference(r) => out.push(r.clone()),
UsdValue::Asset(a) => out.push(UsdReference::new(a.clone(), "")),
UsdValue::Path(p) => out.push(UsdReference::new("", p.clone())),
UsdValue::Array(items) => {
for item in items {
collect_arcs(item, out);
}
}
_ => {}
}
}
fn sublayers_of(value: &UsdValue) -> Vec<(String, LayerOffset)> {
match value {
UsdValue::Reference(r) => vec![(
r.asset.clone(),
LayerOffset {
offset: r.offset,
scale: r.scale,
},
)],
UsdValue::Array(items) => items.iter().flat_map(sublayers_of).collect(),
other => asset_paths(other)
.into_iter()
.map(|a| (a, LayerOffset::default()))
.collect(),
}
}
fn asset_paths(value: &UsdValue) -> Vec<String> {
match value {
UsdValue::Asset(a) => vec![a.clone()],
UsdValue::String(s) => vec![s.clone()],
UsdValue::Reference(r) => vec![r.asset.clone()],
UsdValue::Array(items) => items.iter().flat_map(asset_paths).collect(),
_ => Vec::new(),
}
}
fn ordered_names<'a>(lists: impl Iterator<Item = &'a Vec<UsdPrim>>) -> Vec<String> {
let mut out: Vec<String> = Vec::new();
for list in lists {
for prim in list {
if !out.contains(&prim.name) {
out.push(prim.name.clone());
}
}
}
out
}
fn fill_in(strong: &mut UsdProperty, weak: &UsdProperty) {
if strong.type_name.is_empty() {
strong.type_name = weak.type_name.clone();
}
if matches!(strong.value, UsdValue::None) && !matches!(weak.value, UsdValue::None) {
strong.value = weak.value.clone();
}
strong.uniform |= weak.uniform;
strong.relationship |= weak.relationship;
for (key, value) in &weak.metadata {
if !strong.metadata.iter().any(|(k, _)| k == key) {
strong.metadata.push((key.clone(), value.clone()));
}
}
}
pub fn mask(layer: &UsdLayer, paths: &[&str]) -> UsdLayer {
if paths.is_empty() {
return layer.clone();
}
let wanted: Vec<String> = paths
.iter()
.map(|p| {
let p = p.trim().trim_end_matches('/');
if p.starts_with('/') {
p.to_string()
} else {
format!("/{p}")
}
})
.filter(|p| p.len() > 1)
.collect();
let mut out = layer.clone();
out.prims = layer
.prims
.iter()
.filter_map(|prim| keep(prim, "", &wanted))
.collect();
out
}
fn keep(prim: &UsdPrim, parent: &str, wanted: &[String]) -> Option<UsdPrim> {
let path = format!("{parent}/{}", prim.name);
if wanted
.iter()
.any(|w| path == *w || path.starts_with(&format!("{w}/")))
{
return Some(prim.clone());
}
let prefix = format!("{path}/");
if !wanted.iter().any(|w| w.starts_with(&prefix)) {
return None;
}
let mut kept = prim.clone();
kept.children = prim
.children
.iter()
.filter_map(|child| keep(child, &path, wanted))
.collect();
Some(kept)
}
#[cfg(test)]
mod tests {
#[test]
fn a_population_mask_keeps_ancestors_and_descendants() {
let layer = super::super::parse::parse(include_str!("testdata/mask/src.usda")).unwrap();
let masked = mask(&layer, &["/World/Keep"]);
let paths: Vec<String> = masked
.prims_by_path()
.into_iter()
.map(|(p, _)| p)
.collect();
assert_eq!(paths, ["/World", "/World/Keep", "/World/Keep/Inner"]);
assert!(
masked.prim_at("/World").unwrap().value("xformOp:translate").is_some(),
"the ancestor keeps the transform that places what was kept"
);
}
#[test]
fn a_population_mask_unions_and_defaults_to_everything() {
let layer = super::super::parse::parse(include_str!("testdata/mask/src.usda")).unwrap();
let both: Vec<String> = mask(&layer, &["/World/Keep", "/Other"])
.prims_by_path()
.into_iter()
.map(|(p, _)| p)
.collect();
assert_eq!(
both,
[
"/World",
"/World/Keep",
"/World/Keep/Inner",
"/Other",
"/Other/Elsewhere"
]
);
assert_eq!(
mask(&layer, &[]).prims_by_path().len(),
layer.prims_by_path().len()
);
}
#[test]
fn a_mask_that_matches_nothing_keeps_nothing() {
let layer = super::super::parse::parse(include_str!("testdata/mask/src.usda")).unwrap();
assert!(mask(&layer, &["/Nowhere"]).prims.is_empty());
}
#[test]
fn a_mask_through_a_missing_prim_keeps_the_chain_that_exists() {
let layer = super::super::parse::parse(include_str!("testdata/mask/src.usda")).unwrap();
let masked = mask(&layer, &["/World/Keep/Missing"]);
let paths: Vec<String> = masked.prims_by_path().into_iter().map(|(p, _)| p).collect();
assert_eq!(paths, ["/World", "/World/Keep"]);
assert!(masked.prim_at("/World/Keep").unwrap().value("size").is_some());
let deep = mask(&layer, &["/World/Drop/Gone/Deeper"]);
let paths: Vec<String> = deep.prims_by_path().into_iter().map(|(p, _)| p).collect();
assert_eq!(paths, ["/World", "/World/Drop", "/World/Drop/Gone"]);
assert!(deep.prim_at("/World/Drop/Gone").unwrap().value("radius").is_some());
}
use super::*;
use super::super::parse::parse;
use super::super::write::layer_to_usda;
fn pipeline() -> MemoryResolver {
let mut r = MemoryResolver::new();
r.insert("asset.usda", include_str!("testdata/comp/asset.usda"))
.insert("base.usda", include_str!("testdata/comp/base.usda"))
.insert("shot.usda", include_str!("testdata/comp/shot.usda"));
r
}
fn compose_shot(options: &ComposeOptions) -> UsdLayer {
let root = parse(include_str!("testdata/comp/shot.usda")).expect("the shot parses");
compose(&root, "shot.usda", &pipeline(), options).expect("composes")
}
#[test]
fn a_composed_stage_matches_what_openusd_flattens() {
let ours = compose_shot(&ComposeOptions::default());
let theirs = parse(include_str!("testdata/comp/flat.usda")).expect("the truth parses");
let chair = ours
.prim_at("/Room/Chair1")
.expect("the referenced chair is there");
let expected = theirs.prim_at("/Room/Chair1").unwrap();
assert_eq!(chair.type_name, expected.type_name, "type name");
assert_eq!(chair.type_name, "Xform");
for property in &expected.properties {
let mine = chair
.value(&property.name)
.unwrap_or_else(|| panic!("{} is missing", property.name));
if let Some(text) = property.value.as_str() {
assert_eq!(mine.as_str(), Some(text), "{}", property.name);
} else {
assert_eq!(
mine.flat_f32(),
property.value.flat_f32(),
"{}",
property.name
);
}
}
let seat = ours.prim_at("/Room/Chair1/Seat").expect("the seat");
assert_eq!(seat.type_name, "Mesh");
assert_eq!(seat.value("points").unwrap().flat_f32().len(), 9);
}
#[test]
fn nothing_is_missing_and_nothing_is_invented() {
let ours = compose_shot(&ComposeOptions::default());
let theirs = parse(include_str!("testdata/comp/flat.usda")).unwrap();
let ours_paths: Vec<String> = ours.prims_by_path().into_iter().map(|(p, _)| p).collect();
let theirs_paths: Vec<String> =
theirs.prims_by_path().into_iter().map(|(p, _)| p).collect();
assert_eq!(ours_paths, theirs_paths, "the set of prims differs");
for (path, expected) in theirs.prims_by_path() {
let mine = ours.prim_at(&path).unwrap();
assert_eq!(mine.type_name, expected.type_name, "type of {path}");
let mut mine_names: Vec<&str> =
mine.properties.iter().map(|p| p.name.as_str()).collect();
let mut expected_names: Vec<&str> =
expected.properties.iter().map(|p| p.name.as_str()).collect();
mine_names.sort();
expected_names.sort();
assert_eq!(mine_names, expected_names, "properties of {path}");
for property in &expected.properties {
let mine = mine.value(&property.name).unwrap();
match property.value.as_str() {
Some(text) => assert_eq!(mine.as_str(), Some(text), "{path}.{}", property.name),
None => assert_eq!(
mine.flat_f32(),
property.value.flat_f32(),
"{path}.{}",
property.name
),
}
}
}
}
#[test]
fn a_binary_pipeline_composes_to_the_same_thing_as_a_text_one() {
let mut binary = MemoryResolver::new();
binary
.insert("asset.usda", include_bytes!("testdata/comp/asset.usdc").as_slice())
.insert("base.usda", include_bytes!("testdata/comp/base.usdc").as_slice());
let root = super::super::UsdLoader::parse_layer(include_bytes!(
"testdata/comp/shot.usdc"
))
.expect("the binary shot parses");
let from_binary = compose(&root, "shot.usda", &binary, &ComposeOptions::default())
.expect("the binary pipeline composes");
let from_text = compose_shot(&ComposeOptions::default());
let paths = |l: &UsdLayer| -> Vec<String> {
l.prims_by_path().into_iter().map(|(p, _)| p).collect()
};
assert_eq!(paths(&from_binary), paths(&from_text), "different prims");
for (path, expected) in from_text.prims_by_path() {
let mine = from_binary.prim_at(&path).unwrap();
assert_eq!(mine.type_name, expected.type_name, "type of {path}");
for property in &expected.properties {
let mine = mine
.value(&property.name)
.unwrap_or_else(|| panic!("{path}.{} missing", property.name));
match property.value.as_str() {
Some(text) => assert_eq!(mine.as_str(), Some(text), "{path}.{}", property.name),
None => assert_eq!(
mine.flat_f32(),
property.value.flat_f32(),
"{path}.{}",
property.name
),
}
}
}
}
#[test]
fn every_arc_spelling_survives_the_binary_form() {
let from_text = parse(include_str!("testdata/comp/arcs.usda")).unwrap();
let from_binary =
super::super::UsdLoader::parse_layer(include_bytes!("testdata/comp/arcs.usdc"))
.expect("parses");
let a = from_binary.prim_at("/A").expect("A");
let refs = a.meta("references").expect("references survived");
let refs = refs.references();
assert_eq!(refs.len(), 3, "{refs:?}");
assert_eq!(refs[0].asset, "asset.usda");
assert_eq!(refs[0].prim_path, "/Chair");
assert_eq!(refs[1].asset, "other.usda");
assert_eq!(refs[1].prim_path, "", "no prim path means the default prim");
assert_eq!(refs[2].asset, "", "an internal arc has no asset");
assert_eq!(refs[2].prim_path, "/A/Local");
let payload = a.meta("payload").expect("payload survived").references();
assert_eq!(payload.len(), 1);
assert_eq!(payload[0].asset, "heavy.usda");
assert_eq!(payload[0].prim_path, "/Deep");
assert_eq!(
a.meta("specializes").unwrap().references()[0].prim_path,
"/A/Base"
);
let b = from_binary.prim_at("/B").unwrap().meta("references").unwrap();
let b = b.references();
assert_eq!((b[0].offset, b[0].scale), (10.0, 2.0));
let text_refs = from_text.prim_at("/A").unwrap().meta("references").unwrap();
assert_eq!(text_refs.references().len(), 3);
}
#[test]
fn variants_survive_the_binary_form() {
let layer = super::super::UsdLoader::parse_layer(include_bytes!(
"testdata/comp/asset.usdc"
))
.unwrap();
let chair = layer.prim_at("/Chair").expect("the chair");
let set = chair
.variant_sets
.iter()
.find(|s| s.name == "look")
.expect("the look variant set");
let mut names: Vec<&str> = set.variants.iter().map(|(n, _)| n.as_str()).collect();
names.sort();
assert_eq!(names, vec!["oak", "steel"]);
let oak = set.get("oak").expect("oak");
assert_eq!(
oak.value("primvars:displayColor").unwrap().flat_f32(),
vec![0.6, 0.4, 0.2]
);
let UsdValue::Dict(entries) = chair.meta("variants").expect("variants") else {
panic!("expected a dictionary");
};
assert_eq!(entries[0].0, "look");
assert_eq!(entries[0].1.as_str(), Some("oak"));
assert_eq!(
chair.meta("inherits").unwrap().references()[0].prim_path,
"/Furniture"
);
}
#[test]
fn an_arc_shifts_the_animation_it_pulls_in() {
let mut r = MemoryResolver::new();
r.insert("clip.usda", include_str!("testdata/comp/offset_clip.usda"));
let root = parse(include_str!("testdata/comp/offset_use.usda")).unwrap();
let out = compose(&root, "use.usda", &r, &ComposeOptions::default()).unwrap();
let samples = out
.prim_at("/Shifted")
.expect("the referenced prim")
.value("xformOp:translate")
.expect("still animated")
.samples()
.expect("time samples")
.to_vec();
let theirs = parse(include_str!("testdata/comp/offset_flat.usda")).unwrap();
let expected = theirs
.prim_at("/Shifted")
.unwrap()
.value("xformOp:translate")
.unwrap()
.samples()
.unwrap();
assert_eq!(samples.len(), expected.len());
for (mine, theirs) in samples.iter().zip(expected) {
assert_eq!(mine.0, theirs.0, "sample time");
assert_eq!(mine.1.flat_f32(), theirs.1.flat_f32(), "sample value");
}
assert_eq!(samples[0].0, 100.0);
assert_eq!(samples[1].0, 120.0);
}
#[test]
fn nested_arcs_compose_their_shifts() {
let mut r = MemoryResolver::new();
r.insert("clip.usda", include_str!("testdata/comp/offset_clip.usda"))
.insert(
"mid.usda",
"#usda 1.0\n(\n defaultPrim = \"Mid\"\n)\ndef Xform \"Mid\" (\n references = @clip.usda@ (offset = 10; scale = 2)\n)\n{\n}\n",
);
let root = parse(
"#usda 1.0\ndef Xform \"Top\" (\n references = @mid.usda@ (offset = 100; scale = 3)\n)\n{\n}\n",
)
.unwrap();
let out = compose(&root, "root.usda", &r, &ComposeOptions::default()).unwrap();
let samples = out
.prim_at("/Top")
.unwrap()
.value("xformOp:translate")
.unwrap()
.samples()
.unwrap()
.to_vec();
assert_eq!(samples[0].0, 130.0, "0 -> (0*2+10)*3+100");
assert_eq!(samples[1].0, 190.0, "10 -> (10*2+10)*3+100");
}
#[test]
fn delete_and_reorder_compose_as_openusd_does() {
let mut r = MemoryResolver::new();
r.insert("a.usda", include_str!("testdata/listops/a.usda"))
.insert("b.usda", include_str!("testdata/listops/b.usda"))
.insert("base.usda", include_str!("testdata/listops/base.usda"));
let root = parse(include_str!("testdata/listops/shot.usda")).unwrap();
let ours = compose(&root, "shot.usda", &r, &ComposeOptions::default()).unwrap();
let theirs = parse(include_str!("testdata/listops/flat.usda")).unwrap();
let holder = ours.prim_at("/Root/Holder").expect("Holder");
assert!(
holder.value("fromA").is_none(),
"the deleted reference still applied: {:?}",
holder.properties
);
assert_eq!(holder.value("fromB").unwrap().flat_f32(), vec![2.0]);
let order: Vec<&str> = ours
.prim_at("/Root/Ordered")
.unwrap()
.children
.iter()
.map(|c| c.name.as_str())
.collect();
assert_eq!(order, vec!["Third", "First", "Second"]);
let expected: Vec<&str> = theirs
.prim_at("/Root/Ordered")
.unwrap()
.children
.iter()
.map(|c| c.name.as_str())
.collect();
assert_eq!(order, expected);
}
#[test]
fn a_reorder_is_kept_as_well_as_applied() {
let mut r = MemoryResolver::new();
r.insert("base.usda", include_str!("testdata/listops/base.usda"));
let root = parse(include_str!("testdata/listops/shot.usda")).unwrap();
let ours = compose(&root, "shot.usda", &r, &ComposeOptions::default()).unwrap();
assert!(
ours.prim_at("/Root/Ordered")
.unwrap()
.meta_exact("reorder nameChildren")
.is_some(),
"the reorder statement was consumed rather than kept"
);
}
#[test]
fn the_strongest_layer_wins() {
let ours = compose_shot(&ComposeOptions::default());
assert_eq!(
ours.prim_at("/Room/Chair1")
.unwrap()
.value("xformOp:translate")
.unwrap()
.flat_f32(),
vec![9.0, 1.0, 0.0],
"the shot's override should win over the base layer and the asset"
);
}
#[test]
fn a_variant_selection_can_be_overridden_from_a_stronger_layer() {
let ours = compose_shot(&ComposeOptions::default());
let colour = ours
.prim_at("/Room/Chair1")
.unwrap()
.value("primvars:displayColor")
.unwrap()
.flat_f32();
assert_eq!(colour, vec![0.7, 0.7, 0.75], "steel, not oak");
}
#[test]
fn a_referenced_prim_keeps_its_own_variant_selection() {
let stage = |placement: &str| {
let text = format!(
"#usda 1.0\n\
class Xform \"Piece\" (\n\
\x20 prepend variantSets = \"finish\"\n\
\x20 variants = {{\n string finish = \"enamel\"\n }}\n\
)\n{{\n\
\x20 variantSet \"finish\" = {{\n\
\x20 \"brass\" {{\n float weight = 1\n }}\n\
\x20 \"enamel\" {{\n float weight = 2\n }}\n\
\x20 }}\n}}\n\
def Xform \"A\" (\n prepend references = </Piece>{placement}\n)\n{{\n}}\n"
);
let root = parse(&text).unwrap();
let composed =
compose(&root, "root.usda", &MemoryResolver::new(), &ComposeOptions::default())
.unwrap();
composed.prim_at("/A").unwrap().value("weight").unwrap().flat_f32()
};
assert_eq!(stage(""), vec![2.0], "the class's own selection, not the first variant");
assert_eq!(
stage("\n variants = {\n string finish = \"brass\"\n }"),
vec![1.0],
"the placement's selection is stronger"
);
}
#[test]
fn an_inherited_class_contributes_but_does_not_appear() {
let ours = compose_shot(&ComposeOptions::default());
let chair = ours.prim_at("/Room/Chair1").unwrap();
assert_eq!(chair.value("purpose").unwrap().as_str(), Some("render"));
assert_eq!(chair.value("weight").unwrap().flat_f32(), vec![10.0]);
}
#[test]
fn a_payload_can_be_left_unloaded() {
let mut r = MemoryResolver::new();
r.insert(
"heavy.usda",
"#usda 1.0\n(\n defaultPrim = \"Heavy\"\n)\ndef Mesh \"Heavy\"\n{\n int[] faceVertexCounts = [3]\n}\n",
);
let root = parse(
"#usda 1.0\ndef Xform \"Holder\" (\n payload = @heavy.usda@\n)\n{\n}\n",
)
.unwrap();
let loaded = compose(&root, "root.usda", &r, &ComposeOptions::default()).unwrap();
assert!(loaded.prim_at("/Holder").unwrap().value("faceVertexCounts").is_some());
let unloaded = compose(
&root,
"root.usda",
&r,
&ComposeOptions {
load_payloads: false,
..Default::default()
},
)
.unwrap();
let holder = unloaded.prim_at("/Holder").expect("the prim is still there");
assert!(
holder.value("faceVertexCounts").is_none(),
"an unloaded payload should bring nothing in"
);
}
#[test]
fn a_cycle_terminates() {
let mut r = MemoryResolver::new();
r.insert(
"a.usda",
"#usda 1.0\n(\n defaultPrim = \"A\"\n)\ndef Xform \"A\" (\n references = @b.usda@\n)\n{\n}\n",
)
.insert(
"b.usda",
"#usda 1.0\n(\n defaultPrim = \"B\"\n)\ndef Xform \"B\" (\n references = @a.usda@\n)\n{\n}\n",
);
let root = parse(include_str!("testdata/comp/asset.usda")).unwrap();
let _ = compose(&root, "asset.usda", &r, &ComposeOptions::default());
let a = parse("#usda 1.0\ndef Xform \"Top\" (\n references = @a.usda@\n)\n{\n}\n").unwrap();
let out = compose(&a, "root.usda", &r, &ComposeOptions::default()).unwrap();
assert!(out.prim_at("/Top").is_some(), "it should still compose");
}
#[test]
fn a_sublayer_cycle_terminates() {
let mut r = MemoryResolver::new();
r.insert(
"loop.usda",
"#usda 1.0\n(\n subLayers = [\n @loop.usda@\n ]\n)\ndef Xform \"X\"\n{\n}\n",
);
let root = parse(
"#usda 1.0\n(\n subLayers = [\n @loop.usda@\n ]\n)\n",
)
.unwrap();
let out = compose(&root, "root.usda", &r, &ComposeOptions::default()).unwrap();
assert!(out.prim_at("/X").is_some());
}
#[test]
fn paths_resolve_against_the_layer_that_named_them() {
assert_eq!(resolve_path("shots/010/shot.usda", "asset.usda"), "shots/010/asset.usda");
assert_eq!(resolve_path("shots/010/shot.usda", "../lib/chair.usda"), "shots/lib/chair.usda");
assert_eq!(resolve_path("shots/010/shot.usda", "./here.usda"), "shots/010/here.usda");
assert_eq!(resolve_path("shot.usda", "asset.usda"), "asset.usda");
assert_eq!(resolve_path("shots/shot.usda", "/abs/a.usda"), "/abs/a.usda");
assert_eq!(resolve_path("", "a.usda"), "a.usda");
}
#[test]
fn composing_a_flat_layer_is_a_no_op() {
let layer = parse(include_str!("testdata/rich.usda")).unwrap();
let composed = compose(
&layer,
"rich.usda",
&MemoryResolver::new(),
&ComposeOptions::default(),
)
.unwrap();
assert_eq!(layer_to_usda(&composed), layer_to_usda(&layer));
}
}
#[cfg(test)]
mod gaps {
use super::*;
use super::super::parse::parse;
#[test]
fn a_blocked_value_stays_blocked() {
let mut r = MemoryResolver::new();
r.insert("weak.usda", include_str!("testdata/block/weak.usda"));
let root = parse(include_str!("testdata/block/strong.usda")).unwrap();
let ours = compose(&root, "strong.usda", &r, &ComposeOptions::default()).unwrap();
let theirs = parse(include_str!("testdata/block/flat.usda")).unwrap();
let root_prim = ours.prim_at("/Root").expect("Root");
assert_eq!(
root_prim.value("blocked"),
Some(&UsdValue::Block),
"the block should have stopped the weaker `= 2`"
);
assert_eq!(root_prim.value("kept").unwrap().flat_f32(), vec![1.0]);
assert_eq!(root_prim.value("stamp").unwrap().flat_f32(), vec![1.0, 2.0, 3.0]);
assert_eq!(root_prim.value("when").unwrap().flat_f32(), vec![24.0]);
assert_eq!(
theirs.prim_at("/Root").unwrap().value("blocked"),
Some(&UsdValue::Block)
);
}
#[test]
fn an_expression_in_an_asset_path_resolves() {
let mut r = MemoryResolver::new();
r.insert("red_asset.usda", include_str!("testdata/expr/red_asset.usda"))
.insert("blue_asset.usda", include_str!("testdata/expr/blue_asset.usda"));
let root = parse(include_str!("testdata/expr/expr.usda")).unwrap();
let ours = compose(&root, "expr.usda", &r, &ComposeOptions::default()).unwrap();
let thing = ours.prim_at("/Root/Thing").expect("the referenced prim");
assert_eq!(
thing.value("which").unwrap().flat_f32(),
vec![1.0],
"COLOR was red, so the red asset should have been pulled in"
);
let theirs = parse(include_str!("testdata/expr/flat.usda")).unwrap();
assert_eq!(
thing.value("which").unwrap().flat_f32(),
theirs.prim_at("/Root/Thing").unwrap().value("which").unwrap().flat_f32()
);
}
#[test]
fn changing_the_variable_changes_the_asset() {
let mut r = MemoryResolver::new();
r.insert("red_asset.usda", include_str!("testdata/expr/red_asset.usda"))
.insert("blue_asset.usda", include_str!("testdata/expr/blue_asset.usda"));
let root = parse(
&include_str!("testdata/expr/expr.usda").replace("\"red\"", "\"blue\""),
)
.unwrap();
let ours = compose(&root, "expr.usda", &r, &ComposeOptions::default()).unwrap();
assert_eq!(
ours.prim_at("/Root/Thing").unwrap().value("which").unwrap().flat_f32(),
vec![2.0]
);
}
#[test]
fn an_unresolvable_expression_opens_nothing() {
let mut r = MemoryResolver::new();
r.insert("red_asset.usda", include_str!("testdata/expr/red_asset.usda"));
let root = parse(
r#"#usda 1.0
def Xform "Root"
{
def Scope "Thing" (
references = @`"${NOT_SET}_asset.usda"`@
)
{
}
}
"#,
)
.unwrap();
let ours = compose(&root, "expr.usda", &r, &ComposeOptions::default()).unwrap();
assert!(
ours.prim_at("/Root/Thing").unwrap().value("which").is_none(),
"an undefined variable should not have resolved to anything"
);
}
#[test]
fn an_inactive_prim_is_not_on_the_stage() {
let root = parse(include_str!("testdata/gaps/active.usda")).unwrap();
let ours = compose(
&root,
"active.usda",
&MemoryResolver::new(),
&ComposeOptions::default(),
)
.unwrap();
let theirs = parse(include_str!("testdata/gaps/flat_active.usda")).unwrap();
assert!(ours.prim_at("/Root/Kept").is_some());
assert!(
ours.prim_at("/Root/Dropped").is_none(),
"an inactive prim should be gone: {:?}",
ours.prim_at("/Root").map(|p| p.children.iter().map(|c| &c.name).collect::<Vec<_>>())
);
assert!(ours.prim_at("/Root/Dropped/ChildOfDropped").is_none());
let names = |l: &UsdLayer| -> Vec<String> {
l.prims_by_path().into_iter().map(|(p, _)| p).collect()
};
assert_eq!(names(&ours), names(&theirs));
}
#[test]
fn a_sublayers_time_offset_applies() {
let mut r = MemoryResolver::new();
r.insert("anim_sub.usda", include_str!("testdata/gaps/anim_sub.usda"));
let root = parse(include_str!("testdata/gaps/shifted.usda")).unwrap();
let ours = compose(&root, "shifted.usda", &r, &ComposeOptions::default()).unwrap();
let samples = ours
.prim_at("/Moving")
.expect("the prim came through the sublayer")
.value("xformOp:translate")
.expect("still animated")
.samples()
.expect("time samples")
.to_vec();
let theirs = parse(include_str!("testdata/gaps/flat_shifted.usda")).unwrap();
let expected = theirs
.prim_at("/Moving")
.unwrap()
.value("xformOp:translate")
.unwrap()
.samples()
.unwrap();
assert_eq!(samples.len(), expected.len());
for (mine, theirs) in samples.iter().zip(expected) {
assert_eq!(mine.0, theirs.0, "sample time");
}
assert_eq!(samples[0].0, 100.0);
assert_eq!(samples[1].0, 120.0);
}
#[test]
fn a_relocation_renames_what_an_arc_brought_in() {
let mut r = MemoryResolver::new();
r.insert("asset_r.usda", include_str!("testdata/gaps/asset_r.usda"));
let root = parse(include_str!("testdata/gaps/reloc2.usda")).unwrap();
let ours = compose(&root, "reloc2.usda", &r, &ComposeOptions::default()).unwrap();
let theirs = parse(include_str!("testdata/gaps/flat_reloc2.usda")).unwrap();
assert!(
ours.prim_at("/Holder/OldName").is_none(),
"the old name should be gone"
);
let renamed = ours
.prim_at("/Holder/NewName")
.expect("the prim should be under its new name");
assert_eq!(renamed.value("marker").unwrap().flat_f32(), vec![7.0]);
let names = |l: &UsdLayer| -> Vec<String> {
l.prims_by_path().into_iter().map(|(p, _)| p).collect()
};
assert_eq!(names(&ours), names(&theirs));
}
#[test]
fn a_relocation_across_parents_is_refused() {
let mut layer = parse(
r#"#usda 1.0
def Scope "A"
{
def Scope "Thing"
{
}
}
def Scope "B"
{
}
"#,
)
.unwrap();
relocate(&mut layer, "/A/Thing", "/B/Thing");
assert!(layer.prim_at("/A/Thing").is_some(), "left where it was");
assert!(layer.prim_at("/B/Thing").is_none());
}
}