fbxcelのテストコード

binary-parser-simple.rs

extern crate env_logger;
extern crate fbxcel;

use std::fs::File;
use std::io::BufReader;
use std::path::Path;


#[test]
fn test_binary_parser() {
    env_logger::init().unwrap();

    test_parser("resources/NakanoSisters_1_2_FBX/naka.fbx");
    test_parser("resources/unitychan.fbx");
    test_parser("resources/blender_2_78_default.fbx");
}


fn test_parser<P: AsRef<Path>>(path: P) {
    let file = File::open(path).unwrap();
    //let mut parser = fbxcel::parser::binary::BinaryParser::new(BufReader::new(file));
    let mut parser = fbxcel::parser::binary::BinaryParser::from_seekable(BufReader::new(file));
    let mut depth = 0;

    loop {
        use fbxcel::parser::binary::*;

        let ev = parser.next_event().unwrap();
        match ev {
            Event::StartFbx(_) => {
                depth += 1;
            },
            Event::EndFbx(_) => {
                depth -= 1;
                break;
            },
            Event::StartNode(StartNode { mut attributes, .. }) => {
                while let Some(attr) = attributes.next_attribute().unwrap() {
                    match attr {
                        Attribute::Primitive(val) => {
                            let _ = val;
                        },
                        Attribute::Array(val) => match val {
                            ArrayAttribute::Bool(val) => {
                                //let arr = val.collect::<::std::result::Result<Vec<_>, _>>();
                                let arr = val.into_vec();
                                assert!(arr.is_ok());
                            },
                            ArrayAttribute::I32(val) => {
                                //let arr = val.collect::<::std::result::Result<Vec<_>, _>>();
                                let arr = val.into_vec();
                                assert!(arr.is_ok());
                            },
                            ArrayAttribute::I64(val) => {
                                //let arr = val.collect::<::std::result::Result<Vec<_>, _>>();
                                let arr = val.into_vec();
                                assert!(arr.is_ok());
                            },
                            ArrayAttribute::F32(val) => {
                                //let arr = val.collect::<::std::result::Result<Vec<_>, _>>();
                                let arr = val.into_vec();
                                assert!(arr.is_ok());
                            },
                            ArrayAttribute::F64(val) => {
                                //let arr = val.collect::<::std::result::Result<Vec<_>, _>>();
                                let arr = val.into_vec();
                                assert!(arr.is_ok());
                            },
                        },
                        Attribute::Special(mut val) => {
                            match val.value_type() {
                                SpecialAttributeType::Binary => {
                                    use std::io::{Seek, SeekFrom};
                                    //let vec = val.into_vec();
                                    //assert!(vec.is_ok());

                                    let mut reader = val.reader();
                                    reader.seek(SeekFrom::End(0)).unwrap();
                                    let size = reader.seek(SeekFrom::Current(0)).unwrap();
                                    reader.seek(SeekFrom::Current(-(size as i64) / 2)).unwrap();
                                    assert_eq!(reader.seek(SeekFrom::Start(0)).unwrap(), 0);
                                    assert_eq!(reader.seek(SeekFrom::End(0)).unwrap(), size);
                                    println!("binary attr size = {}", size);
                                },
                                SpecialAttributeType::String => {
                                    let vec = val.into_vec();
                                    assert!(vec.is_ok());
                                },
                            }
                        },
                    }
                }
                depth += 1;
            },
            Event::EndNode => {
                depth -= 1;
            },
        }
    }

    assert_eq!(depth, 0);
}