> ## Documentation Index
> Fetch the complete documentation index at: https://docs.teriyakigaming.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Blueprint API Reference
> Every Blueprint-callable function, property, event and struct on Inkwell's runtime classes, with types and defaults
This is the complete Blueprint surface of the `Inkwell` runtime module — nothing on this
page needs C++, and nothing Blueprint-visible is missing from it. For task-oriented
walkthroughs, use the component pages instead:
[Ink Page Display](/plugins/inkwell/components/page-display), [Ink Page Stack](/plugins/inkwell/components/page-stack),
[Ink Page](/plugins/inkwell/components/page-actor), [Ink Page Reader](/plugins/inkwell/components/reader),
[Ink Page Interactor](/plugins/inkwell/components/interactor),
[Ink Page widget](/plugins/inkwell/components/page-widget).
**How to read this page.** Names are given as they appear in the Blueprint palette, with
the C++ identifier in parentheses. Boolean properties lose their `b` prefix in Blueprint,
so `bLoopPages` is the pin **Loop Pages**. Functions marked *pure* are green nodes with no
execution pins. Where a function takes a world context object, that pin is hidden in
Blueprint and filled in for you. Functions with a **Side** parameter
([Ink Page Side](#ink-page-side)) default it to `Front` — leave it alone unless you are
working with an authored page back.
## Ink Page Document
`UInkPageDocument`, display name **Ink Page Document** — a Data Asset holding authored page
content. Create one with **right-click → Inkwell → Page Document** and author it in the
[Page Editor](/plugins/inkwell/authoring/page-editor).
### Properties
Every document property is `BlueprintReadOnly` except **Page Width Cm**. That is
deliberate: a page change has to invalidate the bake cache, which a directly writable array
could not guarantee, so content changes go through the [functions](#functions) below.
**Page Setup**
| Property | Type | Default | Access | What it does |
| --------------------------------------------------- | --------- | -------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Page Size Pixels** (`PageSizePixels`) | Int Point | 1024 × 1400 | Read | Bake resolution of a page, and the aspect ratio of the layout. |
| **Page Width Cm** (`PageWidthCm`) | Float | 21.0 | Read / Write | How wide a page is in the world, in centimeters. The only physical dimension there is — height follows from the Page Size Pixels aspect ratio. Minimum 0.1. |
| **Margins Px** (`MarginsPx`) | Margin | 90 on all four sides | Read | Text margins, in page pixels. Used by text layers that fill the page. |
| **Line Height Percentage** (`LineHeightPercentage`) | Float | 1.18 | Read | Line spacing for the whole document, as a multiple of the font's own line height. Clamped 0.5–3. Every text layer follows it until given a Line Height Percentage of its own. |
**Paper & Ink**
| Property | Type | Default | Access | What it does |
| ---------------------------------------- | --------------------------------------------- | ------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Paper Mode** (`PaperMode`) | [Ink Paper Mode](#ink-paper-mode) | `Texture` | Read | Where the paper comes from: a texture, a generated sheet, a whole material of your own, or the mesh's own material. |
| **Procedural Paper** (`ProceduralPaper`) | [Ink Procedural Paper](#ink-procedural-paper) | see struct | Read | Settings for generated paper. Used only while Paper Mode is `Procedural`. |
| **Paper Material** (`PaperMaterial`) | Material Interface | None | Read | The page's whole material while Paper Mode is `CustomMaterial` — your own graph with the `MF_InkwellPageInk` material function dropped in to receive the writing. |
| **Paper Texture** (`PaperTexture`) | Texture 2D | None | Read | Paper albedo. Unset falls back to the page material's flat paper color. Used only while Paper Mode is `Texture`. |
| **Paper Tint** (`PaperTint`) | Linear Color | White | Read | Multiplied over the paper. |
| **Back Paper** (`BackPaper`) | [Ink Paper Face](#ink-paper-face) | Same As Front | Read | Where the back of every sheet gets its paper: the front's (the default, and free), its own texture, its own generated sheet, or its own custom material. |
| **Ink Tint** (`InkTint`) | Linear Color | White | Read | Multiplied over the baked ink — tints everything written on the pages. |
| **Ink Strength** (`InkStrength`) | Float | 1.0 | Read | 1 = fully opaque ink, lower lets more paper through every stroke. Clamped 0–1. |
**Default Text Style**
| Property | Type | Default | Access | What it does |
| ----------------------------------------- | ------------ | ------------------------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Default Font** (`DefaultFont`) | Font | None | Read | Font for unstyled text. Unset uses the project's Inkwell default font. Documents created through the Content Browser are seeded from that setting, so in practice this is rarely empty. |
| **Default Typeface** (`DefaultTypeface`) | Name | None | Read | Typeface entry inside the composite font — `Regular`, `Bold`, `Italic`, … |
| **Default Font Size** (`DefaultFontSize`) | Float | 28.0 | Read | Size of unstyled text in page pixels. Clamped 6–400. |
| **Default Color** (`DefaultColor`) | Linear Color | (0.02, 0.017, 0.025, 1.0) | Read | Color of unstyled text. A warm near-black reads as ink better than pure black. |
**Pages**
| Property | Type | Default | Access | What it does |
| ------------------- | ---------------------------------------- | -------------- | ------ | --------------------------------------------------------- |
| **Pages** (`Pages`) | Array of [Ink Page Spec](#ink-page-spec) | one empty page | Read | The document's pages. Mutate through the functions below. |
`FontReferences` (hard references to every font the markup names by string path, maintained
by the Page Editor on save so the cooker can see them), `ContentRevision` and
`LayoutVersion` exist on the asset but are **not** exposed to Blueprint. To invalidate
bakes, call **Bump Revision**. The editor-only Preview Mesh properties never cook.
### Functions
Category **Inkwell → Page Document**.
| Node | Parameters | Returns | What it does |
| --------------------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Get Page Count** *(pure)* | — | Integer | Number of pages in this document. |
| **Get Page Size Cm** *(pure)* | — | Vector 2D | Physical page size in centimeters: Page Width Cm, with the height derived from the Page Size Pixels aspect ratio. |
| **Get Paper For Page** *(pure)* | `Page Index` (Integer), `Side` (Ink Page Side, default Front) | Texture 2D | That side's resolved paper: the page's override if set, otherwise generated paper when the mode is Procedural (baked on first use and reused), otherwise the texture. The back resolves through Back Paper, falling through to the front's. |
| **Get Paper Tint** *(pure)* | `Side` (Ink Page Side, default Front) | Linear Color | The tint over that side's paper: the front's Paper Tint, or the back's own. |
| **Has Back** *(pure)* | `Page Index` (Integer) | Boolean | Whether this sheet has an authored back. False for every document authored before backs existed — an unauthored back never bakes and never allocates a render target. |
| **Has Distinct Back Paper** *(pure)* | `Page Index` (Integer) | Boolean | Whether this page's back *declares* its own paper — a document back mode other than Same As Front, or a per-page back override. |
| **Get Page Layers** *(pure)* | `Page Index` (Integer), `Side` (Ink Page Side, default Front) | Array of [Ink Page Layer](#ink-page-layer) | That side's layers, back to front. Empty for an out-of-range page. |
| **Set Page Layers** | `Page Index` (Integer), `Layers` (Array of Ink Page Layer), `Side` (Ink Page Side, default Front) | Boolean | Replaces one side's whole layer stack. False if the index was out of range. A front stack is normalized to keep a Text layer; a back is stored exactly as given, so an empty array un-authors the back. |
| **Add Page Layer** | `Page Index` (Integer), `Layer` (Ink Page Layer), `Side` (Ink Page Side, default Front) | Integer | Appends a layer to the **front** of that side's stack and returns its index, or -1 if the page index was out of range. |
| **Remove Page Layer** | `Page Index` (Integer), `Layer Index` (Integer), `Side` (Ink Page Side, default Front) | Boolean | Removes one layer. False if either index was out of range. |
| **Move Page Layer** | `Page Index` (Integer), `Layer Index` (Integer), `Delta` (Integer), `Side` (Ink Page Side, default Front) | Integer | Moves a layer through the stack; positive Delta is towards the front. Returns the new index, or -1 when nothing moved (clamped at either end, or Delta 0). |
| **Find Text Layer Index** *(pure)* | `Page Index` (Integer), `Side` (Ink Page Side, default Front) | Integer | Index of that side's first Text layer, or -1 when it has none. |
| **Get Effective Default Font** *(pure)* | — | Font | This document's Default Font, else the project's Inkwell default font, else the engine's Roboto — so text is never invisible. |
| **Bump Revision** | — | — | Invalidates every cached bake of this document. Call after changing pages by any route the functions here do not cover. |
| **Add Page** | `Page` ([Ink Page Spec](#ink-page-spec)) | Integer | Appends a page and returns its index. Guarantees the new page has a Text layer, so a page built from Blueprint can always show its markup. |
| **Remove Page** | `Page Index` (Integer) | Boolean | Removes a page. False if the index was out of range. |
| **Set Page** | `Page Index` (Integer), `Page` (Ink Page Spec) | Boolean | Replaces one page wholesale. False if the index was out of range. |
| **Set Page Markup** | `Page Index` (Integer), `Markup` (String) | Boolean | Replaces the text in the page's **first** front text box. False if the page index was out of range. A page that somehow has no Text layer gets one first, so the markup always has somewhere to draw. |
| **Set Layer Markup** | `Page Index` (Integer), `Layer Index` (Integer), `Markup` (String), `Side` (Ink Page Side, default Front) | Boolean | Replaces the text of one specific Text layer. False if the indices are out of range or the layer is not a Text layer. |
| **Get Page** *(pure)* | `Page Index` (Integer) | [Ink Page Spec](#ink-page-spec) | A **copy** of one page's data, or a default-constructed page when out of range. |
**Get Page** returns a copy. Editing the struct you get back changes nothing in the
document — push it back with **Set Page**. Every mutating node above bumps the content
revision for you; nothing else does. And note the asymmetry that keeps old documents free:
**Add Page** guarantees a front Text layer, but a page's **Back Layers** are never
auto-created — an empty back array means "unauthored", and it costs no bake.
## Ink Page Display
`UInkPageDisplayComponent`, display name **Ink Page Display** — an Actor Component that
draws one page of a document onto a mesh. Blueprintable and spawnable.
### Properties
Category **Inkwell → Page**.
| Property | Type | Default | Access | What it does |
| --------------------------------------------- | ----------------------------------------------- | -------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Document** (`Document`) | Ink Page Document | None | Read / Write | The authored content to show. |
| **Page Index** (`PageIndex`) | Integer | 0 | Read / Write | Which page is shown. Minimum 0. |
| **Page Scale** (`PageScale`) | Float | 1.0 | Read / Write | Resizes this page relative to the size its document was authored at: 1 = as authored, 2 = twice as big. Both dimensions together, so the writing never stretches. Clamped to a minimum of 0.01; the slider runs 0.1–5. |
| **Target Mesh** (`TargetMesh`) | Component Reference | None | Read / Write | Mesh the page is drawn onto. Empty uses the first mesh component on the actor. Needs clean 0–1 UVs across the page face. The picker only populates on an actor placed in a level; inside the Blueprint editor, type the component's variable name into the Component Property Name field instead. |
| **Page Face** (`FaceMapping`) | [Ink Page Face Mapping](#ink-page-face-mapping) | identity | Read / Write | Where on the target mesh's face the page lands. The default is the whole 0–1 UV square, so this only needs opening for a mesh that was not unwrapped for Inkwell. |
| **Material Slot** (`MaterialSlot`) | Integer | 0 | Read / Write | Material slot on the target mesh the page is drawn into. |
| **Apply On Begin Play** (`bApplyOnBeginPlay`) | Boolean | `true` | Read / Write | Draw the page automatically when the game starts. |
| **Loop Pages** (`bLoopPages`) | Boolean | `false` | Read / Write | Wrap from the last page back to the first, and the other way, when turning pages. |
| **Can Be Picked Up** (`bAllowReading`) | Boolean | `true` | Read / Write | Whether the Ink Page Interactor may focus this page and hold it up to read. Off, the page renders identically but the focus trace treats it as scenery — for the poster glued to a wall. Writable at runtime, so a page can be locked until a quest step. |
| **Preview In Editor** (`bPreviewInEditor`) | Boolean | `true` | Read / Write | Update the page live in the level viewport without pressing Play. |
| **Procedural Paper** (`bProceduralPaper`) | Boolean | `true` | Read / Write | Spawn and size a paper sheet when the actor has no mesh of its own. Never takes over a mesh you supplied. |
### Events
| Event | Signature | Fires when |
| ---------------------------------------------- | -------------------------------------------------- | -------------------------------------------------------------------------- |
| **On Page Changed** (`OnPageChanged`) | `New Page Index` (Integer), `Page Count` (Integer) | The displayed page changes — page turn, document swap, refresh. |
| **On Page Size Changed** (`OnPageSizeChanged`) | `New Size Cm` (Vector 2D) | The paper's physical size changes — a document swap, or a Page Scale edit. |
### Functions
Category **Inkwell → Page**.
| Node | Parameters | Returns | What it does |
| --------------------------------------- | ------------------------------------------------------------------------- | ------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| **Set Document** | `New Document` (Ink Page Document), `New Page Index` (Integer, default 0) | — | Swaps in a different document and shows the given page. |
| **Set Page Index** | `New Page Index` (Integer) | Boolean | Shows a specific page. Out-of-range values are clamped. True if the page actually changed. |
| **Next Page** | — | Boolean | Turns to the next page. False when already on the last page, unless Loop Pages is on. |
| **Previous Page** | — | Boolean | Turns to the previous page. False when already on the first page, unless Loop Pages is on. |
| **Refresh** | — | — | Re-bakes and re-applies the current page. Call after editing the document at runtime. |
| **Get Page Count** *(pure)* | — | Integer | Pages in the current document, 0 if none is assigned. |
| **Get Current Page Index** *(pure)* | — | Integer | The page being shown. |
| **Is On First Page** *(pure)* | — | Boolean | True when the first page is shown — handy for graying out a "previous" prompt. |
| **Is On Last Page** *(pure)* | — | Boolean | True when the last page is shown. |
| **Get Effective Page Size Cm** *(pure)* | — | Vector 2D | The size this page is actually drawn at: the document's size times Page Scale. A4 when no document is assigned. |
| **Apply Page Size** | — | — | Re-applies the paper's physical size without re-baking the ink. Far cheaper than Refresh, and what a Page Scale change needs. |
| **Resolve Target Mesh** *(pure)* | — | Mesh Component | The mesh this component draws onto: Target Mesh if set, otherwise the actor's first mesh. |
| **Get Page Material** *(pure)* | — | Material Instance Dynamic | The dynamic instance created for the current page, if it has been drawn yet. |
| **Get Procedural Paper Mesh** *(pure)* | — | Static Mesh Component | The sheet spawned by Procedural Paper, or None when the actor supplies its own mesh. |
## Ink Page Stack
`UInkPageStackComponent`, display name **Ink Page Stack** — extends Ink Page Display, so
**every property, event and function above is available on it unchanged**. It presents the
document as a physical pile of sheets, one mesh per page, and overrides **Refresh**,
**Resolve Target Mesh** and **Apply Page Size** to lay out the pile.
### Additional properties
Category **Inkwell → Stack**.
| Property | Type | Default | Access | What it does |
| ---------------------------------------------- | ------------------------------------------- | ------------ | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Sheet Gap** (`SheetGap`) | Float | 0.35 | Read / Write | Vertical gap between sheets in the pile, in centimeters. Minimum 0.01. |
| **Fan Splay** (`FanSplay`) | Float | 0.35 | Read / Write | How far each deeper sheet splays sideways, in centimeters, alternating left/right. |
| **Fan Angle** (`FanAngle`) | Float | 0.8 | Read / Write | How far each deeper sheet twists, in degrees, alternating direction. |
| **Stack Yaw** (`StackYaw`) | Float | 0.0 | Read / Write | Spins the whole pile about its own normal so the writing reads upright for your actor. Clamped -360–360. |
| **Stack Offset** (`StackOffset`) | Vector | (0, 0, 0) | Read / Write | Where the pile sits relative to the actor's root component. |
| **Flip Interp Speed** (`FlipInterpSpeed`) | Float | 8.0 | Read / Write | How quickly sheets ease to their places in the pile. Under Glide that includes the turned sheet; under Arc it only moves the sheets shuffling up behind it. Minimum 0.1. |
| **Page Turn Style** (`PageTurnStyle`) | [Ink Page Turn Style](#ink-page-turn-style) | `Glide` | Read / Write | What a page turn looks like: sheets easing to their new places (Glide), the turned sheet flying around the edge of the pile (Arc), or no motion at all (Snap). |
| **Page Turn Duration** (`PageTurnDuration`) | Float | 0.45 | Read / Write | Seconds for one page turn, lift-off to landing. Editable only while Page Turn Style is Arc. Minimum 0.01. |
| **Page Turn Lift Cm** (`PageTurnLiftCm`) | Float | 4.0 | Read / Write | How far above the pile the turning sheet rises at the peak of its arc. Editable only while Page Turn Style is Arc. |
| **Max Visible Sheets** (`MaxVisibleSheets`) | Integer | 16 | Read / Write | Upper bound on sheet meshes. Longer documents show a sliding window and re-bake the hidden bottom sheet as you read. Clamped 1–64. |
| **Sheet Mesh** (`SheetMesh`) | Static Mesh | None | Read / Write | Sheet mesh override. Unset uses the project's Inkwell page sheet mesh. Needs clean 0–1 UVs. |
| **Sheets Block Traces** (`bSheetsBlockTraces`) | Boolean | `true` | Read / Write | Give sheets query-only collision so line-trace interaction can focus the pile. Sheets never block the player, physics or the camera. |
| **Sheet Trace Channel** (`SheetTraceChannel`) | Collision Channel | `Visibility` | Read / Write | The one channel sheets respond to; every other channel is ignored. Match it to your interactor's Trace Channel — the two must agree, or the stack never focuses, with no warning anywhere. |
### Additional function
| Node | Parameters | Returns | What it does |
| ----------------------- | ---------- | ------------------------------ | -------------------------------------------------------------- |
| **Get Sheets** *(pure)* | — | Array of Static Mesh Component | The sheet meshes currently in the pile, top of the pile first. |
**Procedural Paper** is grayed out on a stack. A stack always spawns its own sheets, so the
inherited fallback sheet would only duplicate them.
## Ink Page (actor)
`AInkPageActor`, display name **Ink Page** — a placeable sheet of paper. Blueprintable: make
a child Blueprint and implement the events below. Its functions forward to the display
component it owns.
### Properties
| Property | Type | Default | Access | What it does |
| -------------------------------------- | --------------------- | ---------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Page Root** (`PageRoot`) | Scene Component | created in constructor | Read | Scene root. Move and rotate the actor with this. |
| **Page Mesh** (`PageMesh`) | Static Mesh Component | created in constructor | Read | The paper sheet. Uses the Inkwell page sheet mesh unless you assign your own. |
| **Page Display** (`PageDisplay`) | Ink Page Display | created in constructor | Read | Does the actual work. Reach it for anything the forwarding functions do not cover — Page Scale, Page Face, the Loop Pages toggle, On Page Size Changed. |
| **Page Yaw** (`PageYaw`) | Float | 0.0 | Read | Spins the sheet about its own normal so the writing reads upright for your mesh. Clamped -360–360. |
| **Auto Size Sheet** (`bAutoSizeSheet`) | Boolean | `true` | Read | Let the page's own size and Page Yaw drive the sheet. Off positions the mesh entirely by hand. |
### Functions
Category **Inkwell → Page**.
| Node | Parameters | Returns | What it does |
| ----------------------------------- | ------------------------------------------------------------------------- | ----------------- | ------------------------------------------------------------------------------------------------ |
| **Set Document** | `New Document` (Ink Page Document), `New Page Index` (Integer, default 0) | — | Swaps in a different document and shows the given page. |
| **Set Page Index** | `New Page Index` (Integer) | Boolean | Shows a specific page; out-of-range values are clamped. |
| **Next Page** | — | Boolean | Turns forward. False on the last page. |
| **Previous Page** | — | Boolean | Turns back. False on the first page. |
| **Refresh** | — | — | Re-bakes and re-applies the current page. |
| **Get Page Count** *(pure)* | — | Integer | Pages in the assigned document, 0 if none. |
| **Get Current Page Index** *(pure)* | — | Integer | The page currently shown. |
| **Get Document** *(pure)* | — | Ink Page Document | The document assigned to this sheet. |
| **Notify Interacted** | `Interactor` (Actor) | — | Call from your interaction code when the player uses this page. Raises **On Interacted**. |
| **Notify Focus Changed** | `Focused` (Boolean), `Interactor` (Actor) | — | Call from your interaction code when the page gains or loses focus. Raises **On Focus Changed**. |
### Implementable events
Override these in a Blueprint child of Ink Page.
| Event | Signature | Runs when |
| -------------------- | -------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| **On Page Changed** | `New Page Index` (Integer), `Page Count` (Integer) | A different page is shown — play a page-turn sound, update a "3 / 12" label. |
| **On Interacted** | `Interactor` (Actor) | Your code calls **Notify Interacted**. |
| **On Focus Changed** | `Focused` (Boolean), `Interactor` (Actor) | Your code calls **Notify Focus Changed** — show or hide a "Read" prompt, highlight the sheet. |
## Ink Page Reader
`UInkPageReaderComponent`, display name **Ink Page Reader** — put it on a pawn, character or
controller to float a page up in front of the camera. This is the **production**
presentation component your own interaction system drives: it contains no input handling
at all, apart from the optional flip-key convenience binding below.
### Properties
Category **Inkwell → Reading**.
| Property | Type | Default | Access | What it does |
| ------------------------------------------------------------- | --------- | ------------------------ | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Fit Page To View** (`bFitPageToView`) | Boolean | `true` | Read / Write | Work out the hold distance from the page's real size and the camera's field of view, so a playbill and a sticky note are both held where they fill the same comfortable slice of the screen. Off, the flat View Distance below is used instead. |
| **View Fill Fraction** (`ViewFillFraction`) | Float | 0.75 | Read / Write | How much of the screen the page covers while the fit is on, as a fraction of the viewport's height (and width — whichever runs out first wins). Clamped 0.05–1. Editable while Fit Page To View is on. |
| **Min View Distance** (`MinViewDistance`) | Float | 18.0 | Read / Write | Closest the fitted distance may come, in centimeters. Inkwell also enforces its own floor of the near clip plane plus half the page's width, so a page always has room to flip over; the larger floor wins. Editable while the fit is on. |
| **Max View Distance** (`MaxViewDistance`) | Float | 90.0 | Read / Write | Furthest the fitted distance may go, in centimeters — the cap that keeps a big page from being pushed through the furniture behind it. Raise it only for props read from genuinely far away. Editable while the fit is on. |
| **View Distance** (`ViewDistance`) | Float | 45.0 | Read / Write | How far in front of the camera the page floats, in centimeters. Used verbatim when Fit Page To View is off; with the fit on it is only the distance View Offset is measured against. Minimum 1. |
| **View Offset** (`ViewOffset`) | Vector 2D | (0.0, -2.0) | Read / Write | Nudges the reading page sideways (X = right) and vertically (Y = up) on screen, in centimeters. |
| **Reading Rotation Offset** (`ReadingRotationOffset`) | Rotator | Pitch 0, Yaw 90, Roll 90 | Read / Write | Extra rotation composed onto the camera rotation so the printed face points at the viewer with the text upright. Tuned for the Inkwell page sheet; override it when reading from your own mesh. |
| **Blend Time** (`BlendTime`) | Float | 0.3 | Read / Write | Seconds for the page to float up and back. 0 snaps instantly. |
| **Flip Duration** (`FlipDuration`) | Float | 0.35 | Read / Write | Seconds for turning the page over. 0 snaps, same contract as Blend Time. |
| **Bind Flip Key** (`bBindFlipKey`) | Boolean | `true` | Read / Write | Bind Flip Key on the owning pawn so a page can be turned over out of the box. Separate from the interactor's Enable Default Input — flipping is a reader operation with no other default way to reach it. The binding does not consume input. |
| **Flip Key** (`FlipKey`) | Key | F | Read / Write | The key Bind Flip Key binds. Only meaningful while that is on. |
| **Keep Clear Of Obstructions** (`bKeepClearOfObstructions`) | Boolean | `true` | Read / Write | A trace pulls the held page in front of whatever the player is facing, so reading off a podium does not sink the page into it. The page itself and the reader's own pawn are ignored. |
| **Return To Front On Page Turn** (`bReturnToFrontOnPageTurn`) | Boolean | `true` | Read / Write | Turn a flipped page back to its front when the reader moves to another page. |
| **Follow Camera** (`bFollowCamera`) | Boolean | `true` | Read / Write | Keep the page glued to the view so it stays centered as the player looks around. |
| **Lock Movement While Reading** (`bLockMovementWhileReading`) | Boolean | `true` | Read / Write | Ignore move input and disable jumping while a page is held up. Released the moment **End Reading** is called, not when the page finishes floating down. |
| **Lock Look While Reading** (`bLockLookWhileReading`) | Boolean | `true` | Read / Write | Ignore look input while a page is held up. Released with the movement lock. |
### Events
| Event | Signature | Fires when |
| ---------------------------------------------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **On Reading Started** (`OnReadingStarted`) | `Page` (Ink Page Display) | A page starts being read — hide the crosshair, show a "close" prompt, play a paper rustle. |
| **On Reading Ended** (`OnReadingEnded`) | `Page` (Ink Page Display) | The page is put back down. `Page` can be None if the page actor was destroyed mid-read. |
| **On Reading Side Changed** (`OnReadingSideChanged`) | `Page` (Ink Page Display), `Side` (Ink Page Side) | The face turned towards the viewer changes — swap a "Front" / "Back" label. Fires at the halfway point of the flip, the frame the paper goes edge-on. Never fires for a page turn or a put-back; only a flip changes the side. |
### Functions
| Node | Parameters | Returns | What it does |
| ---------------------------------- | --------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Begin Reading** | `Page` (Ink Page Display) | Boolean | Floats the given page up in front of the camera. False if the page is invalid or something is already being read. Starting a read while a previous page is still floating down is fine. |
| **Begin Reading Actor** | `Page Actor` (Actor) | Boolean | Same, but finds the Ink Page Display component on the actor for you. |
| **End Reading** | — | — | Puts the page back down. The descent leaves from wherever the page actually is — the reading target is frozen at release — and lands exactly where the page was lying before reading, face up. |
| **Is Reading** *(pure)* | — | Boolean | True while a page is held up, including while it is still floating up. |
| **Get Current Page** *(pure)* | — | Ink Page Display | The page being read, or None. |
| **Next Page** | — | Boolean | Forward, in **book order**: on a front whose sheet has an authored back, it flips the sheet over; otherwise it turns to the next page (returning a flipped sheet to its front when Return To Front On Page Turn is on). False when not reading, or nothing is left to turn to. |
| **Previous Page** | — | Boolean | The mirror: backward off a back face returns to that sheet's front before it retreats a page. False when not reading, or already at the start. |
| **Flip Page** | — | Boolean | Turns the held page over to show its other side, animated over Flip Duration. A toggle against the side the page is turning *towards*, so tapping it twice reverses the turn cleanly. Never changes which page is shown. False when no page is held. |
| **Set Reading Side** | `Side` (Ink Page Side), `Animate` (Boolean, default true) | Boolean | Turns the held page to a specific side. Animate off snaps immediately — what restoring a saved state wants. False when no page is held. |
| **Set Showing Back** | `Show Back` (Boolean), `Animate` (Boolean, default true) | Boolean | Convenience over Set Reading Side for a plain toggle bool. |
| **Get Reading Side** *(pure)* | — | Ink Page Side | Which face is turned towards the viewer right now. Swaps at the halfway point of a flip, in step with On Reading Side Changed. Front whenever nothing is being read. |
| **Is Showing Back** *(pure)* | — | Boolean | True while the back of the sheet is the face on screen. |
| **Get Reading Side Text** *(pure)* | — | Text | "Front" or "Back", ready to drop into a HUD label. |
| **Is Flipping** *(pure)* | — | Boolean | True while a flip is still in motion. |
| **Can Flip Page** *(pure)* | — | Boolean | True when there is a page held up that Flip Page would turn — use it to gray out a prompt. |
| **Get Reading Distance** *(pure)* | — | Float | How far in front of the camera the page is being held, in centimeters — the value the fit computed, or View Distance when the fit is off. 0 when not reading. |
## Ink Page Interactor
`UInkPageInteractorComponent`, display name **Ink Page Interactor** — the reference
"look at a page, press a key, read it" implementation. It line-traces from the player's
view, raises a focus event for your prompt UI, and drives an Ink Page Reader found or
created on the same actor.
**Demo/reference only — not recommended for production.** This component exists so the
showroom plays out of the box and so you can read a complete working example of driving
the reader. In your own project, skip it and call the
[Ink Page Reader](#ink-page-reader)'s functions from your existing interaction system —
see [Integration](/plugins/inkwell/guides/integration).
### Properties
Category **Inkwell → Interaction**.
| Property | Type | Default | Access | What it does |
| ------------------------------------------------ | ----------------- | ------------ | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Interaction Distance** (`InteractionDistance`) | Float | 300.0 | Read / Write | How far away a page can be and still be picked up by the focus trace, in centimeters. |
| **Trace Channel** (`TraceChannel`) | Collision Channel | `Visibility` | Read / Write | Channel the focus trace runs on. Ink Page Stack sheets answer only their own Sheet Trace Channel, so when changing this, set every stack's channel to match — otherwise stacks become unfocusable. |
| **Focus Check Interval** (`FocusCheckInterval`) | Float | 0.1 | Read / Write | Seconds between focus traces. 0 traces every tick. |
| **Draw Debug Trace** (`bDrawDebugTrace`) | Boolean | `false` | Read / Write | Draw each focus trace: green when it hits a readable page, red otherwise, with a ring at the impact point. No effect in Shipping or Test builds. |
| **Enable Default Input** (`bEnableDefaultInput`) | Boolean | `true` | Read / Write | Bind the demo keys below on the owning pawn. Turn off when wiring your own input. |
| **Interact Key** (`InteractKey`) | Key | E | Read / Write | Toggles reading the focused page. Only bound while Enable Default Input is on. |
| **Put Back Key** (`PutBackKey`) | Key | Q | Read / Write | Puts the page being read back down. Only bound while Enable Default Input is on. |
| **Next Page Key** (`NextPageKey`) | Key | Right | Read / Write | Turns the page being read forward; mouse wheel up always does too. Only bound while Enable Default Input is on. |
| **Previous Page Key** (`PreviousPageKey`) | Key | Left | Read / Write | Turns the page being read back; mouse wheel down always does too. Only bound while Enable Default Input is on. |
### Event
| Event | Signature | Fires when |
| --------------------------------------- | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **On Focus Changed** (`OnFocusChanged`) | `New Focus` (Ink Page Display) | The page under the view changes. `New Focus` is None when focus is lost — including when reading begins. A page whose **Can Be Picked Up** is off never becomes the focus. |
### Functions
| Node | Parameters | Returns | What it does |
| ----------------------------- | ---------- | ---------------- | ---------------------------------------------------------------------------------------------------- |
| **Interact** | — | — | Toggles reading: opens the focused page, or closes the page being read. |
| **Stop Reading** | — | — | Puts the page being read back down. Does nothing when nothing is being read. |
| **Next Page** | — | Boolean | Turns the page being read forward (the reader's book order, backs included). False when not reading. |
| **Previous Page** | — | Boolean | Turns the page being read back. False when not reading. |
| **Get Focused Page** *(pure)* | — | Ink Page Display | The page under the player's view, or None. Always None while reading. |
| **Is Reading** *(pure)* | — | Boolean | True while a page is snapped into view. |
| **Get Reader** *(pure)* | — | Ink Page Reader | The reader component this interactor drives, found or created on the owner at Begin Play. |
## Ink Page (UMG widget)
`UInkPageWidget`, display name **Ink Page**, palette category **Inkwell** — shows a page on
screen instead of on a mesh. It builds the page with the same code the mesh bake uses, and
scales it to fit its slot while keeping the authored aspect ratio.
### Properties
All four are `BlueprintReadOnly`; change them with **Set Document** / **Set Page Index**.
| Property | Type | Default | Access | What it does |
| ------------------------------------ | ----------------- | ------- | ------ | ------------------------------------------------------------------------------------------- |
| **Document** (`Document`) | Ink Page Document | None | Read | The authored content to show. |
| **Page Index** (`PageIndex`) | Integer | 0 | Read | Which page is shown. Minimum 0. |
| **Show Paper** (`bShowPaper`) | Boolean | `true` | Read | Draw the document's paper behind the writing. Off leaves ink over your own background. |
| **Apply Ink Tint** (`bApplyInkTint`) | Boolean | `true` | Read | Apply the document's Ink Tint and Ink Strength to the writing, matching the world material. |
### Functions
| Node | Parameters | Returns | What it does |
| ----------------------------------- | ------------------------------------------------------------------------- | ------- | --------------------------------------------------------------------------- |
| **Set Document** | `New Document` (Ink Page Document), `New Page Index` (Integer, default 0) | — | Swaps in a different document and shows the given page. |
| **Set Page Index** | `New Page Index` (Integer) | Boolean | Shows a specific page; out-of-range values are clamped. True if it changed. |
| **Next Page** | — | Boolean | Turns forward. False on the last page. |
| **Previous Page** | — | Boolean | Turns back. False on the first page. |
| **Refresh** | — | — | Rebuilds the page. Call after editing the document at runtime. |
| **Get Page Count** *(pure)* | — | Integer | Pages in the assigned document, 0 if none. |
| **Get Current Page Index** *(pure)* | — | Integer | The page currently shown. |
The widget does not loop — **Next Page** on the last page returns false and does nothing —
and it shows page **fronts** only. Looping and flipping are display-component and reader
features.
## Ink Page Render Library
`UInkPageRenderLibrary` — a Blueprint function library, so every node here is a free node
with no target pin. Category **Inkwell → Page Content**. `World Context Object` pins are
hidden and filled in for you; `Side` pins default to Front.
| Node | Parameters | Returns | What it does |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Get Page Count** *(pure)* | `Document` (Ink Page Document) | Integer | Pages in a document, 0 for a null document. |
| **Get Page Ink Texture** | `Document` (Ink Page Document), `Page Index` (Integer), `Side` (Ink Page Side) | Texture Render Target 2D | The cached ink texture for one side of one page, baking it on first request. Nothing for an unauthored back. In an editor world (no cache) it bakes uncached into the transient package. |
| **Apply Page To Mesh** | `Mesh Component` (Mesh Component), `Document` (Ink Page Document), `Page Index` (Integer), `Material Slot` (Integer, default 0) | Material Instance Dynamic | Sets a mesh up to display one page: resolves the base material by the document's Paper Mode, instances it, feeds it the baked ink and paper settings, and assigns it to the slot. Fronts only — it never dresses a mesh's `Back` slot; the display components do that themselves through the C++-only `ApplyBackOfSheet`. Under Mesh's Own Material the instanced material is the one the slot already wears — per-instance overrides survive, and only the ink parameters are written. If the page ink material cannot be loaded it falls back to the mesh's existing material, so the failure is visible rather than invisible. |
| **Bake Page To New Target** | `Document` (Ink Page Document), `Page Index` (Integer), `Side` (Ink Page Side) | Texture Render Target 2D | Bakes one side into a fresh, uncached render target you own. Game thread only. The target is outered to the world context object when there is one, so it lives as long as the object that asked for it. |
| **Bake Page To Target** | `Document` (Ink Page Document), `Page Index` (Integer), `Target` (Texture Render Target 2D), `Side` (Ink Page Side) | Boolean | Bakes one side into an existing render target. It should match the document's clamped page size. |
| **Create Page Material** | `Outer` (Object), `Document` (Ink Page Document), `Page Index` (Integer), `Side` (Ink Page Side) | Material Instance Dynamic | The page material instance for one side without touching a mesh — UMG, decals, custom setups. Returns None if the base material cannot be resolved. |
| **Apply Face Mapping Params** | `MID` (Material Instance Dynamic), `Mapping` (Ink Page Face Mapping) | — | Writes a face mapping into a page material instance. Every apply resets the mapping to identity first, so call this afterwards with the mapping you want. On a material without the face parameters the setters are silent no-ops. |
| **Clear Page Cache** | `Document` (Ink Page Document) | — | Drops this world's cached bakes for a document, fronts and backs. |
| **Get Page Ink Brush** | `Document` (Ink Page Document), `Page Index` (Integer), `Brush Size` (Vector 2D) | Slate Brush | A Slate brush of one page's front ink at the given size, for UMG Image widgets. |
## Ink Page Cache Subsystem
`UInkPageCacheSubsystem` — a World Subsystem holding baked ink render targets, keyed on
document path + page index + side + content revision. It exists in **Game and PIE worlds
only**; get it with **Get World Subsystem** and the Ink Page Cache Subsystem class.
| Node | Parameters | Returns | What it does |
| --------------- | -------------------------------------------- | ------- | ------------------------------------------------------------------------------- |
| **Clear Cache** | `Document` (Ink Page Document, default None) | — | Drops every cached bake for one document, or for all documents when left empty. |
## Inkwell Settings accessors
`UInkwellSettings`, category **Inkwell → Settings**. Static pure nodes that load the
configured asset, or return None plus a one-per-session warning naming the setting to fix.
See [Project Settings](/plugins/inkwell/reference/settings).
| Node | Returns |
| ----------------------------- | ------------------ |
| **Get Page Ink Material** | Material Interface |
| **Get Page Preview Material** | Material Interface |
| **Get Page Sheet Mesh** | Static Mesh |
| **Get Default Paper Texture** | Texture 2D |
| **Get Blank Ink Texture** | Texture 2D |
| **Get Default Page Font** | Font |
## Demo classes
The showroom's supporting cast is Blueprint-visible too, but exists only so the demo plays
out of the box — **demo/reference, not production**, like the interactor. None of the
production components know these classes exist, and deleting them breaks no page anywhere.
| Class | Display name | What it is |
| -------------------------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `AInkwellReaderCharacter` | **Inkwell Reader Character** | A complete first-person reader pawn: movement and look built at runtime in C++ (no input assets needed), the interactor and reader as components (`PageInteractor`, `PageReader`, `FirstPersonCamera`, all readable), plus `LookScale` (Float, 1.0) and `PromptWidgetClass` (soft class, defaults to the bundled read prompt). |
| `AInkwellReaderGameMode` | **Inkwell Reader Game Mode** | A game mode whose default pawn is the reader character. Set it as a level's GameMode Override and every Inkwell page in the map is playable. |
| `UInkwellExhibitComponent` | **Inkwell Exhibit** | Per-exhibit prompt lines and reading-distance overrides for the showroom: `FocusPrompt` / `ReadingPrompt` (Text), a checkbox-gated `HoldDistanceCm` (Float, 45 — absolute centimeters, smaller is closer, live while reading) and `ViewFillFraction` (Float, 0.75), plus a static pure **Find For Page** (Ink Page Display → Inkwell Exhibit). A worked example of driving the reader's public properties from game code. |
| `UInkwellReadPromptBase` | — | Abstract C++ base of the demo's read-prompt widget (`WBP_InkwellReadPrompt`), composing the prompt line from what the focused page actually is. |
See [Examples](/plugins/inkwell/guides/examples) for what each does in the showroom.
## Structs
Every struct here is Blueprint-constructible: right-click → **Make** *(struct)*, or split
the pin.
### Ink Page Spec
`FInkPageSpec` — one page. Used by **Add Page**, **Set Page** and **Get Page**.
| Field | Type | Default | What it does |
| --------------------------------------------- | ------------------------------------------ | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Layers** (`Layers`) | Array of [Ink Page Layer](#ink-page-layer) | Empty | Everything drawn on the front of this page, back to front: index 0 is the back, the last entry the front. |
| **Back Layers** (`BackLayers`) | Array of [Ink Page Layer](#ink-page-layer) | Empty | Everything drawn on the **back** of this sheet, same rules. **Empty means the back was never authored**: the sheet renders bare paper there and costs no bake and no render target. |
| **Paper Override** (`PaperOverride`) | Texture 2D | None | Overrides the document's paper for this page only. None uses the document's. |
| **Back Paper Override** (`BackPaperOverride`) | Texture 2D | None | Paper for this page's back only — the back-side twin of Paper Override. None uses the document's Back Paper, which itself defaults to the front's. |
A page you build yourself with an empty Layers array is normalized when you hand it to
**Add Page** or **Set Page**: Inkwell guarantees the front has a Text layer, so a page
built from Blueprint can always show markup. Back Layers are deliberately left alone.
### Ink Page Layer
`FInkPageLayer` — one entry in a page's stack. Exactly one payload is used, chosen by
**Type**; the other two are ignored.
| Field | Type | Default | What it does |
| ------------------------ | --------------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------- |
| **Type** (`Type`) | [Ink Layer Type](#ink-layer-type) | `Image` | What this layer draws. |
| **Name** (`Name`) | String | Empty | Shown in the Page Editor's layer list. Blank falls back to a name derived from the type. |
| **Visible** (`bVisible`) | Boolean | `true` | Hidden layers are skipped by the bake and by the editor preview alike. |
| **Locked** (`bLocked`) | Boolean | `false` | Locked layers cannot be selected or dragged in the Page Editor. Purely an authoring aid — it has no runtime effect. |
| **Opacity** (`Opacity`) | Float | 1.0 | Multiplies the whole layer's alpha. Clamped 0–1. |
| **Text** (`Text`) | [Ink Page Text](#ink-page-text) | default | Payload when Type is `Text`. |
| **Image** (`Image`) | [Ink Page Image](#ink-page-image) | default | Payload when Type is `Image`. |
| **Drawing** (`Drawing`) | [Ink Drawing](#ink-drawing) | default | Payload when Type is `Drawing`. |
### Ink Page Text
`FInkPageText` — the payload of a Text layer: an independent text box, so one page can hold
a heading, a body and a signature on three layers with images stacked between them.
| Field | Type | Default | What it does |
| --------------------------------------------------- | ------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Markup** (`Markup`) | String | Empty | Rich-text markup in the UE rich-text format; styled runs carry font, typeface, size and color attributes. Author it in the Page Editor, not by hand. |
| **Justification** (`Justification`) | Text Justify | `Left` | Left, Center or Right, per text box. |
| **Position** (`Position`) | Vector 2D | (0, 0) | Top-left of the text box, normalized. Ignored while the box fills the page. |
| **Size** (`Size`) | Vector 2D | (0, 0) | Normalized size of the box. **Zero or negative on either axis means the layer fills the page inside the document's margins** instead of using its own box. |
| **Line Height Percentage** (`LineHeightPercentage`) | Float | 0.0 | Line spacing for this box, as a multiple of the font's own line height. Clamped 0–3. **Zero means inherit the document's Line Height Percentage** — where every text layer starts — so one heading or signature can break ranks without dragging the page with it. |
### Ink Page Image
`FInkPageImage` — the payload of an Image layer. Positions and sizes are normalized 0–1
page coordinates.
| Field | Type | Default | What it does |
| ---------------------------------------- | ---------- | ---------- | ------------------------------------------------------------------------------- |
| **Texture** (`Texture`) | Texture 2D | None | The image. A layer with no texture draws nothing. |
| **Position** (`Position`) | Vector 2D | (0.1, 0.1) | Top-left corner of the image box, normalized. |
| **Size** (`Size`) | Vector 2D | (0.3, 0.0) | Normalized width and height. **Height ≤ 0 keeps the texture's aspect ratio.** |
| **Rotation Degrees** (`RotationDegrees`) | Float | 0.0 | Rotation about the image's center. |
| **Opacity** (`Opacity`) | Float | 1.0 | Multiplies the image's alpha. Clamped 0–1. Stacks with the layer's own Opacity. |
### Ink Drawing
`FInkDrawing` — the payload of a Drawing layer.
| Field | Type | Default | What it does |
| ----------------------- | ---------------------------------- | ------- | -------------------------------------- |
| **Strokes** (`Strokes`) | Array of [Ink Stroke](#ink-stroke) | Empty | Ordered list of strokes, oldest first. |
### Ink Stroke
`FInkStroke` — a single continuous mark: one press, drag and release.
| Field | Type | Default | What it does |
| ------------------------ | ---------------------------------------------- | ------------------------- | -------------------------------------------------------------------------------- |
| **Brush** (`Brush`) | [Ink Brush Type](#ink-brush-type) | `Pen` | Which of the five procedural brushes draws this stroke. |
| **Color** (`Color`) | Linear Color | (0.02, 0.017, 0.025, 1.0) | Ink color. |
| **Width Px** (`WidthPx`) | Float | 6.0 | Stroke width in page pixels, before pressure. Minimum 0.1; the slider runs 1–80. |
| **Opacity** (`Opacity`) | Float | 1.0 | Stroke opacity. Clamped 0–1. |
| **Points** (`Points`) | Array of [Ink Stroke Point](#ink-stroke-point) | Empty | The samples along the stroke, in order. |
### Ink Stroke Point
`FInkStrokePoint` — one sample along a stroke.
| Field | Type | Default | What it does |
| ------------------------- | ---------------------------------------- | ------- | ------------------------------------------------------------- |
| **Position** (`Position`) | Vector 2f *(single-precision Vector 2D)* | (0, 0) | Normalized page space: (0,0) is top-left, (1,1) bottom-right. |
| **Pressure** (`Pressure`) | Float | 1.0 | 0–1. Scales width and opacity for brushes that respond to it. |
### Ink Procedural Paper
`FInkProceduralPaper` — settings for paper Inkwell generates itself. The sheet is drawn
procedurally — no image assets needed — unless **Texture Base** is on, in which case the
ruling prints onto real stock. All the `Px` values are in page pixels.
| Field | Type | Default | What it does |
| ------------------------------------------------ | ------------------------------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Ruling** (`Ruling`) | [Ink Paper Ruling](#ink-paper-ruling) | `Lined` | The ruling drawn across the sheet. |
| **Paper Color** (`PaperColor`) | Linear Color | (0.96, 0.945, 0.90, 1.0) | The paper stock itself. |
| **Line Color** (`LineColor`) | Linear Color | (0.55, 0.68, 0.82, 1.0) | The lines, grid or dots. |
| **Line Spacing Px** (`LineSpacingPx`) | Float | 64.0 | Distance between ruled lines. Minimum 4; the slider runs 16–300. |
| **Line Thickness Px** (`LineThicknessPx`) | Float | 2.0 | Minimum 0.5; the slider runs 1–12. |
| **Top Margin Px** (`TopMarginPx`) | Float | 90.0 | Blank margin above the first line and below the last. |
| **Margin Rule** (`bMarginRule`) | Boolean | `false` | Draw a vertical margin rule down the left of the page — a notebook's red line. |
| **Margin Rule Color** (`MarginRuleColor`) | Linear Color | (0.85, 0.42, 0.42, 1.0) | Color of that rule. Editable while Margin Rule is on. |
| **Margin Rule Offset Px** (`MarginRuleOffsetPx`) | Float | 90.0 | How far in from the left edge the rule sits. |
| **Punch Holes** (`bPunchHoles`) | Boolean | `false` | Punched binder holes down the left edge. |
| **Hole Count** (`HoleCount`) | Integer | 3 | How many holes run down the page. Clamped 1–16. |
| **Hole Diameter Px** (`HoleDiameterPx`) | Float | 34.0 | Minimum 2; the slider runs 8–140. |
| **Hole Inset Px** (`HoleInsetPx`) | Float | 42.0 | Distance from the left edge to the center of the holes. |
| **Hole Edge Margin Px** (`HoleEdgeMarginPx`) | Float | 220.0 | Blank space above the first hole and below the last. |
| **Hole Color** (`HoleColor`) | Linear Color | (0.05, 0.05, 0.06, 1.0) | What a hole shows. The paper is an opaque albedo, so holes are drawn rather than cut — a dark color reads as a hole against most backgrounds. |
| **Grain Strength** (`GrainStrength`) | Float | 0.04 | Subtle per-pixel fiber noise. 0 is perfectly flat stock. Clamped 0–1. |
| **Grain Seed** (`GrainSeed`) | Integer | 0 | Seed for the grain, so two sheets with identical settings can still differ. |
| **Texture Base** (`bTextureBase`) | Boolean | `false` | Print the sheet on real stock instead of a flat color: ruling, margin rule, holes and grain go down on the base texture exactly as they would on flat stock, with Paper Color multiplying over it as a tint. |
| **Base Texture** (`BaseTexture`) | Texture 2D | None | The stock to print on. None uses the project's Default Paper Texture. |
### Ink Paper Face
`FInkPaperFace` — the back's own paper, when it differs from the front's. Lives on the
document as **Back Paper**.
| Field | Type | Default | What it does |
| ----------------------------- | --------------------------------------------- | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Mode** (`Mode`) | [Ink Back Paper Mode](#ink-back-paper-mode) | `SameAsFront` | Where the back of every sheet gets its paper. |
| **Texture** (`Texture`) | Texture 2D | None | Paper albedo for the back. Used only while Mode is Texture. |
| **Procedural** (`Procedural`) | [Ink Procedural Paper](#ink-procedural-paper) | default | Settings for the back's generated sheet. Used only while Mode is Procedural. |
| **Tint** (`Tint`) | Linear Color | White | Multiplied over the back's paper, the way Paper Tint is over the front's. Used whenever Mode is not Same As Front. |
| **Material** (`Material`) | Material Interface | None | The back slot's whole material, while Mode is Custom Material. Must carry `MF_InkwellPageInk` to receive the writing. Slab-only: a flat single-slot mesh has one material for both faces and ignores this. |
### Ink Page Face Mapping
`FInkPageFaceMapping` — where on a mesh's face the page lands. Lives on the display
component as **Page Face**. Every field defaults to "the whole 0–1 UV square", which is
what the bundled sheet — and any mesh unwrapped for Inkwell — needs.
| Field | Type | Default | What it does |
| --------------------------------------------------- | --------------------------------------- | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| **Fit** (`Fit`) | [Ink Page Face Fit](#ink-page-face-fit) | `FullUVRange` | How the page's rectangle is found within the face's UVs. |
| **Region Min** (`RegionMin`) | Vector 2D | (0, 0) | The UV rectangle the page occupies. Auto Fit writes these from the mesh; Custom Region reads what you set. Ignored while Fit is Full UV Range. |
| **Region Max** (`RegionMax`) | Vector 2D | (1, 1) | Same. |
| **Rotation Quarter Turns** (`RotationQuarterTurns`) | Byte | 0 | Turns the page a quarter at a time, for the face whose unwrap runs sideways or upside down. Clamped 0–3. |
| **Ink On Back Face** (`bInkOnBackFace`) | Boolean | `true` | Whether back faces show the writing (mirrored show-through, like thin paper). Off, back faces show bare paper. |
## Enums
### Ink Layer Type
`EInkLayerType` — what a layer draws.
| Value | Meaning |
| --------- | -------------------- |
| `Text` | A body of rich text. |
| `Image` | A placed image. |
| `Drawing` | Freehand strokes. |
### Ink Brush Type
`EInkBrushType` — the look of a stroke. Each brush is drawn procedurally; Inkwell ships no
brush images.
| Value | Meaning |
| ------------- | ----------------------------------------------------------------------- |
| `Pen` | Even, opaque line with rounded joins. |
| `Pencil` | Thin, semi-transparent, lightly grained — darker where strokes overlap. |
| `Marker` | Thick, flat and fully opaque. |
| `Crayon` | Broad, heavily grained, slightly ragged at the edges. |
| `Highlighter` | Wide, very transparent, drawn under the ink it passes over. |
### Ink Paper Mode
`EInkPaperMode` — how a page's paper is produced. See
[Rendering → the page material](/plugins/inkwell/reference/rendering#the-page-material) for what each mode
does to the mesh.
| Value | Meaning |
| ----------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Texture` | Use the Paper Texture asset. Unset draws on the page material's flat paper color. |
| `Procedural` | Generate the paper from the Procedural Paper settings. |
| `CustomMaterial` | The document's Paper Material **is** the page's material: your own graph with `MF_InkwellPageInk` dropped in to receive the ink. Replaces whatever the target slot wore. |
| `MeshMaterial` *(display name "Mesh's Own Material")* | No paper from Inkwell: the ink is laid onto whatever material the mesh already wears, via a dynamic instance per mesh instance — per-instance overrides survive, and nothing is replaced. The material must contain `MF_InkwellPageInk` or ink silently does not appear; that silence is the contract, not a failure. |
### Ink Back Paper Mode
`EInkBackPaperMode` — where the back of every sheet gets its paper.
| Value | Meaning |
| ---------------- | --------------------------------------------------------------------------------- |
| `SameAsFront` | The front's paper, whatever that resolves to page by page. The default, and free. |
| `Texture` | Its own texture. |
| `Procedural` | Its own generated sheet — a lined front can carry a plain back. |
| `CustomMaterial` | Its own material entirely, carrying `MF_InkwellPageInk`. |
### Ink Page Side
`EInkPageSide` — which face of a sheet is meant.
| Value | Meaning |
| ------- | ------------------------------------------------------------------ |
| `Front` | Every page Inkwell has ever drawn. |
| `Back` | The other side of the same physical sheet, authored independently. |
### Ink Page Turn Style
`EInkPageTurnStyle` — how an Ink Page Stack rearranges itself when the page changes.
| Value | Meaning |
| ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Snap` | Every sheet is in its new place the instant the page changes. No motion at all. |
| `Glide` | Sheets ease straight to their new places at Flip Interp Speed, the turned one included — the pile settles the way a hand squaring it up would leave it. The default. |
| `Arc` | The turned sheet lifts clear of the pile, swings out past its edge and arcs down to the bottom, so nothing ever passes through anything. Driven by Page Turn Duration and Page Turn Lift. |
### Ink Page Face Fit
`EInkPageFaceFit` — how a Page Face mapping finds the page's place in UV space.
| Value | Meaning |
| -------------- | ------------------------------------------------------------------------------------------- |
| `FullUVRange` | The page spans the face's whole 0–1 UV square — the flat-sheet assumption, and the default. |
| `AutoFit` | The page spans the UV rectangle the mesh's face actually occupies, measured from the mesh. |
| `CustomRegion` | The page spans the rectangle you type into Region Min / Region Max. |
### Ink Paper Ruling
`EInkPaperRuling` — the ruling drawn across generated paper.
| Value | Meaning |
| -------- | -------------------------------- |
| `Plain` | No ruling at all. |
| `Lined` | Horizontal writing lines. |
| `Grid` | Horizontal and vertical lines. |
| `Dotted` | A dot at each grid intersection. |
## Next
These nodes put to work: building and rewriting documents while the game runs.
Wiring the reader into an interaction system you already have.
What the render library actually does with a page.
What the layer structs mean on the page.