Houdini Engine for Unreal - Version 2.0.2

Update 2 of the V2 Plugin.
The plug-in is now linked to Houdini 18.5.596 / HAPI 3.6.2.

Documentation for version 2.0 of the plug-in is available:
https://www.sidefx.com/docs/unreal/

-------------------------------------------------------
New features:
-------------------------------------------------------

- Added support for Landscape Edit Layers:
  Output: Heightfield data can now be assigned to landscape edit layers on existing landscapes. Those landscapes need to have the "Enable Edit Layers" option enabled. The "unreal_landscape_editlayer_landscape" prim string attribute can be used to set the name of the target landscape actor. The "unreal_landscape_editlayer_name" prim string attribute can be used to set the name of the targeted edit layer. Finally, the "unreal_landscape_editlayer_after" primitive string attributes can be used to specify the name of another layer that the target layer should be created after.
  Input: If a Landscape with edit layers is used as input, the (final) heightfield and paint layers are still imported as usual, but we will also create heightfields of the individual edit layers using the layer names, prefixed by landscapelayer_. The imported layers will be hidden by default, and the visibility SOP is needed to unhide them.

- Added a public API to the plugin:
  The API supports instantiating HDAs, setting parameters and inputs, cooking, inspecting and baking outputs of instantiated HDAs via C++, Blueprints and Python. 

The API has an example Editor Utility Widget and example Python scripts in the plugin's "Content/Examples" folder. 
Documentation for the public API will be added soon to the plugin's documentation.



-------------------------------------------------------
Bug fixes:
-------------------------------------------------------

- Fixed a regression that caused generic property attributes to not always be properly applied to generated Static Mesh Components. (specifically when using RawMeshes).
- Fixed "unreal_uproperty_CollisionProfileName" not being properly applied in some cases.
- Fixed crash when using the bake button in the output section.
- Generic property attributes are now applied on spline outputs.
- Textures from Houdini Materials are now created only if the corresponding "use" parameter isn't disabled.
- Reduced the number of HAPI calls when translating Houdini materials.
- Optimized mesh creation. (removed redundant calls to Physics/NavCollisions functions that are already part of the StaticMesh::Build function)
- Mesh creation: removed unnecessary attempt to load an unreal material with an invalid path.
- Fixed World inputs creating invalid input nodes with "Import as Reference" enabled.
- Fixed "Import as Reference" not triggering input updates when disabled.
- Fixed issues with multiparm/ramps sync if a HDA's parameter interface had changed. This could cause mix-ups in the multiparms children parameters, and even crashes due to a recursive loop after load/rebuild.
- Fixed missing output detail UI when an output's node is marked as editable but is not an editable curve.
- Fixed potential crash caused by the plugin attempting to update rendering while loading a level.
- Fixed an issue that caused OBJ HDAs with nested OBJ_geo subnets to not display/use the main OBJ geo. This caused some HDAs that used vellum solvers/DOP networks to not properly output their results.
- Float Vector3 parameters now have spin buttons on the XYZ values.
- Fixed regression causing mesh sockets to be ignored when they were on a separate part. This was likely to happen when using socket groups on "floating" points (point that are not used by a mesh).
- Fixed generated mesh sockets displaying the default "Not found" mesh when they had no actor assigned. We only display the default mesh when we failed to attach or spawn the assigned Actor.
- The output UI for Proxy meshes now display the number of sockets found in the output.
- Fixed issue where landscape updates wouldn't immediately update viewport after cooking.
- Fixed material assignments for Meshes with LODs (when using RawMesh) Before, all LODs used the first material.
- Fixed materials being mixed up when using multiple point instancers with the "unreal_split_attr" attributes. Only the first instancer had the proper materials.
- Fixed multiple issues when importing one/multiple landscape proxies via a world/landscape input:
  - The paint layers data were not properly converted to HF masks when converting the landscape to Heightfield.
  - Fixed landscape proxies having an incorrect transform in Houdini.
  - Fixed multiple landscapes not being imported properly with World Inputs.

Author: dpernuit

Content/Examples/EUW/EUW_APIExample.uasset

@@ -0,0 +1,143 @@
+""" An example script that uses the API to instantiate two HDAs. The first HDA
+will be used as an input to the second HDA. For the second HDA we set 2 inputs:
+an asset input (the first instantiated HDA) and a curve input (a helix). The
+inputs are set during post instantiation (before the first cook). After the
+first cook and output creation (post processing) the input structure is fetched
+and logged.
+
+"""
+import math
+
+import unreal
+
+_g_wrapper1 = None
+_g_wrapper2 = None
+
+
+def get_copy_curve_hda_path():
+    return '/HoudiniEngine/Examples/hda/copy_to_curve_1_0.copy_to_curve_1_0'
+
+
+def get_copy_curve_hda():
+    return unreal.load_object(None, get_copy_curve_hda_path())
+
+
+def get_pig_head_hda_path():
+    return '/HoudiniEngine/Examples/hda/pig_head_subdivider_v01.pig_head_subdivider_v01'
+
+
+def get_pig_head_hda():
+    return unreal.load_object(None, get_pig_head_hda_path())
+
+
+def configure_inputs(in_wrapper):
+    print('configure_inputs')
+
+    # Unbind from the delegate
+    in_wrapper.on_post_instantiation_delegate.remove_callable(configure_inputs)
+
+    # Create a geo input
+    asset_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPIAssetInput)
+    # Set the input objects/assets for this input
+    # asset_input.set_input_objects((_g_wrapper1.get_houdini_asset_actor().houdini_asset_component, ))
+    asset_input.set_input_objects((_g_wrapper1, ))
+    # copy the input data to the HDA as node input 0
+    in_wrapper.set_input_at_index(0, asset_input)
+    # We can now discard the API input object
+    asset_input = None
+
+    # Create a curve input
+    curve_input = in_wrapper.create_empty_input(unreal.HoudiniPublicAPICurveInput)
+    # Create a curve wrapper/helper
+    curve_object = unreal.HoudiniPublicAPICurveInputObject(curve_input)
+    # Make it a Nurbs curve
+    curve_object.set_curve_type(unreal.HoudiniPublicAPICurveType.NURBS)
+    # Set the points of the curve, for this example we create a helix
+    # consisting of 100 points
+    curve_points = []
+    for i in range(10):
+        t = i / 10.0 * math.pi * 2.0
+        x = 100.0 * math.cos(t)
+        y = 100.0 * math.sin(t)
+        z = i * 10.0
+        curve_points.append(unreal.Transform([x, y, z], [0, 0, 0], [1, 1, 1]))
+    curve_object.set_curve_points(curve_points)
+    # Set the curve wrapper as an input object
+    curve_input.set_input_objects((curve_object, ))
+    # Copy the input data to the HDA as node input 1
+    in_wrapper.set_input_at_index(1, curve_input)
+    # We can now discard the API input object
+    curve_input = None
+
+
+def print_api_input(in_input):
+    print('\t\tInput type: {0}'.format(in_input.__class__))
+    print('\t\tbKeepWorldTransform: {0}'.format(in_input.keep_world_transform))
+    print('\t\tbImportAsReference: {0}'.format(in_input.import_as_reference))
+    if isinstance(in_input, unreal.HoudiniPublicAPICurveInput):
+        print('\t\tbCookOnCurveChanged: {0}'.format(in_input.cook_on_curve_changed))
+        print('\t\tbAddRotAndScaleAttributesOnCurves: {0}'.format(in_input.add_rot_and_scale_attributes_on_curves))
+
+    input_objects = in_input.get_input_objects()
+    if not input_objects:
+        print('\t\tEmpty input!')
+    else:
+        print('\t\tNumber of objects in input: {0}'.format(len(input_objects)))
+        for idx, input_object in enumerate(input_objects):
+            print('\t\t\tInput object #{0}: {1}'.format(idx, input_object))
+            if hasattr(in_input, 'get_object_transform_offset'):
+                print('\t\t\tObject Transform Offset: {0}'.format(in_input.get_object_transform_offset(input_object)))
+            if isinstance(input_object, unreal.HoudiniPublicAPICurveInputObject):
+                print('\t\t\tbClosed: {0}'.format(input_object.is_closed()))
+                print('\t\t\tCurveMethod: {0}'.format(input_object.get_curve_method()))
+                print('\t\t\tCurveType: {0}'.format(input_object.get_curve_type()))
+                print('\t\t\tReversed: {0}'.format(input_object.is_reversed()))
+                print('\t\t\tCurvePoints: {0}'.format(input_object.get_curve_points()))
+
+
+def print_inputs(in_wrapper):
+    print('print_inputs')
+
+    # Unbind from the delegate
+    in_wrapper.on_post_processing_delegate.remove_callable(print_inputs)
+
+    # Fetch inputs, iterate over it and log
+    node_inputs = in_wrapper.get_inputs_at_indices()
+    parm_inputs = in_wrapper.get_input_parameters()
+
+    if not node_inputs:
+        print('No node inputs found!')
+    else:
+        print('Number of node inputs: {0}'.format(len(node_inputs)))
+        for input_index, input_wrapper in node_inputs.items():
+            print('\tInput index: {0}'.format(input_index))
+            print_api_input(input_wrapper)
+
+    if not parm_inputs:
+        print('No parameter inputs found!')
+    else:
+        print('Number of parameter inputs: {0}'.format(len(parm_inputs)))
+        for parm_name, input_wrapper in parm_inputs.items():
+            print('\tInput parameter name: {0}'.format(parm_name))
+            print_api_input(input_wrapper)
+
+
+def run():
+    # get the API singleton
+    api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
+
+    global _g_wrapper1, _g_wrapper2
+    # instantiate the input HDA with auto-cook enabled
+    _g_wrapper1 = api.instantiate_asset(get_pig_head_hda(), unreal.Transform())
+
+    # instantiate the copy curve HDA
+    _g_wrapper2 = api.instantiate_asset(get_copy_curve_hda(), unreal.Transform())
+
+    # Configure inputs on_post_instantiation, after instantiation, but before first cook
+    _g_wrapper2.on_post_instantiation_delegate.add_callable(configure_inputs)
+    # Print the input state after the cook and output creation.
+    _g_wrapper2.on_post_processing_delegate.add_callable(print_inputs)
+
+
+if __name__ == '__main__':
+    run()

Content/Examples/Maps/LandscapeInputExample.umap

@@ -0,0 +1,110 @@
+import unreal
+
+""" Example script for instantiating an asset, cooking it and baking all of
+its outputs.
+
+"""
+
+_g_wrapper = None
+
+
+def get_test_hda_path():
+    return '/HoudiniEngine/Examples/hda/pig_head_subdivider_v01.pig_head_subdivider_v01'
+
+
+def get_test_hda():
+    return unreal.load_object(None, get_test_hda_path())
+
+
+def on_post_instantiation(in_wrapper):
+    print('on_post_instantiation')
+    # in_wrapper.on_post_instantiation_state_exited_delegate_delegate.remove_callable(on_post_instantiation)
+
+    # Set parameter values for the next cook
+    # in_wrapper.set_bool_parameter_value('add_instances', True)
+    # in_wrapper.set_int_parameter_value('num_instances', 8)
+    in_wrapper.set_parameter_tuples({
+        'add_instances': unreal.HoudiniParameterTuple(bool_values=(True, )),
+        'num_instances': unreal.HoudiniParameterTuple(int32_values=(8, )),
+    })
+    
+    # Print all parameter values
+    param_tuples = in_wrapper.get_parameter_tuples()
+    print('parameter tuples: {}'.format(len(param_tuples) if param_tuples else 0))
+    if param_tuples:
+        for param_tuple_name, param_tuple in param_tuples.items():
+            print('parameter tuple name: {}'.format(param_tuple_name))
+            print('\tbool_values: {}'.format(param_tuple.bool_values))
+            print('\tfloat_values: {}'.format(param_tuple.float_values))
+            print('\tint32_values: {}'.format(param_tuple.int32_values))
+            print('\tstring_values: {}'.format(param_tuple.string_values))
+
+    # Force a cook/recook
+    in_wrapper.recook()
+
+
+def on_post_bake(in_wrapper, success):
+    in_wrapper.on_post_bake_delegate.remove_callable(on_post_bake)
+    print('bake complete ... {}'.format('success' if success else 'failed'))
+
+    # Delete the hda after the bake
+    in_wrapper.delete_instantiated_asset()
+    global _g_wrapper
+    _g_wrapper = None
+
+
+def on_post_process(in_wrapper):
+    print('on_post_process')
+
+    # in_wrapper.on_post_processing_delegate.remove_callable(on_post_process)
+
+    # Print out all outputs generated by the HDA
+    num_outputs = in_wrapper.get_num_outputs()
+    print('num_outputs: {}'.format(num_outputs))
+    if num_outputs > 0:
+        for output_idx in range(num_outputs):
+            identifiers = in_wrapper.get_output_identifiers_at(output_idx)
+            print('\toutput index: {}'.format(output_idx))
+            print('\toutput type: {}'.format(in_wrapper.get_output_type_at(output_idx)))
+            print('\tnum_output_objects: {}'.format(len(identifiers)))
+            if identifiers:
+                for identifier in identifiers:
+                    output_object = in_wrapper.get_output_object_at(output_idx, identifier)
+                    output_component = in_wrapper.get_output_component_at(output_idx, identifier)
+                    is_proxy = in_wrapper.is_output_current_proxy_at(output_idx, identifier)
+                    print('\t\tidentifier: {}'.format(identifier))
+                    print('\t\toutput_object: {}'.format(output_object.get_name() if output_object else 'None'))
+                    print('\t\toutput_component: {}'.format(output_component.get_name() if output_component else 'None'))
+                    print('\t\tis_proxy: {}'.format(is_proxy))
+                    print('')
+
+    # bind to the post bake delegate
+    in_wrapper.on_post_bake_delegate.add_callable(on_post_bake)
+
+    # Bake all outputs to actors
+    print('baking all outputs to actors')
+    in_wrapper.bake_all_outputs_with_settings(
+        unreal.HoudiniEngineBakeOption.TO_ACTOR,
+        replace_previous_bake=False,
+        remove_temp_outputs_on_success=False)
+
+
+def run():
+    # get the API singleton
+    api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
+
+    global _g_wrapper
+
+    # instantiate an asset, disabling auto-cook of the asset (so we have to
+    # call wrapper.reCook() to cook it)
+    _g_wrapper = api.instantiate_asset(get_test_hda(), unreal.Transform(), enable_auto_cook=False)
+
+    # Bind to the on post instantiation delegate (before the first cook)
+    _g_wrapper.on_post_instantiation_delegate.add_callable(on_post_instantiation)
+    # Bind to the on post processing delegate (after a cook and after all
+    # outputs have been generated in Unreal)
+    _g_wrapper.on_post_processing_delegate.add_callable(on_post_process)
+
+
+if __name__ == '__main__':
+    run()

Content/Examples/Maps/LandscapeInputExample_BuiltData.uasset

@@ -0,0 +1,79 @@
+import unreal
+
+""" Example script for instantiating an asset, cooking it and baking an
+individual output object.
+
+"""
+
+_g_wrapper = None
+
+
+def get_test_hda_path():
+    return '/HoudiniEngine/Examples/hda/pig_head_subdivider_v01.pig_head_subdivider_v01'
+
+
+def get_test_hda():
+    return unreal.load_object(None, get_test_hda_path())
+
+
+def on_post_process(in_wrapper):
+    print('on_post_process')
+    # Print details about the outputs and record the first static mesh we find
+
+    sm_index = None
+    sm_identifier = None
+
+    # in_wrapper.on_post_processing_delegate.remove_callable(on_post_process)
+    
+    num_outputs = in_wrapper.get_num_outputs()
+    print('num_outputs: {}'.format(num_outputs))
+    if num_outputs > 0:
+        for output_idx in range(num_outputs):
+            identifiers = in_wrapper.get_output_identifiers_at(output_idx)
+            output_type = in_wrapper.get_output_type_at(output_idx)
+            print('\toutput index: {}'.format(output_idx))
+            print('\toutput type: {}'.format(output_type))
+            print('\tnum_output_objects: {}'.format(len(identifiers)))
+            if identifiers:
+                for identifier in identifiers:
+                    output_object = in_wrapper.get_output_object_at(output_idx, identifier)
+                    output_component = in_wrapper.get_output_component_at(output_idx, identifier)
+                    is_proxy = in_wrapper.is_output_current_proxy_at(output_idx, identifier)
+                    print('\t\tidentifier: {}'.format(identifier))
+                    print('\t\toutput_object: {}'.format(output_object.get_name() if output_object else 'None'))
+                    print('\t\toutput_component: {}'.format(output_component.get_name() if output_component else 'None'))
+                    print('\t\tis_proxy: {}'.format(is_proxy))
+                    print('')
+
+                    if (output_type == unreal.HoudiniOutputType.MESH and 
+                            isinstance(output_object, unreal.StaticMesh)):
+                        sm_index = output_idx
+                        sm_identifier = identifier
+    
+    # Bake the first static mesh we found to the CB
+    if sm_index is not None and sm_identifier is not None:
+        print('baking {}'.format(sm_identifier))
+        success = in_wrapper.bake_output_object_at(sm_index, sm_identifier)
+        print('success' if success else 'failed')
+
+    # Delete the instantiated asset
+    in_wrapper.delete_instantiated_asset()
+    global _g_wrapper
+    _g_wrapper = None
+
+
+def run():
+    # get the API singleton
+    api = unreal.HoudiniPublicAPIBlueprintLib.get_api()
+
+    global _g_wrapper
+    # instantiate an asset with auto-cook enabled
+    _g_wrapper = api.instantiate_asset(get_test_hda(), unreal.Transform())
+
+    # Bind to the on post processing delegate (after a cook and after all 
+    # outputs have been generated in Unreal)
+    _g_wrapper.on_post_processing_delegate.add_callable(on_post_process)
+
+
+if __name__ == '__main__':
+    run()