Could not load glb

[ThomasCartier]

Hi,

I want to run Bevy as a headless tool for simulation.
To test it out with known to work models, I downloaded the SimpleGltf and tried to query the world and it failed.

I didn't open an issue because I am sure it's on me, and not a bug of Bevy.

Here is the code:

pub(crate) mod generate_animation {

        //! Loads and renders a glTF file as a scene.

        use std::f32::consts::FRAC_PI_2;

        use bevy::{
                animation::RepeatAnimation,
                animation::{
                        AnimationClip,
                        AnimationPlayer,
                        AnimationPlugin
                },
                app::{
                        App,
                        Startup,
                        Update
                },
                asset::{
                        AssetPlugin,
                        AssetServer,
                        Assets,
                        Handle
                },
                diagnostic::DiagnosticsPlugin,
                ecs::{
                        entity::Entity,
                        query::{
                                Added,
                                With,
                                WorldQuery
                        },
                        schedule::IntoSystemConfigs,
                        system::{
                                Commands,
                                Query,
                                Res,
                                ResMut,
                                Resource
                        },
                        world::World
                },
                gltf::GltfPlugin,
                hierarchy::{
                        Children,
                        HierarchyPlugin,
                        Parent
                },
                math::Quat,
                pbr::{
                        AmbientLight,
                        StandardMaterial
                },
                prelude::default,
                render::mesh::skinning::SkinnedMesh,
                render::mesh::Mesh,
                scene::{
                        SceneBundle,
                        ScenePlugin
                },
                time::Time,
                transform::{
                        components::Transform,
                        TransformPlugin
                },
                MinimalPlugins
        };

        #[derive(Resource)]

        struct PathToLoad(String);

        fn launch(s: String) {

                App::new()
                        .add_plugins(MinimalPlugins)
                        .add_plugins(AssetPlugin::default())
                        .add_plugins(AnimationPlugin::default())
                        .add_plugins(GltfPlugin::default())
                        .add_plugins(TransformPlugin::default())
                        .add_plugins(HierarchyPlugin::default())
                        .add_plugins(DiagnosticsPlugin::default())
                        .add_plugins(ScenePlugin::default())
                        .insert_resource(PathToLoad(s))
                        .add_systems(Startup, setup)
                        .add_systems(Update, prepare.after(setup))
                        .run();
        }

        fn prepare(mut commands: Commands, parent_query: Query<&Parent>, children_query: Query<&Children>, mut transform_query: Query<&mut Transform>) {

                // Enters here just fine
                for skinned_mesh_parent in &parent_query {

                        // never enters the code here
                }

        }

        fn setup(mut commands: Commands, mut asset_server: Res<AssetServer>, res: ResMut<PathToLoad>) {

                // -----------------
                // Place the model
                // -----------------

                let j = asset_server.load(&res.0);

                commands.spawn(SceneBundle {
                        scene: j,
                        ..default()
                });
        }

        #[cfg(test)]

        mod test {

                use super::launch;


                #[test]

                fn t0() {

                        launch("/absolute/path/to/SimpleSkin.gltf#Scene0".to_string());
                }
        }
}

I also tried with

fn prepare( time: Res<Time>, mut commands: Commands, parent_query: Query<&Parent>, children_query: Query<&Children>, mut transform_query: Query<&mut Transform>) {
fn prepare( time: Res<Time>, mut commands: Commands, parent_query: Query<&Parent, With<SkinnedMesh>>, children_query: Query<&Children>, mut transform_query: Query<&mut Transform>) {

Same result: I never enter the code inside the loop (but I enter the prepare function). Meaning that my gltf is not loaded for some reasons.

May you help ?

Thanks

[ThomasCartier]

Tried with defaultPlugins and it works..
Hmm..

Requested resource bevy_asset::assets::Assets<bevy_render::render_resource::shader::Shader> does not exist in the World.

[ThomasCartier]

Yeah.. this app requires a window to launch which is incompatible with my need on a hardware without a gpu.
Because the render plugin is needed, it forces a whole world of deps around it.
No headless mode possible for me at the moment.
Still, Bevy is a great lib ! 👍