Most Houdini assets produces Static Meshes upon cook. The generated Static Meshes Components corresponding to the output nodes attaches to the Houdini Asset Actor, and listed in the Houdini Outputs section in the details panel. They can be baked to separate them from the asset and convert them to standalone Static Meshes available in the content browser.

The Houdini Outputs section also displays the materials assigned to each generated meshes. You can override them by drag and drop or selecting a Material in the drop down list.

Generated meshes can also have colliders and sockets assigned to them. Those can be visualized in the Static Mesh Editor by double on the mesh thumbnail in the Details panel.

For more information on the mesh generation mechanism, see Meshes

Static Mesh creation time has been optimized and now uses Mesh Descriptions. You can use a faster Proxy Mesh generation while editing the HDA. The ProxyMeshes can be automatically refined to Static Mesh, either on a timer, when saving/playing the level, or manually.

Select Enable Proxy Mesh in the project settings to turn them on.

Proxy Meshes provides a faster visual feedback when modifying an HDA, but shouldn’t be considered as an asset’s final output. They only create their main level LOD, won’t have colliders, and can’t be instanced.

You can see an HDA is using proxy meshes as the proxy always displays a Houdini Logo sprite.

To separate multiple meshes in your output, you can pack each mesh into a pack primitive before merging them in your asset’s output. A single pack primitive always creates a Static Mesh instead of an instancer with one instance.

You can use the unreal_output_name attribute to set the output mesh’s name.

You can output Unreal Dynamic Meshes instead of Static Meshes by adding an integer unreal_output_dynamic_mesh attribute with a non-zero value to the output geometry. The attribute can be a detail or primitive attribute.

The plug-in creates a UDynamicMesh and displays it with a UDynamicMeshComponent attached to the Houdini Asset Actor. This lets you further modify the output with Unreal’s Geometry Scripting tools without converting it to a Static Mesh first.

Dynamic Mesh output supports positions, triangle topology, normals, UV layers, vertex colors and alpha, material IDs, and simple collision. Materials are assigned to the Dynamic Mesh Component in the same order as the output’s material slots.

Dynamic Meshes do not support LODs. Only the base render mesh is output, and Static Mesh-specific generation features such as Nanite, proxy meshes, and Static Mesh build settings do not apply. If you need a Static Mesh asset or LODs, use a Static Mesh output instead.

When using packed primitives or attribute instancers, Houdini assets produces Instanced Static Mesh Components. All the instancers are listed in the Houdini Outputs sections of the details panel and labeled instancer.

Similar to Static Meshes, if the instanced static geometry was produced by the asset, it’s also listed in the Houdini Output Mesh section. It’s labeled as instanced to indicate that the mesh is used by one of the instancer in the HDA’s outputs.

The unreal_output_name attribute can set the output instancer’s name.

For more information, see Instancing.

You can also directly create Foliage instances instead of Instanced Static Mesh Components. Add the unreal_foliage int attribute to your instancer, and set its value to 1.

New foliage is created for the instanced meshes and the instances added to to the current level’s foligage actor.

When you modify the HDA, the plugin only modify/updates the foliage instances it creates and doesnt modify or remove manually placed foliage instances.

If your asset outputs one or multiple Heightfield node, then the resulting geometry creates a Landscape in Unreal.

Generated Landscapes and their materials lists in the Houdini Outputs section in the details panel.

The unreal_output_name attribute sets the output landscape actor’s name. When using streaming proxies, the proxies' shared landscape actor name can be set using the unreal_landscape_shared_actor_name attribute, and the unreal_output_name attribute will control the proxies' names.

For more information, see Landscapes.

If an HDA output is a Houdini point cloud, it will generate an Unreal DataTable when added to the scene. The DataTable will be populated according to the point cloud’s attributes.

The Unreal struct to use as the basis for the data table is determined by the value of the unreal_data_table_rowstruct attribute of the points. The value of the first point will be taken. The value should be a string representing a valid Unreal object reference. If no structure is specified then one will be generated when cooking based off the table data.

The final baked output name of the table - and structure, if not specifed - created by Baking, can be specified by the unreal_output_name attribute.

The string that will be used as the row name (key) for each row of the data table is determined by the unreal_data_table_rowname attribute of the points. If no such attribute is given, the row names will be defaulted to NewRow_x where x is the index of the row, starting at 0.

The data table will be saved at the string specified by the unreal_object_path attribute. The string at the first point will be taken. This path should be a valid Unreal path (where /Game represents the Content folder). If no path is specified, a name for the data table will be automatically generated and it will be saved in the HoudiniEngine/Temp folder. If the specified data table path already exists, it will be overwritten.

Any other attributes that start with unreal_data_table_ are candidates to use for populating the data table. If the row struct for the data table already exists, these attributes will be matched to the variables of the row struct. Otherwise, variables will be added to the newly created row struct based on these attributes.

Point clouds generated by inputting a data table into Houdini as a geometry input will generate an identical data table when added to Unreal (with the exception of unsupported types that were converted to strings in Houdini, the values of these will be skipped).

If the row struct already exists:

• If the attribute names following the prefix start with an integer followed by an underscore, that integer will be treated as the index of the variable to match with.

  • The variable at that index must have an identical name to the attribute name with the prefix and index (including the underscore).

    • For example, the attribute unreal_data_table_2_type will be matched with the second variable of the row struct if its name is type. It will not be matched if the name is not type.

• If no index is present in the attribute name, it will be matched with any variable that shares the same name after the prefix.

  • For example, the attribute unreal_data_table_type will be matched with a variable of the row struct with name type. If no such variable exists, it will not be matched.

• If no match is found, the attribute will be skipped.

• The attribute type and the matched variable type must satisfy the following constraints:

  • The variable type must be one of the following:

    • Any numeric type

    • Vectors

    • Rotators

    • Transforms

    • Colors

    • Linear Colors

    • Strings

  • They must have the same number of components (they are both single values, or are tuples of the same size).

    • Rotators have 3 components, transforms have 10 (4 component quarternion, 3 component scale and translation), colors and linear colors have 4.

  • If the attribute type does not exactly match the variable type, one of the following must be true:

    • They are both numeric types (in which case the attribute values will be forcefully converted to the variable type and overflow may occur).

    • The attribute is numeric and the variable is a string type (String, Name, or Text).

• Transforms are handled as a special case. Attributes will be matched to a variable with a transform type only if there are 3 separate attributes with the standard name, but appended with rotation, scale, and translate. The rotation attribute must be a tuple of size 4, and the others must have size 3. This reflects the way transform variables are converted to Houdini attributes when a data table is used as a geometry input.

If the row struct does not already exist:

• Transform variables will be created if 3 attributes match the naming pattern described above.

• Otherwise, a variable will be created for each attribute with the prefix.

  • The best matching Unreal type will be used. For tuples, generic vector types will be used.

  • Tuple sizes cannot exceed 4.

A Houdini point cloud with the point string attribute unreal_data_asset_class creates a Data Asset output. The attribute value must be the Unreal object path of a class derived from UDataAsset. For Blueprint Data Asset classes, a path copied from the Unreal Editor may omit the generated _C suffix; the plugin retries the path with _C appended when needed.

Set the Data Asset’s values with either the unreal_data_asset_values point dictionary attribute or point attributes matching editable property names.

{
    "Children":[
        {
            "Float":1,
            "__bake_folder":"/Game/HoudiniEngine/Bake/DataAssets",
            "__bake_output_name":"DataAssetCustomName",
            "__class_path":"/Script/HoudiniEngineEditor.HoudiniSubDataAsset"
        },
        {
            "Float":2,
            "__class_path":"/Script/HoudiniEngineEditor.HoudiniSubDataAsset",
            "__unique_id":"shared"
        },
        {
            "__unique_id":"shared"
        },
        {
            "__object_path":"/Game/TestHDAs/DataAssets/Nested/TestSubAsset.TestSubAsset"
        }
    ],
    "Float":42
}

The HDA can output curves as Spline Components in Unreal. To do this, add the unreal_output_curve int attribute to the curve, with its value set to 1.

For more information, see Curve Output.

The HDA have the ability to output Geometry Collections, allowing compatibility with Unreal’s Chaos Physics. Geometry collection outputs are generated from packed primitive that have a non-zero unreal_gc_piece primitive attribute. You can achieve this using the Voronoi fracture node, with the unreal_gc_piece attribute.

For more information, see Chaos (Geometry Collections).

The Houdini Engine for Unreal plugin can output Skeletal Meshes from KineFX. To export a Skeletal mesh back to Unreal properly, you will need to use the KineFXtoUnreal node for your output, with the Rest Geometry and Capture Pose.

For more information, see Skeletal Mesh.

For more information, see Landscape Splines.

The plugin can output Animation Sequence from Motion clips found in the HDA’s outputs. To properly export a Motion Clip to Unreal, make sure the Motion clips is packed. A motion clip may become unpacked if you use the Motion Clip Evaluate node. A solution is to create a Motion Clip node and turn on the pack input parameter.

When using COP HDAs, the plugin can output the Textures found in the HDA’s outputs'

For more information, see Copernicus with Unreal.

When the Output Templated Geos asset option is on, the plugin displays an asset’s templated geos. You can display helper geometry used to produce the HDA’s output, without creating an output.

Templated geos outputs use a specific wireframe default material. They will not be baked, and be hidden in-game by default. Only templated meshes are supported, and display geos are never considered templated.

A number of properties that control the behaviour/creation of the generated Static Meshes (ex. the default collision presets, the use of MikkTSpace, and Distance Field) can be modifed directly on the details panels.

Those properties are found in the Static Mesh Components details or in the Static Mesh Editor. They are listed under Static Mesh Generation in the Houdini Asset’s details, as Static Mesh Generation properties and Static Mesh Build Settings.

They allow overriding the default build settings values set in the plugin settings per Houdini Asset Component. Additionally, they can also be modified procedurally via attributes by using generic property attributes (detail attributes only).

i@unreal_uproperty_UseFullPrecisionUVs = 1;