-
Notifications
You must be signed in to change notification settings - Fork 76
What's new ?
Here's a detailed list of the changes and new features available in Beta1:
- New and redesigned core architecture, more modular and lightweight:
The plugin now uses 3 modules: HoudiniEngine, HoudiniEngineEditor, and HoudiniEngineRuntime.
All the Houdini Engine/HAPI logic is now Editor-only and contained in the "HoudiniEngine" module. All the custom runtime components and actors used by the plugin now simply acts as data-holders, and are processed by the HoudiniEngine modules, removing the need to bake HDA before packaging a game.
- The plugin now relies exclusively on native, UProperties based serialization, so operations like cut and paste, move between level, duplicate, etc.. do not exhibit any of the issues that version 1 had with those operations.
- Static Mesh creation time has been optimized and now uses Mesh Descriptions.
- You can decide to use an even 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. To enable them, tick "Enable Proxy Mesh" in the project settings.
- Instancers Components are only created if the number of instances exceeds one. If an instance only has one instance, a StaticMeshComponent is created instead. This is especially useful if using packed primitives to split geometry.
- Instancers can now have a position offset per instance override variation.
- Material overrides and generic uproperty attributes can be applied on the instancer, or per instance (when using mesh split instancers)
- Added support for landscape material/hole material in the output details: material update via the ComboBox/drag & drop, and reset the material to its default value.
- Physical Materials can be set on landscape/per landscape layer when using the "unreal_physical_material" primitive attribute.
- It is possible to "pre-assign" landscape layer info object when using the "unreal_landscape_layer_info" primitive attribute. The attribute value must point to a valid LandscapeLayerInfoObject reference. The LayerInfo should have the same "LayerName" as the Landscape Layer. Since this attribute is only used when the landscape is created, it should be present and valid on first cook. It will be ignored if changed on recook, unless if the output landscape actor is deleted first before the recook.
- Added back support for assigning actors to output mesh sockets.
- Added the ability to assign a reference to an asset in the content browser to output mesh sockets. The referenced asset will be instantiated and assigned to the socket. The created actors will be destroyed when the actors are re-created, or when the HDA is deleted.
- When an asset referenced by an attribute instancer ("unreal_instance") or for socket assignment could not be found, the plugin will now create a default "asset not found" box mesh (hidden in-game by default). This can be enabled/disabled by default in the project settings.
- Added support for creating foliage instances directly without baking. This requires having the "unreal_foliage" point/primitive/detail integer/float attribute on the instancer, with its value set to 1.
- Added support for outputting templated geos: - To use this, tick the "output templated geos" checkbox on the asset options, and make sure the desired node have the template flags on in your HDA. - Templated geos are outputted using a specific, wireframe, default material. - Templated geos are not baked, and are hidden in-game by default. - Only templated meshes are supported, and display geos are never considered templated.
- Added the ability to instantiate a class when using the "unreal_instance" attribute instead of only accepting references to an asset in the Content Browser. (ie "PointLight", "AudioVolume"... ) This is especially useful when wanting to instantiate a class that cannot be saved as an asset in the content browser, and removes the need to create a BP for that. This will succeed as long as the specified class can be placed as an actor.
- Added support for the "unreal_level_path" attribute to Meshes and Instancers: When baking, this allows the user to specify the path to a level where the baked Actors will go. If the level doesn't exist, then the level and its package will be created. This allows moving meshes and instancers to the appropriate levels when using PDG and/or World Composition.
- Attribute and packed primitives instancers can now be split using attribute values. The name of the attribute used to split the instancers can be set via the "unreal_split_attr" attribute (string). The specified attributes values will then be used to create multiple instancers instead of one. ie: setting the "unreal_split_attr value" to "tile" will create a separate instancer for each value of the "tile" attribute.
- Added support for forcing the creation of Hierarchical Instanced Static Mesh Components when instancing. To do so, simply add the "unreal_hierarchical_instancer" (value 1) to the instancer.
- Added support for outputting Curves to Spline Components. To do so, curves in the HDA need to be marked using the "unreal_output_curve" primitive attribute (value set to 1). You can also control if you want the spline to be linear/closed using the "unreal_output_curve_linear" and "unreal_output_curve_closed" primitive attributes respectively.
- Geometry Inputs:
- Added the ability for Geometry Input to import StaticMeshComponents found in BP.
- World Inputs:
- Colliders on Static Meshes can be imported as group geometry when "Export colliders" is enabled.
- World inputs can now read data from brushes.
- Instancers and Foliage actors are now imported as packed primitives instead of merged, individual meshes.
- World inputs have an improved bound selector mode, that lets them send all the actors and objects contained in the bounds of the selected object.
- World inputs can now import data from all supported input objects (landscape, Houdini asset actors..)
- World inputs can now import data from an actor placed in a different level than the Houdini Asset Actor's.
- World inputs now only update the actors that have been modified (version 1 updated all the selection)
- Added buttons to select all / clear the current selection.
- Curve Inputs:
- A single curve inputs can now create and import any number of curves.
- You can Alt-click on a curve input or editable curve to create new points.
- Auto-update checkbox to enable/disable cook when modifying the input curve.
- Landscape Inputs:
- Added clear Button for Landscape inputs.
- Added a "Disable input" button on when there is no input selected for Asset and Landscape inputs.
- Added "import as reference" for geometry, asset, and world inputs. This allows importing the selected assets/actors as "unreal_instance" references.
- Material parameter attributes are now imported when importing meshes (scalar, vector and texture parameter types are currently supported)
- Added the "Set from Content Browser" arrow on Geometry inputs, and output materials.
- HDA parameters and inputs editing now support multi-selection.
- Folder UI (tabs, radio, collapsible) has been improved.
- Ramps UI has been improved, and it is now easy to turn off auto-update while editing them.
- String parameters now support Drag & Drop. When an asset is dropped on a string parameter, its value is automatically set to that asset reference. This is especially useful for when using unreal_instance / unreal_material attributes.
- Similarly, String parameters can be turned into an asset picker, that sets the string value to the asset's reference. To do so, add the "unreal_ref" tag (with the value set to 1) to the string param.
- When using a string parameter as an actor picker by using the unreal_ref, it is now possible to filter the classes displayed by the actor picker by using the "unreal_ref_class" tag, and setting the value of the tag to the desired class (ie StaticMesh).
- Support for File parameters has been improved (custom extension, directory, new file...)
- Multi-line strings, Column Labels, Button Strip, Log Integer and Float parameters are now supported.
- Added default values to parameters/revert to default support per parameter. The "Revert" arrow and "Reset Parameters" buttons are now only enabled/visible when there are non-default parameters.
- The plugin's UI has been completely revamped, a new Houdini Engine menu has been added to the editor.
- bgeo/bgeo.sc files can be imported natively in the content browser (Mesh and instancers).
Session Sync allows the plugin to connect to a session of Houdini Engine running inside Houdini. The state of Houdini Engine can then be viewed in Houdini while working with the plugin in Unreal, and changes on either end, whether in Unreal via the plugin or in Houdini via its various interfaces, will be synchronized across so that both applications will be able to make changes and see the same results.
- Added a new menu command to open Houdini in Session Sync mode and directly connect to it. Connection is handled by an async task, that connects as soon as the SessionSync session is available.
- We only launch Houdini in Session Sync mode if it's not already running. If we've previously started Houdini in SessionSync, we just reconnect to the existing process.
- Added SessionSync default settings: - SyncWithHoudiniCook: when enabled and connected to a Session Sync session, Unreal will update after a change has been made in Houdini. - CookUsingHoudiniTime: controls if the plugin should use the Houdini timeline time when cooking.
- SessionSync features are only enabled if we're connected to a SessionSync session. Auto-started session (using HARS) ignore SessionSync features.
- Added menu entry to close the current Houdini Session Sync.
- Viewport Sync: When using session sync, you can choose to sync the houdini and unreal viewport via the Viewport Sync menu. It will let you choose whether you want to sync both viewport, to only sync one of them (unreal's or houdini's) , or none. (Viewport Sync is still currently a Work In Progress)
As of Beta1, it is now possible to use Houdini Asset Components in the Blueprint Editor. This lets you preset and use Houdini Digital Assets in Blueprint Actors. Changing parameters on the Houdini Asset will automatically update all placed instances of that Blueprint.
After adding the Houdini Asset Component, the Houdini Asset it uses can be selected in the details panel. This will cook the HDA, and display its parameters interface.
Currently, only Static mesh and Instancer outputs are supported, and only geometry inputs are available when using HDAs in the BP Editor. This will be improved upon in subsequent releases of the plugin.
The plugin now has a PDG Asset Link, similar to the one used by the Unity plugin that allows cooking and fetching results from PDG Graphs embedded in HDAs.
A PDG Asset Link is automatically created when importing an HDA that contains a TOP Network. The PDG Asset Link UI will list all the TOP Networks available in the HDA. It will also display all the TOP Nodes available for the currently selected TOP Network, as well as controls to dirty, cook them...
To avoid displaying all the nodes in a TOP Network, the PDG Asset Link uses a filter that specifies a prefix for the node names to decide if they should be listed by the PDG asset link. By default, the filter is set to "HE_", so only nodes that start with HE_ will be listed in the PDG Asset Link: HE_Terrain, HE_Trees, etc...
Similarly, nodes that produce output BGEOs that should be processed and created in Unreal can be specified via a TOP Output filter prefix. By default, the filter is set to "HE_OUT_", so the PDG Asset Link will only try to load Work Item Output files that are created by nodes that start with this prefix: HE_OUT_Trees, HE_OUT_Roads, HE_OUT_Buildings...
Those filters can be modified or disabled in the PDG Asset Link UI.
When cooking the PDG Graph, the PDG Asset Link will automatically import Work Items output files that have successfully cooked on the TOP Output Nodes. The results are loaded on actors that reproduce the PDG Graph's hierarchy:
- TOP NETWORK
- TOP NODE - WorkItem Output File
Despite not being attached to the HDA, it is important to note that "Cooked" PDG results are still considered temporary, like normal HDA outputs would, and are still owned by the Houdini Asset Actor until baked. This means that dirtying or changing the PDG asset can potentially destroy or update them, and destroying the Houdini Actor will also destroy them.
The PDG Asset Link has its own "bake" section, which gives more control in deciding what/how the PDG graph's results are baked. You can choose whether to bake all outputs, only the selected top network, or selected TOP node. You can decide if you want to replace existing assets and actors created from a previous bake or create new ones...
As of the v2 beta, the PDG Asset Link now has the ability to use an asynchronous importer commandlet to import Work Item outputs once they are ready.
The commandlet communicates with the PDG Asset Link via a message bus, and automatically imports the BGEO files from output work items, creating uassets. After a successful import, the commandlet then notifies the PDG asset link which will then instantiate the uasset in the level.
Asynchronous import can be enabled/started/stopped via the "Work Item Import Settings" entry in the Houdini Engine menu. The PDG Asset Link will display the status of the async importer in its details UI when using it.
World Composition support has been completely updated and redesigned and is now supported only when baking.
When baking tiled landscapes in a world with world composition enabled, the plugin automatically creates or updates the levels needed for the tiles. When cooking the HDA, the generated landscape tiles remain attached to the HDA Actor to provide visual feedback and fast iteration.
The following attributes can be used on the HF to control World Composition baking:
- the "unreal_landscape_tile_actor_type" primitive, int attribute can be used to decide if LandscapeStreamingProxies should be created when baking. When set to 1, Landscape streaming proxies are created. When set to 0, landscape actors are created. This replaces the "unreal_landscape_streaming_proxy" attribute used in v1.
- Individual landscape tile actor names can be set using the "unreal_output_name" attribute.
- The "unreal_level_path" attribute can be used to set the name and path to the levels that will be generated for the landscape tiles.
- When generating landscape streaming proxies, the "unreal_landscape_shared_actor_name" primitive, int attribute can be used to specify the name of the common, shared landscape actor that controls all the streaming proxies.
- "unreal_landscape_layer_min" and "unreal_landscape_layer_max" can be used to specify the min and max values to be used when converting HeightField masks or height values.
When mixing heightfield tiles and instancers/meshes in the same hda, the "unreal_level_path" attribute can be used to control the sub-levels that will be used for baking the landscapes, but also for the instancers and meshes as well. In order to do that properly, you'll likely need to split the instancers, for example, using the tile number of the tile they were scattered on.
- promote/copy the "tile" attribute from the heightfield to the instances.
- after merging all the outputs, indicate that you want to split the instancers with the tile attribute by setting the "unreal_split_attr" attribute to "tile".
- finally set the "unreal_level_path" for both the HF and instancers to something that uses the tile output token: ie: "{world}/Landscape/Tile{tile}"
note: In some cases, like when using point instancers (unreal_instance), you may need to promote the "tile" and "unreal_level_path" attributes on the Heightfield to points as well, due to the mismatch caused by the attributes being stored on points for the instances.
The plugin now has the ability to process a set of output tokens (keywords in curly brackets) that can be used on certain attributes to make path and name more dynamic.
They are still in the process of being added to the plugin and are mainly used now for the "unreal_output_name" and "unreal_level_path" attributes to control the naming and path of the output objects generated when baking for world composition, or PDG.
This s a list of some of the currently supported attribute tokens:
{world} - Path the directory that contains the world. {hda_name} - Name of the HDA {hda_actor_name} - Name of the Houdini Asset Actor {object_name} - Name of the Object {guid} - GUID of the HDA component {out} - The output directory (varies if cooking or baking the asset) {pdg_topnet_name} - Name of the TOP Network that generated the output. {pdg_topnode_name} - Name of the TOP Node that generated the output. {pdg_workitem_index} - Index of the WorkItem that generated the output. {tile}- Tile number, available on tiled Heightfields.
{geo_id} - ID of the geo node used by HAPI to create the result. {part_id} - ID of the Part that created the output. {split_str} - Split string used to identify the output.
Some examples:
unreal_level_path = "{world}/Landscape/Tile{tile}" unreal_output_name = "{hda_actor_name}PurplePlants{geo_id}_{part_id}" unreal_level_path = "{out}/{hda_name}/{guid}/PurplePlants/{geo_id}/{part_id}"
The commandlet that is used for Asynchronous import of a PDG Graph's work item outputs can also be used independently, to automatically import BGEO files to an unreal project.
The -watch= command-line argument can be used to place the commandlet into directory watching mode.
The BGEO import commandlet supports importing to bake path, by reading the "unreal_bake_folder" and "unreal_output_name" name attributes when in "bake" mode.
- To watch a directory for new files and import them as uassets to the HoudiniEngine temporary path: <editor_exe> -run=HoudiniGeoImport -watch=
- To watch a directory for new files and import them as uassets to bake paths (respecting "unreal_bake_folder" and "unreal_output_name"): <editor_exe> -run=HoudiniGeoImport -bake -watch=
- To import a single .bgeo file as a uasset to the HoudiniEngine temporary path: <editor_exe> -run=HoudiniGeoImport
- To import a single .bgeo file as a uasset to the bake path (respecting "unreal_bake_folder" and "unreal_output_name"): <editor_exe> -run=HoudiniGeoImport -bake
- To display/log the help: <editor_exe> -run=HoudiniGeoImport -help