Ink Page Actor

Ink Page (AInkPageActor) is a placeable sheet of paper that shows an Ink Page Document. Drag it into the level from the Place Actors panel, assign a document, and the page is there — sized in real-world centimeters and previewed live in the viewport, without pressing Play. It deliberately contains no input or interaction logic. Call Next Page / Previous Page from whatever your project already uses — a trigger volume, an interaction component, a widget button — and implement the On … events to react. To let the player pick the sheet up and read it in front of the camera, put an Ink Page Reader on your player and call its Begin Reading from your interact verb. (The bundled Ink Page Interactor wires those calls for the demo showroom — it is a reference to read, not a component to ship.)

Placing one

Find it in Place Actors

Open Window → Place Actors and search for Ink Page. Drag the result into the level. You get a blank A4 sheet: no document is assigned yet, so the actor shows the paper it is about to print on.

Assign a document

Select the actor, open the Page Display component in the Details panel, and set Document. The sheet re-fits to that document’s page size and the first page bakes into the viewport immediately.

Place and orient it

Move and rotate the actor as usual. If the writing ends up sideways for the way you have laid the sheet down, set Page Yaw on the actor rather than rotating the mesh by hand.

A sheet that renders as a gray checkerboard, or shows nothing at all, almost always means the page material or the sheet mesh could not be loaded. Inkwell logs what is missing as a Warning on LogInkwell — check the Output Log, then Project Settings → Plugins → Inkwell: see Settings.

What it is made of

The actor is a thin wrapper around three components, all exposed as read-only properties so a Blueprint subclass can reach them:

Component	Type	Role
Page Root (`PageRoot`)	Scene Component	The actor’s root. Move and rotate the actor with this; the sheet below it carries the page size.
Page Mesh (`PageMesh`)	Static Mesh Component	The paper itself. Filled in with the Inkwell page sheet mesh (`/Inkwell/Meshes/SM_PageSheet`, configurable in Settings) only when the slot is empty — a mesh you assign is never overwritten. Movable, with overlap events off.
Page Display (`PageDisplay`)	Ink Page Display	Does the work: bakes the document’s page and applies it to the sheet.

Page Display is explicitly pointed at Page Mesh through its Target Mesh property, so an extra mesh added in a Blueprint subclass can never win the “first mesh on the actor” search and steal the page. For the same reason the display component’s Procedural Paper never spawns a second sheet here: the actor already supplies one. The bundled page sheet is a thin two-sided slab with three material slots — Front, Back and Edge — which is what lets a page with an authored back show its other side with no setup: the display component dresses the Back slot automatically, and an unauthored back shows the front’s writing faintly mirrored through the paper, the way thin stock reads. The Ink Page Reader’s Flip Page is how the player actually turns the sheet over. The actor does not tick.

Sheet sizing

How big the paper is, is not a property of the actor. It comes from the page: the document’s own size — the Page Width Cm you authored, with the height derived from the Page Size Pixels aspect ratio — multiplied by Page Scale on the Page Display component. Because there is only ever that one size, the paper can never be a different shape from the page printed on it, and the writing can never come out stretched. The actor owns only the two properties around that:

Property	Type	Default	What it does
Page Yaw (`PageYaw`)	Float	`0.0`	Spins the sheet about its own normal, in degrees, so the writing reads upright for the way you placed it. Clamped to ±360.
Auto Size Sheet (`bAutoSizeSheet`)	Boolean	`true`	Let the page’s own size (document × Page Scale) and Page Yaw drive the sheet’s relative transform. Turn it off and the actor stops touching the mesh entirely — position, rotate and scale Page Mesh by hand.

Both are editable in the Details panel and readable — but not writable — from Blueprint. The Inkwell page sheet is a 100 cm sheet, so centimeters map straight to relative scale: a 21 × 29.7 cm page is the sheet at 0.21 × 0.297. Sizing is re-applied on construction, on any property edit, and whenever the display component broadcasts On Page Size Changed — which is how a Set Document call bringing in a differently sized document, or a Page Scale drag, re-fits the sheet live. Page Mesh is Movable precisely so all of that also works at runtime.

Collision

Inkwell does not override collision on this actor’s sheet. Page Mesh is created with overlap events disabled and is otherwise left on the standard Static Mesh Component defaults, which resolve to the collision authored on SM_PageSheet: a simple box primitive on the Block All preset. What that means in practice:

An interaction line trace on Visibility hits the sheet. That is what makes a placed Ink Page readable out of the box — in the showroom, and from your own interaction trace.
The sheet is also a solid blocker. A page lying on a desk is a thin box the player can walk into. The Ink Page Reader switches the whole actor’s collision off for the duration of a read for exactly this reason, so a page held at the reader’s face never bumps the player or swallows their traces.

If you want a page that answers traces but never blocks movement, set it yourself:

Select the sheet

Select the actor in the level (or open your Blueprint subclass) and pick the Page Mesh component in the Details / Components panel.

Make it query-only

Under Collision, set Collision Presets to Custom, then Collision Enabled to Query Only (No Physics Collision).

Answer only the trace you use

Set every response to Ignore, then set Visibility — or whatever channel your interaction system traces on — to Block.

That recipe is exactly what the Ink Page Display component applies to the sheet it spawns for actors that have no mesh of their own: query-only, object type WorldDynamic, ignore everything, block Visibility only. If you would rather inherit that behavior than configure it, use a bare actor with an Ink Page Display component instead of this actor.

Blueprint API

Every function forwards to the internal Ink Page Display component and behaves identically:

Node	Returns	What it does
Set Document	—	Swaps in a different Ink Page Document and shows the given page (default 0).
Set Page Index	Boolean	Shows a specific page (0 = first). Out-of-range values are clamped. True only when the page actually changed.
Next Page	Boolean	Turns to the next page. False when already on the last page — unless the display’s Loop Pages is on, which wraps to the first.
Previous Page	Boolean	Turns to the previous page. False when already on the first page — unless Loop Pages wraps to the last.
Refresh	—	Re-bakes and re-applies the current page. Call it after editing the document at runtime.
Get Page Count	Integer	Pages in the assigned document (0 if none).
Get Current Page Index	Integer	The page currently shown (0 = first page).
Get Document	Ink Page Document	The document currently assigned to this sheet.

Events and interaction hooks

Event	Fires when	Parameters
On Page Changed	A different page is shown — a page turn, a document swap, or the first draw at game start.	New Page Index (0-based), Page Count
On Interacted	Your code calls Notify Interacted.	Interactor (Actor)
On Focus Changed	Your code calls Notify Focus Changed.	Focused (Boolean), Interactor (Actor)

All three are Blueprint-implementable events: override them in a Blueprint subclass. The actor binds the display component’s delegate before Begin Play, so On Page Changed also fires for the very first page drawn at game start. Notify Interacted and Notify Focus Changed are the seam for your own interaction system. Your code decides when the player is looking at or using the page; the actor turns that into an event your Blueprint reacts to:

A focus-and-use flow

Your interaction trace hits the Ink Page actor
  -> call Notify Focus Changed (Focused = true, Interactor = the player)
       -> On Focus Changed runs -> show "Press E to read"
Player presses your interact key
  -> call Notify Interacted (Interactor = the player)
       -> On Interacted runs -> Begin Reading on your reader component, or Next Page, or open your UI

Neither notify function does anything on its own — they are relays. Nothing in the plugin calls them for you.

Subclassing it

Use a Blueprint subclass when several notes in your level should behave the same way: share the interaction reactions, the audio and the mesh once.

Create the Blueprint

Right-click in the Content Browser → Blueprint Class, search the All Classes picker for Ink Page, and choose it. (The UMG widget of the same display name is not Blueprintable, so only the actor appears here.)

Adjust the inherited components

Select Page Mesh in the Components panel to swap in your own paper mesh or change its collision, and Page Display to set Page Scale, Loop Pages or Apply On Begin Play. Both are native components: their defaults are editable here and again per placed instance.

Implement the events

In the Event Graph, right-click and add Event On Focus Changed, Event On Interacted and Event On Page Changed. Wire your prompt widget, page-turn sound and “3 / 12” label to them.

Drive them from your interaction system

From your interactable base class or interface, call Notify Focus Changed and Notify Interacted on this actor. The full pattern is in the integration guide.

Place it

Drag the Blueprint into the level and set Document per instance. Everything else is inherited.

Do not add a second mesh component to the subclass and expect the page to land on it. Page Display is pinned to Page Mesh. To draw a page onto a different mesh, point that component’s Target Mesh at it — or, better, use a plain actor with its own Ink Page Display component.

When to use it, and when not to

Use Ink Page

A loose sheet in the world — a note on a desk, a letter on a bed, a poster on a wall — with zero setup. The mesh, the sizing and the yaw are handled for you.

Use Ink Page Display

The page belongs on something you already have: a prop, a clipboard, an existing interactable Blueprint. Add the component to that actor; with one mesh it finds it on its own, and with several you point Target Mesh at the right one. Or leave the actor mesh-less and let Procedural Paper make the sheet.

Use Ink Page Stack

A physical pile of sheets for a journal or book, with real thickness and animated page turns.

Use the Ink Page widget

The page is read on screen in UMG rather than in the world.

Ink Page Display

The component doing the work inside this actor, and everything it can do on your own actors.

Integration guide

Wiring the notify hooks into an interaction system you already have.

Ink Page Reader

Snapping a placed page into the player’s view to read it — and flipping it over.

Get Started

Authoring

Components

Guides

Reference

Placing one

What it is made of

Sheet sizing

Collision

Blueprint API

Events and interaction hooks

Subclassing it

When to use it, and when not to

Use Ink Page

Use Ink Page Display

Use Ink Page Stack

Use the Ink Page widget

Next

Ink Page Display

Integration guide

Ink Page Reader

​Placing one

​What it is made of

​Sheet sizing

​Collision

​Blueprint API

​Events and interaction hooks

​Subclassing it

​When to use it, and when not to

Use Ink Page

Use Ink Page Display

Use Ink Page Stack

Use the Ink Page widget

​Next

Ink Page Display

Integration guide

Ink Page Reader

Placing one

What it is made of

Sheet sizing

Collision

Blueprint API

Events and interaction hooks

Subclassing it

When to use it, and when not to

Next