use super::parse::{UsdLayer, UsdPrim};
use super::value::UsdValue;
#[derive(Debug, Default, Clone)]
pub struct ClipSet {
pub name: String,
pub assets: Vec<String>,
pub prim_path: String,
pub active: Vec<(f64, usize)>,
pub times: Vec<(f64, f64)>,
pub manifest: String,
}
impl ClipSet {
pub fn clip_at(&self, time: f64) -> Option<usize> {
if self.active.is_empty() {
return (!self.assets.is_empty()).then_some(0);
}
let mut chosen = self.active.first()?.1;
for (at, index) in &self.active {
if *at <= time {
chosen = *index;
} else {
break;
}
}
Some(chosen)
}
}
pub fn sets_of(prim: &UsdPrim) -> Vec<ClipSet> {
let mut out = Vec::new();
if let Some(UsdValue::Dict(entries)) = prim.meta("clips") {
for (name, value) in entries {
if let UsdValue::Dict(fields) = value {
out.push(read_set(name, fields));
}
}
}
if out.is_empty() {
let flat: Vec<(String, UsdValue)> = [
("assetPaths", "clipAssetPaths"),
("primPath", "clipPrimPath"),
("active", "clipActive"),
("times", "clipTimes"),
("manifestAssetPath", "clipManifestAssetPath"),
]
.iter()
.filter_map(|(to, from)| prim.meta(from).map(|v| (to.to_string(), v.clone())))
.collect();
if !flat.is_empty() {
out.push(read_set("default", &flat));
}
}
out
}
fn read_set(name: &str, fields: &[(String, UsdValue)]) -> ClipSet {
let field = |key: &str| fields.iter().find(|(k, _)| k == key).map(|(_, v)| v);
let pairs = |key: &str| -> Vec<(f64, f64)> {
let Some(value) = field(key) else {
return Vec::new();
};
let flat = value.flat_f32();
flat.as_chunks::<2>()
.0
.iter()
.map(|p| (p[0] as f64, p[1] as f64))
.collect()
};
ClipSet {
name: name.to_string(),
assets: field("assetPaths")
.map(|v| match v {
UsdValue::Array(items) => items
.iter()
.filter_map(|i| i.as_str())
.map(str::to_string)
.collect(),
other => other.as_str().map(str::to_string).into_iter().collect(),
})
.unwrap_or_default(),
prim_path: field("primPath")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string(),
active: pairs("active")
.into_iter()
.map(|(at, index)| (at, index.max(0.0) as usize))
.collect(),
times: pairs("times"),
manifest: field("manifestAssetPath")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string(),
}
}
pub fn animated_names(manifest: Option<&UsdLayer>, prim_path: &str, prim: &UsdPrim) -> Vec<String> {
if let Some(manifest) = manifest
&& let Some(found) = manifest.prim_at(prim_path)
{
let names: Vec<String> = found.properties.iter().map(|p| p.name.clone()).collect();
if !names.is_empty() {
return names;
}
}
prim.properties.iter().map(|p| p.name.clone()).collect()
}
pub fn sample_times(set: &ClipSet, from_clips: impl Fn(usize) -> Vec<f64>) -> Vec<(f64, f64)> {
if !set.times.is_empty() {
let mut out = set.times.clone();
out.sort_by(|a, b| a.0.total_cmp(&b.0));
return out;
}
let mut out: Vec<(f64, f64)> = Vec::new();
for index in 0..set.assets.len() {
for time in from_clips(index) {
if set.clip_at(time) == Some(index) && !out.iter().any(|(t, _)| *t == time) {
out.push((time, time));
}
}
}
out.sort_by(|a, b| a.0.total_cmp(&b.0));
out
}
#[cfg(test)]
mod tests {
use super::super::compose::{compose, ComposeOptions, MemoryResolver};
use super::super::parse::parse;
use super::*;
fn pipeline() -> MemoryResolver {
let mut r = MemoryResolver::new();
r.insert("clip_0.usda", include_str!("testdata/clips/clip_0.usda"))
.insert("clip_1.usda", include_str!("testdata/clips/clip_1.usda"))
.insert(
"manifest.usda",
include_str!("testdata/clips/manifest.usda"),
);
r
}
#[test]
fn clips_resolve_to_the_same_samples_openusd_produces() {
let stage = parse(include_str!("testdata/clips/stage.usda")).expect("parses");
let out = compose(
&stage,
"stage.usda",
&pipeline(),
&ComposeOptions::default(),
)
.expect("composes");
let mine = out
.prim_at("/Shot")
.expect("the shot")
.value("xformOp:translate")
.expect("the clipped attribute")
.samples()
.expect("clips should have made it animated")
.to_vec();
let theirs = parse(include_str!("testdata/clips/flat.usda")).unwrap();
let expected = theirs
.prim_at("/Shot")
.unwrap()
.value("xformOp:translate")
.unwrap()
.samples()
.unwrap();
assert_eq!(mine.len(), expected.len(), "sample count");
for (mine, theirs) in mine.iter().zip(expected) {
assert_eq!(mine.0, theirs.0, "sample time");
assert_eq!(mine.1.flat_f32(), theirs.1.flat_f32(), "at {}", mine.0);
}
assert_eq!(mine[0].1.flat_f32(), vec![0.0, 0.0, 0.0]);
assert_eq!(mine[1].1.flat_f32(), vec![0.0, 1.0, 0.0]);
assert_eq!(mine[2].1.flat_f32(), vec![1.0, 0.0, 0.0]);
assert_eq!(mine[3].1.flat_f32(), vec![1.0, 1.0, 0.0]);
}
#[test]
fn the_active_table_holds_between_entries() {
let set = ClipSet {
assets: vec!["a".into(), "b".into(), "c".into()],
active: vec![(0.0, 0), (10.0, 2), (20.0, 1)],
..Default::default()
};
assert_eq!(set.clip_at(-5.0), Some(0), "before the first, the first");
assert_eq!(set.clip_at(0.0), Some(0));
assert_eq!(set.clip_at(9.9), Some(0), "holds until the next entry");
assert_eq!(set.clip_at(10.0), Some(2));
assert_eq!(set.clip_at(19.0), Some(2));
assert_eq!(set.clip_at(1000.0), Some(1), "the last one holds forever");
}
#[test]
fn a_single_clip_needs_no_table() {
let set = ClipSet {
assets: vec!["only".into()],
..Default::default()
};
assert_eq!(set.clip_at(42.0), Some(0));
assert_eq!(ClipSet::default().clip_at(0.0), None, "no clips, no answer");
}
#[test]
fn missing_times_fall_back_to_the_clips_own_samples() {
let set = ClipSet {
assets: vec!["a".into(), "b".into()],
active: vec![(0.0, 0), (2.0, 1)],
..Default::default()
};
let schedule = sample_times(&set, |index| match index {
0 => vec![0.0, 1.0, 2.0],
_ => vec![2.0, 3.0],
});
assert_eq!(
schedule,
vec![(0.0, 0.0), (1.0, 1.0), (2.0, 2.0), (3.0, 3.0)]
);
}
#[test]
fn the_flat_spelling_is_read_too() {
let layer = parse(
r#"#usda 1.0
def Xform "Old" (
clipAssetPaths = [@a.usda@, @b.usda@]
clipPrimPath = "/Cache"
clipActive = [(0, 0), (5, 1)]
clipTimes = [(0, 0), (5, 0)]
)
{
double3 xformOp:translate
}
"#,
)
.unwrap();
let sets = sets_of(layer.prim_at("/Old").unwrap());
assert_eq!(sets.len(), 1);
assert_eq!(sets[0].assets, vec!["a.usda", "b.usda"]);
assert_eq!(sets[0].prim_path, "/Cache");
assert_eq!(sets[0].active, vec![(0.0, 0), (5.0, 1)]);
}
#[test]
fn clips_do_not_invent_attributes() {
let stage = parse(
&include_str!("testdata/clips/stage.usda")
.replace(" double3 xformOp:translate\n", ""),
)
.unwrap();
let out = compose(
&stage,
"stage.usda",
&pipeline(),
&ComposeOptions::default(),
)
.unwrap();
assert!(
out.prim_at("/Shot")
.unwrap()
.value("xformOp:translate")
.is_none(),
"an undeclared attribute stays undeclared"
);
}
}