# Gallery (scene)
The variety of watercolorBlocks in one place, every piece labelled on its own white card so it reads in the scene and on the cover. It is the package cover.
- **Front rows: every block, and the hero material.** Each block sits on the same still life over one base wash, limited to its own pedestal by a sphere mask, beside an unstyled pedestal ("As rendered"). The "Hero material" pedestal is the single-object form: its still life wears watercolor surface materials written by `WatercolorHero.paint` (kept in `gallery/hero`), and the full-frame stack leaves it out, so you see the material form alone next to the full-frame blocks.
- **Middle row: every whole look.** One board per look shows it on the Lookbook's campaign stage. Switch a scene to any of them with `StyleKit.applyLook(id)`.
- **Back row: every pigment set.** Each board shows the Watercolor look on the campaign stage painted in that set, with the set's name and a strip of its own paints, built from the set when the scene is built. Switch a scene to any of them with `StyleKit.setPigments(id)`.
Labels, boards and the hero pedestal are left out of the stack by name (`exclude = { "GalleryLabels", "LookBoards", "PigmentBoards", "pedestal_hero" }`), so they stay as made after the scene is saved and loaded again. The GalleryView camera stands far back on a long lens, so the far rows are drawn nearly as large as the near pedestals and every label reads on the cover. Load the scene with `zero scene load watercolorBlocks.Gallery`.
Both switches work in a running game. During play, `StyleKit.applyLook("pictureBook")` turns the Watercolor recipe into Picture Book in one call. The look lives on the scene's synced StyleStack, so every player sees the change.
## Known limits
- The look runs after antialiasing, so offscreen captures do not show it; read the presented frame (#17427).
- A two-client editor sometimes refuses to load two different scenes at once (#24666, #24667).
- A world boot can wait about 30 s on a network handshake before any content starts (#24669).
- The web build was not checked from here (#20946).
# WatercolorHero (component)
Marks an entity whose materials `WatercolorHero.paint` replaced with watercolor surface materials, and remembers what each Model wore before so `WatercolorHero.unpaint` restores them. Synced and saved with the scene.
## Known limits
- Two engines on one account join as one player, so a two-player check needs two accounts or two machines (#14448).
- A world boot can wait about 30 s on a network handshake before any content starts (#24669).
- A two-client editor sometimes refuses to load two different scenes at once (#24666, #24667).
The package README's Known limits lists the rest.
# WatercolorHero (module)
The material form of the watercolor blocks for a hero object or a chosen set: `paint(target, opts)` gives every Model under the target a derived material on the `watercolorSurface` shader (base colour and texture kept, the scene's pigment set's shadow and light colours taken), so any published collection's material is used as it is; `unpaint(target)` puts every original back. Marks stay on the object as it moves.
## Known limits
- Two engines on one account join as one player, so a two-player check needs two accounts or two machines (#14448).
- A world boot can wait about 30 s on a network handshake before any content starts (#24669).
- The web build was not checked from here (#20946).
The package README's Known limits lists the rest.
The full-frame pass of the Backrun bloom style block (watercolorBlocks).
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# Backrun bloom (styleBlock, Fill)
Here and there a backrun (a bloom or cauliflower): water run back into a drying wash pushes the pigment outward into a paler bloom with a frilled, darker rim, inside flat washes only.
Settings: `amount` (0.6), `frequency` (0.015), `size` (1.2), `frill` (0.9), `rimDark` (0.3), `flatOnly` (0.8). Low quality changes no setting; like every block it runs at half resolution there, and the soft field at half of that.
It reads the frame, depth and the soft field. Surfaces are cut into patches `size` metres across, and a share of them (`frequency`) bloom: inside a lobed boundary bent by surface noise (`frill`) the paint is paler, and along it pigment gathers in a darker rim (`rimDark`). Blooms only form where the wash has paint in it and is even (`flatOnly`, read against the soft field), never on bare paper. It is the last block of the watercolor Fill chain (rank 80, stacking chain).
## What it gives up in motion
Blooms are laid on surfaces in world position, so they stay put on still things under any camera move, and they never appear or vanish on their own (nothing is re-seeded over time). They slide across moving characters and props. A bloom near a surface's edge can be cut where the surface ends, since the patch belongs to the surface.
## How it treats content
- Opaque things: a few pale blooms with frilled rims in flat, painted washes.
- Transparent things (glass, water): blooms are laid on the surface behind, so they can show through clear glass and still water.
- Particles and smoke: a bloom on the surface behind shows through soft smoke.
- Sky: never; a pale bloom in a thin sky wash reads as a hole, so the sky is left alone.
- Fog: lifted, pale distance carries little paint, so blooms there fade out by themselves.
- Skinned characters: blooms slide across a moving body; keep this block off characters with a group mask.
- Foliage: busy leaf masses are rarely flat enough to bloom, so foliage mostly stays clear of blooms.
- World text: a bloom over a sign can pale part of it; exclude labels a player must read.
- Black stays black: it returns through `sk_finish`, and blooms need paint in the wash, so an unlit pixel is never lifted.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
The full-frame pass of the Wet-in-wet bleed style block (watercolorBlocks).
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# Wet-in-wet bleed (styleBlock, Fill)
Neighbouring watercolor washes run softly into each other with feathered fringes where the paper was wet: the soft wet-in-wet edges of a painting, without ever smearing the foreground over the background.
Settings: `amount` (0.75), `wetness` (0.6), `patchSize` (0.3), `reach` (16), `feather` (0.6), `wobble` (1). Low quality draws the bleed with `reach` 10; like every block it runs at half resolution there, and the soft field at half of that.
It reads the frame, the soft field, depth and the shared wobble. Wet and dry patches are laid on surfaces (`wetness`, `patchSize`); inside a wet patch, where the colour around differs from here, the colour of the soft field one ring wider (`reach`) is mixed in as pigment, a little to one side that turns with fine surface noise (`feather`). A tap that falls on a nearer surface is refused, so a dark character never bleeds into the bright wall behind it. It sits after the wash in the Fill chain (rank 20, stacking chain), so it bleeds the wash's colours, not the raw render's.
## What it gives up in motion
The wet patches and the fringe direction are laid on surfaces, so they stay put on still things under any camera move. The bleed itself reads the screen-space soft field, so on a moving character the fringe moves with the character's edge every frame rather than sticking to a point: it softens the edge rather than smearing it. Fast motion of a high-contrast edge can show the fringe redrawing each frame as a soft shimmer. With a Time block the fringe trembles on the held clock.
## How it treats content
- Opaque things: colours run across edges where the paper was wet; dry patches keep crisp edges.
- Transparent things (glass, water): not in the depth, so the bleed treats them as the surface behind and runs their colour into that surface's neighbours; a window edge can bleed into the wall.
- Particles and smoke: no depth, so their colours run into the washes around them like any colour; that suits soft smoke and softens sharp sparks.
- Sky: the sky bleeds into the skyline where its colour differs, a wet sky against hills; things in front of the sky never bleed into it.
- Fog: fogged distance bleeds like any wash; since fog lowers colour differences, there is less bleed in fog.
- Skinned characters: their edges soften where a wet patch reaches them; nothing from behind runs onto them, since nearer surfaces refuse taps. Keep the bleed off a hero with a group mask when the silhouette must stay crisp.
- Foliage: leaf masses run into each other and into the sky, which reads as wet foliage; fine branches soften.
- World text: text edges are colour edges and bleed: exclude signs and labels a player must read.
- Black stays black: it returns through `sk_finish`, so an unlit pixel is never lifted.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
# coldPress (shader module)
The tooth of a rough cold-press watercolor paper (`wcp_paper_height`), shared by the Cold-press paper block's field and pass and by the watercolorSurface material, so hero objects sit on the same paper. Pure math; include after styleKit's skPatterns.
## Known limits
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
The full-frame pass of the Cold-press paper style block (watercolorBlocks): lays the picture on the paper.
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# Cold-press paper (styleBlock, Ground)
Rough cold-press watercolor paper with a deep tooth of felt bumps and cotton fibre: the painting is laid on its warm white, and the shared ground carries the tooth so granulation and dry brush settle into it. The paper texture for watercolor looks.
Settings: `paper` (`#f7f2e6`), `toothPx` (6), `roughness` (0.75), `emboss` (0.25). Low quality changes no setting; the field and the pass run at half resolution there, so the finest tooth softens.
As the first Ground block it publishes the shared ground: its field pass (`wcColdPressField`) writes the paper colour and the tooth's height, which `wcGranulation`, `wcDryBrush`, `depthLine`'s grain break and every other block that reads the ground use. Its full-frame pass multiplies the painting onto the paper colour and lights the tooth from the upper left (`emboss`). The tooth is irregular felt marks with fibre over them (`roughness`, 0 smooth hot-press to 1 rough), never a regular grid. Its material form is `coldPress.shaderModule` (`wcp_paper_height`), which the `watercolorSurface` shader includes, so a hero object is painted on the same paper.
## What it gives up in motion
The tooth stays on surfaces in world position and keeps its size in the picture by blending two sizes of tooth with distance, so walking toward a wall the tooth grows into the next size rather than sliding or zooming. On the sky it is laid by view direction and stays put as the camera turns. It slides across moving characters and props; the hero material carries its own tooth on the object.
## How it treats content
- Opaque things: laid on the warm paper with a lit tooth; whites become the paper's own white.
- Transparent things (glass, water): the tooth is the surface behind, so glass and water show the paper of what is behind them.
- Particles and smoke: multiplied onto the paper like everything else, with the tooth of what is behind.
- Sky: laid on the paper with the tooth by view direction; a bare sky reads as the sheet.
- Fog: fogged distance is laid on the paper; with `wcPaperFade` it lifts to the paper's own colour.
- Skinned characters: on paper like everything, but the tooth slides across a moving body.
- Foliage: on paper like everything; the tooth is too fine to fight leaf detail.
- World text: the tooth's emboss lightly textures text; exclude labels a player must read so they stay exact.
- Black stays black: it multiplies onto the paper and returns through `sk_finish`, so an unlit pixel stays black, never paper white.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
The field pass of the Cold-press paper style block (watercolorBlocks): publishes the shared ground.
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
The full-frame pass of the Dry brush style block (watercolorBlocks).
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# Dry brush (styleBlock, Fill)
Broken dry-brush strokes that skip over the peaks of the paper's tooth, leaving flecks of bare paper inside the wash in patches where the brush ran dry: rough, textured watercolor for walls, paving, bark and grass.
Settings: `amount` (0.45), `coverage` (0.25), `strokePx` (10), `stretch` (7), `angle` (0.35), `bite` (0.3), `preferLight` (0.6), `wobble` (1). Low quality changes no setting; like every block it runs at half resolution there, so strokes are softer.
It reads the frame, depth, the shared ground and the shared wobble. In patches a few metres across where the brush ran dry (`coverage`), strokes of `strokePx` reference pixels, `stretch` times as long as wide, dragged at `angle`, skip the tooth's peaks and leave bare paper (`amount`; `bite`, where higher is drier: 0 lets the paint reach nearly every peak, 1 leaves it only in the valleys), mostly in lighter passages (`preferLight`). The tooth comes from the shared ground, so it pairs with `wcColdPress`. It sits after the granulation in the Fill chain (rank 65, stacking chain). Its material form is the dry brush inside `wcPaint.shaderModule`.
## What it gives up in motion
Strokes stay on surfaces and keep their size in the picture: walking closer they grow into the next size of stroke rather than sliding or zooming. Dry patches are laid on surfaces too, so both stay put on still things under any camera move. Both slide across moving characters and props, because they come from world position. With a Time block the strokes tremble on the held clock.
## How it treats content
- Opaque things: rough flecks of bare paper inside lighter washes, in dry patches.
- Transparent things (glass, water): strokes are laid on the surface behind, so a window shows the dry brush of the wall behind it.
- Particles and smoke: strokes from the surface behind show through soft smoke.
- Sky: never dry brushed; the sky is skipped.
- Fog: pale, lifted distance is lighter and so takes more dry brush by `preferLight`; lower `coverage` with a depth mask if far things sparkle too much.
- Skinned characters: strokes slide across a moving body; keep this block off characters with a group mask, or use the hero material.
- Foliage: broken strokes read well on grass and bark; fine leaves can lose small pieces to bare paper.
- World text: bare-paper flecks can break small text; exclude labels a player must read.
- Black stays black: it returns through `sk_finish`, so an unlit pixel is never lifted.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
The full-frame pass of the Edge darkening style block (watercolorBlocks).
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# Edge darkening (styleBlock, Fill)
Pigment collected at the rim of each wash as it dried: a soft, darker gradient just inside the edge of the darker wash, not an outline, the hallmark of real watercolor painting.
Settings: `amount` (1.8), `width` (1.6), `threshold` (0.04), `wobble` (1). Low quality changes no setting; like every block it runs at half resolution there, and the soft field at half of that, so rims are a little wider and softer.
It reads the frame, the soft field, depth and the shared wobble. Rims belong to shapes, not texture: where the wash this pixel sits in (the soft field) is denser than the wash a ring wider (`width`) by more than `threshold`, the pixel is just inside a darker shape's edge, and pigment is added there (`amount`) as a soft gradient over the field's width, keeping the paint's own hue and never driving it to black. A mortar line or a seam is not a wash edge and gets no rim, and a light passage inside the edge keeps its paper. It sits near the end of the Fill chain (rank 70, stacking chain), so it darkens the rims of the washes, glazes and pools before it. The soft radius of the whole stack (`StyleKit.options({ softRadius })`) sets how wide rims are. Its material form is the rim inside `wcPaint.shaderModule`.
## What it gives up in motion
Rims are found from the picture each frame, so they follow moving things exactly and never slide. Detailed textures under a thin wash show small rims of their own, which can shimmer under a pan; raise the wash's `flatten` and `abstraction`, or `threshold` here, to calm them.
## How it treats content
- Opaque things: a soft darker band inside the edge of every darker wash.
- Transparent things (glass, water): the edge of a tinted pane against the wall behind it is an edge in the picture and gets a rim, which reads as a painted pane.
- Particles and smoke: the denser side of a smoke edge gets a soft rim; small sparks can gain a dark ring, so lower `amount` or mask effects that must read exactly.
- Sky: a skyline gets a rim on the darker side (usually the land), never a hard outline; the sky itself is rimmed only where its own washes differ.
- Fog: fog lowers differences, so far edges are rimmed less.
- Skinned characters: rims follow a moving body exactly; the soft field never smears the background onto it.
- Foliage: leaf masses gain soft rims against the sky, which reads as painted foliage.
- World text: dark text gains a rim and can thicken; exclude labels a player must read.
- Black stays black: it returns through `sk_finish`, so an unlit pixel is never lifted.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
The full-frame pass of the Glazed layers style block (watercolorBlocks).
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# Glazed layers (styleBlock, Fill)
Rebuilds the picture from a few transparent watercolor glazes laid one over another, slightly off register, so overlaps get darker and richer and each glaze keeps a faint dried edge: layered, glazed watercolor.
Settings: `layers` (3), `amount` (0.8), `misregister` (0.5), `softness` (0.18), `edgeDark` (0.35), `patchSize` (0.5), `detail` (0.2), `wobble` (1). Low quality draws 2 layers; like every block it runs at half resolution there, and the soft field at half of that.
It reads the frame, the soft field, depth and the shared wobble. The paint's density is split into `layers` slices that follow the large shapes (the soft field) rather than texture noise; each slice is laid with its own wandering edge (`misregister`, `patchSize`), so where glazes overlap the paint is darker and where one falls short it is lighter, and a faint rim (`edgeDark`) sits just inside each glaze's edge. The slices add back up to the same paint, so overall value is kept. Only a share of the render's own texture survives under them (`detail`, 0.2 by default): the glazes are the painting, not a filter over the picture. It sits after the wash and bleed in the Fill chain (rank 30, stacking chain).
## What it gives up in motion
Glaze edges are thresholds of brightness, so a slow light change (a sunset, a cloud) sweeps them across a surface as moving steps instead of fading smoothly. The wander of each edge is laid on surfaces and stays put on still things under any camera move; on a moving character the glaze edges follow its shading each frame. With a Time block the edges tremble on the held clock.
## How it treats content
- Opaque things: rebuilt in glazes; smooth gradients become a few soft-edged layers.
- Transparent things (glass, water): treated as part of the surface behind them; their colour is glazed with it.
- Particles and smoke: no depth; a soft puff is cut into glaze steps by its brightness, which can show stepped rings on large smoke.
- Sky: a sky gradient becomes a few glazes with soft wandering edges, the way a graded sky is laid in layers; lower `amount` on the sky with a depth mask if the steps are too strong.
- Fog: fog's smooth falloff becomes stepped glazes; this reads well at 4 or more `layers`.
- Skinned characters: shading on a moving body is glazed each frame, so steps follow the body's light; nothing slides, but the glaze edges move as the body turns.
- Foliage: leaf masses take glazes by their large shapes; fine leaves are not cut into steps of their own.
- World text: small text keeps its edges but can gain a dried rim; exclude labels a player must read.
- Black stays black: it returns through `sk_finish`, so an unlit pixel is never lifted.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
The full-frame pass of the Granulation style block (watercolorBlocks).
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# Granulation (styleBlock, Fill)
Pigment settles into the paper's valleys and clumps into fine flecks, strongest for granulating pigments like ultramarine and the earths, never on the bare paper: the speckled, grainy texture of real watercolor.
Settings: `amount` (0.3), `clumps` (0.4), `clumpPx` (2.5), `granulation` (0.5). Low quality changes no setting; like every block it runs at half resolution there, so the finest flecks soften.
It reads the frame, depth, the shared ground and the scene's pigment set. The valleys come from the paper the first Ground block publishes (`sk_tooth`, so put `wcColdPress` in the Ground slot for a deep tooth); fine flecks (`clumps`, `clumpPx`) stay on the surface and keep their size in the picture at any distance (`sk_scaled_fbm`). With a pigment set picked each colour granulates as much as the pigments it is mixed from (ultramarine and earths a lot, staining pigments little); with none, `granulation` is used. Bare paper never granulates. It sits after the fade in the Fill chain (rank 60, stacking chain). Its material form is the granulation inside `wcPaint.shaderModule`.
## What it gives up in motion
The valleys come from the shared paper and the flecks stay on surfaces and keep their size in the picture, so both stay put on still things under any camera move; walking toward a wall the flecks grow into the next size of fleck rather than sliding or zooming. On a moving character or prop they slide, because they come from world position: paint a hero with `WatercolorHero.paint` (the `watercolorSurface` material) for flecks that stay on it.
## How it treats content
- Opaque things: paint settles into the tooth and flecks; heavier on granulating colours, none on bare paper.
- Transparent things (glass, water): the flecks are laid on the surface behind, so glass and water take the grain of what is behind them.
- Particles and smoke: grained by the surface behind them; soft smoke picks up a light speckle.
- Sky: the sky granulates on the paper laid by view direction, which reads as a grainy painted sky; pale skies near bare paper hardly grain.
- Fog: lifted, pale distance carries less pigment and so grains less.
- Skinned characters: grained, but the flecks slide across a moving body; use the hero material or a group mask on heroes.
- Foliage: leaf masses take grain like any wash; fine leaves can look noisier at low resolution.
- World text: speckle over small text lowers its contrast a little; exclude labels a player must read.
- Black stays black: it returns through `sk_finish`, so an unlit pixel is never lifted.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
The full-frame pass of the Thin light style block (watercolorBlocks).
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# Thin light (styleBlock, Fill)
Paints lit areas with less pigment so they thin toward the white paper, and lays a little warm or cool light over them, the way a watercolor painter leaves the lights: glowing, warm-lit watercolor highlights.
Settings: `threshold` (0.85), `softness` (0.3), `thin` (0.25), `temperature` (0.4), `shift` (0.35). Low quality changes no setting; like every block it runs at half resolution there.
It reads the frame, depth, the base colour (albedo), the frame as rendered (`rendered`) and the scene's pigment set, and finds light the same way `wcShadowPool` does (the rendered frame against its base colour, averaged over five taps, so surface texture never reads as light). Above `threshold` the paint is diluted toward the paper (`thin`) and glazed with a warm or cool tint (`temperature`, `shift`); with a pigment set picked the tint is the set's light colour. It sits after the shadow pools in the Fill chain (rank 45, stacking chain). Its material form is the thinned light inside `wcPaint.shaderModule`.
## What it gives up in motion
Light is read per pixel each frame, so the thinning follows moving lights and a turning sun exactly; nothing slides and nothing sticks to the screen. A fast light change (a lamp switched on, a flash) makes the lights brighten at once, with no painterly lag.
## How it treats content
- Opaque things: lit faces thin toward the paper and take the light tint; shadowed faces are left as they came.
- Transparent things (glass, water): bright reflections on glass and water read as lit and thin toward the paper, which suits painted glints.
- Particles and smoke: bright particles read as lit and thin toward paper; a bright effect can lose some of its colour, so keep `shift` low or mask effects that carry gameplay colour.
- Sky: left alone; the sky is never thinned by this block (use `wcPaperFade` for the sky).
- Fog: bright fog can read as lit and thin a little further toward the paper.
- Skinned characters: lit faces of a moving body thin and warm each frame, following its light exactly.
- Foliage: sunlit leaf tops thin and warm, which reads as light through the canopy.
- World text: light text can thin toward paper and lose contrast; exclude signs and labels a player must read.
- Black stays black: it returns through `sk_finish`, and only lit pixels are thinned, so an unlit pixel stays black.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
The full-frame pass of the Fade to paper style block (watercolorBlocks).
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# Fade to paper (styleBlock, Fill)
Lifts far things, fog and the sky toward the bare paper (a pale air wash at most) instead of toward grey, with clouds lifted out of the sky and an optional ragged unpainted margin at the sheet's edges: watercolor aerial perspective and a picture-book border.
Settings: `near` (15), `far` (120), `amount` (0.95), `sky` (0.6), `fog` (0.5), `air` (0.15), `skyClouds` (0.6), `cloudSize` (0.55), `margin` (0), `marginSoft` (0.12), `marginRough` (0.5). Low quality changes no setting; like every block it runs at half resolution there.
It reads the frame, depth and the scene's pigment set. Between `near` and `far` metres things are mixed as pigment toward a pale air wash (the pigment set's air colour, or bare paper with none); greyed, foggy distance lifts further (`fog`). The sky is lifted by `sky`, more toward the horizon, and patches of it are lifted back to bare paper as clouds (`skyClouds`, `cloudSize`). With `margin` above 0 the painting stops at a still, ragged edge of bare paper around the sheet. It sits after the light in the Fill chain (rank 50, stacking chain), so granulation, dry brush and rims come after it and are paler where it lifted.
## What it gives up in motion
The fade follows view distance, so things lift and come back smoothly as the camera moves toward and away from them. The lifted clouds are laid on the view direction and stay put in the sky as the camera turns. The margin belongs to the sheet, not to the world: it stays on the screen on purpose and does not move with the camera.
## How it treats content
- Opaque things: lift toward the paper with distance; near things are untouched.
- Transparent things (glass, water): they lift by the distance of the surface behind them, so a near window over a far view lifts like the view.
- Particles and smoke: they lift by the distance of what is behind them, so near smoke against the sky lifts as much as the sky.
- Sky: lifted by `sky`, paler toward the horizon, with clouds lifted out; at `sky` 1 it is bare paper.
- Fog: greyed, low-colour distance lifts further by `fog`, so the engine's fog becomes mist on paper instead of grey.
- Skinned characters: lift only when they are far away; a player close to the camera is never faded.
- Foliage: far trees lift into pale silhouettes, which reads as a painted landscape.
- World text: far text lifts and loses contrast like anything far; exclude labels a player must read from distance. The margin covers whatever is under it, so keep world labels away from the sheet's edges.
- Black stays black: it returns through `sk_finish`, so an unlit pixel is never lifted toward paper, the margin included.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
The full-frame pass of the Pooled shadows style block (watercolorBlocks).
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# Pooled shadows (styleBlock, Fill)
Paints shadows as denser, uneven pools of watercolor wash that lean toward a shadow colour (a violet, an indigo, a sepia) with pigment gathered at the shadow's edge: coloured, painterly watercolor shadows.
Settings: `threshold` (0.45), `softness` (0.25), `density` (0.5), `tint` (0.75), `uneven` (0.35), `poolSize` (0.8), `shadowColour` (`#54548c`), `contact` (0.8), `contactSize` (1.0). Low quality changes no setting; like every block it runs at half resolution there.
It reads the frame, depth, the base colour (albedo), the frame as rendered (`rendered`) and the scene's pigment set. How much light reaches a pixel is the rendered frame against its own base colour where the renderer gives one (the deferred path; two images aligned pixel for pixel, so surface texture cancels out and is never printed back as shade), and the rendered brightness otherwise (low tier, forward path), averaged over five taps. Pigment also pools where surfaces meet, whichever way the light falls (`contact`, `contactSize`): at the foot of a wall, under a crate, inside a corner, found from world positions on surfaces facing up, where water would collect. Where the light falls below `threshold`, or a meeting of surfaces closes in, the paint gets denser (`density`), mottled (`uneven`, `poolSize`), with a little more pigment along the shadow's edge, and leans toward the pigment set's shadow pigment, or `shadowColour` with no set picked (`tint`). It sits after the wash, bleed and glaze in the Fill chain (rank 40, stacking chain). Its material form is the pooled shadow inside `wcPaint.shaderModule`, which the `watercolorSurface` shader uses.
## What it gives up in motion
Shadow is read per pixel from the light each frame, so a moving shadow carries its pool with it and a moving light moves the pools exactly; nothing lags. The mottling inside a pool is laid on surfaces and stays put on still things, but slides across moving characters. A shadow edge that crosses `threshold` slowly (a sunset) moves smoothly, since the edge is soft by `softness`.
## How it treats content
- Opaque things: shadows pool and lean toward the shadow pigment; lit areas are left as they came.
- Transparent things (glass, water): they have no base colour of their own in the copy, so the light estimate is read from the surface behind; dark tinted glass can read as shadow and pool a little.
- Particles and smoke: no base colour or depth; dark smoke can read as shadow and take the shadow tint, bright sparks stay lit.
- Sky: left exactly as it came; the sky is never pooled.
- Fog: fogged distance is brighter than its surface, so far shadows pool less, which matches aerial perspective.
- Skinned characters: their own shading and shadows pool like any surface; the mottling slides on a moving body. Use `WatercolorHero.paint` for pools that stay on a hero.
- Foliage: the dark undersides of leaf masses pool into coloured shade, which reads as painted trees.
- World text: dark text can read as shadow and take the shadow tint; exclude signs and labels a player must read.
- Black stays black: it returns through `sk_finish`, and density only deepens paint (eased off where paint is already dark), so an unlit pixel stays black.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
The full-frame pass of the Watercolor wash style block (watercolorBlocks).
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# Watercolor wash (styleBlock, Fill)
Turns the whole scene into flat, graded, transparent watercolor washes mixed from a pigment palette, with the white of the paper as the only white: the base of every watercolor painting look.
Settings: `flatten` (0.85), `abstraction` (0.85), `reach` (8), `body` (1.8), `dilution` (0.0), `pigmentPull` (1.0), `grade` (0.35), `gradeSize` (0.2), `whitePoint` (0.96), `wobble` (1). Low quality draws the wash with `reach` 4 and one ring of samples instead of two; like every block it runs at half resolution there, and the soft field it reads at half of that.
It reads the frame, the soft field (a depth-aware blur of what it reads, never smearing a nearer thing onto a farther one), the shared wobble and the scene's pigment set. Each area becomes one flat wash through a generalized Kuwahara filter (`flatten`, `reach`): four overlapping sectors around the pixel are averaged and the calmest win, so detail thinner than the brush (mortar, seams, a thin outline) dissolves while the edge between two areas stays put, and a tap on a nearer surface is refused so foreground never runs onto background. Then texture inside one shape (wherever the soft field barely changes: a tile grid, brick, wood grain, however strong) is let go into the soft field (`abstraction`), while at a shape's boundary the filtered edge is kept, the result is read as paint on paper, given more pigment in the middle values (`body`), re-mixed from the pigment set (`pigmentPull`, nothing with no set picked), thinned with water (`dilution`) and graded heavier and lighter across each surface. It is the first block of the watercolor Fill chain (rank 10, stacking chain): every later Fill block from watercolorBlocks reads what the wash made. Its material form is `wcPaint.shaderModule`, which the `watercolorSurface` shader includes for hero objects (`WatercolorHero.paint`).
## What it gives up in motion
Detail inside an area of colour is let go, so small texture that was there in the render is gone in the painting. The grading is laid on surfaces in world position, so it stays put on still things while the camera pans, dollies or orbits, but slides across moving characters and moving props. The flattening is found from the picture each frame, so a thin pattern moving under it (a fence passing a wall) can show soft shimmer where it changes which area it belongs to. With a Time block in the stack the wash edges tremble on the held clock (`wobble`), never per frame.
## How it treats content
- Opaque things: washed as described; real colour edges and depth edges stay, texture inside a surface is let go.
- Transparent things (glass, water): they are not in the depth, so the wash reads them as part of the opaque surface behind and averages their colour with it; a pane over a wall becomes one wash. Clear glass mostly vanishes into the wash behind it, tinted glass keeps its tint as a hue shift.
- Particles and smoke: no depth either, so soft smoke is flattened into the wash behind it and small sparks can be averaged away. Strong, bright effects stay readable; keep small gameplay effects out with a mask or `exclude` if they must read exactly.
- Sky: washed like a surface, graded by view direction so the grading stays put in the sky as the camera turns; a bright sky above `whitePoint` reads as bare paper.
- Fog: the fogged colour is washed and re-mixed like any colour, so fog stays as a pale wash; add `wcPaperFade` to lift it toward the paper instead.
- Skinned characters: washed like everything else; the grading slides across a moving body. For washes that stay on a hero, use `WatercolorHero.paint` and keep this block off it with a group mask.
- Foliage: leaves on one depth plane flatten into one mass of colour, which reads as a painted tree; thin, far branches can soften away.
- World text: small text inside a wash is averaged and blurred and can become unreadable: put signs and labels a player must read in `StyleKit.options({ exclude = { id } })`.
- Black stays black: it returns through `sk_finish`, so an unlit pixel is never lifted toward paper; with every light off the frame stays black.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
# Crisp and glazed (whole look)
Clean, controlled washes built up in transparent glazes with crisp dried edges: the patient layered look of a botanical plate or an architectural study.
Blocks: wcWash (light simplification), wcGlaze (four layers, strong rims), wcShadowPool, wcLightThin, wcPaperFade (lifted clouds), wcEdgeDarken (strong), wcColdPress (smoother paper). Pigments: brightBotanical. No bleeds, blooms or dry brush.
Apply it with `StyleKit.applyLook("crispAndGlazed")`; keep your own line with `StyleKit.applyLook("crispAndGlazed", { keep = { "line" } })`. Every block in it can be removed, swapped or retuned afterwards like any other entry.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
# Dry and sketchy (whole look)
Thin, dry paint dragged over very rough paper with a soft pencil line: lots of bare paper sparkling through broken strokes, in sepia.
Blocks: wcWash (more water), wcDryBrush (over half the picture), wcGranulation (heavy), wcPaperFade (the sky left as paper), wcEdgeDarken, sketchLine (a light pencil), wcColdPress (very rough). Pigments: sepiaSketch.
Apply it with `StyleKit.applyLook("drySketchy")`; keep your own line with `StyleKit.applyLook("drySketchy", { keep = { "line" } })`. Every block in it can be removed, swapped or retuned afterwards like any other entry.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
# Loose and wet (whole look)
Big soft washes that run into each other, little detail, strong blooms and dark wet rims: a fast, loose wet-in-wet sketch.
Blocks: wcWash (heavily simplified), wcBleed (wet almost everywhere), wcShadowPool, wcPaperFade, wcGranulation, wcEdgeDarken (strong), wcBackrun (frequent), wcColdPress. Pigments: coolMorning. A wider soft field (14) for the bleeds.
Apply it with `StyleKit.applyLook("looseAndWet")`; keep your own line with `StyleKit.applyLook("looseAndWet", { keep = { "line" } })`. Every block in it can be removed, swapped or retuned afterwards like any other entry.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
# Misty landscape (whole look)
Everything beyond the near ground dissolves into wet mist and bare paper, with soft bleeds and granulating greys: a damp morning landscape.
Blocks: wcWash, wcBleed (very wet), wcShadowPool, wcPaperFade (near fade, heavy fog lift, clouds), wcGranulation, wcEdgeDarken (soft), wcColdPress. Pigments: coolMorning. A wide soft field (16).
Apply it with `StyleKit.applyLook("mistyLandscape")`; keep your own line with `StyleKit.applyLook("mistyLandscape", { keep = { "line" } })`. Every block in it can be removed, swapped or retuned afterwards like any other entry.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
# Night painting (whole look)
Indigo washes pooled deep in the shadows with warm lamplight thinning toward the paper: a night scene painted in watercolor, still readable.
Blocks: wcWash, wcBleed, wcShadowPool (deep indigo), wcLightThin (warm lamp light), wcPaperFade (dusk air), wcGranulation, wcEdgeDarken, wcColdPress. Pigments: nightIndigo.
Apply it with `StyleKit.applyLook("nocturne")`; keep your own line with `StyleKit.applyLook("nocturne", { keep = { "line" } })`. Every block in it can be removed, swapped or retuned afterwards like any other entry.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
# Picture book (whole look)
Soft pale washes in spring pastels, a gentle brown pencil line, warm light and a wide white margin where the painting fades to the paper: a children's picture book page.
Blocks: wcWash (more water), wcBleed (gentle), wcShadowPool (lavender), wcLightThin (warm), wcPaperFade (white margin), wcEdgeDarken (soft), sketchLine (gentle brown), wcColdPress. Pigments: springPastel.
Apply it with `StyleKit.applyLook("pictureBook")`; keep your own line with `StyleKit.applyLook("pictureBook", { keep = { "line" } })`. Every block in it can be removed, swapped or retuned afterwards like any other entry.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
# Urban sketch with a line (whole look)
A confident ink line over loose washes that do not quite fill it, in ink and tea: the travel sketchbook page of a city street.
Blocks: wcWash, wcGlaze, wcShadowPool, wcDryBrush, wcPaperFade, wcEdgeDarken, depthLine (a warm ink line), wcColdPress. Pigments: inkAndTea. Swap the line for a pencil with StyleKit.swap("line", "sketchLine").
Apply it with `StyleKit.applyLook("urbanSketch")`; keep your own line with `StyleKit.applyLook("urbanSketch", { keep = { "line" } })`. Every block in it can be removed, swapped or retuned afterwards like any other entry.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
# Watercolor (whole look)
Every watercolor block together on rough cold-press paper with earth pigments: graded washes, wet bleeds, glazes, pooled violet shadows, warm thinned lights, granulation, dry brush, darkened rims, backruns and lifted clouds. The look the Watercolor recipe is tuned on.
Blocks: wcWash, wcBleed, wcGlaze, wcShadowPool, wcLightThin, wcPaperFade, wcGranulation, wcDryBrush, wcEdgeDarken, wcBackrun, wcColdPress. Pigments: earthy.
Apply it with `StyleKit.applyLook("watercolor")`; keep your own line with `StyleKit.applyLook("watercolor", { keep = { "line" } })`. Every block in it can be removed, swapped or retuned afterwards like any other entry.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it (#17427).
- Per-object settings (a style channel or a game role) reach it through the shared object mask, at most eight distinct settings a scene. A per-object value cannot reach a geometry pass, so a per-object look that needs one draws passes of its own (#24549).
- Its passes are queued again every frame, even when nothing changed (#24548).
The package README's Known limits lists the rest.
# Autumn forest (pigment set)
Quinacridone gold, burnt orange, olive, alizarin and a deep violet: a rich autumn woodland palette.
Foliage turns gold and rust, shadows pool into warm violet, and distance lifts into a hazy gold air.
Use it with `StyleKit.setPigments("autumnForest")`, or through a whole look that names it. Every watercolorBlocks block that reads pigments (wash, pooled shadows, thin light, fade to paper, granulation) mixes from it.
## Known limits
- It shows only through the blocks that read it, which run after antialiasing, so offscreen captures do not show it (#17427).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.
# Bright botanical (pigment set)
Clean, saturated greens, yellows, roses and violets: a crisp botanical-plate palette for gardens and cheerful scenes.
Low-granulating, staining pigments keep washes clean; shadows lean to a cool cobalt violet and lights stay bright.
Use it with `StyleKit.setPigments("brightBotanical")`, or through a whole look that names it. Every watercolorBlocks block that reads pigments (wash, pooled shadows, thin light, fade to paper, granulation) mixes from it.
## Known limits
- It shows only through the blocks that read it, which run after antialiasing, so offscreen captures do not show it (#17427).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.
# Cool morning (pigment set)
Ceruleans, cobalt, viridian and a touch of lemon and rose under a pale blue light: an early, misty, fresh palette.
Shadows lean blue-grey, lights take a cool silver, and distance lifts into a pale blue-white air.
Use it with `StyleKit.setPigments("coolMorning")`, or through a whole look that names it. Every watercolorBlocks block that reads pigments (wash, pooled shadows, thin light, fade to paper, granulation) mixes from it.
## Known limits
- It shows only through the blocks that read it, which run after antialiasing, so offscreen captures do not show it (#17427).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.
# Earth pigments (pigment set)
Ochres, siennas and umbers with sap green, cerulean and ultramarine: a warm, granulating landscape palette for brick, wood, stone and fields.
Shadows pool toward a soft violet, lights thin toward a warm cream, and distance lifts into a dusty paper. Ultramarine and the earths granulate strongly.
Use it with `StyleKit.setPigments("earthy")`, or through a whole look that names it. Every watercolorBlocks block that reads pigments (wash, pooled shadows, thin light, fade to paper, granulation) mixes from it.
## Known limits
- It shows only through the blocks that read it, which run after antialiasing, so offscreen captures do not show it (#17427).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.
# Single grey-blue (pigment set)
One blue-grey pigment only: a calm monochrome study where every form is a value of the same paint.
Values hold exactly; hue is gone. Good for a moody study or a menu background.
Use it with `StyleKit.setPigments("greyBlue")`, or through a whole look that names it. Every watercolorBlocks block that reads pigments (wash, pooled shadows, thin light, fade to paper, granulation) mixes from it.
## Known limits
- It shows only through the blocks that read it, which run after antialiasing, so offscreen captures do not show it (#17427).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.
# Ink and tea (pigment set)
Two paints only, an indigo ink and a tea brown: a two-colour journal palette where warm and cool split cleanly.
Warm colours take the tea, cool ones the ink, neutrals a mix of both; shadows lean ink-dark.
Use it with `StyleKit.setPigments("inkAndTea")`, or through a whole look that names it. Every watercolorBlocks block that reads pigments (wash, pooled shadows, thin light, fade to paper, granulation) mixes from it.
## Known limits
- It shows only through the blocks that read it, which run after antialiasing, so offscreen captures do not show it (#17427).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.
# Night indigo (pigment set)
Indigo, Prussian blue, Payne's grey and ultramarine violet with one warm lamp yellow: a night palette where lit things glow.
Shadows sink into deep indigo, lights take a warm lamp gold, and distance lifts into a dusk blue rather than white.
Use it with `StyleKit.setPigments("nightIndigo")`, or through a whole look that names it. Every watercolorBlocks block that reads pigments (wash, pooled shadows, thin light, fade to paper, granulation) mixes from it.
## Known limits
- It shows only through the blocks that read it, which run after antialiasing, so offscreen captures do not show it (#17427).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.
# Seaside (pigment set)
Turquoise, cerulean, sand, coral and a deep sea blue: a bright coastal summer palette.
Water and sky stay clean turquoise and cerulean, sand thins warm, shadows lean cool blue.
Use it with `StyleKit.setPigments("seaside")`, or through a whole look that names it. Every watercolorBlocks block that reads pigments (wash, pooled shadows, thin light, fade to paper, granulation) mixes from it.
## Known limits
- It shows only through the blocks that read it, which run after antialiasing, so offscreen captures do not show it (#17427).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.
# Sepia sketch (pigment set)
Sepia, raw umber and buff only: a warm brown monochrome for old travel sketches and journals.
Every colour becomes a value of brown; shadows deepen toward a dark sepia and lights thin to cream.
Use it with `StyleKit.setPigments("sepiaSketch")`, or through a whole look that names it. Every watercolorBlocks block that reads pigments (wash, pooled shadows, thin light, fade to paper, granulation) mixes from it.
## Known limits
- It shows only through the blocks that read it, which run after antialiasing, so offscreen captures do not show it (#17427).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.
# Spring pastel (pigment set)
Rose, lavender, mint, butter, sky and peach, all pale: a gentle high-key palette for picture books and soft spring scenes.
Nothing goes darker than a mid value, shadows lean to a soft lavender, and lights stay creamy.
Use it with `StyleKit.setPigments("springPastel")`, or through a whole look that names it. Every watercolorBlocks block that reads pigments (wash, pooled shadows, thin light, fade to paper, granulation) mixes from it.
## Known limits
- It shows only through the blocks that read it, which run after antialiasing, so offscreen captures do not show it (#17427).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.
# Warm evening (pigment set)
Cadmium orange, rose, burnt sienna and Indian yellow against a deep purple: a glowing golden-hour palette.
Shadows pool toward a deep violet, lights glow amber, and distance lifts into a peach-tinted air.
Use it with `StyleKit.setPigments("warmEvening")`, or through a whole look that names it. Every watercolorBlocks block that reads pigments (wash, pooled shadows, thin light, fade to paper, granulation) mixes from it.
## Known limits
- It shows only through the blocks that read it, which run after antialiasing, so offscreen captures do not show it (#17427).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.
# watercolorSurface (shader)
The material form of the watercolor blocks for a hero object or a chosen set: wash, pooled shadow, thin light, granulation in the paper's tooth, a little dry brush and a darkened rim, painted by the same rules (wcPaint, coldPress) as the full-frame blocks, with every mark laid on the object's own position so it stays on a moving character. Takes `base_color` and `base_color_texture` like the published collections' materials. Applied with `WatercolorHero.paint(entity)` (it writes a derived material that keeps the collection untouched).
## Known limits
- A post-process shader has no surface preview image.
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# wcPaint (shader module)
The watercolor rules every watercolorBlocks block follows, as pure math: paint held as transmittance on white paper (`wcp_paint`, `wcp_show`), granulation in the paper's valleys, a dry brush skipping the tooth, shadows as denser pooled washes, lit areas thinning with a warm or cool tint, and a darkened wash rim. The full-frame blocks and the `watercolorSurface` material include it, so a hero object painted in its material matches the full-frame washes around it. Include after styleKit's `skPigment` and `skPatterns`.
## Known limits
- A pass reads the scene's depth only when it also writes the scene picture (#24550), and an unknown blend name draws as replace (#24551).
- A per-object value cannot reach a geometry pass (#24549).
The package README's Known limits lists the rest.
# watercolorBlocks tests
Checks the package against the rules: every block passes styleKit's block check and sits in its slot with its rank, chain stacking orders a stack whatever order blocks are added in, a Fill block swaps and removes in one change, every whole look applies in one change with its pigment set (and keeps a slot when asked), every pigment set loads into the palette, and a hero material paints and unpaints exactly. The scene's shared stack is saved first and put back after. Run with `asset.resolve("watercolorBlocks", "testSuite"):run()`.
## Known limits
- Frame tests read the presented frame, so a run needs a drawn view, and a busy machine moves the timing checks (#24548).
- A two-client editor sometimes refuses to load two different scenes at once (#24666, #24667).
- The web build was not checked from here (#20946).
The package README's Known limits lists the rest.
# watercolorWorld
Turn an existing world, scene or installed kit into a watercolor painting with watercolorBlocks and styleKit, without breaking or losing anything.
## What it does
1. **Survey.** Reads what is there before changing anything: the scene's entities, the materials in use (toon, outlined, emissive, glass and water), the lights and whether they change over time, the screen UI, particles, the player and other characters, world labels, colours that carry gameplay meaning, any stack already in place, and the watercolor blocks, whole looks and pigment sets installed.
2. **Reference.** Saves the unpainted presented frame under `/zero/source/tmp/watercolor/<subject>/` and generates a reference painting of the same view with image generation (the `image_gen` service), so the tuning has a target to look at.
3. **Choose.** Picks a whole look (`watercolor`, `looseAndWet`, `crispAndGlazed`, `drySketchy`, `pictureBook`, `urbanSketch`, `mistyLandscape`, `nocturne`) or the watercolor blocks one by one, and a pigment set, with a reason for each.
4. **Build.** Builds the stack in one call that replaces rather than duplicates: `StyleKit.applyLook(id)` or `StyleKit.load(entries, { pigments, softRadius })`.
5. **Tune.** Up to three rounds of comparing presented frames against the reference painting and the asked look, adjusting settings, strengths, the pigment set and the soft radius.
6. **Heroes and UI.** Paints the player and hero characters inside their own materials with `WatercolorHero.paint` (only when allowed) and keeps the full-frame Fill blocks off them with a group mask; excludes world labels; keeps gameplay colours readable; checks screen UI contrast.
7. **Check.** UI and labels readable, gameplay colours kept, black stays black, no flashing above 3 Hz and no fine high-contrast stripes, the Lookbook's numbers for the new stack against the old one, and the low quality tier.
8. **Report.** Answers with the look, the pigment set, the stack, every exclusion, group and mask, every painted hero with the call that restores it, the checks, the Lookbook numbers and how to remove it all.
It is non-destructive: the stack edits no material and comes off with `StyleKit.clear()` (or by deleting the `StyleStack` entity). Hero materials are derived copies written under `/zero/source/watercolorHero`, the originals recorded on a synced `WatercolorHero` component; `WatercolorHero.unpaint(id, { removeFiles = true })` puts each one back. Hero painting happens only when the run allows it (the default; pass `heroes = false` to keep to the stack).
## What it needs
styleKit 1.1.0 and watercolorBlocks installed. The reference painting uses the `image_gen` service (it spends credits; the run carries on without one if generation fails, and says so). The Lookbook check uses lookbookKit when the world has it and says so when it does not.
## Starting it
zero workflow start --name watercolorWorld --args '{"subject":"main","look":"a picture book page with crisp characters"}'
`subject` names the world, scene or kit (default: the loaded scene); `look` is the painting in the asker's words (default: the run proposes one); `heroes` lets it paint hero characters inside their materials (default true).
## Known limits
- Installing a package with several dependencies can take a while (#21420).
- ZeroMind's description of this can lag one release behind what is installed (#19258).
- The web build was not checked from here (#20946).
The package README's Known limits lists the rest.
# styleBlock (asset type)
A styleBlock is one stackable piece of an art style. It sits in one of ten slots (Surface, Light, Fill, Tone, Line, Colour, Ground, Time, Raster, Medium), it states what it reads and what it writes, and the styleKit stack runs it over the whole frame after antialiasing. Any block swaps for any other block of its slot with no other change.
## Folder shape
A block is a plain folder holding the block asset and its shader side by side:
```
blocks/posterize/
posterize.styleBlock/ the block: block.yaml, README.md, .metadata (all required)
posterize.shader/ the post-process shader the stack runs
posterizeField.shader/ optional: the shader that writes a shared field (Ground or Time blocks)
posterize.shaderModule/ optional: the piece a material includes for a chosen set of objects
```
Paths in `block.yaml` are relative to the plain folder. The shader sits beside the `.styleBlock` rather than inside it, because a shader nested inside another asset folder is not listed by the engine and could not be found without a computed lookup that would block publishing.
The quickest way to start one is `StyleKit.newBlock("myTint", { slot = "colour" })` (written to `/zero/source/myBlocks/myTint`, or the `folder` you pass), which writes the whole folder, block and shader, and registers it at once. `asset.create("styleBlock", name, { slot = "line" })` writes only the `.styleBlock` files; write the `<name>.shader` beside it yourself.
## block.yaml
```yaml
name: "Posterize"
slot: colour # surface light fill tone line colour ground time raster medium
version: "1.0.0"
summary: "Cuts the picture into a few flat tone steps."
reads: [frame] # frame depth normal albedo motion ground wobble clock mask soft pigments rendered paper sun
writes: [frame] # frame, and field:ground, field:paper (Ground) or field:wobble (Time) when it has a field
stacking: layer # optional: layer (default) or chain
rank: 10 # optional: StyleKit.add places it before the first block of its slot with a higher rank
keepDim: false # optional: true keeps a dim room dim under this block (the dim guard); defaults to true in the Tone slot, false elsewhere
shader: posterize.shader # relative to the plain folder
field: { name: ground, shader: plainPaperField.shader } # optional, Ground and Time only
include: posterize.shaderModule # optional
settings: # every non-sk_ property of the shader, with what it means
levels: "How many steps each channel keeps."
defaults: # optional: this block's own defaults over the shader's (many blocks, one shader)
levels: 4
quality: # optional per-tier overrides of settings
low: { samples: 4 }
```
A Ground block's `field` may also name a paper-field shader and say that it layers (styleKit 1.2.0):
```yaml
field: { name: ground, shader: paperField.shader, paper: paperTakes.shader, layers: true }
writes: [frame, field:ground, field:paper]
```
- `paper`: a shader that publishes the paper field (`sk_paper`: r thirst -1 hard-sized to +1 thirsty, 0 the standard sheet; g sheen; b fibre; a dark ground 0 to 1) for blocks that read `paper`. It is run only when a live block reads it. A Ground block without one leaves the paper field neutral (every value 0). Add `field:paper` to `writes`.
- `layers: true`: when this block is not the first Ground block in the stack, it lays its ground (and its paper field) over the one before by its strength and mask, instead of being ignored as a later field. Its field shaders receive the field before as `sk_ground` / `sk_paper` and mix over it (`sk_view.y` is 1 when they are layered).
`defaults` lets several blocks share one shader (paperBlocks' seventeen papers run on one): each key must be a setting the shader declares, it overrides the shader's default for this block on every tier (`quality` overrides come after it, an entry's own settings last), and `StyleKit.settingsOf(id)` reports it as the block's default.
The shader's `properties.yaml` starts with the styleKit shared header (the `sk_` properties) and then declares the block's own settings with their defaults and ranges. `StyleKit.checkBlock(id)` reports anything missing.
## Stacking and rank
- `stacking: layer` (the default): every block in a slot reads the slot's input, and later ones are laid over the earlier ones by strength and mask.
- `stacking: chain`: the block reads what the blocks before it in its slot made, so modifier blocks build on each other (a wash, then its granulation, then its darkened edges).
- `rank: <number>`: `StyleKit.add` places the block before the first block of its slot with a higher rank, so a chain lands in its intended order whatever order its blocks are added in. A block with no rank lands before the first block of its slot ranked 100 or more: give finishing blocks that must stay on top (a printed margin, a frame, weather laid over the picture) `rank: 100` and up with `stacking: chain`, and grain or a vignette added later goes under them instead of painting them out.
## Keeping a dark scene dark (keepDim)
`keepDim` (styleKit 1.4.0) asks for the stack's dim guard. While any live block declares it, two small passes run after the chain: they measure the stack's result against the frame as rendered and scale the result down wherever it comes out brighter than a dim room was, so a shading block's sheet and the light between its marks never brighten a dim or unlit room. Every mark keeps its shape, and in daylight or a well lit room the guard hands the result on exactly unchanged.
- Leave it out on a Tone block: every Tone block keeps dim unless it says `keepDim: false`. A new hatching, stipple or dots block gets the guard for free.
- Set `keepDim: true` on a block in another slot that lays a light sheet or light marks over the picture.
- Set `keepDim: false` on a Tone block that is meant to light up the dark (a glow, chalk marks on a black board).
## Published inputs (styleKit 1.8.0)
Beyond the five extra inputs, a block can read a texture another package computes: list `input:<name>` under `reads` and declare an `in_<name>` texture after the shared header. The producer calls `StyleKit.publishInput(name, texture)` on each machine and draws it before the stack runs; with nothing published the block reads black. `StyleKit.checkBlock` refuses a read without its texture and a texture without its read. The guide "Writing your own style block" has the whole recipe.
## Extra inputs
Five inputs come after the shared header, each declared straight after it and bound by the stack only when `reads` lists the matching word:
- `sk_soft` (`reads: soft`): a half-resolution, depth-aware blur of what the block reads, never smearing a nearer thing over a farther one. Read it through the `skSoft` shader module (`sk_soft_at`, `sk_soft_wide`, `sk_soft_depth`, `sk_soft_in_front`). Its width is the stack option `softRadius`.
- `sk_pigments` (`reads: pigments`): the scene's pigment set as a 16 x 1 palette. Read it through the `skPigmentSet` shader module (`skg_has_set`, `skg_pigment`, `skg_shadow`, `skg_light`, `skg_air`, `skg_remix`).
- `sk_rendered` (`reads: rendered`): the frame as it entered the stack, before any block changed it. Read it through the `skRendered` shader module (`sk_rendered_at`). Its use is a light estimate against `sk_albedo` (texture cancels out) or an original colour to restore.
- `sk_paper` (`reads: paper`, a texture, default black): the paper field the Ground blocks publish. Read it through the `skPaper` shader module (`sk_thirst`, `sk_sheen`, `sk_fibre`, `sk_dark_ground`). Where no Ground block publishes it every value is 0, so the block draws as it did without it. A Ground block's own paper-field shader declares it to read the field laid before it, without listing `paper` under reads.
- `sk_sun` (`reads: sun`, a float4): the direction toward the scene's first directional light, `w` 1 when it gives light. Read about once a second. Raking light and sheen use it.
`StyleKit.checkBlock` refuses a block that declares one of them without the word under `reads`, or lists the word without declaring the texture.
When an asset of this type registers on any machine (world load, install, a collaborator's new block arriving), the type's `onRegister` hands it to the styleKit library, so `StyleKit.blocks()` lists it and a stack can use it at once.
## Known limits
- An asset of this type registers when the engine indexes its files, a moment after they are written.
- ZeroMind's description of this can lag one release behind what is installed (#19258).
The package README's Known limits lists the rest.