Field From Expression

1. Place Field From Expression from the 1. Field panel. The default expression is a unit sphere: sqrt(x*x + y*y + z*z) - 1.
2. To preview it, wire the output into Preview Field 3D. To mesh it, give it a box with Implicit From Field and wire that into Mesh From Implicit.
3. Click + on the component to add a number input. Right-click the new input, choose Set Nickname, and use that name in the expression: sqrt(x*x + y*y + z*z) - r.
4. Right-click the component for typed inputs:
   • Add Field input takes any other field (a sphere, a mesh, a volume, another expression) and uses its value at each point.
   • Add Point input and Add Vector input bind a point or vector as a vec3. Name one p and write length(vec3(x, y, z) - p) - r for a sphere centred on that point.

The result of the whole expression must be a single number: the signed distance, negative inside the shape. Vectors and matrices can only be intermediate values.

x, y and z are the Cartesian coordinates of the point. PI (3.14159…), TAU (6.28318…, that is 2π) and E (2.71828…) are constants. These six names are always available and cannot be used for an input or bound with let: an input with one of these names is refused with an error asking you to rename it.

Arithmetic

+ - * / ^, a leading - to negate, and a leading +, which does nothing. Power is right-associative: 2^3^2 is 2^(3^2).

Operators work element by element on vectors. A scalar combined with a vector applies to every component: vec3(x, y, z) * 2. Mixing a vec2 with a vec3 is an error. With a matrix, * is matrix multiplication (see Matrices).

Comparisons, logic and conditions

• <, <=, >, >=, == and != compare two values and give 1 (true) or 0 (false).
• && (and), || (or) and ! (not) combine them. Any non-zero value counts as true.
• cond ? a : b gives a when cond is non-zero, otherwise b. The branches can be scalars or vectors of the same width; the condition must be a scalar, so reduce a vector comparison first, as in (p > q).x.
• Comparisons work element by element on vectors, like arithmetic.
• Comparisons don't chain: write 0 < x && x < 10, not 0 < x < 10.

Precedence, from lowest to highest: ?:, then ||, &&, == and !=, < <= > >=, + and -, * and /, ^, a leading - + or !, and finally . for components.

Read or reorder a vector's components by name, using any combination of x, y and z, one to three letters long, with repeats allowed:

Each letter must exist on the vector (.z on a vec2 is an error), and there is no four-component vector.

let name = value in body names a value so you can use it in body. The value can be a scalar, a vector or a matrix, and the body runs to the closing bracket or the end of the expression:

let q = twist(vec3(x, y, z), k) in length(q.xy) - r

Bindings can be nested, and a later one can use an earlier one: let a = x * 2 in let b = a + 1 in b - z. Inside its body, a let name hides an input with the same name.

Scalar functions

These take numbers, and also work element by element on vectors.

smin and smax are the smooth union and intersection. k is the same fillet radius as the Radius input on the boolean components: two surfaces meeting at a right angle get a round fillet of radius k, and as k approaches 0 they become plain min and max. They are polynomial, so they stay safe to mesh: use them rather than an exponential blend, which can overflow.

Vector functions

Matrices

Use * to apply them: M * v transforms a vector, M * N combines two matrices, and M * s scales every element. To transform a shape, evaluate it at the inverse-transformed point: rotate by evaluating at inverse(M) * vec3(x, y, z). For a pure rotation, transpose(M) is the same as the inverse and cheaper.

Noise

value_noise(p), perlin(p) and simplex(p) give smooth noise between roughly −1 and 1, where p is a vec2 or vec3. An optional second argument is a whole-number seed: simplex(p, 7). All three are continuous, so safe to mesh, and give the same result every time.

• value_noise is cheap and blocky.
• perlin is smooth gradient noise.
• simplex is smooth with no grid direction, usually the best choice for organic forms.

Scale the point to set the feature size: simplex(vec3(x, y, z) * 0.2) has features about five units across.

Domain operations

These take a point and return a transformed point, so you can build a shape once and repeat, mirror, twist or bend it. They cost the same as writing the maths out by hand.

Every expression below can be pasted straight into the Expression input. Names in the Inputs column are Number inputs unless marked otherwise; add them with + and set their nicknames.

Basic shapes

Combining shapes

Repeating, mirroring and twisting

Lattices

Triply periodic minimal surfaces repeat every 2π / f units. Use abs(…) - t to turn the surface into a wall of thickness about t, then clip it with Implicit From Field or wrap it with Conform To Surface.

These surfaces aren't exact distance fields, so mesh them with a finer MinFeatureSize than you would a solid of the same size.

Grading, noise and texture

Points, let and matrices

Combining other fields

These use Add Field input. Each name is the nickname of a Field input wired from another component.

Result	Expression	Inputs
Union of two fields	min(a, b)	a, b (Field)
Smooth union	smin(a, b, k)	a, b (Field), k
Smooth intersection	smax(a, b, k)	a, b (Field), k
Subtract b from a	max(a, -b)	a, b (Field)
Shell of a field	abs(a) - thickness	a (Field), thickness
Blend between two fields	a + t * (b - a)	a, b (Field), t
Texture on an imported mesh	m + sin(x*freq)*cos(y*freq)*amp	m (Field, from Implicit From Mesh), freq, amp
Sphere pushed out by a mesh's distance	length(vec3(x, y, z)) - 1 + 0.1 * m	m (Field)

The last two are the reason Field inputs exist: wire any mesh-based field in as m and add procedural detail to it, with no scripting.

• When every input is a number, or a field built from primitives and arithmetic, the expression compiles to native code and runs as fast as a built-in primitive.
• When an input is a mesh, a volume or another sampled field, the expression is evaluated point by point instead. That is slower, so keep those inputs for where you need them.
• A Number input becomes a constant in the compiled expression, so dragging its slider recompiles the expression at every step.
• Preview and mesh resolution are set downstream: MinFeatureSize on Mesh From Implicit, and the preview feature size in the right-click menu of Implicit From Field.

Mistakes in the expression show as a red balloon on the component, with the column where the problem starts.

What the component may report, shown as a balloon on the canvas.