> ## 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.
# Project Settings
> Every Inkwell setting: name, type, default, what it does, and where it lives in Project Settings > Plugins > Inkwell
Inkwell never hard-codes a content path. Every asset the plugin loads — the page material,
the sheet mesh, the paper new documents start on, the default font — resolves through
**Project Settings → Plugins → Inkwell**, so your project can repoint any of them (your own
ink material, your own paper, your own default font) without touching code.
The settings object is `UInkwellSettings`, a `UDeveloperSettings` declared
`config = Game, defaultconfig`. Its container is **Project**, its category **Plugins**, and
its section **Inkwell** — that is the whole of the path above, and there is no second
settings page anywhere else in the editor.
## Per-project or per-user?
**Every setting on this page is per-project.** Changes are written to your project's
`Config/DefaultGame.ini`, are checked into source control with the project, and apply to
everyone who opens it — including **Show Toolbar Button**, which reads like a personal
editor preference but is not one.
Inkwell stores exactly one thing per user: the Page Editor's **recent documents** list
behind the toolbar dropdown. That is a workflow habit rather than project data, so it goes
to `Saved/Config/.../EditorPerProjectUserSettings.ini` under the section
`[Inkwell.PageEditor]`, key `RecentDocuments`, capped at eight entries. Nothing else the
plugin does writes per-user config.
When a configured asset is unset or fails to load, Inkwell logs **one warning per session**
naming the exact setting to fix — for example
`Set 'Project Settings > Plugins > Inkwell > Page Ink Material'` — and the accessor returns
nothing. If pages stop rendering after a settings change, read the Output Log for
`LogInkwell` before anything else.
## Materials
**Project Settings → Plugins → Inkwell → Materials.** Both entries are soft object
references, so nothing loads until a page is actually drawn.
| Property | Type | Default | What it does |
| ------------------------------------------------- | ------------------------- | -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Page Ink Material** (`PageInkMaterial`) | Material (soft reference) | `/Inkwell/Materials/MI_PageInk` | Base material used to display baked pages on meshes. Every Ink Page Display, every Ink Page Stack sheet and every **Apply Page To Mesh** call creates a dynamic instance of it. It must expose the parameters named under [Material Parameters](#material-parameters) — the `MF_InkwellPageInk` material function supplies the nine ink parameters; the six paper ones are declared by the material itself (see [Using your own page material](#using-your-own-page-material)). Repoint it to use your own page material — a lit parchment shader, a translucent vellum — without changing any code. |
| **Page Preview Material** (`PagePreviewMaterial`) | Material (soft reference) | `/Inkwell/Materials/M_PageComposite_Preview` | The unlit twin of the page material, used **only** by the Page Editor's live preview, so the editor shows the exact composite the game does. If it is unset the editor falls back to a paper + ink alpha stack, which still previews well enough to author with. |
**Page Ink Material** is the base only while a document's Paper Mode is **Texture asset**
or **Generated**. A document in **Custom Material** mode brings its own material (its
**Paper Material** replaces the slot), and one in **Mesh's Own Material** mode instances
whatever material the target mesh already wears — neither touches this setting. Both of
those materials must carry `MF_InkwellPageInk` to receive the ink; see
[Rendering → the MF\_InkwellPageInk contract](/plugins/inkwell/reference/rendering#the-mf_inkwellpageink-contract).
## Material Parameters
**Project Settings → Plugins → Inkwell → Material Parameters.** All fifteen live behind
the category's **Advanced** expander, because most projects never touch them.
These are the *parameter names* Inkwell writes into the page material's dynamic instances.
The defaults match the parameters inside `MF_InkwellPageInk`, and UE hoists a material
function's parameters onto whatever material calls it — so a custom material built by
dropping that function into its graph automatically has every name below, and this
section can stay closed. Change these names only if you built a page material *without*
the function and named its parameters differently.
**Ink and paper**
| Property | Type | Default | What it receives |
| ------------------------------------------------------------ | ---- | ----------------- | ----------------------------------------------------------------------------------------------------------- |
| **Ink Texture Parameter** (`InkTextureParameter`) | Name | `InkTexture` | Texture parameter that receives the baked ink render target. |
| **Paper Texture Parameter** (`PaperTextureParameter`) | Name | `PaperTexture` | Texture parameter that receives the page's paper albedo. |
| **Use Paper Texture Parameter** (`UsePaperTextureParameter`) | Name | `UsePaperTexture` | Scalar switch: set to 1 when a paper texture is supplied, 0 to use the material's flat paper color instead. |
| **Paper Tint Parameter** (`PaperTintParameter`) | Name | `PaperTint` | Vector parameter multiplied over the paper. |
| **Ink Tint Parameter** (`InkTintParameter`) | Name | `InkTint` | Vector parameter multiplied over the ink — it tints everything written on the pages. |
| **Ink Strength Parameter** (`InkStrengthParameter`) | Name | `InkStrength` | Scalar parameter: 1 = fully opaque ink, lower lets more paper grain through every stroke. |
**Face mapping** — where on a mesh's face the page lands (the display component's
**Page Face** property). A material without these parameters ignores face mappings; the
setters are silent no-ops.
| Property | Type | Default | What it receives |
| ---------------------------------------------------------- | ---- | ---------------- | ------------------------------------------------------------------------------------------------------- |
| **Ink UV Transform Parameter** (`InkUVTransformParameter`) | Name | `InkUVTransform` | Vector parameter carrying the mapping's 2×2 UV matrix, packed row-major as RGBA = (m00, m01, m10, m11). |
| **Ink UV Offset Parameter** (`InkUVOffsetParameter`) | Name | `InkUVOffset` | Vector parameter carrying the mapping's UV offset in RG. |
| **Ink On Back Face Parameter** (`InkOnBackFaceParameter`) | Name | `InkOnBackFace` | Scalar: 1 = back faces show the writing, 0 = back faces show bare paper. |
**Back of the sheet** — the flat-plane fallback for [two-sided pages](/plugins/inkwell/reference/rendering#two-sided-pages-and-the-back-of-the-sheet).
A mesh with no material slot named `Back` shows an authored back through these on its one
material, selected by `TwoSidedSign` and sampled U-mirrored. All default to inert.
| Property | Type | Default | What it receives |
| ----------------------------------------------------------------------- | ---- | ---------------------- | ------------------------------------------------------------------------------- |
| **Back Ink Texture Parameter** (`BackInkTextureParameter`) | Name | `BackInkTexture` | The back side's baked ink render target. |
| **Has Authored Back Parameter** (`HasAuthoredBackParameter`) | Name | `HasAuthoredBack` | Scalar: 1 = Back Ink Texture carries an authored back. |
| **Back Paper Texture Parameter** (`BackPaperTextureParameter`) | Name | `BackPaperTexture` | The back's own paper texture, when it differs from the front's. |
| **Use Back Paper Texture Parameter** (`UseBackPaperTextureParameter`) | Name | `UseBackPaperTexture` | Scalar switch for Back Paper Texture, like Use Paper Texture. |
| **Back Paper Tint Parameter** (`BackPaperTintParameter`) | Name | `BackPaperTint` | Vector tint over the back's paper. |
| **Has Distinct Back Paper Parameter** (`HasDistinctBackPaperParameter`) | Name | `HasDistinctBackPaper` | Scalar: 1 = back faces wear the Back\* paper parameters instead of the front's. |
The values pushed into these parameters come from each
[Ink Page Document](/plugins/inkwell/authoring/documents) — its Ink Tint, Ink Strength, Paper Tint and
resolved paper texture. See
[Rendering → the page material](/plugins/inkwell/reference/rendering#the-page-material) for exactly what is
set, and what is deliberately left alone.
## Content
**Project Settings → Plugins → Inkwell → Content.**
| Property | Type | Default | What it does |
| ------------------------------------------------- | ---------------------------- | -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Page Sheet Mesh** (`PageSheetMesh`) | Static Mesh (soft reference) | `/Inkwell/Meshes/SM_PageSheet` | Default mesh for page sheets: used by the [Ink Page](/plugins/inkwell/components/page-actor) actor, by [Ink Page Display](/plugins/inkwell/components/page-display)'s Procedural Paper sheet, and by [Ink Page Stack](/plugins/inkwell/components/page-stack) when its own **Sheet Mesh** override is unset. The bundled sheet is a thin 100 cm slab with `Front`, `Back` and `Edge` material slots, so authored backs render on it out of the box. A replacement must have clean 0–1 UVs across the page face — atlas-mapped prop meshes garble page content, because the baked ink is sampled across the full 0–1 UV range. |
| **Default Paper Texture** (`DefaultPaperTexture`) | Texture 2D (soft reference) | `/Inkwell/Textures/T_PaperPlain` | The project's paper stock, in three roles: it **seeds the Paper Texture of newly created Page Documents**; a Texture-mode page whose Paper Texture is cleared **falls back to it at runtime**; and it is the stock a generated sheet prints on when **Texture base** is on with no Base Texture named. Repoint it and all three follow. |
| **Blank Ink Texture** (`BlankInkTexture`) | Texture 2D (soft reference) | `/Inkwell/Textures/T_InkNone` | Fully transparent texture assigned to page sheets that have no content yet. An Ink Page Display with **no Document assigned** gets this in the ink slot with `UsePaperTexture` forced to 0, so a bare sheet renders as blank paper instead of showing whatever ink was in the slot before. |
| **Default Page Font** (`DefaultPageFont`) | Font (soft reference) | `/Engine/EngineFonts/Roboto` | Two jobs. It **seeds** a newly created Page Document's Default Font (with the typeface `Regular`), and it is the **runtime fallback** for any document whose Default Font is empty — which the Page Editor shows as *(project default)*. Point it at one of the bundled families, for example `/Inkwell/Fonts/Font_CrimsonText`. |
Set **Default Page Font** *before* you create your documents. A new document is stamped
with whatever this setting names, so changing it afterwards restyles only documents whose
Default Font is genuinely empty — the Page Editor shows those as *(project default)* under
**Default Text Style**. For documents that already carry a font, change it per document in
that same picker.
## Fonts
**Project Settings → Plugins → Inkwell → Fonts.** These feed the Page Editor's font picker
and the [font import tool](/plugins/inkwell/authoring/fonts); none of them affect a packaged build.
| Property | Type | Default | What it does |
| -------------------------------------------------- | ---------------------------- | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Font Search Paths** (`FontSearchPaths`) | Array of content directories | `/Inkwell/Fonts`, `/Game` | Content paths scanned for runtime composite Font assets to list in the Page Editor's font picker. |
| **Include Engine Fonts** (`bIncludeEngineFonts`) | Bool | `true` | Also list the engine's built-in fonts (`/Engine/EngineFonts`, i.e. Roboto) in the picker. They always sort last. |
| **Font Build Output Path** (`FontBuildOutputPath`) | String | `/Game/Fonts` | Where the font import tool writes the composite Font assets it generates. Must be a writable project path — plugin content is read-only in a shipped plugin install. |
Keep **Font Search Paths** tight on a large project. Every font found is loaded so its
typeface names can be read, so scanning all of `/Game` costs a visible hitch the first time
the Page Editor window opens. If your project has thousands of assets, replace the default
`/Game` entry with the specific folder your fonts live in.
## Rendering
**Project Settings → Plugins → Inkwell → Rendering.**
| Property | Type | Default | What it does |
| --------------------------------------------------------------- | ------------------------ | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Max Page Bake Dimension** (`MaxPageBakeDimension`) | Integer, clamped 64–8192 | `4096` | Safety clamp on page bake resolution, per axis, in pixels. A document asking for more is scaled down **proportionally** — one factor on both axes, so the aspect ratio survives and a clamped bake still fills its target instead of cropping. See [page size clamping](/plugins/inkwell/reference/rendering#page-size-and-what-it-costs). |
| **New Document Page Size Pixels** (`NewDocumentPageSizePixels`) | Int Point | `1024 × 1400` | Page size, in pixels, assigned to newly created Page Documents. It does not touch documents that already exist. |
## Editor
**Project Settings → Plugins → Inkwell → Editor.**
| Property | Type | Default | What it does |
| ---------------------------------------------- | ---- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Show Toolbar Button** (`bShowToolbarButton`) | Bool | `true` | Show the Inkwell "Page Editor" dropdown in the Level Editor toolbar. Turn it off if your project has a crowded toolbar — the Page Editor stays reachable by double-clicking a Page Document, from **Tools → Inkwell**, and from the `Inkwell.OpenPageEditor` console command. **Takes effect after an editor restart**, and it is per-project, so turning it off hides it for the whole team. |
## Reading the settings from Blueprint
The resolved assets are available as Blueprint-pure nodes under the category
**Inkwell → Settings**. Each loads its soft reference and returns the asset, or nothing
plus the one-per-session warning described above.
| Node | Returns |
| -------------------------------------------------------- | ------------------ |
| **Get Page Ink Material** (`GetPageInkMaterial`) | Material Interface |
| **Get Page Preview Material** (`GetPagePreviewMaterial`) | Material Interface |
| **Get Page Sheet Mesh** (`GetPageSheetMesh`) | Static Mesh |
| **Get Default Paper Texture** (`GetDefaultPaperTexture`) | Texture 2D |
| **Get Blank Ink Texture** (`GetBlankInkTexture`) | Texture 2D |
| **Get Default Page Font** (`GetDefaultPageFont`) | Font |
The *values* of the settings — parameter names, search paths, the bake clamp — are not
exposed to Blueprint. Read them in C++ through `UInkwellSettings::Get()`, which returns the
class default object and is never null. The same six accessors exist there as statics,
alongside `ResolvePageInkMaterial()`, `ResolvePagePreviewMaterial()`,
`ResolvePageSheetMesh()`, `ResolveDefaultPaperTexture()`, `ResolveBlankInkTexture()` and
`ResolveDefaultFont()` — short aliases with identical behavior.
## Using your own page material
Before repointing **Page Ink Material** project-wide, check whether a paper mode already
does what you want with no settings change at all: **Custom Material** puts your material
on one document's pages, and **Mesh's Own Material** lays ink onto whatever a mesh already
wears. Repoint the setting when you want *every* page in the project on your material.
Make your own material — or duplicate `/Inkwell/Materials/M_PageInk` into your content
folder — and drop the **MF\_InkwellPageInk** material function into its graph: feed it
your paper color, wire its `InkedColor` output onward.
The function carries the **nine ink parameters** — `InkTexture`, `BackInkTexture`,
`InkTint`, `PaperTint`, `InkStrength`, `InkUVTransform`, `InkUVOffset`, `InkOnBackFace`
and `HasAuthoredBack` — and UE hoists them onto your material, so those names match
automatically.
The **six paper parameters** — `PaperTexture`, `UsePaperTexture`, `BackPaperTexture`,
`UseBackPaperTexture`, `BackPaperTint` and `HasDistinctBackPaper` — are *not* in the
function, by design: the function inks whatever paper colour you feed it, and your paper
is yours to build. Declare them yourself only if you want Inkwell to drive your paper —
that is, if your documents use **Texture** paper mode, or a back paper distinct from the
front. Duplicating `/Inkwell/Materials/M_PageInk` is the shortest route, since it already
declares all six. Skip them and Texture-mode pages simply keep whatever paper your
material draws.
Plugin content is read-only in a shipped install, so never edit `/Inkwell/` assets in
place.
A material built without the function works too, if its parameters match the names
under **Material Parameters** — or you change those names to match your material. A
parameter Inkwell writes that your material does not have is silently ignored: the
page renders, but it stops responding to that document setting. Without the ink
texture parameter there is no writing at all.
Set **Page Ink Material** to your material. Placed pages re-apply on the next refresh;
a property edit on the component, or reopening the map, forces one.
No `LogInkwell` warning means the asset resolved. A warning naming the setting means
the path is wrong or the asset is not cooked into this build.
A repointed setting creates a reference from your project to your asset, but the **plugin's
own** defaults are referenced only softly. If you repoint everything away from `/Inkwell/`
and then rely on a bundled asset somewhere else, add it to a cook-always directory — see
[Installation](/plugins/inkwell/installation).
## Next
Where the material, the parameter names and the bake clamp are actually used.
What the font search paths and the import output path feed.
The full runtime surface, including the settings accessors.
What the one-per-session settings warnings mean in practice.