GroomLab

Motion & simulation

Procedural motion with the Wind and Jiggle nodes, guide simulation with the Simulate node, follow-the-scalp evaluation, nHair in Maya, guide caches from other packages, and shot correctives.

A wolf's fur in a looping wind over several frames
Wind looping over 48 frames

There are three ways to animate a groom, from cheapest to most expensive:

  • Wind and Jiggle nodes: procedural motion computed per frame, with nothing to cache.
  • The Simulate node: dynamics on the guides, identical in every host.
  • An external simulation (nHair, Houdini) imported as a guide cache.

On an animated character, also turn on Follow Scalp: the groom is evaluated once on the rest pose and carried by the skin, which makes playback, caches and motion blur much cheaper.

In the app and in Blender

App: add Wind, Jiggle or Simulate with Tab in the Graph Editor. An animated groom shows a timeline at the bottom (play, scrub, loop); Follow turns follow-the-scalp on or off. With a Simulate node the timeline has Simulate, Bake and Clear; while it runs, Simulate reads Cancel. The Groom Tools' Correctives tab holds the shot fixes. nHair and keys on params are Maya's (GroomLab app).

Blender: Wind works. Jiggle and Simulate are not supported yet: Jiggle passes the strands through and Simulate isn't fed the scalp's motion. Follow Scalp is on by default. Correctives are not in Blender yet (Blender).

Procedural motion

Two nodes (Add Node > Motion) animate the groom without simulation or caching. Each frame is computed from the time and the scalp's last few frames, so frames can be evaluated in any order, rendered independently on a farm, and always give the same result.

NodeEffectMain parameters
WindBends strands in a gusting wind field that travels over time.direction, strength, gust, frequency, speed, turbulence
JiggleStrands lag behind the head's motion, overshoot when it stops, and settle.strength, frequency, damping, history
  • Play the timeline to see them.
  • Both keep roots and segment lengths, and work on strands or guides.
  • Bypassing (B) or deleting either restores the groom exactly.
  • Their parameters can be keyed like any other (right-click > Set Key, or S over a field), for example a wind that picks up or changes direction (direction is keyed as X, Y, Z). See Animating parameters.
groomlab.add_wind(groom, direction=(1, 0, 0), strength=0.3)
groomlab.add_jiggle(groom, strength=1.0)

Looping animation

Turn on loop and set loopStart and loopEnd (in frames) on either node to make a cycle (a game idle, a looping clip):

  • Wind repeats over the range: the groom at loopEnd equals the groom at loopStart, with no discontinuity across the seam. Gusts still travel with the wind, spaced speed times the loop length apart.
  • Jiggle reads the frames before loopStart from the end of the range: animate the head as a cycle over the same frames and the jiggle loops with it.
  • Render loopStart to loopEnd - 1 and play them in a loop.
groomlab.add_wind(groom, strength=0.3, loop=True, loop_start=1, loop_end=49)

Simulate the guides

The Simulate node (Add Node > Motion) is GroomLab's hair solver. Place it between the guides and Interpolate: the guides respond to gravity and head motion, air drag and wind, and collide with the scalp and a collision mesh; the strands interpolated from them follow. It runs in Maya, the standalone app, groom files and on the farm, with the same results.

  • Playback: playing or scrubbing past the simulated frames steps the simulation forward from the last one; scrubbing back reads the cached frames. Changing a setting, or editing the guides, restarts the simulation from the start frame.
  • Simulate, bake, render: Simulate Range (GroomLab > Simulate) fills the frames of the playback range; Bake Simulation writes them to an Alembic guide cache (one per Simulate node, next to the scene or the groom file) that renders, exports and the farm read instead of simulating. A bake made with different settings from the node's current ones is ignored (with a message) and the node simulates.
  • Bypass (B) restores the groomed guides; before the start frame the guides are as groomed.
ParameterEffect
stretchStiffnessHow strongly segments keep their length (1: no stretch).
bend, twistHow strongly the guides keep their groomed bends and twist (0: a rope).
rootStiffness, rootStiffnessProfileHow firmly each part of a guide is held to its groomed shape (rootStiffness, mappable, can be painted per guide), multiplied by the root-to-tip profile: stiff roots, free tips.
damping, dragHow quickly motion dies out; air drag (also the coupling to the wind).
massHair mass: drag and other hair move heavier hair less (gravity accelerates all hair equally).
strengthFraction of the simulated motion applied, 0-1: paint 0 where guides should stay as groomed.
gravity, gravityDirection980 (cm/s²), straight down.
groomedUnderGravityThe groomed shape is how the hair rests under gravity at the start frame, so still hair keeps its shape. preload (default): the hair keeps its full weight, and each guide's rest shape is bent just enough to carry it, so it rests in the groomed shape, presses on what it lies on, and falls back with its weight after a fast move (gravity preloading, as in Liu 2022). Soft hair that could not hold all of its weight upright takes what it can and the rest is taken away. weightless: gravity's pull at the start is taken away; only its change as the head tilts or turns over moves the hair. off: gravity pulls on the groomed shape and the hair sags until it hangs.
windSpeed, windDirection, windGust, windFrequencyA gusting wind the hair is dragged toward (the same gusts as the Wind node).
inertiaHow much of the head's motion the hair feels (lower: less floppy; 0 moves rigidly with the head).
collideScalp, collisionOffset, frictionCollision with the scalp and the collider input's mesh; friction is the scalp's (a ColliderMesh node's friction sets its own mesh's).
repulsion, repulsionRadiusPushes guides apart where they bunch up (off by default).
volume, volumeCellSizeVolume preservation (off by default): hair packed denser than one cell is pushed apart, so long hair keeps its body.
substeps, iterationsAccuracy: steps per frame, constraint iterations per step.
startFrameThe frame at which the simulation starts at rest; start a few frames before the shot so the hair can settle.
prerollFrames the hair settles before the start frame, from the rest pose (0: off). It starts at rest in the groomed shape on the scalp's rest pose, with the driver curves as bound; the head and the rig move to the start frame's pose over the first half and hold over the second. A shot that starts far from the rest pose (the head turned, the rig posed) starts with the hair hanging as it would, not stiffly holding the groomed shape. Without a rest pose on the scalp the head holds where it is and the hair settles there.
cacheModelive simulates during playback; cached only in Simulate Range (other frames as groomed).
water, waterLevelWater (off by default): below the surface, either the plane at waterLevel (world Y) or the mesh on the water input.
buoyancy, waterDragUnder water: upward force as a fraction of gravity (above 1 the hair floats up); drag much stronger than in air.
currentSpeed, currentDirectionA slowly varying current that the hair drifts with under water.
dryTime, wetWeight, rainWetness: seconds to dry after leaving the water; how much heavier and limper wet hair is; rain that wets the hair without applying forces.

Presets

The Simulate node's Preset button (under its parameters in Maya's Graph Editor; Presets beside its name in the standalone app's parameter panel) sets the motion settings in one click:

  • Default: the node's defaults. Hair keeps its groomed shape while still, swings freely and is held only near the root.
  • Fur: springy fur that holds its groom (next section).

Both set the same parameters (groomedUnderGravity, bend, twist, damping, drag, rootStiffness, rootStiffnessProfile, inertia, iterations), so switching between them leaves nothing behind. Gravity, wind, collisions, water and painted maps are not changed. In Python: sim.simulate_preset(groom, "fur"), or sim.add_simulate(groom, preset="fur").

Springy fur that holds its groom

Short fur should keep its groomed look when the animal stands still, react when it moves, and spring back after a few quick swings. The Fur preset does this. These are the settings that matter, with the preset's values:

SettingFurWhat it does
groomedUnderGravityweightlessGravity does not pull the groom out of shape. The groomed shape is taken as how the fur rests under gravity, so only motion moves it.
bend0.8How stiff each guide is along its length. This setting has the largest effect: 0.9 is nearly rigid, 0.7 is clearly loose.
rootStiffnessProfile (with rootStiffness 1)root 1, middle 0.7, tips 0.35How firmly each part of the guide is pulled back to its groomed shape. Holding the whole length, not only the root, keeps the look and makes the fur spring back.
inertia0.8How much of the body's motion the fur feels.
damping0.25Slows the swinging. Its effect is small next to bend and the profile.

On a wolf (30 fps, a 90 degree turn in 8 frames, a run, a hard stop), the typical guide's tip moved less than 0.1% of its length while the wolf stood still (86% with the node's defaults, which let the fur hang). During the motion the tips moved about half the guide's length. After the stop they swung two or three times and came to rest within a third of a second.

If the result is not what you want:

  • Too stiff (barely moves): lower bend to 0.7 to 0.75, or lower the profile's middle and tips (0.5 and 0.25), or raise inertia to 1.
  • Too floppy (moves far, loses its shape in motion): raise bend to 0.85, or raise the profile's middle and tips, or lower inertia to 0.6.
  • Too wobbly (keeps swinging): raise bend or the profile's middle and tips; damping up to 0.5 shortens the swinging a little.
  • Too dead (stops without any spring): lower bend to 0.75, or lower the profile's tips.
  • Sags when the head tilts or turns over: groomedUnderGravity keeps the shape for the pose at the start frame; gravity's change as the head tilts still acts. Raise the profile's tips to hold it, or set groomedUnderGravity to off to let gravity act on the groom fully.
  • Floats instead of falling back after a fast move: use groomedUnderGravity preload, so the fur keeps its weight.

Notes:

  • The guides must follow the body. On an animated character, give the groom a rest mesh (Attribute Editor > Inputs, or groomlab.set_rest_mesh(groom)). A groom whose guides were saved on an earlier version of the scalp mesh (re-meshed or subdivided since) needs it to bind them to the current mesh.
  • The Simulate node collides with the scalp and its collider input only. To keep fur off the ground or out of another body part, connect that mesh to the collider input through a ColliderMesh node. A Collide node later in the graph acts on the strands, not on the simulation.

Painted simulation parameters

stretchStiffness, bend, twist, damping, drag, rootStiffness, mass and strength are mappable, per guide and along each guide (like Yeti's per-guide simulation attributes). Paint a guide map with the Paint brush (Groom Tools > Paint, on the guides) and assign it to the param ({"guide": "simMask"}), or use a texture, a color set, an expression, or a field node connected to the exposed param. The maps are read on the guides fed to the node, every frame.

  • strength: 0 holds the hair to its groomed shape (it still moves rigidly with its root and the head), 1 fully simulates it, values in between apply that fraction of the simulated motion. Painted along a guide (a per-point layer, or an expression of t), the held part stays and the rest hangs from it: stiff fringe roots, free ends.
  • mass: heavier hair is moved less by wind, air drag and neighboring hair, and keeps swinging longer; along a guide, heavier points move less. Gravity acts on all hair equally.
  • bend, stretchStiffness, rootStiffness: stiffer strands in one area, limper ones in another, a firmer hold at the crown.

With every one of these at a constant value (no maps; mass, strength and rootStiffness at 1), the simulation is identical to an unpainted one.

Volume and friction

Long hair under gravity collapses onto itself, because each guide falls to the same place as its neighbors. volume (similar to Yeti's density gradient) pushes apart hair packed tighter than about one volumeCellSize and leaves hair that is already spread out alone. Start with volume 0.3 and a cell size about the spacing you want between guides (1 cm on a head); larger cells give a fuller, smoother shape.

friction works like real friction: hair pressed hard against a surface grips it, and hair barely touching it slides. The value is the steepest slope hair rests on without sliding, as a share of a right angle: 0.3 holds on slopes up to 27 degrees, 0.5 up to 45, and 1 never slides. On the scalp, the hair slides against the scalp as it moves, so a head turn carries the hair resting on it.

Each collision surface has its own friction: friction is the scalp's (and the default), and a ColliderMesh node's friction its mesh's (-1 uses the Simulate node's). For example, hair catches on a wool collar and slides off a leather jacket. In Maya, groomlab.add_collider(groom, mesh, friction=0.8) sets it, and the Attribute Editor's Colliders rows show and edit it.

Water and wet hair

With water on, hair below the surface floats (buoyancy), is slowed (waterDrag) and drifts with the current; the forces fade in over a thin band at the surface, so hair crossing it does not jump. The simulation writes a per-point wetness attribute, 0 dry to 1 soaked: it rises within a quarter of a second under water (or in rain) and decays over dryTime. Other nodes can read it like any attribute: map a Clump's strength to {"attribute": "wetness"} so wet hair gathers into locks, and HairColor's tipStrength (with a dark tipColor and a flat tipProfile) to darken it. Bakes include the wetness, so renders use it too.

In Maya: GroomLab > Simulate > Add Simulate Node, Simulate Range, Bake Simulation, Clear Simulation (the last three also at the top of the Simulate node's settings, in every host). In the standalone app the timeline shows Simulate, Bake and Clear when the graph has a Simulate node, and a strip under the scrubber shows the frames simulated (emerald) and baked (blue); a saved groom references its bakes.

from groomlab import sim

node = sim.add_simulate(groom, bend=0.6, startFrame=-10)
sim.simulate(groom, end=120)           # Simulate Range
sim.bake_simulation(groom)             # the bake that renders and exports read
sim.invalidate_simulation(groom)       # simulate again from the start frame

Rigged hair: driver curves

Studios pose hero and stylized hair with a hair rig before any simulation: a few controls an animator keys for the big shapes and the silhouette, then a simulation adds the follow-through on top. In GroomLab the rig is a set of driver curves, rigged with whatever the host has (in Maya: joints and a skinCluster, spline IK, wire or blend shapes; in Blender: curve objects with hooks, armatures or plain keys), with guides attached to them, and a DriveGuides node that makes the attached guides follow. Maya and Blender have the same Simulate > Drivers menu; the app and the farm play a groom file's drivers from its driver cache.

  1. Attach: select guides with the GroomLab select tool and a driver curve, then GroomLab > Simulate > Drivers > Attach Selected Guides to Curve. The curve is connected, a DriveGuides node goes right after the Guides node, and the drivers are bound at frame 0 (the pose the groom was made in). The bind and the attachments are saved with the scene and in .groom files.
  2. Animate: each attached guide, and its children, keeps its place round its driver, in the driver's rotation-minimizing frame, as it swings, bends and stretches. Roots stay on the scalp. Guides attached to nothing stay as groomed; a guide attached to several drivers follows each, the nearest most. The viewport draws the driven guides. No curve yet? Create Driver from Selected Guides makes one down the middle of the selected guides, and Create a Driver per Selected Guide one on each guide, exactly its shape (the guide follows it as if bound to it directly): made from the guides as groomed at the bind frame, the pivot at the root, attached and bound, ready to rig.
  3. Detach Selected Guides returns guides to their groom; Rebind Drivers at Frame 0 takes the bind pose again after the rig's rest pose changed (the attachments stay).
ParameterEffect
strengthHow much the attached guides follow (mappable: paint where hair stays as groomed).
profileHow much each part follows, root to tip.

Which hair follows the animation exactly: paint the Simulate node's strength (mappable): 0 holds the hair to its input, the driven shape, and 1 simulates it, so a fringe can stick to the rig while the rest swings.

Simulation on top: put a Simulate node after the DriveGuides node (Guides, DriveGuides, Simulate). The solver takes the driven guides as its targets on every frame, so its bend and twist hold the animated shape and rootStiffness (with its profile) pulls toward it: the animation sets the pose, the simulation adds the swing.

With Follow Scalp, drivers are taken to the rest pose through the scalp point each was anchored to at the bind, so a driver that only moves with the head drives nothing.

On the farm: export_groom writes the driver curves' animation beside the groom file (<name>.drivers.abc, the file's driverCache) whenever driver curves are connected, so the CLI, the procedurals and the app drive the hair (and simulate on top) as Maya does, exactly.

Twist: a curve turned about its own length looks the same, so each driver's transform has a keyable twist (degrees at its tip, none at its root): key it, or connect a joint's rotateX to it. The guides round the driver turn with its twist since the bind; the driver cache carries it to the farm.

import groomlab

groomlab.attach_guides(groom, "hair_ctrl_crv1")                 # the selected guides
groomlab.attach_guides(groom, "hair_ctrl_crv2", group="bangs")  # a whole guide group
groomlab.create_drivers(groom)                                  # a curve down the selected guides
groomlab.create_drivers(groom, group="bangs", per_guide=True)   # a curve on each guide
groomlab.detach_guides(groom, guides=[12, 13])
groomlab.bind_drivers(groom, frame=0)                            # after changing the rig's rest pose

Follow the scalp

On an animated head, the groom is normally re-evaluated on every frame on the deformed scalp. With Follow Scalp on (Attribute Editor > Inputs, followScalp), it is evaluated once on the rest mesh, and each strand is then transformed to the deformed scalp by its root: a rigid rotation and translation taken from the root's triangle (its edge and normal), without stretching. Every strand keeps its rest shape, and only this transform is computed per frame, so playback, exports and motion blur keys are much cheaper (all keys share the rest evaluation).

  • Requires a rest mesh (below). Without one, or on a frame where the scalp is at rest, the result is identical to Follow Scalp off.
  • World-space guide data: guide curves, simulated guides and guide caches are positions on the current frame; each is transformed back to rest through its root, so the strands they shape end up where the guides are.
  • Evaluated at rest: colliders (Collide), ImportCurves' curves, Wind's direction and gusts, and Noise and other world-space effects are evaluated on the rest groom and then carried, so they rotate with the head instead of staying fixed in the world. Collision against a moving body, or wind blowing one way in world space, will differ; turn Follow Scalp off for those grooms.
  • Jiggle responds to head motion as it does without Follow Scalp (the scalp history is transformed into rest space).
  • No stretch: a scalp that stretches moves the roots apart, but the strands keep their rest size.
  • Exports, Arnold (both render modes) and groom files honor it; the flag is stored in the .groom file.
groomlab.set_follow_scalp(groom, True)

nHair in Maya

nHair remains available alongside the Simulate node: GroomLab > Simulate > Legacy > Simulate Guides (nHair)... creates nHair curves for the primary guides, with follicles on the scalp. Children follow their simulated parents, so the whole groom moves.

  • Presets: fur, short, long, bouncy and wet.
  • Bake Simulation to Cache writes the posed guides to Alembic and removes the live simulation, for fast, scrubbable playback.
  • Remove Simulation returns to the groom as authored. The authored guides are never modified.
from groomlab import sim

made = sim.create_sim_curves(groom, "primary", preset="long", collide=True, preroll=20)
sim.bake_sim(groom, "shot010.guides.abc", made)

Houdini and other packages

Guides simulated in another package drive the groom through a GuideCache node, the same in Maya, Blender and the app (GroomLab > Simulate in each):

  1. Export Guides for Simulation... writes the guides (every guide the Guides node feeds) to Alembic over the playback range, in GroomLab's space (Y up, centimeters). Each curve carries its guide ID as a per-curve strandId attribute. Maya's progress bar counts the frames; Esc cancels and removes the half-written file.
  2. Simulate the curves in the other package. Keep strandId on each curve (a primitive attribute in Houdini), keep the roots pinned, and write the result back to Alembic in the same space.
  3. Load Guide Cache... adds a GuideCache node right after the Guides node (loading again points the same node at the new file). At each frame it lays each curve on the guide with its strandId: the guides move, and their groups, painted maps and brushed shapes stay. A curve with another point count is resampled along its length to the guide's.

The node's settings: Path and Object (only the curves under one object), Match By (id, or order for a cache whose curves lost strandId), Frame Offset (a cache that starts earlier or later than the shot) and Blend (1 the cache's pose, 0 the guides as groomed; key it to fade the simulation in). Guides with no curve in the cache keep their pose, and the node's note says how many were posed. Bypass the node to see the groomed guides.

While a GuideCache or Simulate node moves the guides, the viewport draws them as they move, in amber over the groomed guides (which dim): what the strands follow. Brushes still edit the groomed guides.

# Maya
sim.export_guides(groom, "guides.abc", start=1, end=100)  # every guide; or one group: "primary"
sim.add_guide_cache(groom, "sim.abc")
# Blender
bpy.ops.groomlab.export_guides_sim(filepath="//guides.abc")
bpy.ops.groomlab.load_guide_cache(filepath="//sim.abc")

Older Maya scenes whose groom has a guide cache set (sim.set_guide_cache, the groom's guideCache attribute) still play it.

Motion blur

Give a groom on a deforming scalp a rest mesh, so the strands match between motion samples (and turn on Follow Scalp for the cheapest keys). The rest mesh is not affected by the character's transform or rig: it stores the mesh's own points as they were when it was set. Instances on the strands are motion blurred with them; turn on the Instance node's pinToRest so simulated guides that stretch don't slide them along the strands.

Shot fixes

Correctives (Groom Tools > Correctives) are sculpt layers applied on top of the groom. Fix Frame creates one that blends in and out around the current frame, with keyable weights; renders include them.

Fixing a simulation: correctives apply to the groomed guides, before the graph's DriveGuides and Simulate nodes. To sculpt on the simulated hair itself, as studios fix a sim, use Simulate > Sculpt on Simulation (Maya): the Simulate node's frames are baked (unless its bake is current), the guides are posed from the bake and the Simulate node, with the DriveGuides and Simulate nodes feeding it, is bypassed. The guides on screen are then the simulated ones and brushes make shot fixes on top of them; renders, exports and groom files carry both (the farm gives the same hair). Back to Live Simulation turns those nodes on again and clears the guide cache; the correctives stay.

from groomlab import shots
shots.sculpt_on_simulation(groom)   # bake, pose the guides from it, bypass the sim
shots.add_layer(groom, frame=1012, fade=6)  # a fix keyed around frame 1012; brush it
shots.live_simulation(groom)        # simulate again

On this page