Ink Page Reader

Ink Page Reader (UInkPageReaderComponent) is the component that lets a player pick up and read a page. Add it to your player — pawn, character or player controller — and call Begin Reading: the page floats up in front of the camera, held at a distance where it fills a comfortable slice of the screen. Call End Reading and it floats back to exactly where it was lying. Flip Page turns the sheet over to show its back. The reader is the presentation engine: it contains no interaction logic and almost no input handling. It is driven by whatever runs interaction in your project — your own interaction component, a Blueprint trigger, or the bundled Ink Page Interactor. Every function is Blueprint-callable. The reader moves the actor that owns the page — the owner of the Ink Page Display component you hand to Begin Reading — so anything attached to that actor rides along. The level still owns the actor; the reader holds only weak references to it.

​

Adding it

Add Ink Page Reader from the Add Component menu (category Inkwell) to your player pawn, character or player controller. It is Blueprint-spawnable and Blueprintable, so you can subclass it if you want your own defaults. Where you put it decides which controller the input locks reach: on a pawn, the reader resolves the pawn’s possessing controller; on a controller, that controller is used directly. Either works. (The flip-key binding is the exception: it binds on the owning pawn’s input component, so a reader living on a controller never binds it.) If you use the Ink Page Interactor for prototyping, you do not need to add a reader yourself — the interactor reuses one on its owner if there is one, and creates one if there is not.

​

Wiring it to your interaction system

​

Properties

All properties live under Inkwell → Reading, are editable per instance, and are readable and writable from Blueprint at runtime.

​

How a read plays out

The reader moves through four phases:

1. Idle — nothing held. The component does not tick at all.
2. Blend in — the page floats from where it lay to the reading pose over Blend Time seconds, on a smoothstep curve so the pick-up eases in and out.
3. Reading — held at the eyes. With Follow Camera on, the pose is recomputed every frame; with it off, the component stops ticking here (unless a flip is still turning), because nothing is left to move.
4. Blend out — the same smoothstep in reverse, back onto the exact transform the actor had when the read began. Collision and physics are restored when it lands.

Is Reading is true through blend-in and reading — including while the page is still on its way up — and false during blend-out. Get Current Page returns the page being read, or None. The put-back descends from wherever the page actually was: the reading target is frozen at the moment End Reading is called, before On Reading Ended fires. So a listener that restores reader properties on that event — a per-prop tuning component putting View Fill Fraction back, for example — cannot yank the descending page to a different distance. Overrides applied while reading release cleanly. A page put back while turned over unwinds its flip on the way down, landing front-up on the exact pose it was picked up from.

​

Where the page goes

The pose is derived from the player’s view point:

• A possessed pawn reads through its controller’s view point, so camera managers, view targets and control rotation are all respected.
• Anything else — an unpossessed pawn, a non-pawn owner — falls back to the actor’s eyes view point.

From there the page is placed straight ahead at the hold distance, nudged by View Offset along the camera’s right and up axes, and rotated by the camera rotation composed with Reading Rotation Offset. Scale is never part of the pose: the page keeps the physical size its document, Page Scale and actor scale give it. With Follow Camera off, the target is captured once, at the moment the blend starts.

​

How the hold distance is chosen

With Fit Page To View on (the default), the reader computes the distance at which the page covers View Fill Fraction of the screen — against the viewport’s real field of view and aspect ratio, height and width both, whichever runs out first. The page size used is the document’s printed size times Page Scale times the actor’s scale, not the mesh bounds — on the showroom’s poster board it is the 60×90 cm page being framed, not the plywood around it. The result is clamped between a floor and Max View Distance:

• The floor is the larger of Min View Distance and the near clip plane plus half the page’s width. The second term is what guarantees a flip can swing the sheet’s edge toward the camera without any part of it crossing the near plane — applied whether or not a flip is running, so starting one never makes the page lurch backwards.
• Max View Distance yields to the floor rather than fighting it.

With the fit off, View Distance is used verbatim — to the centimeter, so a project that tuned it keeps its framing. On that manual path a flip that needs more room than the tuned distance allows eases the page away from the eye for the duration of the turn and brings it straight back. Get Reading Distance returns the distance in use — the fitted value, or View Distance when the fit is off, before the obstruction clamp — and 0 when nothing is being read.

​

Staying out of the furniture

The hold distance is measured along the view with no knowledge of the world, so with Keep Clear Of Obstructions on (the default) the reader traces the view ray on the Visibility channel — ignoring the page actor and the reader’s own pawn — and pulls the page in front of the first blocking hit, with a margin for the edge that swings out mid-flip. Pressed right up against a wall, the distance is floored at the near-plane term so the page stays visible rather than comfortable.

​

Book order

On a multipage document whose sheets have authored backs (see two-sided pages), Next Page and Previous Page read the document the way a book is read:

• Next Page on a front face whose sheet has an authored back turns the sheet over instead of skipping what is written on the other side. On a front with no back, it turns to the next page as usual.
• Previous Page on a back face returns to the front of the same sheet before it retreats a page.
• With Return To Front On Page Turn on (the default), an actual page turn also turns the new sheet front-up.

This is also what makes a two-sided single-page note readable with the same two inputs as everything else: forward is the flip, and there is no third thing to press. A sheet with no authored back never flips on a page turn — an unauthored back costs nothing and shows nothing.

​

Turning the sheet over

Flip Page turns the held page over, animated over Flip Duration seconds. It is a toggle against the side the page is currently turning towards, not the side on screen — so tapping it twice in quick succession reverses the turn and settles back where it started rather than finishing the rotation anyway. It never changes which page is shown: “Page 2 of 3” does not move, and On Page Changed does not fire. The turn is about whichever of the page’s own axes Reading Rotation Offset puts vertically on screen, so a custom prop with its own offset still turns the way a sheet of paper turns. It rotates about the page actor’s origin: a mesh whose page face is off-center will swing rather than spin. With Bind Flip Key on, the reader binds Flip Key (default F) on the owning pawn once the pawn has an input component, retrying on a timer until it does. The binding does not consume input, so it sits alongside your Enhanced Input mappings rather than swallowing the key, and it quietly does nothing while no page is held. Turn Bind Flip Key off when you route your own input to Flip Page.

​

Customizing the reading pose

The pose properties are all live: change them from Blueprint mid-read and the next frame uses the new values (with Follow Camera on). That makes tuning quick — set them on the component’s Details panel, press Play, read a page, and adjust. The showroom’s demo-only Inkwell Exhibit component is a worked example of exactly this: it writes the reader’s public properties when a read starts and restores them when it ends. Making the page bigger or smaller on screen. With Fit Page To View on, raise View Fill Fraction to fill more of the screen. With it off, apparent size is a function of distance: lower View Distance. If a page needs to be physically larger everywhere — in the world as well as in the hand — change Page Scale on the display component instead. Framing. View Offset is in centimeters at the page, not in screen percent. The default (0, -2) drops the sheet slightly below eye line, which reads as “held in the hands” rather than “pinned to the face”. Positive X shifts it right — useful if your HUD occupies one side. With the fit on, the nudge is scaled with the fitted distance so its apparent size stays constant; with the fit off it is untouched, to the centimeter. Orientation. ReadingRotationOffset is composed onto the camera rotation, so it describes the sheet’s orientation relative to the view, not to the world. The default — Pitch 0, Yaw 90, Roll 90 — is tuned for the Inkwell page sheet, a flat plane whose printed face points up: it turns the sheet to face the camera and then spins it in its own plane so the writing reads upright. If you read from your own mesh, tune it like this:

​

The locks

The reader has two independent input locks, both on by default. They engage the moment Begin Reading succeeds and release the moment End Reading is called — not when the page finishes floating down — so control comes back instantly when the player lets go.

​

Lock Movement While Reading

• Move input on the controller is ignored (SetIgnoreMoveInput).
• The pawn’s current motion is stopped immediately — unless it is falling. An airborne pawn is left alone, because zeroing velocity mid-jump would freeze it in the air.
• Jumping is covered too. Ignoring move input does not stop a character from jumping, so for an ACharacter the reader also calls Stop Jumping and clears the character movement component’s own jump permission (NavAgentProps.bCanJump), restoring the saved value on unlock. This is the part most hand-rolled “freeze the player” code misses.

​

Lock Look While Reading

• Look input on the controller is ignored (SetIgnoreLookInput), so the view cannot rotate while the page is being inspected. Combined with Follow Camera, the page stays perfectly still in front of the reader.

​

How the locks behave around the engine

The engine’s ignore-input counters stack, so the reader is careful with them:

• Each lock is taken at most once per read, and the reader remembers exactly which controller it locked, so exactly that one is released.
• If possession arrives or resets mid-read — a client restart zeroes a controller’s ignore counters — the reader re-asserts both locks from its tick while a page is up. Best effort: with Follow Camera off the tick sleeps during the reading phase, so re-assertion cannot run there.
• On release, a pawn-mounted reader whose controller has meanwhile possessed a different pawn does not decrement the counters: the engine already reset them on repossession, and decrementing would steal another system’s lock. A reader living on a controller always releases.
• The character’s jump permission is restored only if it is still disabled, so an outside system that deliberately re-enabled jumping mid-read keeps its change.

​

Physics and collision capture

When a read begins the reader captures everything needed to put the page back exactly as it was:

• The page actor’s full transform is saved. That is the blend-back destination.
• Every primitive on the actor that is simulating physics — a loose sheet the player can knock off a desk — has simulation switched off for the ride, because a simulating body ignores actor moves. Each one is re-attached to the actor’s root so it follows the actor while held.
• The actor’s collision is disabled, with its previous state saved, so nothing traces against or bumps into a page held at the reader’s face. (This is also why a page’s own blocking collision — see Ink Page actor — is not a problem while reading.)

On landing, the reverse: the actor is teleported onto its saved transform, collision is restored to the saved state, and simulation is switched back on for every primitive that had it. Re-enabling simulation re-detaches those meshes from the actor root, which is standard engine behavior and exactly the state they were in before.

​

Events

​

Blueprint API

The flip half of the API — Flip Page, Set Reading Side, Set Showing Back, Get Reading Side, Is Showing Back, Get Reading Side Text, Is Flipping, Can Flip Page — is tabled under Turning the sheet over.

​

Starting a read while a page is floating back

Calling Begin Reading during a blend-out is handled for you:

• The same page, still on its way down: the blend reverses from wherever the page currently is. The original resting transform and physics state stay as captured, so it still lands home correctly later. A flip still unwinding keeps unwinding smoothly.
• A different page, still on its way down: the old one is put home instantly, then the new read starts from scratch.

While a page is actively up (blend-in or reading), Begin Reading refuses and returns false. Call End Reading first.

​

Edge cases the reader handles

​

Next