fbxcel 0.9.0

Excellent FBX library
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! FBX data tree loader.

use std::io;

use indextree::Arena;
use log::{debug, error, trace};
use string_interner::{DefaultBackend, StringInterner};

use crate::{
    low::v7400::FbxFooter,
    pull_parser::{
        v7400::{attribute::loaders::DirectLoader, Event, Parser, StartNode},
        Error as ParserError,
    },
    tree::v7400::{LoadError, NodeData, NodeId, NodeNameSym, Tree},
};

/// FBX data tree loader.
#[derive(Debug, Clone)]
pub struct Loader {
    /// Tree data.
    arena: Arena<NodeData>,
    /// Node name interner.
    node_names: StringInterner<DefaultBackend<NodeNameSym>>,
    /// (Implicit) root node ID.
    root_id: NodeId,
}

impl Loader {
    /// Creates a new `Loader`.
    #[inline]
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Loads a tree from the given parser, and returns the tree and FBX footer.
    ///
    /// The given parser should be brand-new, i.e. it should not have emited any
    /// events.
    /// This can be checked by [`Parser::is_used()`].
    /// If the given parser is already used, [`LoadError::BadParser`] error will
    /// be returned.
    ///
    /// If the tree is successfully read but FBX footer is not,
    /// `Ok(tree, Err(parser_error))` is returned.
    pub fn load<R: io::Read>(
        mut self,
        parser: &mut Parser<R>,
    ) -> Result<(Tree, Result<Box<FbxFooter>, ParserError>), LoadError> {
        debug!("Loading FBX data tree from a parser");

        if parser.is_used() {
            error!("The given parser should be brand-new, but it has already emitted some events");
            return Err(LoadError::BadParser);
        }

        let mut open_nodes = vec![self.root_id];
        let footer = loop {
            trace!("Loading next parser event: open_nodes={:?}", open_nodes);
            assert!(
                !open_nodes.is_empty(),
                "Open nodes stack should not be empty on loop start"
            );
            match parser.next_event()? {
                Event::StartNode(start) => {
                    trace!("Got `Event::StartNode(name={:?})`", start.name());
                    let parent = open_nodes
                        .last_mut()
                        .expect("Should never fail: Open nodes stack should not be empty here");
                    let current = self.add_node(*parent, start)?;

                    // Update the open nodes stack.
                    open_nodes.push(current);
                }
                Event::EndNode => {
                    trace!("Got `Event::EndNode`");
                    open_nodes
                        .pop()
                        .expect("Should never fail: Open nodes stack should not be empty here");
                }
                Event::EndFbx(footer) => {
                    trace!("Got `Event::EndFbx(_)`");
                    open_nodes
                        .pop()
                        .expect("Should never fail: Open nodes stack should not be empty here");
                    break footer;
                }
            }
        };
        assert!(
            open_nodes.is_empty(),
            "Should never fail: There should be no open nodes after `EndFbx` event is emitted"
        );

        debug!("Successfully loaded FBX data tree");
        let tree = Tree::new(self.arena, self.node_names, self.root_id);
        Ok((tree, footer))
    }

    /// Creates and adds a new node to the tree.
    fn add_node<R: io::Read>(
        &mut self,
        parent: NodeId,
        start: StartNode<'_, R>,
    ) -> Result<NodeId, LoadError> {
        trace!(
            "Adding a new child name={:?} to the parent {:?}",
            start.name(),
            parent
        );

        // Create a new node.
        let current = {
            let name_sym = self.node_names.get_or_intern(start.name());
            let attributes = start
                .attributes()
                .into_iter(std::iter::repeat(DirectLoader))
                .collect::<Result<Vec<_>, _>>()?;

            NodeId::new(self.arena.new_node(NodeData::new(name_sym, attributes)))
        };

        // Set the parent.
        parent.raw().append(current.raw(), &mut self.arena);

        trace!(
            "Successfully added a new child {:?} to the parent {:?}",
            current,
            parent
        );

        Ok(current)
    }
}

impl Default for Loader {
    fn default() -> Self {
        let mut arena = Arena::new();
        let mut node_names = StringInterner::new();
        let root_id = {
            // Use empty string as dummy node name.
            let empty_sym = node_names.get_or_intern("");
            NodeId::new(arena.new_node(NodeData::new(empty_sym, Vec::new())))
        };
        Self {
            arena,
            node_names,
            root_id,
        }
    }
}