Is there a way to read, output for and or use Unreal Engine's landscape (terrain) generation tools?
- Specifically I would like to:
1.: Read out the poly-paint information of the terrain (to influence instance placements).
1.b.: Read out the material information of the terrain (to influence instance placements).
2.: Read out and manipulate landscape height information (around my instance placements).
3.: Read out and manipulate Foliage painting (to expand or remove foliage around instance placements).
3.b.: Get some kind of information so my procedure won't place things (or will place very specific things), where an artist added foliage.
5.: Raise or lower parts of the terrain (get and manipulate the heightmap of the terrain).


If this (or any part of it) is possible, could you please post a simple example for this?

If these are planned features/will be coming in the near future, is it likely to get implemented within the next 1 to 2 months?

We do not have direct support for Unreal terrain tools or landscape; If you can transform your terrain into a static mesh and then use that as an input to an HDA that would work. We preserve vertex information when we marshal data into Houdini Engine (such as normals, colors, UE material names). So you can use painting tool on your static mesh and then use that information inside Houdini to do processing.

We do not have any terrain work scheduled in this time frame. However, please do submit an RFE if you do require it. This would help us pick next desired features.

Thank you!

Thx, I use Houdini Indie, so I have to to email the RFE to support@sidefx.com , right?
(I don't see options for this on http://service.sidefx.com). [service.sidefx.com]

Hello!

I took care of that and I've submitted an RFE, #72208 . Thanks for suggestions

Thanks!

We also referenced this in https://github.com/sideeffects/HoudiniEngineForUnreal/issues/7 [github.com] .

Awesome!
As far as I can tell you already have the option to Input an UE4 Landscape into an HDA via Houdini Engine, but unfortunately I could not get it to work.
Could you please give a brief explanation on how to use this?
I attached a screenshot on how I tried to set it up in UE4. I have an object path parameter that by default points to a mountain geometry (deformed gird) inside the HDA. I scatter some instanced boxes on that. I thought if I point the parameter to the UE4 Landscape the boxes would be scattered on there.
Maybe it's a matter of how I set it up, maybe I am not getting polygons from the landscape but something else and my procedure is not designed to use that.

And how would one “Commit landscape geometry and connect it to host asset.”? And what exactly does it mean?

Most likely it is a bug somewhere, I will have a look, we are still in the process of testing / working on this.

I am not sure about your screenshot - UI looks outdated. Are you running the latest build?

When you select landscape type input and then select landscape from a list, it will send landscape vertex data to the asset as point data. At the moment we only send point data. You can use that point data to instance things inside the asset.

'Import selected parts only' - will send only selected parts of landscape (using mouse selection).

'Recommit landscape' button can be used to resend landscape data to the asset. We aded it for the time being so you could send your things over if you updated landscape. We will probably automate detection of landscape changes in the future.

There is still a number of features that we are going to add soon (like having an option to send actual geometry, not just vertex/point data), send UE4 component information (grid information) as well as send material related stuff.

Hope this helps and thanks for reporting!

Thank you!
I was running 15.0.329. I updated to 15.376 and it seems to work, but I still have issues:

Once imported the points seem to be scaled into 0 to 1 space or something like that. In the screenshot attached, I got the scale to match by multiplying the scale of the Landscape input by 100.

The output is a fairly dense point cloud, but what would be a consistent and efficient way to turn those points into a surface in Houdini? My method would be to copy metaballs to the points, turn that into a mesh and process it further, but that leads to all kinds of issues. I guess there is a way that I could use inherent point order to create a clean polygon mesh, but I can't quite figure it out.

Hello,

Yes, we had a number of bugs to fix in landscape input code.
We fixed scaling and added a number of features, please see here:
https://github.com/sideeffects/HoudiniEngineForUnreal/issues/7 [github.com]

It sounds like you want to enable full geometry option to get the mesh data. If you don't enable it, only the point data will be marshalled in. In that case you would have to remesh it (we also do marshall in normals, so it should be easier).

Please note that you can select individual landscape components through selection tool and if you have that option enabled we will only marshall selected geometry. This makes it much faster than marshalling the whole landscape.

We are still in the process of adding features, mainly landscape materials and UVs.

Please let us know if you have any questions.
Thanks!

Very nice! Thank you!
To turn the points into geometry I now do the following:
- Move the points to @P.y=0 and store the original @P.y
- Triangulate2D SOP
- Move the points back in P.y
I can't seem to get rid of the triangulation, but aside from that the method seems quite efficient and precise.

Is there now a way to deform the point position data (and possible other attributes) and push that back onto the Input Landscape or a new Landscape? How would I do that, exactly?

Awesome. Glad you found it useful!

We don't have Unreal landscape export yet, it's a separate feature, but definitely planned First step was to let people instance / create things on landscape surfaces.

As for modification, definitely, but we still are trying to figure out the workflow for this. I will file a separate RFE / GitHub issue for this purpose.

I am not sure the documentation on this is up to date, but I think you can paint different materials on one landscape: https://docs.unrealengine.com/latest/INT/Engine/Landscape/QuickStart/5/index.html [docs.unrealengine.com]
I suspect this information is relatively dificult to extract, but technically it could be useful for controlling scattering. Basically if this info was some kind of per point attribute, it could be converted into simple vertex paint and then processed to change regional distribution. This would be quite useful.

Normal and tangent data are relatively pointless, because you end up recreating the terrain in Houdini Engine for scattering anyways. (I could be wrong on this, but basically they just use smoothed normals on the whole Landscape.)
Similarly UV data seems rather useless unless you could detect UV tension. Then you could scatter stuff in regions of high UV tension to cover up bad UVs.

On another note:
I am reading the Houdini Daily Build Journals and I don't think I see the changes from https://github.com/sideeffects/HoudiniEngineForUnreal/issues/7 [github.com] . Maybe I am looking in the wrong place. Anyways, I don't mind if it's not in the Journals, but maybe you could leave a note on https://github.com/sideeffects/HoudiniEngineForUnreal/issues/7 [github.com] which build contains a specific change. - Sorry about that, I just don't like to experiment with getting new builds to test experimental features that might or might not be in there… Too many variables.

Are these new features documented somewhere (like the Houdini docs)?

Landscape output could be achieved by using UE4 tools for landscape creation. Basically you could just automate the process of creating a new landscape from a heightmap texture and copy paste the parameters (like scale, position and resolution) from the input landscape. Now that I think about it, I could output a height-map myself…

Thank you for your work!

Hello

It's not in changes since it's not a finished feature. I will add it to changelog once it is done.

You are right about tangents. Normals I think could be useful, for remeshing.
We are working on getting layer / weightmap info.

As for heightmap output, you are correct, it's one way to do it. We are also planning landscape modification through an asset.

Another request was to add lightmap information.

There's no documentation yet, but we will provide test assets.

Thanks for the feedback!!

Normals I think could be useful, for remeshing.

How would that work? I am always on the lookout for new remeshing techniques and tricks.

DASD

Normals I think could be useful, for remeshing.

How would that work? I am always on the lookout for new remeshing techniques and tricks.

I was thinking along the lines of point cloud iso .

ttvdsfx

DASD

Normals I think could be useful, for remeshing.

How would that work? I am always on the lookout for new remeshing techniques and tricks.

I was thinking along the lines of point cloud iso .

Ah! Very interesting. That's a very useful tool. I tested this method versus mine (flatten, triangulate 2D, deflatten) and mine gave more stable results and was significantly faster. Creating a grid, raying the points down on it and deforming the grid gave me the cleanest geometry, but I had an offset issue in there that was probably related to the way I transferred the position attribute. It was also a bit slower than flatten-triangulate-deflatten (but still faster than point cloud iso).
I'm definitely going to keep the point cloud iso in mind, though. Thanks!

The unreal_vertex_index point attribute seems to be a great way to turn the polygons into geometry. (If you know the order of the points, you can connect them in their natural sequence, right?) From the unreal_vertex_index I could calculate the number of points in a row or column. Than I could use an add node to create rows or columns (set add to Groups of N points). And finally I could create polygons with a skin node. This process would be very fast, very stable and fully procedural. The only thing I am missing to do this, is the information of what is actually in unreal_vertex_index. What kind of data can I expect and how is it formatted? I expected it be something like a local coordinate system, starting at 0,0 and being something like PoinnumbertInRow,PoinnumbertInColumn

Hello!

I actually do like your approach, haha, you learn something every day. It would definitely be faster than point cloud iso, imo.

Basically, unreal landscape is composed of components (one component corresponds to a landscape tile). We marshall names of those components as “name” attribute, so you can always figure out which points belong to which component. Now, each component / tile is a grid as well, composed of points. unreal_vertex_index is an integer vec2 which gives you a local index within the component. They should be consistent and you can think of it as a local coordinate system per component / tile. They will start at 0,0 and will go to max number of divisions, which is variable (you can specify that at landscape generation time).

Hope this helps

We are looking into marshalling weightmaps and layers at the moment.

Hi DASD!

Would you mind sharing a screenshot of your pointvop setup for this:

Very nice! Thank you!
To turn the points into geometry I now do the following:
- Move the points to @P.y=0 and store the original @P.y
- Triangulate2D SOP
- Move the points back in P.y
I can't seem to get rid of the triangulation, but aside from that the method seems quite efficient and precise.

Is there now a way to deform the point position data (and possible other attributes) and push that back onto the Input Landscape or a new Landscape? How would I do that, exactly?

Best regards

If I am not mistaken this is no longer necessary. Set your input to Landscape Input and activate “Export Full Landscape Geometry”. Then you get a triangulated mesh into your HDA.

I attached a test HDA that also has the triangulation method that I described. I tested this with UE4.13 and Houdini 15.5.651

Tell me how it works for you.