Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

model: OBJ/MTL references from another machine find the file next to the model, and a missing one is logged (#1274)

midasmatterhorne6c3e4178c8e
diff --git a/Cargo.lock b/Cargo.lock
index ce8fe1231..8ecad6d92 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1449,6 +1449,7 @@ version = "0.10.0"
dependencies = [
"effectcraft-geom",
"image",
+ "log",
"miniz_oxide 0.8.9",
"serde",
"serde_json",
diff --git a/crates/model/Cargo.toml b/crates/model/Cargo.toml
index 25397921a..9531e5745 100644
--- a/crates/model/Cargo.toml
+++ b/crates/model/Cargo.toml
@@ -14,5 +14,6 @@ effectcraft-geom = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
thiserror = { workspace = true }
+log = { workspace = true }
image = { workspace = true }
miniz_oxide = "0.8"
diff --git a/crates/model/src/obj.rs b/crates/model/src/obj.rs
index 059278ecd..26c01b55a 100644
--- a/crates/model/src/obj.rs
+++ b/crates/model/src/obj.rs
@@ -14,18 +14,52 @@ use std::sync::Arc;
use crate::{AlphaMode, Material, Mesh, Model, Primitive, Result, TexRef, Texture, perr};
+/// The last component of a referenced path, treating `\` as a separator too: a path from a
+/// machine of another kind (`C:\textures\checker.png`) still finds `checker.png` next to the
+/// model (#1274). `None` when the name carries no path at all.
+fn sibling_name(name: &str) -> Option<&str> {
+ let file = name.rsplit(['/', '\\']).next()?;
+ (!file.is_empty() && file.len() < name.len()).then_some(file)
+}
+
+/// A material reference resolved against the model's folder: the name as written (options are
+/// part of it, `-bm 1 file.png`), the whole value (a name containing spaces), then its file name
+/// (an absolute path from another machine, #1274).
+fn resolve_reference(resolve: &dyn Fn(&str) -> Option<Vec<u8>>, name: &str) -> Option<Vec<u8>> {
+ let mut tried: Vec<&str> = vec![];
+ for candidate in [name.split_whitespace().last().unwrap_or(name), name, sibling_name(name).unwrap_or(name)] {
+ if tried.contains(&candidate) {
+ continue;
+ }
+ tried.push(candidate);
+ if let Some(b) = resolve(candidate) {
+ return Some(b);
+ }
+ }
+ None
+}
+
/// Parse MTL text into named materials (textures appended to `textures`).
pub fn parse_mtl(text: &str, resolve: &dyn Fn(&str) -> Option<Vec<u8>>, textures: &mut Vec<Arc<Texture>>) -> Vec<Material> {
let mut out: Vec<Material> = vec![];
let mut loaded: HashMap<String, Option<usize>> = HashMap::new();
let mut tex = |name: &str, textures: &mut Vec<Arc<Texture>>| -> Option<TexRef> {
- // Options (`-bm 1 file.png`): the file name is the last token.
- let file = name.split_whitespace().last()?.to_string();
- let t = *loaded.entry(file.clone()).or_insert_with(|| {
- let b = resolve(&file)?;
- let t = Texture::decode(&b).ok()?;
- textures.push(Arc::new(t));
- Some(textures.len() - 1)
+ let key = name.trim().to_string();
+ let t = *loaded.entry(key.clone()).or_insert_with(|| {
+ let Some(b) = resolve_reference(resolve, &key) else {
+ log::warn!("model: texture `{key}` was not found next to the model");
+ return None;
+ };
+ match Texture::decode(&b) {
+ Ok(t) => {
+ textures.push(Arc::new(t));
+ Some(textures.len() - 1)
+ }
+ Err(e) => {
+ log::warn!("model: cannot decode texture `{key}`: {e}");
+ None
+ }
+ }
});
t.map(|texture| TexRef { texture, uv_set: 0 })
};
@@ -147,13 +181,18 @@ pub fn parse(bytes: &[u8], resolve: &dyn Fn(&str) -> Option<Vec<u8>>) -> Result<
}
"mtllib" => {
let name = line["mtllib".len()..].trim();
- for file in std::iter::once(name).chain(name.split_whitespace()) {
+ let mut found = false;
+ for file in std::iter::once(name).chain(name.split_whitespace()).chain(sibling_name(name)) {
if let Some(b) = resolve(file) {
let mut ms = parse_mtl(&String::from_utf8_lossy(&b), resolve, &mut textures);
materials.append(&mut ms);
+ found = true;
break;
}
}
+ if !found && !name.is_empty() {
+ log::warn!("model: material library `{name}` was not found next to the model");
+ }
}
"usemtl" => {
let name = line["usemtl".len()..].trim();
diff --git a/crates/model/src/tests.rs b/crates/model/src/tests.rs
index 9206ef83f..c68db576c 100644
--- a/crates/model/src/tests.rs
+++ b/crates/model/src/tests.rs
@@ -119,6 +119,54 @@ fn obj_without_normals_gets_them() {
assert!(obj::parse(b"v 0 0 0\n", &|_| None).is_err());
}
+#[test]
+fn obj_textures_from_another_machine_find_the_file_next_to_the_model() {
+ // No committed media: the material file and its textures are written by the test itself.
+ let d = std::env::temp_dir().join(format!("ec-obj-sibling-{}", std::process::id()));
+ let _ = std::fs::remove_dir_all(&d);
+ std::fs::create_dir_all(&d).unwrap();
+ let png = {
+ let img = image::RgbaImage::from_fn(2, 2, |x, y| {
+ if (x + y) % 2 == 0 { image::Rgba([255, 0, 0, 255]) } else { image::Rgba([0, 0, 255, 255]) }
+ });
+ let mut out = std::io::Cursor::new(Vec::new());
+ img.write_to(&mut out, image::ImageFormat::Png).unwrap();
+ out.into_inner()
+ };
+ std::fs::write(d.join("checker.png"), &png).unwrap();
+ std::fs::write(d.join("Diffuse Map.png"), &png).unwrap();
+ let mtl = "newmtl Mat\nKd 0.640000 0.640000 0.640000\nmap_Kd C:\\Users\\somebody\\Desktop\\textures\\checker.png\n\
+ newmtl Spaced\nKd 1.000000 1.000000 1.000000\nmap_Kd Diffuse Map.png\n\
+ newmtl Missing\nKd 0.500000 0.500000 0.500000\nmap_Kd nowhere.png\n";
+ let obj = "mtllib quad.mtl\nv -1 -1 0\nv 1 -1 0\nv 1 1 0\nv -1 1 0\nvt 0 0\nvt 1 0\nvt 1 1\nvt 0 1\n\
+ usemtl Mat\nf 1/1 2/2 3/3\nf 1/1 3/3 4/4\n";
+ // Like the media layer's resolver: a relative name joins the model's folder; an absolute
+ // path is only looked up where it points (here: nowhere else).
+ let resolve = |uri: &str| -> Option<Vec<u8>> {
+ let p = std::path::Path::new(uri);
+ if p.is_absolute() { return None; }
+ std::fs::read(d.join(p)).ok()
+ };
+ let resolver = |uri: &str| -> Option<Vec<u8>> {
+ if uri == "quad.mtl" { Some(mtl.as_bytes().to_vec()) } else { resolve(uri) }
+ };
+ let m = obj::parse(obj.as_bytes(), &resolver).unwrap();
+ assert_eq!(m.materials.len(), 3);
+ let mat = &m.materials[0];
+ let t = mat.base_color_tex.expect("the absolute map_Kd path finds checker.png next to the .obj");
+ let tex = &m.textures[t.texture];
+ assert_eq!((tex.width, tex.height), (2, 2));
+ assert_eq!(tex.data[0], [1.0, 0.0, 0.0, 1.0]);
+ assert!((mat.base_color[0] - obj::srgb_to_linear(0.64)).abs() < 1e-6, "Kd still tints the texture");
+ assert!(m.materials[1].base_color_tex.is_some(), "a texture name containing spaces is one name");
+ assert!(m.materials[2].base_color_tex.is_none(), "a genuinely missing texture keeps the Kd colour");
+ assert!((m.materials[2].base_color[0] - obj::srgb_to_linear(0.5)).abs() < 1e-6);
+ // The same fallback applies to the material library itself.
+ let here = obj.replace("mtllib quad.mtl", "mtllib C:\\build\\quad.mtl");
+ assert_eq!(obj::parse(here.as_bytes(), &resolver).unwrap().materials.len(), 3);
+ let _ = std::fs::remove_dir_all(&d);
+}
+
#[test]
fn channel_interpolation_modes() {
let mut c = Channel { node: 0, path: ChannelPath::Translation, interp: Interp::Step, times: vec![0.0, 1.0], values: vec![0.0, 0.0, 0.0, 10.0, 0.0, 0.0] };