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 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
// Copyright 2017 The gltf Library Developers // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![deny(missing_docs)] //! glTF 2.0 loader //! //! This crate is intended to load [glTF 2.0], a file format designed for the //! efficient runtime transmission of 3D scenes. The crate aims to provide //! rustic utilities that make working with glTF simple and intuitive. //! //! [glTF 2.0]: https://www.khronos.org/gltf //! //! ## Installation //! //! Add `gltf` version 0.9 to your `Cargo.toml`. //! //! ```toml //! [dependencies.gltf] //! version = "0.9" //! ``` //! //! ## Examples //! //! ### Walking the node hierarchy //! //! Below demonstates visiting the root [`Node`]s of every [`Scene`], printing the //! number of children each node has. //! //! [`Node`]: scene/struct.Node.html //! [`Scene`]: scene/struct.Scene.html //! ``` //! # fn run() -> Result<(), Box<std::error::Error>> { //! # use std::{fs, io}; //! # let path = "examples/Box.gltf"; //! use gltf::Gltf; //! let file = fs::File::open(path)?; //! let gltf = Gltf::from_reader(io::BufReader::new(file))?.validate_minimally()?; //! for scene in gltf.scenes() { //! for node in scene.nodes() { //! // Do something with this node. //! println!( //! "Node {} has {} children", //! node.index(), //! node.children().count(), //! ); //! } //! } //! # Ok(()) //! # } //! # fn main() { //! # let _ = run().expect("No runtime errors"); //! # } //! ``` #[cfg(test)] #[macro_use] extern crate approx; extern crate cgmath; #[macro_use] extern crate lazy_static; /// Contains (de)serializable data structures that match the glTF JSON text. #[deprecated(since = "0.9.1", note = "Will be removed in 1.0.0")] #[doc(hidden)] pub extern crate gltf_json as json; /// Accessors for reading vertex attributes from buffer views. pub mod accessor; /// Animations, their channels, targets, and samplers. pub mod animation; /// Buffers and buffer views. pub mod buffer; /// Cameras and their projections. pub mod camera; /// Primitives for working with binary glTF. pub mod glb; /// **The main module - start here.** pub mod gltf; /// Images that may be used by textures. pub mod image; /// Material properties of primitives. pub mod material; /// Meshes and their primitives. pub mod mesh; /// The glTF node heirarchy. pub mod scene; /// Mesh skinning primitives. pub mod skin; /// Textures and their samplers. pub mod texture; pub use self::animation::Animation; pub use self::accessor::Accessor; pub use self::buffer::Buffer; pub use self::camera::Camera; pub use self::glb::Glb; pub use self::gltf::{Gltf, Unvalidated}; pub use self::image::Image; pub use self::material::Material; pub use self::mesh::{Attribute, Mesh, Primitive, Semantic}; pub use self::scene::{Node, Scene}; pub use self::skin::Skin; pub use self::texture::Texture; /// Represents a runtime error. #[derive(Debug)] pub enum Error { /// JSON deserialization error. Deserialize(json::Error), /// GLB parsing error. Glb(String), /// `glTF` validation error. Validation(Vec<(json::Path, json::validation::Error)>), } /// Returns `true` if the slice begins with the `b"glTF"` magic string, indicating /// a binary `glTF` asset. /// /// # Examples /// /// ```rust /// assert_eq!(true, gltf::is_binary(b"glTF...")); /// assert_eq!(false, gltf::is_binary(b"{...}")); /// ``` pub fn is_binary(slice: &[u8]) -> bool { slice.starts_with(b"glTF") } impl std::fmt::Display for Error { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { use std::error::Error; write!(f, "{}", self.description()) } } impl std::error::Error for Error { fn description(&self) -> &str { match *self { Error::Deserialize(_) => "deserialization error", Error::Glb(_) => "invalid .glb format", Error::Validation(_) => "invalid glTF JSON", } } } impl From<json::Error> for Error { fn from(err: json::Error) -> Self { Error::Deserialize(err) } } impl From<Vec<(json::Path, json::validation::Error)>> for Error { fn from(errs: Vec<(json::Path, json::validation::Error)>) -> Self { Error::Validation(errs) } }