draco-io 0.3.2

Rust IO helpers for Draco geometry compression formats
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! Compare a big-endian FBX against its little-endian twin.
//!
//! The two files describe the same scene, so every decoded value must match
//! except the version field. Run with:
//!
//! ```text
//! cargo run --example fbx_endian_diff -- little.fbx big.fbx
//! ```

use draco_io::fbx_reader::{FbxNode, FbxProperty};
use draco_io::FbxReader;
use std::env;

fn summarize(node: &FbxNode, depth: usize, out: &mut Vec<String>) {
    let props: Vec<String> = node
        .properties
        .iter()
        .map(|p| match p {
            FbxProperty::Bool(v) => format!("B{v}"),
            FbxProperty::U8(v) => format!("Z{v}"),
            FbxProperty::I16(v) => format!("Y{v}"),
            FbxProperty::I32(v) => format!("I{v}"),
            FbxProperty::I64(v) => format!("L{v}"),
            FbxProperty::F32(v) => format!("F{v:.6}"),
            FbxProperty::F64(v) => format!("D{v:.9}"),
            FbxProperty::String(v) => format!("S{v}"),
            FbxProperty::Raw(v) => format!("R[{}]", v.len()),
            FbxProperty::BoolArray(v) => format!("b{:?}", &v[..v.len().min(4)]),
            FbxProperty::I32Array(v) => format!("i[{}]{:?}", v.len(), &v[..v.len().min(4)]),
            FbxProperty::I64Array(v) => format!("l[{}]{:?}", v.len(), &v[..v.len().min(4)]),
            FbxProperty::F32Array(v) => format!("f[{}]{:?}", v.len(), &v[..v.len().min(4)]),
            FbxProperty::F64Array(v) => format!("d[{}]{:?}", v.len(), &v[..v.len().min(4)]),
        })
        .collect();
    out.push(format!(
        "{}{} {}",
        "  ".repeat(depth),
        node.name,
        props.join(",")
    ));
    for child in &node.children {
        summarize(child, depth + 1, out);
    }
}

fn load(path: &str) -> Result<Vec<String>, Box<dyn std::error::Error>> {
    let mut reader = FbxReader::open(path)?;
    println!(
        "{path}: version={} order={:?}",
        reader.version(),
        reader.byte_order()
    );
    let mut out = Vec::new();
    for node in reader.read_nodes()? {
        summarize(&node, 0, &mut out);
    }
    Ok(out)
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = env::args().collect();
    if args.len() < 3 {
        return Err("usage: fbx_endian_diff <little.fbx> <big.fbx>".into());
    }
    let little = load(&args[1])?;
    let big = load(&args[2])?;

    if little.len() != big.len() {
        println!("MISMATCH: {} lines vs {} lines", little.len(), big.len());
    }
    let mut differences = 0;
    for (index, (l, b)) in little.iter().zip(big.iter()).enumerate() {
        // The version node legitimately differs between the two profiles.
        if l != b {
            differences += 1;
            if differences <= 10 {
                println!("line {index}:\n  LE {l}\n  BE {b}");
            }
        }
    }
    println!(
        "compared {} lines, {differences} differing",
        little.len().min(big.len())
    );
    if differences == 0 && little.len() == big.len() {
        println!("IDENTICAL");
    }
    Ok(())
}