Import Model with child node as the scene tree root node

[QueenOfSquiggles]

One of the problems I've been having is where I want to import a GLTF model. I have all of the important flags on the objects in Blender and I have everything parented exactly how I like it. But then when I go to make an inherited scene so I can add interactive elements and script(s), It comes with a root node on top of all of the object nodes I set in Blender. I know I can define what type that inserted root node is, but I would much rather have one of my object nodes be the root. Specifically when I am importing a model with the -rigid flag, I want the rigid body to be the root.

Ideally the feature I would like would be to allow importing a model where a child node can be set as the scene's root node. I'm not familiar with the GLTF specification or how Godot handles model importing. But I imagine adding a path to the sub-node would allow just loading that branch of the file.

I'm totally open to if this has some existing solution I just haven't found yet. But here's some example pictures to show more of what I mean.

Tree In Blender (with flags assigned)

Godot Import View of tree

Scene Tree of inherited scene (from the GLB file)

[theraot]

What about not using scene inheritance? You can create a new scene where you instantiate the imported scene, and use editable children to modify it.

[hmans]

That is a good example of some of the limitation you avoid by not using scene inheritance.

Heh, I missed the "not" in your original reply. Apologies.

Still, what @lyuma said.

I'm currently trying to solve this using a custom import script. Only problem is that I'm failing to even have it trigger at all. Is there something missing from the import script documentation? copied the example script from there and it just won't trigger. Figured it out. Let's go.

[theraot]

@lyuma If you only instance your imported scene, you can also have a non-destructive workflow.

The modifications done with editable children are similar to the modications you do on an inherited scene. You can you can add nodes and you can change the values of the properties of the imported nodes, those modifications are stored in the scene where you instantiated the imported scene. You cannot remove anything.

Just to be clear, I'm not suggesting to convert the scene into a Godot scene, nor to make it local to another scene.

Addendum: To be extra clear, if you reimport the scene (regardless of import scripts), the changes you did to the imported scene are not lost because they were not stored in the imported scene, instead they are reapplied to the instance, which would now be of the new version of the imported scene.

[hmans]

@theraot But what about getting rid of the unwanted root node (the original question)?

[theraot]

@hmans

I think my take back then was that the root wasn't too important (I don't really remember what I was thinking). At least I can tell you that I was often adding my own root anyway because I was doing composition, also if you are getting third party models with weird transform another root is a solution, plus that indirection - even today - that allows me to swap the imported scenes without additional trouble.

And yes, I see that using an import script, such as the one you provided, is a solution. I have used import scripts for other uses cases, so the fact that they are useful is not lost on me.

And about the discussion above, I believe both composition and inheritance workflows can work, although I continue to find inheritance too restrictive.

[hmans]

I think it's worth noting that there's never going to be a "one size fits all" solution to this. Sometimes you want to import a full scene with all child nodes intact; sometimes you just want to the one object that's in the scene, with no extra node around it. Sometimes you'll want to keep the scene connected to the external asset (so it automatically updates once you make changes in eg. Blender); sometimes you want to deliberately sever this connection.

It's also worth noting that there's also the approach where you configure the import to extract individual meshes into their own .tres files. Since meshes in Godot contain both mesh and material information (right?), you can then manually plop the whole thing into a MeshInstance3D node and, if you want physics, wrap that in a RigidBody3D and use the mesh dropdown in the scene view to generate a convex/trimesh collision shape. When making changes in the external application, the mesh and all your Godot nodes that use it will then still get updated automatically. I think this is a valid workflow for imported scenes that consist of a single object (and with no animation, I guess.)

But for scenes that contain a single node with children, the script I posted is probably a good solution. I'll give it some more testing over the next couple of weeks to refine it if further refinement is needed. In particular, I need to find out how it fares with included animations. Sadly, I have close to zero experience with them.

[lyuma]

Unity by default will exclude the root node of a scene with only one root node. So by default, the imported file would be CheeseWedge-rigid.

Unity does still have an importer option called "preserve hierarchy" which will keep the root node the same way Godot does now. Perhaps Godot could have a similar checkbox to the only root node as the root node of the imported scene?

https://docs.unity3d.com/Manual/FBXImporter-Model.html
Preserve Hierarchy
Always create an explicit prefab root, even if this model only has a single root. Normally, the FBX Importer strips any empty root nodes from the model as an optimization strategy. However, if you have multiple FBX files with portions of the same hierarchy you can use this option to preserve the original hierarchy.

For example, file1.fbx contains a rig and a Mesh and file2.fbx contains the same rig but only the animation for that rig. If you import file2.fbx without enabling this option, Unity strips the root node, the hierarchies don’t match, and the animation breaks.

[lyuma]

To be clear, in contrast to the opt-out behavior of Unity, I'm suggesting an opt-in import setting, something like "Exclude root node".

I'm just pointing at it to show that other engines also consider this to be a useful feature, and to show an example of how the feature might be explained.

[kiprou]

Couldn't agree more. When importing an object with the -rigid hint I always want the resulting RigidBody3D node to be the scene root. That Godot adds an unsolicited Node3D as root instead, with no opt-out, is super frustrating.

Since it's been a few months, did you manage to find a sane way to deal with this?

[lyuma]

Note that since this proposal was made, Godot has since added support for a GLTF extension called GODOT_single_root which permits excluding the root node from the imported document.

Theoretically speaking, it would not take much Blender python code to make Blender export the scene with this extension enabled.

It would also be similarly possible to use a global GLTFDocumentExtension in Godot to do the same sort of thing.

[hmans]

@lyuma, will this work in 4.2.2? Do you have any additional pointers on where to get started?

What I tried earlier is to write an import script that returns scene.get_child(0), but that only caused many many many error messages in the logs, making me think that import scripts aren't intended to change the structure of what is imported from the GLTF.

Happy to try some other things, especially if they're implementable in userland.

[lyuma]

In theory, it should be possible in 4.2.2 - the trick will be to manually set the GODOT_single_root extension, which should work in 4.2.2:

See here: in your GLTFDocumentExtension, you can call state.add_used_extension with the argument "GODOT_single_root"
https://docs.godotengine.org/en/stable/classes/class_gltfstate.html#class-gltfstate-method-add-used-extension

As for how to register a GLTFDocumentExtension globally, it would be done using an addon (plugin.cfg / plugin.gd) that registers / unregisters the extension in _enter_tree / _exit_tree:
https://github.com/V-Sekai/godot-vrm/blob/master/addons/vrm/plugin.gd#L203..L207

That said, there are lots of import plugin APIs, so you might be able to do the same thing multiple ways. This is just what I was thinking.

[hmans]

Thanks, I'll give that a try.

Meanwhile, I dream of a future where the Advanced Import screen lets me configure individual nodes to be saved in separate scene files (similar to how I can do it for meshes and materials already.) :-P

[hmans]

I've come up with an import script that solves this. Full explanation here, but here's the code:

@tool
extends EditorScenePostImport

func _post_import(scene):
	# If the imported asset has only a single root node, that's the only node
	# we're interested in:
	if scene.get_child_count() == 1:
		print("Imported asset only contains a single root note; discarding outer root node.")
		return _remove_root_node(scene)
		
	# If the asset contains animation, Godot's importer will put them into an
	# AnimationPlayer node. If there's only a single root object, but we also
	# have animations, we need to handle this explicitly:
	elif scene.get_child_count() == 2 and scene.get_child(1) is AnimationPlayer:
		print("Imported asset contains a single root note and an AnimationPlayer; discarding outer root node.")
		
		# First, convert the scene using our little trick.
		var new_scene := _remove_root_node(scene)
		
		# Now grab the AnimationPlayer that was generated from the asset's animations.
		var anim_player : AnimationPlayer = scene.get_child(1)
		
		# The following might seem a little verbose, but we have to be this 
		# exact in order to not trigger various Godot warnings.
		scene.remove_child(anim_player)
		anim_player.owner = null
		new_scene.add_child(anim_player)
		anim_player.owner = new_scene
		
		return new_scene
		
	# In all other cases, we will just return the scene as originally imported.
	else:
		return scene


func _remove_root_node(scene: Node) -> Node:
	var new_root: Node = scene.get_child(0)

	# Keep the original name so instances of this scene will have the
	# imported asset's filename by default
	new_root.name = scene.name

	# Recursively set the owner of the new root and all its children
	_set_new_owner(new_root, new_root)

	# That's it!
	return new_root
	

func _set_new_owner(node: Node, owner: Node):
	# If we set a node's owner to itself, we'll get an error
	if node != owner:
		node.owner = owner

	for child in node.get_children():
		_set_new_owner(child, owner)

Don't forget that adding this script to your project is not enough; you must also select it in the "Import Script - Path" field in the import settings of each asset you want to import this way (I'm currently trying to find a way to automate this.)

Update (2024-07-15): I've updated the script to also handle files with animations correctly.