fbxcel/
pull_parser.rs

1//! Pull parser for FBX binary.
2//!
3//! # FBX versions and types
4//!
5//! Some types are version-agnostic, and some aren't.
6//!
7//! These modules are common among all supported FBX versions:
8//!
9//! * Error types (defined in [`error`] module).
10//! * [`AnyParser`][`any::AnyParser`] feature (defined in [`any`] module).
11//!
12//! # Using pull parser
13//!
14//! There are two ways to set up a parser: easy setup and manual setup.
15//!
16//! ## Easy setup (recommended)
17//!
18//! If you don't care about precise FBX version (e.g. difference between FBX 7.4
19//! and 7.5), you can use easy setup using [`any`] module.
20//!
21//! ```no_run
22//! use fbxcel::pull_parser::any::AnyParser;
23//!
24//! let file = std::fs::File::open("sample.fbx").expect("Failed to open file");
25//! // You can also use raw `file`, but do buffering for better efficiency.
26//! let reader = std::io::BufReader::new(file);
27//!
28//! // Use `AnyParser::from_seekable_reader` for readers implementing
29//! // `std::io::Seek`. To use readers without `std::io::Seek` implementation,
30//! // use `AnyPraser::from_reader` instead.
31//! match AnyParser::from_seekable_reader(reader).expect("Failed to setup FBX parser") {
32//!     // Use v7400 parser (implemented in `v7400` module).
33//!     AnyParser::V7400(mut parser) => {
34//!         // You got a parser! Do what you want!
35//!     },
36//!     // `AnyParser` is nonexhaustive.
37//!     // You should handle new unknown parser version case.
38//!     _ => panic!("Unsupported FBX parser is required"),
39//! }
40//! ```
41//!
42//! ## Manual setup
43//!
44//! In this way you have full control, but usual users don't need this.
45//!
46//! 1. Get FBX header.
47//! 2. Decide which version of parser to use.
48//! 3. Create parser with source reader.
49//!
50//! ```no_run
51//! use fbxcel::{low::FbxHeader, pull_parser::ParserVersion};
52//!
53//! let file = std::fs::File::open("sample.fbx").expect("Failed to open file");
54//! // You can also use raw `file`, but do buffering for better efficiency.
55//! let mut reader = std::io::BufReader::new(file);
56//!
57//! // 1. Get FBX header.
58//! let header = FbxHeader::load(&mut reader)
59//!     .expect("Failed to load FBX header");
60//! // 2. Decide which version of parser to use.
61//! match header.parser_version() {
62//!     // Use v7400 parser (implemented in `v7400` module).
63//!     Some(ParserVersion::V7400) => {
64//!         // 3. Create parser with source reader.
65//!         // Pass both header and reader.
66//!         // Use `Parser::from_seekable_reader` for readers implementing
67//!         // `std::io::Seek`. To use readers without `std::io::Seek`
68//!         // implementation, use `Parser::from_reader` instead.
69//!         let mut parser = fbxcel::pull_parser::v7400::Parser::from_seekable_reader(header, reader)
70//!             .expect("Failed to setup parser");
71//!         // You got a parser! Do what you want!
72//!     },
73//!     // `ParserVersion` is nonexhaustive.
74//!     // You should handle new unknown parser version case.
75//!     Some(v) => panic!("Parser version {:?} is not yet supported", v),
76//!     // No appropriate parser found
77//!     None => panic!(
78//!         "FBX version {:?} is not supported by backend library",
79//!         header.version()
80//!     ),
81//! }
82//! ```
83
84pub use self::{
85    error::{Error, Result, Warning},
86    position::SyntacticPosition,
87    version::ParserVersion,
88};
89
90pub mod any;
91pub mod error;
92mod position;
93mod reader;
94pub mod v7400;
95mod version;