# PencilDrawn (component)
Marks an entity whose materials `PencilHero.paint` replaced with pencilSurface materials, so its pencil marks ride on it as it moves. Holds what each Model wore before (synced and saved, so every player sees the same hero and `PencilHero.unpaint` restores it), and on each machine keeps the materials' stroke size matched to that screen and their strokes redrawn on styleKit's one held clock. Added and removed by the PencilHero module; you do not add it by hand.
## 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.
# PencilHero (module)
Gives a character or hero prop its pencil marks inside its own materials, so they travel with it as it moves instead of sliding across it like the full-frame strokes would. `PencilHero.paint(target, opts?)` writes derived materials on the `pencilSurface` shader (keeping each original's colour and texture), drawn in the medium of the stack's pencil shade block with that entry's tuning, and keeps the full-frame shade off the target with a group mask; `PencilHero.unpaint(target, { removeFiles = true })` restores every original; `PencilHero.list()` names what is painted. Called from scripts, the pencilBlocks guides and the `pencilWorld` workflow: `require("~pencilBlocks.PencilHero")`.
## 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.
# Ballpoint black line (styleBlock, Line)
Edge lines in a black ballpoint pen: fine crossing hatching building to deep black, ink blobs at stroke starts and a cool shine on the heaviest passages: outlines, folds and contacts drawn as wandering ballpoint pen passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#1b1b1f), `darkness` (0.95), `hardness` (0.7), `tooth` (0.1), `width` (1), `strokes` (3), `wander` (1.2), `overshoot` (4), `variation` (0.25), `blobs` (0.5).
Pair it with `ballpointBlackShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("ballpointBlackLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Ballpoint black shade (styleBlock, Tone)
Shades the picture in a black ballpoint pen: fine crossing hatching building to deep black, ink blobs at stroke starts and a cool shine on the heaviest passages. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#26262b), `deepLead` (#101013), `deepFrom` (0.7), `hardness` (0.7), `pressure` (0.55), `tooth` (0.1), `smudge` (0), `gloss` (0.45), `glossColour` (#8e8e9e), `blobs` (0.6), `direction` (2), `angle` (-45), `strokeLength` (60), `spacing` (6), `width` (1), `layers` (6), `jitter` (0.15), `taper` (0.15), `lightest` (0.9), `darkest` (0.25).
Pair it with `ballpointBlackLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("ballpointBlackShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Ballpoint blue line (styleBlock, Line)
Edge lines in a blue ballpoint pen: thin even lines built up in patient crossing layers into dense dark blue, small blobs where strokes start and a faint shine where the ink is heavy: outlines, folds and contacts drawn as wandering ballpoint pen passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#22357c), `darkness` (0.95), `hardness` (0.7), `tooth` (0.1), `width` (1), `strokes` (3), `wander` (1.2), `overshoot` (4), `variation` (0.25), `blobs` (0.5).
Pair it with `ballpointBlueShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("ballpointBlueLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Ballpoint blue shade (styleBlock, Tone)
Shades the picture in a blue ballpoint pen: thin even lines built up in patient crossing layers into dense dark blue, small blobs where strokes start and a faint shine where the ink is heavy. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#2b3f8f), `deepLead` (#1a2459), `deepFrom` (0.7), `hardness` (0.7), `pressure` (0.55), `tooth` (0.1), `smudge` (0), `gloss` (0.5), `glossColour` (#8c7fa8), `blobs` (0.6), `direction` (2), `angle` (50), `strokeLength` (60), `spacing` (6), `width` (1), `layers` (6), `jitter` (0.15), `taper` (0.15), `lightest` (0.9), `darkest` (0.25).
Pair it with `ballpointBlueLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("ballpointBlueShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Ballpoint red correction pen line (styleBlock, Line)
Edge lines in a red correction pen: quick red hatching and confident red outlines, like a teacher's marks over a page: outlines, folds and contacts drawn as wandering ballpoint pen passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#b02622), `darkness` (0.95), `hardness` (0.7), `tooth` (0.1), `width` (1.1), `strokes` (2), `wander` (1.6), `overshoot` (7), `variation` (0.3), `blobs` (0.4).
Pair it with `ballpointRedShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("ballpointRedLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Ballpoint red correction pen shade (styleBlock, Tone)
Shades the picture in a red correction pen: quick red hatching and confident red outlines, like a teacher's marks over a page. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#c0302a), `deepLead` (#7e1a17), `deepFrom` (0.75), `hardness` (0.7), `pressure` (0.5), `tooth` (0.1), `smudge` (0), `gloss` (0.35), `glossColour` (#d9a29a), `blobs` (0.45), `direction` (1), `angle` (60), `strokeLength` (65), `spacing` (7), `width` (1.1), `layers` (4), `jitter` (0.25), `taper` (0.2), `lightest` (0.88), `darkest` (0.25).
Pair it with `ballpointRedLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("ballpointRedShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Ballpoint dense study line (styleBlock, Line)
Edge lines in a careful blue-black ballpoint study: dense, close cross-hatching in eight layers that turns the shadows nearly solid and shiny: outlines, folds and contacts drawn as wandering ballpoint pen passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#1d2242), `darkness` (0.95), `hardness` (0.65), `tooth` (0.1), `width` (0.9), `strokes` (2), `wander` (0.8), `overshoot` (3), `variation` (0.2), `blobs` (0.3).
Pair it with `ballpointStudyShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("ballpointStudyLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Ballpoint dense study shade (styleBlock, Tone)
Shades the picture in a careful blue-black ballpoint study: dense, close cross-hatching in eight layers that turns the shadows nearly solid and shiny. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#2a3256), `deepLead` (#12152a), `deepFrom` (0.6), `hardness` (0.65), `pressure` (0.6), `tooth` (0.1), `smudge` (0), `gloss` (0.6), `glossColour` (#8f86ad), `blobs` (0.4), `direction` (2), `angle` (30), `strokeLength` (50), `spacing` (5), `width` (0.9), `layers` (8), `jitter` (0.1), `taper` (0.15), `lightest` (0.92), `darkest` (0.3), `contrast` (0.9).
Pair it with `ballpointStudyLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("ballpointStudyShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Compressed charcoal line (styleBlock, Line)
Edge lines in compressed charcoal: deep velvety blacks in the shadows, bold broad strokes, the paper's grain showing hard in the half-tones: outlines, folds and contacts drawn as wandering charcoal passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#151415), `hardness` (0.05), `pressure` (0.8), `tooth` (0.7), `smudge` (0.35), `width` (2.6), `strokes` (2), `wander` (2), `overshoot` (6), `variation` (0.55).
Pair it with `charcoalCompressedShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("charcoalCompressedLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Compressed charcoal shade (styleBlock, Tone)
Shades the picture in compressed charcoal: deep velvety blacks in the shadows, bold broad strokes, the paper's grain showing hard in the half-tones. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#252326), `deepLead` (#0e0d0e), `deepFrom` (0.5), `hardness` (0.05), `pressure` (0.75), `tooth` (0.75), `smudge` (0.4), `mass` (0.82), `gloss` (0), `direction` (2), `angle` (35), `strokeLength` (85), `spacing` (9), `width` (3.2), `layers` (5), `jitter` (0.3), `taper` (0.6), `lightest` (0.88), `darkest` (0.3), `contrast` (1.25), `formShade` (0.45).
Pair it with `charcoalCompressedLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("charcoalCompressedShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Charcoal smudged tonal line (styleBlock, Line)
Edge lines in charcoal rubbed with a finger and a blending stump into soft, smoky tonal masses, only a few strokes left showing at the edges: outlines, folds and contacts drawn as wandering charcoal passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#2c2a2c), `hardness` (0.1), `tooth` (0.6), `smudge` (0.8), `width` (2.6), `strokes` (1), `wander` (2.8), `overshoot` (5), `variation` (0.75).
Pair it with `charcoalSmudgedShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("charcoalSmudgedLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Charcoal smudged tonal shade (styleBlock, Tone)
Shades the picture in charcoal rubbed with a finger and a blending stump into soft, smoky tonal masses, only a few strokes left showing at the edges. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#3a383b), `deepLead` (#1a191a), `hardness` (0.1), `pressure` (0.6), `tooth` (0.6), `smudge` (0.9), `mass` (0.92), `gloss` (0), `direction` (0), `angle` (10), `strokeLength` (100), `spacing` (11), `width` (4), `layers` (4), `jitter` (0.4), `taper` (0.8), `lightest` (0.88), `darkest` (0.3), `formShade` (0.45).
Pair it with `charcoalSmudgedLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("charcoalSmudgedShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Vine charcoal line (styleBlock, Line)
Edge lines in light, soft vine charcoal: grey, powdery broad strokes that smudge easily into soft tonal masses: outlines, folds and contacts drawn as wandering charcoal passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#3a383b), `hardness` (0.15), `pressure` (0.45), `tooth` (0.8), `smudge` (0.45), `width` (2.4), `strokes` (2), `wander` (2.4), `overshoot` (8), `variation` (0.7).
Pair it with `charcoalVineShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("charcoalVineLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Vine charcoal shade (styleBlock, Tone)
Shades the picture in light, soft vine charcoal: grey, powdery broad strokes that smudge easily into soft tonal masses. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#47454a), `deepLead` (#2a2829), `hardness` (0.15), `pressure` (0.5), `tooth` (0.85), `smudge` (0.6), `mass` (0.8), `gloss` (0), `direction` (0), `angle` (25), `strokeLength` (90), `spacing` (10), `width` (3.5), `layers` (5), `jitter` (0.35), `taper` (0.75), `lightest` (0.88), `darkest` (0.3), `formShade` (0.45).
Pair it with `charcoalVineLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("charcoalVineShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# White charcoal line (styleBlock, Line)
Edge lines in white charcoal on black or dark paper: the scene drawn only in light, sunlit planes built up from many white strokes, shadows left as the dark sheet. Use it on paperBlack, paperBlackboard or a dark toned sheet: outlines, folds and contacts drawn as wandering charcoal passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#ece9e1), `hardness` (0.2), `smudge` (0.3), `width` (1.8), `strokes` (2), `wander` (1.8), `overshoot` (6), `variation` (0.6).
Pair it with `charcoalWhiteShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("charcoalWhiteLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# White charcoal shade (styleBlock, Tone)
Shades the picture in white charcoal on black or dark paper: the scene drawn only in light, sunlit planes built up from many white strokes, shadows left as the dark sheet. Use it on paperBlack, paperBlackboard or a dark toned sheet. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#efece4), `deepLead` (#fbfaf6), `deepFrom` (0.6), `hardness` (0.2), `pressure` (0.55), `tooth` (0.8), `smudge` (0.35), `mass` (0.6), `gloss` (0), `direction` (0), `angle` (30), `strokeLength` (80), `spacing` (9), `width` (2.8), `layers` (5), `jitter` (0.3), `taper` (0.7), `lightest` (1), `darkest` (0.5), `contrast` (1.3).
Pair it with `charcoalWhiteLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("charcoalWhiteShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Coloured pencil burnished line (styleBlock, Line)
Edge lines in coloured pencil burnished to a smooth, saturated finish: the layers rubbed together so little paper shows, strokes only at the edges of the light: outlines, folds and contacts drawn as wandering coloured pencil passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#36304a), `hue` (0.9), `hardness` (0.45), `pressure` (0.7), `smudge` (0.1), `width` (1.3), `strokes` (1), `wander` (0.7), `overshoot` (2), `variation` (0.3).
Pair it with `coloredPencilBurnishedShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("coloredPencilBurnishedLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Coloured pencil burnished shade (styleBlock, Tone)
Shades the picture in coloured pencil burnished to a smooth, saturated finish: the layers rubbed together so little paper shows, strokes only at the edges of the light. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#6a5c4c), `deepLead` (#33304a), `deepFrom` (0.75), `hardness` (0.45), `pressure` (0.75), `tooth` (0.2), `smudge` (0.2), `wax` (0.5), `burnish` (0.7), `hue` (1), `gloss` (0.2), `glossColour` (#f4efe6), `direction` (0), `angle` (0), `strokeLength` (60), `spacing` (6), `width` (2.2), `layers` (5), `jitter` (0.2), `taper` (0.5), `lightest` (0.96), `darkest` (0.2).
Pair it with `coloredPencilBurnishedLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("coloredPencilBurnishedShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Coloured pencil hard and layered line (styleBlock, Line)
Edge lines in hard coloured pencils layered in many thin crossing passes of the thing's own colour, the paper sparkling through every layer: outlines, folds and contacts drawn as wandering coloured pencil passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#3a3f55), `hue` (0.85), `hardness` (0.8), `smudge` (0), `width` (1), `strokes` (1), `wander` (0.8), `overshoot` (3), `variation` (0.35).
Pair it with `coloredPencilHardShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("coloredPencilHardLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Coloured pencil hard and layered shade (styleBlock, Tone)
Shades the picture in hard coloured pencils layered in many thin crossing passes of the thing's own colour, the paper sparkling through every layer. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#6d6458), `deepLead` (#2f3a55), `deepFrom` (0.65), `hardness` (0.8), `pressure` (0.5), `tooth` (0.75), `smudge` (0), `wax` (0), `hue` (0.95), `gloss` (0), `direction` (2), `angle` (40), `strokeLength` (55), `spacing` (6), `width` (1.2), `layers` (6), `jitter` (0.12), `taper` (0.5), `lightest` (0.95), `darkest` (0.2).
Pair it with `coloredPencilHardLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("coloredPencilHardShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Coloured pencil loose sketch line (styleBlock, Line)
Edge lines in a quick, loose coloured pencil sketch: open hatching in each thing's colour at one slant, lots of paper left, lively wandering outlines: outlines, folds and contacts drawn as wandering coloured pencil passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#47405a), `hue` (0.75), `hardness` (0.6), `width` (1.3), `strokes` (2), `wander` (2), `overshoot` (8), `variation` (0.5).
Pair it with `coloredPencilSketchShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("coloredPencilSketchLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Coloured pencil loose sketch shade (styleBlock, Tone)
Shades the picture in a quick, loose coloured pencil sketch: open hatching in each thing's colour at one slant, lots of paper left, lively wandering outlines. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#5f6370), `deepLead` (#40364f), `deepFrom` (0.8), `hardness` (0.6), `pressure` (0.45), `tooth` (0.6), `smudge` (0), `hue` (0.85), `direction` (1), `angle` (55), `strokeLength` (75), `spacing` (9), `width` (1.6), `layers` (3), `jitter` (0.3), `taper` (0.7), `lightest` (0.9), `darkest` (0.25).
Pair it with `coloredPencilSketchLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("coloredPencilSketchShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Coloured pencil underlayer (styleBlock, Fill)
A light first layer of coloured pencil: each thing's own colour laid in soft, even, light-pressure strokes that follow the form over a pale blank of the picture, the way a coloured pencil drawing is started. Graphite, coloured pencil or ink is then drawn over it.
Part of pencilBlocks. Runs the shared `pencilFill` shader with `strokes = 1`; `sketchBlankFill` is the same shader with no strokes. Its strokes come from styleKit's shared stroke piece (skStrokes) through pencilCore, like every pencil shade block, so `hardness`, `pressure`, `tooth`, `direction`, `angle`, `strokeLength`, `spacing` and `layers` mean the same here as there.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("pencilSketch")
StyleKit.add("coloredPencilUnderlayFill", { id = "fill" }) -- colour first, lightly
StyleKit.set("shade", { over = 1 }) -- graphite over the colour
StyleKit.set("fill", { direction = 0, pressure = 0.45 }) -- follow the form, press a little harder
```
## What it gives up in motion
Its strokes are laid on the world position of the surface under each pixel and kept at screen size by octaves blended by distance, so they stay put on still things while the camera pans, dollies, orbits or zooms, and grow into the next octave instead of sliding. `boil` redraws each patch a little only on the shared held clock, never per frame; the colour under it never changes with it.
## How it treats content
- Opaque things: lifted toward the bare sheet by `paleness`, keeping `keepColour` of their colour; the underlayer's strokes are laid in each thing's material colour, greys getting only a little.
- Transparent things, particles and smoke: lifted like everything else, pixel by pixel; strokes are laid on the surface behind them.
- Sky: lifted at least `skyBare` of the way to the sheet; no strokes.
- Fog: lifted with what is behind it, so foggy distance goes toward the bare sheet; past `fadeEnd` the underlayer's strokes give way to a soft tone.
- Foliage: alpha-tested leaves are in the depth and are treated like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Skinned characters: the blank is pixel by pixel and travels with them; the underlayer's strokes are laid on world positions, so keep it off a moving character with a group mask, or paint the character with `PencilHero.paint`.
- Dark sheets (black paper, the boards): the blank sinks toward the sheet instead of toward white.
- Black stays black: only what light reached is lifted, so 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.
# Coloured pencil soft and waxy line (styleBlock, Line)
Edge lines in soft, waxy coloured pencils in the colours of what they draw, laid thick so they fill the paper's tooth, with indigo in the shadows: outlines, folds and contacts drawn as wandering coloured pencil passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#3e3550), `hue` (0.8), `hardness` (0.35), `pressure` (0.6), `smudge` (0.05), `width` (1.5), `strokes` (2), `wander` (1.3), `overshoot` (4), `variation` (0.45).
Pair it with `coloredPencilWaxyShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("coloredPencilWaxyLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Coloured pencil soft and waxy shade (styleBlock, Tone)
Shades the picture in soft, waxy coloured pencils in the colours of what they draw, laid thick so they fill the paper's tooth, with indigo in the shadows. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#6b5b4a), `deepLead` (#3b3557), `deepFrom` (0.7), `hardness` (0.35), `pressure` (0.6), `tooth` (0.45), `smudge` (0.1), `wax` (0.6), `hue` (0.9), `gloss` (0.1), `glossColour` (#efe9df), `direction` (0), `angle` (15), `strokeLength` (60), `spacing` (7), `width` (2.2), `layers` (4), `jitter` (0.25), `taper` (0.6), `lightest` (0.95), `darkest` (0.2).
Pair it with `coloredPencilWaxyLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("coloredPencilWaxyShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Conte black line (styleBlock, Line)
Edge lines in black conte crayon with white heightening on a toned sheet: dense, slightly waxy black strokes, crisp edges, the lights put on in white: outlines, folds and contacts drawn as wandering conte crayon passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#1d1c1e), `hardness` (0.35), `tooth` (0.65), `smudge` (0.55), `width` (1.6), `strokes` (2), `wander` (1.4), `overshoot` (5), `variation` (0.5).
Pair it with `conteBlackShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("conteBlackLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Conte black shade (styleBlock, Tone)
Shades the picture in black conte crayon with white heightening on a toned sheet: dense, slightly waxy black strokes, crisp edges, the lights put on in white. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#2b2a2c), `deepLead` (#121112), `deepFrom` (0.7), `hardness` (0.35), `pressure` (0.6), `tooth` (0.7), `smudge` (0.55), `gloss` (0.05), `heighten` (0.95), `heightenFrom` (0.76), `direction` (1), `angle` (40), `strokeLength` (70), `spacing` (9), `width` (2), `layers` (4), `jitter` (0.25), `taper` (0.35), `lightest` (0.92), `darkest` (0.3), `toneMiddle` (0.66), `formShade` (0.55).
Pair it with `conteBlackLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("conteBlackShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Conte sanguine line (styleBlock, Line)
Edge lines in red-brown sanguine conte crayon with white heightening: square-stick strokes in warm red-brown for the darks, the lights put on in white on a toned sheet: outlines, folds and contacts drawn as wandering conte crayon passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#7a3524), `hardness` (0.35), `tooth` (0.7), `smudge` (0.55), `width` (1.7), `strokes` (2), `wander` (1.5), `overshoot` (5), `variation` (0.55).
Pair it with `conteSanguineShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("conteSanguineLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Conte sanguine shade (styleBlock, Tone)
Shades the picture in red-brown sanguine conte crayon with white heightening: square-stick strokes in warm red-brown for the darks, the lights put on in white on a toned sheet. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#9a4a32), `deepLead` (#6b2c1d), `deepFrom` (0.75), `hardness` (0.35), `pressure` (0.55), `tooth` (0.75), `smudge` (0.55), `gloss` (0), `heighten` (0.95), `heightenFrom` (0.76), `direction` (1), `angle` (40), `strokeLength` (70), `spacing` (9), `width` (2), `layers` (4), `jitter` (0.25), `taper` (0.35), `lightest` (0.92), `darkest` (0.3), `toneMiddle` (0.66), `formShade` (0.55).
Pair it with `conteSanguineLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("conteSanguineShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Conte sepia line (styleBlock, Line)
Edge lines in warm sepia-brown conte with soft white heightening: a gentle, old-master brown drawing on a toned sheet: outlines, folds and contacts drawn as wandering conte crayon passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#4f3424), `hardness` (0.4), `tooth` (0.65), `smudge` (0.25), `width` (1.6), `strokes` (2), `wander` (1.6), `overshoot` (5), `variation` (0.55).
Pair it with `conteSepiaShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("conteSepiaLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Conte sepia shade (styleBlock, Tone)
Shades the picture in warm sepia-brown conte with soft white heightening: a gentle, old-master brown drawing on a toned sheet. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#6e4a32), `deepLead` (#3f2a1d), `deepFrom` (0.75), `hardness` (0.4), `pressure` (0.5), `tooth` (0.7), `smudge` (0.55), `gloss` (0), `heighten` (0.8), `heightenFrom` (0.78), `direction` (0), `angle` (20), `strokeLength` (75), `spacing` (9), `width` (2), `layers` (4), `jitter` (0.25), `taper` (0.45), `lightest` (0.92), `darkest` (0.3), `toneMiddle` (0.66), `formShade` (0.55).
Pair it with `conteSepiaLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("conteSepiaShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Conte three crayons line (styleBlock, Line)
Edge lines in the three-crayon figure drawing: sanguine for the middle darks, black for the deepest darks and accents, white chalk heightening on the lights, the middle tones left as the tan sheet: outlines, folds and contacts drawn as wandering conte crayon passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#5a2a1f), `hardness` (0.35), `tooth` (0.7), `smudge` (0.55), `width` (1.7), `strokes` (2), `wander` (1.5), `overshoot` (5), `variation` (0.55).
Pair it with `conteThreeCrayonsShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("conteThreeCrayonsLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Conte three crayons shade (styleBlock, Tone)
Shades the picture in the three-crayon figure drawing: sanguine for the middle darks, black for the deepest darks and accents, white chalk heightening on the lights, the middle tones left as the tan sheet. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#9e4b31), `deepLead` (#1e1c1d), `deepFrom` (0.6), `hardness` (0.35), `pressure` (0.55), `tooth` (0.75), `smudge` (0.55), `gloss` (0), `heighten` (0.95), `heightenFrom` (0.76), `direction` (1), `angle` (40), `strokeLength` (70), `spacing` (9), `width` (2), `layers` (5), `jitter` (0.25), `taper` (0.4), `lightest` (0.92), `darkest` (0.3), `toneMiddle` (0.66), `formShade` (0.55).
Pair it with `conteThreeCrayonsLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("conteThreeCrayonsShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Doodle wax crayon line (styleBlock, Line)
Edge lines in a child's wax crayon scribble in the colours of things: chunky, waxy, scribbled back and forth, catching the paper's tooth, outlines that wobble off the shapes: outlines, folds and contacts drawn as wandering notebook doodle passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#3f3550), `hue` (0.7), `hardness` (0.25), `tooth` (0.8), `width` (2.8), `strokes` (1), `wander` (3), `scribble` (0.5), `overshoot` (10), `variation` (0.4), `boil` (0.3).
Pair it with `doodleCrayonShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("doodleCrayonLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Doodle wax crayon shade (styleBlock, Tone)
Shades the picture in a child's wax crayon scribble in the colours of things: chunky, waxy, scribbled back and forth, catching the paper's tooth, outlines that wobble off the shapes. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#7a6a52), `deepLead` (#4a3b5a), `deepFrom` (0.8), `hardness` (0.25), `pressure` (0.6), `tooth` (0.85), `smudge` (0), `wax` (0.4), `hue` (1), `gloss` (0), `direction` (3), `angle` (15), `strokeLength` (60), `spacing` (12), `width` (4), `layers` (3), `jitter` (0.8), `taper` (0.3), `scribble` (0.7), `lightest` (0.97), `darkest` (0.3), `boil` (0.3).
Pair it with `doodleCrayonLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("doodleCrayonShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Doodle felt tip line (styleBlock, Line)
Edge lines in a black felt-tip marker: bold, even, rounded lines and chunky scribbled fills that do not catch the paper at all: outlines, folds and contacts drawn as wandering notebook doodle passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#141415), `darkness` (1), `hardness` (0.6), `pressure` (0.8), `tooth` (0), `width` (2.6), `strokes` (1), `wander` (1.8), `scribble` (0.45), `overshoot` (6), `variation` (0), `blobs` (0.6), `boil` (0.3).
Pair it with `doodleFeltTipShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("doodleFeltTipLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Doodle felt tip shade (styleBlock, Tone)
Shades the picture in a black felt-tip marker: bold, even, rounded lines and chunky scribbled fills that do not catch the paper at all. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#1b1b1d), `deepLead` (#0f0f10), `deepFrom` (1), `hardness` (0.6), `pressure` (0.7), `tooth` (0), `smudge` (0), `gloss` (0), `blobs` (0.5), `direction` (3), `angle` (20), `strokeLength` (55), `spacing` (11), `width` (2.6), `layers` (3), `jitter` (0.7), `taper` (0), `scribble` (0.7), `lightest` (0.8), `darkest` (0.25), `contrast` (1.3), `boil` (0.3).
Pair it with `doodleFeltTipLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("doodleFeltTipShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Doodle in the margin line (styleBlock, Line)
Edge lines in a margin doodle in blue pen: scribbly loopy fills in the shadows and wobbly, exaggerated lines, playful and unfinished: outlines, folds and contacts drawn as wandering notebook doodle passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#22357c), `darkness` (0.95), `hardness` (0.7), `tooth` (0.1), `width` (1.2), `strokes` (2), `wander` (1.5), `scribble` (0.6), `overshoot` (10), `variation` (0.3), `blobs` (0.3), `boil` (0.35).
Pair it with `doodleMarginShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("doodleMarginLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Doodle in the margin shade (styleBlock, Tone)
Shades the picture in a margin doodle in blue pen: scribbly loopy fills in the shadows and wobbly, exaggerated lines, playful and unfinished. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#2d3f86), `deepLead` (#1d285c), `deepFrom` (0.8), `hardness` (0.7), `pressure` (0.7), `tooth` (0.1), `smudge` (0), `gloss` (0.2), `glossColour` (#8c7fa8), `blobs` (0.3), `direction` (3), `angle` (0), `strokeLength` (45), `spacing` (7), `width` (1.4), `layers` (4), `jitter` (0.8), `taper` (0.2), `scribble` (0.8), `lightest` (0.93), `darkest` (0.35), `formShade` (0.6), `boil` (0.35).
Pair it with `doodleMarginLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("doodleMarginShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Doodle on a sticky note line (styleBlock, Line)
Edge lines in a quick pencil doodle on a small sticky note: fast loose scribbles and wobbly lines, a few marks standing for each shadow. Pair it with any smooth paper tinted pale yellow: outlines, folds and contacts drawn as wandering notebook doodle passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#3d3e44), `hardness` (0.45), `tooth` (0.3), `width` (1.4), `strokes` (2), `wander` (1.8), `scribble` (0.5), `overshoot` (9), `variation` (0.5), `boil` (0.3).
Pair it with `doodleStickyNoteShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("doodleStickyNoteLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Doodle on a sticky note shade (styleBlock, Tone)
Shades the picture in a quick pencil doodle on a small sticky note: fast loose scribbles and wobbly lines, a few marks standing for each shadow. Pair it with any smooth paper tinted pale yellow. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#4b4c52), `deepLead` (#303136), `deepFrom` (0.85), `hardness` (0.45), `pressure` (0.5), `tooth` (0.3), `smudge` (0.1), `gloss` (0.2), `direction` (3), `angle` (30), `strokeLength` (50), `spacing` (10), `width` (1.6), `layers` (2), `jitter` (0.7), `taper` (0.5), `scribble` (0.65), `lightest` (0.82), `darkest` (0.3), `boil` (0.3).
Pair it with `doodleStickyNoteLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("doodleStickyNoteShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Graphite 2H line (styleBlock, Line)
Edge lines in a hard 2H lead: pale, thin, crisp strokes at one even slant, like a technical or architectural study: outlines, folds and contacts drawn as wandering graphite pencil passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#5d6066), `darkness` (0.85), `hardness` (0.95), `pressure` (0.5), `smudge` (0), `width` (0.9), `strokes` (1), `wander` (0.6), `overshoot` (6), `variation` (0.25).
Pair it with `graphite2HShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("graphite2HLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Graphite 2H shade (styleBlock, Tone)
Shades the picture in a hard 2H lead: pale, thin, crisp strokes at one even slant, like a technical or architectural study. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#6e7178), `deepLead` (#4f535a), `hardness` (0.95), `pressure` (0.45), `tooth` (0.7), `smudge` (0), `gloss` (0.15), `direction` (1), `angle` (45), `strokeLength` (60), `spacing` (6), `width` (1), `layers` (4), `jitter` (0.08), `taper` (0.4), `lightest` (0.9), `darkest` (0.3).
Pair it with `graphite2HLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("graphite2HShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Graphite 4B line (styleBlock, Line)
Edge lines in a soft 4B lead: dark, broad, slightly fuzzy strokes crossing in the shadows, with a soft shine where it lies heavy: outlines, folds and contacts drawn as wandering graphite pencil passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#2c2e34), `hardness` (0.3), `pressure` (0.6), `smudge` (0.2), `width` (1.7), `strokes` (2), `wander` (1.8), `overshoot` (7), `variation` (0.6).
Pair it with `graphite4BShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("graphite4BLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Graphite 4B shade (styleBlock, Tone)
Shades the picture in a soft 4B lead: dark, broad, slightly fuzzy strokes crossing in the shadows, with a soft shine where it lies heavy. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#3a3c43), `deepLead` (#1f2026), `hardness` (0.3), `pressure` (0.6), `tooth` (0.55), `smudge` (0.25), `mass` (0.7), `gloss` (0.5), `direction` (2), `angle` (30), `strokeLength` (80), `spacing` (8), `width` (2), `layers` (5), `jitter` (0.2), `taper` (0.65).
Pair it with `graphite4BLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("graphite4BShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Graphite 6B study line (styleBlock, Line)
Edge lines in a very soft 6B lead: a dark tonal study, broad strokes rubbed into velvety shadows that shine where they are heaviest: outlines, folds and contacts drawn as wandering graphite pencil passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#1f2025), `hardness` (0.1), `pressure` (0.7), `smudge` (0.4), `width` (2.2), `strokes` (2), `wander` (2.2), `overshoot` (8), `variation` (0.65).
Pair it with `graphite6BShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("graphite6BLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Graphite 6B study shade (styleBlock, Tone)
Shades the picture in a very soft 6B lead: a dark tonal study, broad strokes rubbed into velvety shadows that shine where they are heaviest. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#2e3036), `deepLead` (#16171b), `hardness` (0.1), `pressure` (0.7), `tooth` (0.5), `smudge` (0.5), `mass` (0.65), `gloss` (0.65), `direction` (0), `angle` (20), `strokeLength` (90), `spacing` (9), `width` (2.6), `layers` (6), `jitter` (0.25), `taper` (0.7), `darkest` (0.3).
Pair it with `graphite6BLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("graphite6BShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Graphite HB line (styleBlock, Line)
Edge lines in an everyday HB lead: even grey strokes that follow the form, the plain pencil sketch: outlines, folds and contacts drawn as wandering graphite pencil passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#33353b), `darkness` (0.95), `hardness` (0.55), `smudge` (0.08), `width` (1.1), `strokes` (2), `wander` (1.4), `overshoot` (5), `variation` (0.5), `crease` (0.85), `contact` (0.6).
Pair it with `graphiteHBShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("graphiteHBLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Graphite HB shade (styleBlock, Tone)
Shades the picture in an everyday HB lead: even grey strokes that follow the form, the plain pencil sketch. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#383b42), `deepLead` (#24262b), `hardness` (0.55), `pressure` (0.65), `tooth` (0.6), `smudge` (0.35), `gloss` (0.1), `direction` (0), `angle` (25), `strokeLength` (70), `spacing` (6), `width` (1.15), `layers` (5), `jitter` (0.15), `taper` (0.6), `lightest` (0.84), `darkest` (0.28), `contrast` (0.9).
Pair it with `graphiteHBLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("graphiteHBShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Graphite mechanical 0.5 line (styleBlock, Line)
Edge lines in a fine mechanical pencil: very even, thin, close-set parallel strokes with no smudge, crossed only in the deepest shadow: outlines, folds and contacts drawn as wandering graphite pencil passes that break on the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so every line block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#45484f), `hardness` (0.75), `smudge` (0), `width` (0.9), `strokes` (1), `wander` (0.5), `overshoot` (3), `variation` (0.2).
Pair it with `graphiteMechanicalShade` for the same medium's shading, or use it alone over the rendered picture, or over any shade or wash.
```luau
StyleKit.add("graphiteMechanicalLine", { id = "line" })
StyleKit.swap("line", "charcoalVineLine") -- another medium's line, one change
```
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Graphite mechanical 0.5 shade (styleBlock, Tone)
Shades the picture in a fine mechanical pencil: very even, thin, close-set parallel strokes with no smudge, crossed only in the deepest shadow. Darker places get more strokes laid over the lighter places' strokes; the strokes stay on the surfaces and catch the paper's tooth.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so every shade block takes the same settings and `StyleKit.swap(entry, otherBlock, { keepSettings = true })` carries them across. This variant's own defaults: `lead` (#55585f), `deepLead` (#3a3d44), `deepFrom` (0.85), `hardness` (0.75), `pressure` (0.5), `tooth` (0.45), `smudge` (0), `gloss` (0.2), `direction` (2), `angle` (-35), `strokeLength` (55), `spacing` (5), `width` (0.9), `layers` (5), `jitter` (0.05), `taper` (0.3).
Pair it with `graphiteMechanicalLine` for the same medium's edges, or with any Line block (inkBlocks' pens, styleKit's `depthLine`). Put it on a paperBlocks paper for the tooth: the strokes catch on the peaks and skip the valleys.
```luau
StyleKit.add("graphiteMechanicalShade", { id = "shade" })
StyleKit.set("shade", { pressure = 0.7, direction = 2 }) -- press harder, cross the strokes
```
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# pencilFill (shader)
The full-frame pass the pencilBlocks Fill blocks run: the sheet a pencil drawing starts from. It lays a pale "sketch blank" of the picture that keeps `keepColour` of its colour and is lifted `paleness` of the way to the bare sheet, and, with `strokes` above 0, a light first layer of coloured pencil in each thing's own colour, laid with the same surface-anchored strokes as the shade blocks (pencilCore on styleKit's skStrokes), so they stay on the surfaces when the camera moves and catch the paper's tooth. Only what light reached is lifted, so with every light off the frame stays black.
Used by `sketchBlankFill` and `coloredPencilUnderlayFill`. A pencil shade over it shows it where the shade's `over` is above 0 (the shade lays its strokes over what the blocks before it made); at `over = 0` the shade starts from a clean sheet.
## 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.
# pencilLine (shader)
The full-frame pass every pencilBlocks line block runs (Line slot): edges found with inkBlocks' inkCore (silhouettes, folds, contacts) drawn as one to three pencil passes that wander, overshoot the corners, vary in pressure and break on the paper's 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.
# pencilShade (shader)
The full-frame pass every pencilBlocks shade block runs (Tone slot): strokes that build up stroke by stroke as the picture darkens, laid on surfaces with styleKit's skStrokes and drawn in a medium by pencilCore.
In a dim scene the sheet is drawn no brighter than the brightest parts of the frame as rendered (read on a fixed 5 x 5 grid), and whatever the strokes are laid over is held to it, so a dark room stays dark; when most of the screen would carry strokes they give way to rubbed tone of the same value, so the screen never fills with stripes. The package README's "Dim scenes and dark rooms" has the numbers.
## 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.
# Sketch blank (styleBlock, Fill)
A pale sketch blank: the picture lifted toward the bare paper, keeping as much of its own colour as you choose. `keepColour = 0` gives a grey value drawing, `1` keeps every colour as rendered, and `paleness` sets how close to bare paper it goes. Pencil, charcoal or ink is then drawn over a quiet, light underpainting instead of over the full-colour render.
Part of pencilBlocks. Runs the shared `pencilFill` shader with `strokes = 0`; `coloredPencilUnderlayFill` is the same shader with a light layer of coloured pencil strokes, so the two swap with `StyleKit.swap("fill", "coloredPencilUnderlayFill", { keepSettings = true })`.
A pencil shade drawn over it shows it where the shade's `over` is above 0 (at 0 a shade starts from a clean sheet):
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("pencilSketch")
StyleKit.add("sketchBlankFill", { id = "fill" }) -- the blank, under the shade
StyleKit.set("fill", { keepColour = 0.5 }) -- keep half the colour
StyleKit.set("shade", { over = 1 }) -- the shade's strokes over the blank
```
## What it gives up in motion
It changes only colour and value, pixel by pixel, so it adds nothing that can slide, swim or shimmer when the camera moves.
## How it treats content
- Opaque things: lifted toward the bare sheet by `paleness`, keeping `keepColour` of their colour; the underlayer's strokes are laid in each thing's material colour, greys getting only a little.
- Transparent things, particles and smoke: lifted like everything else, pixel by pixel; strokes are laid on the surface behind them.
- Sky: lifted at least `skyBare` of the way to the sheet; no strokes.
- Fog: lifted with what is behind it, so foggy distance goes toward the bare sheet; past `fadeEnd` the underlayer's strokes give way to a soft tone.
- Foliage: alpha-tested leaves are in the depth and are treated like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Skinned characters: the blank is pixel by pixel and travels with them; the underlayer's strokes are laid on world positions, so keep it off a moving character with a group mask, or paint the character with `PencilHero.paint`.
- Dark sheets (black paper, the boards): the blank sinks toward the sheet instead of toward white.
- Black stays black: only what light reached is lifted, so 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.
# Storybook fill (styleBlock, Fill)
A soft storybook underlayer: the picture lifted to warm, light pastel colour, laid with the side of a soft coloured pencil and rubbed smooth, so a pencil line and a light shade sit over it like the pages of a picture book. Keeps more of each thing's colour than `sketchBlankFill`. Black stays black.
Part of pencilBlocks. Runs the shared `pencilFill` shader and takes the same settings as `sketchBlankFill` and `coloredPencilUnderlayFill`, so it swaps with them in one change: `StyleKit.swap("fill", "storybookFill")`. Put a shade over it with `settings = { over = 1 }` so the strokes are laid over the colour. This variant's own defaults: `keepColour` (0.65), `paleness` (0.62), `coverage` (0.75), `hardness` (0.25), `smudge` (0.75), `width` (3.4), `spacing` (10), `layers` (2).
## What it gives up in motion
Its strokes are laid on the world position of the surface under each pixel and kept at screen size by octaves blended by distance, so they stay put on still things while the camera pans, dollies, orbits or zooms, and grow into the next octave instead of sliding. `boil` redraws each patch a little only on the shared held clock, never per frame; the colour under it never changes with it.
## How it treats content
- Opaque things: lifted toward the bare sheet by `paleness`, keeping `keepColour` of their colour; the underlayer's strokes are laid in each thing's material colour, greys getting only a little.
- Transparent things, particles and smoke: lifted like everything else, pixel by pixel; strokes are laid on the surface behind them.
- Sky: lifted at least `skyBare` of the way to the sheet; no strokes.
- Fog: lifted with what is behind it, so foggy distance goes toward the bare sheet; past `fadeEnd` the underlayer's strokes give way to a soft tone.
- Foliage: alpha-tested leaves are in the depth and are treated like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Skinned characters: the blank is pixel by pixel and travels with them; the underlayer's strokes are laid on world positions, so keep it off a moving character with a group mask, or paint the character with `PencilHero.paint`.
- Dark sheets (black paper, the boards): the blank sinks toward the sheet instead of toward white.
- Black stays black: only what light reached is lifted, so 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.
# Technical hatching shade (styleBlock, Tone)
Shades the picture in ruled technical hatching: long, straight, evenly spaced lines at 45 degrees, crossed at right angles in the darks, as a draughtsman shades a section or an elevation. In dark ink on white paper; on a dark or blue sheet (the `blueprint` look) the hatching is drawn in white.
Part of pencilBlocks. Runs the shared `pencilShade` shader, so it takes every setting the other pencil shades take, darker tones add crossing lines over the lighter tone's, and it swaps with any of them in one change: `StyleKit.swap("shade", "technicalHatchShade")`. This variant's own defaults: `lead` (#27304a), `direction` (2, crossed), `angle` (45), `strokeLength` (420), `spacing` (6), `width` (0.9), `layers` (3), `jitter` (0.02), `taper` (0), `hardness` (0.95), `pressure` (0.8), `lightest` (0.95), `darkest` (0.3), `boil` (0.05).
## What it gives up in motion
Strokes are laid on the world position of the surface under each pixel, measured in its own tangent plane, so they stay put on still things while the camera pans, dollies, orbits or zooms. To keep their size on screen the pattern is drawn at two octaves (spacing s and 2s) blended by distance: walking closer, strokes grow and new ones fade in between them rather than sliding. On a moving character they slide unless it carries its own marks (`PencilHero.paint`). The tone that decides how many strokes a place gets changes with the light, so a slowly moving light adds or removes strokes one by one. `boil` redraws each patch a little on every held step of the shared clock (8 a second in the pencil looks) without changing the tone, so the whole picture never flashes.
## How it treats content
- Opaque things: drawn by light, with `localTone` of each material's own darkness; lit planes are left as bare sheet and shade builds up stroke by stroke. Textures (brick, planks, grass) cancel out of the light, so they do not print as strokes; `detail` brings some back.
- Transparent things (glass, water): not in the depth, so strokes are laid on what is behind them.
- Particles and smoke: not in the depth; they take the strokes of the surface behind them.
- Sky: left as bare sheet with `sky` of its tone rubbed in as a light smudge; no strokes.
- Fog: thickens the value toward light, so foggy distance gets fewer strokes; past `fadeEnd` strokes give way to a soft rubbed tone.
- Skinned characters: strokes are laid on world positions, so they slide over a character that moves. Paint the character with `PencilHero.paint` (it carries the same marks on its own position) and keep this block off it with a group mask.
- Foliage: alpha-tested leaves are in the depth and take strokes like any surface; very fine foliage reads as tone.
- World text: exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`); the block leaves them as rendered.
- Black stays black: with every light off the frame stays black; `sk_finish` holds every pixel at or below the value the scene gave it.
## 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.
# Technical pen line (styleBlock, Line)
Edge lines in a fine technical pen: one even, steady stroke per edge with no wander, crisp folds, and construction lines that run a little past every corner, like an architect's or an engineer's sketch. In dark ink on white paper; on a dark or blue sheet (the `blueprint` look) the same line is drawn in white.
Part of pencilBlocks. Runs the shared `pencilLine` shader, so it takes every setting the other pencil lines take and swaps with them in one change: `StyleKit.swap("line", "technicalPenLine")`. This variant's own defaults: `lead` (#1d2433), `darkness` (1), `hardness` (1), `pressure` (0.6), `tooth` (0.15), `smudge` (0), `width` (1.0), `strokes` (1), `wander` (0.15), `overshoot` (16), `variation` (0.05), `crease` (1), `creaseAngle` (0.3), `boil` (0.1).
## What it gives up in motion
Edges are found from depth, normals and surface colour every frame, so outlines follow moving things exactly. The wander, the pressure along a line and the tooth breaks are laid on the surface under the line, so they stay put under camera moves and slide a little along a moving character. `boil` redraws a small part of the wander on each held step of the shared clock, never per frame. Lines thinner than about a drawn pixel fade instead of breaking into dashes.
## How it treats content
- Opaque things: outlines where depth jumps (on the near side only, so two outlines never double), folds between faces and contacts where differently coloured things meet.
- Transparent things (glass, water): not in the depth, so no line is drawn round them; the line of what is behind shows through.
- Particles and smoke: no lines.
- Sky: no lines; a silhouette against the sky is drawn on the near side.
- Fog: lines thin with distance (`thinNear` to `thinFar`) and are gone at `fadeEnd`.
- Skinned characters: outlined from depth every frame, so the line moves with them; the wander and the tooth break are laid on world positions and slide a little along a moving character.
- Foliage: alpha-tested leaves draw outlines; dense foliage can fill with lines, so raise `threshold` or mask it.
- World text: exclude labels a player must read; the block leaves them as rendered.
- Black stays black: 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.
# Ballpoint notebook doodle look
A notebook doodle style for a 3D game: how to make a scene look drawn in a school notebook, either as patient blue ballpoint pen cross-hatching or as loopy margin doodles with wobbly felt-tip outlines, on a ruled page, in one call with pencilBlocks. Also a red correction pen, a black felt tip, a wax crayon scribble and a doodle on a yellow sticky note.
## 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.
# Charcoal drawing look
A charcoal sketch look for a 3D game: how to make a scene read as a charcoal drawing or charcoal study, with soft smudged masses, a few strokes at their edges and deep velvety darks on rough grey-white paper, in one call with pencilBlocks. Covers vine, compressed, smudged and white charcoal and when to use each, the papers charcoal wants, white charcoal on black paper for a night scene, and why a dark charcoal scene stays dark.
## 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.
# Coloured pencil over watercolor
How to give a game a colored pencil over watercolor look, the mixed-media illustration of sketchbooks and field notes: loose transparent watercolor washes of each thing's colour with coloured pencil hatched over them, in one call with pencilBlocks and watercolorBlocks. Shows why the wash runs first and the pencil over it, how to change the wash colours, how to tone it down to pencil on bare paper, and the field notes look on brown kraft paper.
## 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.
# Example: a small pencil-sketch game from an empty world
A step-by-step tutorial for a small playable game with a pencil sketch art style, starting from an empty world: install pencilBlocks, build a courtyard from simple shapes, light it, put the pencil sketch look on in the scene build, and let the player collect pencils that each redraw the world in a darker lead, ending in colour. Every line was run in a fresh world, and the last section takes it all apart again.
## 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.
# How to make my game look like a pencil sketch
How do I make my game look like a pencil drawing? This guide turns any 3D game into a hand-drawn pencil sketch while it runs: graphite hatching that builds up in the shadows and stays on the surfaces as the camera moves, soft pencil outlines and a paper texture, in one call with pencilBlocks. Then change the pencil (hard 2H to soft 6B), switch to charcoal, conte, coloured pencil, ballpoint or a doodle, change the line or the paper with one change each, draw a moving character in the same hand, keep menus and labels readable, and keep a night scene dark.
## 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.
# Ballpoint notebook (styleLook)
A blue ballpoint drawing on a ruled notebook page: patient crossing hatching building to dense dark blue in the shadows, little ink blobs where strokes start, a faint shine where the ink is heavy, confident blue outlines.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("ballpointNotebook")
```
Every entry is an ordinary block: swap any one for another of its slot (`StyleKit.swap("shade", "charcoalVineShade")`, `StyleKit.swap("line", "inkPenLine")`, `StyleKit.swap("paper", "paperKraft")`) and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# Blueprint (styleLook)
A blueprint: the scene drawn in white technical pen lines and ruled white hatching on deep cyanotype blue paper, construction lines running past the corners, the darks left as the blue sheet.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("blueprint")
```
The sheet is paperBlocks' black paper tinted cyanotype blue; on a dark sheet pencilBlocks draws a dark line or shade in white, as a white pencil would. Every entry is an ordinary block: swap any one for another of its slot and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# Bold ink sketch (styleLook)
A bold, inky sketch: a heavy ink brush line that swells and tapers round every shape, over deep, contrasty 6B graphite hatching on smooth hot-press paper, sunlit planes left bare. Graphic and punchy, like a comic artist's pencils inked with a brush.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("boldInkSketch")
```
The line is inkBlocks' brush line, which pencilBlocks installs with it. Every entry is an ordinary block: swap any one for another of its slot and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# Charcoal study (styleLook)
A charcoal study on grey-white rough paper: broad vine charcoal smudged into soft tonal masses, compressed charcoal outlines and deep velvety darks, the paper's grain showing hard in the half-tones.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("charcoalStudy")
```
Every entry is an ordinary block: swap any one for another of its slot (`StyleKit.swap("shade", "charcoalVineShade")`, `StyleKit.swap("line", "inkPenLine")`, `StyleKit.swap("paper", "paperKraft")`) and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# Coloured pencil over watercolor (styleLook)
Loose transparent watercolor washes of each thing's colour, with hard coloured pencil hatched over them in the same colours, blue-violet pencil in the shadows and coloured pencil outlines, on white cold-press paper.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("coloredPencilWash")
```
Every entry is an ordinary block: swap any one for another of its slot (`StyleKit.swap("shade", "charcoalVineShade")`, `StyleKit.swap("line", "inkPenLine")`, `StyleKit.swap("paper", "paperKraft")`) and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# Conte figure study on tan (styleLook)
A three-crayon figure study on tan toned paper: sanguine for the middle darks, black for the deepest darks, white chalk heightening on the sunlit planes, the middle tones left as the bare tan sheet.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("conteFigureStudy")
```
Every entry is an ordinary block: swap any one for another of its slot (`StyleKit.swap("shade", "charcoalVineShade")`, `StyleKit.swap("line", "inkPenLine")`, `StyleKit.swap("paper", "paperKraft")`) and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# Doodle margins (styleLook)
A notebook margin doodle: scribbly, loopy blue pen fills in the shadows and wobbly black felt-tip outlines that overshoot every corner, playful and unfinished, on a ruled page.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("doodleMargins")
```
Every entry is an ordinary block: swap any one for another of its slot (`StyleKit.swap("shade", "charcoalVineShade")`, `StyleKit.swap("line", "inkPenLine")`, `StyleKit.swap("paper", "paperKraft")`) and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# Field notes on kraft (styleLook)
A naturalist's field-notes page on brown kraft paper: thin watercolor washes, hard coloured pencil hatched over them, a fine black ballpoint outline and white heightening put on over the sunlit planes. Four packages in one look.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("fieldNotesOnKraft")
```
Every entry is an ordinary block: swap any one for another of its slot (`StyleKit.swap("shade", "charcoalVineShade")`, `StyleKit.swap("line", "inkPenLine")`, `StyleKit.swap("paper", "paperKraft")`) and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# Pencil sketch (styleLook)
A graphite pencil sketch on warm white cold-press paper: HB hatching that follows the forms and builds up stroke by stroke in the shadows, soft wandering outlines, sunlit planes left as bare paper.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("pencilSketch")
```
Every entry is an ordinary block: swap any one for another of its slot (`StyleKit.swap("shade", "charcoalVineShade")`, `StyleKit.swap("line", "inkPenLine")`, `StyleKit.swap("paper", "paperKraft")`) and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# Storybook pencil (styleLook)
A soft storybook pencil look: warm pastel colour laid with the side of a soft coloured pencil and rubbed smooth, light coloured pencil hatching in the shadows and a soft, wandering pencil outline, on warm cold-press paper. Gentle and cosy, like a picture book.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("storybookPencil")
```
Every entry is an ordinary block: swap any one for another of its slot and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# Technical sketch (styleLook)
A technical or architectural sketch: fine, even technical pen lines with construction lines running past the corners, and ruled 45 degree hatching, crossed in the darks, on smooth white hot-press paper.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("technicalSketch")
```
Swap the paper for `paperBlack` with a blue `tint` (or apply `blueprint`) and the same lines and hatching are drawn in white. Every entry is an ordinary block: swap any one for another of its slot and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# White charcoal on black (styleLook)
White charcoal on black paper: the scene drawn only in light, sunlit planes built up from many white strokes, shadows left as the black sheet.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.applyLook("whiteCharcoalNight")
```
Every entry is an ordinary block: swap any one for another of its slot (`StyleKit.swap("shade", "charcoalVineShade")`, `StyleKit.swap("line", "inkPenLine")`, `StyleKit.swap("paper", "paperKraft")`) and swap back to get exactly this look again. Part of pencilBlocks.
## 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.
# pencilCore (shader module)
How a drawing medium lays its marks: lead and deep colour, hardness, pressure, how it catches the paper's tooth, smudge, burnish, wax, taking the colour of what it draws, shine where it lies heavy, ballpoint blobs and white heightening. Builds on styleKit's `skStrokes` (direction and stacked strokes by tone). Pure math with no bindings, so pencilBlocks' full-frame `pencilShade` pass and the `pencilSurface` material for a hero character draw with the same hand. Include after `~styleKit.shaders.skPatterns` and `~styleKit.shaders.skStrokes`.
## 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.
# pencilSurface (shader)
A hero object drawn in a pencilBlocks medium inside its own material, by the same rules the full-frame shade blocks follow (pencilCore on styleKit's skStrokes). Every stroke is laid on the object's own position, so on a walking character or a moving prop the marks travel with it instead of sliding across it. Written onto derived materials by `PencilHero.paint`; the PencilHero component keeps `pixelsPerRef` and `heldStep` current on each machine.
## 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.
# pencilBlocks (testSuite)
Twelve tests that prove pencilBlocks on the presented frame, at a 3D view of 1920 x 1080, on the campaign stage (lookbookShowcaseKit's stage where it is installed, as in the Style Cookbook; a stand-in set with the engine's humanoid figure otherwise): every block passes styleKit's block rules and each of the six media ships four or more shade and line variants; every whole look applies in one change; each medium reads as itself on the stage and on the figure (graphite neutral grey, coloured pencil coloured, charcoal darkest, conte warm, ballpoint blue, felt tip neutral black, all told apart); mark density grows with darkness and darker tones keep the lighter tone's strokes; the marks move with the world when the camera turns and zooms; charcoal and the soft leads draw masses, never zebra bands, never streaks close to a dark wall and never wide regular bands from 8 m; a figure painted with PencilHero carries its marks as it moves; adding, swapping and removing blocks gives the frame back; the held clock redraws without flashing; with every light off the picture stays black, and a dim room stays dim.
Every case brings its own lights and camera, holds the clock still, saves the scene's stack first and puts it back, and leaves no painted material behind. A frame is read only once every style shader has compiled and the frame was drawn after the change being judged, and two agreeing reads must be two different frames. Each test prints its numbers, and they are kept in `/zero/source/tmp/pencilBlocks_suite.txt`. Run it with `asset.resolve("pencilBlocks.tests.pencilBlocks", "testSuite"):run()`, in a scene nobody else is changing while it runs.
In a world that has only pencilBlocks installed, twelve cases run and one reports as **skipped** ("charcoal and the soft leads draw no wide bands from a normal distance"): the wide bands it looks for form only on the textured walls of lookbookShowcaseKit's campaign stage, so without that stage the case is skipped rather than passed on a reading that proves nothing. The runner prints a skip with a tick and counts it under `Skipped`, not `Passed`. To run it too, install **lookbookShowcaseKit** from the Style Cookbook and the kits its README lists. The suite can be run again in the same session: before a case builds its test room it rebuilds the room materials in place through the material type's own change handler (nothing is written to disk), because the scene swap at the end of a run lets the engine release them and a released material otherwise draws as the magenta error pattern on the next run.
The stage cases hold every sky in the open scene to one fixed day (the ProceduralSky defaults, 14:00) and put it back afterwards, as they switch the scene's own lights off, so a stage reading no longer follows the open scene's sky. Stage readings then repeat within 0.2 of 255 between runs; the density check's stroke counts land in one of two close states (up to 3% apart). The package README's "What repeats from run to run" says what was measured.
Where the campaign stage is not installed, the stand-in set's figure is the engine's humanoid, which arrives as a player's body: a character controller that poses and idles it, and a name label above it. The suite takes both off before it measures (since 1.1.18), so the figure is a still prop, as the campaign stage's figure is. Left on, they made one reading change from run to run in a fresh world (the held-clock case read 209.35 in one run and 209.71 in the next, every other reading the same).
The case "the darkest band stays the darkest, with the screen calm on" (pencilBlocks 1.1.24) builds one material turned three ways to its own sun (lit, glancing, shadow side) 600 m from the world's centre, under four light levels down to a dim scene where the screen calm engages, and reads every medium with its default settings and with `screenCalm = 0`. It fails when a medium's shadow band reads lighter than its glancing band (or the glancing lighter than the lit), or when the calm leaves the shadow band more than 1 level lighter than with the calm off. On the calm of 1.1.23 and earlier (strokes turned down, one layer's worth of tone rubbed in) the shadow band of graphite, coloured pencil and ballpoint read 2.9 to 3.5 lighter with the calm on at a fifth of the light; since 1.1.24 the calm rubs each layer into its average coverage and the gap is 0.4 at most.
## 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.
# pencilTestRoomSurface (shader)
A plain matte surface lit only by the scene's own lights (the sun with its shadow, point and spot lamps, ambient) and never by the sky's captured light, as the inside of a closed room is. The pencilBlocks test suite builds its every-light-off room from it (`pencilTestRoom.material`), so with every light switched off the room is truly black on any machine and in any world, whatever else the world holds. Not meant for game content.
## 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.
# pencilWorld
Turn an existing world, scene or installed kit into a hand-drawn pencil sketch (or a charcoal, conte, coloured pencil, ballpoint or doodle drawing) with pencilBlocks 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 (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 moving characters, world labels, any stack already in place (kept so it can be put back), any character already painted with `PencilHero`, and the pencil blocks and whole looks installed.
2. **Reference.** Saves the plain presented frame under `/zero/source/tmp/pencil/<subject>/` and picks a reference drawing of the same view: one generated with image generation (the `image_gen` service), or, for this world's pencil stage, one of the reference pictures already in `/zero/source/design/references/pencilstage`.
3. **Choose.** Picks a medium and its variant (graphite 2H, HB, 4B, 6B or mechanical; coloured pencil; charcoal; conte; ballpoint; notebook doodle), a line and a paper, or one of the eight whole looks (`pencilSketch`, `charcoalStudy`, `whiteCharcoalNight`, `conteFigureStudy`, `ballpointNotebook`, `doodleMargins`, `coloredPencilWash`, `fieldNotesOnKraft`), 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, { holdRate, softRadius })` with `shade`, `line` and `paper` entries.
5. **Tune.** Up to three rounds of comparing presented frames against the reference and the asked look, adjusting hardness, pressure, stroke direction and size, layers, tone range, smudge, line weight and distance, and the paper's tooth.
6. **Content.** Paints the player and moving characters with `PencilHero.paint`, so their marks travel with them and the full-frame shade and any wash are kept off them; 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 and a dim room stays dim (styleKit's dim guard), 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 medium, the stack before and after, every exclusion, group and mask, every painted character 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 makes is painting characters with `PencilHero.paint`, which writes derived materials under `/zero/source/pencilHero` and records the originals; each painted character is reported with `PencilHero.unpaint(target, { removeFiles = true })`, which puts every original back and deletes the derived files.
## What it needs
pencilBlocks installed (it comes with styleKit, paperBlocks, watercolorBlocks, inkBlocks and lookbookKit). 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.
## Starting it
zero workflow start --name pencilWorld --args '{"subject":"main","look":"soft graphite sketch with crossed hatching on rough paper"}'
`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.