# Ben-Day flat tint on surfaces (styleBlock, Tone)
Flat, even Ben-Day tints: each area is one even dot size picked from a few mechanical tints, the flat dot fills of old printed comics, laid on the surfaces so the dots stay on things as the camera moves.
Settings this block starts from: `shape` (0), `onSurfaces` (1), `angle` (45), `cellPx` (7), `flatten` (0.85), `gamma` (0.8), `levels` (3), `maxCover` (0.6). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
The screen is laid on the surfaces (along each surface's main axis in styleKit's shared coordinates), so a pan, orbit or dolly does not drag it: the dots stay on the walls and floor. It keeps about the same dot size on screen at any distance by blending two neighbouring screen sizes on the surface, so as you walk closer the dots grow into the next size instead of swelling or sliding; in the narrow distance band where two sizes blend, dots take a mixed shape for a moment. A cell is never drawn smaller than about five pixels: where it would be (a floor grazing to the horizon) it melts into flat tone, so there is no moire or shimmer. On a moving skinned character the dots come from world position and slide across the body. Curved surfaces switch dot direction where their main axis changes, which shows as a seam. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them, with the coordinates of the opaque surface behind them.
- Particles and smoke: screened where they change the picture's brightness, with the coordinates of the surface behind them.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else; the dots slide on a moving body.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Ben-Day flat tint (styleBlock, Tone)
Flat, even Ben-Day tints: each area is one even dot size picked from a few mechanical tints, the flat dot fills of old printed comics, holding still on the screen like a printed page.
Settings this block starts from: `shape` (0), `onSurfaces` (0), `angle` (45), `cellPx` (6), `flatten` (0.85), `gamma` (0.8), `levels` (3), `maxCover` (0.6). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
This is a page screen: the dots hold still on the screen, like the dot screen of a printed page, while the picture moves under them. Nothing crawls or shimmers, because the screen never moves and its cells are at least a few pixels across at every resolution (sized in reference pixels). What moves is which dots are inked: as a shadow edge or a light crosses the screen, dots grow and shrink smoothly in place, never popping. Fine contrasty detail in the picture can beat against a fine screen; raise `cellPx` if it does. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them.
- Particles and smoke: screened where they change the picture's brightness.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Chain dot screen on surfaces (styleBlock, Tone)
A chain (elliptical) dot halftone screen on the surfaces of things: oval dots that link into chains in the middle tones for smooth skin and sky gradients, laid on the surfaces so it stays on things as the camera moves.
Settings this block starts from: `shape` (3), `onSurfaces` (1), `angle` (45), `cellPx` (8). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
The screen is laid on the surfaces (along each surface's main axis in styleKit's shared coordinates), so a pan, orbit or dolly does not drag it: the dots stay on the walls and floor. It keeps about the same dot size on screen at any distance by blending two neighbouring screen sizes on the surface, so as you walk closer the dots grow into the next size instead of swelling or sliding; in the narrow distance band where two sizes blend, dots take a mixed shape for a moment. A cell is never drawn smaller than about five pixels: where it would be (a floor grazing to the horizon) it melts into flat tone, so there is no moire or shimmer. On a moving skinned character the dots come from world position and slide across the body. Curved surfaces switch dot direction where their main axis changes, which shows as a seam. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them, with the coordinates of the opaque surface behind them.
- Particles and smoke: screened where they change the picture's brightness, with the coordinates of the surface behind them.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else; the dots slide on a moving body.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Chain dot screen (styleBlock, Tone)
A chain (elliptical) dot halftone screen on the page: oval dots that link into chains in the middle tones for smooth skin and sky gradients, holding still on the screen.
Settings this block starts from: `shape` (3), `onSurfaces` (0), `angle` (45), `cellPx` (7). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
This is a page screen: the dots hold still on the screen, like the dot screen of a printed page, while the picture moves under them. Nothing crawls or shimmers, because the screen never moves and its cells are at least a few pixels across at every resolution (sized in reference pixels). What moves is which dots are inked: as a shadow edge or a light crosses the screen, dots grow and shrink smoothly in place, never popping. Fine contrasty detail in the picture can beat against a fine screen; raise `cellPx` if it does. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them.
- Particles and smoke: screened where they change the picture's brightness.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Cross-line screen on surfaces (styleBlock, Tone)
A cross-line screen on the surfaces of things: a grid of crossed lines that thicken with darkness, laid on the surfaces so it stays on things as the camera moves.
Settings this block starts from: `shape` (5), `onSurfaces` (1), `angle` (45), `cellPx` (8). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
The screen is laid on the surfaces (along each surface's main axis in styleKit's shared coordinates), so a pan, orbit or dolly does not drag it: the dots stay on the walls and floor. It keeps about the same dot size on screen at any distance by blending two neighbouring screen sizes on the surface, so as you walk closer the dots grow into the next size instead of swelling or sliding; in the narrow distance band where two sizes blend, dots take a mixed shape for a moment. A cell is never drawn smaller than about five pixels: where it would be (a floor grazing to the horizon) it melts into flat tone, so there is no moire or shimmer. On a moving skinned character the dots come from world position and slide across the body. Curved surfaces switch dot direction where their main axis changes, which shows as a seam. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them, with the coordinates of the opaque surface behind them.
- Particles and smoke: screened where they change the picture's brightness, with the coordinates of the surface behind them.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else; the dots slide on a moving body.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Cross-line screen (styleBlock, Tone)
A cross-line screen on the page: a grid of crossed lines that thicken with darkness, holding still on the screen.
Settings this block starts from: `shape` (5), `onSurfaces` (0), `angle` (45), `cellPx` (7). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
This is a page screen: the dots hold still on the screen, like the dot screen of a printed page, while the picture moves under them. Nothing crawls or shimmers, because the screen never moves and its cells are at least a few pixels across at every resolution (sized in reference pixels). What moves is which dots are inked: as a shadow edge or a light crosses the screen, dots grow and shrink smoothly in place, never popping. Fine contrasty detail in the picture can beat against a fine screen; raise `cellPx` if it does. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them.
- Particles and smoke: screened where they change the picture's brightness.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Diamond dot screen on surfaces (styleBlock, Tone)
A diamond dot halftone screen on the surfaces of things: diamond dots grow with darkness and meet as an exact checkerboard at half tone, laid on the surfaces so it stays on things as the camera moves.
Settings this block starts from: `shape` (2), `onSurfaces` (1), `angle` (0), `cellPx` (8). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
The screen is laid on the surfaces (along each surface's main axis in styleKit's shared coordinates), so a pan, orbit or dolly does not drag it: the dots stay on the walls and floor. It keeps about the same dot size on screen at any distance by blending two neighbouring screen sizes on the surface, so as you walk closer the dots grow into the next size instead of swelling or sliding; in the narrow distance band where two sizes blend, dots take a mixed shape for a moment. A cell is never drawn smaller than about five pixels: where it would be (a floor grazing to the horizon) it melts into flat tone, so there is no moire or shimmer. On a moving skinned character the dots come from world position and slide across the body. Curved surfaces switch dot direction where their main axis changes, which shows as a seam. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them, with the coordinates of the opaque surface behind them.
- Particles and smoke: screened where they change the picture's brightness, with the coordinates of the surface behind them.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else; the dots slide on a moving body.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Diamond dot screen (styleBlock, Tone)
A diamond dot halftone screen on the page: diamond dots grow with darkness and meet as an exact checkerboard at half tone, holding still on the screen.
Settings this block starts from: `shape` (2), `onSurfaces` (0), `angle` (0), `cellPx` (7). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
This is a page screen: the dots hold still on the screen, like the dot screen of a printed page, while the picture moves under them. Nothing crawls or shimmers, because the screen never moves and its cells are at least a few pixels across at every resolution (sized in reference pixels). What moves is which dots are inked: as a shadow edge or a light crosses the screen, dots grow and shrink smoothly in place, never popping. Fine contrasty detail in the picture can beat against a fine screen; raise `cellPx` if it does. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them.
- Particles and smoke: screened where they change the picture's brightness.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Round dot screen on surfaces (styleBlock, Tone)
A round halftone dot screen printed on the surfaces of things: dot size follows how dark each place is, the dots touch in a checker at half tone and open into white holes in the darks, and the dots are laid on the surfaces so they stay on things as the camera moves.
Settings this block starts from: `shape` (0), `onSurfaces` (1), `angle` (45), `cellPx` (8). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
The screen is laid on the surfaces (along each surface's main axis in styleKit's shared coordinates), so a pan, orbit or dolly does not drag it: the dots stay on the walls and floor. It keeps about the same dot size on screen at any distance by blending two neighbouring screen sizes on the surface, so as you walk closer the dots grow into the next size instead of swelling or sliding; in the narrow distance band where two sizes blend, dots take a mixed shape for a moment. A cell is never drawn smaller than about five pixels: where it would be (a floor grazing to the horizon) it melts into flat tone, so there is no moire or shimmer. On a moving skinned character the dots come from world position and slide across the body. Curved surfaces switch dot direction where their main axis changes, which shows as a seam. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them, with the coordinates of the opaque surface behind them.
- Particles and smoke: screened where they change the picture's brightness, with the coordinates of the surface behind them.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else; the dots slide on a moving body.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Round dot screen (styleBlock, Tone)
A round halftone dot screen printed on the page: dot size follows how dark each place is, the dots touch in a checker at half tone and open into white holes in the darks, and the screen holds still on the screen like a printed page.
Settings this block starts from: `shape` (0), `onSurfaces` (0), `angle` (45), `cellPx` (7). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
This is a page screen: the dots hold still on the screen, like the dot screen of a printed page, while the picture moves under them. Nothing crawls or shimmers, because the screen never moves and its cells are at least a few pixels across at every resolution (sized in reference pixels). What moves is which dots are inked: as a shadow edge or a light crosses the screen, dots grow and shrink smoothly in place, never popping. Fine contrasty detail in the picture can beat against a fine screen; raise `cellPx` if it does. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them.
- Particles and smoke: screened where they change the picture's brightness.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Line screen on surfaces (styleBlock, Tone)
A line screen on the surfaces of things: parallel lines that thicken with darkness, like a mezzotint or line-screen print, laid on the surfaces so it stays on things as the camera moves.
Settings this block starts from: `shape` (4), `onSurfaces` (1), `angle` (30), `cellPx` (7). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
The screen is laid on the surfaces (along each surface's main axis in styleKit's shared coordinates), so a pan, orbit or dolly does not drag it: the dots stay on the walls and floor. It keeps about the same dot size on screen at any distance by blending two neighbouring screen sizes on the surface, so as you walk closer the dots grow into the next size instead of swelling or sliding; in the narrow distance band where two sizes blend, dots take a mixed shape for a moment. A cell is never drawn smaller than about five pixels: where it would be (a floor grazing to the horizon) it melts into flat tone, so there is no moire or shimmer. On a moving skinned character the dots come from world position and slide across the body. Curved surfaces switch dot direction where their main axis changes, which shows as a seam. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them, with the coordinates of the opaque surface behind them.
- Particles and smoke: screened where they change the picture's brightness, with the coordinates of the surface behind them.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else; the dots slide on a moving body.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Line screen (styleBlock, Tone)
A line screen on the page: parallel lines that thicken with darkness, like a mezzotint or line-screen print, holding still on the screen.
Settings this block starts from: `shape` (4), `onSurfaces` (0), `angle` (30), `cellPx` (6). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
This is a page screen: the dots hold still on the screen, like the dot screen of a printed page, while the picture moves under them. Nothing crawls or shimmers, because the screen never moves and its cells are at least a few pixels across at every resolution (sized in reference pixels). What moves is which dots are inked: as a shadow edge or a light crosses the screen, dots grow and shrink smoothly in place, never popping. Fine contrasty detail in the picture can beat against a fine screen; raise `cellPx` if it does. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them.
- Particles and smoke: screened where they change the picture's brightness.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Coarse newspaper screen on surfaces (styleBlock, Tone)
A coarse newspaper halftone: big round dots at a low screen ruling, swollen by ink spreading into cheap paper with ragged edges, laid on the surfaces so it stays on things as the camera moves.
Settings this block starts from: `shape` (0), `onSurfaces` (1), `angle` (45), `cellPx` (13), `flatten` (0.7), `gain` (0.55), `maxCover` (0.9), `rough` (0.6). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
The screen is laid on the surfaces (along each surface's main axis in styleKit's shared coordinates), so a pan, orbit or dolly does not drag it: the dots stay on the walls and floor. It keeps about the same dot size on screen at any distance by blending two neighbouring screen sizes on the surface, so as you walk closer the dots grow into the next size instead of swelling or sliding; in the narrow distance band where two sizes blend, dots take a mixed shape for a moment. A cell is never drawn smaller than about five pixels: where it would be (a floor grazing to the horizon) it melts into flat tone, so there is no moire or shimmer. On a moving skinned character the dots come from world position and slide across the body. Curved surfaces switch dot direction where their main axis changes, which shows as a seam. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them, with the coordinates of the opaque surface behind them.
- Particles and smoke: screened where they change the picture's brightness, with the coordinates of the surface behind them.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else; the dots slide on a moving body.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Coarse newspaper screen (styleBlock, Tone)
A coarse newspaper halftone: big round dots at a low screen ruling, swollen by ink spreading into cheap paper with ragged edges, holding still on the screen.
Settings this block starts from: `shape` (0), `onSurfaces` (0), `angle` (45), `cellPx` (12), `flatten` (0.7), `gain` (0.55), `maxCover` (0.9), `rough` (0.6). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
This is a page screen: the dots hold still on the screen, like the dot screen of a printed page, while the picture moves under them. Nothing crawls or shimmers, because the screen never moves and its cells are at least a few pixels across at every resolution (sized in reference pixels). What moves is which dots are inked: as a shadow edge or a light crosses the screen, dots grow and shrink smoothly in place, never popping. Fine contrasty detail in the picture can beat against a fine screen; raise `cellPx` if it does. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them.
- Particles and smoke: screened where they change the picture's brightness.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
The full-frame pass of toneScreens' four-colour process blocks (processFourColour and processFourColourOnSurfaces).
# Four-colour process (styleBlock, Colour)
It sits in the **Colour** slot (a colour choice: the inks the page is printed in) as a chain block with rank 90, so it prints whatever a palette before it made.
Four-colour process printing: the picture separated into cyan, magenta, yellow and black plates, each laid down as its own angled dot screen so they form the little rosettes of a printed comic page, holding still on the screen like a printed page; plates can be printed slightly out of register.
Settings: `cellPx` (6), `angles` (15, 75, 0, 45), `blackGen` (0.6), `levels` (0), `gain` (0.15), `rough` (0.15), `offsetCM` and `offsetYK` (no misregistration), `density` (1), the four inks and `sky` (1). Print it out of register with `StyleKit.set(entry, { offsetCM = { 1.5, 0, 0, -1.2 } })`.
## What it gives up in motion
This is a page screen: the dots hold still on the screen, like the dot screen of a printed page, while the picture moves under them. Nothing crawls or shimmers, because the screen never moves and its cells are at least a few pixels across at every resolution (sized in reference pixels). What moves is which dots are inked: as a shadow edge or a light crosses the screen, dots grow and shrink smoothly in place, never popping. Fine contrasty detail in the picture can beat against a fine screen; raise `cellPx` if it does. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; separated into four plates by colour; each plate's dots grow with how much of its ink the colour needs.
- Transparent things (glass, water): screened by the colour seen through them.
- Particles and smoke: screened where they change the picture's brightness.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Four-colour process on surfaces (styleBlock, Colour)
It sits in the **Colour** slot (a colour choice: the inks the page is printed in) as a chain block with rank 90, so it prints whatever a palette before it made.
Four-colour process printing laid on the surfaces: cyan, magenta, yellow and black plates as angled dot screens forming rosettes, with the dots staying on things as the camera moves; plates can be printed slightly out of register.
Settings: `cellPx` (7), `angles` (15, 75, 0, 45), `blackGen` (0.6), `levels` (0), `gain` (0.15), `rough` (0.15), `offsetCM` and `offsetYK` (no misregistration), `density` (1), the four inks and `sky` (1). Print it out of register with `StyleKit.set(entry, { offsetCM = { 1.5, 0, 0, -1.2 } })`.
## What it gives up in motion
The screen is laid on the surfaces (along each surface's main axis in styleKit's shared coordinates), so a pan, orbit or dolly does not drag it: the dots stay on the walls and floor. It keeps about the same dot size on screen at any distance by blending two neighbouring screen sizes on the surface, so as you walk closer the dots grow into the next size instead of swelling or sliding; in the narrow distance band where two sizes blend, dots take a mixed shape for a moment. A cell is never drawn smaller than about five pixels: where it would be (a floor grazing to the horizon) it melts into flat tone, so there is no moire or shimmer. On a moving skinned character the dots come from world position and slide across the body. Curved surfaces switch dot direction where their main axis changes, which shows as a seam. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; separated into four plates by colour; each plate's dots grow with how much of its ink the colour needs.
- Transparent things (glass, water): screened by the colour seen through them, with the coordinates of the opaque surface behind them.
- Particles and smoke: screened where they change the picture's brightness, with the coordinates of the surface behind them.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else; the dots slide on a moving body.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
The full-frame pass every toneScreens screen block shares (page screens and screens on surfaces).
# Square dot screen on surfaces (styleBlock, Tone)
A square dot halftone screen on the surfaces of things: square dots grow with darkness until they close into solid ink, laid on the surfaces so it stays on things as the camera moves.
Settings this block starts from: `shape` (1), `onSurfaces` (1), `angle` (45), `cellPx` (8). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
The screen is laid on the surfaces (along each surface's main axis in styleKit's shared coordinates), so a pan, orbit or dolly does not drag it: the dots stay on the walls and floor. It keeps about the same dot size on screen at any distance by blending two neighbouring screen sizes on the surface, so as you walk closer the dots grow into the next size instead of swelling or sliding; in the narrow distance band where two sizes blend, dots take a mixed shape for a moment. A cell is never drawn smaller than about five pixels: where it would be (a floor grazing to the horizon) it melts into flat tone, so there is no moire or shimmer. On a moving skinned character the dots come from world position and slide across the body. Curved surfaces switch dot direction where their main axis changes, which shows as a seam. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them, with the coordinates of the opaque surface behind them.
- Particles and smoke: screened where they change the picture's brightness, with the coordinates of the surface behind them.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else; the dots slide on a moving body.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# Square dot screen (styleBlock, Tone)
A square dot halftone screen on the page: square dots grow with darkness until they close into solid ink, holding still on the screen.
Settings this block starts from: `shape` (1), `onSurfaces` (0), `angle` (45), `cellPx` (7). It shares every setting of the screen shader (see the package README), so any screen swaps for any other with `StyleKit.swap(entry, otherScreen, { keepSettings = true })` keeping your tuning.
## What it gives up in motion
This is a page screen: the dots hold still on the screen, like the dot screen of a printed page, while the picture moves under them. Nothing crawls or shimmers, because the screen never moves and its cells are at least a few pixels across at every resolution (sized in reference pixels). What moves is which dots are inked: as a shadow edge or a light crosses the screen, dots grow and shrink smoothly in place, never popping. Fine contrasty detail in the picture can beat against a fine screen; raise `cellPx` if it does. Nothing changes on the clock, so there is no flicker.
## How it treats content
- Opaque things: screened by their brightness; dark places get big dots or solid ink, light places little or none.
- Transparent things (glass, water): screened by the colour seen through them.
- Particles and smoke: screened where they change the picture's brightness.
- Sky: screened by its brightness, scaled by `sky` (set it to 0 to keep a clean sky).
- Fog: fog lightens things, so far away there are fewer dots.
- Skinned characters: screened like everything else.
- Foliage: screened; dense leaves can look busy, raise `cellPx` or lower `amount`.
- World text: dark letters collect ink; exclude labels a player must read (`StyleKit.options({ exclude = { ... } })`).
- Black stays black: dots only darken, they add no light.
- Dim rooms: kept dim; this is a Tone block, so the stack's dim guard holds a dark room as dark as it was rendered.
# halftone (shader module)
The halftone and tone screens of toneScreens as pure math with no bindings: round, square, diamond, chain, line and cross-line screens whose inked share of a cell really equals the wanted coverage (dot size follows tone), flat Ben-Day style tints, dot gain (ink spreading into paper), ragged ink edges, four-colour process separation (CMYK with grey component replacement) and a melt to flat tone where a screen would get too fine to draw. Every block in toneScreens draws through it, and any surface material or other package (a manga screentone look, a printed poster material) can include it to draw the same dots: `#include "~toneScreens.shaders.halftone"`.
| Function | What it gives |
|---|---|
| `ht_cover(p, angle, shape, c, aa, rough, n)` | Ink coverage 0..1 at `p` (in screen cells) for wanted coverage `c`, antialiased over `aa` cells. Shapes: 0 round, 1 square, 2 diamond, 3 chain, 4 line, 5 cross-line. |
| `ht_sd(q, shape, c)` | Signed distance in cells to the ink edge (q already rotated): blend two screens in this form and they stay crisp. |
| `ht_rotate(p, a)` | Rotate a position into a screen's axes. |
| `ht_tone(luma, light, dark, gamma, maxCover)` | Wanted coverage from brightness. |
| `ht_tint(c, levels, soft)` | Snap a tone to a few even Ben-Day tints. |
| `ht_gain(c, gain)` | Dot gain: ink spreading into the paper, most in the middle tones. |
| `ht_cmyk(rgb, blackGen)` | Four-colour process separation. |
| `ht_lift(rgb, value)` | A colour at a lighter value with its hue kept, so dots carry the shade. |
| `ht_melt(aa)` | How far a screen melts into its flat tone at this cell size. |
| `ht_noise(p)`, `ht_hash(p)` | Small stable noise for ragged edges. |
It depends on nothing, not even styleKit, so it works in any shader.
# steadySurface (shader module)
Surface coordinates for marks that stay on things, with the engine's antialiasing jitter taken back out. `ts_surface_plane(uv)` returns the same coordinates as styleKit's `sk_surface_plane` (world metres along the surface's main axis, or view-direction radians on the sky), but steady from frame to frame: crisp dots laid on it no longer flicker at their edges on a still camera.
Include it after styleKit's shared prelude in a full-screen (post-process) shader:
```wgsl
#include "~styleKit.shaders.skCommon"
#include "~toneScreens.shaders.steadySurface"
```
Call it from control flow every pixel takes alike (it takes screen derivatives). toneScreens' screens on surfaces and four-colour process on surfaces use it. Unlike `~toneScreens.shaders.halftone`, which is pure maths, this module needs styleKit's prelude.
Measured on a still camera in the showcase street: a black round-dot screen on surfaces went from 20.6 to 1.2 per-pixel standard deviation over ten frames (the untouched frame reads 0.5); on the sky, from 17.6 to 0.7.
# toneScreens tests
Checks the package against styleKit's block rules and against what its docs promise, partly on the presented frame of a small set the suite builds itself (a light wall, a dark wall and a camera of its own), since the test runner empties the scene.
- **Rules:** all eighteen screens are installed from toneScreens, pass `StyleKit.checkBlock` and sit in the Tone slot.
- **Two forms, one set of settings:** every page screen (holds still on the screen) has a screen on surfaces (stays on things) with exactly the same settings, so switching between them is one swap.
- **One change:** any screen swaps for any other in one `StyleKit.swap("screen", id)` that keeps the entry's id.
- **Dot size follows tone:** with the screen's paper lift and print fade off, the round, square, line and newspaper screens each take a larger share of the dark wall's brightness than of the light wall's.
- **Still screen:** on a still camera two settled frames a second apart match under the round, chain, cross-line and four-colour screens, misregistration included. Nothing crawls, shimmers or jitters on the clock.
- **Clean removal:** clearing a stack of screens puts the frame back within 0.5 of 255.
The scene's shared stack, the viewport camera and the test set are put back after each test. Run with `zero tests run toneScreensTests` or `asset.resolve("toneScreensTests", "testSuite"):run()`. It takes about a minute, most of it waiting for frames to settle.
## Known limits
The tests judge the frame by mean brightness over regions, which is what tone means for a screen; they do not count individual dots. Motion of the camera (surface screens staying on things) is covered by the Lookbook's motion numbers in styleKit, not here.