├── .github ├── FUNDING.yml └── workflows │ └── ci.yml ├── src ├── utils │ ├── mod.rs │ ├── triangulate.rs │ └── fbx_extend.rs ├── lib.rs ├── data.rs ├── fbx_transform.rs ├── material_loader.rs └── loader.rs ├── assets └── cube.fbx ├── .gitignore ├── scripts ├── test_wasm.html └── test_wasm.sh ├── .editorconfig ├── LICENSE-MIT ├── Cargo.toml ├── dev_docs ├── fbx_tree_printer.rs └── custom_material_design.md ├── examples ├── cube.rs └── scene_viewer.rs ├── CONTRIBUTING.md ├── README.md └── LICENSE-APACHE /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: [nicopap, HeavyRain266] 2 | -------------------------------------------------------------------------------- /src/utils/mod.rs: -------------------------------------------------------------------------------- 1 | pub(crate) mod fbx_extend; 2 | pub(crate) mod triangulate; 3 | -------------------------------------------------------------------------------- /assets/cube.fbx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nicopap/bevy_mod_fbx/HEAD/assets/cube.fbx -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Cargo 2 | /target 3 | Cargo.lock 4 | 5 | # Nix/NixOS 6 | .envrc # direnv 7 | shell.nix 8 | flake.nix 9 | flake.lock 10 | 11 | # VScode 12 | .vscode 13 | 14 | # Jetbrains 15 | .idea 16 | .fleet 17 | -------------------------------------------------------------------------------- /scripts/test_wasm.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 12 | 13 | 14 | -------------------------------------------------------------------------------- /.editorconfig: -------------------------------------------------------------------------------- 1 | root = true 2 | 3 | [*] 4 | charset = utf-8 5 | indent_size = 4 6 | indent_style = tab 7 | end_of_line = crlf 8 | max_line_length = 80 9 | insert_final_newline = true 10 | trim_trailing_whitespace = true 11 | 12 | [*.rs] 13 | indent_size = 4 14 | indent_style = space 15 | 16 | [*.toml] 17 | indent_size = 2 18 | indent_style = space 19 | 20 | [*.yml] 21 | indent_size = 2 22 | indent_style = space 23 | 24 | [*.md] 25 | indent_style = space 26 | trim_trailing_whitespace = false -------------------------------------------------------------------------------- /LICENSE-MIT: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy 4 | of this software and associated documentation files (the "Software"), to deal 5 | in the Software without restriction, including without limitation the rights 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 | copies of the Software, and to permit persons to whom the Software is 8 | furnished to do so, subject to the following conditions: 9 | 10 | The above copyright notice and this permission notice shall be included in all 11 | copies or substantial portions of the Software. 12 | 13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 19 | SOFTWARE. 20 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "bevy_mod_fbx" 3 | authors = ["Nicola Papale", "HeavyRain266"] 4 | description = "Autodesk Filmbox (*.fbx) loader for Bevy Engine" 5 | license = "MIT OR Apache-2.0" 6 | readme = "README.md" 7 | keywords = ["bevy", "bevy_plugin", "fbx_loader"] 8 | categories = ["game-development"] 9 | repository = "https://github.com/nicopap/bevy_mod_fbx" 10 | exclude = ["assets/**/*", "scripts/**/*", ".github/**/*"] 11 | version = "0.4.0" 12 | edition = "2021" 13 | 14 | [features] 15 | profile = [] 16 | maya_3dsmax_pbr = [] 17 | 18 | [dependencies] 19 | rgb = "0.8" 20 | anyhow = "1.0.58" 21 | glam = { version = "0.23", features = ["mint"] } 22 | mint = "0.5" 23 | # fbxcel-dom = { version = "0.0.9", path = "../fbxcel-dom" } 24 | fbxcel-dom = "0.0.9" 25 | 26 | [dependencies.bevy] 27 | version = "0.10" 28 | default-features = false 29 | features = [ 30 | "bevy_pbr", 31 | "bevy_asset", 32 | "bevy_render", 33 | "bevy_scene", 34 | ] 35 | 36 | [dev-dependencies.bevy] 37 | version = "0.10" 38 | default-features = false 39 | features = [ 40 | "x11", #"wayland", 41 | 42 | "tga", "dds", 43 | "bevy_pbr", 44 | "bevy_render", 45 | "bevy_winit", 46 | "bevy_scene", 47 | "filesystem_watcher", 48 | "bevy_core_pipeline" 49 | ] 50 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | use bevy::prelude::{AddAsset, App, Plugin, Resource}; 2 | 3 | pub use data::{FbxMesh, FbxScene}; 4 | pub use loader::FbxLoader; 5 | 6 | pub(crate) mod data; 7 | pub(crate) mod fbx_transform; 8 | pub(crate) mod loader; 9 | pub mod material_loader; 10 | pub(crate) mod utils; 11 | 12 | use material_loader::MaterialLoader; 13 | 14 | /// Adds support for FBX file loading to the app. 15 | #[derive(Default)] 16 | pub struct FbxPlugin; 17 | 18 | /// Resource to control which material loaders the `FbxLoader` 19 | /// uses. 20 | /// 21 | /// See [`MaterialLoader`] documentation for more details. 22 | /// 23 | /// You can define your own by inserting this as a resource 24 | /// **before** adding the `FbxPlugin` to the app. 25 | /// If you define your own, make sure to add back the default 26 | /// fallback methods if you need them! 27 | /// 28 | /// The default loaders are defined by [`material_loader::default_loader_order`]. 29 | #[derive(Clone, Resource)] 30 | pub struct FbxMaterialLoaders(pub Vec); 31 | impl Default for FbxMaterialLoaders { 32 | fn default() -> Self { 33 | Self(material_loader::default_loader_order().into()) 34 | } 35 | } 36 | 37 | impl Plugin for FbxPlugin { 38 | fn build(&self, app: &mut App) { 39 | app.init_asset_loader::() 40 | .add_asset::() 41 | .add_asset::(); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /dev_docs/fbx_tree_printer.rs: -------------------------------------------------------------------------------- 1 | fn print_children(depth: usize, children: Children) { 2 | let show_depth = depth * 3; 3 | for child in children { 4 | print!("{space:>depth$}", space = "", depth = show_depth); 5 | if child.name().len() > 1 { 6 | print!("{name} ", name = child.name(),); 7 | } 8 | let attr_display = |att: &AttributeValue| match att { 9 | AttributeValue::Bool(v) => v.to_string(), 10 | AttributeValue::I16(v) => v.to_string(), 11 | AttributeValue::I32(v) => v.to_string(), 12 | AttributeValue::I64(v) => v.to_string(), 13 | AttributeValue::F32(v) => v.to_string(), 14 | AttributeValue::F64(v) => v.to_string(), 15 | AttributeValue::ArrBool(_) => "[bool]".to_owned(), 16 | AttributeValue::ArrI32(_) => "[i32]".to_owned(), 17 | AttributeValue::ArrI64(_) => "[i64]".to_owned(), 18 | AttributeValue::ArrF32(_) => "[f32]".to_owned(), 19 | AttributeValue::ArrF64(_) => "[f64]".to_owned(), 20 | AttributeValue::String(s) => s.clone(), 21 | AttributeValue::Binary(_) => "[u8]".to_owned(), 22 | }; 23 | print!("["); 24 | for (i, attr) in child.attributes().iter().map(attr_display).enumerate() { 25 | // if matches!(i, 1 | 2 | 3) { 26 | // continue; 27 | // } 28 | if i == 0 { 29 | print!("{attr}: "); 30 | } else { 31 | print!("{attr}, "); 32 | } 33 | } 34 | println!("]"); 35 | if child.children().next().is_some() { 36 | println!("{:>depth$}{{", "", depth = show_depth); 37 | } 38 | print_children(depth + 1, child.children()); 39 | if child.children().next().is_some() { 40 | println!("{:>depth$}}}", "", depth = show_depth); 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/data.rs: -------------------------------------------------------------------------------- 1 | use bevy::{ 2 | prelude::{Handle, Image, Mesh, StandardMaterial, Transform}, 3 | reflect::TypeUuid, 4 | utils::HashMap, 5 | }; 6 | use fbxcel_dom::v7400::object::ObjectId; 7 | 8 | #[derive(Debug, Clone, TypeUuid)] 9 | #[uuid = "966d55c0-515b-4141-97a1-de30ac8ee44c"] 10 | pub struct FbxMesh { 11 | pub name: Option, 12 | pub bevy_mesh_handles: Vec>, 13 | pub materials: Vec>, 14 | } 15 | 16 | /// The data loaded from a FBX scene. 17 | /// 18 | /// Note that the loader spawns a [`Scene`], with all the 19 | /// FBX nodes spawned as entities (with their corresponding [`Name`] set) 20 | /// in the ECS, 21 | /// and you should absolutely use the ECS entities over 22 | /// manipulating this data structure. 23 | /// It is provided publicly, because it might be a good store for strong handles. 24 | /// 25 | /// [`Scene`]: bevy::scene::Scene 26 | /// [`Name`]: bevy::core::Name 27 | #[derive(Default, Debug, Clone, TypeUuid)] 28 | #[uuid = "e87d49b6-8d6a-43c7-bb33-5315db8516eb"] 29 | pub struct FbxScene { 30 | pub name: Option, 31 | pub bevy_meshes: HashMap, String>, 32 | pub materials: HashMap>, 33 | pub textures: HashMap>, 34 | pub meshes: HashMap>, 35 | pub hierarchy: HashMap, 36 | pub roots: Vec, 37 | } 38 | 39 | /// An FBX object in the scene tree. 40 | /// 41 | /// This serves as a node in the transform hierarchy. 42 | #[derive(Default, Debug, Clone)] 43 | pub struct FbxObject { 44 | pub name: Option, 45 | pub transform: Transform, 46 | /// The children of this node. 47 | /// 48 | /// # Notes 49 | /// Not all [`ObjectId`] declared as child of an `FbxObject` 50 | /// are relevant to Bevy. 51 | /// Meaning that you won't find the `ObjectId` in `hierarchy` or `meshes` 52 | /// `HashMap`s of the [`FbxScene`] structure. 53 | pub children: Vec, 54 | } 55 | -------------------------------------------------------------------------------- /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: Continous Integration 2 | 3 | on: 4 | push: 5 | branches: [main] 6 | pull_request: 7 | branches: [main] 8 | 9 | env: 10 | CARGO_TERM_COLORS: always 11 | 12 | jobs: 13 | clippy_check: 14 | name: Clippy 15 | runs-on: ubuntu-latest 16 | steps: 17 | - name: Checkout sources 18 | uses: actions/checkout@v3 19 | - name: Cache 20 | uses: actions/cache@v2 21 | with: 22 | path: | 23 | ~/.cargo/bin/ 24 | ~/.cargo/registry/index/ 25 | ~/.cargo/registry/cache/ 26 | ~/.cargo/git/db/ 27 | target/ 28 | key: ${{ runner.os }}-cargo-clippy-${{ hashFiles('**/Cargo.toml') }} 29 | - name: Install stable toolchain 30 | uses: actions-rs/toolchain@v1 31 | with: 32 | toolchain: stable 33 | profile: minimal 34 | components: clippy 35 | override: true 36 | - name: Install Dependencies 37 | run: sudo apt-get update; sudo apt-get install pkg-config libx11-dev libasound2-dev libudev-dev 38 | - name: Run clippy 39 | uses: actions-rs/clippy-check@v1 40 | with: 41 | token: ${{ secrets.GITHUB_TOKEN }} 42 | args: --examples -- -D warnings 43 | - name: Run clippy for optional features 44 | uses: actions-rs/clippy-check@v1 45 | with: 46 | token: ${{ secrets.GITHUB_TOKEN }} 47 | args: --examples --features maya_3dsmax_pbr -- -D warnings 48 | 49 | format: 50 | name: Format 51 | runs-on: ubuntu-latest 52 | steps: 53 | - name: Checkout sources 54 | uses: actions/checkout@v2 55 | - name: Install stable toolchain 56 | uses: actions-rs/toolchain@v1 57 | with: 58 | toolchain: stable 59 | profile: minimal 60 | components: rustfmt 61 | override: true 62 | - name: Run cargo fmt 63 | uses: actions-rs/cargo@v1 64 | with: 65 | command: fmt 66 | args: --all -- --check 67 | -------------------------------------------------------------------------------- /examples/cube.rs: -------------------------------------------------------------------------------- 1 | use bevy::{ 2 | log::{Level, LogPlugin}, 3 | prelude::*, 4 | render::camera::ScalingMode, 5 | window::{close_on_esc, WindowResolution}, 6 | }; 7 | use bevy_mod_fbx::FbxPlugin; 8 | 9 | #[derive(Component)] 10 | pub struct Spin; 11 | 12 | fn main() { 13 | let mut app = App::new(); 14 | 15 | app.add_plugins( 16 | DefaultPlugins 17 | .set(LogPlugin { 18 | level: Level::INFO, 19 | filter: "bevy_mod_fbx=trace,wgpu=warn".to_owned(), 20 | }) 21 | .set(WindowPlugin { 22 | primary_window: Some(Window { 23 | title: "Spinning Cube".into(), 24 | resolution: WindowResolution::new(756., 574.), 25 | ..default() 26 | }), 27 | ..default() 28 | }), 29 | ) 30 | .add_plugin(FbxPlugin) 31 | .add_startup_system(setup) 32 | .add_system(spin_cube) 33 | .add_system(close_on_esc); 34 | 35 | app.run(); 36 | } 37 | 38 | fn spin_cube(time: Res, mut query: Query<&mut Transform, With>) { 39 | for mut transform in query.iter_mut() { 40 | transform.rotate_local_y(0.3 * time.delta_seconds()); 41 | transform.rotate_local_x(0.3 * time.delta_seconds()); 42 | transform.rotate_local_z(0.3 * time.delta_seconds()); 43 | } 44 | } 45 | 46 | fn setup(mut cmd: Commands, asset_server: Res) { 47 | // Orthographic camera 48 | cmd.spawn(Camera3dBundle { 49 | projection: OrthographicProjection { 50 | scale: 3.0, 51 | scaling_mode: ScalingMode::FixedVertical(2.0), 52 | ..default() 53 | } 54 | .into(), 55 | transform: Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y), 56 | ..default() 57 | }); 58 | 59 | // light 60 | cmd.spawn(PointLightBundle { 61 | transform: Transform::from_xyz(3.0, 8.0, 5.0), 62 | ..default() 63 | }); 64 | 65 | // Cube 66 | cmd.spawn(( 67 | SceneBundle { 68 | scene: asset_server.load("cube.fbx#Scene"), 69 | ..default() 70 | }, 71 | Spin, 72 | )); 73 | } 74 | -------------------------------------------------------------------------------- /scripts/test_wasm.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/bash 2 | # Adopted from https://github.com/team-plover/warlocks-gambit 3 | 4 | set -e 5 | 6 | # Install wasm-bindgen with `cargo install wasm-bindgen-cli`. 7 | # Pass --run option to run after build (uses python). 8 | # Files in OutDir is everything needed to run the web page. 9 | 10 | OutDir=target/wasm_package 11 | 12 | HttpServerAddress=127.0.0.1 13 | HttpServerPort=8000 14 | 15 | if [ ! -e .git ]; then 16 | echo "Must be run from repository root" 17 | exit 1 18 | fi 19 | 20 | # 21 | # Extract project name from Cargo.toml 22 | # 23 | 24 | ProjName="$(cargo metadata --no-deps --format-version 1 | 25 | sed -n 's/.*"name":"$[^"]*$".*/\1/p')" 26 | 27 | # 28 | # Build 29 | # 30 | 31 | if [ ! -e target ] ; then 32 | mkdir target 33 | fi 34 | 35 | cargo build \ 36 | --release --examples \ 37 | --no-default-features \ 38 | --target wasm32-unknown-unknown \ 39 | 40 | WasmFile="$(cargo metadata --format-version 1 | sed -n 's/.*"target_directory":"$[^"]*$".*/\1/p')/wasm32-unknown-unknown/release/examples/$ProjName.wasm" 41 | 42 | if [ ! -e "$WasmFile" ]; then 43 | echo "Script is borken, it expects file to exist: $WasmFile" 44 | exit 1 45 | fi 46 | 47 | [ ! -e "$OutDir" ] || rm -r "$OutDir" 48 | 49 | BINDGEN_EXEC_PATH="$HOME/.cargo/bin/wasm-bindgen" 50 | 51 | if [ ! -e "$BINDGEN_EXEC_PATH" ] ; then 52 | echo "Please install wasm-bindgen, cannot generate the wasm output without it" 53 | exit 1 54 | fi 55 | 56 | $BINDGEN_EXEC_PATH \ 57 | --no-typescript \ 58 | --out-dir "$OutDir" \ 59 | --target web \ 60 | "$WasmFile" 61 | 62 | # 63 | # Copy files 64 | # 65 | 66 | cp scripts/test_wasm.html "$OutDir/index.html" 67 | cp -r assets "$OutDir/assets" 68 | 69 | # 70 | # Rename JS 71 | # 72 | 73 | Count=0 74 | for _ in $OutDir/*.js; do 75 | ((Count+=1)) 76 | done 77 | 78 | if [ $Count -ne 1 ]; then 79 | echo "Script is broken, must be 1 JS file matching mask" 80 | exit 1 81 | fi 82 | 83 | mv $OutDir/*.js "$OutDir/main.js" 84 | 85 | # 86 | # Run 87 | # 88 | 89 | if [ "$1" = "--run" ]; then 90 | python3 -m http.server --bind $HttpServerAddress --directory "$OutDir" $HttpServerPort & 91 | Browser=${BROWSER:-chromium} 92 | $Browser http://$HttpServerAddress:$HttpServerPort/index.html 93 | fi 94 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing 2 | 3 | ### About 4 | 5 | FBX is a very widely used and flexible file format. 6 | We currently expect most models **to not load properly**. 7 | We cannot test how `bevy_mod_fbx` handles the export formats of every software out there. 8 | If your model loads properly, thank your lucky start, 9 | if you encounter any issue please do the following: 10 | 11 | - Try opening the model using the `scene_viewer` (run `cargo run --example scene_viewer --release -- /path/to/file.fbx`) 12 | (if your file has textures, make sure to enable the correct file formats using `--features bevy/png bevy/jpg bevy/tga` etc.) 13 | - If it fails, open an [issue] on our Github repo with a screenshot in the scene viewer 14 | and a screenshot of how the model should look like 15 | - Ideally provide a download link to your FBX model 16 | 17 | #### What have to be done 18 | 19 | - [ ] Proper handling of Coordinate system 20 | - [ ] Support `bevy_animation` as optional feature ([#13]) 21 | - [ ] Provide examples with usage of complex scenes ([#6]) 22 | - [ ] Convert lambert into PBR and load materials ([#12]) 23 | - [ ] Expand/rewrite triangulator ([#11]) 24 | 25 | #### Commiting changes 26 | 27 | Before you commit any changes, ensure that `rustfmt` is installed and then run `cargo fmt`. 28 | 29 | #### Further troubleshooting tools 30 | 31 | If you want to help us figure out how to load a particularly tricky model, 32 | the following tools may be useful: 33 | 34 | - 35 | - 36 | - Use the `profile` feature with the [profiling] instructions from Bevy Engine 37 | 38 | ### Licensing 39 | 40 | Unless you explicitly state otherwise, 41 | any contribution intentionally submitted for inclusion in the work by you, 42 | as defined in the Apache-2.0 license, shall be dual licensed 43 | as in the [License](#license) section, 44 | without any additional terms or conditions. 45 | 46 | [issue]: https://github.com/HeavyRain266/bevy_mod_fbx/issues/new/choose 47 | [profiling]: https://github.com/bevyengine/bevy/blob/main/docs/profiling.md 48 | 49 | [#13]: https://github.com/HeavyRain266/bevy_mod_fbx/issues/13 50 | [#6]: https://github.com/HeavyRain266/bevy_mod_fbx/issues/6 51 | [#12]: https://github.com/HeavyRain266/bevy_mod_fbx/issues/12 52 | [#11]: https://github.com/HeavyRain266/bevy_mod_fbx/issues/11 53 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # bevy_mod_fbx 2 | 3 | Autodesk Filmbox (*.fbx) loader for Bevy Engine. 4 | 5 | **Special Credit**: Thanks to the original author HeavyRain266 for starting the project. 6 | `bevy_mod_fbx` is now maintained by someone else. 7 | 8 | ### Features 9 | 10 | - Load meshes, textures & material properties 11 | - Supported material properties: 12 | - normal maps 13 | - occlusion maps 14 | - diffuse texture 15 | - Maya PBR material support 16 | - Scene tree transform hierarchy support 17 | 18 | #### Planned features 19 | 20 | - Skeleton rig imports 21 | - `bevy_animation` support 22 | - Optional lambert material shader support 23 | - Optional phong shading model support 24 | - Extended compatibility: 25 | - `IndexToDirect` 26 | - Handle file-based axis properties 27 | - Handle backed cameras & lights 28 | - N-gon triangulation 29 | 30 | ### Limitations 31 | 32 | - FBX v7.4 & 7.5 are the only supported versions 33 | - FBX doesn't support multiple scenes in single file, use multiple files instead 34 | - There are no plans for loading ASCII format, export FBX as binary v7.4/7.5 35 | - There is no support for complex shapes at the moment, see [#11] 36 | 37 | ### Cargo features 38 | 39 | #### `profile` 40 | 41 | Enables spans, in combination with bevy's `bevy/trace` feature, 42 | you can generate profiling reports you can open with any trace reading software. 43 | Useful for debugging why your assets are so slow to load. 44 | 45 | #### `maya_3dsmax_pbr` 46 | 47 | Enable handling of Maya's PBR material extension for FBX (presumebly also 3DS max). 48 | This is highly experimental and only tested with a single model! 49 | Please report if your model's materials do not load properly. 50 | 51 | This material loader do not work with every type of texture files, 52 | the textures must be readable from CPU and have each component (color channel) 53 | be exactly 8 bits (such as PNG). 54 | 55 | ### Examples 56 | 57 | - `cube`: Load simple cube with point light 58 | - `scene_viewer`: Load any FBX files from `/path/to/file.fbx`, defaults to `assets/cube.fbx` 59 | 60 | Run example: 61 | 62 | ```sh 63 | # Regular dev build 64 | cargo run --example 65 | 66 | # Faster asset loading 67 | cargu run --example --release --features bevy/dynamic 68 | ``` 69 | 70 | ### Version matrix 71 | 72 | | bevy | bevy_mod_fbx | 73 | |------|--------------| 74 | | 0.10 | 0.4 | 75 | | 0.9 | 0.3 | 76 | | 0.8 | 0.1.0-dev | 77 | 78 | ## Contributing 79 | 80 | See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed informations. 81 | 82 | ## License 83 | 84 | Original loader and triangulation code (`loader.rs` and `triangulate.rs`) from [fbx_viewer] by YOSHIOKA Takuma. 85 | Original scene viewer code (`scene_viewer.rs`) from [scene_viewer] by Bevy contributors. 86 | All additions and modifications authored by `bevy_mod_fbx` contributors (see git log). 87 | 88 | Code copyrights go to their respective authors. 89 | 90 | All code in `bevy_mod_fbx` is licensed under either: 91 | 92 | - Apache License 2.0 93 | - MIT License 94 | 95 | at your option. 96 | 97 | [#11]: https://github.com/HeavyRain266/bevy_mod_fbx/issues/11 98 | 99 | [fbx_viewer]: https://github.com/lo48576/fbx-viewer/ 100 | [bevy_scene_viewer]: https://github.com/bevyengine/bevy/blob/115211161b783a2f5c39346caeb8ee6b3b202bef/examples/tools/scene_viewer.rs 101 | -------------------------------------------------------------------------------- /dev_docs/custom_material_design.md: -------------------------------------------------------------------------------- 1 | # Custom materials 2 | 3 | FBX is a widespread standard. 4 | Each individual software that works with FBX has their own material definition, 5 | implemented as custom extensions to the basic FBX model. 6 | 7 | It is likely that the library user will want to load a material type that we, 8 | as library developers, did not or couldn't anticipate. 9 | 10 | To still allow them to load their material types, we define an API 11 | for the user to provide their own material loader. 12 | 13 | ## API requirements 14 | 15 | * Provide default loaders for lambert/phong 16 | * Provide loader attempt order, so that the first to "win" is the one loaded. 17 | Loader should be able to say "I can't load that", to let other loaders try 18 | * Ability to load assets like `Image`s 19 | * _Direct access to `Image`_ (not just `Handle`) so that they 20 | can be combined (in the case of Maya's PBR, reflection and metalicness 21 | maps are two different textures, they need to be combined for bevy's PBR) 22 | * This requires ability to register `Handle`s 23 | (maybe? Could we provide an untyped `Handle` registration API?) 24 | * Should be able to separate async operations from pure operations 25 | For example, the loader could give a list of asset paths to load 26 | and a function that takes the deserialized typed assets from those paths 27 | and return a new asset. 28 | (because `async` fundamentally composes poorly with combinators like 29 | `Iterator` or `Option` and `Result`) 30 | * Loader should be able to take a single `MaterialHandle` from `fbxcell_dom` lib 31 | and return a sort of material component. 32 | * (optional) Ability to load other types of assets 33 | * (optional) Ability to return more than just bevy's `StandardMaterial` PBR shader 34 | * (optional) Provide loaders for FBX extensions like Maya's PBR 35 | 36 | ## How to solve this 37 | 38 | Ideally, bevy provides a **composable loader API**. 39 | 40 | However, let's point out there are two types of asset composition: 41 | * Taking multiple assets and combining them into one, 42 | such as with the reflection/metalicness map example from earlier. 43 | * I guess we could just create a new component that creates the new 44 | texture based on the two old ones after loading and replace them 45 | with the combined version? 46 | * Taking handles to existing assets and using them in new assets. 47 | 48 | But we are working with today's bevy, so we have to go with a bespoke solution. 49 | 50 | ### Design 51 | 52 | See https://github.com/HeavyRain266/bevy_mod_fbx/issues/18 53 | 54 | Maybe we should _delegate_ fbx material loading to a different `AssetLoader`? 55 | How would that work? I'd like to be able to give it a `MaterialHandle`, 56 | not a file path or a `Vec`. 57 | 58 | #### Proper handling of `Handle`s 59 | 60 | **Problem**: We want to cache textures with a globally identifying name, 61 | so that it's possible to re-use the same handle instead of loading it 62 | again. 63 | But lose the exact mapping of fbxcel `TextureHandle` to label after running 64 | `preprocess_textures`. 65 | How to reconciliate? 66 | 67 | - If we pre-process, we lose the 1-to-1 mapping between `TextureHandle` and 68 | bevy `Handle`. 69 | - We generally want to "store" the `Image`s as they are output by the 70 | `preprocess_textures` function. 71 | - The caching requires 72 | - **being executed before the image is loaded** 73 | - a `&mut` access to the `scene` in the loader 74 | - a `&mut` access to the `LoadContext` to create the asset 75 | 76 | **Solution**: Split the list of loaded textures in two. 77 | 78 | The resulting code is still very awkward, but it's still better than before. 79 | 80 | This is hopeless anyway (well it depends) because merging two different textures 81 | requires being able to read and edit the texture format, which is far from trivial 82 | in bevy. -------------------------------------------------------------------------------- /src/utils/triangulate.rs: -------------------------------------------------------------------------------- 1 | //! Triangulator. 2 | 3 | // TODO: https://github.com/HeavyRain266/bevy_mod_fbx/issues/11 4 | 5 | use anyhow::{anyhow, bail}; 6 | use bevy::math::{DVec2, DVec3}; 7 | use fbxcel_dom::v7400::data::mesh::{PolygonVertexIndex, PolygonVertices}; 8 | 9 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] 10 | enum Axis { 11 | X, 12 | Y, 13 | Z, 14 | } 15 | 16 | /// Returns smallest direction. 17 | fn smallest_direction(v: &DVec3) -> Axis { 18 | match () { 19 | () if v.x < v.y && v.z < v.x => Axis::Z, 20 | () if v.x < v.y => Axis::X, 21 | () if v.z < v.y => Axis::Z, 22 | () => Axis::Y, 23 | } 24 | } 25 | 26 | /// Triangulate. 27 | pub fn triangulate( 28 | pvs: &PolygonVertices<'_>, 29 | poly_pvis: &[PolygonVertexIndex], 30 | results: &mut Vec<[PolygonVertexIndex; 3]>, 31 | ) -> anyhow::Result<()> { 32 | macro_rules! get_vec { 33 | ($pvii:expr) => { 34 | get_vec(pvs, poly_pvis[$pvii]) 35 | }; 36 | } 37 | 38 | match poly_pvis.len() { 39 | n @ 0..=2 => { 40 | // Not a polygon. 41 | // It is impossible to triangulate a point, line, or "nothing". 42 | bail!("Not enough vertices in the polygon: length={n}"); 43 | } 44 | 3 => { 45 | // Got a triangle, no need of triangulation. 46 | results.push([poly_pvis[0], poly_pvis[1], poly_pvis[2]]); 47 | 48 | Ok(()) 49 | } 50 | 4 => { 51 | // p0, p1, p2, p3: vertices of the quadrangle (angle{0..3}). 52 | let p0 = get_vec!(0)?; 53 | let p1 = get_vec!(1)?; 54 | let p2 = get_vec!(2)?; 55 | let p3 = get_vec!(3)?; 56 | 57 | // n1: Normal vector calculated with two edges of the angle1. 58 | // n3: Normal vector calculated with two edges of the angle3. 59 | let n1 = (p0 - p1).cross(p1 - p2); 60 | let n3 = (p2 - p3).cross(p3 - p0); 61 | 62 | // If both angle1 and angle3 are concave, vectors n1 and n3 are 63 | // oriented in the same direction and `n1.dot(n3)` will be positive. 64 | // If either angle1 or angle3 is concave, vector n1 and n3 are 65 | // oriented in the opposite directions and `n1.dot(n3)` will be 66 | // negative. 67 | // It does not matter when the vertices of quadrangle is not on the 68 | // same plane, because whichever diagonal you choose, the cut will 69 | // be inaccurate. 70 | if n1.dot(n3) >= 0.0 { 71 | // Both angle1 and angle3 are concave. 72 | // This means that either angle0 or angle2 can be convex. 73 | // Cut from p0 to p2. 74 | results.extend_from_slice(&[ 75 | [poly_pvis[0], poly_pvis[1], poly_pvis[2]], 76 | [poly_pvis[2], poly_pvis[3], poly_pvis[0]], 77 | ]); 78 | } else { 79 | // Either angle1 or angle3 is convex. 80 | // Cut from p1 to p3. 81 | results.extend_from_slice(&[ 82 | [poly_pvis[0], poly_pvis[1], poly_pvis[3]], 83 | [poly_pvis[3], poly_pvis[1], poly_pvis[2]], 84 | ]); 85 | } 86 | Ok(()) 87 | } 88 | n => { 89 | let points = (0..n).map(|i| get_vec!(i)).collect::, _>>()?; 90 | let points_2d: Vec<_> = { 91 | // Reduce dimensions for faster computation. 92 | // This helps treat points which are not on a single plane. 93 | let (min, max) = 94 | bounding_box(&points).expect("Should never happen: there are 5 or more points"); 95 | 96 | let width = max - min; 97 | 98 | match smallest_direction(&width) { 99 | Axis::X => points.into_iter().map(|v| DVec2::new(v[1], v[2])).collect(), 100 | Axis::Y => points.into_iter().map(|v| DVec2::new(v[0], v[2])).collect(), 101 | Axis::Z => points.into_iter().map(|v| DVec2::new(v[0], v[1])).collect(), 102 | } 103 | }; 104 | // Normal directions. 105 | let normal_directions = { 106 | // 0 ... n-1 107 | let iter_cur = points_2d.iter(); 108 | 109 | // n-1, 0, ... n-2 110 | let iter_prev = points_2d.iter().cycle().skip(n - 1); 111 | 112 | // 1, ... n-1, 0 113 | let iter_next = points_2d.iter().cycle().skip(1); 114 | 115 | iter_cur 116 | .zip(iter_prev) 117 | .zip(iter_next) 118 | .map(|((cur, prev), next)| { 119 | let prev_cur = *prev - *cur; 120 | let cur_next = *cur - *next; 121 | prev_cur.perp_dot(cur_next) > 0.0 122 | }) 123 | .collect::>() 124 | }; 125 | assert_eq!(normal_directions.len(), n); 126 | 127 | let dirs_true_count = normal_directions.iter().filter(|&&v| v).count(); 128 | 129 | if dirs_true_count <= 1 || dirs_true_count >= n - 1 { 130 | // Zero or one angles are concave. 131 | let minor_sign = dirs_true_count <= 1; 132 | 133 | // If there are no concave angles, use 0 as center. 134 | let convex_index = normal_directions 135 | .iter() 136 | .position(|&sign| sign == minor_sign) 137 | .unwrap_or(0); 138 | 139 | let convex_pvi = poly_pvis[convex_index]; 140 | 141 | let iter1 = (0..n) 142 | .cycle() 143 | .skip(convex_index + 1) 144 | .take(n - 2) 145 | .map(|i| poly_pvis[i]); 146 | 147 | let iter2 = (0..n).cycle().skip(convex_index + 2).map(|i| poly_pvis[i]); 148 | 149 | for (pvi1, pvi2) in iter1.zip(iter2) { 150 | results.push([convex_pvi, pvi1, pvi2]); 151 | } 152 | 153 | Ok(()) 154 | } else { 155 | bail!("Unsupported polygon: {n}-gon with two or more concave angles"); 156 | } 157 | } 158 | } 159 | } 160 | 161 | /// Returns the vector. 162 | fn get_vec(pvs: &PolygonVertices<'_>, pvi: PolygonVertexIndex) -> anyhow::Result { 163 | pvs.control_point(pvi) 164 | .map(Into::into) 165 | .ok_or_else(|| anyhow!("Index out of range: {pvi:?}")) 166 | } 167 | 168 | /// Returns bounding box as `(min, max)`. 169 | fn bounding_box<'a>(points: impl IntoIterator) -> Option<(DVec3, DVec3)> { 170 | points.into_iter().fold(None, |minmax, point| { 171 | minmax.map_or_else( 172 | || Some((*point, *point)), 173 | |(min, max)| { 174 | Some(( 175 | DVec3::new(min.x.min(point.x), min.y.min(point.y), min.z.min(point.z)), 176 | DVec3::new(max.x.max(point.x), max.y.max(point.y), max.z.max(point.z)), 177 | )) 178 | }, 179 | ) 180 | }) 181 | } 182 | -------------------------------------------------------------------------------- /examples/scene_viewer.rs: -------------------------------------------------------------------------------- 1 | // This file is heavily inspired by the Bevy scene_viewer.rs 2 | // found in the repository's tools folder. 3 | //! A simple FBX scene viewer made with Bevy. 4 | //! 5 | //! Just run `cargo run --release --example scene_viewer /path/to/model.fbx#Scene`, 6 | //! (note: the #Scene is added if not already present) 7 | //! replacing the path as appropriate. 8 | //! With no arguments it will load the default cube. 9 | 10 | use bevy::{ 11 | input::mouse::MouseMotion, 12 | log::{Level, LogPlugin}, 13 | prelude::*, 14 | window::close_on_esc, 15 | }; 16 | use bevy_mod_fbx::FbxPlugin; 17 | 18 | use std::f32::consts::TAU; 19 | 20 | fn main() { 21 | println!( 22 | " 23 | Controls: 24 | MOUSE - Move camera orientation 25 | LClick/M - Enable mouse movement 26 | WSAD - forward/back/strafe left/right 27 | LShift - 'run' 28 | E - up 29 | Q - down 30 | L - animate light direction 31 | U - toggle shadows 32 | C - cycle through cameras 33 | 34 | " 35 | ); 36 | let mut app = App::new(); 37 | app.insert_resource(AmbientLight { 38 | color: Color::WHITE, 39 | brightness: 1.0 / 5.0f32, 40 | }) 41 | .add_plugins( 42 | DefaultPlugins 43 | .set(AssetPlugin { 44 | asset_folder: std::env::var("CARGO_MANIFEST_DIR") 45 | .unwrap_or_else(|_| ".".to_string()), 46 | watch_for_changes: true, 47 | }) 48 | .set(LogPlugin { 49 | level: Level::WARN, 50 | filter: "bevy_mod_fbx=info".to_owned(), 51 | }) 52 | .set(WindowPlugin { 53 | primary_window: Some(Window { 54 | title: "bevy scene viewer".to_string(), 55 | ..default() 56 | }), 57 | ..default() 58 | }), 59 | ) 60 | .add_plugin(FbxPlugin) 61 | .add_startup_system(setup) 62 | .add_system(update_lights) 63 | .add_system(camera_controller) 64 | .add_system(close_on_esc); 65 | 66 | app.run(); 67 | } 68 | 69 | fn setup(mut commands: Commands, asset_server: Res) { 70 | let mut scene_path = std::env::args() 71 | .nth(1) 72 | .unwrap_or_else(|| "assets/cube.fbx".to_owned()); 73 | if !scene_path.ends_with("#Scene") { 74 | scene_path += "#Scene"; 75 | } 76 | info!("Loading {}", scene_path); 77 | commands.spawn(( 78 | Camera3dBundle { 79 | transform: Transform::from_xyz(10.0, 4.4, 3.0).looking_at(Vec3::ZERO, Vec3::Y), 80 | ..default() 81 | }, 82 | CameraController::default(), 83 | )); 84 | 85 | info!("Spawning a directional light"); 86 | commands.spawn(DirectionalLightBundle { 87 | directional_light: DirectionalLight { 88 | illuminance: 20000.0, 89 | shadows_enabled: false, 90 | ..default() 91 | }, 92 | ..default() 93 | }); 94 | commands.spawn(( 95 | SceneBundle { 96 | scene: asset_server.load(&scene_path), 97 | ..default() 98 | }, 99 | Name::new(scene_path), 100 | )); 101 | } 102 | 103 | const SCALE_STEP: f32 = 0.1; 104 | 105 | fn update_lights( 106 | key_input: Res>, 107 | time: Res, 108 | mut query: Query<(&mut Transform, &mut DirectionalLight)>, 109 | mut animate_directional_light: Local, 110 | ) { 111 | let mut projection_adjustment = Vec3::ONE; 112 | if key_input.just_pressed(KeyCode::Key5) { 113 | projection_adjustment.x -= SCALE_STEP; 114 | } else if key_input.just_pressed(KeyCode::Key6) { 115 | projection_adjustment.x += SCALE_STEP; 116 | } else if key_input.just_pressed(KeyCode::Key7) { 117 | projection_adjustment.y -= SCALE_STEP; 118 | } else if key_input.just_pressed(KeyCode::Key8) { 119 | projection_adjustment.y += SCALE_STEP; 120 | } else if key_input.just_pressed(KeyCode::Key9) { 121 | projection_adjustment.z -= SCALE_STEP; 122 | } else if key_input.just_pressed(KeyCode::Key0) { 123 | projection_adjustment.z += SCALE_STEP; 124 | } 125 | for (_, mut light) in query.iter_mut() { 126 | if key_input.just_pressed(KeyCode::U) { 127 | light.shadows_enabled = !light.shadows_enabled; 128 | } 129 | } 130 | 131 | if key_input.just_pressed(KeyCode::L) { 132 | *animate_directional_light = !*animate_directional_light; 133 | } 134 | if *animate_directional_light { 135 | for (mut transform, _) in query.iter_mut() { 136 | transform.rotation = Quat::from_euler( 137 | EulerRot::ZYX, 138 | 0.0, 139 | time.elapsed_seconds() * TAU / 30.0, 140 | -TAU / 8., 141 | ); 142 | } 143 | } 144 | } 145 | 146 | #[derive(Component)] 147 | struct CameraController { 148 | pub enabled: bool, 149 | pub initialized: bool, 150 | pub sensitivity: f32, 151 | pub key_forward: KeyCode, 152 | pub key_back: KeyCode, 153 | pub key_left: KeyCode, 154 | pub key_right: KeyCode, 155 | pub key_up: KeyCode, 156 | pub key_down: KeyCode, 157 | pub key_run: KeyCode, 158 | pub mouse_key_enable_mouse: MouseButton, 159 | pub keyboard_key_enable_mouse: KeyCode, 160 | pub walk_speed: f32, 161 | pub run_speed: f32, 162 | pub friction: f32, 163 | pub pitch: f32, 164 | pub yaw: f32, 165 | pub velocity: Vec3, 166 | } 167 | 168 | impl Default for CameraController { 169 | fn default() -> Self { 170 | Self { 171 | enabled: true, 172 | initialized: false, 173 | sensitivity: 0.5, 174 | key_forward: KeyCode::W, 175 | key_back: KeyCode::S, 176 | key_left: KeyCode::A, 177 | key_right: KeyCode::D, 178 | key_up: KeyCode::E, 179 | key_down: KeyCode::Q, 180 | key_run: KeyCode::LShift, 181 | mouse_key_enable_mouse: MouseButton::Left, 182 | keyboard_key_enable_mouse: KeyCode::M, 183 | walk_speed: 5.0, 184 | run_speed: 15.0, 185 | friction: 0.5, 186 | pitch: 0.0, 187 | yaw: 0.0, 188 | velocity: Vec3::ZERO, 189 | } 190 | } 191 | } 192 | 193 | fn camera_controller( 194 | time: Res, 195 | mut mouse_events: EventReader, 196 | mouse_button_input: Res>, 197 | key_input: Res>, 198 | mut move_toggled: Local, 199 | mut query: Query<(&mut Transform, &mut CameraController), With>, 200 | ) { 201 | let dt = time.delta_seconds(); 202 | 203 | if let Ok((mut transform, mut options)) = query.get_single_mut() { 204 | if !options.initialized { 205 | let (yaw, pitch, _roll) = transform.rotation.to_euler(EulerRot::YXZ); 206 | options.yaw = yaw; 207 | options.pitch = pitch; 208 | options.initialized = true; 209 | } 210 | if !options.enabled { 211 | return; 212 | } 213 | 214 | // Handle key input 215 | let mut axis_input = Vec3::ZERO; 216 | if key_input.pressed(options.key_forward) { 217 | axis_input.z += 1.0; 218 | } 219 | if key_input.pressed(options.key_back) { 220 | axis_input.z -= 1.0; 221 | } 222 | if key_input.pressed(options.key_right) { 223 | axis_input.x += 1.0; 224 | } 225 | if key_input.pressed(options.key_left) { 226 | axis_input.x -= 1.0; 227 | } 228 | if key_input.pressed(options.key_up) { 229 | axis_input.y += 1.0; 230 | } 231 | if key_input.pressed(options.key_down) { 232 | axis_input.y -= 1.0; 233 | } 234 | if key_input.just_pressed(options.keyboard_key_enable_mouse) { 235 | *move_toggled = !*move_toggled; 236 | } 237 | 238 | // Apply movement update 239 | if axis_input != Vec3::ZERO { 240 | let max_speed = if key_input.pressed(options.key_run) { 241 | options.run_speed 242 | } else { 243 | options.walk_speed 244 | }; 245 | options.velocity = axis_input.normalize() * max_speed; 246 | } else { 247 | let friction = options.friction.clamp(0.0, 1.0); 248 | options.velocity *= 1.0 - friction; 249 | if options.velocity.length_squared() < 1e-6 { 250 | options.velocity = Vec3::ZERO; 251 | } 252 | } 253 | let forward = transform.forward(); 254 | let right = transform.right(); 255 | transform.translation += options.velocity.x * dt * right 256 | + options.velocity.y * dt * Vec3::Y 257 | + options.velocity.z * dt * forward; 258 | 259 | // Handle mouse input 260 | let mut mouse_delta = Vec2::ZERO; 261 | if mouse_button_input.pressed(options.mouse_key_enable_mouse) || *move_toggled { 262 | for mouse_event in mouse_events.iter() { 263 | mouse_delta += mouse_event.delta; 264 | } 265 | } 266 | 267 | if mouse_delta != Vec2::ZERO { 268 | // Apply look update 269 | let (pitch, yaw) = ( 270 | (options.pitch - mouse_delta.y * 0.5 * options.sensitivity * dt).clamp( 271 | -0.99 * std::f32::consts::FRAC_PI_2, 272 | 0.99 * std::f32::consts::FRAC_PI_2, 273 | ), 274 | options.yaw - mouse_delta.x * options.sensitivity * dt, 275 | ); 276 | transform.rotation = Quat::from_euler(EulerRot::ZYX, 0.0, yaw, pitch); 277 | options.pitch = pitch; 278 | options.yaw = yaw; 279 | } 280 | } 281 | } 282 | -------------------------------------------------------------------------------- /src/fbx_transform.rs: -------------------------------------------------------------------------------- 1 | //! Handles FBX transform propagation, and translation 2 | //! into bevy Transform and GlobalTransform. 3 | 4 | // a bit of trivia on how transform is encoded in FBX: 5 | // rotation: EulerXYZ in degrees, three steps: PreRotation, Lcl Rotation, PostRotation 6 | // https://forums.autodesk.com/t5/fbx-forum/maya-quot-rotate-axis-quot-vs-fbx-quot-postrotation-quot/td-p/4168814 7 | // https://help.autodesk.com/cloudhelp/2017/ENU/FBX-Developer-Help/files/GUID-C35D98CB-5148-4B46-82D1-51077D8970EE.htm 8 | // http://docs.autodesk.com/FBX/2014/ENU/FBX-SDK-Documentation/cpp_ref/class_fbx_node.html 9 | // https://help.autodesk.com/cloudhelp/2016/ENU/FBX-Developer-Help/cpp_ref/_view_scene_2_draw_scene_8cxx-example.html#a78 10 | // (see "Pivot Management" section for last link) 11 | // 12 | // The following code is somewhat taken from: 13 | // https://stackoverflow.com/questions/34452946/how-can-i-get-the-correct-position-of-fbx-mesh 14 | // which itself is taken from: 15 | // https://help.autodesk.com/cloudhelp/2016/ENU/FBX-Developer-Help/cpp_ref/_transformations_2main_8cxx-example.html#a30 16 | // 17 | // FbxNode also has {Rotation,Scaling,Translation}Active propreties, 18 | // what is their meaning? 19 | // - https://forums.autodesk.com/t5/fbx-forum/rotationactive/td-p/4267206 20 | // - https://help.autodesk.com/cloudhelp/2016/ENU/FBX-Developer-Help/cpp_ref/class_fbx_node.html 21 | use std::f32::consts::TAU; 22 | 23 | use anyhow::Result; 24 | use bevy::math::{DVec3, EulerRot}; 25 | use bevy::prelude::{Mat4, Transform, Vec3}; 26 | use fbxcel_dom::v7400::object::{model::ModelHandle, property::ObjectProperties, ObjectHandle}; 27 | 28 | use crate::utils::fbx_extend::{InheritType, Loadable}; 29 | 30 | #[derive(Copy, Clone, Debug)] 31 | struct Translation(Vec3); 32 | impl Translation { 33 | fn mat(&self) -> Mat4 { 34 | Mat4::from_translation(self.0) 35 | } 36 | fn from_double(p: DVec3) -> Translation { 37 | Self(p.as_vec3()) 38 | } 39 | } 40 | 41 | // FBX encodes rotations in Eulers (customizable order) in degrees, 42 | // and for some reasons, it needs to be negated and then inverted. 43 | #[derive(Copy, Clone, Debug)] 44 | struct Rotation(Vec3, EulerRot); 45 | impl Rotation { 46 | fn from_euler(euler: EulerRot, angles: DVec3) -> Self { 47 | Rotation(angles.as_vec3() * -(TAU / 360.0), euler) 48 | } 49 | fn mat(&self) -> Mat4 { 50 | let Vec3 { x, y, z } = self.0; 51 | Mat4::from_euler(self.1, x, y, z).inverse() 52 | } 53 | } 54 | 55 | #[derive(Copy, Clone, Debug)] 56 | struct Scale(Vec3); 57 | impl Scale { 58 | fn mat(&self) -> Mat4 { 59 | Mat4::from_scale(self.0) 60 | } 61 | fn from_double(p: DVec3) -> Scale { 62 | Self(p.as_vec3()) 63 | } 64 | const IDENTITY: Self = Self(Vec3::ONE); 65 | } 66 | 67 | #[derive(Clone, Debug)] 68 | struct NodeScale { 69 | pivot: Translation, 70 | offset: Translation, 71 | local: Scale, 72 | } 73 | #[derive(Clone, Debug)] 74 | struct NodeRotation { 75 | pivot: Translation, 76 | offset: Translation, 77 | local: Rotation, 78 | pre: Rotation, 79 | post: Rotation, 80 | } 81 | /// Handle the awkward translation from FBX to Bevy transform. 82 | /// 83 | /// The transform propagation in FBX is _way too flexible_, 84 | /// and doesn't translate well to bevy's simple global/matrix+local/TRS. 85 | /// So it's necessary to compute the actual global position 86 | /// based on the FBX formula and do a second pass 87 | /// where we set the local transform infered 88 | /// from the computed FBX global position. 89 | #[derive(Clone, Debug)] 90 | struct FbxNodeTransformInfo { 91 | rotation: NodeRotation, 92 | translation: Translation, 93 | scale: NodeScale, 94 | inherit_type: InheritType, 95 | } 96 | impl FbxNodeTransformInfo { 97 | // if you were wondering: "Lcl" stands for "Local" 98 | // FIXME: Non-zero {Rotation,Scaling}{Pivot,Offset} is untested. 99 | // TODO: Geometric{Translation,Scaling,Rotation} 100 | // (see docs.autodesk.com and stackoverflow.com links at top of this file) 101 | fn from_object(object: ObjectHandle) -> Result { 102 | fn load(p: ObjectProperties, attribute: &str) -> Result { 103 | T::get_property(p, attribute) 104 | } 105 | let p = object.properties_by_native_typename("FbxNode"); 106 | let e = load(p, "RotationOrder")?; 107 | Ok(FbxNodeTransformInfo { 108 | rotation: NodeRotation { 109 | pivot: Translation::from_double(load(p, "RotationPivot")?), 110 | offset: Translation::from_double(load(p, "RotationOffset")?), 111 | local: Rotation::from_euler(e, load(p, "Lcl Rotation")?), 112 | pre: Rotation::from_euler(e, load(p, "PreRotation")?), 113 | post: Rotation::from_euler(e, load(p, "PostRotation")?), 114 | }, 115 | translation: Translation::from_double(load(p, "Lcl Translation")?), 116 | scale: NodeScale { 117 | pivot: Translation::from_double(load(p, "ScalingPivot")?), 118 | offset: Translation::from_double(load(p, "ScalingOffset")?), 119 | local: Scale::from_double(load(p, "Lcl Scaling")?), 120 | }, 121 | inherit_type: load(p, "InheritType")?, 122 | }) 123 | } 124 | } 125 | 126 | #[derive(Copy, Clone, Debug)] 127 | pub(crate) struct LocalScale(Scale); 128 | 129 | // This is similar to mat.to_scale_rotation_translation() 130 | // but takes into account shear operations (meaning: rotation followed by non-uniform scale) 131 | // The implementation is the one used in the Autodesk scene translation example file. 132 | fn get_reverse_transform(mat: Mat4) -> (Mat4, Mat4, Mat4) { 133 | let mat_q = Mat4::from_quat; 134 | let mat_t = Mat4::from_translation; 135 | let (_, rotation, translation) = mat.to_scale_rotation_translation(); 136 | let rotation = mat_q(rotation); 137 | let translation = mat_t(translation); 138 | let shear_scale = mat * rotation.inverse() * translation.inverse(); 139 | (shear_scale, rotation, translation) 140 | } 141 | 142 | // NOTE: there were no thought about performance put into this, 143 | // the goal of this method is to get something working ASAP, 144 | // performance can wait. 145 | // I particularly dislike the amount of matrix inversion and multiplication this incures. 146 | fn global_transform(node: FbxNodeTransformInfo, parent: Option) -> Mat4 { 147 | let mat_t = Mat4::from_translation; 148 | let rot = node.rotation; 149 | let scale = node.scale; 150 | let rotation = rot.pre.mat() * rot.local.mat() * rot.post.mat(); 151 | 152 | let FbxTransform { 153 | global: parent_transform, 154 | local_scale: local_parent_scale, 155 | } = parent.unwrap_or_default(); 156 | 157 | let (parent_shear_scale, parent_rotation, parent_translation) = 158 | get_reverse_transform(parent_transform); 159 | let parent_nonlocal_scale = parent_shear_scale * local_parent_scale.mat().inverse(); 160 | 161 | let inherited_rot_scale = match node.inherit_type { 162 | InheritType::RrSs => parent_rotation * rotation * parent_shear_scale * scale.local.mat(), 163 | InheritType::RSrs => parent_rotation * parent_shear_scale * rotation * scale.local.mat(), 164 | InheritType::Rrs => parent_rotation * rotation * parent_nonlocal_scale * scale.local.mat(), 165 | }; 166 | let with_off_piv = |offset: Translation, pivot: Translation, transform| { 167 | offset.mat() * pivot.mat() * transform * pivot.mat().inverse() 168 | }; 169 | let translation = node.translation.mat() 170 | * with_off_piv(rot.offset, rot.pivot, rotation) 171 | * with_off_piv(scale.offset, scale.pivot, scale.local.mat()); 172 | let translation = translation.to_scale_rotation_translation().2; 173 | // NOTE: this is unlike the Autodesk resource provided on top, it seems 174 | // we need to remove the scale component from the parent's global matrix 175 | // we multiply the translation with. Absolutely no idea why, but it works. 176 | let parent_non_scale_transform = parent_translation * parent_rotation; 177 | let global_translation = parent_non_scale_transform.transform_vector3(translation); 178 | mat_t(global_translation) * inherited_rot_scale 179 | } 180 | 181 | /// Fbx global transform, including parent local scale to compute 182 | /// the children's transform. 183 | #[derive(Debug, Clone, Copy)] 184 | pub(crate) struct FbxTransform { 185 | local_scale: Scale, 186 | pub(crate) global: Mat4, 187 | } 188 | impl Default for FbxTransform { 189 | fn default() -> Self { 190 | FbxTransform { 191 | local_scale: Scale::IDENTITY, 192 | global: Mat4::IDENTITY, 193 | } 194 | } 195 | } 196 | impl FbxTransform { 197 | pub(crate) fn from_node(node: ModelHandle, parent: Option) -> Self { 198 | let transform = FbxNodeTransformInfo::from_object(*node).unwrap(); 199 | FbxTransform::from_fbxtrans(transform, parent) 200 | } 201 | fn from_fbxtrans(trans: FbxNodeTransformInfo, parent: Option) -> Self { 202 | FbxTransform { 203 | local_scale: trans.scale.local, 204 | global: global_transform(trans, parent), 205 | } 206 | } 207 | // Problem: `Self` is the _global_ position of fbx node, not local. 208 | // An FBX local transform can't be translated directly into a bevy Transform, 209 | // so we need to compute the global transform and work backward from there. 210 | // 1. we have parent(FbxGlobalTransform) 211 | // 2. we just computed child(FbxGlobalTransform) 212 | // 3. GlobalTransform = FbxGlobalTransform 213 | // 4. We need to find the child(Transform): 214 | // - from bevy's transform mat: child(GlobalTransform) = parent(GlobalTransform) * child(Transform) 215 | // - We have: child(GlobalTransform) and parent(GlobalTransform) 216 | // - child(Transform) = child(GlobalTransform) * parent(GlobalTransform)¯¹ 217 | pub(crate) fn as_local_transform(&self, parent: Option) -> Transform { 218 | let mat = if let Some(parent) = parent { 219 | self.global * parent.inverse() 220 | } else { 221 | self.global 222 | }; 223 | Transform::from_matrix(mat) 224 | } 225 | } 226 | -------------------------------------------------------------------------------- /src/utils/fbx_extend.rs: -------------------------------------------------------------------------------- 1 | //! Collection of temporary extensions to the fbxcell_dom types 2 | //! until they are merged upstream. 3 | 4 | use bevy::math::{DVec2, DVec3, DVec4, EulerRot, Vec2, Vec3, Vec4}; 5 | use mint::{Vector2, Vector3, Vector4}; 6 | 7 | use fbxcel_dom::{ 8 | fbxcel::low::v7400::AttributeValue, 9 | v7400::{ 10 | object::{ 11 | material::MaterialHandle, 12 | model::ModelHandle, 13 | property::{ 14 | loaders::{MintLoader, PrimitiveLoader, RgbLoader}, 15 | LoadProperty, ObjectProperties, PropertyHandle, 16 | }, 17 | texture::TextureHandle, 18 | ObjectHandle, TypedObjectHandle, 19 | }, 20 | Document, GlobalSettings, 21 | }, 22 | }; 23 | use rgb::{RGB, RGBA}; 24 | 25 | pub trait MaterialHandleExt<'a> { 26 | fn load_texture(&self, name: &'static str) -> Option; 27 | } 28 | impl<'a> MaterialHandleExt<'a> for MaterialHandle<'a> { 29 | fn load_texture(&self, name: &'static str) -> Option { 30 | self.source_objects() 31 | .filter(|obj| obj.label() == Some(name)) 32 | .filter_map(|obj| obj.object_handle()) 33 | .find_map(|obj| match obj.get_typed() { 34 | TypedObjectHandle::Texture(o) => Some(o), 35 | _ => None, 36 | }) 37 | } 38 | } 39 | 40 | pub trait MaterialHandleQuickPropsExt<'a> { 41 | fn get_f32(&self, field: &str) -> Option; 42 | fn get_u32(&self, field: &str) -> Option; 43 | fn get_i32(&self, field: &str) -> Option; 44 | fn get_bool(&self, field: &str) -> Option; 45 | } 46 | impl<'a> MaterialHandleQuickPropsExt<'a> for MaterialHandle<'a> { 47 | fn get_f32(&self, field: &str) -> Option { 48 | let props = self.properties(); 49 | let prop = props.get_property(field)?; 50 | prop.load_value(PrimitiveLoader::::new()).ok() 51 | } 52 | fn get_u32(&self, field: &str) -> Option { 53 | let props = self.properties(); 54 | let prop = props.get_property(field)?; 55 | prop.load_value(PrimitiveLoader::::new()).ok() 56 | } 57 | fn get_i32(&self, field: &str) -> Option { 58 | let props = self.properties(); 59 | let prop = props.get_property(field)?; 60 | prop.load_value(PrimitiveLoader::::new()).ok() 61 | } 62 | fn get_bool(&self, field: &str) -> Option { 63 | let props = self.properties(); 64 | let prop = props.get_property(field)?; 65 | prop.load_value(PrimitiveLoader::::new()).ok() 66 | } 67 | } 68 | 69 | pub trait GlobalSettingsExt<'a> { 70 | fn fbx_scale(&self) -> Option; 71 | } 72 | impl<'a> GlobalSettingsExt<'a> for GlobalSettings<'a> { 73 | fn fbx_scale(&self) -> Option { 74 | let prop = self.raw_properties().get_property("UnitScaleFactor")?; 75 | let attribute = prop.value_part().get(0)?; 76 | match attribute { 77 | AttributeValue::F64(scale) => Some(*scale), 78 | _ => None, 79 | } 80 | } 81 | } 82 | 83 | pub trait Loadable: Sized { 84 | fn get_property(properties: ObjectProperties, attribute: &str) -> anyhow::Result; 85 | } 86 | struct EnumLoader { 87 | enum_name: &'static str, 88 | try_into: fn(i32) -> anyhow::Result, 89 | } 90 | impl EnumLoader { 91 | fn new(enum_name: &'static str) -> Self 92 | where 93 | T: TryFrom, 94 | { 95 | Self { 96 | enum_name, 97 | try_into: T::try_from, 98 | } 99 | } 100 | } 101 | impl<'a, T> LoadProperty<'a> for EnumLoader { 102 | type Error = anyhow::Error; 103 | type Value = T; 104 | fn expecting(&self) -> String { 105 | self.enum_name.to_string() 106 | } 107 | fn load(self, node: &PropertyHandle<'a>) -> Result { 108 | use anyhow::anyhow; 109 | let attributes = node.value_part(); 110 | match attributes { 111 | [attribute, ..] => match attribute { 112 | AttributeValue::I32(value) => (self.try_into)(*value), 113 | attribute => Err(anyhow!( 114 | "Was expecting a I32 attribute value when decoding {}, got {attribute:?}", 115 | self.enum_name, 116 | )), 117 | }, 118 | _ => Err(anyhow!( 119 | "There were no elements in the FBX attributes when decoding {}", 120 | self.enum_name, 121 | )), 122 | } 123 | } 124 | } 125 | 126 | // Part of the "FbxNode" native_typename 127 | /// The `InheritType` property, equivalent to `EInheritType` in the FBX SDK. 128 | /// 129 | /// This controls the order in which parent to child transformation is applied. 130 | /// Note that "child" here is the node with the `InheritType` attribute. 131 | /// 132 | /// - See also: http://docs.autodesk.com/FBX/2014/ENU/FBX-SDK-Documentation/cpp_ref/class_fbx_transform.html#a0affdd70d8df512d82fdb6a30112bf0c 133 | #[derive(Copy, Clone, Default, Debug)] 134 | pub enum InheritType { 135 | /// Parent Rotation → child rotation → Parent Scale → child scale (default) 136 | #[default] 137 | RrSs, 138 | /// Parent Rotation → Parent Scale → child rotation → child scale 139 | RSrs, 140 | /// Parent Rotation → child rotation → child scale 141 | Rrs, 142 | } 143 | impl TryFrom for InheritType { 144 | type Error = anyhow::Error; 145 | fn try_from(value: i32) -> Result { 146 | use InheritType::*; 147 | match value { 148 | 0 => Ok(RrSs), 149 | 1 => Ok(RSrs), 150 | 2 => Ok(Rrs), 151 | i => Err(anyhow::anyhow!("{i} not in range of InheritType enum")), 152 | } 153 | } 154 | } 155 | // Part of the "FbxNode" native_typename 156 | /// The order of rotation of the `Rotation` attributes. 157 | /// 158 | /// Rotation in FBX is defined as a Vec3 of **degrees** 159 | /// (not radians) of Tait-Bryan angles (commonly called Euler angles). 160 | /// 161 | /// Note that for reasons unbeknownst, to translate this into the bevy equivalent, 162 | /// the euler angles must be negated and the resulting matrix inverted. 163 | #[allow(clippy::upper_case_acronyms)] 164 | #[derive(Copy, Clone, Default, Debug)] 165 | pub enum RotationOrder { 166 | #[default] 167 | XYZ, 168 | XZY, 169 | YZX, 170 | YXZ, 171 | ZXY, 172 | ZYX, 173 | // Not sure what that means. 174 | SphericXYZ, 175 | } 176 | impl From for EulerRot { 177 | fn from(ord: RotationOrder) -> Self { 178 | use EulerRot as Er; 179 | use RotationOrder as Ro; 180 | match ord { 181 | Ro::XYZ => Er::XYZ, 182 | Ro::XZY => Er::XZY, 183 | Ro::YZX => Er::YZX, 184 | Ro::YXZ => Er::YXZ, 185 | Ro::ZXY => Er::ZXY, 186 | Ro::ZYX => Er::ZYX, 187 | Ro::SphericXYZ => Er::XYZ, 188 | } 189 | } 190 | } 191 | impl TryFrom for RotationOrder { 192 | type Error = anyhow::Error; 193 | fn try_from(value: i32) -> Result { 194 | use RotationOrder::*; 195 | match value { 196 | 0 => Ok(XYZ), 197 | 1 => Ok(XZY), 198 | 2 => Ok(YZX), 199 | 3 => Ok(YXZ), 200 | 4 => Ok(ZXY), 201 | 5 => Ok(ZYX), 202 | 6 => Ok(SphericXYZ), 203 | i => Err(anyhow::anyhow!("{i} not in range of RotationOrder enum")), 204 | } 205 | } 206 | } 207 | 208 | macro_rules! impl_loadable { 209 | ( $( $loader:expr => $target:ty ),* $(,)? ) => { 210 | $( 211 | impl_loadable!(@single $target, $loader ); 212 | )* 213 | }; 214 | (@single $target:ty, $loader:expr) => { 215 | impl Loadable for $target { 216 | fn get_property(properties: ObjectProperties, attribute: &str) -> anyhow::Result { 217 | let loader = $loader; 218 | let property= properties.get_property(attribute).ok_or_else(|| 219 | anyhow::anyhow!("no {attribute} in properties when decoding {}", stringify!($target)) 220 | )?; 221 | Ok(loader.load(&property)?.into()) 222 | } 223 | } 224 | }; 225 | } 226 | impl_loadable!( 227 | RgbLoader::>::default() => RGB, 228 | RgbLoader::>::default() => RGB, 229 | RgbLoader::>::default() => RGBA, 230 | RgbLoader::>::default() => RGBA, 231 | PrimitiveLoader::::default() => bool, 232 | PrimitiveLoader::::default() => f32, 233 | PrimitiveLoader::::default() => f64, 234 | PrimitiveLoader::::default() => i16, 235 | PrimitiveLoader::::default() => i32, 236 | PrimitiveLoader::::default() => i64, 237 | PrimitiveLoader::::default() => u16, 238 | PrimitiveLoader::::default() => u32, 239 | PrimitiveLoader::::default() => u64, 240 | MintLoader::>::default() => Vec2, 241 | MintLoader::>::default() => DVec2, 242 | MintLoader::>::default() => Vec3, 243 | MintLoader::>::default() => DVec3, 244 | MintLoader::>::default() => Vec4, 245 | MintLoader::>::default() => DVec4, 246 | EnumLoader::::new("InheritType") => InheritType, 247 | EnumLoader::::new("RotationOrder") => EulerRot, 248 | ); 249 | 250 | // TODO: additional useful fields in the Model node: 251 | // - "Primary Visibility" 252 | // - "Casts Shadows" 253 | // - "Receive Shadows" 254 | // - "Culling" 255 | fn is_object_root(object: &ObjectHandle) -> bool { 256 | object 257 | .destination_objects() 258 | .any(|obj| obj.label().is_none() && obj.object_id().raw() == 0) 259 | } 260 | 261 | pub trait ModelTreeRootExt { 262 | fn model_roots(&self) -> Vec>; 263 | } 264 | impl ModelTreeRootExt for Document { 265 | fn model_roots(&self) -> Vec> { 266 | self.objects() 267 | .filter(is_object_root) 268 | .filter_map(|obj| match obj.get_typed() { 269 | TypedObjectHandle::Model(o) => Some(*o), 270 | _ => None, 271 | }) 272 | .collect() 273 | } 274 | } 275 | -------------------------------------------------------------------------------- /LICENSE-APACHE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | -------------------------------------------------------------------------------- /src/material_loader.rs: -------------------------------------------------------------------------------- 1 | #[cfg(feature = "maya_3dsmax_pbr")] 2 | use crate::utils::fbx_extend::*; 3 | 4 | use bevy::{ 5 | pbr::{AlphaMode, StandardMaterial}, 6 | prelude::{Color, Handle, Image}, 7 | utils::HashMap, 8 | }; 9 | use fbxcel_dom::v7400::{data::material::ShadingModel, object::material::MaterialHandle}; 10 | use rgb::RGB; 11 | 12 | /// Load materials from an FBX file. 13 | /// 14 | /// Define your own to extend `bevy_mod_fbx`'s material loading capabilities. 15 | #[derive(Clone, Copy)] 16 | pub struct MaterialLoader { 17 | /// The FBX texture field name used by the material you are loading. 18 | /// 19 | /// Textures declared here are directly passed to `with_textures` without modification, 20 | /// this enables caching and re-using textures without re-reading the files 21 | /// multiple times over. 22 | /// 23 | /// They are loaded by the [`FbxLoader`] and provided to the other functions 24 | /// defined in the rest of this struct, associated with their names in a `HashMap`. 25 | /// 26 | /// [`FbxLoader`]: crate::FbxLoader 27 | pub static_load: &'static [&'static str], 28 | 29 | /// The FBX texture field name used by textures you wish to transform. 30 | /// 31 | /// Textures declared here are passed to `preprocess_textures` for further 32 | /// processing, enabling preprocessing. 33 | /// 34 | /// They are loaded by the [`FbxLoader`] and provided to the other functions 35 | /// defined in the rest of this struct, associated with their names in a `HashMap`. 36 | /// 37 | /// [`FbxLoader`]: crate::FbxLoader 38 | pub dynamic_load: &'static [&'static str], 39 | 40 | /// Run some math on the loaded textures, handy if you have to convert between texture 41 | /// formats or swap color channels. 42 | /// 43 | /// To update, remove or add textures, return the `HashMap` with the new values. 44 | /// 45 | /// The `Image`s are then added to the asset store (`Assets`) and a handle 46 | /// to them is passed to `with_textures` in additions to the handles of the textures 47 | /// declared in the `static_load` field. 48 | pub preprocess_textures: fn(MaterialHandle, &mut HashMap<&'static str, Image>), 49 | 50 | /// Create and return the bevy [`StandardMaterial`] based on the [`Handle`] loaded 51 | /// from the return value of `preprocess_textures`. 52 | pub with_textures: 53 | fn(MaterialHandle, HashMap<&'static str, Handle>) -> Option, 54 | } 55 | 56 | const SPECULAR_TO_METALLIC_RATIO: f32 = 0.8; 57 | 58 | /// Load Lambert/Phong materials, making minimal effort to convert them 59 | /// into bevy's PBR material. 60 | /// 61 | /// Note that the conversion has very poor fidelity, since Phong doesn't map well 62 | /// to PBR. 63 | pub const LOAD_LAMBERT_PHONG: MaterialLoader = MaterialLoader { 64 | static_load: &[ 65 | "NormalMap", 66 | "EmissiveColor", 67 | "DiffuseColor", 68 | "TransparentColor", 69 | ], 70 | dynamic_load: &[], 71 | preprocess_textures: |_, _| {}, 72 | with_textures: |material_obj, textures| { 73 | use AlphaMode::{Blend, Opaque}; 74 | use ShadingModel::{Lambert, Phong}; 75 | let properties = material_obj.properties(); 76 | let shading_model = properties 77 | .shading_model_or_default() 78 | .unwrap_or(ShadingModel::Unknown); 79 | if !matches!(shading_model, Lambert | Phong) { 80 | return None; 81 | }; 82 | let transparent = textures.get("TransparentColor").cloned(); 83 | let is_transparent = transparent.is_some(); 84 | let diffuse = transparent.or_else(|| textures.get("DiffuseColor").cloned()); 85 | let base_color = properties 86 | .diffuse_color_or_default() 87 | .map_or(Default::default(), ColorAdapter) 88 | .into(); 89 | let specular = properties.specular_or_default().unwrap_or_default(); 90 | let metallic = (specular.r + specular.g + specular.b) / 3.0; 91 | let metallic = metallic as f32 * SPECULAR_TO_METALLIC_RATIO; 92 | let roughness = properties 93 | .shininess() 94 | .ok() 95 | .flatten() 96 | .map_or(0.8, |s| (2.0 / (2.0 + s)).sqrt()); 97 | Some(StandardMaterial { 98 | alpha_mode: if is_transparent { Blend } else { Opaque }, 99 | // For bistro only 100 | // alpha_mode: AlphaMode::Mask(0.8), 101 | base_color, 102 | metallic, 103 | perceptual_roughness: roughness as f32, 104 | emissive_texture: textures.get("EmissiveColor").cloned(), 105 | base_color_texture: diffuse, 106 | normal_map_texture: textures.get("NormalMap").cloned(), 107 | flip_normal_map_y: true, 108 | ..Default::default() 109 | }) 110 | }, 111 | }; 112 | 113 | /// The default material if all else fails. 114 | /// 115 | /// Picks up the non-texture material values if possible, 116 | /// otherwise it will just look like white clay. 117 | pub const LOAD_FALLBACK: MaterialLoader = MaterialLoader { 118 | static_load: &[], 119 | dynamic_load: &[], 120 | preprocess_textures: |_, _| {}, 121 | with_textures: |material_obj, _| { 122 | let properties = material_obj.properties(); 123 | let base_color = properties 124 | .diffuse_color() 125 | .ok() 126 | .flatten() 127 | .map(|c| ColorAdapter(c).into()) 128 | .unwrap_or(Color::PINK); 129 | let metallic = properties 130 | .specular() 131 | .ok() 132 | .flatten() 133 | .map(|specular| (specular.r + specular.g + specular.b) / 3.0) 134 | .map(|metallic| metallic as f32 * SPECULAR_TO_METALLIC_RATIO) 135 | .unwrap_or(0.2); 136 | let roughness = properties 137 | .shininess() 138 | .ok() 139 | .flatten() 140 | .map_or(0.8, |s| (2.0 / (2.0 + s)).sqrt()); 141 | Some(StandardMaterial { 142 | base_color, 143 | perceptual_roughness: roughness as f32, 144 | alpha_mode: AlphaMode::Opaque, 145 | metallic, 146 | ..Default::default() 147 | }) 148 | }, 149 | }; 150 | 151 | #[cfg(feature = "maya_3dsmax_pbr")] 152 | mod maya_consts { 153 | pub const PBR_TYPE_ID: i32 = 1166017; 154 | pub const DEFAULT_ROUGHNESS: f32 = 0.089; 155 | pub const DEFAULT_METALIC: f32 = 0.01; 156 | } 157 | 158 | // Note that it's impossible to enable the `maya_pbr` feature right now. 159 | /// Load Maya's PBR material FBX extension. 160 | /// 161 | /// This doesn't preserve environment maps or fresnel LUT, 162 | /// since bevy's PBR currently doesn't support environment maps. 163 | /// 164 | /// This loader is only available if the `maya_pbr` feature is enabled. 165 | #[cfg(feature = "maya_3dsmax_pbr")] 166 | pub const LOAD_MAYA_PBR: MaterialLoader = MaterialLoader { 167 | static_load: &[ 168 | "Maya|TEX_normal_map", 169 | "Maya|TEX_color_map", 170 | "Maya|TEX_ao_map", 171 | "Maya|TEX_emissive_map", 172 | ], 173 | dynamic_load: &["Maya|TEX_metallic_map", "Maya|TEX_roughness_map"], 174 | // FIXME: this assumes both metallic map and roughness map 175 | // are encoded in texture formats that can be stored as 176 | // a byte array in CPU memory. 177 | // This is not the case for compressed formats such as KTX or DDS 178 | // FIXME: this also assumes the texture channels are 8 bit. 179 | preprocess_textures: |material_handle, images| { 180 | use bevy::render::render_resource::{TextureDimension::D2, TextureFormat::Rgba8UnormSrgb}; 181 | let mut run = || { 182 | // return early if we detect this material is not Maya's PBR material 183 | let mat_maya_type = material_handle.get_i32("Maya|TypeId")?; 184 | if mat_maya_type != maya_consts::PBR_TYPE_ID { 185 | return None; 186 | } 187 | let combine_colors = |colors: &[u8]| match colors { 188 | // Only one channel is necessary for the metallic and roughness 189 | // maps. If we assume the texture is greyscale, we can take any 190 | // channel (R, G, B) and assume it's approximately the value we want. 191 | &[bw, ..] => bw, 192 | _ => unreachable!("A texture must at least have a single channel"), 193 | }; 194 | // Merge the metallic and roughness map textures into one, 195 | // following the GlTF standard for PBR textures. 196 | // The resulting texture should have: 197 | // - Green channel set to roughness 198 | // - Blue channel set to metallic 199 | let metallic = images.remove("Maya|TEX_metallic_map")?; 200 | let rough = images.remove("Maya|TEX_roughness_map")?; 201 | let image_size = metallic.texture_descriptor.size; 202 | let metallic_components = 203 | metallic.texture_descriptor.format.describe().components as usize; 204 | let rough_components = rough.texture_descriptor.format.describe().components as usize; 205 | let metallic_rough: Vec<_> = metallic 206 | .data 207 | .chunks(metallic_components) 208 | .zip(rough.data.chunks(rough_components)) 209 | .flat_map(|(metallic, rough)| { 210 | [0, combine_colors(rough), combine_colors(metallic), 255] 211 | }) 212 | .collect(); 213 | let metallic_rough = Image::new(image_size, D2, metallic_rough, Rgba8UnormSrgb); 214 | images.insert("Metallic_Roughness", metallic_rough); 215 | Some(()) 216 | }; 217 | run(); 218 | }, 219 | with_textures: |handle, textures| { 220 | // return early if we detect this material is not Maya's PBR material 221 | let mat_maya_type = handle.get_i32("Maya|TypeId"); 222 | if mat_maya_type != Some(maya_consts::PBR_TYPE_ID) { 223 | return None; 224 | } 225 | let lerp = |from, to, stride| from + (to - from) * stride; 226 | // Maya has fields that tells how much of the texture should be 227 | // used in the final computation of the value vs the baseline value. 228 | // We set the `metallic` and `perceptual_roughness` to 229 | // lerp(baseline_value, fully_texture_value, use_map) 230 | // so if `use_map` is 1.0, only the texture pixel counts, 231 | // while if it is 0.0, only the baseline count, and anything inbetween 232 | // is a mix of the two. 233 | let has_rm_texture = textures.contains_key("Metallic_Roughness"); 234 | let use_texture = if has_rm_texture { 1.0 } else { 0.0 }; 235 | let use_metallic = handle 236 | .get_f32("Maya|use_metallic_map") 237 | .unwrap_or(use_texture); 238 | let use_roughness = handle 239 | .get_f32("Maya|use_roughness_map") 240 | .unwrap_or(use_texture); 241 | let metallic = handle 242 | .get_f32("Maya|metallic") 243 | .unwrap_or(maya_consts::DEFAULT_METALIC); 244 | let roughness = handle 245 | .get_f32("Maya|roughness") 246 | .unwrap_or(maya_consts::DEFAULT_ROUGHNESS); 247 | Some(StandardMaterial { 248 | flip_normal_map_y: true, 249 | base_color_texture: textures.get("Maya|TEX_color_map").cloned(), 250 | normal_map_texture: textures.get("Maya|TEX_normal_map").cloned(), 251 | metallic_roughness_texture: textures.get("Metallic_Roughness").cloned(), 252 | metallic: lerp(metallic, 1.0, use_metallic), 253 | perceptual_roughness: lerp(roughness, 1.0, use_roughness), 254 | occlusion_texture: textures.get("Maya|TEX_ao_map").cloned(), 255 | emissive_texture: textures.get("Maya|TEX_emissive_map").cloned(), 256 | alpha_mode: AlphaMode::Opaque, 257 | ..Default::default() 258 | }) 259 | }, 260 | }; 261 | 262 | /// The default fbx material loaders. 263 | /// 264 | /// If you don't provide your own in the [`FbxMaterialLoaders`] resource, 265 | /// the ones declared in this will be used instead. 266 | /// 267 | /// You can also use thise function if you want to add your own loaders 268 | /// and still want to fallback to the default ones. 269 | /// 270 | /// [`FbxMaterialLoaders`]: crate::FbxMaterialLoaders 271 | pub const fn default_loader_order() -> &'static [MaterialLoader] { 272 | &[ 273 | #[cfg(feature = "maya_3dsmax_pbr")] 274 | LOAD_MAYA_PBR, 275 | LOAD_LAMBERT_PHONG, 276 | LOAD_FALLBACK, 277 | ] 278 | } 279 | 280 | #[derive(Default)] 281 | struct ColorAdapter(RGB); 282 | impl From for Color { 283 | fn from(ColorAdapter(rgb): ColorAdapter) -> Self { 284 | Color::rgb(rgb.r as f32, rgb.g as f32, rgb.b as f32) 285 | } 286 | } 287 | -------------------------------------------------------------------------------- /src/loader.rs: -------------------------------------------------------------------------------- 1 | use std::path::Path; 2 | 3 | use anyhow::{anyhow, bail, Context}; 4 | use bevy::{ 5 | asset::{AssetLoader, BoxedFuture, LoadContext, LoadedAsset}, 6 | math::{DVec2, DVec3, Vec2}, 7 | prelude::{ 8 | debug, error, info, trace, BuildWorldChildren, FromWorld, Handle, Image, Mesh, Name, 9 | PbrBundle, Scene, StandardMaterial, Transform, TransformBundle, VisibilityBundle, World, 10 | WorldChildBuilder, 11 | }, 12 | render::{ 13 | mesh::{Indices, PrimitiveTopology, VertexAttributeValues}, 14 | render_resource::{AddressMode, SamplerDescriptor}, 15 | renderer::RenderDevice, 16 | texture::{CompressedImageFormats, ImageSampler, ImageType}, 17 | }, 18 | utils::HashMap, 19 | }; 20 | use fbxcel_dom::{ 21 | any::AnyDocument, 22 | v7400::{ 23 | data::{mesh::layer::TypedLayerElementHandle, texture::WrapMode}, 24 | object::{ 25 | self, 26 | model::{ModelHandle, TypedModelHandle}, 27 | texture::TextureHandle, 28 | ObjectId, TypedObjectHandle, 29 | }, 30 | Document, 31 | }, 32 | }; 33 | 34 | #[cfg(feature = "profile")] 35 | use bevy::log::info_span; 36 | use glam::Vec3; 37 | 38 | use crate::{ 39 | data::{FbxMesh, FbxObject, FbxScene}, 40 | fbx_transform::FbxTransform, 41 | utils::fbx_extend::{GlobalSettingsExt, ModelTreeRootExt}, 42 | utils::triangulate, 43 | MaterialLoader, 44 | }; 45 | 46 | /// Bevy is kinda "meters" based while FBX (or rather: stuff exported by maya) is in "centimeters" 47 | /// Although it doesn't mean much in practice. 48 | const FBX_TO_BEVY_SCALE_FACTOR: f32 = 0.01; 49 | 50 | pub struct Loader<'b, 'w> { 51 | scene: FbxScene, 52 | load_context: &'b mut LoadContext<'w>, 53 | suported_compressed_formats: CompressedImageFormats, 54 | material_loaders: Vec, 55 | } 56 | 57 | pub struct FbxLoader { 58 | supported: CompressedImageFormats, 59 | material_loaders: Vec, 60 | } 61 | impl FromWorld for FbxLoader { 62 | fn from_world(world: &mut World) -> Self { 63 | let supported = match world.get_resource::() { 64 | Some(render_device) => CompressedImageFormats::from_features(render_device.features()), 65 | 66 | None => CompressedImageFormats::all(), 67 | }; 68 | let loaders: crate::FbxMaterialLoaders = world.get_resource().cloned().unwrap_or_default(); 69 | Self { 70 | supported, 71 | material_loaders: loaders.0, 72 | } 73 | } 74 | } 75 | impl AssetLoader for FbxLoader { 76 | fn load<'a>( 77 | &'a self, 78 | bytes: &'a [u8], 79 | load_context: &'a mut LoadContext, 80 | ) -> BoxedFuture<'a, anyhow::Result<()>> { 81 | Box::pin(async move { 82 | let cursor = std::io::Cursor::new(bytes); 83 | let reader = std::io::BufReader::new(cursor); 84 | let maybe_doc = 85 | AnyDocument::from_seekable_reader(reader).expect("Failed to load document"); 86 | if let AnyDocument::V7400(_ver, doc) = maybe_doc { 87 | let loader = 88 | Loader::new(self.supported, self.material_loaders.clone(), load_context); 89 | let potential_error = loader 90 | .load(*doc) 91 | .await 92 | .with_context(|| format!("failed to load {:?}", load_context.path())); 93 | if let Err(err) = potential_error { 94 | error!("{err:?}"); 95 | } 96 | Ok(()) 97 | } else { 98 | Err(anyhow!("TODO: better error handling in fbx loader")) 99 | } 100 | }) 101 | } 102 | fn extensions(&self) -> &[&str] { 103 | &["fbx"] 104 | } 105 | } 106 | 107 | fn spawn_scene( 108 | fbx_file_scale: f32, 109 | roots: &[ObjectId], 110 | hierarchy: &HashMap, 111 | models: &HashMap, 112 | ) -> Scene { 113 | #[cfg(feature = "profile")] 114 | let _generate_scene_span = info_span!("generate_scene").entered(); 115 | 116 | let mut scene_world = World::default(); 117 | scene_world 118 | .spawn(( 119 | VisibilityBundle::default(), 120 | TransformBundle::from_transform(Transform::from_scale( 121 | Vec3::ONE * FBX_TO_BEVY_SCALE_FACTOR * fbx_file_scale, 122 | )), 123 | Name::new("Fbx scene root"), 124 | )) 125 | .with_children(|commands| { 126 | for root in roots { 127 | spawn_scene_rec(*root, commands, hierarchy, models); 128 | } 129 | }); 130 | Scene::new(scene_world) 131 | } 132 | fn spawn_scene_rec( 133 | current: ObjectId, 134 | commands: &mut WorldChildBuilder, 135 | hierarchy: &HashMap, 136 | models: &HashMap, 137 | ) { 138 | let current_node = match hierarchy.get(¤t) { 139 | Some(node) => node, 140 | None => return, 141 | }; 142 | let mut entity = commands.spawn(( 143 | VisibilityBundle::default(), 144 | TransformBundle::from_transform(current_node.transform), 145 | )); 146 | if let Some(name) = ¤t_node.name { 147 | entity.insert(Name::new(name.clone())); 148 | } 149 | entity.with_children(|commands| { 150 | if let Some(mesh) = models.get(¤t) { 151 | for (mat, bevy_mesh) in mesh.materials.iter().zip(&mesh.bevy_mesh_handles) { 152 | let mut entity = commands.spawn(PbrBundle { 153 | mesh: bevy_mesh.clone(), 154 | material: mat.clone(), 155 | ..Default::default() 156 | }); 157 | if let Some(name) = mesh.name.as_ref() { 158 | entity.insert(Name::new(name.clone())); 159 | } 160 | } 161 | } 162 | for node_id in ¤t_node.children { 163 | spawn_scene_rec(*node_id, commands, hierarchy, models); 164 | } 165 | }); 166 | } 167 | 168 | impl<'b, 'w> Loader<'b, 'w> { 169 | fn new( 170 | formats: CompressedImageFormats, 171 | loaders: Vec, 172 | load_context: &'b mut LoadContext<'w>, 173 | ) -> Self { 174 | Self { 175 | scene: FbxScene::default(), 176 | load_context, 177 | material_loaders: loaders, 178 | suported_compressed_formats: formats, 179 | } 180 | } 181 | 182 | async fn load(mut self, doc: Document) -> anyhow::Result<()> { 183 | info!( 184 | "Started loading scene {}#FbxScene", 185 | self.load_context.path().to_string_lossy(), 186 | ); 187 | let mut meshes = HashMap::new(); 188 | let mut hierarchy = HashMap::new(); 189 | 190 | let fbx_scale = doc 191 | .global_settings() 192 | .and_then(|g| g.fbx_scale()) 193 | .unwrap_or(1.0); 194 | let roots = doc.model_roots(); 195 | for root in &roots { 196 | traverse_hierarchy(*root, &mut hierarchy); 197 | } 198 | 199 | for obj in doc.objects() { 200 | if let TypedObjectHandle::Model(TypedModelHandle::Mesh(mesh)) = obj.get_typed() { 201 | meshes.insert(obj.object_id(), self.load_mesh(mesh).await?); 202 | } 203 | } 204 | let roots: Vec<_> = roots.into_iter().map(|obj| obj.object_id()).collect(); 205 | let scene = spawn_scene(fbx_scale as f32, &roots, &hierarchy, &meshes); 206 | 207 | let load_context = &mut self.load_context; 208 | load_context.set_labeled_asset("Scene", LoadedAsset::new(scene)); 209 | 210 | let mut scene = self.scene; 211 | scene.hierarchy = hierarchy.clone(); 212 | scene.roots = roots; 213 | load_context.set_labeled_asset("FbxScene", LoadedAsset::new(scene)); 214 | info!( 215 | "Successfully loaded scene {}#FbxScene", 216 | load_context.path().to_string_lossy(), 217 | ); 218 | Ok(()) 219 | } 220 | 221 | fn load_bevy_mesh( 222 | &mut self, 223 | mesh_obj: object::geometry::MeshHandle, 224 | num_materials: usize, 225 | ) -> anyhow::Result>> { 226 | let label = match mesh_obj.name() { 227 | Some(name) if !name.is_empty() => format!("FbxMesh@{name}/Primitive"), 228 | _ => format!("FbxMesh{}/Primitive", mesh_obj.object_id().raw()), 229 | }; 230 | trace!( 231 | "loading geometry mesh for node_id: {:?}", 232 | mesh_obj.object_node_id() 233 | ); 234 | 235 | #[cfg(feature = "profile")] 236 | let _load_geometry_mesh = info_span!("load_geometry_mesh", label = &label).entered(); 237 | 238 | #[cfg(feature = "profile")] 239 | let triangulate_mesh = info_span!("traingulate_mesh", label = &label).entered(); 240 | 241 | let polygon_vertices = mesh_obj 242 | .polygon_vertices() 243 | .context("Failed to get polygon vertices")?; 244 | let triangle_pvi_indices = polygon_vertices 245 | .triangulate_each(triangulate::triangulate) 246 | .context("Triangulation failed")?; 247 | 248 | #[cfg(feature = "profile")] 249 | drop(triangulate_mesh); 250 | 251 | // TODO this seems to duplicate vertices from neighboring triangles. We shouldn't 252 | // do that and instead set the indice attribute of the Mesh properly. 253 | let get_position = |pos: Option<_>| -> Result<_, anyhow::Error> { 254 | let cpi = pos.ok_or_else(|| anyhow!("Failed to get control point index"))?; 255 | let point = polygon_vertices 256 | .control_point(cpi) 257 | .ok_or_else(|| anyhow!("Failed to get control point: cpi={:?}", cpi))?; 258 | Ok(DVec3::from(point).as_vec3().into()) 259 | }; 260 | let positions = triangle_pvi_indices 261 | .iter_control_point_indices() 262 | .map(get_position) 263 | .collect::, _>>() 264 | .context("Failed to reconstruct position vertices")?; 265 | 266 | debug!("Expand position lenght to {}", positions.len()); 267 | 268 | let layer = mesh_obj 269 | .layers() 270 | .next() 271 | .ok_or_else(|| anyhow!("Failed to get layer"))?; 272 | 273 | let indices_per_material = || -> Result<_, anyhow::Error> { 274 | if num_materials == 0 { 275 | return Ok(None); 276 | }; 277 | let mut indices_per_material = vec![Vec::new(); num_materials]; 278 | let materials = layer 279 | .layer_element_entries() 280 | .find_map(|entry| match entry.typed_layer_element() { 281 | Ok(TypedLayerElementHandle::Material(handle)) => Some(handle), 282 | _ => None, 283 | }) 284 | .ok_or_else(|| anyhow!("Materials not found for mesh {:?}", mesh_obj))? 285 | .materials() 286 | .context("Failed to get materials")?; 287 | for tri_vi in triangle_pvi_indices.triangle_vertex_indices() { 288 | let local_material_index = materials 289 | .material_index(&triangle_pvi_indices, tri_vi) 290 | .context("Failed to get mesh-local material index")? 291 | .to_u32(); 292 | indices_per_material 293 | .get_mut(local_material_index as usize) 294 | .ok_or_else(|| { 295 | anyhow!( 296 | "FbxMesh-local material index out of range: num_materials={:?}, got={:?}", 297 | num_materials, 298 | local_material_index 299 | ) 300 | })? 301 | .push(tri_vi.to_usize() as u32); 302 | } 303 | Ok(Some(indices_per_material)) 304 | }; 305 | let normals = { 306 | let normals = layer 307 | .layer_element_entries() 308 | .find_map(|entry| match entry.typed_layer_element() { 309 | Ok(TypedLayerElementHandle::Normal(handle)) => Some(handle), 310 | _ => None, 311 | }) 312 | .ok_or_else(|| anyhow!("Failed to get normals"))? 313 | .normals() 314 | .context("Failed to get normals")?; 315 | let get_indices = |tri_vi| -> Result<_, anyhow::Error> { 316 | let v = normals.normal(&triangle_pvi_indices, tri_vi)?; 317 | Ok(DVec3::from(v).as_vec3().into()) 318 | }; 319 | triangle_pvi_indices 320 | .triangle_vertex_indices() 321 | .map(get_indices) 322 | .collect::, _>>() 323 | .context("Failed to reconstruct normals vertices")? 324 | }; 325 | let uv = { 326 | let uv = layer 327 | .layer_element_entries() 328 | .find_map(|entry| match entry.typed_layer_element() { 329 | Ok(TypedLayerElementHandle::Uv(handle)) => Some(handle), 330 | _ => None, 331 | }) 332 | .ok_or_else(|| anyhow!("Failed to get UV"))? 333 | .uv()?; 334 | let get_indices = |tri_vi| -> Result<_, anyhow::Error> { 335 | let v = uv.uv(&triangle_pvi_indices, tri_vi)?; 336 | let fbx_uv_space = DVec2::from(v).as_vec2(); 337 | let bevy_uv_space = fbx_uv_space * Vec2::new(1.0, -1.0) + Vec2::new(0.0, 1.0); 338 | Ok(bevy_uv_space.into()) 339 | }; 340 | triangle_pvi_indices 341 | .triangle_vertex_indices() 342 | .map(get_indices) 343 | .collect::, _>>() 344 | .context("Failed to reconstruct UV vertices")? 345 | }; 346 | 347 | if uv.len() != positions.len() || uv.len() != normals.len() { 348 | bail!( 349 | "mismatched length of buffers: pos{} uv{} normals{}", 350 | positions.len(), 351 | uv.len(), 352 | normals.len(), 353 | ); 354 | } 355 | 356 | // TODO: remove unused vertices from partial models 357 | // this is complicated, as it also requires updating the indices. 358 | 359 | // A single mesh may have multiple materials applied to a different subset of 360 | // its vertices. In the following code, we create a unique mesh per material 361 | // we found. 362 | let full_mesh_indices: Vec<_> = triangle_pvi_indices 363 | .triangle_vertex_indices() 364 | .map(|t| t.to_usize() as u32) 365 | .collect(); 366 | let all_indices = if let Some(per_materials) = indices_per_material()? { 367 | per_materials 368 | } else { 369 | vec![full_mesh_indices.clone()] 370 | }; 371 | 372 | debug!("Material count for {label}: {}", all_indices.len()); 373 | 374 | let mut mesh = Mesh::new(PrimitiveTopology::TriangleList); 375 | mesh.insert_attribute( 376 | Mesh::ATTRIBUTE_POSITION, 377 | VertexAttributeValues::Float32x3(positions), 378 | ); 379 | mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, VertexAttributeValues::Float32x2(uv)); 380 | mesh.insert_attribute( 381 | Mesh::ATTRIBUTE_NORMAL, 382 | VertexAttributeValues::Float32x3(normals), 383 | ); 384 | mesh.set_indices(Some(Indices::U32(full_mesh_indices))); 385 | mesh.generate_tangents() 386 | .context("Failed to generate tangents")?; 387 | 388 | let all_handles = all_indices 389 | .into_iter() 390 | .enumerate() 391 | .map(|(i, material_indices)| { 392 | debug!("Material {i} has {} vertices", material_indices.len()); 393 | 394 | let mut material_mesh = mesh.clone(); 395 | material_mesh.set_indices(Some(Indices::U32(material_indices))); 396 | 397 | let label = format!("{label}{i}"); 398 | 399 | let handle = self 400 | .load_context 401 | .set_labeled_asset(&label, LoadedAsset::new(material_mesh)); 402 | self.scene.bevy_meshes.insert(handle.clone(), label); 403 | handle 404 | }) 405 | .collect(); 406 | Ok(all_handles) 407 | } 408 | 409 | // Note: FBX meshes can have multiple different materials, it's not just a mesh. 410 | // the FBX equivalent of a bevy Mesh is a geometry mesh 411 | async fn load_mesh( 412 | &mut self, 413 | mesh_obj: object::model::MeshHandle<'_>, 414 | ) -> anyhow::Result { 415 | let label = if let Some(name) = mesh_obj.name() { 416 | format!("FbxMesh@{name}") 417 | } else { 418 | format!("FbxMesh{}", mesh_obj.object_id().raw()) 419 | }; 420 | debug!("Loading FBX mesh: {label}"); 421 | 422 | let bevy_obj = mesh_obj.geometry().context("Failed to get geometry")?; 423 | 424 | // async and iterators into for are necessary because of `async` `read_asset_bytes` 425 | // call in `load_video_clip` that virally infect everything. 426 | // This can't even be ran in parallel, because we store already-encountered materials. 427 | let mut materials = Vec::new(); 428 | for mat in mesh_obj.materials() { 429 | let mat = self.load_material(mat).await; 430 | let mat = mat.context("Failed to load materials for mesh")?; 431 | materials.push(mat); 432 | } 433 | let material_count = materials.len(); 434 | if material_count == 0 { 435 | materials.push(Handle::default()); 436 | } 437 | 438 | let bevy_mesh_handles = self 439 | .load_bevy_mesh(bevy_obj, material_count) 440 | .context("Failed to load geometry mesh")?; 441 | 442 | let mesh = FbxMesh { 443 | name: mesh_obj.name().map(Into::into), 444 | bevy_mesh_handles, 445 | materials, 446 | }; 447 | 448 | let mesh_handle = self 449 | .load_context 450 | .set_labeled_asset(&label, LoadedAsset::new(mesh.clone())); 451 | 452 | self.scene.meshes.insert(mesh_obj.object_id(), mesh_handle); 453 | 454 | Ok(mesh) 455 | } 456 | 457 | async fn load_video_clip( 458 | &mut self, 459 | video_clip_obj: object::video::ClipHandle<'_>, 460 | ) -> anyhow::Result { 461 | debug!("Loading texture image: {:?}", video_clip_obj.name()); 462 | 463 | let relative_filename = video_clip_obj 464 | .relative_filename() 465 | .context("Failed to get relative filename of texture image")?; 466 | debug!("Relative filename: {:?}", relative_filename); 467 | 468 | let file_ext = Path::new(&relative_filename) 469 | .extension() 470 | .unwrap() 471 | .to_str() 472 | .unwrap() 473 | .to_ascii_lowercase(); 474 | let image: Vec = if let Some(content) = video_clip_obj.content() { 475 | // TODO: the clone here is absolutely unnecessary, but there 476 | // is no way to reconciliate its lifetime with the other branch of 477 | // this if/else 478 | content.to_vec() 479 | } else { 480 | let parent = self.load_context.path().parent().unwrap(); 481 | let clean_relative_filename = relative_filename.replace('\\', "/"); 482 | let image_path = parent.join(clean_relative_filename); 483 | self.load_context.read_asset_bytes(image_path).await? 484 | }; 485 | let is_srgb = false; // TODO 486 | let image = Image::from_buffer( 487 | &image, 488 | ImageType::Extension(&file_ext), 489 | self.suported_compressed_formats, 490 | is_srgb, 491 | ); 492 | let image = image.context("Failed to read image buffer data")?; 493 | debug!( 494 | "Successfully loaded texture image: {:?}", 495 | video_clip_obj.name() 496 | ); 497 | 498 | Ok(image) 499 | } 500 | 501 | async fn run_loader( 502 | &mut self, 503 | material_obj: object::material::MaterialHandle<'_>, 504 | MaterialLoader { 505 | static_load, 506 | dynamic_load, 507 | preprocess_textures, 508 | with_textures, 509 | }: MaterialLoader, 510 | ) -> anyhow::Result> { 511 | use crate::utils::fbx_extend::*; 512 | enum TextureSource<'a> { 513 | Processed(Image), 514 | Handle(TextureHandle<'a>), 515 | } 516 | let mut textures = HashMap::default(); 517 | // code is a bit tricky so here is a rundown: 518 | // 1. Load all textures that are meant to be preprocessed by the 519 | // MaterialLoader 520 | for &label in dynamic_load { 521 | if let Some(texture) = material_obj.load_texture(label) { 522 | let texture = self.get_texture(texture).await?; 523 | textures.insert(label, texture); 524 | } 525 | } 526 | preprocess_textures(material_obj, &mut textures); 527 | // 2. Put the loaded images and the non-preprocessed texture labels into an iterator 528 | let mut texture_handles = HashMap::with_capacity(textures.len() + static_load.len()); 529 | let texture_handles_iter = textures 530 | .drain() 531 | .map(|(label, image)| (label, TextureSource::Processed(image))) 532 | .chain(static_load.iter().filter_map(|l| { 533 | material_obj 534 | .load_texture(l) 535 | .map(|te| (*l, TextureSource::Handle(te))) 536 | })); 537 | // 3. For each of those, create an image handle (with potential caching based on the texture name) 538 | for (label, texture) in texture_handles_iter { 539 | let handle_label = match texture { 540 | TextureSource::Handle(texture_handle) => match texture_handle.name() { 541 | Some(name) if !name.is_empty() => format!("FbxTexture@{name}"), 542 | _ => format!("FbxTexture{}", texture_handle.object_id().raw()), 543 | }, 544 | TextureSource::Processed(_) => match material_obj.name() { 545 | Some(name) if !name.is_empty() => format!("FbxTextureMat@{name}/{label}"), 546 | _ => format!("FbxTextureMat{}/{label}", material_obj.object_id().raw()), 547 | }, 548 | }; 549 | 550 | // Either copy the already-created handle or create a new asset 551 | // for each image or texture to load. 552 | let handle = if let Some(handle) = self.scene.textures.get(&handle_label) { 553 | debug!("Already encountered texture: {label}, skipping"); 554 | 555 | handle.clone() 556 | } else { 557 | let texture = match texture { 558 | TextureSource::Processed(texture) => texture, 559 | TextureSource::Handle(texture) => self.get_texture(texture).await?, 560 | }; 561 | let handle = self 562 | .load_context 563 | .set_labeled_asset(&handle_label, LoadedAsset::new(texture)); 564 | self.scene.textures.insert(handle_label, handle.clone()); 565 | handle 566 | }; 567 | texture_handles.insert(label, handle); 568 | } 569 | // 4. Call with all the texture handles 570 | Ok(with_textures(material_obj, texture_handles)) 571 | } 572 | 573 | async fn get_texture( 574 | &mut self, 575 | texture_obj: object::texture::TextureHandle<'_>, 576 | ) -> anyhow::Result { 577 | let properties = texture_obj.properties(); 578 | let address_mode_u = { 579 | let val = properties 580 | .wrap_mode_u_or_default() 581 | .context("Failed to load wrap mode for U axis")?; 582 | match val { 583 | WrapMode::Repeat => AddressMode::Repeat, 584 | WrapMode::Clamp => AddressMode::ClampToEdge, 585 | } 586 | }; 587 | let address_mode_v = { 588 | let val = properties 589 | .wrap_mode_v_or_default() 590 | .context("Failed to load wrap mode for V axis")?; 591 | match val { 592 | WrapMode::Repeat => AddressMode::Repeat, 593 | WrapMode::Clamp => AddressMode::ClampToEdge, 594 | } 595 | }; 596 | let video_clip_obj = texture_obj 597 | .video_clip() 598 | .context("No image data for texture object")?; 599 | 600 | let image: Result = self.load_video_clip(video_clip_obj).await; 601 | let mut image = image.context("Failed to load texture image")?; 602 | 603 | image.sampler_descriptor = ImageSampler::Descriptor(SamplerDescriptor { 604 | address_mode_u, 605 | address_mode_v, 606 | ..Default::default() 607 | }); 608 | Ok(image) 609 | } 610 | 611 | async fn load_material( 612 | &mut self, 613 | material_obj: object::material::MaterialHandle<'_>, 614 | ) -> anyhow::Result> { 615 | let label = match material_obj.name() { 616 | Some(name) if !name.is_empty() => format!("FbxMaterial@{name}"), 617 | _ => format!("FbxMaterial{}", material_obj.object_id().raw()), 618 | }; 619 | if let Some(handle) = self.scene.materials.get(&label) { 620 | debug!("Already encountered material: {label}, skipping"); 621 | 622 | return Ok(handle.clone_weak()); 623 | } 624 | debug!("Loading FBX material: {label}"); 625 | 626 | let mut material = None; 627 | let loaders = self.material_loaders.clone(); 628 | for &loader in &loaders { 629 | if let Some(loader_material) = self.run_loader(material_obj, loader).await? { 630 | material = Some(loader_material); 631 | break; 632 | } 633 | } 634 | let material = material.context("None of the material loaders could load this material")?; 635 | let handle = self 636 | .load_context 637 | .set_labeled_asset(&label, LoadedAsset::new(material)); 638 | debug!("Successfully loaded material: {label}"); 639 | 640 | self.scene.materials.insert(label, handle.clone()); 641 | Ok(handle) 642 | } 643 | } 644 | 645 | fn traverse_hierarchy(node: ModelHandle, hierarchy: &mut HashMap) { 646 | #[cfg(feature = "profile")] 647 | let _hierarchy_span = info_span!("traverse_fbx_hierarchy").entered(); 648 | 649 | traverse_hierarchy_rec(node, None, hierarchy); 650 | debug!("Tree has {} nodes", hierarchy.len()); 651 | trace!("root: {:?}", node.object_node_id()); 652 | } 653 | fn traverse_hierarchy_rec( 654 | node: ModelHandle, 655 | parent: Option, 656 | hierarchy: &mut HashMap, 657 | ) -> bool { 658 | let name = node.name().map(|s| s.to_owned()); 659 | let data = FbxTransform::from_node(node, parent); 660 | 661 | let mut mesh_leaf = false; 662 | node.child_models().for_each(|child| { 663 | mesh_leaf |= traverse_hierarchy_rec(*child, Some(data), hierarchy); 664 | }); 665 | if node.subclass() == "Mesh" { 666 | mesh_leaf = true; 667 | } 668 | // Only keep nodes that have Mesh children 669 | // (ie defines something visible in the scene) 670 | // I've found some very unwindy FBX files with several thousand 671 | // nodes that served no practical purposes, 672 | // This also trims deformers and limb nodes, which we currently 673 | // do not support 674 | if mesh_leaf { 675 | let fbx_object = FbxObject { 676 | name, 677 | transform: data.as_local_transform(parent.as_ref().map(|p| p.global)), 678 | children: node.child_models().map(|c| c.object_id()).collect(), 679 | }; 680 | hierarchy.insert(node.object_id(), fbx_object); 681 | } 682 | mesh_leaf 683 | } 684 | --------------------------------------------------------------------------------