Removing GltfNodes from Gltf / Spawning GltfNodes / Get Mesh3d from Mesh

[berezowski]

Hi,

thanks for taking the time reading this, i hope someone can guide me through it. Nothing i try seems to work.
I'm desperately trying to get a 'clean' entity representation of a gltf from blender.

In Blender i have one scene with two meshes named..
.."Frame"
..and "Collider"
..as well as an Empty named "Motor"

In Bevy..

• ..i just care about the position of the Motor
• ..the Mesh of the Collider
• ..and the Frame contains the Model and should be a Entity.

When i spawn the asset via named_scenes:

All components are wrapped as children in in a 'parent' entity. Which itself is wrapped. (i suppose one represents the scene itself).

so at first i tried manipulating the asset itself, but i can't get rid of the Motor. Even after removing the GltfNode it is being spawned afterwards:

fn assetevent(
    mut commands: Commands,
    mut assets: ResMut<Assets<Gltf>>,
    mut asset_event_reader: EventReader<AssetEvent<Gltf>>,
    mut nodes: ResMut<Assets<GltfNode>>,
) {
    for asset_event in asset_event_reader.read() {
        match asset_event {
            AssetEvent::LoadedWithDependencies { id } => {
                let mut asset = &mut assets.get_mut(*id).unwrap();

                asset.named_nodes.retain(|name, node| {
                    if *name != "Motor".into() {
                        if let Some(motor) = nodes.get(&mut *node) {
                            dbg!(motor.transform);
                            // extract position
                        }
                        // remove node from nodes
                        asset.nodes.retain(|handle| handle != node);
                        // remove node from named_nodes
                        true
                    } else {
                        false
                    }
                });

                // this also does not prevent spawning of a "Motor" from the asset
                asset.named_nodes = asset
                    .named_nodes
                    .clone()
                    .into_iter()
                    .filter(|(name, node)| *name != "Motor".into())
                    .collect();
            }
            _ => (),
        }
    }
}

On the other Hand i could not figure out how to just spawn the Frame or use the Mesh in a pbrbundle.

#[derive(Resource)]
struct FrameAssets {
    generic: Handle<Gltf>,
}

fn load_gltf(mut commands: Commands, asset_server: Res<AssetServer>) {
    let generic = asset_server.load("frame/generic.glb");
    commands.insert_resource(FrameAssets {
        generic,
    });
}

[..]
        app
            .add_systems(Startup, load_gltf)
            .add_systems(Update, spawn)
[..]

pub fn spawn(
    [..]
    frames: Res<FrameAssets>,
    assets_gltf: Res<Assets<Gltf>>,
    meshes: Res<Assets<Mesh>>,
    [..]
) {
    [..]
    commands.spawn((
        [..]
	)).with_children(|parent| {
	    if let Some(gltf) = assets_gltf.get(&frames.generic) {

	        // for (name, node) in gltf.named_nodes.clone() {
	        //     if name == "Frame".into() {

			Is there a way to spawn GltfNodes like Components?

	        //     }
	        // }

	        for mesh_handle in &gltf.meshes {
	            let mesh = meshes.get(mesh_handle).unwrap();
	            parent.spawn(PbrBundle {

	                i've given up on this, is this (creating a new pbrbundle) even the way to do what i intend?:


	                // 605 | ...                   mesh: Mesh3d::from(mesh),
	                //     |                             ^^^^^^ the trait `From<&bevy::prelude::Mesh>` is not implemented for `bevy::prelude::Mesh3d`

	                or:

	                //     |                             ------ ^^^^^^^^^^^ expected `Handle<Mesh>`, found `&Handle<GltfMesh>`

	                ..Default::default()
	            });
	        }
		}
	})
        [..]
}

[berezowski]

regarding "Removing GltfNodes from Gltf":
i've read a bit on Handles and came to the conclusion that i don't want to remove gltfNodes, but rather
create a new Gltf with an new "Generation". Is this assumption correct?

How would i 'increment' the AssetId by one Generation and 'depcrecate' the old one?
i tried just reusing the old id, but to my surprise the Motor Component that i filter out is still being spawned.

then i tried reinserting with commands.insert_resource. But that failed:
^^^ expected Handle<Gltf>, found AssetId<Gltf>

So i thought i'll ask again here to see if i'm even on the right track.

fn assetevent(
    mut frames: ResMut<FrameAssets>,
    mut commands: Commands,
    mut assets: ResMut<Assets<Gltf>>,
    mut asset_event_reader: EventReader<AssetEvent<Gltf>>,
    mut nodes: ResMut<Assets<GltfNode>>,
    mut commands: Commands,
) {
    for asset_event in asset_event_reader.read() {
        match asset_event {
            AssetEvent::LoadedWithDependencies { id } => {
                let mut asset = &mut assets.get_mut(*id).unwrap();

                let named_nodes = asset
                    .named_nodes
                    .clone()
                    .into_iter()
                    .filter(|(name, node)| *name != "Motor".into())
                    .collect();

                let gltf = Gltf {
                    named_nodes,
                    nodes: asset.nodes.clone(),
                    scenes: asset.scenes.clone(),
                    named_scenes: asset.named_scenes.clone(),
                    meshes: asset.meshes.clone(),
                    named_meshes: asset.named_meshes.clone(),
                    materials: asset.materials.clone(),
                    named_materials: asset.named_materials.clone(),
                    skins: asset.skins.clone(),
                    named_skins: asset.named_skins.clone(),
                    default_scene: asset.default_scene.clone(),
                    animations: asset.animations.clone(),
                    named_animations: asset.named_animations.clone(),
                    source: asset.source.clone(),
                };
                // assets.insert(*id, gltf);
                commands.insert_resource(FrameAssets { generic: *id });
            }
            _ => (),
        }
    }
}