# Gallery (scene)
The variety of inkBlocks 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 (`gallery/cover.texture`).
- **Front rows: every ink line and every ink fill.** Each pedestal holds the same still life. A light base ink wash (`inkWash`), plain paper and the line boil run over every pedestal but the first ("As rendered"), and each block is limited to its own pedestal by a sphere mask, so every pedestal shows the wash plus that one block: the five Line blocks (`inkPenLine`, `inkBrushLine`, `inkNibLine`, `inkSketchPen`, `inkDryLine`, which swap for each other with `StyleKit.swap("line", id)`) and the three chained Fill blocks over the wash (`inkPool`, `inkDryTexture`, `inkSplatter`). The "Ink wash" pedestal shows the base wash alone.
- **Middle row: every whole look.** One board per look shows it on the Lookbook's campaign stage from the reference camera: Ink drawing, Brush and wash, Noir ink, Spattered comic ink and Sketchbook pen. Switch a scene to any of them with `StyleKit.applyLook(id)`.
- **Back row: every ink colour.** Each board shows the Ink drawing look on the campaign stage in that ink set, with the set's name and a strip of its inks, built from the set when the scene is built. Switch a scene to any of them with `StyleKit.setPigments(id)`.
The gallery camera stands far back, so the base wash and the blocks run here with their distance settings pushed past the gallery (no low mist, no fade to paper and no line thinning before 150 to 400 m); in a game the blocks use their own defaults. The stack holds 11 entries on one StyleStack (`holdRate` 4, pigments `inkBlack`).
Labels and boards are left out of the stack by name (`exclude = { "GalleryLabels", "LookBoards", "InkBoards" }`), so they stay as made after the scene is saved and loaded again; the cards and frames use the unlit `gallery/boards/galleryCard` material so they read the same under any sky. The GalleryView camera stands far back on a long lens so the far rows are drawn nearly as large as the near pedestals; it draws `all !debug !EditorUI`, so editor gizmos never reach the inked frame. Load the scene with `zero scene load inkBlocks.Gallery`.
The boards are presented captures of `scenes.recipeLineAndWash` (reference board hidden) at the reference pose: position (7, 4.5, 15) looking at (0.5, 1.2, 0), 50 degree lens. They live in `gallery/looks`, `gallery/inks` and `gallery/boards`.
## 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).
# Ink boil (styleBlock, Time)
Makes every line and wash edge tremble together, redrawn on each step of the held clock, like hand-drawn animation where each frame is traced again.
Settings: `amount` (1.6 reference px), `size` (1.5 cells per metre), `calm` (0.5). It draws nothing itself: it publishes the stack's shared wobble, and every block that reads the wobble (the depth line, the sketch line, the flat wash) offsets its edges by it, so a wash and its ink line boil together on one clock. The stack's `holdRate` sets how often it is redrawn (8 steps a second by default).
## What it gives up in motion
Edges move a little on every held step even when the world stands still. That is the point of the block, and it never runs faster than the held clock, so it reads as drawn animation rather than as noise. Where one cell of its pattern would cover fewer than about 8 drawn pixels (far ground near the horizon, and more of the picture on the half-resolution low tier) the wobble fades out, full from 8 pixels a cell and none under 3, so it never jumps from pixel to pixel and breaks lines into dashes. The wobble pattern is laid on surfaces, so a pan does not drag it; it is re-seeded each step. The paper does not boil: grounds do not read the wobble.
## How it treats content
- Opaque things: their lines and wash edges wobble.
- Transparent things (glass, water): no lines of their own, so nothing boils on them.
- Particles and smoke: untouched.
- Sky: no edges to move, untouched; silhouettes against the sky boil.
- Fog: far edges calm with distance (`calm`), so a foggy horizon stays quiet.
- Skinned characters: their outlines boil like anything else.
- Foliage: leaf outlines boil, which can get busy; lower `amount`.
- World text: text outlines boil if a line block draws them; exclude labels that must stay steady.
- Black stays black: it moves edges, it adds no light.
## 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 Ink boil block: publishes the stack's shared wobble on the held clock.
## 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 Brush line style block (inkBlocks).
## 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.
# Brush line (styleBlock, Line)
A pointed ink brush line that tapers at both ends of every stroke and swells with pressure, heavier in shadow and on curves and thinner in the distance: the living line of brush and ink drawing, ink wash painting and bold illustration.
Settings: `width` (3.6), `ink` (`#0f0e0f`), `setInk` (1), `opacity` (1), `silhouette` (1), `crease` (0.8), `creaseAngle` (0.3), `contact` (0.45), `threshold` (0.02), `thinNear` (4), `thinFar` (45), `farWidth` (0.35), `fadeEnd` (140), `paperBreak` (0.1), `wobble` (1), `curve` (0.6), `taper` (0.18), `strokePx` (90), `pressure` (0.6), `lift` (0.1), `boil` (0.15). Low quality draws no contact lines (`contact` 0) and finds edges with one ring of taps instead of two; like every block it runs at half resolution there, and with no copy of the surface's colour and normals creases come from depth alone (so only within 25 m) and curves are not weighted.
It finds edges the same way as the pen line (silhouettes on the near side only, folds from depth kinks and copied normals, colour contacts faded out from 8 to 22 m) and reads the shared ground, the wobble, the held clock and the pigment set. What makes it a brush is the stroke: a noise laid on the surface's world position and kept about `strokePx` reference pixels long in the picture (two sizes blended by distance) sets where each stroke swells to full `width` and where it falls to `taper` of it, and where the noise is lowest the brush lifts off and leaves a small gap (`lift`). Where the picture is dark the hand presses harder and the line grows by up to `pressure` x 0.6; on curved surfaces it grows by `curve`. Distance thins it from `thinNear` to `thinFar` (down to `farWidth`) and fades it out by `fadeEnd`. The ink follows the picked ink set by `setInk`, as every inkBlocks line does; a watercolor set leaves the line its own `ink`. It swaps in one change with the other ink lines and with `depthLine` and `sketchLine`.
## What it gives up in motion
The edges are found again every frame, so the line stays on them under any camera move and follows moving things. The stroke rhythm (where a stroke swells, tapers and lifts) is laid on the surface and keeps its length in the picture: on still things it stays put while the camera pans, dollies or orbits, and as you walk closer it grows into the next size of stroke rather than sliding. On a moving character or prop the rhythm comes from world position, so the swells slide along the body's outline while it moves. With `boil` above 0 the rhythm shifts a little on each held step of the shared clock (never per frame); the default 0.15 reads as a calm living line, higher values as a restless one. Lines thinner than a pixel on far, thin things can shimmer, so they thin and fade with distance.
## How it treats content
- Opaque things: outlined with tapered, swelling strokes, heavier in shadow and on curves.
- Transparent things (glass, water): no depth, so glass and water get no line of their own and the edges behind them are brushed through them, over their colour.
- Particles and smoke: no outline around smoke or sparks; lines of things behind soft smoke are drawn on top of it. Dark smoke makes the picture darker, so lines behind it press a little heavier.
- Sky: never inked; a silhouette against the sky is drawn on the near side.
- Fog: lines come from depth, so fog does not thin them; distance does. With thick fog, set `fadeEnd` near the fog's far distance.
- Skinned characters: the outline follows every pose; the swell and taper pattern slides along a moving body. Keep it off a character with a group mask if that reads wrong, and off toon materials that draw their own outline (toonMaterials' ToonInk) so one thing owns each outline.
- Foliage: leaf edges brush into lively clumps near the camera, which suits ink painting; far branches can shimmer. Raise `threshold` or lower `fadeEnd` if trees read too busy.
- World text: outlined like any shape, and the heavy default `width` fills small letters in. Exclude labels a player must read by name: `StyleKit.options({ exclude = { "labelName" } })`.
- Black stays black: it returns through `sk_finish`, so the brush only darkens what is there and an unlit pixel stays black; with white ink, strokes on parts that get no light at all are held black too.
## 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 Dry brush line style block (inkBlocks).
## 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 line (styleBlock, Line)
A dry ink brush dragged along every edge: a broad, rough line broken by bristle streaks and the paper's tooth, heavier where the brush was reloaded: the scratchy, textured outline of dry-brush ink drawing, woodcut-like illustration and gritty comics.
Settings: `width` (3.4), `ink` (`#0f0e0f`), `setInk` (1), `opacity` (1), `silhouette` (1), `crease` (0.8), `creaseAngle` (0.3), `contact` (0.45), `threshold` (0.02), `thinNear` (4), `thinFar` (45), `farWidth` (0.35), `fadeEnd` (140), `paperBreak` (0.1), `wobble` (1), `curve` (0.5), `dryness` (0.5), `streakPx` (5), `stretch` (9), `strokePx` (140). Low quality draws no contact lines (`contact` 0) and finds edges with one ring of taps instead of two; like every block it runs at half resolution there, and with no copy of the surface's colour and normals creases come from depth alone (so only within 25 m) and curves are not weighted.
It finds edges the same way as the pen line (silhouettes on the near side only, folds, colour contacts faded out from 8 to 22 m) and reads the shared ground, the wobble and the pigment set. A load of ink lasts about `strokePx` reference pixels along an edge, laid on the surface: just after each reload the line is at full `width`, and as the ink runs low it narrows to 60% and gets drier. Bristle streaks about `streakPx` across and `stretch` times as long run along the edge's direction on screen, laid on the surface and kept at their size in the picture (two sizes blended by distance). Where a streak and a peak of the shared paper's tooth meet, the brush touches; the drier the brush (`dryness`), the more of the line it skips. This block breaks the line on the tooth through `dryness`; it declares `paperBreak` like every inkBlocks line, so settings carry over in a swap, but this shader does not read it. Distance thins the line from `thinNear` to `thinFar` and fades it by `fadeEnd`. The ink follows the picked ink set by `setInk`; a watercolor set leaves the line its own `ink`. It has no boil of its own and swaps in one change with the other ink lines and with `depthLine` and `sketchLine`.
## What it gives up in motion
The edges are found again every frame, so the line stays on them under any camera move. The streaks and the reloads are laid on the surface and keep their size in the picture, growing into the next size as you walk closer rather than sliding; on a moving character or prop they come from world position and slide along its outline. The streaks point along the edge's direction on screen, so they turn with an edge as the camera orbits. The broken edge follows the shared ground's tooth, so it changes with the paper picked (a rougher Ground block breaks it more). With a Time block it trembles with the stack on the held clock, never per frame. `streakPx` cannot go below 1.5 reference pixels, so the streaks never become fine stripes.
## How it treats content
- Opaque things: outlined with a broad, broken, streaky line, heavier on curves and just after each reload.
- Transparent things (glass, water): no depth, so glass and water get no line of their own; the edges behind them are dragged through them, over their colour.
- Particles and smoke: no outline around smoke or sparks; lines of things behind soft smoke are drawn on top of it.
- Sky: never inked; a silhouette against the sky is drawn on the near side.
- Fog: lines come from depth, so fog does not thin them; distance does. In thick fog set `fadeEnd` near the fog's far distance.
- Skinned characters: outlines follow every pose; streaks and reloads slide along a moving body. Keep it off toon materials that draw their own outline (toonMaterials' ToonInk) with a group mask, so one thing owns each outline.
- Foliage: leaf edges become a scratchy mass, which reads well as bark and brush; far branches can shimmer. Raise `threshold` or lower `fadeEnd` for calmer trees.
- World text: the broad broken line breaks small letters apart. Exclude labels a player must read by name: `StyleKit.options({ exclude = { "labelName" } })`.
- Black stays black: it returns through `sk_finish`, so the brush only darkens what is there and an unlit pixel stays black; with white ink, lines on parts that get no light at all are held black too.
## 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 Dry-brush ink texture style block (inkBlocks).
## 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 ink texture (styleBlock, Fill)
A nearly dry ink brush dragged across the darker passages, its bristles catching the peaks of the paper's tooth and leaving broken streaks of ink with paper between them: texture and grit for walls, ground, bark and shadow in ink drawings and comics, or fine hatch-like strokes in the middle tones.
Settings: `ink` (`#0d0b0d`), `setInk` (1), `amount` (0.6), `toneFrom` (0.3), `toneTo` (0.75), `strokePx` (9), `stretch` (5), `angle` (0.5), `bite` (0.5), `patchSize` (0.5), `coverage` (0.6), `fadeEnd` (40), `wobble` (1). Low quality changes no setting; like every block it runs at half resolution there, so the strokes are softer.
It reads the frame, depth, the shared ground and wobble, and the pigment set. It sits after the wash and the pooled black in the ink Fill chain (rank 60, stacking chain), so it reads the picture they made: the brush is dragged only through a band of its darkness, from `toneFrom` to `toneTo` (0 white, 1 black), which leaves bare paper and solid pools alone. Inside that band it works in patches about `patchSize` metres across laid on the surface (`coverage` of them), and inside a patch it draws streaks about `strokePx` reference pixels wide and `stretch` times as long, at `angle` on the surface, kept at their size in the picture by blending two sizes by distance. Where a streak meets a peak of the shared paper's tooth the bristles catch ink; the higher `bite`, the shallower they bite and the more paper shows between them. A stroke only adds ink and never lightens what is already darker, and the strokes fade out over the last third of the way to `fadeEnd`. The ink is `ink`, or the picked ink set's first paint by `setInk`; with a light ink (`inkWhiteOnDark`) the brush drags white ink through the brighter passages instead. With a small `strokePx`, a long `stretch` and a high `coverage` it reads as hatching (the `inkDrawing` look uses it that way).
## What it gives up in motion
Streaks and patches are laid on surfaces and keep their size in the picture, growing into the next size of stroke as you walk closer rather than sliding or zooming; under pan, dolly and orbit they stay on still things. On moving characters and props they come from world position and slide across the body. Which passages take strokes follows the picture's tone each frame, so a shadow moving over a wall moves the strokes' extent with it (the strokes themselves stay put on the wall). The tooth they catch on is the shared ground's, so they change with the paper picked. Nothing re-seeds on its own; with a Time block the strokes tremble with the stack on the held clock (`wobble`). `strokePx` cannot go below 2 reference pixels, so strokes never become fine stripes; on large walls keep `coverage` moderate with a long `stretch`.
## How it treats content
- Opaque things: middle-dark surfaces take broken streaks; paper-white lights and solid black pools are left alone.
- Transparent things (glass, water): no depth of their own, so strokes are laid on the surface behind the glass or under the water, over the glass's colour, where the picture there falls in the band.
- Particles and smoke: smoke in the tone band takes streaks laid on the surface behind it; bright sparks are out of the band and stay clear.
- Sky: never stroked.
- Fog: fogged distance is paler and drops out of the band, and strokes are gone by `fadeEnd` (70 m), so the distance stays clean.
- Skinned characters: a character's mid-tones take strokes that slide across a moving body; keep this block off characters with a group mask (`StyleKit.setMask("dry", { kind = "group", group = 1, invert = true })`).
- Foliage: shaded leaf masses and bark take scratchy strokes, which reads well as drawn trees; strokes stay in the world while swaying leaves move through them.
- World text: mid-tone signs take streaks that can break small letters. Exclude labels a player must read by name: `StyleKit.options({ exclude = { "labelName" } })`.
- Black stays black: it returns through `sk_finish`, and dark ink only darkens, so an unlit pixel stays black; white strokes on a part of the scene with no light at all are held black too.
## 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 Dip nib line style block (inkBlocks).
## 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.
# Dip nib line (styleBlock, Line)
A flexible dip pen nib line whose width swells and thins with the direction of the stroke and opens up on curves and in shadow: the lively thick-and-thin line of crow-quill and steel-nib ink drawing, engraving-like illustration and old book plates.
Settings: `width` (2.4), `ink` (`#0f0e0f`), `setInk` (1), `opacity` (1), `silhouette` (1), `crease` (0.8), `creaseAngle` (0.3), `contact` (0.45), `threshold` (0.02), `thinNear` (4), `thinFar` (45), `farWidth` (0.35), `fadeEnd` (140), `paperBreak` (0.1), `wobble` (1), `curve` (0.9), `hairline` (0.3), `nibAngle` (0.8), `flex` (0.35). Low quality draws no contact lines (`contact` 0) and finds edges with one ring of taps instead of two; like every block it runs at half resolution there, and with no copy of the surface's colour and normals creases come from depth alone (so only within 25 m) and curves are not weighted.
It finds edges the same way as the pen line (silhouettes on the near side only, folds, colour contacts faded out from 8 to 22 m) and reads the shared ground, the wobble and the pigment set. Before it draws, eight depth reads at the pixel tell which way the nearest edge runs on screen. A stroke that runs across the nib (held at `nibAngle` on the picture) lays the nib's full breadth, `width`; one that runs along it is a hairline of `hairline` x `width`; where no edge direction can be told, the nib lays its full breadth. The nib also opens up on curved surfaces (`curve`) and where the picture is dark (`flex`, the hand pressing harder). Distance thins it from `thinNear` to `thinFar` and fades it by `fadeEnd`. The ink follows the picked ink set by `setInk`; a watercolor set leaves the line its own `ink`. It has no boil of its own and swaps in one change with the other ink lines and with `depthLine` and `sketchLine`.
## What it gives up in motion
The line is found again every frame from depth, so it stays on its edges under any camera move. The thick and thin follow each edge's direction on screen, not on the surface: as the camera orbits an object a line turns smoothly from broad to hairline, the way the drawing itself would change if drawn again from there, but it does mean the weight along one edge changes while you circle it. Very short edges can pick a direction badly and read a little broad. Nothing is laid on surfaces except the paper break, which follows the shared tooth and slides along a moving character. With a Time block the line trembles with the stack on the held clock, never per frame.
## How it treats content
- Opaque things: outlined in thick and thin, broad across the nib, hairline along it, opened up on curves and in shadow.
- Transparent things (glass, water): no depth, so glass and water get no line of their own; the edges of what is behind them are drawn through them, over their colour.
- Particles and smoke: no outline around smoke or sparks; lines of things behind soft smoke are drawn on top of it, and a little broader where the smoke darkens the picture.
- Sky: never inked; a silhouette against the sky is drawn on the near side.
- Fog: lines come from depth, so fog does not thin them; distance does. In thick fog set `fadeEnd` near the fog's far distance.
- Skinned characters: the outline follows every pose, and its thick and thin turns as the limbs turn, which reads as drawn rather than sliding. Keep it off toon materials that draw their own outline (toonMaterials' ToonInk) with a group mask, so one thing owns each outline.
- Foliage: many short leaf edges each pick a direction, so a near tree becomes a crowd of hatched-looking strokes; far branches can shimmer. Raise `threshold` or lower `fadeEnd` for calmer trees.
- World text: outlined like any shape; the hairlines keep small letters a little more open than the brush, but labels a player must read belong in `StyleKit.options({ exclude = { "labelName" } })`.
- Black stays black: it returns through `sk_finish`, so the nib only darkens what is there and an unlit pixel stays black; with white ink, lines on parts that get no light at all are held black too.
## 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 Ink paper block: multiplies the picture onto warm paper with a fine tooth.
## 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.
# Ink paper (styleBlock, Ground)
Lays the whole picture on a warm white paper with a fine tooth, so light areas read as bare paper and every wash and line above shows the grain.
Settings: `paper` (warm white), `tooth` (0.35), `fibre` (0.3), `grainSize` (40 cells per metre). As the stack's first Ground block it also publishes the shared ground (paper colour and grain height), which a wash reads to granulate and a line reads to break like dry brush.
## What it gives up in motion
The grain is laid in surface coordinates, so it stays on walls and floors as the camera pans and dollies instead of sliding like a screen overlay. The price: on a moving skinned character the grain is taken from world position, so it slides across the body as it moves; and on surfaces seen edge-on the grain stretches. The sky takes its grain from the view direction.
## How it treats content
- Opaque things: multiplied onto paper, grain on their surface.
- Transparent things (glass, water): multiplied as they appear; the grain is that of the opaque surface behind.
- Particles and smoke: multiplied; their grain is that of what is behind them.
- Sky: becomes paper tinted by the sky colour; grain by view direction.
- Fog: multiplied; fogged distance reads as paper showing through.
- Skinned characters: multiplied; grain slides on the moving body (see above).
- Foliage: multiplied like any surface.
- World text: multiplied; dark text on light stays readable, light text loses a little brightness.
- Black stays black: paper multiplies the light, it never adds any.
## 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 Ink paper block: publishes the paper colour and grain as the stack's 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.
# inkPaperGrain (shader module)
The grain of inkBlocks' paper: `sbp_grain(coord, fibre, footprint)` returns a tooth height 0..1 mixing fine tooth, long fibres and soft mottling; `footprint` is how many grain cells one pixel covers (`fwidth` of the coordinate), and every detail finer than about two pixels fades to its mean so the tooth does not shimmer. It is pure math over styleKit's `skPatterns`, so the Ink paper's ground field, its picture pass and a material that wants the same tooth all agree. Include it in a material shader with `#include "~styleKit.shaders.skPatterns"` followed by `#include "~inkBlocks.blocks.inkPaper.inkPaperGrain"` to give an object the same tooth as the ink paper. For a fuller paper on an object (tooth lit by the scene's light, fibres, weave, every paper's settings) use paperBlocks' `paperSurface` material instead.
## 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 Pen line style block (inkBlocks).
## 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.
# Pen line (styleBlock, Line)
An even technical-pen ink line on silhouettes, folds and where one object meets another, a touch heavier on curves and thinner in the distance: the clean line of a pen-and-ink drawing, an architectural sketch or a line-and-wash painting.
Settings: `width` (1.5), `ink` (`#0f0e0f`), `setInk` (1), `opacity` (1), `silhouette` (1), `crease` (0.8), `creaseAngle` (0.3), `contact` (0.45), `threshold` (0.02), `thinNear` (4), `thinFar` (45), `farWidth` (0.35), `fadeEnd` (140), `paperBreak` (0.1), `wobble` (1), `curve` (0.25). Low quality draws no contact lines (`contact` 0) and finds edges with one ring of taps instead of two; like every block it runs at half resolution there, and with no copy of the surface's colour and normals creases come from depth alone (so only within 25 m) and curves are not weighted.
It reads depth, the copied normals and surface colour, the shared ground and wobble, and the scene's pigment set. Edges are found at the line's own width from inverse depth on two rings of opposite taps: a silhouette where depth jumps, drawn on the near thing's side only so two outlines never double up; a fold where depth kinks (every tier, faded out from 12 to 25 m, since the stack keeps depth in half floats and grazing far ground would ripple), or where the copied normals bend more than `creaseAngle` and depth kinks a little too (high and medium, at any distance), so a normal map (grass, brick, tiles) never draws folds; a contact where two surfaces at nearly the same depth each hold one steady colour and the two colours differ, so a texture's own pattern (grass tufts, gravel, brick) is left alone, faded out from 8 to 22 m so far ground never fills with specks. The weight is full up to `thinNear`, eases to `farWidth` of it by `thinFar`, is heavier on curved surfaces by `curve`, and the line fades out over the last third of the way to `fadeEnd`. `paperBreak` lets the valleys of the shared paper's tooth (from a Ground block such as `inkPaper`) break the line. The ink is `ink`, or the picked ink set's first paint mixed in by `setInk` (`StyleKit.setPigments("inkSepia")`); a set whose first paint is neither very dark nor very light (most watercolor sets) is ignored, so the line keeps its own ink over a watercolor palette. A white ink (the `inkWhiteOnDark` set) draws white lines. It is a Line block with layer stacking, so it swaps in one change with the other ink lines and with styleKit's `depthLine` and `sketchLine`: `StyleKit.swap("line", "inkPenLine")`.
## What it gives up in motion
Lines are found again every frame from depth, so they stay on their edges under pan, dolly, orbit and zoom and follow moving and animated things exactly. Nothing in the line itself is laid on surfaces except the paper break, which follows the shared tooth and so slides along a moving character. Parts thinner than a pixel (far railings, wires, thin branches) can shimmer as they move; that is why lines thin with distance and are gone by `fadeEnd`. The line has no boil of its own: with a Time block (`inkBoil`) it trembles with the rest of the stack on the held clock, never per frame.
## How it treats content
- Opaque things: outlined at silhouettes, folds and colour contacts at one even weight, a little heavier on curves.
- Transparent things (glass, water): they write no depth, so a pane or a water surface gets no line of its own, and the edges of what is behind it are drawn through it, over the glass's colour. A window shows the lines of the room behind; a pond shows the lines of its bed.
- Particles and smoke: no depth, so smoke, sparks and glows get no outline, and the lines of things behind soft smoke are drawn on top of it: thick smoke does not hide edges. Make effects that must read big and bright rather than fine.
- Sky: never inked. A silhouette against the sky is drawn on the near thing's side.
- Fog: lines come from depth, not colour, so fog does not thin them; distance does (`thinNear`, `thinFar`, `farWidth`, `fadeEnd`). In thick fog set `fadeEnd` near the fog's far distance so dark lines do not float in pale fog.
- Skinned characters: outlines follow every pose exactly, since they are found each frame. Toon materials that draw their own outline (toonMaterials' ToonInk) get a second line beside theirs: keep this block off them with a group mask (`StyleKit.options({ groups = { { id } } })`, `StyleKit.setMask("line", { kind = "group", group = 1, invert = true })`) so one thing owns each outline.
- Foliage: alpha-tested leaves write depth, so every leaf edge can draw and a near tree reads busy; far branches can shimmer. Raise `threshold`, lower `crease`, lower `fadeEnd`, or keep the line off far things with a depth mask.
- World text: text with depth is outlined like any shape, and small letters can fill in. Leave labels a player must read out of the stack by name: `StyleKit.options({ exclude = { "labelName" } })`.
- Black stays black: it returns through `sk_finish`, so the line only darkens what is there and an unlit pixel stays black; with white ink, lines on parts of the scene that get no light at all are held black too.
## 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 black style block (inkBlocks).
## 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 black (styleBlock, Fill)
Deep shadow settles into solid black ink with a ragged edge, and ink gathers where things meet the ground: the bold spotted blacks of noir ink, comics and woodcut-like ink illustration. On a dark ground with white ink it leaves deep shadow as bare ground.
Settings: `ink` (`#0a090a`), `setInk` (1), `threshold` (0.22), `softness` (0.06), `ragged` (0.5), `raggedSize` (1.5), `contact` (0.7), `contactSize` (0.5), `sheen` (0.15), `fadeEnd` (80), `wobble` (1). Low quality gathers no ink at contacts (`contact` 0); like every block it runs at half resolution there, and since the low tier makes no copy of surface colour, light is judged from the drawn brightness, so a dark material in full light (black paint, dark wood) can pool as if it were in shadow.
It reads the frame, depth, the copied surface colour (albedo), the frame as rendered, the wobble and the pigment set. How much light reaches a pixel is the frame as rendered against its own surface colour, averaged over five taps 3 reference pixels apart (texture cancels, so a dark texture in sun is not shadow); with no surface colour copy it is the drawn brightness. Where light falls below `threshold` (about 1 is full light), with a soft edge of `softness` made ragged by a noise laid on the surface (`ragged`, `raggedSize`), the shadow fills with solid ink. Ink also gathers where something stands on a surface facing up (the foot of a wall, under a crate): it looks up the picture for a surface a little higher within `contactSize` metres across the ground, whichever way the light falls (`contact`). A pool is not perfectly flat: `sheen` shows thinner, lighter patches in it. Pools only darken what is there, and fade out over the last third of the way to `fadeEnd`. The ink is `ink`, or the picked ink set's first paint by `setInk`; with a light ink (`inkWhiteOnDark`) deep shadow becomes the set's dark ground instead. It sits after the wash in the ink Fill chain (rank 40, stacking chain), the same rank as watercolorBlocks' `wcShadowPool`, so `StyleKit.swap("shadow", "inkPool")` trades watercolor's coloured shadows for spotted blacks in one change. Its `reads` lists `ground`, but this shader does not read the shared ground: pools are the same on any paper.
## What it gives up in motion
Pools follow the light the renderer drew each frame, so they move with shadows and stay on things under any camera move: a moving shadow carries its pool with it, and a shadow edge sweeping slowly over a surface moves the pool edge smoothly. The ragged edge and the sheen are laid on surfaces in world position, so they slide across moving characters. Contact pools are found by looking up the picture, so seen from straight above (a top-down camera) there is little above to find and they thin out. Thin shadows from far, thin things (railings, branches) can shimmer at the pool's hard edge, so pools fade out by `fadeEnd`.
## How it treats content
- Opaque things: surfaces in deep shadow turn solid black with a ragged edge; lit surfaces are left as they came.
- Transparent things (glass, water): not in the surface colour copy, so the light estimate reads the rendered pixel (glass included) against the surface behind; dark tinted glass can pool. A water surface pools like its bed.
- Particles and smoke: dark smoke over a lit floor lowers the light estimate and can pool solid black through the smoke; bright sparks and glows lift the light and never pool. Keep dark smoke effects light or mask the pool there.
- Sky: never pooled.
- Fog: fog brightens the rendered colour, so far shadows pool less, and pools are gone by `fadeEnd` (80 m), so the far distance stays light.
- Skinned characters: a character in deep shadow becomes a black silhouette, which suits noir but can hide the player; keep this block off the player with a group mask (`StyleKit.setMask("pool", { kind = "group", group = 1, invert = true })`). The ragged edge slides on a moving body.
- Foliage: the dark undersides of trees and the shade under a canopy become black masses, and dappled light gives ragged spotted blacks.
- World text: on high and medium dark lettering in light is not shadow and stays as it is; on the low tier dark text can pool. Exclude labels a player must read by name: `StyleKit.options({ exclude = { "labelName" } })`.
- Black stays black: it returns through `sk_finish` and pools only darken, so an unlit pixel stays black; with white ink the dark ground it lays is held at black where the scene had no light.
## 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 Sketchy pen style block (inkBlocks).
## 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.
# Sketchy pen (styleBlock, Line)
A loose, quick sketchbook pen line that wobbles off each edge and back, overshoots the corners and doubles up where the hand went over a line twice: the energy of a travel sketch, concept sketch or urban sketchbook drawing.
Settings: `width` (1.1), `ink` (`#0f0e0f`), `setInk` (1), `opacity` (1), `silhouette` (1), `crease` (0.8), `creaseAngle` (0.3), `contact` (0.45), `threshold` (0.02), `thinNear` (4), `thinFar` (45), `farWidth` (0.35), `fadeEnd` (140), `paperBreak` (0.1), `wobble` (1), `curve` (0.3), `strokes` (2), `wander` (2.2), `wanderPx` (120), `overshoot` (7), `boil` (0.25), `secondInk` (0.7). Low quality draws no contact lines (`contact` 0) and at most two passes (`strokes` 2); like every block it runs at half resolution there, and with no copy of the surface's colour and normals creases come from depth alone (so only within 25 m) and curves are not weighted. Each pass finds its edges with one ring of taps on every tier, since several passes already cost more than one line.
It draws each edge with `strokes` passes (1 to 3), each one an edge search like the pen line's (silhouettes on the near side, folds, colour contacts faded out from 8 to 22 m) moved off the true edge. Each pass wanders by up to `wander` reference pixels along a path laid on the surface's world position and about `wanderPx` long in the picture, and runs past the corners by `overshoot` along the edge's direction on screen, the first pass one way and the second the other. Later passes are lighter (`secondInk`), and every pass skips here and there along a quick stroke (a fixed pattern about 40 reference pixels long). A small part of each pass (`boil`) is redrawn on each held step of the shared clock. Width, wander and overshoot all thin with distance from `thinNear` to `thinFar`, and the line fades by `fadeEnd`. It reads the shared ground, the wobble, the held clock and the pigment set; the ink follows the picked ink set by `setInk`, and a watercolor set leaves the line its own `ink`. It swaps in one change with the other ink lines and with `depthLine` and `sketchLine`.
## What it gives up in motion
The edges are found every frame, so the passes stay with their edges under any camera move. Each pass's wander and its skips are laid on the surface and keep their size in the picture, so on still things they stay put while the camera moves; on a moving character or prop they come from world position and slide along its outline. The overshoot follows the edge's direction on screen, so it turns with the edge as the camera orbits. The boil redraws a small offset (up to `wander` x `boil` reference pixels) on each held step, never per frame: at the looks' hold rate of 8 drawings a second it reads as a nervous, living sketch; set `boil` to 0 for a still one.
## How it treats content
- Opaque things: outlined with one to three loose passes that overshoot corners and double up.
- Transparent things (glass, water): no depth, so glass and water get no line of their own and the edges behind them are sketched through them, over their colour.
- Particles and smoke: no outline around smoke or sparks; lines of things behind soft smoke are drawn on top of it.
- Sky: never sketched; a silhouette against the sky is drawn on the near side, though a wandering pass can stray a pixel or two onto the sky.
- Fog: lines come from depth, so fog does not thin them; distance does. In thick fog set `fadeEnd` near the fog's far distance.
- Skinned characters: outlines follow every pose; the wander and skips slide along a moving body, which reads as the sketch being redrawn. Keep it off a character with a group mask if that is distracting, and off toon materials that draw their own outline (toonMaterials' ToonInk) so one thing owns each outline.
- Foliage: every leaf edge drawn two or three times reads as scribbled foliage near the camera, which suits a sketch; far branches can shimmer. Raise `threshold`, lower `strokes` or `fadeEnd` for calmer trees.
- World text: doubled, wandering passes make small text hard to read. Exclude labels a player must read by name: `StyleKit.options({ exclude = { "labelName" } })`.
- Black stays black: it returns through `sk_finish`, so the passes only darken what is there and an unlit pixel stays black; with white ink, lines on parts that get no light at all are held black too.
## 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 Splatter and drips style block (inkBlocks).
## 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.
# Splatter and drips (styleBlock, Fill)
Flicked ink splats with spiky rims and thrown droplets sitting on surfaces, drips running down walls to a bead, and a fine spray where things meet: the energy of spattered comic ink, gritty illustration and expressive ink drawing.
Settings: `ink` (`#0a090a`), `setInk` (1), `amount` (0.18), `cellSize` (0.9), `size` (0.5), `spikes` (0.5), `droplets` (0.6), `drip` (0.5), `spray` (0.6), `sprayReach` (40), `opacity` (0.95), `accentShare` (0), `seed` (0), `fadeEnd` (60), `nearFade` (2). Low quality draws no fine spray (`spray` 0) and fewer droplets (`droplets` 0.3); like every block it runs at half resolution there.
It reads depth, the copied normals (or the normal rebuilt from world positions on the forward path), the frame and the pigment set. Every mark is laid on the surface in metres: the surface is divided into cells `cellSize` metres across, `amount` of them hold a splat of `size` against the cell with a rim bent by `spikes`, ringed by up to six thrown droplets (`droplets`); on walls (surfaces facing sideways) `drip` of the splats run straight down in a drip that ends in a bead. A fine spray of specks gathers where things meet, found from concave folds in depth at `sprayReach` reference pixels around the pixel (`spray`). Marks smaller than a couple of pixels are left out, so far surfaces never fill with speckle, and everything fades out over the last third of the way to `fadeEnd`. Splats land on lit and shadowed surfaces alike: it does not read the picture's tone. The ink is `ink`, or the picked ink set's first paint by `setInk` (white splats with `inkWhiteOnDark`); `accentShare` of the splats are drawn in the accent ink. With `accentShare` above 0 the accent is the set's second paint when it has one (`inkRedAccent`'s vermilion), and a built-in vermilion otherwise, including with no set picked. `seed` picks which cells hold a splat (the same seed gives the same splats on every machine). It sits last in the ink Fill chain (rank 80, stacking chain). It has no `wobble` setting and does not read the shared wobble, so splats never tremble with the boil.
## What it gives up in motion
Every splat, drip and droplet is laid on the surface in metres, so it stays put on still things under pan, dolly, orbit and zoom and never changes on its own: nothing in it follows the clock. Because it comes from world position, it slides across moving characters and props like a pattern projected onto them: keep it off them with a group mask. Splats keep their size on the surface, so they grow as you walk closer, like real ink on a wall. The spray's reach is measured in pixels on screen while its specks sit on the surface, so as you dolly in the band where spray gathers narrows on the surface while each speck stays where it is.
## How it treats content
- Opaque things: splats, droplets and drips sit on every surface, walls take the drips, and spray gathers in corners and at the foot of walls.
- Transparent things (glass, water): no depth, so splats are laid on the surface behind the glass or under the water and drawn over the glass; a pond shows splats on its bed.
- Particles and smoke: splats belong to the surface behind smoke and are drawn over it.
- Sky: never splattered.
- Fog: splats are drawn at full ink over fogged surfaces until they fade by `fadeEnd` (60 m); in thick, near fog lower `fadeEnd` so dark splats do not float in pale fog.
- Skinned characters: splats slide across a moving body. Keep them off characters with a group mask (`StyleKit.options({ groups = { { bodyId } } })`, `StyleKit.setMask("splat", { kind = "group", group = 1, invert = true })`).
- Foliage: leaves are surfaces and take splats; on swaying foliage the splats stay in the world while the leaves move through them, which reads as flicker on wind-blown trees. Mask trees if that shows.
- World text: splats land on signs and can cover letters. Exclude labels a player must read by name: `StyleKit.options({ exclude = { "labelName" } })`.
- Black stays black: it returns through `sk_finish`, so an unlit pixel stays black; white splats on parts of the scene with no light at all are held black too.
## 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 Ink wash style block (inkBlocks).
## 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.
# Ink wash (styleBlock, Fill)
Lays the picture in a few tonal steps of diluted ink on bare paper, lit planes left as paper and shadow washed, with wet edges a little darker where each wash dried, fading to bare paper with distance and low mist: the base of ink wash painting, brush and wash, and monochrome ink illustration. Swaps for the watercolor wash in one change.
Settings: `ink` (`#0f0e0f`), `setInk` (1), `steps` (4), `softness` (0.22), `whitePoint` (0.8), `darkest` (0.85), `contrast` (1.15), `localTone` (0.45), `lightFull` (0.85), `abstraction` (0.7), `grade` (0.3), `gradeSize` (0.25), `granulation` (0.25), `edgePool` (0.4), `fadeStart` (15), `fadeEnd` (90), `mist` (0.5), `mistFrom` (25), `mistHeight` (2), `sky` (0.1), `accent` (1), `accentPick` (0.6), `wobble` (1). Low quality draws no granulation (`granulation` 0); like every block it runs at half resolution there and reads the soft field at half of that, and since the low tier makes no copy of surface colour, the tone there is the drawn brightness rather than light, so a texture that the light estimate would cancel shows as tone.
It reads the frame, depth, the soft field, the copied surface colour (albedo), the frame as rendered, the shared ground and wobble, and the pigment set. The tone comes from light, the way an ink painter works: how much light reaches each surface is the frame as rendered against the surface's own colour (two images aligned pixel for pixel, so a brick wall in sun reads as one lit plane), summed over three rings out to 24 reference pixels before dividing so a texture's pattern cancels in bulk, and divided by `lightFull`. A share of the surface's own tone (`localTone`) is added so dark materials still carry ink, read from the soft field's wide ring so no texture finer than the brush reaches it; at 0 every lit plane is paper. Whatever is cut into steps has to be smooth already: texture left in it flips pixels across a step's edge and prints a grid of dots, which is why both are read wide. Where light cannot be told from colour (the low tier, the forward path, the sky) the drawn brightness is used instead, after texture inside a surface is let go into the soft field (`abstraction`). Everything at or above `whitePoint` is bare paper; the rest is pushed apart by `contrast` and cut into `steps` washes with soft edges (`softness`) and a slightly darker rim on the dark side of each edge where the wash dried (`edgePool`). The wash lies unevenly across a surface (`grade`, `gradeSize`, laid on the world position), settles into the shared paper's tooth (`granulation`), thins to paper from `fadeStart` to `fadeEnd`, and thins in low mist: below `mistHeight` metres of world height (fully at a quarter of it) and from about `mistFrom` metres away. The sky takes `sky` of its own tone. Ink is laid in optical density, so a diluted wash keeps the ink's own hue (sepia dilutes to tea browns, blue-black to slate). The ink is `ink`, or the picked ink set's first paint by `setInk`; only an ink set counts (its first paint very dark or very light and its `pull` below 0.35), so a watercolor palette never recolours the wash. With a set carrying a second paint (`inkRedAccent`'s vermilion), things of that hue keep the accent (`accent`, and `accentPick` from anything near the hue to only strongly coloured paint of it). With a light ink (the `inkWhiteOnDark` set) it works the other way round: the set's shadow colour is the dark ground and white ink is laid only where the light is strongest. It is the first block of the ink Fill chain (rank 10, stacking chain), the same rank as watercolorBlocks' `wcWash`, so `StyleKit.swap("wash", "inkWash")` turns a watercolor stack's wash into ink in one change (settings reset; strength and mask stay).
## What it gives up in motion
The tone is read from the picture's own light every frame, so washes stay on things under any camera move and move with shadows: a moving shadow carries its wash with it. The abstraction reads the soft field, a screen-space blur made each frame, so it follows moving things. The grading and the tooth's settling are laid on surfaces in world position: still on still things, they slide across moving characters and props. Step edges are soft (`softness`), so a slow light change moves a wash edge smoothly; with a very hard edge (the `noirInk` look's 0.06) a slowly moving sun sweeps a crisp edge across a surface, and light that flickers near a step (noisy shadows, aliased shadow edges) can shimmer there. The distance fade and the mist follow view distance and world height smoothly. With a Time block the wash edges tremble on the held clock (`wobble`), never per frame.
## How it treats content
- Opaque things: lit planes go to paper, shadow and dark materials are washed in steps; every colour becomes the ink's, except things of the accent's hue when the set carries one. Colours that carry gameplay meaning are lost: keep them with a group mask or `exclude`.
- Transparent things (glass, water): they are not in the depth or the surface colour copy, so the light estimate reads the rendered pixel (glass included) against the surface behind; tinted glass reads as shade and is washed darker, clear glass vanishes into the wash behind it. A water surface is washed as its bed, and misted by the bed's height.
- Particles and smoke: no depth or surface colour of their own; dark smoke lowers the light estimate and is washed as shadow, bright sparks and glows lift it past `whitePoint` and become bare paper. Small bright gameplay effects can vanish: make them big, or keep them out with a mask or `exclude`.
- Sky: takes `sky` (0.1) of its own tone, so it is nearly bare paper with a hint of the sky; the accent is never kept on the sky. With white ink the sky stays close to the dark ground.
- Fog: fog brightens the rendered colour, so fogged distance washes paler; `fadeStart`, `fadeEnd` and the low `mist` thin it to paper anyway, which reads as ink painting's misty distance.
- Skinned characters: washed by their light like everything else, their own colour adding tone by `localTone`; the grading slides across a moving body. A character masked out of the wash with a group mask keeps its rendered colour on the ink page, which reads as a colour cut-out: often what a game wants for the player.
- Foliage: leaf masses become one or two tone shapes, which reads as painted trees; sunlit leaves go to paper, the shaded inside of a canopy is washed.
- World text: lettering is turned into ink tones and small text is averaged by `abstraction`. Exclude labels a player must read by name: `StyleKit.options({ exclude = { "labelName" } })`.
- Black stays black: it returns through `sk_finish`, so an unlit pixel is never lifted toward paper; with white ink on a dark ground the parts of the scene that get no light at all stay 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.
# Brush and wash (whole look)
Ink wash painting: a tapered brush line over four tonal steps of diluted ink, far planes and low ground dissolving into bare paper in mist.
Blocks: inkWash, inkBrushLine, inkPaper, inkBoil. Ink: inkBlack.
Apply it with `StyleKit.applyLook("brushAndWash")`; keep your own line with `StyleKit.applyLook("brushAndWash", { keep = { "line" } })`, or pick another ink with `StyleKit.setPigments("inkSepia")` after it. Every block in it can be removed, swapped or retuned afterwards like any other entry, and `StyleKit.clear()` takes it all off.
## 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.
# Spattered comic ink (whole look)
Bold comic inking: a heavy brush line, flat blacks, dry-brush texture in the middle tones and flicked splatter and drips on walls and ground.
Blocks: inkWash, inkPool, inkDryTexture, inkSplatter, inkBrushLine, inkPaper, inkBoil. Ink: inkBlack.
Apply it with `StyleKit.applyLook("comicInk")`; keep your own line with `StyleKit.applyLook("comicInk", { keep = { "line" } })`, or pick another ink with `StyleKit.setPigments("inkSepia")` after it. Every block in it can be removed, swapped or retuned afterwards like any other entry, and `StyleKit.clear()` takes it all off.
## 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.
# Ink drawing (whole look)
A plain pen-and-ink drawing: an even technical-pen line, light ink washes in two steps, fine dry strokes like hatching in the middle tones, small pools of black in the deepest shadow, warm white paper and a calm boil.
Blocks: inkWash, inkPool, inkDryTexture, inkPenLine, inkPaper, inkBoil. Ink: inkBlack.
Apply it with `StyleKit.applyLook("inkDrawing")`; keep your own line with `StyleKit.applyLook("inkDrawing", { keep = { "line" } })`, or pick another ink with `StyleKit.setPigments("inkSepia")` after it. Every block in it can be removed, swapped or retuned afterwards like any other entry, and `StyleKit.clear()` takes it all off.
## 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.
# Noir ink (whole look)
High-contrast black ink: lit planes left as white paper, everything in shadow a solid pool of black, a heavy brush outline.
Blocks: inkWash, inkPool, inkBrushLine, inkPaper. Ink: inkBlack.
Apply it with `StyleKit.applyLook("noirInk")`; keep your own line with `StyleKit.applyLook("noirInk", { keep = { "line" } })`, or pick another ink with `StyleKit.setPigments("inkSepia")` after it. Every block in it can be removed, swapped or retuned afterwards like any other entry, and `StyleKit.clear()` takes it all off.
## 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.
# Sketchbook pen (whole look)
A loose sepia pen sketch in a travel sketchbook: wandering, doubled lines that run past the corners over soft, sparse washes.
Blocks: inkWash, inkSketchPen, inkPaper, inkBoil. Ink: inkSepia.
Apply it with `StyleKit.applyLook("sketchbookPen")`; keep your own line with `StyleKit.applyLook("sketchbookPen", { keep = { "line" } })`, or pick another ink with `StyleKit.setPigments("inkSepia")` after it. Every block in it can be removed, swapped or retuned afterwards like any other entry, and `StyleKit.clear()` takes it all off.
## 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.
# Black ink (pigment set)
A dense carbon black ink on warm white paper: the classic pen-and-ink and brush-and-ink colour.
Lines, washes, pools and splatter all in one neutral black; washes dilute to cool greys.
Pick it for the whole stack with `StyleKit.setPigments("inkBlack")`. Every inkBlocks block draws with the set's first pigment as its ink (each block's `setInk` setting says how far), and a second pigment, when the set has one, is the accent the ink wash keeps on things of its hue and the splatter can throw. `StyleKit.setPigments("")` puts each block's own ink back.
## 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.
# Blue-black ink (pigment set)
A cool blue-black ink like a fountain pen's: technical drawings, notebooks and cool night scenes.
Washes dilute to slate blues; reads cool, crisp and a little technical.
Pick it for the whole stack with `StyleKit.setPigments("inkBlueBlack")`. Every inkBlocks block draws with the set's first pigment as its ink (each block's `setInk` setting says how far), and a second pigment, when the set has one, is the accent the ink wash keeps on things of its hue and the splatter can throw. `StyleKit.setPigments("")` puts each block's own ink back.
## 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.
# Brown ink (pigment set)
A mid walnut brown ink, softer than sepia: gentle nature studies and picture books.
Lighter and warmer than sepia, so washes stay soft and the line never looks harsh.
Pick it for the whole stack with `StyleKit.setPigments("inkBrown")`. Every inkBlocks block draws with the set's first pigment as its ink (each block's `setInk` setting says how far), and a second pigment, when the set has one, is the accent the ink wash keeps on things of its hue and the splatter can throw. `StyleKit.setPigments("")` puts each block's own ink back.
## 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.
# Black ink with a red accent (pigment set)
Black ink with a single vermilion accent kept on red things, like a red seal stamped on an ink painting.
Everything is black ink except things whose colour is near the vermilion (a red roof, a flag, a seal), which keep it. The ink wash's accent setting and the splatter's accentShare decide how much.
Pick it for the whole stack with `StyleKit.setPigments("inkRedAccent")`. Every inkBlocks block draws with the set's first pigment as its ink (each block's `setInk` setting says how far), and a second pigment, when the set has one, is the accent the ink wash keeps on things of its hue and the splatter can throw. `StyleKit.setPigments("")` puts each block's own ink back.
## 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.
# Red-brown ink (pigment set)
A rusty red-brown ink like an old chalk-and-ink study: warm figure studies and old master-like sketches.
Washes dilute to warm terracottas and pinks; reads warm and drawn by hand.
Pick it for the whole stack with `StyleKit.setPigments("inkRedBrown")`. Every inkBlocks block draws with the set's first pigment as its ink (each block's `setInk` setting says how far), and a second pigment, when the set has one, is the accent the ink wash keeps on things of its hue and the splatter can throw. `StyleKit.setPigments("")` puts each block's own ink back.
## 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 ink (pigment set)
A warm sepia brown-black ink: old sketchbooks, travel journals and antique drawings.
Washes dilute to warm tea browns; reads aged and gentle beside watercolor.
Pick it for the whole stack with `StyleKit.setPigments("inkSepia")`. Every inkBlocks block draws with the set's first pigment as its ink (each block's `setInk` setting says how far), and a second pigment, when the set has one, is the accent the ink wash keeps on things of its hue and the splatter can throw. `StyleKit.setPigments("")` puts each block's own ink back.
## 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.
# White ink on a dark ground (pigment set)
White ink drawn on a near-black ground: lit planes and edges are white ink, shadow is the bare dark ground, like a scratchboard or white gel pen on black paper.
Every ink block switches to light ink: the wash lays white where the picture is lit, the pooled black leaves deep shadow as the bare dark ground, and lines are drawn in white. The dark ground is the set's shadow colour, laid by the ink blocks themselves, so a light paper block on top (inkPaper, wcColdPress) only warms the white ink a little and still lays its tooth.
Pick it for the whole stack with `StyleKit.setPigments("inkWhiteOnDark")`. Every inkBlocks block draws with the set's first pigment as its ink (each block's `setInk` setting says how far), and a second pigment, when the set has one, is the accent the ink wash keeps on things of its hue and the splatter can throw. `StyleKit.setPigments("")` puts each block's own ink back.
## 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.
# inkCore (shader module)
The rules every inkBlocks block follows, so the lines and fills in one stack are one hand with one ink: which ink and accent to draw with (the picked pigment set's ink, or the block's own colour), white ink on a dark ground, one-sided silhouettes, creases (from normals, or from a kink in depth on tiers without normals) and contacts where two differently coloured things meet, the edge's direction on screen, how curved the surface under a line is, line weight against distance and the far fade, and a gentle seed on the held clock. Every ink line and fill block includes it after styleKit's `skCommon`, `skPatterns`, `skAnchored`, `skPigment` and `skPigmentSet`.
## 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.
# inkBlocks tests
Checks the package against the rules and against what its docs promise, most of it on the presented frame of a small lit set the suite builds itself (floor, wall, boxes, ball, a camera of its own), since the test runner empties the scene.
- **Rules and stacking:** every block passes styleKit's block check and sits in its slot (lines as layer blocks, fills as chain blocks in painting order whatever order they are added in); every line swaps for every other line and for styleKit's depth line in one change that keeps id, strength and mask; the ink wash holds the watercolor wash's rank so the two swap in one change; every whole look and every ink set applies in one change, and every ink set is one the blocks take as ink.
- **Looks work after a plain install:** every block every whole look names ships in inkBlocks itself or in styleKit, the two packages an install of inkBlocks brings, and the paper and boil (`inkPaper`, `inkBoil`) are inkBlocks' own and pass the block check. A look naming a block from another package would be refused in a fresh world, since a package's list of dependencies installs nothing by itself.
- **Settings:** each main setting moves the picture the way its documentation says (line width, wash white point, pool threshold, splatter amount, dry texture amount, dry line dryness).
- **On and off, every block, twice:** each of the nine blocks is added (the frame changes), swapped for another block of its slot (the frame is still styled), and removed (the frame matches the one before, by FLIP under 0.005 and mean colour within 0.5 of 255), two rounds in a row. Clearing a whole stack also leaves the frame exactly as it was.
- **With the watercolor blocks, on the frame:** a pen line over the watercolor wash shows and comes off exactly; swapping the watercolor wash for the ink wash changes the picture and swapping back returns it exactly; the Watercolor look applied with `keep = { "line" }` keeps the ink line visible; the chain ink wash, watercolor edge darkening and cold-press paper runs all three entries. Needs watercolorBlocks (installed in the Style Cookbook) and says so where it is missing.
- **A boil, not a flash:** under the Ink drawing look (8 drawings a second) frames sampled over about 24 held steps differ pixel by pixel, while the whole frame's mean brightness moves by under one code value from sample to sample and under 1.5 over the run.
- **Black stays black:** at the Lookbook's every-light-off moment every look, white ink included, stays within 1.5 of 255 of the unstyled dark frame (needs lookbookKit).
It leaves the Lookbook's motion numbers to the Lookbook itself. The scene's shared stack, the viewport camera and the test set are put back after each test. Run with `zero tests run inkBlocks` or `asset.resolve("inkBlocks", "testSuite"):run()`. A full run takes a few minutes, most of it the on-and-off rounds waiting for each frame to settle.
## 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.
# inkWorld
Turn an existing world, scene or installed kit into an ink drawing with inkBlocks 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 materials with their own outline, emissive, glass and water, bright colours that carry meaning), the lights and whether they change over time, the screen UI, particles, the player and other characters, world labels, any stack already in place (kept so it can be put back), and the ink blocks, whole looks and ink sets installed.
2. **Reference.** Saves the plain presented frame under `/zero/source/tmp/ink/<subject>/` and generates a reference ink drawing 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 (`inkDrawing`, `brushAndWash`, `noirInk`, `comicInk`, `sketchbookPen`) and an ink colour (`inkBlack`, `inkSepia`, `inkBrown`, `inkBlueBlack`, `inkRedBrown`, `inkWhiteOnDark`, `inkRedAccent`), or the ink blocks one by one, with a reason for each.
4. **Build.** Builds the stack in one call that replaces rather than duplicates: `StyleKit.applyLook(id)` then `StyleKit.setPigments(id)`, or `StyleKit.load(entries, { pigments, holdRate, softRadius })`.
5. **Tune.** Up to three rounds of comparing presented frames against the reference drawing and the asked look, adjusting line weight and distance falloff, wash steps and mist, pools, ink colour and boil.
6. **Content.** Puts the player and moving characters in a mask group and keeps the surface-mark fills off them; gives each outline one owner over toon materials (a group mask on the Line entry, or the kit's own outline switched off, recorded with its restore call); leaves labels a player must read out by name; keeps gameplay colours and screen UI readable.
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 ink colour, the stack before and after, every exclusion, group and mask, every outline or material change 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), and the report gives the exact `StyleKit.load(...)` call that puts back the stack from before the run. The one change outside the stack it may make is switching a toon kit's own outline off on chosen objects (`ToonInk.set(object, false)`), and each one is reported with `ToonInk.set(object, true)` to put it back.
## What it needs
inkBlocks installed (it comes with styleKit and holds its own paper and boil). The reference drawing 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 inkWorld --args '{"subject":"main","look":"brush and wash in mist with a crisp player"}'
`subject` names the world, scene or kit (default: the loaded scene); `look` is the drawing in the asker's words (default: the run proposes one).
## 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.