# StyleKit (module) The styleKit library: the block registry (`blocks`, `block`, `settingsOf`, `checkBlock`), the stack operations every player shares (`add`, `remove`, `swap`, `move`, `setStrength`, `setMask`, `set`, `setOn`, `clear`, `load`, `options`), `describe` for what is in the stack, and quality control (`quality`, `setQuality`). Reach it with `require("~styleKit.StyleKit")` from any script.

# PaperSurface (component) Marks an entity that `PaperMaterial.paint` put on paper: it remembers the material every Model under it wore before (`originals`), the paperSurface materials it wears now (`materials`) and the paper and settings they were written with (`settings`). These fields are synced and saved with the scene, so every player sees the same paper on the object, and `PaperMaterial.unpaint` puts every original back. About once a second on each machine it also sets the materials' `pixelsPerRef` to that machine's screen height over 1080, so the tooth keeps the full-frame paper's size in the picture on any screen; that is a runtime setting and is never written into the material files. Add it through `PaperMaterial.paint`, not by hand.

# styleKit Build your own art style out of stackable look blocks: a look is a stack of small blocks (a wash, an ink line, a paper, a grain) that runs over the whole frame after antialiasing, lives in the scene and looks the same for every player. Version 1.2.3. ## Install and use Install **styleKit** from ZeroMind (search "styleKit" or "stackable art style blocks"). Installs with several dependencies can be slow (#21420), so give an install time to finish and check `/zero/source` for the package folder. Then, from the console or any script, stack one of each of the kit's four example blocks: ```luau local StyleKit = require("~styleKit.StyleKit") StyleKit.add("posterize") -- Colour: a few flat tone steps StyleKit.add("duotone", { strength = 0.5 }) -- Colour: two inks, laid half over the posterize StyleKit.add("depthLine") -- Line: a clean ink outline from depth StyleKit.add("sketchLine", { strength = 0.6 }) -- Line: soft pencil strokes laid over the outline print(#StyleKit.describe().entries) -- 4 StyleKit.clear() -- the frame is exactly as rendered again ``` No material is edited. The first `add` makes a synced `StyleStack` entity in the scene, so every player draws the same stack; put a `StyleStack` component in your scene's build to keep a look with the scene. ## The blocks in this package | Block | Slot | What it does | |---|---|---| | `posterize` | Colour | Cuts the picture into a few flat tone steps, like a screen print. | | `duotone` | Colour | Maps the picture onto a shadow ink and a light ink. | | `depthLine` | Line | A clean, one-sided ink outline from depth plus creases from normals. | | `sketchLine` | Line | Soft, broken pencil strokes over shape and colour edges, redrawn on the held clock. | | `sharedView` | Medium | A diagnostic for block authors: shows one shared input in place of the picture. | Every block lists its slot and its tags (the words a person would search for: `watercolor`, `pencil`, `halftone`, `pixel art`, `chalk`), so you can pick blocks by tag with `StyleKit.blocks({ tag = "pencil" })` or `zero styleKit list --tag pencil`. A block's tags come from its `block.yaml` `tags:` list when it has one, otherwise from its `.metadata` tags. More blocks come in their own packages and plug straight in: `starterBlocks` has a block for every slot (card surface, light bands, flat wash, surface dots, plain paper, dark board, line boil, chunky pixels, soft grain, vignette), `watercolorBlocks` has ten chained watercolor Fill blocks and a cold-press paper, with pigment sets, whole looks and a hero material, `inkBlocks` has five ink lines, four ink fills, ink colours and whole looks, and `paperBlocks` has seventeen papers (cold press, rough, hot press, rice, newsprint, kraft, parchment, canvas, board, blackboard, green chalkboard, black paper, aged sketchbook, toned grey and tan, ruled notebook, vellum) that publish the paper field and layer by region. `StyleKit.blocks()` lists every block installed. A package can also ship pigment sets (`pigmentSet` assets: `StyleKit.pigmentSets()`) and whole looks (`styleLook` assets: `StyleKit.looks()`) next to its blocks. ## How a stack works A stack is an ordered list of entries `{ id, block, on, strength, mask, settings }` on a `StyleStack` component. Blocks sit in ten slots that always run in this order: 1. **Surface**: what things are made of. 2. **Light**: how surfaces take light. 3. **Fill**: how areas of colour are laid. 4. **Tone**: marks that carry shade. 5. **Line**: edges. 6. **Colour**: palette and grade. 7. **Ground**: what it is drawn on. The first Ground block publishes the shared ground (and the paper field, when it has one); a later Ground block whose field says `layers: true` lays its ground over the one before by its strength and mask. 8. **Time**: how motion is held. The first Time block publishes the shared wobble. 9. **Raster**: how the image is sampled. 10. **Medium**: what it is seen through. Any slot can be empty. Any block swaps for any other block of its slot with no other change (`StyleKit.swap(entry, otherBlock)`); strength and mask stay. Inside a slot the list order decides: the first block reads the slot's input, and every later block in the same slot reads the same input and is laid over it by its strength and mask (`stacking: layer`, the default). So two Line blocks with weights 1 and 0.4 blend 60 / 40, and two Fill blocks with complementary masks split the frame. A block whose `block.yaml` says `stacking: chain` reads what the blocks before it in its slot made instead, so modifier blocks build on each other (a wash, then its granulation, then its darkened edges). A block's `rank: <number>` decides where `StyleKit.add` places it: before the first block of its slot with a higher rank, so a chain lands in its painting order whatever order its blocks are added in. ### Keeping a stack A stack made with these calls is a live edit of the scene, like moving a prop. Save the scene (`layers.active:save()` or the editor's save) and the stack is in its `scene.json`: it comes back on every load and after a restart, the same for every player. `StyleKit.clear()` takes every block off the frame; to get the saved stack back, revert the scene (`tools.use("scene", "revert")`). `scene.reload` keeps live edits by saving them first, so a clear followed by a reload is a saved clear. Keep one StyleStack per scene. ### Shared by every block in a stack - **One clock.** `sk_time()` and the held clock `sk_held()` / `sk_step()`, stepped at the stack's `holdRate` (8 per second by default). Every wobble and boil runs on the held clock. - **One set of coordinates that stay on things.** `sk_surface_coord(uv, perMetre)` lays marks on surfaces from world position along each surface's main axis, and on the sky from the view direction, so a pan or a dolly does not drag them. - **Surface data copied once per frame**: view distance, world position, normal and base colour (`sk_dist`, `sk_world`, `sk_normal`, `sk_albedo`). - **One ground** (`sk_ground_at`): paper colour and grain height, published by the first Ground block (plain white paper with flat grain when there is none). - **Layered grounds** (since 1.2.0): a later Ground block whose `block.yaml` field says `layers: true` lays its ground, and its paper field, over the one before by its strength and mask, so regions of a world sit on different papers: `StyleKit.add("paperParchment", { id = "mapRoom", mask = { kind = "sphere", center = { 30, 2, 10 }, radius = 6 } })`. A Ground block without `layers: true` publishes only when it is the first. - **One paper field** (`sk_paper`, read through `skPaper`, since 1.2.0): how the sheet under each pixel takes paint and ink, for a block that lists `paper` under `reads`: `sk_thirst(uv)` (-1 hard-sized, 0 the standard sheet blocks are tuned on, +1 thirsty), `sk_sheen(uv)`, `sk_fibre(uv)` and `sk_dark_ground(uv)` (1 where the sheet is dark and the picture is made of light marks). A Ground block publishes it with a `field.paper` shader; where none does every value is 0, so a block reading it draws exactly as before. It is only made when some live block reads it. paperBlocks' papers publish it; watercolorBlocks' bleed and edge darkening and every inkBlocks block read it. - **The scene's sun** (`sk_sun`, a float4, since 1.2.0): for a block that declares it and lists `sun` under `reads`, the direction toward the scene's first directional light, `w` 1 when it gives light (0, and a default direction, when there is none). Read about once a second through the lighting toolbox, so a moving sun reaches blocks within a second. Raking light on paper tooth and sheen use it. - **One wobble** (`sk_wobble_uv`): an offset published by the first Time block (still when there is none). A wash and an ink line that both read it tremble together. - **One pattern library** (`skPatterns`): noise, fractal noise, cells, dots, hatching, ordered threshold, triplanar noise for materials (`skp_triplanar_fbm`) and brush strokes (`skp_stroke`). - **One soft field** (`sk_soft`, read through `skSoft`): a half-resolution, depth-aware blur of what a block reads, for a block that lists `soft` under `reads`. Each tap is tested against the centre surface's plane rebuilt from world positions, so a nearer thing is never smeared over a farther one. The stack makes it for the first block that reads it and makes it again whenever a later reader reads a different image; its width is the stack option `softRadius` (reference pixels, 10 by default). - **One pigment set** (`sk_pigments`, read through `skPigmentSet`): the scene's palette of paints as a 16 x 1 texture, for a block that lists `pigments` under `reads`. `StyleKit.setPigments(id)` changes it for every block and every player at once; with none picked blocks keep the scene's own colours. - **One rendered frame** (`sk_rendered`, read through `skRendered`): the frame as it entered the stack, for a block that lists `rendered` under `reads`. Light estimates read it against the base colour, so surface texture cancels instead of printing back as shade. With `sk_geo_normal` (a normal rebuilt from world positions, every tier) it lets a block judge light and shape on the low tier and the forward path too. - **One way to mix paint** (`skPigment`): pigment mixing in transmittance and optical density (log space), two pigments in one wash, glazes that multiply, dilution toward the paper. Pure math, so a full-frame block and a material mix paint the same way. - **Noise that stays on things and keeps its size** (`skAnchored`): triplanar noise on world position that stays on still things (`sk_anchored_fbm`, `sk_anchored_cells`), and noise that also keeps its size in the picture at any distance by blending two octaves by distance (`sk_scaled_fbm`, `sk_scaled_level`, `sk_surface_plane`, `sk_ref_metres`), for paper tooth, flecks and strokes. `sk_tooth(uv)` reads the shared paper's valleys (0 on a peak, 1 in a valley). - **Chain stacking** inside a slot (`stacking: chain` and `rank` in `block.yaml`): later blocks build on what the ones before them made. - **Many blocks, one shader** (`defaults:` in `block.yaml`, since 1.2.0): a block's own defaults over its shader's, so a family of blocks (paperBlocks' seventeen papers) shares one shader and each block is its own starting point. `StyleKit.settingsOf(id)` reports the block's defaults. - **Swap memory** (since 1.2.0): each stack entry remembers the settings of every block it has held, so `StyleKit.swap("paper", "paperKraft")` then `StyleKit.swap("paper", "inkPaper")` puts back exactly the settings `inkPaper` had, and the frame returns exactly. The memory is kept on the entry in the synced stack, so it is shared and saved with the scene; `load` and `applyLook` write new entries without it. - **One exit** (`sk_finish`): strength, mask, layer mode, and black stays black: a block never makes light where the frame had none. ### Masks `StyleKit.setMask(entry, mask)` limits a block: - `{ kind = "depth", near = 0, far = 12, soft = 0.2 }`: by view distance in metres. The soft edges lie outside the band and scale with their own distance: the block fades in over `soft` x `near` metres before `near` and out over `soft` x `far` metres after `far`, so nothing nearer than `near` x (1 - `soft`) is touched, whatever `far` is. The sky lies at the viewing camera's far distance (its `Camera.far`, 8000 m by default): a band whose `far` reaches that distance takes the sky in, a shorter one leaves it out. - `{ kind = "rect", rect = { x0, y0, x1, y1 } }`: a screen region in 0..1 (top left is 0, 0). - `{ kind = "sphere", center = { x, y, z }, radius = 5 }`: a region of the world. - `{ kind = "group", group = 1 }`: the objects in mask group 1, 2 or 3 (`StyleKit.options({ groups = { { id, id }, { id } } })`). - `invert = true` flips any of them. `StyleKit.options({ exclude = { "SignBoard" } })` leaves objects (and their children) exactly as rendered: a prop, a world label. Name them: an entry is an entity name or an id, and a scene should store names, because an id written into the stack does not survive the scene being saved and loaded again (the entity comes back under a new id). Entities that arrive later are picked up within half a second. Put labels on a card of their own (a plain white quad behind the words), so the area left out around them is card rather than the raw scene. ### Quality The stack follows the device's quality tier (`renderer.qualityTier()`), and the tiers really change the cost: - `high` and `medium`: every block pass and every shared input at full resolution. `medium` also applies each block's `quality.medium` settings where it states them. - `low`: the shared inputs (surface data, ground, wobble) and the block chain itself run at half resolution, a quarter of the pixels for every pass, and blocks take their `quality.low` settings (fewer samples, fewer strokes). The copy of base colour and normals is made on `low` too, at that half resolution (since 1.1.4), so a block judges light and lays marks by the same rules on every tier and a look stays the same look; only the forward render path, which keeps no g-buffer, goes without it. The result is scaled up once at the end, before the UI; excluded objects are put back from the full-size frame, so they stay crisp. Measured on the Lookbook's textured wall at 2097 by 1409 with a wash, a sketch line, paper, boil and dots: 1.64 ms of block passes at full resolution, 0.30 ms on `low` (before the half-size copy, which adds one small compute pass). On `low`, marks are drawn at half resolution and so are softer: the honest trade for running on a small device. `StyleKit.setQuality("low")` forces a tier on this machine; `StyleKit.setQuality(nil)` follows the device again. The Lookbook measures the cost per pass at each tier. ### Whole frame or inside a material Every block works on the whole frame with no material edits. Where it means something, a block also ships a shader module a material includes for a chosen set of objects (`include:` in its `block.yaml`), for example starterBlocks' Stepped light, whose `bandedToon` shader bands a material by the same rule. Use a group mask to keep the full-frame pass off those objects. ## API | Call | What it does | |---|---| | `StyleKit.blocks(filter?)` | Every block installed: `{ id, name, slot, tags, summary, reads, writes, settings, package, path }`. Filter by `slot`, `package`, `tag` (one tag or a list, all must match) or `text` (which also searches tags). In the shell: `zero styleKit list`, `zero styleKit list line`, `zero styleKit list --tag pencil`. | | `StyleKit.block(id)` / `settingsOf(id)` | One block / its settings with docs, defaults (the block's own `defaults:` where it states them) and ranges. | | `StyleKit.add(id, opts?)` | Add a block (`strength`, `mask`, `settings`, `id`, `index`). Returns `ok, entryId`. | | `StyleKit.remove(entry)` | Remove an entry (by entry id, block id or position). | | `StyleKit.swap(entry, id, opts?)` | Swap an entry's block for another of its slot; strength and mask stay. The entry remembers the settings of every block it held, so a block swapped back in gets exactly the settings it had (a block it never held starts from its defaults). `{ keepSettings = true }` carries the current settings across instead; `{ anySlot = true }` allows a swap across slots. | | `StyleKit.move(entry, index)` | Reorder (orders blocks inside a slot). | | `StyleKit.setStrength(entry, 0..1)` / `setOn(entry, bool)` | Weight / switch an entry. | | `StyleKit.setMask(entry, mask?)` | Limit an entry by depth, region or group. | | `StyleKit.set(entry, { name = value })` | Change settings. Colours take `"#rrggbb"`, `{ r, g, b }` or `{ r, g, b, a }`. | | `StyleKit.load(entries, opts?)` / `clear()` | Replace / empty the stack. `opts`: `holdRate`, `markScale`, `pigments`, `softRadius`, `look`. | | `StyleKit.options({ holdRate, markScale, exclude, groups, active, pigments, softRadius })` | Stack-wide options. `pigments` is a pigment set id (`""` for none); `softRadius` is the soft field's width in reference pixels (2 to 40, default 10). | | `StyleKit.pigmentSets(filter?)` / `pigmentSet(id)` | Every pigment set installed: `{ id, name, summary, tags, pigments = { { name, colour, granulation } }, shadow, light, air, package, path }`, filtered by `package`, `tag` or `text` / one set by id. | | `StyleKit.setPigments(id)` | Pick the pigment set every block that reads pigments mixes from, for the whole stack and every player. `""` picks none, so blocks keep the scene's own colours. | | `StyleKit.looks(filter?)` / `look(id)` | Every whole look installed (`styleLook` assets): `{ id, name, summary, tags, entries, pigments, holdRate, markScale, package, path }` / one look by id. | | `StyleKit.applyLook(id, opts?)` | Apply a whole look in one change: its blocks replace the stack and its pigment set, hold rate, mark scale and soft radius are set with them. `{ keep = { "line" } }` keeps the entries of the slots named from the current stack. A look naming a block that is not installed is refused and nothing changes. | | `StyleKit.describe()` | What is in the stack, in run order, its `pigments`, `look` and `softRadius`, and what the runtime drew last frame. | | `StyleKit.checkBlock(id)` | Problems with a block against the block rules (empty when it passes). | | `StyleKit.newBlock(name, { slot, folder })` | Write a working block of your own to start from. | | `StyleKit.quality()` / `setQuality(tier?)` | The tier the stack draws at / force one here. | | `StyleKit.setClock(fn?)` | Drive the stack's one clock (boil, grain, wobble) from your own time in seconds, for a cutscene, a recording or the Lookbook; `nil` returns to the shared clock (wall-clock UTC, the same held step on every player's machine). | Writes go through the stack's owner, so in play any player can change the shared stack and every player sees the change. The `styleKit` toolbox offers the same from the shell (`zero styleKit list`, `zero styleKit stack`, `zero styleKit add posterize`). ## Writing a block A block is a plain folder holding `<name>.styleBlock/` (block.yaml, README.md, .metadata) and its `<name>.shader/` (a post-process shader whose `properties.yaml` starts with the styleKit shared header). `newBlock` writes one that works and registers it at once: ```luau local StyleKit = require("~styleKit.StyleKit") local path = StyleKit.newBlock("warmTint", { slot = "medium", title = "Warm tint" }) print(path) -- /zero/source/myBlocks/warmTint/warmTint.styleBlock StyleKit.add("warmTint", { strength = 0.6 }) -- a warm filter over the whole look StyleKit.set("warmTint1", { tint = "#ffcf8a" }) -- its setting, like any block's ``` Then edit `/zero/source/myBlocks/warmTint/warmTint.shader/shader.wgsl` to make it do what you want; the stack picks up the change as you save. To share blocks, move their folders into the `blocks/` folder of a package of your own (a `<name>.package` folder with its `package.yaml`): a package that holds blocks adds them to every world that installs it, with no code. The guide "Writing your own style block" walks the whole shape every block follows. ## Rules every block follows - It states its slot, what it reads and what it writes, and takes over nothing it does not own (a Ground block alone writes the ground, a Time block alone the wobble). - Every setting is named, documented in `block.yaml` and has a good default in its shader. - Marks stay on things unless the medium really is a screen (pixels, grain, a vignette), and they run after antialiasing and upscaling. - Wobble runs on the held clock. - Its README says what it gives up in motion and how it treats opaque things, transparent things, particles, sky, fog, skinned characters, foliage and world text. - With every light off the frame stays black (`sk_finish` holds every block to it). - The UI is drawn after the stack, so it stays readable. - No full-screen flashing above 3 Hz and no fine high-contrast stripes filling the view. `StyleKit.checkBlock` and the `styleKit` test suite check the rules that can be read from files. ## Guides and workflow This package carries its guides (search them with the `guides` tool or ZeroMind): combining blocks into your own art style, how to use styleKit, writing your own style block, and a worked example from an empty world to a small stylized game. The `restyleWorld` workflow gives an existing world, scene or kit a new look non-destructively, and the `styleKit` agent skill tells an agent what it can do with blocks. ## What a look costs GPU milliseconds per frame of the style passes, 3D view drawing at 1893 x 1072 (98% of a 1920 x 1080 frame's pixels), measured with the Lookbook (`zero lookbook cost 1920 1080 true`) over its pan on a desktop GPU. The rest of the frame (scene, shadows, antialiasing) is not counted. Low quality runs the whole chain at half resolution. | Look | High | Low | |---|---|---| | README example: posterize, duotone 0.5, depthLine, sketchLine 0.6 | 0.60 | 0.11 | | Cookbook: flatWash, depthLine, plainPaper, lineBoil, softGrain 0.6 | 1.03 | 0.21 | | Comic: lightBands, surfaceDots, depthLine, posterize | 0.41 | 0.10 | | Chalk: depthLine, darkBoard | 0.43 | 0.10 | | Retro: posterize, chunkyPixels, softGrain, vignette | 0.22 | 0.07 | Each block alone, high / low: flatWash 0.45 / 0.07, sketchLine 0.32 / 0.06, darkBoard 0.24 / 0.07, plainPaper 0.23 / 0.07, depthLine 0.19 / 0.04, cardSurface 0.11 / 0.03, lightBands 0.09 / 0.03, surfaceDots 0.09 / 0.03, softGrain 0.09 / 0.03, lineBoil 0.06 / 0.02, chunkyPixels 0.06 / 0.02, posterize 0.05 / 0.02, duotone 0.04 / 0.02, vignette 0.04 / 0.02. A look costs a little less than its blocks added up, because the shared inputs (depth, surface coordinates, ground) are made once per frame for the whole stack. **Frame rate and the web.** On the web the Cookbook look was measured at about 29 to 30 fps in the Cookbook scene (one sample 25), against about 43 fps with no look, and the low tier did not change it: the look cost about 10 ms a frame there while its passes took about 1 ms of GPU time. That measurement is of styleKit 1.0.6. The cost was not the shading but the work around it, which a browser pays several times over: 15 screen-sized images made up front whatever the look, 11 passes, and engine calls every frame for every effect. 1.0.7 cuts it, measured on desktop: the Cookbook look now makes 7 images on high and 5 on low (was 15), runs 9 passes on high and 8 on low (was 11), and spends 0.19 ms of Luau a frame on high and 0.12 ms on low (was 0.40 ms on both), so low now saves passes and Luau, not only pixels. **Whether 1.0.7 holds 30 fps on the web is not measured yet:** an agent cannot start a browser engine (#20946), and in the desktop editor the whole-frame rate swings more from the editor's own load than the look costs, so no desktop fps is quoted here. `zero lookbook report` now starts with the frame rate in the scene you are in (no look, the look on high, on low, measured in turns), so one run in the web build gives the answer. The web limits it may still meet are open engine issues: #20750 (web frame rate), #17441 (cost of scene-colour features) and #17478 (post tiers on mobile). ## How it runs The `styleStack` render feature starts on a machine as soon as the scene's stack holds a live block (one that is on, has strength above 0 and is installed), on every player's machine alike. Each frame it copies the base colour and normal from the deferred g-buffer at `afterLighting`, then at `afterScenePost` (after antialiasing and the render-scale upscale, before the UI) it rebuilds world position and distance from depth, copies the frame, publishes the ground and wobble, runs each slot, puts excluded objects back and hands the result to the screen. A frame of the Cookbook look runs 9 passes: the copy of base colour and normals (only when a live block reads them, and never on the low tier), world position, the two shared fields, one pass per block, and the hand-off to the screen; the blocks read the scene directly, so there is no copy of the frame first. Only five screen-sized images are made up front (the chain's two, world position and the two fields); the rest are made the first time a look uses them (group masks, excluded objects, the base colour and normal copies). The Luau work per frame is a few calls into the engine: uniforms, settings and mask groups are written only when the stack, the tier or the camera's frame inputs change, and the clock only when the held step moves. When the stack holds no live block (after `StyleKit.clear()`, or with every entry off) the kit lets everything of its own go within two frames: every block effect and its five internal effects are removed from the screen effect list, its screen targets, buffer and mask materials are freed, and the render feature itself ends. `StyleKit.holdsAnything()` then reads false, and the first block added brings it all back. ## Known limits - **Offscreen captures and render-to-texture cameras do not draw the stack.** The stack runs at `afterScenePost`, which only the presented frame reaches, so `capture` with `source = "main"`, `"entity"` or `"position"` shows the unstyled scene; use `source = "presented"` or `renderer.presentedFrames`. Per-camera post: engine issues #66 and #17427. - **Depth in a feature's fragment pass reads 0 after post.** `zero_scene_depth` is not bound to a render feature's fragment pass at `afterScenePost`, so the kit copies depth with a compute pass once per frame and blocks read that copy (#17427). - **G-buffer channels are refused after post**, so base colour and normal are copied at `afterLighting`. On the forward path there is no base colour: Surface and Light blocks fall back to working from brightness alone. - **Marks on moving objects.** Surface coordinates come from world position, so marks stay put on still things under any camera move, but slide across a moving skinned character or a moving prop. Object-space coordinates need per-object data a full-frame pass does not have, so marks that stay on a moving object can only be drawn inside its material: watercolorBlocks' `watercolorSurface` shader shows how, carrying the object's own position from `vertex_clip` (`local_position`) to the fragment in the vertex colour (applied with `WatercolorHero.paint`). - **The soft field costs two half-resolution passes each time a reader reads a new image.** In a chain, a later block that reads `soft` reads a different picture from the first one, so the field is made again for it; keep soft readers few, or next to each other on the same input, on small devices. - **Post effects get one pass each and no history** (#17427): a block cannot read the previous frame or its own last output, so nothing in a block can build up or settle over time. - **Effect uniforms reset on recompile** without notice; the runtime renews its writes twice a second, so after a shader edit a setting can take up to half a second to come back. - **One held clock for every player, as close as their clocks are set.** Since 1.1.3 the held clock runs on wall-clock UTC (caught to the frame from `os.time()` ticking over), so every machine shows the same boil step at the same moment; machines whose clocks are set by the network agree to a few hundredths of a second, so two screens differ only in that sliver around each step. A machine whose clock is set wrong boils out of step with the others. `StyleKit.setClock` drives it from a time of your choosing instead, so a cutscene or the Lookbook repeats exactly. - **Transparent things and particles have no depth**, so lines and surface marks treat them as the opaque surface behind them; each block's README says how. - **Stage order** (#17426, #17439): blocks rely on `afterScenePost` running after the TAA resolve and the upscale, as the engine documents today. - **One stack per scene.** With two StyleStack entities in a scene the kit draws the last one it found; keep one, and change it rather than adding a second. - **After a scene switch** the engine can free the stack's screen targets; the runtime notices within about two seconds and rebuilds them, so the look can be missing for that moment. - Post-process shaders have no preview image, so the shader previews in this package are absent. ## Version history **1.2.3 (2026-11-02)**: the scene's sun is written to every block that reads it again twice a second, like every other shared value, so a block whose shader was compiled or recompiled after its sun was written (the first use of a block in a fresh install, a hot reload) no longer draws without its sun until the sun moves. This was why paperBlocks' Lookbook numbers changed from run to run. And outline ink: a surface that publishes metallic 3/255 with roughness 251/255 (toonBlocks' outlines) is copied with base colour known 0.5, `sk_is_ink(uv)` answers it, and every block, which takes base colour only above 0.5, leaves drawn ink as drawn. `StyleKit.VERSION` says 1.2.3. **1.2.2 (2026-11-01)**: the scene's sun (`reads: sun`, `sk_sun`) is read every 4 frames instead of about once a second, at once whenever the stack changes, and every frame while someone drives the clock (`StyleKit.setClock`, as the Lookbook does). A block that rakes light from the sun (paperBlocks' papers) no longer steps once a second under a moving sun, and no longer draws its first second with the sun of the scene or run before it, which had made Lookbook runs depend on what ran before them. `StyleKit.VERSION` says 1.2.2 (it had stayed at 1.2.0). **1.2.1 (2026-11-01)**: documentation only: install notes describe how installing works (install from ZeroMind search; installs with several dependencies can be slow) without naming internal ticket numbers. **1.2.0 (2026-11-01)**: the paper field, a second shared ground input (`reads: paper`, `sk_paper`, read through `skPaper`: thirst, sheen, fibre, dark ground), published by a Ground block's `field.paper` shader, neutral where none does and made only when a live block reads it; layered grounds (`field.layers: true`: a later Ground block lays its ground and paper field over the one before by its strength and mask, so regions of a world sit on different papers); the scene's sun for blocks that declare `sk_sun` (`reads: sun`); `defaults:` in `block.yaml` (per-block defaults over the shader's, reported by `settingsOf`, so many blocks share one shader); swap memory (each entry remembers the settings of every block it held, so swapping back returns the frame exactly; `keepSettings` carries settings across instead). `checkBlock` knows `field:paper` (Ground only), `sk_paper` and `sk_sun`, and a default for a setting the shader lacks. **1.1.0 (2026-10-31)**: blocks can build on each other inside a slot (`stacking: chain` in `block.yaml`; `layer` stays the default) and take a place in it (`rank`); two extra inputs a block may declare after the shared header, the soft field (`sk_soft`, a half-resolution, depth-aware blur, width `softRadius`, read through `skSoft`) and the scene's pigment set (`sk_pigments`, read through `skPigmentSet`); pigment mixing in optical density (`skPigment`), noise that stays on things and keeps its size in the picture (`skAnchored`), `skp_triplanar_fbm`, `skp_stroke` and `sk_tooth`; two new asset types, `pigmentSet` and `styleLook`, with `pigmentSets`, `pigmentSet`, `setPigments`, `looks`, `look` and `applyLook`; `options` and `load` take `pigments` and `softRadius`, `describe()` returns `pigments`, `look` and `softRadius`, and the StyleStack carries them as synced fields. **1.1.5 (2026-11-01)**: documentation only: Known limits and the using-styleKit guide said the held clock was each machine's own and out of step between players; since 1.1.3 it runs on wall-clock UTC and every machine shows the same boil step. Both now say so. **1.1.4 (2026-11-01)**: the `low` tier makes the copy of base colour and normals too, at its half resolution, so a block judges light and lays marks by the same rules on every tier (a look on `low` had stopped being the same look: light read from brightness turned dark materials grey and put mid-tone marks on lit walls). `sk_mark_normal(uv)` gives marks a surface facing on every path, rebuilt from neighbouring world positions where no normal was copied, and `sk_surface_coord`, `sk_surface_plane`, the triplanar noise and `sk_ref_metres` use it, so a wall is never projected as a floor (which smeared marks down their columns into vertical stripes). **1.1.3 (2026-11-01)**: the stack's held clock runs on wall-clock UTC (caught to the frame from `os.time()` ticking over), so every player's machine holds the same boil step at the same moment instead of each running its own; the step number wraps every 65536 steps at the same moment everywhere, so shaders keep every digit. `StyleKit.setClock(fn)` still drives it for a cutscene or the Lookbook. **1.1.2 (2026-11-01)**: `exclude` and group lists take entity names as well as ids (an id stored in a scene does not survive a save and load, so a scene's left-out board or labels were being painted over), and entries that find nothing yet are looked for again twice a second; a stack whose component was removed and added again is let go instead of refusing every change. **1.1.1 (2026-10-31)**: a third extra input, the frame as rendered (`reads: rendered`, `sk_rendered`, `skRendered`), for light estimates that do not print surface texture back; `sk_geo_normal` (a normal from world positions on every tier); and `sk_albedo` and `sk_normal` answer "unknown" when no g-buffer copy was made (low tier, forward path) instead of reading a stale frame. **1.0.8 (2026-10-31)**: store listing rewritten for creators; built on the current engine library (@builtin 0405ea4). **1.0.7 (2026-10-31)**: a depth mask's near limit holds whatever `far` is (each soft edge now scales with its own distance, not the whole band) and the sky lies at the camera's far distance; blocks list their tags and `blocks({ tag })` and `zero styleKit list --tag` pick by them; a lighter frame for the web: images made only when a look uses them (7 on high, 5 on low, was 15), no copy of the frame before the chain, no base colour copy on low or when no block reads it, and uniforms, settings and the clock written only when they change (Luau per frame 0.19 ms high, 0.12 ms low, was 0.40). **1.0.6 (2026-10-31)**: clearing the stack leaves nothing of the kit behind (every effect, target, buffer and the render feature are released within two frames, and `StyleKit.holdsAnything()` says so); the renderer starts only for a live block, on every machine; a per-look GPU cost table at 1080p; the wrong "black floor of 17" limit is gone (it was the Lookbook panel); the shared black guard now caps a dark pixel at its own brightness and its own brightest channel, so no block, alone or stacked, lightens an unlit frame (worst of all fourteen: +0.17 of 255). **1.0.5 (2026-10-31)**: `StyleKit.setClock` drives the stack's clock from a time of your choosing, so boil, grain and wobble repeat exactly in a cutscene, a recording or the Lookbook. **1.0.4 (2026-10-31)**: `newBlock` registers the block before it returns, so the README example stacks it on the next line; a block whose shader cannot be registered skips itself instead of stopping the whole stack, and the shader index is read afresh when blocks change; the author example writes to `/zero/source/myBlocks`; how to keep, clear and revert a saved stack. **1.0.3 (2026-10-31)**: screen targets freed by a scene switch are noticed and rebuilt; Known limits on one stack per scene and the dark viewport floor. **1.0.2 (2026-10-31)**: the `low` quality tier runs the block chain at half resolution (about five times cheaper in the Lookbook), excluded objects are restored at full size on every tier, the black guard closes fully on unlit pixels, the block type README describes the side-by-side folder layout. **1.0.1 (2026-10-31)**: masks by object group and exclusion drawn per group, durable state across hot reloads, the toolbox, the test suite, `newBlock`, guides, workflow and agent skill. **1.0.0 (2026-10-31)**: first release. Block type, StyleStack component, runtime, masks (depth, rect, sphere, group), exclusion, shared clock, coordinates, ground, wobble and patterns, quality tiers, four example blocks and a diagnostic block, toolbox, tests, guides, workflow and agent skill.

# paperBlocks Put your game on paper: seventeen papers a stylized look is drawn on, from cold-press watercolor paper and thirsty rice paper to brown kraft, parchment, canvas, a dusty blackboard and black paper for white ink. Each paper is a styleKit Ground block, so it swaps for any other paper in one change, stays on the surfaces it covers while the camera moves, and lets the blocks above it feel it: washes granulate into its tooth and run further on a thirsty sheet, ink lines break on rough grain and feather on soft fibres, and on toned and dark sheets the picture's lights are put on in white gouache, chalk or white ink. Parts of one world can sit on different papers (a village on cold press, a map room on parchment), and every player sees the same paper. Version 1.1.4. Built on styleKit 1.2.3 (the paper field, layered grounds, the scene's sun, per-block defaults and swap memory are styleKit 1.2.0 features; 1.2.3 keeps the sun on every paper after its shader compiles). ## Install and use Install **paperBlocks** from ZeroMind (search "paperBlocks" or "paper texture for a watercolor game"). It brings what its own files use, and nothing needs installing by hand: **styleKit** (the look stack its shaders build on), and **lookbookKit** with **starterBlocks** (the package's test suite measures at the Lookbook's every-light-off moment, and the Lookbook uses starterBlocks' blocks). It does not bring watercolorBlocks or inkBlocks: those are separate installs, and the papers work without them. Checked on 2026-11-01 by installing paperBlocks from ZeroMind into a brand new private world: 617 files in about 3 s, and the example below ran there line by line exactly as written (the frame changed on load, kraft read clearly differently, swapping back brought cold press back with its deeper tooth, and `clear()` returned the frame to exactly its unstyled brightness). Installs with several dependencies can be slow (#21420): give the install time to finish and check `/zero/source` for the `paperBlocks.package` folder. Then, in a fresh world with only paperBlocks installed, from the console or any script: ```luau local StyleKit = require("~styleKit.StyleKit") StyleKit.load({ { id = "line", block = "depthLine" }, -- styleKit's own clean ink outline { id = "paper", block = "paperColdPress" }, -- the picture laid on cold-press paper }) StyleKit.set("paper", { toothHeight = 1 }) -- a deeper tooth: one change StyleKit.swap("paper", "paperKraft") -- the same picture on brown kraft, lights in white gouache StyleKit.swap("paper", "paperColdPress") -- back on cold press, with the deeper tooth it had StyleKit.clear() -- the frame exactly as rendered again ``` Swapping back puts back exactly the settings the paper had (styleKit 1.2.0 remembers them on the entry), so the frame returns as it was. The stack lives on the scene's synced StyleStack, so every player sees the same paper, and it is saved with the scene. To see what is installed: `StyleKit.blocks({ package = "paperBlocks" })`, or in the shell `zero styleKit list ground` and `zero styleKit list --tag paper`. ## The papers Every paper is the same paper model with its own defaults, so a setting means the same thing on every paper and a paper you tuned on one block carries its meaning to another. "Lights" says what the paper needs from the picture's light: on a white sheet the lights are bare paper; on a toned or dark sheet they are put on in an opaque light, which only shows where the scene really is lit. | Paper | Block | Character | Best for | What lights need | |---|---|---|---|---| | Cold press | `paperColdPress` | Warm white, a rough felt tooth, the standard thirst the watercolor and ink blocks were tuned on. | Watercolor, line and wash, picture books: the default sheet. | Nothing special: lights are bare paper. | | Rough | `paperRough` | The deepest, largest tooth, warm white, a little thirstier. | Loose washes full of granulation, broken dry brush, scratchy lines. | A low sun across surfaces shows the tooth most. | | Hot press | `paperHotPress` | Smooth, almost no tooth, crisp white, hard-sized. | Crisp washes with hard edges and dark dried rims, exact ink lines, botanical and technical illustration. | Nothing special. | | Rice paper | `paperRice` | Thin and soft with long visible fibres, very thirsty. | Ink wash painting, soft washes that feather, lines that bleed along the fibres. | Nothing special. | | Newsprint | `paperNewsprint` | Grey-cream, a little yellowed, a fine flat grain and darker fibres, thirsty. | Zines, cheap comics, fuzzy print-like ink. | The sheet's grey-cream is the lightest light. | | Kraft | `paperKraft` | Brown, fibrous, a mid-tone ground. | Toned sketches, crafts and cardboard, gouache highlights. | A clear lit side: lights are put on in white gouache only where the picture is brighter than about halfway from the brown to white. A flat, dim scene stays brown. | | Parchment | `paperParchment` | Warm cream, strongly blotchy, a few age spots, a soft sheen, fairly hard-sized. | Old maps, documents, scrolls, a map room. | The sheen shows only where light reaches a surface, most under raking light. | | Canvas | `paperCanvas` | Primed canvas: a plain weave of threads under everything. | Painterly looks; a weave showing through paint and line. | Raking light shows the weave. | | Illustration board | `paperBoard` | Hard, smooth, bright and even. | Clean comic ink, controlled washes, graphic looks. | Nothing special. | | Blackboard | `paperBlackboard` | Dark slate with sharp grit, chalk dust and the ghosts of old wiping, very hard-sized, dead matte. | Chalk drawings, classrooms, puzzle rooms, night sketches. | The picture is made of chalk: only lit things are drawn. A dark scene is bare board. | | Green chalkboard | `paperGreenChalkboard` | A green school board, dustier than the slate. | The same as the blackboard, friendlier and more schoolroom. | As the blackboard. | | Black paper | `paperBlack` | Near-black with a soft tooth. | White ink drawings, silhouettes, night. | The picture is drawn in white ink: only lit things are drawn. | | Aged sketchbook | `paperSketchbook` | Yellowed, mottled, foxed with brown age spots that show through the paint. | Travel journals, old sketchbooks, memories. | Nothing special: lights are the yellowed sheet. | | Toned grey | `paperTonedGrey` | A mid-grey drawing paper. | Toned drawings: darks laid in, highlights in white chalk and gouache. | Lights are put on in white from about 40% of the way from the grey to white; the values between stay bare grey, the middle tone. | | Toned tan | `paperTonedTan` | A warm tan drawing paper. | Warm toned drawings with white highlights. | As toned grey. | | Ruled notebook | `paperNotebook` | Smooth bright paper with pale blue rules, a little thirsty. | Doodles, school-book and diary looks. | Nothing special; the rules show through every wash. | | Vellum | `paperVellum` | Cool cream, a cloudy formation, a satin sheen, very hard-sized. | Drafting and technical looks, washes that pool on top with hard edges. | The sheen needs light on the surface. | How the papers change watercolor and ink blocks, paper by paper, is in the guide "How paper changes watercolor and ink"; how to pick and tune one is in "How to choose a paper for my art style". ## The shared settings Every paper takes the same settings (each paper starts from its own defaults; `StyleKit.settingsOf("paperKraft")` lists them with that paper's defaults and the ranges). Change them with `StyleKit.set(entry, { name = value })`; colours take `"#rrggbb"`. | Setting | Range | What it does | |---|---|---| | `tint` | colour | The sheet's colour. On a white paper the bright areas become this colour; on a toned or dark sheet it is the ground the darks sink into and the lights are put on over. | | `toothHeight` | 0 to 1 | How tall the tooth is: how much it shades the sheet, how deep paint settles into it, and how strongly granulation, dry brush and ink lines feel it. | | `toothSharpness` | 0 to 1 | 0 soft rounded felt bumps, 1 sharp grit. Sharp grit makes put-on lights catch the peaks first (chalk on slate). | | `toothSize` | 1 to 40 | How large one tooth looks, in reference pixels (1080p). It keeps about this size at any distance. | | `fibre`, `fibreLength`, `fibreTone` | 0 to 1, 1 to 30, -1 to 1 | How many long fibres show, how long they are (in teeth), and whether they read lighter (above 0) or darker (below 0) than the sheet. | | `weave` | 0 to 1 | How much canvas weave replaces the tooth. | | `mottle` | 0 to 1 | How blotchy and uneven the sheet's tone is (warmer where darker). | | `foxing` | 0 to 1 | How many brown age spots the sheet carries. | | `rule`, `ruleColour`, `ruleSpacing` | 0 to 1, colour, 8 to 200 | Ruled lines: how strongly they show, their colour, and their spacing in reference pixels. | | `thirst` | 0 to 1 | How thirsty the sheet is: 0 hard-sized (crisp wash edges, dark dried rims, exact lines), 0.5 the standard sheet the watercolor and ink blocks were tuned on (nothing changes), 1 thirsty (washes spread and feather, lines bleed into the fibres). Felt only by blocks that read the paper field. | | `emboss` | 0 to 1 | How strongly the tooth catches light, strongest where the scene's sun rakes low across a surface. | | `sheen` | 0 to 1 | How much the sheet shines where light reaches it. Sheen is light the scene sends: none where there is none. | | `lights` | 0 to 1 | How much of the picture's light can be put on in an opaque light (gouache, chalk, white ink) instead of being left as bare sheet. 0 for white papers. Any amount above about 0.25 makes the sheet a toned ground (the darks sink into it) and the value is then the most light put on: the boards use 0.6, so a chalk drawing stays marks over slate even where the scene is brightest. | | `lightColour`, `lightTint` | colour, 0 to 1 | The colour of the put-on lights, and how much of the picture's own colour they keep. | | `lightsFrom` | 0 to 1 | Where lights start being put on, as a share of the way from the sheet's value to white: 0 everything lighter than the sheet, toward 1 only the brightest lights. | | `dust` | 0 to 1 | Chalk dust and the ghosts of old wiping on a board. | ## How a paper draws - **Darks go into the sheet** as transparent media: multiplied onto the sheet's colour and settling into the valleys of its tooth, thinner on its peaks. - **Lights are put on** on toned and dark sheets (`lights` above 0), from `lightsFrom` of the way between the sheet's value and white; on sharp grain they catch the tooth's peaks first, on soft grain they lie more evenly. - **The tooth is lit by the scene's sun** (the first directional light, read every few frames and written again whenever the paper's shader compiles), so a low raking sun shows it most, plus a little relief from the upper left as a sheet reads on a table. - **Everything sits on surfaces** and keeps its size in the picture: the tooth, fibres, blotches, spots and rules are laid on world position, so they stay on things under a pan, a dolly or a zoom, and any part finer than about two drawn pixels fades to its average, so nothing shimmers in the distance or on the low tier. They slide across moving characters, as every full-frame mark does. - **Black stays black.** Every pixel goes through styleKit's shared exit, so with every light off the frame is black on every paper, white paper and chalkboard alike. Each paper publishes the stack's shared ground (the sheet's colour and tooth height, which granulation, dry brush and ink lines read) and the **paper field** (thirst, sheen, fibre and whether the sheet is dark), which the watercolor and ink blocks read. The paper field is made only when a block in the stack reads it, so a paper under styleKit's own blocks costs nothing for it. ## Regions on different papers A later paper in the stack lays its ground and paper field over the one before by its strength and mask, so regions of one world sit on different papers: ```luau StyleKit.add("paperColdPress", { id = "paper" }) -- the whole world on cold press StyleKit.add("paperParchment", { id = "mapRoom", mask = { kind = "sphere", center = { 40, 2, -12 }, radius = 6 } }) -- the map room on parchment ``` Every mask kind works (depth, rect, sphere, group; `invert = true` flips it). The older papers (`plainPaper`, `darkBoard`, `inkPaper`, `wcColdPress`) do not layer: one of them can be the first paper under a paperBlocks region, but not a region laid over another paper. ## A paper on an object The papers above lay the sheet over the whole frame from world position, so a prop that moves, or a character that walks, slides under the tooth. To put an object on the same paper with the tooth on its own surface, give it the paper as a material: ```luau local PaperMaterial = require("~paperBlocks.PaperMaterial") PaperMaterial.paint(heroId) -- the paper the stack is on, with its tuned settings StyleKit.options({ groups = { { "Hero" } } }) -- name the object (or its parent) as mask group 1 StyleKit.setMask("paper", { kind = "group", group = 1, invert = true }) -- the full-frame paper leaves it to its own material ``` `paint` gives every Model at or under the entity a material on paperBlocks' `paperSurface` shader, derived from the one it wears: its base colour and texture are kept (the original collection is never rewritten), and it takes every setting of the paper the stack's first paperBlocks Ground entry uses, your tuning included. `PaperMaterial.paint(heroId, "paperCanvas", { emboss = 0.8 })` names another paper and overrides any setting. What the material does: - **The tooth stays on the object.** Tooth, fibres, weave, blotches, foxing and rules are laid on the object's own position, so they ride with it as it moves (on a skinned character, the bind pose, so it stays on the body as it animates). They keep about the full-frame paper's size in the picture: the object's `PaperSurface` component keeps each machine's screen height in the material, so it matches on every screen. - **Every light rakes it.** The tooth bends the surface normal and the engine's own lighting does the rest, so the sun, point lights and shadows show the tooth the way raking light shows it on the frame; `sheen` makes it shine where light reaches it. - **The same picture rules.** Darks go into the sheet and its valleys; on toned and dark papers the lights are put on in `lightColour` from `lightsFrom` up; nothing is brighter than the light that reached it, so an unlit object stays black. - **One paper, not two.** The group mask keeps the full-frame paper off the object, so the tooth is not laid twice (once sliding, once riding). If you would rather keep the full-frame paper on it, paint with `{ sheet = 0 }`: the material then adds only the tooth's relief and tone, and the frame lays the sheet. The blocks above the paper (washes, granulation, lines) still run over the object as they run over everything; granulation and dry brush read the frame's tooth there, so on a moving object keep those off it with a group mask too. `PaperMaterial.unpaint(heroId, { removeFiles = true })` puts every original material back and deletes the materials it wrote; `PaperMaterial.list()` names every painted entity. The materials are world assets (in `/zero/source/paperMaterials` by default) and the swap is a synced change, so every player sees the paper on the object. Limits: see-through materials (glass, water) are left as they are. A material whose own shader lays its texture in its own way (a pixel-art atlas, world-space tiling) keeps its colour and texture but the texture is then laid on the mesh's own UVs, so check it after painting. The material reads no style stack: if you retune the stack's paper, paint the object again to match. ## Mixing with watercolorBlocks and inkBlocks The papers are Ground blocks, which run after Fill and Line, so washes and lines are laid first and the paper takes them. With watercolorBlocks or inkBlocks installed beside paperBlocks: ```luau StyleKit.applyLook("watercolor") -- watercolorBlocks' whole look, on its own cold press StyleKit.swap("paper", "paperRice") -- on rice paper: washes run further and rims soften StyleKit.swap("paper", "paperHotPress") -- on hot press: crisp washes, darker narrower rims StyleKit.applyLook("brushAndWash") -- inkBlocks' ink wash painting StyleKit.swap("paper", "paperRice") -- the brush line feathers into the fibres StyleKit.swap("paper", "paperBlackboard") -- the ink is drawn light, the picture in chalk ``` `wcBleed` and `wcEdgeDarken` (watercolorBlocks 1.1.0) and every inkBlocks line and fill (inkBlocks 1.0.4) read the paper field. Granulation, dry brush and every ink line's `paperBreak` read the tooth through the shared ground, so they feel how much tooth each paper really has (almost none on hot press and board). On cold press with its standard thirst every block draws exactly as it did on the paper it was tuned on. ## Relation to the other papers | Paper | Package | What it is | Next to paperBlocks | |---|---|---|---| | `plainPaper` | starterBlocks | Plain warm white paper with a fine grain. | Swaps with any paperBlocks paper in one change. Publishes no paper field, so the blocks that read it draw as on the standard sheet. | | `darkBoard` | starterBlocks | A simple chalk board with a ceiling on chalk coverage. | `paperBlackboard` is the fuller board: slate grain, dust, wiping ghosts, layering, and a paper field that tells ink blocks to draw light. | | `inkPaper` | inkBlocks | A copy of `plainPaper`, shipped so inkBlocks' looks need nothing else. | Swaps in one change; no paper field. | | `wcColdPress` | watercolorBlocks | watercolorBlocks' rough cold-press paper. | Swaps in one change; no paper field. `paperColdPress` is the same kind of sheet in the shared paper model. | None of the older papers publishes the paper field, so the frame under them stays exactly as before. ## Quality The papers follow the stack's quality tier. On `low` the chain runs at half resolution: the paper keeps its tooth at the same size in the picture, and any part too fine to draw at half resolution fades to its average instead of shimmering. `StyleKit.setQuality("low")` forces the low tier on this machine; `StyleKit.setQuality(nil)` follows the device again. A paper costs one pass for the picture and one for its ground; the paper field adds one more pass, made only when a block in the stack reads it. Each extra region on another paper adds its own picture pass, ground pass and (when read) paper field pass. ## Multiplayer The paper is an entry on the scene's synced StyleStack, so every player sees the same paper, settings and regions, and any player's change reaches everyone through the stack's owner. Swap memory is kept on the entry, so it is shared too. The papers keep no state of their own. Only the quality tier is per machine. ## What is in the package | Asset | What it is | |---|---| | `blocks/` | The seventeen papers (`<name>.styleBlock`) and the three shaders they all share: `paper.shader` (the picture on the sheet), `paperField.shader` (the shared ground) and `paperTakes.shader` (the paper field). | | `shaders/paperTooth.shaderModule` | The pure tooth math (felt tooth and grit, fibres, weave, rules, foxing) shared by the full-frame papers and the paper material. | | `shaders/paperCore.shaderModule` | The full-frame paper model built on it: tooth, fibres, weave, blotches, foxing, rules, chalk dust laid on surfaces. | | `shaders/paperSurface.shader` | The paper as a material for an object: the same tooth on the object's own position, lit by the scene's lights. | | `PaperMaterial`, `PaperSurface` | Put an object on paper (`paint`, `unpaint`, `list`) and the component that records its original materials and keeps the tooth's size right on each screen. | | `Gallery.scene`, `PaperGallery`, `PaperGalleryLook` | Every paper side by side under one stack, each around its own stand as a layered region; the look over them is fitted to what your world has installed every time the scene loads. | | `guides/` | How to choose a paper for my art style, how paper changes watercolor and ink, and a worked example level on paper. | | `workflows/paperWorld.workflow` | Put an existing world on paper, check it, and leave it undoable. | | `tests/` | The package's test suite. | ## Known limits - **Installs with several dependencies can be slow (#21420).** paperBlocks brings styleKit, lookbookKit and starterBlocks; the check above took about 3 s, but give a busy engine time to finish before using it. - **The web build was not checked from inside** (#20946: an agent cannot start a web engine). `zero lookbook report` is the one command to run there. - **A second machine was not tried** (#14448: a second engine on the same account joins as the same player). The stack's fields are replicated, the papers keep no state, and the held clock is wall-clock UTC. - **Frame rate on the web and in the web gallery** is lower than on desktop (#20750); start slower machines on the low tier with `StyleKit.setQuality("low")`. - **The full-frame sheet slides across moving characters.** It is laid on world position. Put the character on paper inside its own material instead (`PaperMaterial.paint`, "A paper on an object" above), and keep the full-frame paper off it with a group mask. - **Glass, water and particles have no depth**, so the sheet under them is the sheet of the surface behind. - **Offscreen captures and render-to-texture cameras do not draw the stack** (styleKit's Known limits). - **Older papers do not layer.** `plainPaper`, `darkBoard`, `inkPaper` and `wcColdPress` can only be the first paper of a stack with regions. ## Removing it `StyleKit.swap("paper", "<the paper you had>")` returns the old paper with exactly its settings; `StyleKit.remove("paper")` takes the paper off; `StyleKit.clear()` takes the whole look off. paperBlocks edits no material and nothing outside the stack, so nothing else needs putting back. Uninstalling the package leaves a stack that names its papers drawing without them until they are swapped out. ## Version history **1.1.4 (2026-11-02)**: needs styleKit 1.2.3, and the Lookbook table is new. A reviewer could not reproduce the 1.1.3 table on a fresh install. The cause was styleKit 1.2.2 losing the scene's sun on a paper whenever its shader compiled, so each run drew the tooth with or without sun relief depending on timing (see "Why the earlier table did not reproduce"). styleKit 1.2.3 fixes it, and every paper now measures the same on both runs of a fresh install: all seventeen papers measured twice with exactly the call the README names. No block changed. **1.1.3 (2026-11-01)**: documentation only: the Gallery's README quotes a single paper's cost as a fresh install measures it (0.52 to 0.74 ms high, 0.15 to 0.20 ms low at 1920 x 1080). **1.1.2 (2026-11-01)**: documentation only. The Lookbook numbers are now what a fresh install measures: every paper twice in a brand new world with only paperBlocks installed, right after the engine started, at 1920 x 1080. Where a paper also showed a second repeatable outcome (kraft on a fresh install; several papers in a long session) the table lists it, since which outcome a run lands on depends on what ran before it in the engine. The 1.1.1 table came from a long session and held some of those second outcomes (cold press 3.13 / +0.18 / 1.86 where a fresh install gives 3.64 / -0.05 / 1.57). No block changed. **1.1.1 (2026-11-01)**: the Gallery fits its look to your world every time it loads (in edit, in play, on every peer), so the first open in a paperBlocks-only world already draws styleKit's pencil line over every paper and its title card says so; before, only a rebuild did. Lookbook numbers measured again on styleKit 1.2.2 and lookbookKit 1.0.11: the earlier numbers had been taken in one long batch in which each paper's first second of path was embossed under the sun left over from the run before (styleKit read the sun about once a second), so they did not match a run on its own. The section now states the exact call and view size, and how the numbers move with the view size. **1.1.0 (2026-11-01)**: a paper on an object: the `paperSurface` material lays any paper's tooth, fibres, weave and tone on an object's own position, lit by the scene's own lights, and `PaperMaterial.paint(entityId)` puts an object on the stack's paper (or a named one) and `unpaint` puts it back (see "A paper on an object"); the pure tooth math moved into `paperTooth`, shared by the frame and the material, with no change to how any paper draws; a test for painting and unpainting. **1.0.1 (2026-11-01)**: the README says exactly what an install brings (styleKit, lookbookKit and starterBlocks), as a fresh-world install showed; no block changed. **1.0.0 (2026-11-01)**: first release: seventeen papers sharing one paper model and one set of settings, the Gallery, guides, the paperWorld workflow and the test suite. ## Lookbook numbers **What a fresh install measures.** Every paper alone, measured twice on 2026-11-02 in a brand new private world: paperBlocks installed from ZeroMind (which brought styleKit, lookbookKit 1.0.11 and starterBlocks 1.0.11) and nothing else, the stack empty before and after every run (no entries, hold rate 8, soft radius 10, no pigment set), desktop GPU, the Lookbook's 3D view at exactly **1920 x 1080** (checked before every run), one discarded warm-up run first, no missed frames. Each paper was measured with exactly this call and nothing else on the stack: ```luau local Lookbook = require("~lookbookKit.Lookbook") local r = Lookbook.measure({ stack = { { id = "paper", block = "paperKraft" } } }) print(r.size[1], r.size[2], r.stylized.all.warpedDiff, r.stylized.markStuck, r.stylized.screenStuck, r.stylized.zoomMarks.growth, r.passMs.high.total, r.passMs.low.total) ``` `zero viewport size` reports the 3D view as `sceneWidth` and `sceneHeight`; the window is larger than the view by the editor's panels, and the Lookbook refuses a run whose view changes size. The styleKit these numbers were taken on carries the sun fix styleKit 1.2.3 ships (below), which paperBlocks 1.1.4 needs: the published styleKit was still 1.2.2 that night, so the one-line fix was put into the fresh install's styleKit by hand. **Every paper's two runs agree** (to 0.01 where they differ at all), and the unstyled frame the same call measures was identical in all 34 runs: 2.30 (whole path), 6.57 (pan), 0.00, -0.53, 7.88. The runs are in `design/lookbook/paper_fresh_runs.txt` in the Style Cookbook world. **Why the earlier table did not reproduce.** The Gallery's stack settings were not the cause: the Lookbook replaces the Gallery scene before it measures, the measured stack was empty with the default hold rate and soft radius before and after every run, and those defaults are the Gallery's own values anyway. The cause was a styleKit bug. styleKit 1.2.2 writes the scene's sun to a block only when the sun changes, and whenever a block's shader is compiled (the first time a paper is used in a fresh install) or recompiled, the engine puts the block's values back to their defaults, which for the sun means "no sun". So a run drew the paper with or without the sun raking its tooth depending on timing. With paperBlocks 1.1.3 and styleKit 1.2.2 freshly installed, 11 of the 17 papers gave two different results on their two runs (kraft 2.26 / +0.41 / 1.81, then 1.93 / +0.50 / 2.59; cold press 3.13 / +0.18 / 1.86 on both runs right after a warm-up of 3.64 / -0.05 / 1.57), while the unstyled frame never changed. The sunless result is the one with higher mark growth and a little less swimming; the earlier table's last column ("other repeatable outcome") was that result, and its two kraft rows were one of each. With the fix put in, the same fresh install gave every paper the same numbers twice. A mark growth of about 1.0 was not seen in any of 87 runs on this machine (the lowest is 1.57, cold press): if your runs show it, `zero lookbook report` and your GPU would help find out why. How to read them, against the unstyled frame rather than as pass marks: - **Warped difference** (0..255, lower is steadier; "how much the picture swims"): how much each frame differs from the one before once the camera's motion is taken out. Unstyled: 2.30 (whole path), 6.57 (pan). - **Marks on things** (the shower-door score): negative means the stack's own marks line up with the surfaces when the camera pans, positive that they line up with the screen. Read the warning below. - **Screen-stuck in the pan**: the whole picture's detail against the same spot on the screen (more negative is less stuck). Unstyled: -0.53. - **Mark growth over the 10x zoom**: about 1 means marks keep their size in the picture, about 10 that they grow with the things they sit on (unstyled 7.88). Papers with almost no tooth (vellum, board, hot press, the notebook's rules) mostly follow the scene. - **GPU ms high / low**: the style passes alone at the pan, on the high and the low quality tier. - **Every light off**: the frame's mean brightness at the Lookbook's every-light-off moment, one frame per paper (unstyled 1.22): it must stay at the unstyled frame's black. | Paper | Run | Warped difference, whole path | Warped difference, pan | Marks on things | Screen-stuck in the pan | Mark growth over the 10x zoom | GPU ms high | GPU ms low | Every light off (0..255) | |---|---|---|---|---|---|---|---|---|---| | Cold press (`paperColdPress`) | 1 | 3.63 | 7.30 | -0.05 | -0.54 | 1.57 | 0.64 | 0.17 | 1.15 | | Cold press (`paperColdPress`) | 2 | 3.63 | 7.30 | -0.05 | -0.54 | 1.57 | 0.64 | 0.18 | | | Rough (`paperRough`) | 1 | 4.12 | 7.96 | -0.06 | -0.52 | 1.58 | 0.64 | 0.17 | 1.17 | | Rough (`paperRough`) | 2 | 4.11 | 7.96 | -0.06 | -0.52 | 1.58 | 0.64 | 0.18 | | | Hot press (`paperHotPress`) | 1 | 2.35 | 6.42 | +0.45 | -0.53 | 3.86 | 0.64 | 0.17 | 1.19 | | Hot press (`paperHotPress`) | 2 | 2.35 | 6.42 | +0.45 | -0.53 | 3.86 | 0.64 | 0.18 | | | Rice paper (`paperRice`) | 1 | 2.87 | 6.56 | +0.15 | -0.53 | 2.02 | 0.64 | 0.18 | 1.18 | | Rice paper (`paperRice`) | 2 | 2.87 | 6.56 | +0.15 | -0.53 | 2.02 | 0.64 | 0.17 | | | Newsprint (`paperNewsprint`) | 1 | 2.19 | 5.71 | +0.84 | -0.53 | 3.26 | 0.64 | 0.17 | 1.06 | | Newsprint (`paperNewsprint`) | 2 | 2.19 | 5.71 | +0.84 | -0.53 | 3.26 | 0.64 | 0.17 | | | Kraft (`paperKraft`) | 1 | 2.26 | 4.90 | +0.41 | -0.53 | 1.81 | 0.64 | 0.18 | 1.14 | | Kraft (`paperKraft`) | 2 | 2.26 | 4.90 | +0.41 | -0.53 | 1.81 | 0.64 | 0.18 | | | Parchment (`paperParchment`) | 1 | 2.37 | 6.25 | +0.65 | -0.53 | 2.10 | 0.71 | 0.20 | 1.08 | | Parchment (`paperParchment`) | 2 | 2.36 | 6.25 | +0.65 | -0.53 | 2.10 | 0.71 | 0.20 | | | Canvas (`paperCanvas`) | 1 | 4.10 | 7.79 | +0.05 | -0.44 | 3.94 | 0.70 | 0.19 | 1.08 | | Canvas (`paperCanvas`) | 2 | 4.09 | 7.79 | +0.05 | -0.44 | 3.94 | 0.70 | 0.19 | | | Illustration board (`paperBoard`) | 1 | 2.28 | 6.35 | +0.78 | -0.53 | 6.07 | 0.54 | 0.15 | 1.15 | | Illustration board (`paperBoard`) | 2 | 2.28 | 6.35 | +0.78 | -0.53 | 6.07 | 0.54 | 0.15 | | | Blackboard (`paperBlackboard`) | 1 | 2.88 | 4.51 | +0.37 | -0.60 | 2.43 | 0.67 | 0.18 | 1.17 | | Blackboard (`paperBlackboard`) | 2 | 2.87 | 4.51 | +0.37 | -0.60 | 2.43 | 0.67 | 0.18 | | | Green chalkboard (`paperGreenChalkboard`) | 1 | 2.10 | 2.42 | +0.67 | -0.59 | 2.48 | 0.67 | 0.18 | 1.33 | | Green chalkboard (`paperGreenChalkboard`) | 2 | 2.10 | 2.42 | +0.67 | -0.59 | 2.48 | 0.67 | 0.18 | | | Black paper (`paperBlack`) | 1 | 3.45 | 8.74 | -0.56 | -0.55 | 2.09 | 0.64 | 0.17 | 1.10 | | Black paper (`paperBlack`) | 2 | 3.45 | 8.74 | -0.56 | -0.55 | 2.09 | 0.64 | 0.18 | | | Aged sketchbook (`paperSketchbook`) | 1 | 2.67 | 6.07 | +0.47 | -0.53 | 1.71 | 0.76 | 0.21 | 1.03 | | Aged sketchbook (`paperSketchbook`) | 2 | 2.67 | 6.07 | +0.47 | -0.53 | 1.71 | 0.76 | 0.21 | | | Toned grey (`paperTonedGrey`) | 1 | 2.72 | 6.62 | +0.07 | -0.53 | 1.77 | 0.64 | 0.17 | 1.20 | | Toned grey (`paperTonedGrey`) | 2 | 2.72 | 6.62 | +0.07 | -0.53 | 1.77 | 0.64 | 0.18 | | | Toned tan (`paperTonedTan`) | 1 | 2.86 | 7.08 | -0.10 | -0.53 | 1.77 | 0.64 | 0.17 | 1.17 | | Toned tan (`paperTonedTan`) | 2 | 2.86 | 7.08 | -0.10 | -0.53 | 1.77 | 0.64 | 0.17 | | | Ruled notebook (`paperNotebook`) | 1 | 2.54 | 6.39 | +0.20 | -0.52 | 4.48 | 0.66 | 0.18 | 1.19 | | Ruled notebook (`paperNotebook`) | 2 | 2.54 | 6.39 | +0.20 | -0.52 | 4.48 | 0.66 | 0.18 | | | Vellum (`paperVellum`) | 1 | 2.23 | 6.22 | +0.91 | -0.53 | 7.41 | 0.64 | 0.18 | 1.13 | | Vellum (`paperVellum`) | 2 | 2.23 | 6.22 | +0.91 | -0.53 | 7.41 | 0.64 | 0.18 | | What they say: - **The shower-door score does not show the tooth staying on things at 1080p, for most papers.** At 1920 x 1080 most papers score positive (+0.05 to +0.91); cold press, rough, black paper and toned tan score negative. A paper's tooth is laid on world position, so this points at the Lookbook's mark comparison at this size rather than at the papers, but it is not proved. Check sliding by eye with a slow pan in your own scene. The screen-stuck column, which reads the whole picture, is -0.44 to -0.60 for every paper: nothing glues the picture to the screen. - **Swimming.** Smooth papers add almost nothing to the unstyled path (hot press 2.35, board 2.28, vellum 2.23, newsprint 2.19, kraft 2.26 against 2.30). Deep tooth adds detail that moves with the surfaces: cold press 3.63, rough 4.12, canvas 4.10, black paper 3.45. - **Black stays black.** With every light off every paper stays at the unstyled frame's black (1.03 to 1.33 against 1.22). - **Cost at 1920 x 1080.** A paper alone is 0.54 to 0.76 ms on the high tier and 0.15 to 0.21 ms on the low tier, about four times cheaper; most of it is the paper's ground field (about 0.5 ms high), the picture pass about 0.14 ms. Under blocks that read the paper field (watercolorBlocks' bleed and edge darkening, every inkBlocks block) the paper field adds one more pass of about 0.5 ms high. - **Line and wash on paper** (watercolorBlocks and inkBlocks installed; from an earlier long session on styleKit 1.2.2, so its two runs can differ by the sun bug above): 4.55 to 4.71 ms high and 0.93 to 1.00 ms low; calmer than unstyled on hot press (1.25) and 2.5 to 3.8 on cold press and canvas. - **The Gallery and the Paper Swatches recipe** run seventeen papers at once (70 passes with the line and wash look): 14.7 ms of GPU time on high at 2097 x 1409. They are swatch books, not stacks to ship; a game picks one or two papers. - **Web frame rate:** run `zero lookbook report` in the web build; it has not been measured from here (#20946). Line and wash, and the unstyled baseline, from the earlier long session on styleKit 1.2.2 (`design/lookbook/paper_runs.json`; columns: warped whole path, warped pan, marks, screen-stuck, growth, GPU high, GPU low, every light off): | Stack | Run | Warped difference, whole path | Warped difference, pan | Marks on things | Screen-stuck in the pan | Mark growth over the 10x zoom | GPU ms high | GPU ms low | Every light off (0..255) | |---|---|---|---|---|---|---|---|---|---| | baseline | 1 | 2.30 | 6.57 | 0.00 | -0.53 | 7.88 | - | - | 1.22 | | baseline | 2 | 2.30 | 6.57 | 0.00 | -0.53 | 7.88 | - | - | | | lineAndWash:paperHotPress | 1 | 1.25 | 1.43 | 0.73 | -0.61 | 3.81 | 4.55 | 0.93 | 1.04 | | lineAndWash:paperHotPress | 2 | 1.25 | 1.43 | 0.73 | -0.61 | 3.81 | 4.56 | 0.93 | | | lineAndWash:paperColdPress | 1 | 2.46 | 2.13 | 0.65 | -0.62 | 1.82 | 4.57 | 0.93 | 1.03 | | lineAndWash:paperColdPress | 2 | 3.13 | 3.39 | 0.52 | -0.58 | 1.49 | 4.56 | 0.93 | | | lineAndWash:paperCanvas | 1 | 2.97 | 3.11 | 0.62 | -0.21 | 4.84 | 4.71 | 1.00 | 1.02 | | lineAndWash:paperCanvas | 2 | 3.79 | 4.72 | 0.49 | -0.18 | 3.27 | 4.71 | 1.00 | | | lineAndWash:paperHotPress | bleed.wcBleed | 0.39 | 0.39 | 0.10 | 0.10 | | lineAndWash:paperHotPress | dry.wcDryBrush | 0.27 | 0.27 | 0.07 | 0.07 | | lineAndWash:paperHotPress | edge.wcEdgeDarken | 0.20 | 0.21 | 0.05 | 0.05 | | lineAndWash:paperHotPress | grain.wcGranulation | 0.23 | 0.23 | 0.07 | 0.06 | | lineAndWash:paperHotPress | line.inkPenLine | 1.19 | 1.19 | 0.15 | 0.15 | | lineAndWash:paperHotPress | paper.paperHotPress | 0.14 | 0.14 | 0.03 | 0.03 | | lineAndWash:paperHotPress | paper.paperHotPress.field | 0.50 | 0.50 | 0.13 | 0.13 | | lineAndWash:paperHotPress | paper.paperHotPress.paper | 0.50 | 0.50 | 0.13 | 0.13 | | lineAndWash:paperHotPress | wash.wcWash | 1.12 | 1.12 | 0.20 | 0.20 | | lineAndWash:paperColdPress | bleed.wcBleed | 0.40 | 0.40 | 0.10 | 0.10 | | lineAndWash:paperColdPress | dry.wcDryBrush | 0.27 | 0.27 | 0.07 | 0.07 | | lineAndWash:paperColdPress | edge.wcEdgeDarken | 0.21 | 0.21 | 0.05 | 0.05 | | lineAndWash:paperColdPress | grain.wcGranulation | 0.23 | 0.23 | 0.07 | 0.07 | | lineAndWash:paperColdPress | line.inkPenLine | 1.19 | 1.19 | 0.15 | 0.15 | | lineAndWash:paperColdPress | paper.paperColdPress | 0.14 | 0.14 | 0.03 | 0.03 | | lineAndWash:paperColdPress | paper.paperColdPress.field | 0.50 | 0.50 | 0.13 | 0.13 | | lineAndWash:paperColdPress | paper.paperColdPress.paper | 0.50 | 0.50 | 0.13 | 0.13 | | lineAndWash:paperColdPress | wash.wcWash | 1.12 | 1.12 | 0.20 | 0.20 | | lineAndWash:paperCanvas | bleed.wcBleed | 0.40 | 0.40 | 0.10 | 0.10 | | lineAndWash:paperCanvas | dry.wcDryBrush | 0.28 | 0.28 | 0.08 | 0.07 | | lineAndWash:paperCanvas | edge.wcEdgeDarken | 0.21 | 0.21 | 0.05 | 0.06 | | lineAndWash:paperCanvas | grain.wcGranulation | 0.23 | 0.23 | 0.07 | 0.07 | | lineAndWash:paperCanvas | line.inkPenLine | 1.20 | 1.20 | 0.16 | 0.16 | | lineAndWash:paperCanvas | paper.paperCanvas | 0.14 | 0.14 | 0.03 | 0.04 | | lineAndWash:paperCanvas | paper.paperCanvas.field | 0.57 | 0.57 | 0.15 | 0.15 | | lineAndWash:paperCanvas | paper.paperCanvas.paper | 0.56 | 0.56 | 0.15 | 0.15 | | lineAndWash:paperCanvas | wash.wcWash | 1.13 | 1.13 | 0.20 | 0.20 | Each pass's GPU milliseconds in the long session, both runs, both tiers: | Stack | Pass | High, run 1 | High, run 2 | Low, run 1 | Low, run 2 | |---|---|---|---|---|---| | paperColdPress | paper.paperColdPress | 0.13 | 0.13 | 0.04 | 0.04 | | paperColdPress | paper.paperColdPress.field | 0.50 | 0.50 | 0.13 | 0.13 | | paperRough | paper.paperRough | 0.13 | 0.13 | 0.04 | 0.04 | | paperRough | paper.paperRough.field | 0.50 | 0.50 | 0.13 | 0.13 | | paperHotPress | paper.paperHotPress | 0.13 | 0.13 | 0.04 | 0.04 | | paperHotPress | paper.paperHotPress.field | 0.50 | 0.50 | 0.13 | 0.13 | | paperRice | paper.paperRice | 0.13 | 0.13 | 0.04 | 0.04 | | paperRice | paper.paperRice.field | 0.50 | 0.50 | 0.13 | 0.13 | | paperNewsprint | paper.paperNewsprint | 0.13 | 0.13 | 0.04 | 0.04 | | paperNewsprint | paper.paperNewsprint.field | 0.50 | 0.50 | 0.13 | 0.13 | | paperKraft | paper.paperKraft | 0.13 | 0.14 | 0.04 | 0.04 | | paperKraft | paper.paperKraft.field | 0.50 | 0.50 | 0.13 | 0.13 | | paperParchment | paper.paperParchment | 0.14 | 0.14 | 0.04 | 0.04 | | paperParchment | paper.paperParchment.field | 0.58 | 0.58 | 0.15 | 0.15 | | paperCanvas | paper.paperCanvas | 0.14 | 0.13 | 0.04 | 0.04 | | paperCanvas | paper.paperCanvas.field | 0.56 | 0.56 | 0.15 | 0.15 | | paperBoard | paper.paperBoard | 0.13 | 0.13 | 0.04 | 0.04 | | paperBoard | paper.paperBoard.field | 0.40 | 0.40 | 0.11 | 0.11 | | paperBlackboard | paper.paperBlackboard | 0.14 | 0.14 | 0.04 | 0.04 | | paperBlackboard | paper.paperBlackboard.field | 0.54 | 0.54 | 0.14 | 0.14 | | paperGreenChalkboard | paper.paperGreenChalkboard | 0.14 | 0.14 | 0.04 | 0.04 | | paperGreenChalkboard | paper.paperGreenChalkboard.field | 0.54 | 0.54 | 0.14 | 0.14 | | paperBlack | paper.paperBlack | 0.14 | 0.13 | 0.04 | 0.04 | | paperBlack | paper.paperBlack.field | 0.51 | 0.50 | 0.13 | 0.13 | | paperSketchbook | paper.paperSketchbook | 0.13 | 0.13 | 0.04 | 0.04 | | paperSketchbook | paper.paperSketchbook.field | 0.62 | 0.63 | 0.17 | 0.17 | | paperTonedGrey | paper.paperTonedGrey | 0.14 | 0.14 | 0.04 | 0.04 | | paperTonedGrey | paper.paperTonedGrey.field | 0.51 | 0.50 | 0.14 | 0.13 | | paperTonedTan | paper.paperTonedTan | 0.13 | 0.14 | 0.04 | 0.04 | | paperTonedTan | paper.paperTonedTan.field | 0.50 | 0.50 | 0.13 | 0.13 | | paperNotebook | paper.paperNotebook | 0.13 | 0.13 | 0.04 | 0.04 | | paperNotebook | paper.paperNotebook.field | 0.53 | 0.53 | 0.14 | 0.14 | | paperVellum | paper.paperVellum | 0.13 | 0.13 | 0.04 | 0.04 | | paperVellum | paper.paperVellum.field | 0.50 | 0.49 | 0.13 | 0.13 | | lineAndWash:paperHotPress | bleed.wcBleed | 0.39 | 0.39 | 0.10 | 0.10 | | lineAndWash:paperHotPress | dry.wcDryBrush | 0.27 | 0.27 | 0.07 | 0.07 | | lineAndWash:paperHotPress | edge.wcEdgeDarken | 0.20 | 0.21 | 0.05 | 0.05 | | lineAndWash:paperHotPress | grain.wcGranulation | 0.23 | 0.23 | 0.07 | 0.06 | | lineAndWash:paperHotPress | line.inkPenLine | 1.19 | 1.19 | 0.15 | 0.15 | | lineAndWash:paperHotPress | paper.paperHotPress | 0.14 | 0.14 | 0.03 | 0.03 | | lineAndWash:paperHotPress | paper.paperHotPress.field | 0.50 | 0.50 | 0.13 | 0.13 | | lineAndWash:paperHotPress | paper.paperHotPress.paper | 0.50 | 0.50 | 0.13 | 0.13 | | lineAndWash:paperHotPress | wash.wcWash | 1.12 | 1.12 | 0.20 | 0.20 | | lineAndWash:paperColdPress | bleed.wcBleed | 0.40 | 0.40 | 0.10 | 0.10 | | lineAndWash:paperColdPress | dry.wcDryBrush | 0.27 | 0.27 | 0.07 | 0.07 | | lineAndWash:paperColdPress | edge.wcEdgeDarken | 0.21 | 0.21 | 0.05 | 0.05 | | lineAndWash:paperColdPress | grain.wcGranulation | 0.23 | 0.23 | 0.07 | 0.07 | | lineAndWash:paperColdPress | line.inkPenLine | 1.19 | 1.19 | 0.15 | 0.15 | | lineAndWash:paperColdPress | paper.paperColdPress | 0.14 | 0.14 | 0.03 | 0.03 | | lineAndWash:paperColdPress | paper.paperColdPress.field | 0.50 | 0.50 | 0.13 | 0.13 | | lineAndWash:paperColdPress | paper.paperColdPress.paper | 0.50 | 0.50 | 0.13 | 0.13 | | lineAndWash:paperColdPress | wash.wcWash | 1.12 | 1.12 | 0.20 | 0.20 | | lineAndWash:paperCanvas | bleed.wcBleed | 0.40 | 0.40 | 0.10 | 0.10 | | lineAndWash:paperCanvas | dry.wcDryBrush | 0.28 | 0.28 | 0.08 | 0.07 | | lineAndWash:paperCanvas | edge.wcEdgeDarken | 0.21 | 0.21 | 0.05 | 0.06 | | lineAndWash:paperCanvas | grain.wcGranulation | 0.23 | 0.23 | 0.07 | 0.07 | | lineAndWash:paperCanvas | line.inkPenLine | 1.20 | 1.20 | 0.16 | 0.16 | | lineAndWash:paperCanvas | paper.paperCanvas | 0.14 | 0.14 | 0.03 | 0.04 | | lineAndWash:paperCanvas | paper.paperCanvas.field | 0.57 | 0.57 | 0.15 | 0.15 | | lineAndWash:paperCanvas | paper.paperCanvas.paper | 0.56 | 0.56 | 0.15 | 0.15 | | lineAndWash:paperCanvas | wash.wcWash | 1.13 | 1.13 | 0.20 | 0.20 | The fresh-install runs are in `design/lookbook/paper_fresh_runs.txt` in the Style Cookbook world.