use crate::animation::{AnimationClip, KeyframeTrack, TrackTarget};
use crate::core::{
BufferAttribute, BufferGeometry, Mesh, Object3D, ObjectArena, ObjectId, ObjectKind,
};
use crate::materials::{Material, StandardMaterial};
use crate::math::{Color, Matrix4, Quaternion, Vector3};
use super::parse::{UsdLayer, UsdPrim, UsdProperty};
use super::schemas::{self, UsdCamera};
use super::skel::{self, UsdSkeleton};
use super::shade;
use super::subdiv;
use crate::core::Skeleton;
use std::rc::Rc;
use super::usdz::UsdzArchive;
use super::value::UsdValue;
use crate::textures::{Texture, TextureFormat, TextureWrap};
pub struct UsdScene {
pub roots: Vec<ObjectId>,
pub arena: ObjectArena,
pub meters_per_unit: f32,
pub up_axis: char,
pub animations: Vec<AnimationClip>,
pub cameras: Vec<UsdCamera>,
pub skeletons: Vec<Skeleton>,
pub morph_targets: Vec<(String, crate::core::MorphAttributes)>,
pub textures: Vec<(String, Vec<shade::TextureRequest>)>,
}
#[derive(Debug, Clone, Default)]
pub struct SceneOptions {
pub subdivision_level: usize,
pub show_guides: bool,
pub show_proxies: bool,
}
pub fn to_scene(layer: &UsdLayer) -> UsdScene {
let start = layer
.time_range()
.or_else(|| layer.sampled_time_range())
.map(|(start, _)| start)
.unwrap_or(0.0);
to_scene_at(layer, start)
}
pub fn to_scene_at(layer: &UsdLayer, time: f64) -> UsdScene {
to_scene_with(layer, time, &SceneOptions::default())
}
pub fn to_scene_with(layer: &UsdLayer, time: f64, options: &SceneOptions) -> UsdScene {
let resolved = layer.at_time(time);
let mut arena = ObjectArena::new();
let mut roots = Vec::new();
let mut placed = Vec::new();
let mut cameras = Vec::new();
let mut skeletons = Vec::new();
let mut skeleton_clips = Vec::new();
let mut texture_requests: Vec<(String, Vec<shade::TextureRequest>)> = Vec::new();
let mut morph_targets: Vec<(String, crate::core::MorphAttributes)> = Vec::new();
for (prim, source) in resolved.prims.iter().zip(&layer.prims) {
let mut context = Build {
layer: &resolved,
source_layer: layer,
placed: &mut placed,
cameras: &mut cameras,
skeletons: &mut skeletons,
clips: &mut skeleton_clips,
rate: layer.time_codes_per_second(),
options,
skeleton_animation: None,
textures: &mut texture_requests,
morphs: &mut morph_targets,
skeleton: None,
};
if let Some(id) = build(prim, &mut arena, source, "", &mut context) {
roots.push(id);
}
}
let mut animations: Vec<AnimationClip> = clip(layer, &placed).into_iter().collect();
animations.extend(skeleton_clips);
UsdScene {
roots,
arena,
meters_per_unit: layer.meters_per_unit(),
up_axis: layer.up_axis(),
animations,
cameras,
skeletons,
morph_targets,
textures: texture_requests
.into_iter()
.filter(|(_, t)| !t.is_empty())
.collect(),
}
}
fn clip(layer: &UsdLayer, placed: &[(ObjectId, UsdPrim)]) -> Option<AnimationClip> {
let rate = layer.time_codes_per_second();
let mut tracks = Vec::new();
let mut span: Option<(f64, f64)> = None;
for (id, prim) in placed {
let mut times = keyed_times(prim);
if times.is_empty() {
continue;
}
times.sort_by(|a, b| a.total_cmp(b));
times.dedup();
let sampled: Vec<_> = times
.iter()
.map(|t| transform_of(&resolve_prim(prim, *t)))
.collect();
let seconds: Vec<f32> = times.iter().map(|t| (t / rate) as f32).collect();
if let (Some(first), Some(last)) = (times.first(), times.last()) {
span = Some(match span {
None => (*first, *last),
Some((lo, hi)) => (lo.min(*first), hi.max(*last)),
});
}
let positions: Vec<_> = sampled.iter().map(|t| t.0).collect();
if varies(&positions, |a, b| a.distance_to(*b) > 1e-6) {
tracks.push(KeyframeTrack::vector(
*id,
TrackTarget::Position,
seconds.clone(),
positions,
));
}
let rotations: Vec<_> = sampled.iter().map(|t| t.1).collect();
if varies(&rotations, |a, b| {
(a.x - b.x).abs() > 1e-6
|| (a.y - b.y).abs() > 1e-6
|| (a.z - b.z).abs() > 1e-6
|| (a.w - b.w).abs() > 1e-6
}) {
tracks.push(KeyframeTrack::quaternion(
*id,
TrackTarget::Quaternion,
seconds.clone(),
rotations,
));
}
let scales: Vec<_> = sampled.iter().map(|t| t.2).collect();
if varies(&scales, |a, b| a.distance_to(*b) > 1e-6) {
tracks.push(KeyframeTrack::vector(
*id,
TrackTarget::Scale,
seconds,
scales,
));
}
}
if tracks.is_empty() {
return None;
}
let (start, end) = layer.time_range().or(span).unwrap_or((0.0, 0.0));
let duration = ((end - start) / rate).max(0.0) as f32;
Some(AnimationClip::new("usd", duration, tracks))
}
fn varies<T: Copy>(values: &[T], differs: impl Fn(&T, &T) -> bool) -> bool {
values.windows(2).any(|w| differs(&w[0], &w[1]))
}
fn refined_geometry(
points: Vec<f32>,
counts: Vec<u32>,
indices: Vec<u32>,
prim: &UsdPrim,
) -> Option<BufferGeometry> {
let vertices = points.len() / 3;
if indices.iter().any(|i| *i as usize >= vertices) {
return None;
}
let flip = prim.value("orientation").and_then(|v| v.as_str()) == Some("leftHanded");
let mut triangles: Vec<u32> = Vec::new();
let mut polygons: Vec<u32> = Vec::new();
let mut at = 0usize;
for count in &counts {
let count = *count as usize;
if count < 3 || at + count > indices.len() {
at += count;
continue;
}
polygons.push(count as u32 - 2);
for i in 1..count - 1 {
let (a, b, c) = (indices[at], indices[at + i], indices[at + i + 1]);
if flip {
triangles.extend_from_slice(&[a, c, b]);
} else {
triangles.extend_from_slice(&[a, b, c]);
}
}
at += count;
}
if triangles.is_empty() {
return None;
}
let mut geometry = BufferGeometry::new();
geometry.set_attribute("position", BufferAttribute::new(points, 3));
geometry.set_index(triangles);
crate::compute_vertex_normals(&mut geometry);
geometry.set_polygons(polygons);
Some(geometry)
}
fn attach_morphs(
prim: &UsdPrim,
geometry: &mut BufferGeometry,
morphs: &crate::core::MorphAttributes,
) -> Option<Vec<f32>> {
let points = prim.value("points")?.flat_f32().len() / 3;
let vertices = geometry.get_attribute("position")?.count();
let corners: Option<Vec<usize>> = if vertices == points {
None
} else {
let counts = prim.value("faceVertexCounts")?.flat_u32();
let indices = prim.value("faceVertexIndices")?.flat_u32();
let flip = prim.value("orientation").and_then(|v| v.as_str()) == Some("leftHanded");
let mut out = Vec::new();
let mut at = 0usize;
for count in &counts {
let n = *count as usize;
if n >= 3 && at + n <= indices.len() {
for k in 1..n - 1 {
let tri = if flip { [at, at + k + 1, at + k] } else { [at, at + k, at + k + 1] };
out.extend(tri.iter().map(|&c| indices[c] as usize));
}
}
at += n;
}
if out.len() != vertices {
return None;
}
Some(out)
};
let expand = |delta: &[f32]| -> Vec<f32> {
match &corners {
None => delta.to_vec(),
Some(c) => c
.iter()
.flat_map(|&p| {
delta.get(p * 3..p * 3 + 3).map(|d| [d[0], d[1], d[2]]).unwrap_or([0.0; 3])
})
.collect(),
}
};
let mapped = crate::core::MorphAttributes {
targets: morphs
.targets
.iter()
.map(|t| crate::core::MorphTarget {
name: t.name.clone(),
position_delta: expand(&t.position_delta),
normal_delta: t.normal_delta.as_deref().map(expand),
})
.collect(),
influences: morphs.influences.clone(),
};
Some(mapped.apply_to(geometry))
}
fn grouped_by_subset(prim: &UsdPrim, path: &str, context: &mut Build) -> Option<Mesh> {
let layer = context.layer;
let level = context.options.subdivision_level;
if level > 0 && subdiv::wanted(prim) {
return None;
}
let subsets = shade::material_subsets(prim);
let counts = prim.value("faceVertexCounts")?.flat_u32();
let indices_len = prim.value("faceVertexIndices")?.flat_u32().len();
let mut starts = Vec::with_capacity(counts.len());
let mut at = 0usize;
for c in &counts {
starts.push(at);
at += *c as usize;
}
let triangles = |f: u32| -> u32 {
match (counts.get(f as usize), starts.get(f as usize)) {
(Some(&n), Some(&s)) if n >= 3 && s + n as usize <= indices_len => n - 2,
_ => 0,
}
};
let remainder = shade::unclaimed_faces(counts.len(), &subsets);
let parts: Vec<(String, Vec<u32>, Option<String>)> = subsets
.iter()
.map(|s| (s.name.clone(), s.faces.clone(), s.material.clone()))
.chain((!remainder.is_empty()).then(|| (prim.name.clone(), remainder, None)))
.collect();
let all: Vec<u32> = parts.iter().flat_map(|p| p.1.iter().copied()).collect();
let mut geometry = mesh_geometry_of_faces(prim, 0, &all)?;
let mut materials = Vec::new();
let mut start = 0u32;
for (i, (name, faces, material_path)) in parts.iter().enumerate() {
let count = faces.iter().map(|&f| triangles(f)).sum::<u32>() * 3;
geometry.add_group(start, count, i as u32);
start += count;
let (material, textures) = match material_path.as_ref().and_then(|p| layer.prim_at(p)) {
Some(m) => {
let resolved = shade::resolve(m, layer);
(resolved.material, resolved.textures)
}
None => bound_material_at(path, layer),
};
context.textures.push((name.clone(), textures));
materials.push(std::sync::Arc::new(material));
}
if start as usize != geometry.draw_count() {
return None;
}
Some(Mesh::with_materials(std::sync::Arc::new(geometry), materials))
}
fn split_by_subset(
prim: &UsdPrim,
arena: &mut ObjectArena,
source: &UsdPrim,
path: &str,
context: &mut Build,
) -> ObjectId {
let layer = context.layer;
let level = context.options.subdivision_level;
let subsets = shade::material_subsets(prim);
let mut group = Object3D::group();
group.name = prim.name.clone();
let id = arena.insert(group);
place_transform(arena, id, prim);
context.placed.push((id, source.clone()));
let total = prim
.value("faceVertexCounts")
.map(|v| v.flat_u32().len())
.unwrap_or(0);
let remainder = shade::unclaimed_faces(total, &subsets);
let parts = subsets
.iter()
.map(|s| (s.name.clone(), s.faces.clone(), s.material.clone()))
.chain((!remainder.is_empty()).then(|| (prim.name.clone(), remainder, None)));
for (name, faces, material_path) in parts {
let Some(geometry) = mesh_geometry_of_faces(prim, level, &faces) else {
continue;
};
let (material, textures) = match material_path {
Some(found) => match layer.prim_at(&found) {
Some(material) => {
let resolved = shade::resolve(material, layer);
(resolved.material, resolved.textures)
}
None => bound_material_at(path, layer),
},
None => bound_material_at(path, layer),
};
context.textures.push((name.clone(), textures));
let mut node = Object3D::mesh(Mesh::new(geometry, material));
node.name = name;
let child = arena.insert(node);
arena.add_child(id, child);
}
id
}
fn place_transform(arena: &mut ObjectArena, id: ObjectId, prim: &UsdPrim) {
let (position, quaternion, scale) = transform_of(prim);
if let Some(node) = arena.get_mut(id) {
node.position = position;
node.quaternion = quaternion;
node.scale = scale;
}
}
fn vertex_animation(
source: &UsdPrim,
object: ObjectId,
rate: f64,
) -> Option<(crate::core::MorphAttributes, Vec<KeyframeTrack>)> {
let samples = source.value("points")?.samples()?.to_vec();
if samples.len() < 2 {
return None;
}
let base = samples[0].1.flat_f32();
if base.is_empty() {
return None;
}
let mut targets = Vec::new();
let mut tracks = Vec::new();
for (index, (_, frame)) in samples.iter().enumerate().skip(1) {
let points = frame.flat_f32();
if points.len() != base.len() {
return None;
}
targets.push(crate::core::MorphTarget {
name: format!("frame{index}"),
position_delta: points.iter().zip(&base).map(|(p, b)| p - b).collect(),
normal_delta: None,
});
let mut times = Vec::new();
let mut values = Vec::new();
for (slot, (time, _)) in samples.iter().enumerate() {
times.push((time / rate) as f32);
values.push(if slot == index { 1.0 } else { 0.0 });
}
tracks.push(KeyframeTrack::scalar(
object,
TrackTarget::MorphWeight {
index: index - 1,
},
times,
values,
));
}
Some((
crate::core::MorphAttributes {
influences: vec![0.0; targets.len()],
targets,
},
tracks,
))
}
fn property_tracks(
prim: &UsdPrim,
layer: &UsdLayer,
path: &str,
object: ObjectId,
rate: f64,
) -> Vec<KeyframeTrack> {
let mut out = Vec::new();
let scalar = |out: &mut Vec<KeyframeTrack>, value: &UsdValue, target: TrackTarget| {
let Some(samples) = value.samples() else { return };
let times: Vec<f32> = samples.iter().map(|(t, _)| (t / rate) as f32).collect();
let values: Vec<f32> = samples
.iter()
.map(|(_, v)| v.as_f64().unwrap_or(0.0) as f32)
.collect();
out.push(KeyframeTrack::scalar(object, target, times, values));
};
let colour = |out: &mut Vec<KeyframeTrack>, value: &UsdValue| {
let Some(samples) = value.samples() else { return };
let times: Vec<f32> = samples.iter().map(|(t, _)| (t / rate) as f32).collect();
let values: Vec<Color> = samples
.iter()
.map(|(_, v)| {
let n = v.flat_f32();
if n.len() >= 3 {
Color::new(n[0], n[1], n[2])
} else {
Color::WHITE
}
})
.collect();
out.push(KeyframeTrack::color(object, TrackTarget::Color, times, values));
};
if let Some(value) = prim.value("visibility") {
if let Some(samples) = value.samples() {
let times: Vec<f32> = samples.iter().map(|(t, _)| (t / rate) as f32).collect();
let values: Vec<f32> = samples
.iter()
.map(|(_, v)| {
if v.as_str() == Some("invisible") {
0.0
} else {
1.0
}
})
.collect();
out.push(KeyframeTrack::scalar(
object,
TrackTarget::Visibility,
times,
values,
));
}
}
if schemas::is_light(&prim.type_name) {
if let Some(value) = prim.value("inputs:intensity").or_else(|| prim.value("intensity")) {
scalar(&mut out, value, TrackTarget::Intensity);
}
if let Some(value) = prim.value("inputs:color").or_else(|| prim.value("color")) {
colour(&mut out, value);
}
}
if prim.type_name == "Mesh" || schemas::is_gprim(&prim.type_name) {
if let Some(shader) = shade::bound_material_path(layer, path)
.and_then(|p| layer.prim_at(&p))
.and_then(|material| shade::surface_shader(material, layer))
{
if let Some(value) = shader.value("inputs:diffuseColor") {
colour(&mut out, value);
}
}
}
out
}
fn keyed_times(prim: &UsdPrim) -> Vec<f64> {
let mut times = Vec::new();
for property in &prim.properties {
if !property.name.starts_with("xformOp:") {
continue;
}
if let Some(samples) = property.value.samples() {
times.extend(samples.iter().map(|(t, _)| *t));
}
}
times
}
fn resolve_prim(prim: &UsdPrim, time: f64) -> UsdPrim {
let mut out = prim.clone();
for property in &mut out.properties {
if property.value.samples().is_some() {
property.value = property.value.at_time(time);
}
}
out
}
struct Build<'a> {
layer: &'a UsdLayer,
source_layer: &'a UsdLayer,
placed: &'a mut Vec<(ObjectId, UsdPrim)>,
cameras: &'a mut Vec<UsdCamera>,
skeletons: &'a mut Vec<Skeleton>,
clips: &'a mut Vec<AnimationClip>,
rate: f64,
options: &'a SceneOptions,
textures: &'a mut Vec<(String, Vec<shade::TextureRequest>)>,
morphs: &'a mut Vec<(String, crate::core::MorphAttributes)>,
skeleton: Option<Rc<UsdSkeleton>>,
skeleton_animation: Option<String>,
}
fn build(
prim: &UsdPrim,
arena: &mut ObjectArena,
source: &UsdPrim,
parent: &str,
context: &mut Build,
) -> Option<ObjectId> {
let layer = context.layer;
let path = format!("{parent}/{}", prim.name);
if prim.specifier == super::parse::Specifier::Class {
return None;
}
if !schemas::is_drawable(prim, context.options.show_guides, context.options.show_proxies) {
return None;
}
let mut morph_order: Vec<String> = Vec::new();
let mut object = match prim.type_name.as_str() {
"Mesh" if !shade::material_subsets(prim).is_empty() => {
match grouped_by_subset(prim, &path, context) {
Some(mesh) => Object3D::mesh(mesh),
None => return Some(split_by_subset(prim, arena, source, &path, context)),
}
}
"Mesh" => {
let mut geometry = mesh_geometry_at(prim, context.options.subdivision_level)?;
let (material, textures) = bound_material_at(&path, layer);
context.textures.push((prim.name.clone(), textures));
match context.skeleton.clone() {
Some(skeleton)
if skel::binds_a_skeleton(prim)
&& skel::skin_attributes(
prim,
geometry.get_attribute("position").map(|a| a.count()).unwrap_or(0),
&mut geometry,
) =>
{
skel::apply_bind_transform(prim, &mut geometry);
let points = prim
.value("points")
.map(|v| v.flat_f32().len() / 3)
.unwrap_or(0);
let targets = skel::blend_shapes(prim, layer, points);
let mut influences = Vec::new();
if !targets.is_empty() {
morph_order = targets.iter().map(|t| t.name.clone()).collect();
let morphs = crate::core::MorphAttributes {
influences: vec![0.0; targets.len()],
targets,
};
influences = attach_morphs(prim, &mut geometry, &morphs).unwrap_or_default();
context.morphs.push((prim.name.clone(), morphs));
}
let mut sm = crate::core::SkinnedMesh::new(
geometry,
material,
skeleton.skeleton.clone(),
);
if !influences.is_empty() {
sm.morph_influences = influences;
}
Object3D::skinned_mesh(sm)
}
_ if prim.value("skel:blendShapes").is_some() => {
let points = prim
.value("points")
.map(|v| v.flat_f32().len() / 3)
.unwrap_or(0);
let targets = skel::blend_shapes(prim, layer, points);
if targets.is_empty() {
Object3D::mesh(Mesh::new(geometry, material))
} else {
morph_order = targets.iter().map(|t| t.name.clone()).collect();
let weights = skel::bound_animation(prim, layer)
.map(|anim| skel::blend_shape_weights(anim, &morph_order))
.unwrap_or_else(|| vec![0.0; targets.len()]);
let morphs = crate::core::MorphAttributes {
influences: weights,
targets,
};
let influences = attach_morphs(prim, &mut geometry, &morphs);
context.morphs.push((prim.name.clone(), morphs));
let mut mesh = Mesh::new(geometry, material);
if let Some(influences) = influences {
mesh.morph_influences = influences;
}
Object3D::mesh(mesh)
}
}
_ => Object3D::mesh(Mesh::new(geometry, material)),
}
}
type_name if schemas::is_gprim(type_name) => match schemas::gprim(prim) {
Some(geometry) => {
let (material, textures) = bound_material_at(&path, layer);
context.textures.push((prim.name.clone(), textures));
Object3D::mesh(Mesh::new(geometry, material))
}
None => Object3D::group(),
},
type_name if schemas::is_light(type_name) => match schemas::light(prim) {
Some(light) => Object3D::light(light),
None => Object3D::group(),
},
"Points" => match schemas::points(prim) {
Some(points) => Object3D::points(points),
None => Object3D::group(),
},
"BasisCurves" | "NurbsCurves" => match schemas::curves(prim) {
Some(curves) => Object3D::line_segments(curves),
None => Object3D::group(),
},
"PointInstancer" => {
let level = context.options.subdivision_level;
let prototype_root = path.clone();
let meshes = schemas::point_instancer(prim, layer, |prototype| {
let path = format!("{prototype_root}/{}", prototype.name);
mesh_geometry_at(prototype, level)
.map(|g| (g, bound_material_at(&path, layer).0))
});
let mut group = Object3D::group();
group.name = prim.name.clone();
let id = arena.insert(group);
for (name, mesh) in meshes {
let mut node = Object3D::instanced_mesh(mesh);
node.name = name;
let child = arena.insert(node);
arena.add_child(id, child);
}
place_transform(arena, id, prim);
context.placed.push((id, source.clone()));
return Some(id);
}
_ => Object3D::group(),
};
object.name = prim.name.clone();
let (position, quaternion, scale) = transform_of(prim);
object.position = position;
object.quaternion = quaternion;
object.scale = scale;
if prim.value("visibility").and_then(|v| v.as_str()) == Some("invisible") {
object.visible = false;
}
let id = arena.insert(object);
if !morph_order.is_empty() {
if let Some(anim) = source
.children
.iter()
.find(|c| c.type_name == "SkelAnimation")
.or_else(|| {
context
.skeleton_animation
.as_ref()
.and_then(|path| context.source_layer.prim_at(path))
})
.or_else(|| skel::bound_animation(source, context.source_layer))
{
let tracks = skel::blend_shape_tracks(anim, &morph_order, id, context.rate);
if !tracks.is_empty() {
context
.clips
.push(AnimationClip::new(format!("{}-blend", prim.name), 0.0, tracks));
}
}
}
if prim.type_name == "Camera" {
context.cameras.push(schemas::camera(prim, id));
}
context.placed.push((id, source.clone()));
let mut tracks = property_tracks(source, context.source_layer, &path, id, context.rate);
if morph_order.is_empty() {
if let Some((morphs, weights)) = vertex_animation(source, id, context.rate) {
if let Some(ObjectKind::Mesh(mesh)) = arena.get_mut(id).map(|o| &mut o.kind) {
let geometry = std::sync::Arc::make_mut(&mut mesh.geometry);
if let Some(influences) = attach_morphs(prim, geometry, &morphs) {
mesh.update_morph_targets();
mesh.morph_influences = influences;
}
}
context.morphs.push((prim.name.clone(), morphs));
tracks.extend(weights);
}
}
if !tracks.is_empty() {
context
.clips
.push(AnimationClip::new(format!("{}-properties", prim.name), 0.0, tracks));
}
let outer = context.skeleton.take();
let skeleton_prim = prim.children.iter().find(|c| c.type_name == "Skeleton");
match skeleton_prim.and_then(|c| skel::skeleton(c, arena, id)) {
Some(found) => {
let source_skeleton = source.children.iter().find(|c| c.type_name == "Skeleton");
if let Some(clip) = source_skeleton
.and_then(|c| skel::animation_source(c, context.source_layer))
.or_else(|| source.children.iter().find(|c| c.type_name == "SkelAnimation"))
.and_then(|anim| skel::animation(anim, &found, context.rate, &prim.name))
{
context.clips.push(clip);
}
context.skeleton_animation = source_skeleton
.and_then(|c| c.value("skel:animationSource"))
.and_then(|v| v.as_str())
.map(str::to_string);
context.skeletons.push(found.skeleton.clone());
context.skeleton = Some(Rc::new(found));
}
None => context.skeleton = outer.clone(),
}
for (child, child_source) in prim.children.iter().zip(&source.children) {
if matches!(
child.type_name.as_str(),
"Skeleton" | "GeomSubset" | "BlendShape" | "SkelAnimation"
) {
continue;
}
if let Some(child_id) = build(child, arena, child_source, &path, context) {
arena.add_child(id, child_id);
}
}
context.skeleton = outer;
Some(id)
}
fn transform_of(prim: &UsdPrim) -> (Vector3, Quaternion, Vector3) {
let identity = (Vector3::ZERO, Quaternion::identity(), Vector3::new(1.0, 1.0, 1.0));
let Some(order) = prim.value("xformOpOrder") else {
return identity;
};
let mut matrix = Matrix4::identity();
let mut any = false;
for op in order.items() {
let Some(name) = op.as_str() else { continue };
let (invert, name) = match name.strip_prefix("!invert!") {
Some(rest) => (true, rest),
None => (false, name),
};
let Some(value) = prim.value(name) else { continue };
let step = op_matrix(name, value);
let Some(step) = step else { continue };
any = true;
let step = if invert { step.invert() } else { step };
matrix = matrix.multiply(&step);
}
if !any {
return identity;
}
matrix.decompose()
}
fn op_matrix(name: &str, value: &UsdValue) -> Option<Matrix4> {
let n = value.flat_f32();
let kind = name.strip_prefix("xformOp:")?;
let kind = kind.split(':').next().unwrap_or(kind);
match kind {
"translate" if n.len() >= 3 => Some(Matrix4::compose(
Vector3::new(n[0], n[1], n[2]),
Quaternion::identity(),
Vector3::new(1.0, 1.0, 1.0),
)),
"scale" if n.len() >= 3 => Some(Matrix4::compose(
Vector3::ZERO,
Quaternion::identity(),
Vector3::new(n[0], n[1], n[2]),
)),
"rotateX" | "rotateY" | "rotateZ" if !n.is_empty() => {
let axis = match kind {
"rotateX" => Vector3::new(1.0, 0.0, 0.0),
"rotateY" => Vector3::new(0.0, 1.0, 0.0),
_ => Vector3::new(0.0, 0.0, 1.0),
};
Some(Matrix4::compose(
Vector3::ZERO,
Quaternion::from_axis_angle(axis, n[0].to_radians()),
Vector3::new(1.0, 1.0, 1.0),
))
}
"rotateXYZ" | "rotateXZY" | "rotateYXZ" | "rotateYZX" | "rotateZXY" | "rotateZYX"
if n.len() >= 3 =>
{
let axes = &kind[6..];
let mut q = Quaternion::identity();
for (i, axis) in axes.chars().enumerate() {
let v = match axis {
'X' => Vector3::new(1.0, 0.0, 0.0),
'Y' => Vector3::new(0.0, 1.0, 0.0),
_ => Vector3::new(0.0, 0.0, 1.0),
};
let step = Quaternion::from_axis_angle(v, n[i].to_radians());
q = q.multiply(step);
}
Some(Matrix4::compose(
Vector3::ZERO,
q,
Vector3::new(1.0, 1.0, 1.0),
))
}
"orient" if n.len() >= 4 => Some(Matrix4::compose(
Vector3::ZERO,
Quaternion::new(n[1], n[2], n[3], n[0]),
Vector3::new(1.0, 1.0, 1.0),
)),
"transform" if n.len() >= 16 => {
let mut m = [0.0f32; 16];
for row in 0..4 {
for col in 0..4 {
m[col * 4 + row] = n[row * 4 + col];
}
}
Some(Matrix4 { elements: m })
}
_ => None,
}
}
pub fn mesh_geometry(prim: &UsdPrim) -> Option<BufferGeometry> {
mesh_geometry_at(prim, 0)
}
pub fn mesh_geometry_of_faces(
prim: &UsdPrim,
level: usize,
faces: &[u32],
) -> Option<BufferGeometry> {
let counts = prim.value("faceVertexCounts")?.flat_u32();
let indices = prim.value("faceVertexIndices")?.flat_u32();
let mut starts = Vec::with_capacity(counts.len());
let mut at = 0usize;
for count in &counts {
starts.push(at);
at += *count as usize;
}
let mut kept_counts = Vec::with_capacity(faces.len());
let mut kept_indices = Vec::new();
for face in faces {
let (Some(start), Some(count)) = (
starts.get(*face as usize).copied(),
counts.get(*face as usize).copied(),
) else {
continue;
};
if start + count as usize > indices.len() {
continue;
}
kept_counts.push(count);
kept_indices.extend_from_slice(&indices[start..start + count as usize]);
}
if kept_counts.is_empty() {
return None;
}
let mut only = prim.clone();
only.children.clear();
for (name, value) in [
("faceVertexCounts", UsdValue::Array(
kept_counts.iter().map(|c| UsdValue::Int(*c as i128)).collect(),
)),
("faceVertexIndices", UsdValue::Array(
kept_indices.iter().map(|i| UsdValue::Int(*i as i128)).collect(),
)),
] {
if let Some(property) = only.properties.iter_mut().find(|p| p.name == name) {
property.value = value;
}
}
mesh_geometry_at(&only, level)
}
pub fn mesh_geometry_at(prim: &UsdPrim, level: usize) -> Option<BufferGeometry> {
let mut points = prim.value("points")?.flat_f32();
if points.len() < 9 {
return None;
}
let mut counts = prim
.value("faceVertexCounts")
.map(|v| v.flat_u32())
.unwrap_or_default();
let mut indices = prim
.value("faceVertexIndices")
.map(|v| v.flat_u32())
.unwrap_or_default();
if counts.is_empty() || indices.is_empty() {
return None;
}
if level > 0 && subdiv::wanted(prim) {
let refined = subdiv::subdivide(
subdiv::Cage {
positions: points.chunks_exact(3).map(|p| [p[0], p[1], p[2]]).collect(),
counts: counts.clone(),
indices: indices.clone(),
},
level,
&subdiv::options_of(prim),
);
points = refined.positions.iter().flat_map(|p| *p).collect();
counts = refined.counts;
indices = refined.indices;
return refined_geometry(points, counts, indices, prim);
}
let flip = prim.value("orientation").and_then(|v| v.as_str()) == Some("leftHanded");
let vertices = points.len() / 3;
if indices.iter().any(|i| *i as usize >= vertices) {
return None;
}
let mut corners: Vec<usize> = Vec::new();
let mut polygons: Vec<u32> = Vec::new();
let mut at = 0usize;
for count in &counts {
let n = *count as usize;
if n >= 3 && at + n <= indices.len() {
polygons.push(n as u32 - 2);
for k in 1..n - 1 {
if flip {
corners.extend_from_slice(&[at, at + k + 1, at + k]);
} else {
corners.extend_from_slice(&[at, at + k, at + k + 1]);
}
}
}
at += n;
}
if corners.is_empty() {
return None;
}
let normals = primvar(prim, "normals").or_else(|| primvar(prim, "primvars:normals"));
let uvs = pick_uvs(prim);
let colours = primvar(prim, "primvars:displayColor").filter(|pv| !pv.constant);
let face_varying = [&normals, &uvs, &colours]
.iter()
.any(|p| matches!(p, Some(pv) if pv.face_varying));
let mut geometry = BufferGeometry::new();
if face_varying {
let mut pos = Vec::with_capacity(corners.len() * 3);
let mut nrm = Vec::new();
let mut uv = Vec::new();
let mut col = Vec::new();
for &c in &corners {
let point = indices[c] as usize;
pos.extend_from_slice(slice3(&points, point));
if let Some(pv) = &normals {
nrm.extend_from_slice(&pv.at3(c, indices[c] as usize));
}
if let Some(pv) = &uvs {
uv.extend_from_slice(&pv.at2(c, indices[c] as usize));
}
if let Some(pv) = &colours {
col.extend_from_slice(&pv.at3(c, indices[c] as usize));
}
}
geometry.set_attribute("position", BufferAttribute::new(pos, 3));
if !nrm.is_empty() {
geometry.set_attribute("normal", BufferAttribute::new(nrm, 3));
}
if !uv.is_empty() {
geometry.set_attribute("uv", BufferAttribute::new(uv, 2));
}
if !col.is_empty() {
geometry.set_attribute("color", BufferAttribute::new(col, 3));
}
} else {
geometry.set_attribute("position", BufferAttribute::new(points.clone(), 3));
let vertices = points.len() / 3;
if let Some(pv) = &normals {
let mut nrm = Vec::with_capacity(vertices * 3);
for v in 0..vertices {
nrm.extend_from_slice(&pv.at3(v, v));
}
geometry.set_attribute("normal", BufferAttribute::new(nrm, 3));
}
if let Some(pv) = &uvs {
let mut uv = Vec::with_capacity(vertices * 2);
for v in 0..vertices {
uv.extend_from_slice(&pv.at2(v, v));
}
geometry.set_attribute("uv", BufferAttribute::new(uv, 2));
}
if let Some(pv) = &colours {
let mut col = Vec::with_capacity(vertices * 3);
for v in 0..vertices {
col.extend_from_slice(&pv.at3(v, v));
}
geometry.set_attribute("color", BufferAttribute::new(col, 3));
}
geometry.set_index(corners.iter().map(|&c| indices[c]).collect());
}
if geometry.get_attribute("normal").is_none() {
crate::compute_vertex_normals(&mut geometry);
}
geometry.set_polygons(polygons);
Some(geometry)
}
fn slice3(v: &[f32], i: usize) -> &[f32] {
let at = i * 3;
if at + 3 <= v.len() {
&v[at..at + 3]
} else {
&[0.0, 0.0, 0.0]
}
}
struct Primvar {
data: Vec<f32>,
indices: Vec<u32>,
face_varying: bool,
constant: bool,
stride: usize,
}
impl Primvar {
fn get(&self, corner: usize, vertex: usize) -> usize {
let i = if self.face_varying { corner } else { vertex };
if self.indices.is_empty() {
i
} else {
*self.indices.get(i).unwrap_or(&0) as usize
}
}
fn at3(&self, corner: usize, vertex: usize) -> [f32; 3] {
let at = self.get(corner, vertex) * self.stride;
[
*self.data.get(at).unwrap_or(&0.0),
*self.data.get(at + 1).unwrap_or(&0.0),
*self.data.get(at + 2).unwrap_or(&0.0),
]
}
fn at2(&self, corner: usize, vertex: usize) -> [f32; 2] {
let at = self.get(corner, vertex) * self.stride;
[
*self.data.get(at).unwrap_or(&0.0),
*self.data.get(at + 1).unwrap_or(&0.0),
]
}
}
fn pick_uvs(prim: &UsdPrim) -> Option<Primvar> {
const SETS: [&str; 5] = [
"primvars:st",
"primvars:st0",
"primvars:UVMap",
"primvars:st1",
"primvars:st2",
];
let mut first: Option<Primvar> = None;
for name in SETS {
let Some(pv) = primvar(prim, name) else { continue };
if !escapes_unit_square(&pv) {
return Some(pv);
}
first.get_or_insert(pv);
}
first
}
fn escapes_unit_square(pv: &Primvar) -> bool {
const SLACK: f32 = 0.01;
pv.data
.iter()
.any(|v| *v < -SLACK || *v > 1.0 + SLACK)
}
fn primvar(prim: &UsdPrim, name: &str) -> Option<Primvar> {
let property: &UsdProperty = prim.property(name)?;
let data = property.value.flat_f32();
if data.is_empty() {
return None;
}
let interpolation = property.meta("interpolation").and_then(|v| v.as_str());
let face_varying = interpolation == Some("faceVarying");
let constant = interpolation == Some("constant");
let indices = prim
.value(&format!("{name}:indices"))
.map(|v| v.flat_u32())
.unwrap_or_default();
let stride = if name.contains("st") || name.contains("UV") {
2
} else {
3
};
let constant = constant || data.len() == stride;
Some(Primvar {
data,
indices,
face_varying,
constant,
stride,
})
}
fn bound_material_at(path: &str, layer: &UsdLayer) -> (Material, Vec<shade::TextureRequest>) {
let (mut material, textures) =
match shade::bound_material_path(layer, path).and_then(|p| layer.prim_at(&p)) {
Some(prim) => {
let resolved = shade::resolve(prim, layer);
(resolved.material, resolved.textures)
}
None => (
StandardMaterial::new(Color::new(0.8, 0.8, 0.8)).into(),
Vec::new(),
),
};
if matches!(
layer.prim_at(path).and_then(|p| p.value("doubleSided")),
Some(UsdValue::Bool(true))
) {
material.set_side(2);
}
(material, textures)
}
pub fn attach_textures(scene: &mut UsdScene, archive: &UsdzArchive) -> usize {
attach_with(scene, |request| decode_from(archive, request))
}
fn attach_with(
scene: &mut UsdScene,
load: impl Fn(&shade::TextureRequest) -> Option<Texture>,
) -> usize {
let mut attached = 0;
let mut pending: Vec<(String, Vec<shade::TextureRequest>)> = Vec::new();
for (name, requests) in std::mem::take(&mut scene.textures) {
let mut unresolved = Vec::new();
let targets: Vec<ObjectId> = scene
.roots
.iter()
.flat_map(|root| scene.arena.get_objects_by_name(*root, &name))
.collect();
for request in requests {
match load(&request) {
Some(texture) => {
let texture = std::sync::Arc::new(texture);
let mut used = false;
for id in &targets {
if let Some(object) = scene.arena.get_mut(*id) {
used |= put_map(object, request.slot, &texture);
}
}
if used {
attached += 1;
} else {
unresolved.push(request);
}
}
None => unresolved.push(request),
}
}
if !unresolved.is_empty() {
pending.push((name, unresolved));
}
}
scene.textures = pending;
attached
}
#[cfg(not(target_arch = "wasm32"))]
pub fn attach_textures_from_dir(scene: &mut UsdScene, base: &std::path::Path) -> usize {
let read = |request: &shade::TextureRequest| -> Option<Vec<u8>> {
let relative = std::path::Path::new(request.file.trim_start_matches("./"));
if relative.is_absolute()
|| relative
.components()
.any(|c| matches!(c, std::path::Component::ParentDir))
{
return None;
}
std::fs::read(base.join(relative)).ok()
};
attach_with(scene, |request| read(request).and_then(|bytes| decode(&bytes, request)))
}
fn decode_from(archive: &UsdzArchive, request: &shade::TextureRequest) -> Option<Texture> {
let wanted = request.file.trim_start_matches("./");
let entry = archive
.entries
.iter()
.find(|e| e.name == wanted || e.name.ends_with(&format!("/{wanted}")))?;
decode(&entry.data, request)
}
fn decode(bytes: &[u8], request: &shade::TextureRequest) -> Option<Texture> {
let image = crate::utils::png::decode_png(bytes).ok()?;
let format = if request.color_space == "raw" {
TextureFormat::Rgba8Unorm
} else {
TextureFormat::Rgba8UnormSrgb
};
Some(Texture {
wrap_s: wrap_from(&request.wrap_s),
wrap_t: wrap_from(&request.wrap_t),
..Texture::new(image.width, image.height, format, image.rgba)
})
}
fn wrap_from(name: &str) -> TextureWrap {
match name {
"repeat" => TextureWrap::Repeat,
"mirror" => TextureWrap::MirroredRepeat,
_ => TextureWrap::ClampToEdge,
}
}
fn put_map(object: &mut Object3D, slot: shade::TextureSlot, texture: &std::sync::Arc<Texture>) -> bool {
use shade::TextureSlot as S;
let ObjectKind::Mesh(mesh) = &mut object.kind else {
return false;
};
let material = std::sync::Arc::make_mut(&mut mesh.material);
macro_rules! set {
($m:expr, $($slot:ident => $field:ident),* $(,)?) => {
match slot {
$(S::$slot => { $m.$field = Some(texture.clone()); true })*
_ => false,
}
};
}
match material {
Material::Standard(m) => set!(m,
BaseColor => map,
Normal => normal_map,
Roughness => roughness_map,
Metalness => metalness_map,
Emissive => emissive_map,
Occlusion => ao_map,
Displacement => displacement_map,
),
Material::Physical(m) => set!(m,
BaseColor => map,
Normal => normal_map,
Roughness => roughness_map,
Metalness => metalness_map,
Emissive => emissive_map,
Occlusion => ao_map,
Displacement => displacement_map,
),
Material::Basic(m) => set!(m, BaseColor => map),
Material::Sprite(m) => set!(m, BaseColor => map),
_ => false,
}
}
#[cfg(test)]
mod tests {
#[test]
fn a_tiling_uv_set_gives_way_to_an_atlas() {
let src = r#"#usda 1.0
def Mesh "m"
{
int[] faceVertexCounts = [4]
int[] faceVertexIndices = [0, 1, 2, 3]
point3f[] points = [(0, 0, 0), (1, 0, 0), (1, 1, 0), (0, 1, 0)]
texCoord2f[] primvars:st = [(-3.9, 0), (9.3, 0), (9.3, 8.8), (-3.9, 8.8)] (
interpolation = "vertex"
)
texCoord2f[] primvars:st1 = [(0.017, 0.063), (0.967, 0.063), (0.967, 0.974), (0.017, 0.974)] (
interpolation = "vertex"
)
}
"#;
let layer = crate::loaders::usd::parse::parse(src).unwrap();
let prim = layer.prim_at("/m").unwrap();
let uvs = super::pick_uvs(prim).unwrap();
assert!(
(uvs.data[0] - 0.017).abs() < 1e-5,
"st runs -3.9..9.3 and tiles; st1 is the atlas the textures are painted in"
);
}
#[test]
fn a_lone_tiling_set_is_left_alone() {
let src = r#"#usda 1.0
def Mesh "m"
{
int[] faceVertexCounts = [4]
int[] faceVertexIndices = [0, 1, 2, 3]
point3f[] points = [(0, 0, 0), (1, 0, 0), (1, 1, 0), (0, 1, 0)]
texCoord2f[] primvars:st = [(0, 0), (4, 0), (4, 4), (0, 4)] (
interpolation = "vertex"
)
}
"#;
let layer = crate::loaders::usd::parse::parse(src).unwrap();
let prim = layer.prim_at("/m").unwrap();
let uvs = super::pick_uvs(prim).unwrap();
assert_eq!(uvs.data[2], 4.0, "nothing to prefer it to, so it stays");
}
#[test]
fn the_first_set_wins_when_neither_escapes() {
let src = r#"#usda 1.0
def Mesh "m"
{
int[] faceVertexCounts = [4]
int[] faceVertexIndices = [0, 1, 2, 3]
point3f[] points = [(0, 0, 0), (1, 0, 0), (1, 1, 0), (0, 1, 0)]
texCoord2f[] primvars:st = [(0, 1), (1, 1), (0, 0), (1, 0)] (
interpolation = "vertex"
)
texCoord2f[] primvars:st1 = [(0.1, 0.9), (0.4, 0.9), (0.4, 0.2), (0.1, 0.2)] (
interpolation = "vertex"
)
}
"#;
let layer = crate::loaders::usd::parse::parse(src).unwrap();
let prim = layer.prim_at("/m").unwrap();
let uvs = super::pick_uvs(prim).unwrap();
assert_eq!(uvs.data[0], 0.0, "st is a real parameterisation here");
}
use super::super::parse::parse;
use super::*;
use crate::animation::TrackValues;
const QUAD: &str = r#"#usda 1.0
def Xform "World"
{
double3 xformOp:translate = (1, 2, 3)
uniform token[] xformOpOrder = ["xformOp:translate"]
def Mesh "Quad"
{
int[] faceVertexCounts = [4]
int[] faceVertexIndices = [0, 1, 2, 3]
point3f[] points = [(0, 0, 0), (1, 0, 0), (1, 1, 0), (0, 1, 0)]
texCoord2f[] primvars:st = [(0, 0), (1, 0), (1, 1), (0, 1)] (
interpolation = "vertex"
)
rel material:binding = </World/Red>
}
def Material "Red"
{
def Shader "S"
{
uniform token info:id = "UsdPreviewSurface"
color3f inputs:diffuseColor = (1, 0, 0)
float inputs:roughness = 0.25
float inputs:metallic = 1
}
}
}
"#;
#[test]
fn an_animated_layer_comes_back_with_a_clip() {
let layer = parse(include_str!("testdata/anim.usda")).unwrap();
let scene = to_scene(&layer);
let clip = scene.animations.first().expect("a clip");
assert_eq!(clip.duration, 2.0);
let spin = scene.roots[0];
let targets: Vec<_> = clip
.tracks
.iter()
.filter(|t| t.object == spin)
.map(|t| format!("{:?}", t.target))
.collect();
assert!(targets.contains(&"Position".to_string()), "{targets:?}");
assert!(targets.contains(&"Quaternion".to_string()), "{targets:?}");
assert!(!targets.contains(&"Scale".to_string()), "{targets:?}");
}
#[test]
fn the_position_track_holds_what_the_samples_said() {
let layer = parse(include_str!("testdata/anim.usda")).unwrap();
let scene = to_scene(&layer);
let clip = &scene.animations[0];
let track = clip
.tracks
.iter()
.find(|t| matches!(t.target, TrackTarget::Position))
.expect("position track");
assert_eq!(track.times, vec![0.0, 1.0, 2.0]);
let TrackValues::Vector(values) = &track.values else {
panic!("expected vectors");
};
assert_eq!(values[0], Vector3::new(0.0, 0.0, 0.0));
assert_eq!(values[1], Vector3::new(10.0, 0.0, 0.0));
assert_eq!(values[2], Vector3::new(10.0, 10.0, 0.0));
}
#[test]
fn ops_keyed_on_different_frames_are_merged() {
let layer = parse(
r#"#usda 1.0
def Xform "A"
{
double3 xformOp:translate.timeSamples = { 0: (0, 0, 0), 10: (1, 0, 0) }
float3 xformOp:scale.timeSamples = { 5: (1, 1, 1), 20: (2, 2, 2) }
uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
}
"#,
)
.unwrap();
let scene = to_scene(&layer);
let clip = &scene.animations[0];
let position = clip
.tracks
.iter()
.find(|t| matches!(t.target, TrackTarget::Position))
.unwrap();
assert_eq!(position.times.len(), 4);
assert_eq!(
clip.tracks
.iter()
.filter(|t| matches!(t.target, TrackTarget::Scale))
.count(),
1
);
}
#[test]
fn a_scene_is_built_at_the_start_of_its_range() {
let layer = parse(
r#"#usda 1.0
(
startTimeCode = 10
endTimeCode = 20
)
def Xform "A"
{
double3 xformOp:translate.timeSamples = { 0: (0, 0, 0), 10: (7, 0, 0), 20: (9, 0, 0) }
uniform token[] xformOpOrder = ["xformOp:translate"]
}
"#,
)
.unwrap();
let scene = to_scene(&layer);
let a = scene.arena.get(scene.roots[0]).unwrap();
assert_eq!(a.position, Vector3::new(7.0, 0.0, 0.0), "posed at frame 10");
let midway = to_scene_at(&layer, 15.0);
assert_eq!(
midway.arena.get(midway.roots[0]).unwrap().position,
Vector3::new(8.0, 0.0, 0.0)
);
}
#[test]
fn an_animated_mesh_still_has_its_points() {
let layer = parse(include_str!("testdata/anim.usda")).unwrap();
let scene = to_scene(&layer);
let body = scene
.arena
.get(scene.arena.get(scene.roots[0]).unwrap().children[0])
.unwrap();
let crate::core::ObjectKind::Mesh(mesh) = &body.kind else {
panic!("expected a mesh");
};
let position = mesh.geometry.get_attribute("position").expect("positions");
assert_eq!(position.count(), 3);
assert_eq!(&position.array[..3], &[0.0, 0.0, 0.0]);
assert_eq!(&position.array[3..6], &[1.0, 0.0, 0.0]);
}
#[test]
fn a_static_layer_has_no_clip() {
let scene = to_scene(&parse(QUAD).unwrap());
assert!(scene.animations.is_empty());
}
#[test]
fn a_quad_becomes_two_triangles() {
let layer = parse(QUAD).unwrap();
let quad = layer.prim_at("/World/Quad").unwrap();
let g = mesh_geometry(quad).unwrap();
assert_eq!(g.get_attribute("position").unwrap().array.len(), 12);
assert_eq!(g.index.as_ref().unwrap().len(), 6);
assert_eq!(g.get_attribute("uv").unwrap().array.len(), 8);
}
#[test]
fn a_quad_is_remembered_as_one_polygon() {
let layer = parse(QUAD).unwrap();
let g = mesh_geometry(layer.prim_at("/World/Quad").unwrap()).unwrap();
assert_eq!(g.polygon_counts(), Some(&[2u32][..]));
assert_eq!(g.polygon_loop(0..2), Some(vec![0, 1, 2, 3]));
let src = QUAD.replace(
"interpolation = \"vertex\"",
"interpolation = \"faceVarying\"",
);
let layer = parse(&src).unwrap();
let g = mesh_geometry(layer.prim_at("/World/Quad").unwrap()).unwrap();
assert_eq!(g.polygon_counts(), Some(&[2u32][..]));
assert_eq!(g.polygon_loop(0..2).map(|l| l.len()), Some(4));
let src = QUAD.replace(
"int[] faceVertexCounts = [4]",
"uniform token orientation = \"leftHanded\"\n int[] faceVertexCounts = [4]",
);
let layer = parse(&src).unwrap();
let g = mesh_geometry(layer.prim_at("/World/Quad").unwrap()).unwrap();
assert_eq!(g.polygon_loop(0..2), Some(vec![0, 3, 2, 1]));
}
#[test]
fn left_handed_orientation_flips_the_winding() {
let right = parse(QUAD).unwrap();
let a = mesh_geometry(right.prim_at("/World/Quad").unwrap()).unwrap();
let flipped = QUAD.replace(
"int[] faceVertexCounts = [4]",
"uniform token orientation = \"leftHanded\"\n int[] faceVertexCounts = [4]",
);
let left = parse(&flipped).unwrap();
let b = mesh_geometry(left.prim_at("/World/Quad").unwrap()).unwrap();
let (ia, ib) = (a.index.clone().unwrap(), b.index.clone().unwrap());
assert_eq!(ia.len(), ib.len());
assert_eq!((ia[0], ia[1], ia[2]), (ib[0], ib[2], ib[1]));
}
#[test]
fn face_varying_primvars_split_the_vertices() {
let src = QUAD.replace("interpolation = \"vertex\"", "interpolation = \"faceVarying\"");
let layer = parse(&src).unwrap();
let g = mesh_geometry(layer.prim_at("/World/Quad").unwrap()).unwrap();
assert!(g.index.is_none());
assert_eq!(g.get_attribute("position").unwrap().array.len(), 18);
assert_eq!(g.get_attribute("uv").unwrap().array.len(), 12);
}
#[test]
fn transforms_come_from_the_op_order() {
let layer = parse(QUAD).unwrap();
let scene = to_scene(&layer);
let world = scene.arena.get(scene.roots[0]).unwrap();
assert_eq!(world.name, "World");
assert!((world.position.x - 1.0).abs() < 1e-6);
assert!((world.position.z - 3.0).abs() < 1e-6);
}
#[test]
fn an_op_that_is_not_in_the_order_is_inactive() {
let src = QUAD.replace(
"uniform token[] xformOpOrder = [\"xformOp:translate\"]",
"uniform token[] xformOpOrder = []",
);
let scene = to_scene(&parse(&src).unwrap());
let world = scene.arena.get(scene.roots[0]).unwrap();
assert!(world.position.length() < 1e-9);
}
#[test]
fn the_bound_material_is_read() {
let layer = parse(QUAD).unwrap();
let scene = to_scene(&layer);
let world = scene.roots[0];
let quad = scene.arena.get(world).unwrap().children[0];
let mesh = scene.arena.get(quad).unwrap();
let material = match &mesh.kind {
crate::core::ObjectKind::Mesh(m) => m.material.clone(),
other => panic!("expected a mesh, got {other:?}"),
};
match &*material {
Material::Standard(s) => {
assert!((s.color.r - 1.0).abs() < 1e-6);
assert!((s.roughness - 0.25).abs() < 1e-6);
assert!((s.metalness - 1.0).abs() < 1e-6);
}
other => panic!("expected a standard material, got {other:?}"),
}
}
#[test]
fn the_hierarchy_is_preserved() {
let scene = to_scene(&parse(QUAD).unwrap());
assert_eq!(scene.roots.len(), 1);
assert_eq!(scene.arena.get(scene.roots[0]).unwrap().children.len(), 2);
}
}
#[cfg(test)]
mod animation_kinds {
use super::*;
use crate::animation::{TrackTarget, TrackValues};
use crate::core::ObjectKind;
fn stage() -> UsdScene {
to_scene(&super::super::parse::parse(include_str!("testdata/allanim.usda")).expect("parses"))
}
fn id_of(scene: &UsdScene, name: &str) -> ObjectId {
fn walk(scene: &UsdScene, id: ObjectId, name: &str) -> Option<ObjectId> {
let node = scene.arena.get(id)?;
if node.name == name {
return Some(id);
}
node.children.iter().find_map(|c| walk(scene, *c, name))
}
scene
.roots
.iter()
.find_map(|r| walk(scene, *r, name))
.unwrap_or_else(|| panic!("no prim called {name}"))
}
fn tracks_for(
scene: &UsdScene,
object: ObjectId,
) -> Vec<&crate::animation::KeyframeTrack> {
scene
.animations
.iter()
.flat_map(|c| &c.tracks)
.filter(|t| t.object == object)
.collect()
}
#[test]
fn a_lights_brightness_and_colour_animate() {
let scene = stage();
let lamp = id_of(&scene, "Lamp");
let tracks = tracks_for(&scene, lamp);
let intensity = tracks
.iter()
.find(|t| matches!(t.target, TrackTarget::Intensity))
.expect("an intensity track");
assert_eq!(intensity.times, vec![0.0, 2.0], "48 codes at 24 a second");
let TrackValues::Scalar(values) = &intensity.values else {
panic!("scalars");
};
assert_eq!(values, &vec![0.0, 100.0]);
let colour = tracks
.iter()
.find(|t| matches!(t.target, TrackTarget::Color))
.expect("a colour track");
let TrackValues::Color(values) = &colour.values else {
panic!("colours");
};
assert_eq!((values[0].r, values[0].b), (1.0, 0.0));
assert_eq!((values[1].r, values[1].b), (0.0, 1.0));
}
#[test]
fn visibility_animates() {
let scene = stage();
let track = tracks_for(&scene, id_of(&scene, "Blinker"))
.into_iter()
.find(|t| matches!(t.target, TrackTarget::Visibility))
.expect("a visibility track");
let TrackValues::Scalar(values) = &track.values else {
panic!("scalars");
};
assert_eq!(values, &vec![1.0, 0.0, 1.0], "on, off, on");
}
#[test]
fn a_bound_materials_colour_animates() {
let scene = stage();
let track = tracks_for(&scene, id_of(&scene, "Painted"))
.into_iter()
.find(|t| matches!(t.target, TrackTarget::Color))
.expect("the bound material's colour");
let TrackValues::Color(values) = &track.values else {
panic!("colours");
};
assert_eq!((values[0].r, values[0].g, values[0].b), (1.0, 1.0, 0.0));
assert_eq!((values[1].r, values[1].g, values[1].b), (0.0, 1.0, 1.0));
}
#[test]
fn animated_vertices_become_morph_targets() {
let scene = stage();
let (_, morphs) = scene
.morph_targets
.iter()
.find(|(name, _)| name == "Wobble")
.expect("the wobbling mesh");
assert_eq!(morphs.targets.len(), 2, "three frames, two targets");
assert_eq!(morphs.targets[0].position_delta[3], 1.0);
assert_eq!(morphs.targets[1].position_delta[7], 2.0);
let tracks = tracks_for(&scene, id_of(&scene, "Wobble"));
let weights: Vec<&crate::animation::KeyframeTrack> = tracks
.iter()
.filter(|t| matches!(t.target, TrackTarget::MorphWeight { .. }))
.copied()
.collect();
assert_eq!(weights.len(), 2);
let TrackValues::Scalar(values) = &weights[0].values else {
panic!("scalars");
};
assert_eq!(values, &vec![0.0, 1.0, 0.0]);
let TrackValues::Scalar(values) = &weights[1].values else {
panic!("scalars");
};
assert_eq!(values, &vec![0.0, 0.0, 1.0]);
let ObjectKind::Mesh(m) = &scene.arena.get(id_of(&scene, "Wobble")).unwrap().kind else {
panic!("a mesh");
};
assert!(m.geometry.morph_targets_relative);
assert_eq!(m.geometry.morph_attributes["position"].len(), 2);
assert_eq!(m.geometry.morph_attributes["position"][1].array[7], 2.0);
assert_eq!(m.morph_influences, vec![0.0, 0.0]);
assert_eq!(m.morph_target_dictionary.get("frame2"), Some(&1));
let ObjectKind::Mesh(mesh) = &scene.arena.get(id_of(&scene, "Wobble")).unwrap().kind else {
panic!("a mesh");
};
assert_eq!(&mesh.geometry.get_attribute("position").unwrap().array[3..5], &[1.0, 0.0]);
}
#[test]
fn every_kind_survives_the_binary_form() {
let binary = to_scene(
&super::super::UsdLoader::parse_layer(include_bytes!("testdata/allanim.usdc"))
.expect("the crate parses"),
);
let kinds: std::collections::BTreeSet<String> = binary
.animations
.iter()
.flat_map(|c| &c.tracks)
.map(|t| format!("{:?}", t.target))
.collect();
for expected in ["Intensity", "Visibility", "Color"] {
assert!(
kinds.iter().any(|k| k.contains(expected)),
"{expected} missing from {kinds:?}"
);
}
assert!(binary.morph_targets.iter().any(|(n, _)| n == "Wobble"));
}
}