Advanced mode

Fields

A field is one number per vertex. That is the whole concept, and it is the connective idea that makes every other module in Rhea combine with every other module. Eleven generators produce them; everything else consumes them.

The pipeline

  generator  →  modifier chain  →  destination

  curvature      remap curve            named attribute
  occlusion      clamp                  vertex group
  noise          invert                 colour channel
  formula        contrast / gamma
  ...            blur
                 quantise
                 normalise

Every field goes through all three stages. The generator decides what is being measured, the modifiers shape it into something usable, and the destination decides who can read it.

Fields write to the active object

This catches everyone at least once. If you generate a field while the component is selected rather than the base, it lands on the component and the base still has nothing. Rhea detects the likely case and offers a Write to base button in the warning, which is usually the fastest fix.

The eleven generators

Controls

Curvaturemean · gaussian · max · min: How sharply the surface bends at each vertex, from a cotangent-weighted discrete Laplacian rather than the cheap normal-angle approximation. That matters: the cheap version is wrong on non-uniform triangulations, which is most real meshes. Mean is the general-purpose choice; Gaussian distinguishes saddles from domes; max and min give the principal curvatures separately.
Ambient occlusion8 – 256 samples: Hemisphere ray sampling against a BVH: how enclosed each vertex is. The most intuitive field there is, because it matches what your eye already reads as depth. Sixty-four samples is the sensible default; below thirty-two it is visibly noisy.
Thicknesscone angle, samples: Inward ray casting: how much solid is behind each vertex. The field for finding thin regions before printing, and for thickening struts where a form is weak.
Cavityinstant: Convexity from neighbour normal deviation. A cheap, local approximation of occlusion that computes instantly on any mesh. Use it when AO is too slow to iterate with, and switch to AO for the final result.
Geodesic distancefrom a vertex group: Distance measured across the surface rather than through space, from a seed selection or vertex group. On a folded or branching form this is wildly different from straight-line distance, and it is what you want for anything that should propagate along the surface.
Proximityto an object: Distance to another object's surface, via a BVH. Move an empty or a mesh around and the field follows it — the most directly art-directable field in the set.
GradientX · Y · Z: A linear ramp along an axis. Simple, and the right answer more often than it looks: most patterns that need to fade out need it to fade in one direction.
Slopeangle from a reference: The angle between each vertex normal and a reference direction. Where is this surface facing up? Where is it vertical? Weathering, snow, moss, and anything gravity-aware starts here.
Noisescale, detail, roughness, lacunarity: Fractal value noise per vertex, with the usual four controls. Note that Perlin-family noise is smooth and clusters around its midrange — it is not a substitute for uniform randomness, and using it where you wanted random will give you a suspiciously even result.
Edge bendingdihedral angle: How far each edge folds between its two faces. Distinct from curvature: this is a per-edge measure of creasing, so it finds hard edges rather than smooth bends.
Formulasafe expression: Your own expression, evaluated over every vertex. See below.

The modifier chain

Applied in this order, always. Order matters — blurring before quantising gives soft bands, quantising before blurring gives soft edges between hard bands.

Remap curve: An editable curve widget applied before everything else. The most direct control there is: drag the curve until the field looks right.
Clamp: Restricts to an explicit min and max. Use it to isolate a band — only the most curved twenty percent, say — rather than compressing everything.
Invert: Flips the field about its own range. Cheaper than a curve when that is all you need.
Contrast0 – 5: Expands or compresses about the midpoint. Applied over the field's own range rather than a fixed 0–1 window, so it works correctly on curvature values that span, say, −4.3 to −1.6 rather than flattening them all to a single clamped value.
Gamma0.01 – 5: A gamma curve. Below 1 pushes values toward the top of the range, above 1 toward the bottom. Use it when contrast is too blunt.
Blur0 – 50 passes: Neighbour averaging over the edge graph. Two or three passes take the noise off a computed field without losing its structure; fifty will smooth almost anything into a gradient.
Quantise0 – 64 steps: Snaps to discrete levels. This is how you get banded, terraced, contour-line results — and how you get a field that selects between component slots cleanly instead of on a continuum.
Normalise: Rescales the finished field to span zero to one. On by default, and worth leaving on: most consumers assume a 0–1 range, and a raw curvature field spans whatever it happens to span.

Where to write it

Named attribute: Full float range, no clamping, and what the Rhea engines read. Default name is rhea_field; recipes use rhea_density. This is the right destination unless you have a reason otherwise.
Vertex group: Clamped to 0–1, but visible to every native Blender modifier. Write here when you want to drive a Displace, a Mask, a particle system or a shader with the same field.
Colour channel: A specific R, G, B or A channel of a colour attribute. The one you can see in the viewport, and the one shaders read. You can pack four independent fields into one colour attribute this way.

Colours and weights exchanger

Bidirectional and channel-aware conversion between any colour channel — R, G, B, A or luminance — and any vertex group. There is a batch mode that does all four channels at once.

The use for this is unglamorous and constant: you have data in the wrong container. A field baked from another add-on lives in vertex colours; the modifier you want to drive reads vertex groups. This moves it, without a round trip through anything.

The formula field

Write an expression and it is evaluated over every vertex, vectorised — there is no per-element Python loop, so a formula over a hundred thousand vertices costs about what a built-in generator does.

  sin(x * 4) * 0.5 + 0.5              a wave along X
  sqrt(x*x + y*y)                    radial distance from the origin
  smoothstep(0.2, 0.8, nz)           soft mask on upward-facing normals
  min(curvature, 1 - ao)             element-wise, over two existing fields
  fract(i / 8)                       a repeating ramp by vertex index
  noise(x, y, z) * rand              structured noise times per-vertex random

What you can use

Variables: x y z local coordinates, nx ny nz normal components, u v UV coordinates, i vertex index, n total count, rand deterministic per-vertex random from the seed — plus any existing vertex group or attribute, by name.
Functions: sin cos tan asin acos atan atan2 sqrt abs pow exp log floor ceil round sign clamp mix step smoothstep min max noise fract mod

min and max take two arrays

min(a, b) with two field arguments returns the element-wise minimum, not a reduction. It also still reduces a single array. This is called out because getting it wrong is a well-known bug in the alternatives, and it silently produces a constant where you expected a pattern.

What is not allowed, and why

The expression is parsed into a syntax tree and walked against a whitelist. It is never handed to eval. Attribute access, subscripting, imports, lambdas, comprehensions, dunder names and calls to anything outside the function table are all rejected.

This is not paranoia about your own formulas — it is because .blend files get shared. An expression stored in a scene someone sends you should not be able to read your filesystem.

Errors appear as a red inline message in the panel with the character position of the fault. There is no traceback in the console to go hunting for.

Using a field

Tessellate — thickness, rotation angle, and which component slot each face gets.
Live effects — the Attribute box on any engine, with Variation setting how hard it bites.
Adaptive subdivide — where the mesh gets denser.
Voronoi — seed density, so cells crowd where the field is strong.
Growth — a mask deciding which nodes are allowed to split.
Reaction-diffusion — the initial seeding pattern.
Overlays — the heatmap, so you can see a field before committing to it.

See it before you commit

Turn on the field heatmap overlay and set it to your attribute name. The field draws over the mesh with a legend, updating as you change the generator and the modifier chain. Dialling a field in visually takes about a tenth as long as generating, applying, looking at the result and going back.