Filter Nodes

Filter nodes take a texture on their Input port, change it, and pass the result out through Output. They are listed under the Filters category in the Node Library. Twenty-three nodes live in the category; twenty-one of them are documented on this page.

Shared behavior

Input is required on every filter. Until something is wired into it, the node produces nothing.
Mask is an optional grayscale input present on every filter in this category. Where the mask is white the effect applies at full strength; where it is black the node’s own Input shows through unchanged; values in between crossfade. Masking a filter therefore always means “less of this effect here”, never “black here”.
Quick Blur, Detail Blur, Directional Blur and Non-Uniform Blur filter color premultiplied by alpha, and so does the mask composite. Blurring or masking a cut-out therefore does not ring its soft edges with a dark halo. Fully opaque work renders identically either way.
Three filters take an extra required second input: Slope Blur (Slope), Non-Uniform Blur (Blur Map) and Vector Morph (Vector Map). Those ports have no fallback; leave one unconnected and the node stays blank.
Two filters have two outputs: Edge Detect (Magnitude, Direction) and Frequency Split (High Pass, Low Pass).
Port types are informational: they color the wire and socket so data flow reads at a glance, and all texture types interconnect freely. “Grayscale” means single-channel data (height, roughness, masks), “color” means RGB data (albedo, normals), “any texture” means the node passes whatever it was given straight through.
Parameter names in the tables below are the labels shown in the Properties Panel. Enum parameters are shown as a dropdown; whole-number and decimal parameters get a slider plus a typed field.
Two nodes in this category (Distance Field and Erosion) run an iterative GPU compute simulation and require the native render core; they are documented under Simulation & Compute Nodes. Bevel uses the compute path when it is available and falls back to a cheaper approximation when it is not.

Blur and Softening

Quick Blur

Type id: quick_blur

A cheap blur that stays responsive at large resolutions at the cost of edge quality. Reach for this while you are building and tuning a graph, then swap in Detail Blur on the branch that actually feeds an output.

Inputs

Input (any texture, required): the texture to soften.
Mask (grayscale, optional): restricts the blur.

Outputs

Output (any texture): the blurred result.

Parameter	Type	Default	Range / Options	Notes
Radius	Decimal	4.0	0.0 to 64.0	Measured in pixels at the node’s current render resolution, so the same value softens less at a higher export size. 0 passes the input through untouched.

The node is a nine-tap kernel. At a radius of 8 or below that is a single pass, which is what it has always rendered. Past 8 the taps would sit far enough apart to read as nine ghosted copies rather than a blur, so the node runs two or three passes at shrinking radii instead, scaled so the overall strength is the same. That chaining needs the native render core; without it the node stays one pass and large radii ghost.

Detail Blur

Type id: blur

A high-quality gaussian blur. Slower than Quick Blur, but clean enough for large radii and for final output. Use it on anything that reaches an output map.

Inputs

Input (any texture, required): the texture to soften.
Mask (grayscale, optional): restricts the blur.

Outputs

Output (any texture): the blurred result.

Parameter	Type	Default	Range / Options	Notes
Radius	Decimal	4.0	0.0 to 64.0	Measured in pixels at the node’s current render resolution. 0 passes the input through untouched.

Detail Blur is internally a separable two-pass gaussian (horizontal, then vertical), which is why it is both slower and cleaner than Quick Blur. The tap count follows the radius rather than being fixed, so the spacing stays near one pixel instead of widening into a comb as the radius grows.

Directional Blur

Type id: directional_blur

Smears the image along a single axis instead of in all directions: motion streaks, brushed metal, fabric weave, and the anisotropic feel of a machined surface.

Inputs

Input (any texture, required): the texture to smear.
Mask (grayscale, optional): restricts the smear.

Outputs

Output (any texture): the streaked result.

Parameter	Type	Default	Range / Options	Notes
Angle	Decimal	0.0	0.0 to 360.0	Degrees. Sets the axis the blur runs along.
Distance	Decimal	0.05	0.0 to 0.5	How far the smear travels in each direction along that axis, as a fraction of the image. Resolution-independent.

The tap count follows the streak length so the taps stay about a pixel apart rather than spreading into a ladder of ghosted copies. The count runs to 128 per side, and past that the spacing widens again.

Non-Uniform Blur

Type id: non_uniform_blur

Blurs by a per-pixel radius read from a second map, so some areas stay razor sharp while others smear. The workhorse for depth-of-field looks, selective softening, and melting only the worn parts of a surface.

Inputs

Input (any texture, required): the texture to soften.
Blur Map (grayscale, required): white blurs at the full radius, black leaves the pixel untouched, grays scale in between.
Mask (grayscale, optional): restricts the effect.

Outputs

Output (any texture): the selectively blurred result.

Parameter	Type	Default	Range / Options	Notes
Radius	Decimal	0.05	0.0 to 0.5	The maximum blur radius, as a fraction of the shorter image edge. The Blur Map scales it per pixel.

Unlike Detail Blur this cannot be split into two cheap passes, because neighboring pixels want different kernels. The sampling density is set by Radius, the same for every pixel: deriving it from the per-pixel radius put a step in the sampling pattern along every contour of the Blur Map, which drew onion-ring lines through the result. Pixels the Blur Map leaves black still exit before sampling, so a mostly black map is still cheap.

Slope Blur

Type id: slope_blur

Marches samples downhill along the slopes of a second, driving texture instead of blurring in a fixed direction. This is the classic weathering and run-off effect: rust streaking down a panel, dirt collecting in crevices, paint melting off an edge. The march re-reads the slope at every step, so the path curves along the terrain the way water would.

Inputs

Input (any texture, required): the texture being smeared.
Slope (grayscale, required): the height field whose gradient steers the march.
Mask (grayscale, optional): restricts the effect.

Outputs

Output (any texture): the smeared result.

Parameter	Type	Default	Range / Options	Notes
Intensity	Decimal	0.1	0.0 to 0.5	How far the march travels, as a fraction of the image. The response is not linear: the slider is squared so the low end is fine-grained, and 0.5 still means half the image.
Samples	Whole number	32	1 to 64	Steps requested along the march. The node samples up to four times denser than asked, to a ceiling of 128 steps, so a step never lands further apart than the features it is marching over. The total is still capped at one step per marched pixel: more steps than pixels only resamples the same pixels. Samples remains the cost and quality knob.
Mode	Choice	Blur	Blur, Min (Erode), Max (Melt)	Blur averages the samples (a smear). Min (Erode) keeps the darkest, carving the input away. Max (Melt) keeps the brightest, growing it.
Falloff	Decimal	1.0	0.0 to 1.0	How the reduction weighs distance. At 1.0 a sample counts for less the further along the march it sits, so one distant extreme cannot decide the pixel; raising Samples then adds detail. At 0.0 every sample counts in full, which is the plain running minimum or maximum other tools compute: a harder, more aggressive carve, where raising Samples mostly adds reach.

The Slope input is read through a small averaging filter and measured over a baseline that scales with the march length, so the march reads the shape of the driver rather than the dither the generators lay over it. Where the gradient falls to the level of 8-bit rounding (the flat areas of a soft driver), the march fades out and the pixel passes through untouched, instead of streaking off in a direction that is really just rounding noise.

Slope Blur is not Erosion: it smears pixels along a gradient, which reads as wear but conserves nothing. Erosion actually transports material.

Median

Type id: median

Removes speckle and isolated stray pixels while keeping edges sharp: a denoiser that does not soften structure the way a blur does. Reach for it after a scatter or noise pass has left salt-and-pepper dots.

Inputs

Input (any texture, required): the texture to clean up.
Mask (grayscale, optional): restricts the effect.

Outputs

Output (any texture): the despeckled result.

Parameter	Type	Default	Range / Options	Notes
Radius	Choice	5×5 (fast)	3×3 (exact), 5×5 (fast)	Kernel size.

Each color channel gets its own median, so color input is handled per channel rather than by luminance; alpha passes through. 3×3 is the exact median of its nine pixels. 5×5 is a separable approximation (the median of five row medians) which clears the same speckle for a fraction of the work.

Detail and Edges

Sharpen

Type id: sharpen

Boosts local contrast to bring fine detail forward. Overdo it and you get bright halos along every edge.

Inputs

Input (any texture, required): the texture to sharpen.
Mask (grayscale, optional): restricts the sharpening.

Outputs

Output (any texture): the sharpened result.

Parameter	Type	Default	Range / Options	Notes
Amount	Decimal	1.0	0.0 to 8.0	Unsharp-mask strength. 0 passes the input through.

The reference blur the sharpen subtracts is scaled to hold a constant footprint as the output grows, so the node has the same character at 512 as at 4K.

Frequency Split

Type id: high_pass

Separates fine detail from broad shape so you can edit one without disturbing the other: strip the lighting and large-scale drift out of a photo-sourced map, keep only surface detail, then recombine. Both halves come out of one node, so their cutoffs can never drift apart.

Inputs

Input (any texture, required): the texture to split.
Mask (grayscale, optional): restricts the effect.

Outputs

High Pass (any texture): detail finer than the radius, centered on mid-gray (0.5 means “no deviation from the local average”), which drops straight into an Overlay or Add blend.
Low Pass (any texture): the broad structure that was subtracted; this is the blur the high pass removed.

Parameter	Type	Default	Range / Options	Notes
Radius	Decimal	0.05	0.0 to 0.5	Cutoff, as a fraction of the shorter image edge. Larger keeps more of the broad structure in the high pass, because the low pass it subtracts is wider.
Amount	Decimal	1.0	0.0 to 8.0	Scales the retained detail around mid-gray.

High Pass plus Low Pass recombine to the original input, which is what makes this a genuine split rather than two independent effects.

Edge Detect

Type id: edge_detect

Finds edges in the input and outputs them as a mask: outlines, wear masks, panel seams, and anything that needs to know where the silhouettes are.

Inputs

Input (any texture, required): the texture to analyze; color is reduced to luminance first.
Mask (grayscale, optional): restricts the effect.

Outputs

Magnitude (grayscale): bright where the input has an edge, dark on flat areas.
Direction (color): the direction each edge runs, encoded in red and green centered on 0.5 exactly like a normal or flow map, so it feeds Warp, Vector Morph and Rotate’s Vector mode unchanged. It is normalized, so a faint edge still reports a usable direction; strength is Magnitude’s job.

Parameter	Type	Default	Range / Options	Notes
Intensity	Decimal	1.0	0.0 to 8.0	Gain on the edge magnitude. Affects the Magnitude output only.
Smoothing	Decimal	0.0	0.0 to 1.0	Widens the detection stencil from one pixel to four and pre-averages each tap. Reads one smooth line where a hard stencil turns small features and dithered areas into single-pixel speckle and doubled edges. Affects both outputs.
Width	Decimal	0.0	0.0 to 0.1	Thickens the detected line into a band, as a fraction of the shorter image edge, the same units as Dilate / Erode’s Amount. 0 leaves the line one stencil wide. Affects the Magnitude output only.
Rounding	Decimal	0.0	0.0 to 0.1	Fillets the corners of the thickened line instead of leaving sharp miters. Affects the Magnitude output only.

Width and Rounding are morphology passes run over the Magnitude output: the line is dilated by Width plus Rounding and then eroded back by Rounding. That overshoot and return is a morphological close, which is why concave corners round as well as convex ones. Rounding on its own, with Width at 0, rounds the line without thickening it.

Edge detection wraps around the image borders, so it stays seamless on tiling maps. The response is calibrated against a 1024-pixel reference so the same content yields the same edge strength at any output size.

Color and Tonal

Levels

Type id: levels

Remaps the input black point, white point and gamma onto a new output range: the workhorse for setting contrast precisely rather than by feel.

Inputs

Input (any texture, required): the texture to remap.
Mask (grayscale, optional): restricts the remap.

Outputs

Output (any texture): the remapped result.

Parameter	Type	Default	Range / Options	Notes
In Black	Decimal	0.0	0.0 to 1.0	Input value that becomes fully black.
In White	Decimal	1.0	0.0 to 1.0	Input value that becomes fully white.
Gamma	Decimal	1.0	0.1 to 4.0	Biases the midtones between the two input points.
Out Black	Decimal	0.0	0.0 to 1.0	Low end of the range the result is written into.
Out White	Decimal	1.0	0.0 to 1.0	High end of the range the result is written into.
Channel	Choice	Master	Master, Red, Green, Blue	Which channel the five sliders act on. Master remaps all three; the others remap only their own and pass the rest through untouched. Chain a second Levels to grade a second channel.

Neither pair is constrained to keep its low end below its high end. Drag In White below In Black, or Out White below Out Black, and the ramp inverts: an invert and a remap in one node instead of two. Dragging the handles across each other stays continuous rather than collapsing to a hard threshold.

Brightness/Contrast

Type id: brightness_contrast

Shifts overall lightness and stretches or compresses the tonal range: the quickest way to strengthen or calm a map when you do not need Levels’ precision.

Inputs

Input (any texture, required): the texture to adjust.
Mask (grayscale, optional): restricts the adjustment.

Outputs

Output (any texture): the adjusted result.

Parameter	Type	Default	Range / Options	Notes
Brightness	Decimal	0.0	-1.0 to 1.0	Negative darkens, positive lightens. 0 is no change.
Contrast	Decimal	0.0	-1.0 to 1.0	Negative flattens toward mid-gray, positive stretches away from it. 0 is no change.

Contrast pivots around mid-gray on a slope that steepens toward the ends of the slider. The top of the range is a decisive contrast wall, at roughly fourteen times the input slope, and it stays monotonic: brighter input still means brighter output. Before 1.2.2 the last stop of the slider overshot into a hard-thresholded negative.

Curves

Type id: curves

Reshapes the tonal response through a draggable curve. Finer control than Levels when only part of the range needs moving: lifting the shadows without touching the highlights, or pinning the midtones while crushing both ends.

Inputs

Input (any texture, required): the texture to remap.
Mask (grayscale, optional): restricts the remap.

Outputs

Output (any texture): the remapped result.

Parameter	Type	Default	Range / Options	Notes
(curve pad)	Control-point list	Identity (two points, at the bottom-left and top-right corners)	Unlimited control points, each anywhere in 0.0 to 1.0 on both axes	There are no numeric parameters. The curve editor in the Properties Panel is the entire interface: add, move and remove points freely, including horizontally.

The curve is interpolated with a monotone cubic that never overshoots, so a dialed-in curve cannot produce values outside the range its points span. Beyond the first and last points the curve extends flat, matching Photoshop. The same curve is applied to each color channel independently; alpha passes through untouched. A malformed or missing curve falls back to the identity curve rather than failing the render.

HSL Shift

Type id: hsl

Rotates hue and scales saturation and lightness: recolor a material without touching any of its structure.

Inputs

Input (any texture, required): the texture to recolor.
Mask (grayscale, optional): restricts the shift.

Outputs

Output (any texture): the recolored result.

Parameter	Type	Default	Range / Options	Notes
Hue Shift	Decimal	0.0	-0.5 to 0.5	A full turn of the hue wheel is 1.0, so ±0.5 is a half turn; the full range reaches every hue.
Saturation	Decimal	1.0	0.0 to 2.0	0.0 removes all color, 1.0 is unchanged, 2.0 doubles it.
Lightness	Decimal	0.0	-1.0 to 1.0	Negative darkens, positive lightens.

Grayscale

Type id: grayscale

Collapses a color input to luminance. Use it before any node that expects a height map or a mask.

Inputs

Input (any texture, required): the texture to reduce.
Mask (grayscale, optional): restricts the effect.

Outputs

Output (grayscale): single-channel luminance.

No parameters.

Invert

Type id: invert

Flips the input so light becomes dark. It has dedicated normal-map modes because a plain inversion of a normal map also negates the Z component and lights the surface inside-out.

Inputs

Input (any texture, required): the texture to flip.
Mask (grayscale, optional): restricts the inversion.

Outputs

Output (any texture): the inverted result.

Parameter	Type	Default	Range / Options	Notes
Mode	Choice	Color	Color, Normal Y, Normal X, Normal XY	Color is the ordinary inversion. The three normal modes flip the named slope axes in signed space and leave Z alone, so the map still lights correctly.

Gradient Map

Type id: gradient_map

Replaces each input value with a color sampled from a gradient: the standard way to turn a height map into an albedo. Accepts grayscale or color input; color is reduced to luminance before the ramp is applied.

Inputs

Input (any texture, required): the values to remap.
Mask (grayscale, optional): restricts the effect.

Outputs

Output (color): the gradient-mapped result. Alpha passes through.

Parameter	Type	Default	Range / Options	Notes
(gradient bar)	Color-stop list	A four-stop rust ramp: near-black `#0D0A08` at 0.0, dark brown `#592E1A` at 0.35, orange `#CC7326` at 0.70, cream `#FFF2D9` at 1.0	Unlimited stops, each with a color and a position 0.0 to 1.0	Edited on the gradient bar in the Properties Panel; stops can be added, removed and moved. A malformed or missing ramp falls back to the default four stops.
Mid	Decimal	0.5	0.01 to 0.99	A gamma-style bias on the lookup: the input value set here is what lands in the middle of the ramp. 0.5 is linear; lower values push more of the image toward the ramp’s bright end, higher values toward its dark end.

Levels, Curves, Gradient Map and Brightness/Contrast all add a ±1 step dither before writing their 8-bit result. Compressing a range squeezes the input’s own dither below one output step, which would otherwise make smooth ramps re-band on export. The dither is seamless, so tiling is unaffected.

Shape and Surface

Dilate / Erode

Type id: morphology

Grows or shrinks bright regions by a radius. Thicken a mask, close small gaps, or eat away at edges. The general-purpose counterpart to Flood Fill’s Region Modify, which only reshapes flood-filled regions.

Inputs

Input (any texture, required): the mask or height field to reshape.
Mask (grayscale, optional): restricts the effect.

Outputs

Output (any texture): the reshaped result.

Parameter	Type	Default	Range / Options	Notes
Amount	Decimal	0.02	-0.5 to 0.5	Signed, as a fraction of the shorter image edge. Positive dilates (grows bright regions), negative erodes (shrinks them), 0 passes through. One control instead of two nodes pointing opposite ways.
Shape	Choice	Disc	Disc, Square, Diamond	The structuring element the radius is measured with.

Open and Close are deliberately not options here. Each needs two full passes over the neighborhood, so chain two of these nodes with opposite Amounts.

The structuring element is sampled densely enough to catch any feature out to about 32 pixels of radius. Past that the node splits the work into as many passes of 32 pixels or less as it takes, up to eight. Dilations compose exactly, so the passes add up to the radius you asked for without the dropout speckle a single sparse pass leaves on thin lines. That splitting needs the native render core; without it the node stays one pass and large radii speckle.

Bevel

Type id: bevel

Rounds the edges of a mask into a soft height ramp: chamfers, panel edges, chiseled tiles and raised lettering. Feed it a mask, take the height into a Normal node. Bevel runs as GPU compute where the native render core is available and falls back to an approximation without it.

Inputs

Input (any texture, required): the mask to shape; anything above the threshold counts as “inside”.
Mask (grayscale, optional): restricts the effect.

Outputs

Output (any texture): a height ramp running inward from the silhouette.

Parameter	Type	Default	Range / Options	Notes
Bevel Width	Decimal	0.03	0.0 to 0.5	How far inward from the silhouette the ramp runs, as a fraction of the shorter image edge.
Profile	Choice	Chamfer	Chamfer, Round, Ridge	Chamfer is a straight ramp, Round is a smooth shoulder, Ridge peaks and comes back down.
Threshold	Decimal	0.5	0.0 to 1.0	Mask cutoff; what counts as inside the shape.

With the native render core present, Bevel is driven by the same jump-flooding distance field the Distance Field node uses, run in Inside mode, with the profile shaping applied on top. That makes the ramp exact at any width. Without the native core it falls back to a bounded outward search capped at the bevel width, whose accuracy is limited by its sample budget; a wide bevel can visibly step. A Bevel Width of exactly 0 always uses the fallback, which fills the shape solid white and leaves everything outside it black.

Vector Morph

Type id: vector_morph

Displaces the input along a vector field in repeated small steps, re-reading the field at each new position, so pixels follow a curved path: material flowing around a form rather than sliding past it. Set Steps to 1 and the walk becomes a single straight jump, which is what Warp does.

Inputs

Input (any texture, required): the texture to displace.
Vector Map (color, required): the direction field, encoded in red and green centered on 0.5, the same convention Flow Map, Edge Detect’s Direction output and normal maps use.
Mask (grayscale, optional): restricts the displacement.

Outputs

Output (any texture): the displaced result.

Parameter	Type	Default	Range / Options	Notes
Intensity	Decimal	0.05	-0.5 to 0.5	Total displacement, as a fraction of the texture. Negative values follow the field backwards. A unit of Intensity here displaces twice as far as it does on Warp, so the two nodes’ defaults move a pixel the same distance.
Steps	Whole number	4	1 to 64	Integration steps. 1 is a plain Warp and is the cheap setting, not a broken one; more steps follow curvature more faithfully. The ceiling reaches 64 because at 16 a full-strength morph on a 2K texture jumped 64 pixels per step and the “curved” path came out as a kinked polyline no setting could smooth.
Angle	Decimal	0.0	0.0 to 360.0	Rotates the vector field before it is followed, in degrees. Lets one vector map drive several directions without re-authoring it.

Steps changes the path taken, not the distance traveled: the total displacement is split across them, so raising quality does not also strengthen the effect. The Vector Map is read through a small averaging filter, which keeps the dither a generated field carries from jittering hard edges as the walk integrates it.

Normal Adjust

Type id: normal_adjust

Scales, flips or re-normalizes an existing normal map: the place to fix a green channel pointing the wrong way. Export already converts orientation per preset, so this node is for mid-graph conversion: bringing an OpenGL-convention map in through an Image node and matching it to the rest of the graph before blending.

Inputs

Input (color, required): the normal map to fix.
Mask (grayscale, optional): restricts the effect.

Outputs

Output (color): the corrected normal map.

Parameter	Type	Default	Range / Options	Notes
Operation	Choice	Normalize	Normalize, Flip Y (OpenGL ↔ DirectX), Flip X, Rebuild Z	Normalize only re-normalizes. Flip Y converts between the two handedness conventions. Rebuild Z recomputes the blue channel from the red and green slopes.
Intensity	Decimal	1.0	0.0 to 4.0	Slope multiplier applied before the vector is re-encoded. 1.0 leaves the strength unchanged; below 1 flattens, above 1 exaggerates.

Maps inside the graph use the DirectX convention.

Normal Adjust is filed under Filters because it edits a map in place rather than deriving one. The nodes that produce surface data from a height field (Normal from Height, Curvature / Cavity, Surface Detail, Directional Occlusion, Flow Map and Roughness from Height) are under Normal & Surface Nodes.

Normal to Height

Type id: normal_to_height

Integrates a normal map back into an approximate height map. For rebuilding displacement from art you only have as normals, and for feeding Height Blend or the Normal & Surface nodes from normal-only source material.

Inputs

Input (color, required): the tangent-space normal map.
Mask (grayscale, optional): restricts the effect.

Outputs

Output (grayscale): the recovered height.

Parameter	Type	Default	Range / Options	Notes
Radius	Decimal	0.1	0.0 to 0.5	Integration reach, as a fraction of the shorter image edge. Raise it for large forms, lower it for fine detail and speed.
Intensity	Decimal	1.0	0.0 to 8.0	Output contrast around mid-gray.

The recovery averages many bounded integrations fanned out from each pixel, and the step count along each of them follows Radius, so the integration never strides past forms finer than its own step and reaches its whole radius at full detail. Below one pixel of Radius the node outputs flat mid-gray.

This is an approximation by construction. Two consequences are worth knowing: absolute height is meaningless, only relative shape survives, and forms broader than Radius are not recovered at all, because the integration never reaches far enough to see them.

Simulation nodes

The two remaining Filters-category nodes, Distance Field and Erosion, run as iterative GPU compute simulations and are documented under Simulation & Compute Nodes.