Node graph
The Graph Editor, node categories, Clump and the other main nodes, guide interpolation and its influence settings, strand attributes, masking with Groups, and animating parameters.
The guides define the overall shape of the groom. The node graph, edited in the Graph Editor, generates the render strands from them: how many strands there are, how they are interpolated from the guides, and the clumping, curl, frizz, width and color applied on top. To edit the graph:
- Open GroomLab > Graph Editor.
- Select a node and click Add Node (or press Tab) to insert a new node after it.
- Select the new node and adjust its parameters; the groom re-evaluates while you drag a slider.
- Press B over a node to bypass it and compare the result with and without it.

The groom list at the top of the Graph Editor is the Groom Tools' current groom: picking a groom in either one, or selecting a groom, moves both. The pin beside it keeps the editor on its groom while you groom another (The current groom).
In the app and in Blender
App: Tab or the Graph pill opens the Graph Editor over the viewport; Tab over it searches for a node to add. Click a node to edit it in Node Settings; Node List on the right rail lists the nodes. B bypasses, V is View Up to Here, Ctrl+D duplicates, Ctrl+C / Ctrl+V copy and paste nodes, F2 renames, Ctrl+L tidies, F and A frame. Ctrl+G groups the selected nodes into a Compound (GroomLab app).
Blender: Graph Editor in the GroomLab tab's Graph panel, or any node editor set to GroomLab Graph. Shift+A or Tab adds a node, and the editor's sidebar (N) > Node tab holds the Node Settings. V is Focus (View Up to Here), B or M bypasses, Ctrl+D or Shift+D duplicates, F2 renames, X or Delete deletes, F frames (Blender).
How it works
Strands flow from the scalp through the graph to the Output node. Scatter generates the roots, Interpolate shapes them from the guides, and the look nodes (Clump, Noise, Curl...) follow it.
- Add Node inserts after the selected node. Its menus list each category's nodes by name (Blend Neighbors, Hair Color, Linked Groom), with the node's description as a tooltip. Tab, or right-click on the canvas, opens a search by name, by what a node does (symmetry finds Mirror, density finds Scatter, frizz finds Noise) or by category; each result shows its category and a line of description.
- Connect nodes by dragging from an output port to an input port. Compatible ports are highlighted; an incompatible connection is refused, with the reason in the status bar.
- Pins: double-click a link to put a pin on it, then drag the pin to route the link (Unreal's reroute nodes). Drop a pin on another pin of the same output to bundle those links through one pin. Drag from a pin's right side to an input for another link of its signal; drop a link from an output on a pin to feed all of its links from there. Select a pin and press Delete to remove it. Snap in the top bar puts nodes and pins on the grid as you move them.
- Cut links by Alt+Shift+dragging across them, as in Maya's Hypershade: every link the line crosses goes, as one edit (Maya's Graph Editor).
- Live applies each edit as one undo step.
- V displays a node's result in the viewport instead of the Output's; B bypasses it.
- Ramps (root-to-tip profiles) have a curve editor.
- Units: lengths are shown in cm, widths in µm, densities in strands per cm² (... > Units). Internally all lengths are in scene units, which GroomLab keeps in centimeters in Maya.
- Node status sits on each node's title row, beside its header toggles: how long it took the last time it ran (grey, yellow from 10 ms), and a yellow warning triangle on a node that has no effect with its current settings (a Clump with no centers, an Instance whose mesh is missing): hover the node for the reason. A bypassed node is faded and its wires are dashed. In the Charcoal theme the headers are filled with the node's category color.
- Node actions sit at the top of the node's settings, above its parameters, and stay there however far the parameters scroll: a Cards node's bakes and exports, a Simulate node's Simulate Range, Bake Simulation and Clear Simulation, a ToGuides node's Bake Node to Guides..., a Sculpt node's Clear Sculpt Edits, a compound's Ungroup and Save as Node.... The app and Blender show the same ones at the top of their node panels.
Node categories
| Category | Nodes | Purpose |
|---|---|---|
| Sources | Scalp, Guides, ColliderMesh, ImportCurves, Linked Groom | Inputs: the scalp mesh, guide groups, collision meshes, external curves, other groom files. |
| Grow | Scatter, Interpolate, Cull | Generate roots, interpolate strands from the guides, remove strands. |
| Shape | Length, Width, Resample, Direction, Flow, Part, Smooth, Mirror, RestoreLength, Sculpt, Subdivide | Length, width, points, direction, flow, parts, smoothing, symmetry; brushable guides; smooth strands from few points (Subdivide: put it last; while you drag a param the viewport skips it, so the drag previews on the GPU, and the release smooths again). |
| Deform | Bend, Transform, BlendNeighbors, Gravity, Displace | Bend and move strands; gravity and volume. |
| Collide | Collide, SelfCollide, MeshCut | Collisions with meshes and between strands; cuts by a mesh. |
| Look | Clump, Twist, Braid, Noise, Curl, Flyaway, Static, Tangle, Wet, Instance, Scales, Spectrum | Clumping, locks, braids, frizz, curls, strays, static and wet hair; meshes and scales along strands. |
| Motion | Wind, Jiggle, Simulate, GuideCache, DriveGuides | Procedural motion, guide simulation and guides simulated in another package (Motion & simulation). |
| Feathers | Propagate, Plume | Feathers grown from shafts and layered over the body (Fur & feathers). |
| Color | HairColor, Bands, FeatherColor, RenderData | Hair color, banded fur, feather patterns (Color patterns); opacity (Rendering). |
| Convert | ToGuides, ToStrands, ToMesh | Convert strands to guides and back; the groom as a live polygon mesh. |
| Fields & Curves | Map, Expression, Control, FieldNoise, FieldRemap, FieldCombine, Layers, ColorLayers, Curve | Drive parameters from maps, images, expressions or sliders. |
| Utility | Value, Group, Blend, Attribute, Merge, Switch, Split, Output | One value for any param, strand masks, custom attributes, blending and combining branches, variants, routing strands to four outputs. |
| Games | Cards | Game hair cards (Game export). |
Random values are seeded from each strand's stable ID, so a groom evaluates identically on every machine and with any number of threads, and a strand keeps its random values at any preview density.
Clump
Clump pulls strands toward clump centers. Main parameters:
| Param | Effect | Typical |
|---|---|---|
strength | Pull toward the center, mappable. Negative values push strands away (fur parting around whiskers, horns, eyes): strands within twice repelRadius (advanced) move out, those at the center to repelRadius, keeping their order so none cross at the part. | 0.5-0.9 |
centersFrom | Source of the clump centers: pick places them on the scalp where strands grow, as many as clumpBy asks (tens of thousands on a dense groom), each clump's axis the hair grown nearest, moved to its center; inputPoints or inputCurves take them from the centers input (see below). A Clump saved by an earlier GroomLab, and the shipped presets' Clumps, keep picking among the strands (a few thousand at most) until you upgrade the node. | pick |
clumpBy, count, size | With pick: about count clumps, or (clumpBy size) clumps about size apart, so a body gets more clumps than a head at the same clump size. | 300 clumps |
randomness | 0 distributes the centers evenly, 1 places them at random. | |
volumize | Each clump's volume: its strands gather into a round lock this thick around the center instead of onto it (dreads, wet strings, stylized locks); each strand keeps its place around the lock, so strands never cross in it. Mappable. Add a Twist after it for ropes. | 0 |
volumizeProfile | The volume along the length, root to tip, times volumize: a lock fuller at the root and tapering to its tip, or swelling midway. | flat 1 |
volumizeRandom | Each clump's volume up to this share bigger or smaller, at random per clump. | 0 |
flatness, flatAlong | Flattens each clump into a ribbon (wet hair), lying along the scalp, at random or along flatDirection; the ribbon turns with the clump without spinning. | 0 |
strengthRandom, copyAmount | Randomize each clump's strength; copy neighboring clumps' shape (the 4 nearest, weighed by distance, with no pops as clumps move) so adjacent clumps share one flow. | 0 |
strandStrengthRandom | Each strand's pull weakened by up to this share, at random: some strands hug the clump, some hang loose (Yeti's weightRandom). | 0 |
pastTip | How a strand lies along its clump's axis: fit tip to tip, so it takes the axis's length as much as it clumps; or extend, keeping its own length and carrying on past a shorter axis's tip. | fit |
clumpChannel | Per-strand attribute that receives the clump index (clumpId). Chained Clumps should each use their own; Twist, Cards and HairColor's clumpShare read the one named by their own clumpChannel. | clumpId |
followTubes | With pick, for strands filling tube guides (Interpolate's fillTubes): each tube picks its own centers among its strands, as far apart as clumpBy says, and a strand clumps only toward its own tube's, so clumps stay inside the tube and flatten, twist and taper with it. With centers given (inputCurves, inputPoints, such as a Guides node handing a tube hierarchy's level 2 guides), each center belongs to the tube it is rooted in, and a strand clumps only toward its own tube's center, never a neighbour tube's; a strand whose tube has none, or that is rooted in no tube (a seam between roots), clumps toward the centers of its level-0 tube (Interpolate's tubeBase: the root outline holding it, else the nearest), so none is left unclumped and none crosses into a neighbour's clump. This follows the drawn root outlines, not the painted region map, so a coarse scalp does not matter. Where neighbouring roots overlap slightly at a shared edge, a strand there belongs to the root whose outline it lies furthest inside. Centers given as guides follow the smooth curve through each guide's points, as Interpolate does, not the straight chords between them. Strands in no tube clump as usual. No effect on strands without tubes. | on |
Custom clump centers. Connect strands or guides to Clump's centers input: a low-density
Scatter, a guide group or a ToGuides node. Connecting centers sets centersFrom to
inputPoints.
inputPointsuses only the root positions of the centers. Each clump's axis is the interpolated strand grown at that position (like XGen's clump guides), so short spikes from a Scatter can place clumps on long, bent hair.inputCurvesuses the center curves themselves as clump axes (groomed clump curves, like Yeti's clump input). A Noise on the center curves moves each clump as a unit.
Multi-level clumping: chain Clumps from small to large. The small clumps form first and the
large ones move them as a whole (cinematic_hair and everyday_sim do this). In the opposite
order, the small clumps pull strands across the borders of the large ones.
Displaying the centers: V on a Clump shows its result with the centers drawn as dots on the scalp.
To keep strand lengths after clumping, add a RestoreLength after the Clump with its
reference input connected to the Clump's input. To let a few strands escape their clump, drive
strength per strand with an expression of rand.
Other main nodes
| Node | Effect | Main params |
|---|---|---|
| Length | Trims strands. Each keeps keep of its length; a fraction of them loses a random share up to randomness, for uneven ends. To lengthen strands, use Transform's scale. | keep, fraction, randomness |
| Direction | Sets the strand direction at the root by inclination (degrees from the scalp normal: 0 is straight out, 90 is flat) and roll (degrees around the normal). | inclination, roll, strength |
| Bend | Bends strands toward the scalp normal (negative: down onto the scalp), the scalp's U direction or a world direction, between start and end along the length, without bending past it. With start and end at 0 it raises each strand at the root, for root volume. With along direction, the direction is projected onto the scalp, so angle 180 combs every strand that way; direction can also be a per-strand vector expression. | angle, along, start, end |
| Transform | Translates, rotates and scales each strand about its root, or the whole set about a pivot. | scale, scaleRandom |
| Collide | Pushes strands out of the scalp and of collision meshes (Pick on the Colliders row, or a ColliderMesh node), offset above the surface. softness is a length along the strand: hair starts curving that far before it meets a collider and then slides along it instead of folding flat. It applies to colliders only, not the scalp; 0 gives a hard projection. Place it last. | offset, softness |
| SelfCollide | Resolves hair-hair interpenetration as a volume constraint: where hair is packed denser than packing (the fraction of space hair may fill) allows, it is pushed apart, so layers rest on each other and volume builds up behind the ears and at the crown. Hair below that density is not moved, and nothing is pushed into the scalp. Lower packing for more volume. Place it near the end, after the shaping nodes. It works on strands; cards (the Cards node) are kept apart by the Cards node's own Separation. | strength, packing, profile |
| Static | Electrostatic repulsion between strands: the outer layer puffs out, tips lift away from the head, and clumps fray into single strands. The charge increases toward the tips (profile); randomness lets some strands move farther. | strength, randomness, profile |
| Sculpt | Brushable procedural guides: place it after a ToGuides (dense guides interpolated from your sparse ones), select it in the Graph Editor, and the shaping brushes edit its guides. Edits are stored as bends and length changes along each guide, so upstream changes (combing the sparse guides, changing density) are applied under them. Clear Sculpt Edits at the top of its panel removes them. | strength |
| ToGuides | Converts strands to guides mid-graph: interpolate dense, even guides from a few hand guides (Scatter + Interpolate, then ToGuides) and feed them to a second Interpolate, to Clump's centers or to a Sculpt node. color sets their display color while brushing. | fraction, color |
| ToMesh | Passes its strands on unchanged and builds a polygon mesh of what it receives. make auto picks the scales when there are some, else instances, else cards, else feathers, else the strands; strands makes tubes (sides around) or flat ribbons, scales the scales' plates bent onto the skin (as quads), feathers the barbs as tubes or ribbons plus the rachis, cards a Cards node's cards (quads, in one atlas), instances an Instance node's meshes where they sit. The mesh follows the animation (a tube mesh keeps a fixed vertex and face count). Its position in the graph decides what the mesh shows. The groom draws the mesh in place of the strands (Show mesh switches back). Mesh in Scene makes a Maya mesh on the groom's outMesh, to sculpt, model or cache; Export Mesh... writes this frame as OBJ, FBX or Alembic, for ZBrush, baking or printing (Utilities). density and maxStrands keep a tube mesh light. | make, style, sides, widthScale, maxStrands |
| Part | Opens the hair at parting lines: hair near a part turns away to its side. partsFrom painted uses lines drawn with the Part tool; auto detects parts where the hair splits to both sides of a line (a parting combed into the guides). splitAngle sets the minimum split angle; minLength discards short ones, such as a whorl's center. | partsFrom, width, strength |
| MeshCut | Trims strands where they intersect a mesh (a ColliderMesh): outside for an obstacle, inside for a haircut hull. | keep, offset |
| Curl | Helical curls, planar waves, zigzags (kinky hair) or tight coils. frequencyProfile varies the curl frequency along the strand, spacingRandom varies the spacing between turns, and coherence clump curls each clump as one (ringlets). weight simulates curls stretching under their own weight: turns spread apart near the root, where more hair hangs below, and stay tight at the tip. Only hair hanging along weightDirection (down by default) stretches. | shape, radius, frequency, weight |
| Noise | Random displacement. Applied to a fraction of the strands at high frequency, it gives frizz (mode kinky for sharp kinks). | amplitude, frequency, fraction |
| Wet | Wet hair in one node: small clumps near the root merge into larger clumps toward the tip, each small clump nested inside one large clump. wetness sets the amount (animate it to dry the hair); clumpSize is the spacing of the largest clumps, levels the number of nested clump sizes. It also writes a wetness attribute that darkens the shading and raises the gloss in the viewport, the app and Arnold. | wetness, clumpSize, levels |
| Smooth | Removes bends from strands, keeping roots and lengths. scale is the wavelength it removes, as a fraction of strand length: small values remove kinks, 1 straightens the whole strand. The result does not depend on point count. | strength, scale |
| Scatter | Generates roots on the scalp. density is in strands per unit area (shown per cm²). layout uvGrid places one root per cell of a UV grid (rows of fur, scale tracts). previewAll keeps every root in the viewport regardless of preview density, for a small number of large elements. length is the length of the straight strands it grows; an Interpolate after it gives them the guides' shapes and lengths, so with guides it only shows where no guide reaches (trim with the Length node). Past 2M strands the node notes it is heavy (a human head has about 100-150k hairs); past 50M it stops with an error. | density, randomness, layout |
Curl is defined on the strand's curve, not on its points: 40 or 256 segments give the same curl, and Curl inserts points where a turn would otherwise be undersampled.
Interpolate and guide influence
Interpolate builds each strand from the guides near its root. Each guide's offsets from its root are transported to the strand's root (rotated from the guide's root normal to the strand's) and blended with weights that fall off with distance, then the blended curve is resampled to the strand's point count.
Which guides are used. Interpolate uses whatever its guides input delivers. In the default
graph that is a Guides node with level -1, which delivers each family's deepest groups:
where a group has child guides, strands interpolate from the children, and its primary guides
drive the strands only through them; a group without children (or whose child groups are empty)
delivers its own guides. Scatter's guideRadius grows hair around every level of those groups. Set the Guides node's group (one or more group names)
to choose groups explicitly, or exclude to leave groups out (for example braid paths). Guide
visibility and the freeze mask do not affect interpolation.
How the weights are computed. Every guide has its own influence radius, its reach: 1.5
times the distance to its neighbors-th nearest other guide (scaled by smoothness: 1 to 3 times). Guides are therefore wider where
they are sparse and narrower where they are dense, without a global radius to tune. For a strand
at distance d from a guide of reach R, the guide's weight is the modified Shepard term
(R - d) / (R·d) (zero at the edge of the reach), divided by the largest such term among the
strand's guides, raised to a power (2, scaled by smoothness: 6 sharp to 1 soft), and finally
normalized so the weights sum to 1. Distances
are in scene units, measured between root positions on the scalp's rest pose (along the skin with
followSurface, see below), never in UV space.
A strand outside every guide's reach is still interpolated: near the outer 25% of the reaches the
blend crossfades to plain inverse-distance weighting over its nearest neighbors guides, so no
strand is left unguided. To leave strands far from guides unaffected, use limitDistance.
| Param | Default | Effect | When to change it |
|---|---|---|---|
smoothness | 50% | How softly the guides blend into one another, the one control most grooms need: 0% is sharp (each strand mostly its nearest guide: crisp locks with soft edges), 100% is soft (each guide reaching twice as far, its neighbours blended evenly). At 50% the weights are exactly as neighbors, reach and power set them; it scales reach (by 2/3 at 0%, 2 at 100%) and power (by 3 at 0%, 1/2 at 100%). Hidden when neighbors is 1. | Lower it for stylized, separated locks; raise it for soft fur or sparse guides. |
guideWeight | 1 | How strongly each guide pulls the strands around it against its neighbours, read at the guide's root (mappable). Paint it with Groom Tools > Paint > + New Map > Guide weight, or plug in any map: where it is black the guides give way to their neighbours, and a guide weighed 0 shapes only the strands no other guide reaches. A number alone changes nothing (every guide weighed alike). A painted guide layer works too. Hidden when neighbors is 1. | Stop a stray guide from bleeding into its neighbours' hair, or let the key guides of a style dominate the ones around them. |
neighbors | 3 | Advanced. Sets each guide's reach (to its n-th nearest guide, times 1.5 scaled by smoothness) and so how many guides blend into a strand. 1 takes the nearest guide only, with hard edges between guides (Voronoi cells). Range 1-16. | Raise it for smoother blending over sparse or uneven guides; 1 for stylized, cleanly separated locks. |
limitDistance | 0 | Maximum distance (scene units) from the nearest guide root at which guides have any influence. Strands farther away keep their incoming shape (for example from a Flow node). 0 disables the limit, and falloff and influenceChannel are then unused. | Guides only for tufts or accents on otherwise flow-groomed fur, within a radius of each guide (to paint where instead, see the flow_with_guides preset: a Blend by a painted map). |
falloff | linear 1 to 0 | With limitDistance above 0: influence as a function of distance, from the guide root (left) to limitDistance (right). Between 0 and 1 the strand is a blend of its incoming shape and the interpolated one. | Shape the transition between guided and unguided areas. |
influenceChannel | guideInfluence | With limitDistance above 0: per-strand attribute that receives the influence, 0-1 (empty: not written). | Mask later nodes (Affect) by how strongly the guides apply. |
take | shape | shape takes the guides' shape and length. length keeps each strand's incoming shape and only scales it to the blended guide length. | length for fur shaped by Flow or Direction, with guides used only to paint length. |
blend | directions | How the guides' shapes combine. offsets averages their points: guides pointing different ways pull the strands between them in (preserveLength scales them back as a whole). directions builds each strand segment by segment, along its guides' average direction at their average length, so strands between guides pointing apart (a parting, a cowlick) keep the guides' length and curve smoothly from one side to the other. Where guides nearly cancel out (more than about 120 degrees apart) directions eases the strand's segments down as offsets does, so no strand flips. Shown with take shape. Interpolate nodes saved before GroomLab 0.34 keep offsets (Upgrade switches them). | offsets to match grooms made before, or for its softer transitions where guides point against each other. |
preserveLength | on | Rescales each blended strand to the weighted mean length of its guides (blending guides that point in different directions would otherwise shorten it; at most 2x). | Turn off to see the raw blend. |
keepClearance | on | Keeps strands out of the skin: where the skin bulges more under a strand than under its guides (an ear, a cheek, the neck), the part that would sink in is lifted just onto the skin with its length kept, and past the bulge the strand eases back to its groomed path, so hair drapes over an ear instead of standing off it. Needs the scalp input. | Leave on; use a Collide node only for other meshes (shoulders, a collar). |
followSurface | on | Measures distances along the scalp surface instead of in a straight line, so a guide does not influence strands across an ear, a fold or a thin shell. Also transports guide shapes across the curved scalp, so hair combed back stays combed back over the whole head. | Leave on; turn off only on flat or open scalps where straight-line distance is wanted. |
respectParts | on | Ignores guides on the other side of a part line drawn with the Part tool. If every candidate guide is across a part, all are used. | Leave on whenever parts are drawn. |
regionMap | empty | A guide map (each value a region) or a color map on the scalp (each color a region), by name or from a Map node plugged into it. Each strand blends only its own region's guides (see Regions). On a color map a guide's region is read at the root of the guide its hierarchy starts from, so a tube's split tubes and children share its region. | Hard separation between areas, such as bangs and sides, or modeled tubes (Tubes to Curves sets it). |
followBends | 0% | How much each strand's place round its guides turns with them as they bend and curl. At 0 each strand is a copy of its guides moved over to its root, so a lock bent over or curled flattens into a ribbon; at 100% its offset from each guide is carried along the guide's bends, so the lock keeps the section it has at the roots (strands on the outside of a bend grow longer, as in a tube). Paintable. | Stylized locks and curls that should stay round; a Clump's volumize after it rounds them further. |
regionChannel | region | Per-strand attribute that receives the region index (-1: none). | Rename it when several Interpolates write regions. |
fillTubes | off | Fills the guides' tubes: a strand rooted inside a guide's tube keeps its place in the tube's cross-section from root to tip, so it stays inside the tube as it flattens, twists and tapers, and is as long as the guide. The tubes of every guide level fill (the deepest wins where they nest), whatever level the Guides node hands over; a strand rooted in a level-0 tube is filled only by that tube's own deeper tubes, never a neighbour's. Where tubes of one level overlap, the strand takes the tube it lies most centrally in. Strands rooted in no tube are interpolated as usual. Writes tubeId, tubeU and tubeV (CPU only: the GPU preview hands it to the CPU). During a brush stroke each strand keeps its tube from dab to dab, and only the strands of the tubes a dab changed are blended again (with Clump's followTubes, only theirs clump again); releasing the stroke finds every strand's tube anew. | Anime and cartoon hair: locks shaped as a whole (the Shape brush, set_tube). |
tubeBlend | 25% | With fillTubes: the tubes' soft edge, as a share of each tube's half-width at its root. Strands rooted outside a tube but within this of its outline lean from the guides' blend toward riding the tube (all the way at the outline, none at the edge of the band), so no seam shows; strands past it are as without Fill Tubes. 0: a hard edge. | Raise it when the edge of a lock still shows; 0 for a crisp cut-out lock. |
Per-guide attributes and painted guide layers are interpolated as well: each becomes a strand attribute (or a per-point attribute, for layers painted along the guides) of the same name, with the same weights. With no guides at all, Interpolate passes the strands through unchanged and reports it.
Regions
To keep groups of hair separate, give each its own region and set Interpolate's regionMap. Each
strand then blends only its own region's guides, and reaches are computed within each region,
which gives a hard edge between regions (a part along an area rather than a line). The regions can
come from the guides or from the scalp.
On the guides (a guide map). Each value painted on the guides is a region: fill each group of guides with a value of its own (Groom Tools > Paint, a guide map, Fill Selected). Each strand is in the region of the guide rooted nearest it, so every strand has a region and two regions meet halfway between their guides; nothing is painted on the scalp. Tubes to Curves makes such a map for modeled tubes (tubes, a value per tube) and sets it on the Interpolate, so each tube's hair comes from that tube's guides alone.
On the scalp (a color map). Paint the areas in a different color each (for example red for the bangs, green for the sides, blue for the back).
- Colors within an RGB distance of 0.1 count as one region. A strand on a soft-painted edge joins the nearer region color, so soft paint needs no cleanup; use distinct colors, since a mix of two colors reads as the edge between them.
- A painted area with no guide rooted in it uses the nearest guides of any region.
Name the map in regionMap, or plug a Map node into it (expose regionMap as an input): a Map node
of a guide map gives the guides' regions, any other map its colors. A scalp map can also be a color
set on the scalp or an image file read at the scalp's UVs.
- Clump, BlendNeighbors and Tangle read the region attribute (their
regionChannel) and stay within regions too. - To display the regions, color the strands by clump with
regionas the source (in Maya's Attribute Editor: Display > Strand Color Mode Clump, Sourceregion).
Mappable parameters
The Map button beside a value switches it to a texture, a color set, a strand attribute, an expression or a painted map. Right-click a parameter for Paint (Painting maps) or Drive with Slider, which adds a Control node and a keyable attribute on the groom. For the expression language, see Expressions.
Connecting an input never hides a parameter; visibility only depends on the node's own menus
(Clump's count is shown when clumpBy is count, for example).
Some nodes have several output ports, along their right edge. Map has luminance, r, g,
b, a and rgb, so one packed map can drive clumping from R and frizz from G, and rgb, the
map's color, can drive a color param: expose HairColor's color, dye or tipColor (right-click
the param > Expose as Input; also Bands' dye and undercoatDye, FeatherColor's dye and
downColor) and link rgb to it. Each strand takes the map's color at its root, times the
param's own color (white: the map as it is). A number param linked to rgb reads its luminance.
Layer stacks
Layers stacks up to 8 layers into one field, the way a paint program's layer panel does, and ColorLayers does the same with colors. Layer 1 is the bottom. Each layer has:
- On: leaves the layer out without losing its settings.
- Mode: how it combines with the layers below it. The modes are normal, multiply, add, subtract, screen, overlay, darken, lighten and difference.
- The layer's value (a number for Layers, a color for ColorLayers).
- Opacity: how much of it shows.
Raise Layers to add a layer on top. A new layer starts clear (opacity 0), so adding one changes nothing until you raise its opacity or link a mask to it. The panel lists the top layer first.
The value and the opacity both take fields. Expose a layer's value (layer2) and link a Map, a
FieldNoise or an Expression to make the layer that map. Expose its opacity (layer2Opacity) and
link a painted mask to show the layer only where you painted. By default layer 1 is black and the
rest are white, so a mask on layer 2's opacity gives the mask itself.
Link the stack's output to any mappable param, or ColorLayers' rgb to a color param such as
HairColor's color. Example: a brown base with a red layer on multiply, masked by a painted map,
gives red streaks where you paint.
Split routes
strands to outputs a to d, by fraction or by a painted map.
Exposing parameters
Every parameter can become an input on its node: right-click it > Expose as Input (in the app, right-click the row). The port it gets depends on the parameter:
- Field port (per strand): mappable numbers and colors that take a color map. A field node (Map, Expression, FieldNoise, Control...) gives each strand its own value, times the parameter's own value.
- Curve port: ramps. A Curve node gives the shape.
- Value port (one value for the whole node): everything else, such as counts, seeds,
switches, choices, vectors, colors, text and plain numbers like Clump's
size. The linked value replaces the parameter's own, which the panel shows as "driven by".
A Value node (Utility) gives one value: a number, integer, switch, vector, color or text. Text
feeds a choice by name, for example guides for Clump's centersFrom. An Expression node with
output set to value gives one number from frame, time and its own variables, for example
$base + frame * 0.01. Per-strand variables, channels, maps and rand() are errors there,
because there is no strand to read.
Rules:
- Numbers, integers and switches feed each other. An integer rounds, and a switch is on above 0.5. A number also feeds a vector (every component) and a Field port (the same value on every strand).
- A vector feeds only a vector or a color. Text feeds only text or a choice, and must be one of the choices.
- A Field output never feeds a Value port. Per-strand data cannot set a value the whole node shares.
- A parameter that cannot be keyed (counts, densities, segments, seeds) accepts a Value port, but only if the value is the same on every frame. An expression that reads the frame, or a keyed Value node, makes the node report an error.
- The parameter keeps its own value in the saved graph. Cutting the link brings it back.
- A few parameters set the node's own ports and cannot be inputs: a Value node's
kind, an Expression'soutput, an Input node'snameandtype, and a Compound'sdefinition.
Inside a compound, an Input node of type Value makes a Value input on the compound. A
compound's exposed parameters can also be exposed as inputs on the compound node, as Value ports.
Attributes
Strands carry named float values, attributes (also called channels), from node to node. An
attribute is either per strand (one value per curve) or per point (one value per vertex). Some
nodes write one (Clump writes clumpId; Interpolate, Wet, Blend, Flyaway, Group and the
Attribute node write their own), and later nodes read it by name: Curl, Twist, Cards and
HairColor's clumpShare read a clump attribute to treat each clump as a unit, Clump reads
regionChannel to clump within a region (and tubeId to clump within a tube), and maps and
expressions can read any attribute.
The Attribute node writes a custom per-strand attribute: name is the attribute name and
value the value, a constant or any map (a painted mask, a texture, an expression such as
rand(0.2, 0.8) for a random value per strand). Attributes reach renderers and exports by
name; see Strand attributes for what each output carries and
how to read it in a shader.
The editors indicate which parameters read and which write. A parameter that writes shows
Writes and a name field, with a warning when it overwrites an attribute written upstream. A
parameter that reads shows Reads and lists only the attributes available at that node, with
the node that writes each; a name that nothing upstream writes gets the warning triangle. Give
chained Clumps different names (for example lockId, then clumpId) so later nodes can choose
which one to follow.
Restricting a node to some strands
Nodes that reshape or recolor strands (Noise, Clump, Bend, Gravity, Curl, HairColor, Width...)
have Affect under Common: a per-strand blend between the node's result (1) and its input
(0). Map it like any parameter: to a painted map, an expression such as $y > 0, or a Group.
A Group node writes a per-strand mask attribute named after the group (1 inside, 0 outside,
in between on soft edges). Membership is defined by the roots (or tips) inside a sphere or a
box with an optional soft falloff, by a value (a map, an attribute or an expression)
passing a threshold, or by proximity to the guides of named guide groups (blended from
the 4 nearest guide roots). combine adds to, subtracts from or intersects with an earlier
group of the same name. For example, to frizz only the crown:
- Add a Group after Interpolate: by sphere, centered on the crown, named
crown. - On the Noise after it, set Affect > Map > Attribute
crown.
Nodes that add, remove or resample strands (Scatter, Cull, Merge, Resample, Mirror, Cards...) have no Affect parameter.
Blending two looks
Branch after Interpolate into two looks and join them with a Blend node. Its mix (0: input
a, 1: input b) multiplied by its root-to-tip profile blends the shape and, with a HairColor
in each branch, the color. Set include to shape to blend only the shape. Drive mix with a
slider or a painted map to animate or paint it (the blend_two_looks preset). A plugged map is
multiplied by mix (1 by default), so with mix at 1 the map alone sets the blend. keepLength
(advanced, on for new Blend nodes) blends each segment's direction and length from the root, so a
strand midway between a curly look and a straight one keeps its length; Blend nodes saved before
GroomLab 0.34 blend the points.
Animating parameters
Numbers, enums, toggles, vectors and colors can be keyed directly in the node editor, as in Maya's Channel Box.
- Set Key: right-click a parameter > Set Key, or press S with the mouse over it. The
first key creates a keyable attribute on the groom,
ctl_<node>_<param>. - Colors: red means a key on this frame, pink animated without a key on this frame, yellow driven by a Control node or a connection.
- Curves are ordinary Maya animation curves: edit them in the Graph Editor or Dope Sheet (Select Attribute selects the groom with the attribute).
- Delete Key removes the key on the current frame; Remove Animation deletes all keys and keeps the current value.
- Not keyable: parameters that set the number of strands, points or cards, or where they are placed (densities, counts, segments, seeds). These must stay constant over time so that motion blur and caches see the same topology on every frame. Set Key is disabled for them, with the reason.
- Renders and exports, including farm renders, evaluate the keyed values on every frame.
groomlab.set_param_key(groom, "clump", "strength", value=0.2, time=1)
groomlab.set_param_key(groom, "clump", "strength", value=0.9, time=24)
groomlab.remove_param_animation(groom, "clump", "strength")Several scalps
A groom can grow on more than one mesh: separate ears, a head and a body, eyebrow patches.
- In the groom's Attribute Editor, Inputs, click Pick on the Scalps row.
- Click the mesh in the viewport or the Outliner (
groomlab.add_scalp(groom, mesh)).
GroomLab adds a Scalp node reading that mesh, its own Scatter and Interpolate, and a Merge
into the groom's strands. A Scalp node's input names the scalp it reads (scalp is the groom's
own). Guides, brushes, parts, flow and painted maps work across all scalps, and every host and
renderer supports them.
Linked Groom node
A Linked Groom node reads the strands of another groom file, or its guides (second output): an
eyebrow or fur patch groomed once and reused in other grooms. Merge it with the groom's strands.
Its type is still Reference in .groom files and the Python API.
path: the.groomfile, resolved like a map's file (next to the scene or groom file, then the search paths). It is re-read when the file changes.bind:worldkeeps the strands where they are in the file;closestPointre-roots each strand at the closest point on this groom's scalp, rotated with the surface;uvre-roots it at its root UV, for scalps that share a UV layout.- A missing file, or a file that references itself, is reported as an error naming the file.
Subdivided scalps
When the render subdivides the head (Arnold subdivision) or you view it smoothed (Maya's 3 key),
hair grown on the cage would float above or sink into the smoothed surface. The Scalp node's
subdivision refines the scalp the same way: matchRender (the default) uses the mesh's Arnold
subdivision iterations, or else its smooth preview level; off uses the cage as is; 1 to 3
set the level. Roots, guides, maps, collisions and simulation all use the subdivided surface, and
the root layout does not change: toggling the smooth preview keeps the same strands in the same
clumps. ColliderMesh has the same parameter.
Viewport-only and render-only nodes
Right-click a node > Evaluate:
- Always: the default.
- Viewport Only: renders and exports pass its input through. Use it for a cheap stand-in while working.
- Render Only: the viewport passes its input through. Use it for expensive nodes (Collide on a dense groom, Tangle) that only the final strands need.
The node shows a tag, and the setting is saved with the groom.
Reuse
- Compounds: select nodes and press Ctrl+G to collapse them into one node, then show the parameters you need (right-click > Show Inner Param). Ctrl+Shift+G (or right-click > Ungroup Compound) expands it again.
- Compound nodes: right-click a compound > Save as Node... to keep it in your node library: it then shows in Add Node in every groom, in the app and Blender too, and shares as one file. See Custom nodes.
- Script nodes: Add Node > New Script Node makes a node of your own from a short script (per strand and per point, with parameters of its own), edited live in the side panel. See Script nodes.
- Presets: the Presets menu holds complete looks and small example graphs that each show one technique; Save as Preset... saves your own. See Presets.
- Copy Graph to Other Grooms... (Utilities) applies one graph to several grooms.
- Copy Graph and Paste Graph copy a whole graph as JSON text, to paste in a chat or save
as a
.jsonfile (Presets).
Number fields
Every number in GroomLab's panels (the node settings, the Groom Tools, the app's Properties) is one field with its name inside and its value on the right, filled to where the value sits in its range:
- Drag across it to scrub, relative to where you pressed: Shift for fine steps, Ctrl for steps of ten.
- Click it to type a value: a number or simple arithmetic (
0.5*2,1/3; a comma works as the decimal point). Enter, Tab or clicking away keeps it; Esc puts the old value back. - With the field focused, Enter (or F2) starts typing and the arrow keys nudge the value (Shift: ten steps).
- A typed value may go past the field's range (dragging stays inside it). In Maya, right-click the field to fit, set or reset its range.
Blender's own number fields work the same way, with Blender's keys.
Ranges and versions
Every numeric parameter has a slider range, and hard limits where values outside them are meaningless (a 0-1 fraction, a count); typing a value past the slider range extends the slider. Saved grooms store every parameter and each node's behaviour version. During early access a parameter can still be renamed or replaced between releases (What's new lists those changes and the values to set); after early access, updates will not change the result of a saved groom.
Guides & brushes
The guide hierarchy (primary and child guides), tube guides (shaped tubes and Fill Tubes), guide groups with show/hide and color, freezing and soloing guides, the grooming brushes and their settings, and how a groom scales with its scalp.
Presets
The shipped graph presets (hair, fur, feathers, scales, motion, techniques, add-ons), how they scale to your scalp, inserting a preset as a compound, saving your own and sharing a graph as text.