Natsura Split

Creates explicit parallel branches in the growth graph. Distinct from innate forking, Split allows you to fork the topology into separate, distinct logical paths.

The Split node creates explicit branching in the graph topology.

  • Explicit Branches: Unlike "Forking" (which is an innate property of Grow driven by branch count), Split creates distinct, parallel outputs.
  • Parallel Execution: Each input connected to the Split node becomes a separate child branch spawning from the same point.
  • Control: Allows per-branch delay, depth incrementing, and attribute inheritance.

== Concept ==

=== Split vs. Fork ===

  • Forking (in Grow) is probabilistic and data-driven. It's best for scattering many similar branches (like twigs on a branch).
  • Splitting is structural. It's best for defining major architectural changes, like a trunk splitting into two main boughs, or separating the "Main Stem" logic from the "Side Branch" logic.

=== Depth Tracking ===

Split can increment the split_depth attribute, which is useful for limiting recursion depth or changing logic based on how many times the structure has branched.

Inputs

Input 0 -- Graph: The parent graph.

Input 1+ -- Child Graphs: Each additional input represents a new parallel branch.

Outputs

Output -- Graph: The combined graph with all branches merged.

Parameters

Overview

Concept

Split vs. Fork

Depth Tracking

Parameters

Global Settings

Delay Growth : Enables per-input delay controls, allowing branches to start growing at different times.

Generate Split Index : Creates a split_index attribute to identify siblings within the split.

Append Grow : A button that appends growth branches interactively.

Per-Input Settings

Delay : How many iterations/steps to wait before this branch starts growing.

Split Vertices : Physically separate the geometry vertices at the split point.

Increase Depth : Increments split_depth for this branch, useful for controlling recursion limits.

Stamp Parent Attributes : Copies attributes from the parent internode to the child branch.

Related

  • Grow Node — Has innate "Forking" (distinct from Split). The primary node for procedural growth.
  • Switch Node — Conditional branching (vs Split's parallel branching). Enables transitions between different growth behaviors based on attribute-driven thresholds.
  • Repeat Node — Reevaluates Grow over multiple iterations to generate branching hierarchies.
  • Signal Node — Guides plant growth using external data such as vector fields or collision geometry.
  • Simulate Node — Processes the procedural graph and environmental inputs to generate complete plant structures.
  • Prune Node — Removes components of the plant structure to simulate natural shedding or manual trimming.
  • Wrangle Node — Allows users to write custom VEX code for advanced procedural control.

@attributes

== Attributes ==

The Split node produces or modifies the following attributes:

  • split_index -- Integer ID for the branch (0, 1, 2...). Created when Generate Split Index is enabled.
  • split_depth -- Hierarchy depth, incremented at splits when Increase Depth is enabled.

@workflow

== Workflow ==

  1. Create a main growth path (e.g., a Trunk) using the Grow Node.
  2. Connect it to Input 0 of a Split node.
  3. Create a secondary growth path (e.g., a heavy Bough).
  4. Connect it to Input 1 of the Split node.
  5. The result is a graph where the Bough spawns from the end of the Trunk.
  6. (Optional) Add more inputs for additional parallel branches (e.g., lateral twigs, fruit stalks).
  7. Use Delay on per-input settings to stagger when each branch begins growing.

@applications

== Applications ==

  • Complex Plant Structures: Model trees, shrubs, or vines with realistic branching patterns.
  • Dynamic Growth: Adapt branching behavior to environmental inputs like light and collisions.
  • Artistic Designs: Create natural or stylized plant forms for landscapes, game assets, or simulations.
  • Architectural Branching: Define distinct trunk-to-bough transitions or main-stem vs. side-branch separation.

@notes

  • Interactive Workflow: Use the Append Grow button to dynamically add new branches in the scene.
  • Integration: The Split Node works seamlessly with other Natsura nodes for a unified procedural modeling approach.
  • Split vs. Fork: Use Split for major structural branching (trunk to boughs). Use Fork (inside Grow) for probabilistic scattering of many similar branches.

Natsura Simulate

The solver node. Traverses the Apex graph, executes growth logic, resolves mappings, and generates the final geometry.

Natsura Switch

Conditional branching node. Routes growth to different subgraphs based on attributes, thresholds, or mappings.