Using Datasmith Metadata

The nodes you'll need are under Datasmith > Scene and Datasmith > Element.

For the nodes above that return a Datasmith Metadata Element object, you can get the keys and values from the metadata object by using Datasmith > Element > Get Properties, Get Property and Get Property Count:

Example usage

This example shows how you could use the values assigned to a metadata key to identify geometry that you know you won't need in your Project, and to remove it from your Datasmith Scene before creating Static Mesh Assets:

During the Datasmith import process, you can get to the metadata about your scene objects through the unreal.DatasmithSceneElement object. For details on the following functions, see the Python API Reference.

Example usage

This example shows how you could use the values assigned to a metadata key to identify geometry that you know you won't need in your Project, and to remove it from your Datasmith Scene before creating Static Mesh Assets:

    key_name = "name"
    remove_keyword = "Clutch"
    meshes_to_skip = set([])
    # Get all scene elements that have the "name" key.
    objects_and_values = ds_scene_in_memory.get_all_objects_and_values_for_key(key_name, unreal.DatasmithMeshActorElement)
    objects = objects_and_values[0]
    values = objects_and_values[1]
    # Iterate through them looking for ones whose value matches a keyword
    for index, value in enumerate(values):
        if remove_keyword in value:
            print("removing actor named: " + value)
            # Remove the mesh actor element from the scene, and put the mesh element in a list to remove later
            mesh_actor = objects[index]
            mesh = mesh_actor.get_mesh_element()
            meshes_to_skip.add(mesh)
            ds_scene_in_memory.remove_mesh_actor(mesh_actor)
    # Remove all the meshes we don't need to import.
    for mesh in meshes_to_skip:
        mesh_name = mesh.get_element_name()
        print("removing mesh named " + mesh_name)
        ds_scene_in_memory.remove_mesh(mesh)

Copy full snippet

The following nodes access metadata for one specific Actor. These have very little impact on performance, so you can use them anytime, even at runtime in your project. If you want to visualize the imported metadata for one or more selected objects in your scene—say, in a callout or a menu in your project's runtime UI—these are the nodes you'll want to use in your runtime Blueprint graphs.

You'll find them under the Datasmith User Data category. 

The following nodes, by contrast, access the metadata for all Static Mesh Actors in the current Level (or all that share a given class). Since your Level can potentially contain a large number of Actors, each with many properties, these functions may be expensive in CPU resources and could cause poor performance when used in runtime gameplay. Therefore, you can only use them in graphs that you create on Editor-only Blueprint classes.

You'll find these nodes under the Editor Scripting > Datasmith User Data category.

The Get Datasmith User Data and Get All Datasmith User Data nodes above return Datasmith User Data Object References. This object has one variable you can access, called Metadata, which is a map of all the key-value pairs that make up the object's Datasmith metadata. To work with this kind of object, drag off the output pin and select Variables > Get Metadata:

This gives you the keys and values as a map. You can then use the utility nodes in the Utilities > Map category to work with the data. For example, this graph iterates through all the keys one by one, and retrieves the value associated with each key:

For more information about Blueprint Map nodes, see the Blueprint API Reference.

Example usage

This section shows a simplified example of how you could visualize your asset metadata at runtime for an object that the player selects in the Level.

The text is written by a UMG widget that contains two text fields, each bound to a string variable. In the Blueprint graph for the widget, a custom action extracts two items of Datasmith metadata from an Actor that you pass in a custom event, and saves those items to the bound variables.

The following Level Blueprint shows an example of how to add a widget like this when play begins, and how to feed it with the Actor under the cursor every time the user presses a mouse button.

For more information about building user interfaces in UMG, see the UMG UI Designer Quick Start Guide and the surrounding sections.

After the Datasmith import process is done, you can access metadata for all Actors or selected Actors using the unreal.DatasmithContentLibrary class. For details on the following functions, see the Python API Reference.

Example usage

In Python scripts that you run inside the Unreal Editor, you can use Datasmith metadata after import to identify Static Mesh Actors in your Level that you want to apply certain special processing to.

    import unreal
    new_actor_name = "Exterior Walls"
    metadata_key = "Type"
    metadata_value = "Wall: Exterior"
    meshes_to_join = set([])
    # Iterate through the Actors in the current Level
    all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
    for actor in all_actors:
        # Retrieve the value of this Actor's Datasmith metadata for the key set above, if any
        actor_value = unreal.DatasmithContentLibrary.get_datasmith_user_data_value_for_key(actor, metadata_key)
        # If the key exists, and its value contains a keyword set above, add the Actor to a list
        if actor_value and metadata_value in actor_value:
            print("found a matching actor: " + actor_value)
            meshes_to_join.add(actor)
    # Join all Actors that were found above into a single Actor with many components
    options = unreal.EditorScriptingJoinStaticMeshActorsOptions(destroy_source_actors=True, new_actor_label=new_actor_name, rename_components_from_source=True)
    unreal.EditorLevelLibrary.join_static_mesh_actors(meshes_to_join, options)
    print "Merged all actors!"

Copy full snippet