Working with Assemblies in Unreal

When you export a Natsura assembly via Export Unreal Nanite Assembly, what lands in Unreal is a USD scene plus a wind.json. The USD carries the geometry, the rig, the skin weights, and the instance hierarchy; the wind.json describes the wind layers authored in Houdini with Wind Config. The engine consumes both as a Nanite Skeletal Assembly.

For the export side, see Export Unreal Nanite Assembly; for the wind layer authoring upstream, see Wind for Unreal; for the full pipeline on screen, watch Nanite Assemblies.

What you get

The export produces:

• USD scene containing the meshed geometry, the rig (already produced at simulate time), the skin weights (transferred automatically based on which part of the skeleton each piece of geometry came from), and the full instance hierarchy.
• wind.json describing the wind layers, ready to be wired into Unreal's wind animation system.

Anything that was an instance in the Houdini network is an instance inside Unreal, the same way it would be in LOPs. Instance preservation is end-to-end through the chain.

Prerequisites

Nanite foliage tooling landed in Unreal 5.7, so use 5.7 or later. Before importing:

• Plugins. Enable Procedural Vegetation Editor, USD Importer, and USD Core.
• Project Settings. Turn on both Nanite and Nanite Foliage. (Nanite Foliage is what enables voxelisation of foliage, the mechanism the import fix below relies on.)

Import workflow

1. Bring in the USD

Drag-and-drop the exported .usd into the Content browser. The defaults are fine; review the USD structure and click Import. You get folders for Materials, Skeletal Meshes, and Textures. Open Skeletal Meshes, find the tree, and drag it into the viewport. The Nanite Skeletal Assembly pipeline consumes the file and surfaces the rigged, skinned mesh with the instance hierarchy intact.

2. Fix instances stuck at the world origin

In the Skeletal Mesh editor:

1. Open the imported skeletal mesh.
2. In the Asset Details panel, search Preserve.
3. Set Shape Preservation to Voxelize.
4. Click Apply Changes.

The tree then reads correctly and the instances move off the origin into place. (This is why Nanite Foliage must be enabled in Project Settings: voxelisation is the path that resolves the instance transforms.)

3. Materials

Materials come across as material attribute references, into the Materials folder. Assign Unreal-side materials to the imported asset's material slots; the rig and skin need no extra setup. For Natsura assemblies that include baked high-poly detail, the Bake outputs (colour, height, normal) feed the engine-side material directly; normals are written in MikkT space, which transfers cleanly.

Two-sided leaves. Leaf materials default to single-sided, which makes foliage look wrong from one side. On the leaf material, enable Two-Sided, and confirm you're viewing with materials enabled.

4. Instances

Anything that was an instance in Houdini is still an instance in Unreal. Confirm in the level or outliner that the instance hierarchy survived the round-trip. This is what makes large Natsura assemblies cheap in the engine: the instance relationships do the work, not duplicated geometry.

5. Wind hook-up

The wind.json sidecar describes which wind layers apply to which parts of the tree. Apply it in two stages:

1. Import the wind data. Right-click the Skeletal Mesh → Scripted Asset Actions → Import Dynamic Wind Data, and select the wind.json that shipped beside the USD.

2. Set up an Instance Skinned Mesh. For a single tree, a Blueprint is the most direct route:
   • Create an Actor Blueprint and add a Skinned Instanced Mesh Component.
   • Set the component's mesh to the imported tree.
   • Add at least one instance; the component renders nothing until it has one.
   • Add a wind transform provider alongside the geometry; without it there's still no motion.
   • Compile and save, then drag the Blueprint into the scene.

To tune visibility, open the Skeletal Mesh editor, search wind, and adjust Gust Attenuation per simulation group (one group per Wind Config layer authored in Houdini). Gust Attenuation resets when you re-import wind data, so expect to set it again after a re-export.

The Houdini-side authoring lives in Wind Config; see Wind for Unreal for how the layers are built. The in-Houdini wind preview is a rough guide, not a one-to-one match for the engine result.

Troubleshooting

• Static mesh importer rejecting geometry. Almost always non-manifold decoration meshes. Confirm decorations are producing watertight, manifold output on the Houdini side before re-exporting.
• Very large exports importing slowly or unstably. The Unreal static mesh importer is currently a bit buggy in the large-volume high-resolution regime. Keep individual exports under roughly 56,000 instances; this is expected to improve with later Unreal versions.
• "Missing BoneCapture" warning on the export node. Surfaces when the input geometry is not from a Simulate (and therefore not rigged and skinned at simulate time). Re-derive from a Simulate before exporting.
• Per-export instance limit. Approximately 56,000 instances. Larger forests should be split across multiple exports.

Performance

Nanite handles the polygon load efficiently; the practical limits are import-time (large high-res imports are slow) and instance count per export. Run Simplify Tree Rig and Skin on the Houdini side before exporting to bring the joint count into a sensible range for the engine. For very large environments, split the export into per-cluster or per-region chunks rather than trying to ship a whole forest in one file.

Related

• Export Unreal Nanite Assembly. The export node.
• Wind for Unreal. How wind layers are authored.
• Nanite Assemblies (learning video). The workflow on screen.
• Send a Forest to Unreal (learning). Large-scale Unreal export walkthrough.
• Assemblies (overview). The decoration workflow that produces the exported geometry.