Scan Workflow

The high poly workflow brings high-resolution scanned or sculpted meshes (typically trunks) into Natsura and prepares them for use in procedural tree generation. The unifying purpose of the workflow is to take raw geometry (scans, sculpts, prefab meshes) that has no rigging, intelligence, or instancing baked in, and chop it into reusable parts that fit into the Natsura simulation pipeline. Same workflow regardless of the input type: photogrammetry from RealityCapture or Metashape, ZBrush or Blender sculpts, real-world scans, hand-modelled high-poly trunks.

The hero surfaces this produces are part of how Natsura handles Materials. For the step-by-step procedural-extension walkthrough, see Trunk Extension; for the broader story of where Natsura sits as a Houdini-native foliage engine, see the Overview.

Two routes through the workflow

Like Natsura's other major workflows, the high-poly toolkit supports both a high-level guided route and a granular step-by-step route.

High-level route: Import Highpoly with its interactive wizard. A single wrapper node packages the common scan-to-procedural-growth path. Press Enter on Import Highpoly and the wizard walks through loading the geometry, assigning textures, and picking the profile points where procedural extension will attach. From there a small chain of further nodes (Create Graft Mesh, Bake, Trunk Decoration) gets you from raw scan to extended hero trunk. This is the recommended starting point.

Granular route: the constituent scan utilities. Once the high-level wizard isn't the right shape for the task, drop into the individual scan utilities (Scan Material, Scan to Parts, Scan Profiles, Scan Rig, Scan to Tube, Scan to Patch). These are the same utilities the wizard composes internally and can be wired directly when you want control the wrapper doesn't expose.

What you can bring in

• Photogrammetry captures (RealityCapture, Metashape, similar).
• ZBrush or Blender sculpts.
• Real-world scans (LiDAR, structured-light, or other capture).
• Hand-modelled high-poly trunks.
• Branches, knots, and boles when the same hero treatment is needed for these parts.

Use cases

The workflow covers three primary use cases:

• Procedural growth from scans. A scanned trunk becomes the static base, and Natsura grows procedural branches and stems on top with a seamless stitch. The stitch is covered by the bake step, which produces tiling textures that blend at the boundary where procedural growth meets the static geometry. The comprehensive how-to lives at Trunk Extension.
• Module extraction. Parts of a scan are cut out and reused as modules. Static modules (knot holes, scars, bowls, tubular sections) can be scattered or instanced onto trees as decoration; whole branching sections can be rigged and turned into rigged components that go into the simulation directly. The constituent nodes for this path are Scan to Parts (selecting which parts of the scan to keep), Scan Profiles (identifying attach surfaces), and Scan Rig (rigging the extracted module).
• Tiling texture extraction. Tubular regions or square patches are extracted from the scan and turned into tiling textures, used for the boundary blend or as inputs to other materials. The constituent nodes are Scan to Tube (identifies a tubular section) and Scan to Patch (identifies a square region within a tube section), with Bake producing the final tiling texture. A patch is the right choice for extracting a specific bark feature (a knot hole, a scar, a textural detail), or for reducing a tube to a square texture region that integrates more easily with other materials.

The toolkit also provides remeshing, decimation, auto-UV, and trim operations on the imported geometry, plus tools to identify which parts of the scan are suitable for procedural growth.

Architecture

High-poly scans can crush the Houdini viewport. To work around this, the workflow uses a point-based visual representation of the mesh in the viewport. The high-poly geometry itself is never directly visible and is only operated on at the last moment of the cook.

Like Natsura's core system, the workflow defers execution. Instead of running each step immediately, it records a description of the operations to perform on the high-poly geometry, then executes the full sequence in a single pass when the cook resolves. This keeps memory usage low and the viewport responsive even with extremely high-poly inputs. The artist works on the point cloud representation; the workflow handles the underlying execution on the high-poly mesh.

The workflow has three layers:

• Core execution pipeline. Handles the deferred batched execution.
• Modular utilities. Individual processing nodes (scan material, scan to parts, scan profiles, scan to mesh, and so on).
• Artist-facing modules. High-level wizards that compose the utilities for common workflows.

The trunk workflow at a glance

The standard scan-to-procedural-growth toolchain is:

1. Import Highpoly. Bring the scan into Natsura. Press Enter on the node to launch an interactive wizard that guides the import process, or switch to advanced mode for manual parameter entry.
2. Create Graft Mesh. Remesh and prepare the region where procedural extensions will attach. The left input takes the imported high-poly mesh; the right (yellow) input carries profiles from Import Highpoly that mark where procedural extensions go.
3. Bake. Bake the high-poly textures onto the new mesh using Natsura's COPs-based texture baker. Outputs colour, height, and normals; supports up to 8k resolution and super-sampling.
4. Trunk Decoration → Grow. Pass the bake output into a trunk decoration that goes onto a grow, which can be further procedurally extended by other grows using a surface decoration.

The comprehensive end-to-end walkthrough lives at Trunk Extension.

When to use a custom trunk

Imported trunks beat pure procedural geometry when:

• The shot calls for hero quality and the scan or sculpt brings real-world fidelity that procedural noise cannot match.
• The reference is a specific real-world tree and the silhouette and detail need to match.
• AAA or close-up rendering: the scan-derived texture detail carries information that a procedural shader chain doesn't.

Pure procedural is the right call when:

• Mass forests with many distant instances where per-tree detail is below the threshold of visibility.
• Performance-critical real-time use where draw cost matters more than per-tree fidelity.
• Cases where the scanned trunk's silhouette is too distinctive to instance widely.

Related

The comprehensive how-to for the most common use case lives at Trunk Extension, and the Extend Scanned Trunks video walkthrough covers the same workflow on screen. For the individual nodes, see Import Highpoly, Create Graft Mesh, Bake, and Trunk Decoration.