Working paper in two minutes, then a page of your own, wired into your own interaction system
Four stages: press Play in the bundled showroom and see everything working, author a page
of your own, put it on an actor in your level, and wire reading into the interaction
system your project already has. That last stage is the point — Inkwell’s reading pipeline
is built to be driven by your interact verb, and the bundled demo pieces exist only to
show you the calls.If the plugin is not installed and enabled yet, do Installation first —
this page assumes the Page Editor button is in your Level Editor toolbar.
1
Press Play in the showroom
In the Content Browser, open Settings and turn on Show Plugin Content. Then
browse to Plugins → Inkwell Content → Maps and open L_InkwellShowroom.
Press Play.You are standing in a room of readable paper: six podium exhibits, a gallery wall and
a wall poster. Walk up to any of them:
Input
Does
WASD / mouse
Walk and look
E
Pick up the page you are looking at (and put it back)
Left / Right arrow or mouse wheel
Turn pages — a sheet with a written back turns over first, book order
F
Flip the sheet over to its back
Q
Put the page back where it lay
The sample note on its podium in the showroom.
The map works in an empty project because its GameMode Override is the Inkwell
Reader Game Mode (AInkwellReaderGameMode), which spawns the Inkwell Reader
Character — a first-person pawn whose movement and look input is built at runtime in
C++, so no project input assets are involved at all.
Everything that makes the showroom play by itself — the reader game mode, the reader
character, the Ink Page Interactor component, the exhibit component and the read
prompt widget — is a demo and reference implementation, not recommended for production
use. The production components are Ink Page Display, Ink Page Stack, the Ink Page
actor and widget, and the Ink Page Reader — the component your own interaction
system drives in step 4.
2
Create and author an Ink Page Document
In the Content Browser, right-click in the empty space of a folder in your project and
choose Inkwell → Page Document. Name the asset and press Enter.That asset (UInkPageDocument) is the content: every page, every layer, the paper and
the default text style. A new one is seeded from your project settings so it renders
something immediately — a 1024 × 1400 px page, the bundled plain paper texture, and
the project’s default font at Regular weight. It opens straight into the Page Editor.
Other ways to create and open documents
Inkwell's Page Editor button (1) sits at the right end of the Level Editor toolbar.
From the Level Editor toolbar, open the Page Editor dropdown and choose
Create New Page Document… — you get an asset-save dialog, and the new document
opens in the editor when you confirm. The same dropdown holds Edit Document…
(a browser dialog), Recent / All Documents (documents you edited recently plus a
filter-as-you-type list of every one in the project), and a Documentation entry
that opens this site. Right-clicking a placed actor that references a document
offers Inkwell → Edit Pages (DocumentName)… in the viewport too.
The Inkwell menu, from the Page Editor button in the Level Editor toolbar.
The window opens in three resizable panes:
The Page Editor, with the three panes it opens in.
1
1 — Left panel
Everything about the document: Pages, Page Setup, Paper & Ink,
Custom Mesh, Default Text Style, Drawing Tools, and the
Save Document button at the bottom.
2
2 — Toolbar
Styling for the text you have selected: font family, size, B / I / U /
-S-, text color, and the three justify buttons. On the right, Mode
switches the page surface between Text, Image and Draw.
3
3 — The page
The paper itself, at the shape you authored. In Text mode you click into it and
type; each text box is outlined so you can see where it ends.
4
4 — Right panel
3D Preview (game-true ink) on top — the page put through the same bake path
the game uses — and Layers (front to back) underneath.
Click on the paper and type. A new document opens with one Text layer that fills the
page inside the document margins, so you can start writing immediately. Then style it:
select some text, pick a font family (the five bundled families are listed first),
set a size, toggle B / I / U / -S-, or click the color block to
recolor the selection. Watch the 3D Preview on the right as you go — it is the
truth: if a font falls back or a color reads wrong there, it will read wrong in game.When you want more than one block of text, an image, or something drawn by hand, use
the buttons under the Layers list: + Text, + Image, + Drawing. See
Layers, Drawing and
Paper — none of it is needed for this walkthrough.Finish by clicking Save Document at the bottom of the left panel.
Save from that button rather than from the Content Browser. Rich-text markup stores
fonts as string paths, which the cooker cannot see — Save Document is what
refreshes the document’s Font References list so those fonts get cooked. Skip it
and styled runs fall back to the default font in a packaged build.
3
Put the page on an actor in your level
Two routes. Take the first if you want paper in the world; take the second if the note
belongs on a prop, a desk, a clipboard or a corkboard you already have.
Drop in an Ink Page actor
Add a display to an actor you already have
Open the Place Actors panel (Window → Place Actors), search for
Ink Page, and drag it into your level. It is the ready-made single sheet
(AInkPageActor) and lands as a flat piece of paper.With it selected, find the PageDisplay component in the Details panel’s
component list and set its Document to your new asset. The writing appears on
the sheet immediately — the display component previews in the editor viewport, no
Play needed.The sheet then sizes itself: Page Width Cm from the document (21 cm, the width
of A4, unless you changed it) with the height following the page’s shape. Two knobs
adjust this copy without touching the document:
Property
Where
What it does
Page Scale
the PageDisplay component
1 is the document’s own size, 2 twice as big, 0.5 half. Scales both axes together, so the writing never stretches.
Page Yaw
the actor, under Inkwell | Sheet
Spins the sheet about its own normal so the writing reads upright for your scene.
Select the actor in the level (or open its Blueprint), click Add Component, and
add Ink Page Display. Set its Document to your asset.Procedural Paper is on by default, and it is what makes this a one-property
setup: if the actor has no mesh of its own, the component spawns a paper sheet,
attaches it to the actor’s root, and sizes it from the document. Swap in a document
authored at a different size and the sheet resizes, live in the viewport.It never takes a mesh away from you. If the actor already has a mesh component — or
you pick one in Target Mesh — the page is drawn onto that instead and no sheet
is spawned. Turn Procedural Paper off to leave a mesh-less actor drawing
nothing.
Drawing onto your own mesh needs clean 0–1 UVs across the page face. An
atlas-mapped prop mesh will garble the text, because the baked ink is sampled
across the full 0–1 range. If the prop has several material slots, set
Material Slot to the one the paper face uses.
Nothing appeared on the actor
No mesh, and Procedural Paper turned off: the component has nowhere to
draw. Turn it back on, or set Target Mesh.
The page landed on the wrong material slot — Material Slot is 0 by default.
Preview In Editor is off: the page still appears in Play, but not in the
viewport.
Nothing in the level at all: check the Output Log for LogInkwell — the
component logs a warning naming exactly what is misconfigured.
Press Play and walk over to it. The page is real geometry at the size you authored, so
it reads from a normal standing distance — and lean in and the strokes hold, because
the ink is baked at the document’s own pixel resolution rather than stretched from a
small texture.
4
Wire reading into YOUR interaction system
To let the player pick the page up — float it in front of the camera, turn pages, put
it back exactly where it lay — add an Ink Page Reader
(UInkPageReaderComponent) to your pawn or player controller.The reader is the production presentation engine, and it contains no input handling
whatsoever: it is a pure snap-into-view service that your interaction code calls.
Whatever your project’s interact verb is — an Enhanced Input action, a trace in a base
interactable Blueprint, a trigger volume — the wiring is the same four calls:
Begin reading. In your interact handler, take the actor your existing focus
trace hit and call Begin Reading Actor on the reader — it finds the Ink Page
Display on the actor for you. (Call Begin Reading instead if you already have
the display component.) It returns false when the actor has no readable page or
something is already being read, so you can fall through to your other
interactables.
Turn pages. From your UI or input, call Next Page and Previous Page on
the reader. On a sheet with an authored back, Next Page reads in book order —
front, back, then the next page.
Flip the sheet.Flip Page turns the held page over to show its back.
Out of the box the reader also binds F to this (Bind Flip Key, default on,
key editable) — turn that off once you bind your own flip input.
Put it back.End Reading floats the page back to exactly where it lay.
Bind the reader’s events to keep your HUD honest: On Reading Started /
On Reading Ended (hide the crosshair, show a “put back” prompt), and
On Reading Side Changed for a Front / Back label that swaps exactly on the turn.While a page is held, the reader stops the pawn by default — Lock Movement While
Reading and Lock Look While Reading are both on, and release the moment
End Reading is called. The hold distance is computed from the page’s real size
(Fit Page To View, default on), so a sticky note and a poster are both held where
they fill the screen comfortably.
Two reference implementations show this wiring, both demo-only:
The Ink Page Interactor (UInkPageInteractorComponent) is the complete “look
at a page, press a key, read it” component from the showroom — a view trace every
0.1 s out to 300 cm, an On Focus Changed event for a prompt, and default keys
(E / Q / Left / Right, plus the mouse wheel) behind an
Enable Default Input switch. Read it as a worked example; in production, make
the calls above from your own system instead. See
Ink Page Interactor.
The example input assets in /Inkwell/Examples/Input/ — IA_Interact,
IA_NextPage, IA_PreviousPage, IA_PutBack and the mapping context
IMC_InkwellDefault binding them to E / Right / Left / Q and the mouse wheel — are
there for projects that drive their own pawn with Enhanced Input and want
ready-made actions to start from.
