# Backporting inline `|T…|t` texture escape sequences to 1.12 The 1.12 text engine shows `|Tpath:height:width:…|t` markup as literal text. This project makes it draw the icon inline in FontStrings, chat, and tooltips — the way 4.3.4 and later clients do. The feature is complete and shipped ([src/text/InlineTexture.cpp](../src/text/InlineTexture.cpp), [src/text/InlineTexturePool.cpp](../src/text/InlineTexturePool.cpp)). This file is the reverse-engineering map. **Current design** below states what ships today. Everything from **Goal & spec** down is the historical RE trail — the 4.3.4 study, the 1.12 injection map, and the bring-up plan. It is kept for the addresses and the reasoning, not as a description of the current code. ## Current design (shipped) Each icon renders as an **engine-managed region** (a pooled `CSimpleTexture`) anchored to its owning FontString. The engine draws the region every frame and moves it with its line, so texture residency and scroll tracking are correct by construction. (A raw-GxU-quad renderer existed during bring-up and was removed in `56c2670`; its RE is the "REMOVED" section below.) The DLL hooks the engine's own text pipeline — no companion addon: - **Positioning** — a co-hook on the glyph emitter `FUN_005ccbe0` records each icon at its pen position and delegates the plain text runs to the engine (segmented delegation, below). The pen read-back needed a fix: the engine's pen is lazy and omits the last glyph's own advance, so a coin sat on its digits; the emitter now adds the true terminal advance from the engine's own glyph-advance helpers (`550cf5e`). - **Rendering** — the paint-pass co-hook `FUN_005c8fe0` walks the icon records and queues each to `Text::InlineTexturePool`, which places the region on the next frame tick (never mid-render). - **Chat has no one-frame lag** — a ScrollingMessageFrame re-`SetText`s every visible line on each new message, and the engine builds each line lazily at paint, so a line's icons would land one frame after its glyphs (glyphs draw synchronously; the icon regions are separate objects whose placement is only known once the line builds mid-paint, after the frame's texture pass already drew). A co-hook on the SMF display refresh (`FUN_00788750`, which runs pre-render from the frame's own methods) forces each icon-bearing line to resolve+build and applies its icon placement synchronously — before the frame draws — so icons move in lockstep with their text. It reuses the engine's own `Realize(0)` → `RebuildString` → ensure-built path and the same placement math the paint flush uses (`ComputePlacementsForNode`), so the later flush dedups to a no-op. Additive and best-effort: any line whose rect isn't resolvable in time falls back to the paint + tick pipeline (correct, one-frame lagged). A pure scroll or drag never lagged — the icons are anchored to the line and the engine moves them for free; only content changes on a reused line needed this. - **Placement coordinates** — text pen space IS render-target pixels. The engine stores node positions NORMALIZED (fs-local anchor ÷ `[0x832A44]`/`[0x832A48]` per axis, `FUN_0041ade0`), and the origin finalize `FUN_005cdf70` multiplies by the integer raster dimensions `[0xC2B9A4]`/`[0xC2B9A0]` (rounded, with the justify shift and vertical align folded in). So the flush converts pen → fs-relative anchor with `K = raster ÷ anchorExtent`, **per axis**, from those four live globals — no calibration, no cache, correct at every resolution and UI scale (`968335d`). Two earlier forms both failed: an empirical K (`origin ÷ rect edge`) that chat could never self-derive (its rect edge sits near screen x = 0 and failed the divide guard) and so rode a global cache seeded by whichever fontstring derived first — right only at the layout it was calibrated on; then a closed form built from the SetPoint px factor, which used the wrong global pair. Full derivation chain at `VAR_TEXT_RASTER_X/Y` in `Offsets.h`. - **Fade / parent alpha** — icons fade with their line (the pool mirrors the fs's folded colour alpha per frame, `3ca3b7e`), and segmented GLYPHS do too: a bit-3 (standalone FontString) node's baked per-glyph colours never re-bake on an alpha change (the engine's colour-change invalidate `FUN_005ccb40` skips bit-3 nodes), so the flush mirrors the node's live alpha byte (node+0x2c — SetTextColor alpha × frame-chain alpha, kept folded by the engine) into every baked colour, change-detected per page (`bd14a93`). An earlier `0xFF` alpha force at emit was a misdiagnosis of a bubble that built while faded out; it froze icon-line text fully opaque while everything around it faded. - **Outlined fonts** — outline ink extends past the glyph advances; the engine itself grows line height by exactly 4.0 / 2.0 pen px for thick / thin outline (`face+0x180` bits 3 / 0, `.rdata` constants). `OutlineInkPen` reads the same flags and constants, and half the ink leads each icon, half trails — threaded through the shared advance helper so the emitter advance, the justify pre-shift, and the wrap-stepper probes all agree. Without it, coins clipped into outlined digits the moment the exact K removed the old miscalibration's accidental slack (`968335d`). - **Measure** — three cold FontString-level co-hooks make measure match the drawn result: width (`FUN_00772890`), height (`FUN_007729B0`), and wrap (`FUN_005C7260`). `GetStringWidth`, `fontstring:GetStringHeight`, wrap breaks, and line height all count the icon. - **Tall icons** — an icon taller than the font grows its line height, so it does not overlap its neighbors, and it centers in the grown line. A hyperlink that contains a tall icon is hoverable across the whole icon (`49934b0`, `b9d0705`). - **Chat fade** — icons fade in lockstep with their chat line (`3ca3b7e`). - **Editboxes** — an editbox keeps the raw markup, so the caret stays aligned (two complementary signals, below). - **Payload** — the full `|Tpath:height:width:offsetX:offsetY:texW:texH:left:right:top:bottom:r:g:b|t`: size, pen offset, sprite-sheet crop, and vertex tint. BLP and uncompressed TGA. - **Anti-spoof** — chat strips player-injected `|T` icons. Every fs-level measure path now counts icons: width (`FUN_00772890`), height (`FUN_007729B0`), wrap (`FUN_005C7260`), and the substring measure (`FUN_00772AE0` — an earlier note claimed nothing consumed it; its xrefs refute that: the GameTooltip auto-size measures each WRAPPED SEGMENT of a wrap-enabled line through it, so icon-bearing wrapped tooltip lines undersized their tooltip until it was hooked too). The Lua control surface is two toggles: `_classicapi_InlineTexEnable` (the whole-feature kill switch; the SEH latch trips it on a flush fault) and `_classicapi_InlineTexEarly` (the SMF-refresh early apply above — on by default, toggle off to A/B the chat lag against the baseline paint+tick pipeline, which keeps running either way). The bring-up tune / stat / probe functions were removed (`5e5677b`, `6800a9a`). ## REMOVED (bring-up record) — the raw-GxU-quad rendering primitive This was the FIRST renderer: each icon drawn as a raw textured quad through the text VB path. It shipped, then was removed in `56c2670` for the engine-region model (regions are resident by construction; the quad path needed the texture- residency machinery below and still flickered on VRAM pressure — see `docs/InlineTextureResidency.md`). This section is the address record for the removed code, not a description of the current renderer. `LoadTextureByPath`, `DrawTexturedQuad`, and the GxU device offsets it names are gone from `Offsets.h`; the values live here and in git history. An arbitrary texture draws through the text VB path as a coloured, alpha-blended quad. The end-to-end recipe: 1. **Load by path** — `LoadTextureByPath` replicates `FUN_00770200`'s load: build flags via `FUN_0058a980(&flags, DAT_00878cf0, 0,0, 0,0,0, 1, 0)`, then `FUN_00449d90(path, &desc, flags, 0, 1)` with a byte-identical 5-dword desc (`{PTR_FUN_007ffa10, 8, &self8, (&self8)|1, 0}`). Returns the **HTEXTURE** (0x15c-byte struct; path@+0xc, flags@+0x110, refcount@+4). 2. **THE KEY — residency + correct bind via `FUN_0044acf0(HTEXTURE, 1, 0)`.** This is the engine's own "get renderable texture" call (what the widget render uses every frame). It returns the bindable **CGxTexture** at `[HTEXTURE+0x140]` and, with force=1, drives the streaming load (`FUN_0044ad50` submits/prioritises it via `[HTEXTURE+0x138]`). **Calling it every frame is the live reference that makes the texture resident** — no hidden widget, no manual BLP decode. This was the entire multi-session blocker: WoW streams textures and only loads ones a live frame references; a standalone `FUN_00449d90` texture never loads on its own. Binding the raw HTEXTURE is `SetTexture([HTEXTURE+0x48]=0)` = a **white** quad; the D3D handle lives on the CGxTexture (`[CGxTexture+0x48]`), not the HTEXTURE. Dead ends that wasted time: manually invoking the decode callback `FUN_0044a260` (fills `[+0x120]` but not the bindable `+0x140`, and faults); binding `[HTEXTURE+0x48]` or `[HTEXTURE+0x120]` (both wrong offsets); forcing the streamable flag `tex[0x3c]|=0x80` (crashes in d3d9 — the bind's stream-in vfunc corrupts the resource). 3. **Bind** — `FUN_00589e80(0x17, cgxTex)` (selector 0x17 = text texture stage). 4. **Colour** — the font stage's default stage-0 COLOROP is already MODULATE, so `texture.rgb × diffuse(white)` = the icon's true colours; texture alpha works too. No colorop override is needed for a plain white vertex. (If a tint is wanted later: COLOROP is D3DTSS internal state `0x42` via `FUN_005a2570`; the engine leaves COLORARG1 at the D3D default = TEXTURE. Do NOT poke it directly mid-draw — it leaks `MODULATE` to the whole UI when a fault skips the restore. Use the engine's selector `0x1f` (value→COLOROP/ALPHAOP preset table at `DAT_0080a25c`/`DAT_0080a274`; value 1 = MODULATE/MODULATE).) 5. **Quad** — lock the shared dynamic VB `FUN_0058a140(0, 0x18, 0x800)`, get the write ptr `FUN_0058a080`, write **4 verts** of the format `{float x,y,z; u32 colorBGRA; float u,v}` (stride 0x18) in corner order **TL, TR, BL, BR** (matches the shared quad index buffer `{0,1,2, 2,1,3}` and the device cull winding), submit `FUN_005c8f40(&handle, 4)`, unlock `FUN_0058a0a0(handle, 0)`. 6. **Where** — co-hook the text paint pass `FUN_005c8fe0` and draw after the original glyph flush (device is in the correct textured-UI state there). Coordinate space is **per-layout pixels, y-down**; glyph verts live at small local coords (a probed glyph was at ~(9,33)–(17,50)). Draw coords must be within the layout's rendered area (a fixed (100,100) test lands in chat). The build-side gotcha: the D3D device (default backend, `FUN_0058dd70`) is actually **OpenGL** (`glMaterialfv`/`glFogi`) — the D3D backend is `FUN_0058ba70` (`FUN_00598ce0`, vtable `PTR_FUN_00809ef8`); its state applier is `vtable[1]` = `FUN_005a2f00`, which maps engine selectors to D3D via `FUN_005a2570` (SetRenderState `+0xe4`, SetTextureStageState `+0x10c`, SetSamplerState `+0x114`, SetTexture `+0x104`). Selector map (shared across GL/D3D backends): 7=blend, 0x10=depthtest, 0x14=cullface, 0x17-0x1e=texture bind (8 units), 0x1f-0x26=colorop/alphaop preset (unit 0-7). ## SOLVED — positioning, measure/wrap, editbox exclusion, texcoords The primitive draws at arbitrary coords; the rest is knowing WHERE and WHEN. Everything is in [src/text/InlineTexture.cpp](../src/text/InlineTexture.cpp); offsets under the "Inline texture escape" + positioning blocks in [Offsets.h](../src/Offsets.h). ### The text render hierarchy (verified) ``` frame → renderNode [frame+0x118] → group [renderNode+0x18] → node [group+0x18] → line [node+0x24] ← the emitter's `this` ``` - Main UI render `FUN_007657d0(DAT_00cf0bd8)` walks strata → frames, calls `FUN_0076fb00(renderNode)` per frame's render node. - `FUN_0076fb00` draws the frame's Texture regions then `FUN_005c1ef0(group)` → `FUN_005c8b70(group)` → `FUN_005c8fe0(node)` per node. - `FUN_005c8fe0(node)` = the **paint pass** we co-hook: ensures each line built (`FUN_005cd6a0` → `FUN_005cdc20` → the emitter), then binds each font page and copies the line's per-page glyph batches into the dynamic VB, translated by the line origin `[line+0x70]/[+0x74]`. - The **emitter** `FUN_005ccbe0(line, text, len, colorState, penXYZ, pageMask, linkState)` builds one wrapped line's glyph quads. `this` (the "line"/node the icon list keys on) owns batches `[+0xa0+page*4]` and origin `[+0x70]`. **Note the render node the emitter sees has NO back-pointer up to the frame** — the editbox discriminator had to be found another way (see below). ### Positioning — segmented delegation (co-hook the emitter) We do NOT reimplement the emitter's intricate glyph vertex math. Instead, in the `FUN_005ccbe0` co-hook, for a line containing an inline texture: 1. Split the line at icon boundaries. Render each **plain run** by calling the ORIGINAL emitter on just that substring — the engine still draws every glyph. 2. Thread the pen across runs: on return the emitter leaves the final node-local pen x in **`linkState[4]`**, stored with `FSTP dword` — a **FLOAT bit pattern**, not an int. Read it as a float (`*(float*)&linkState[4]`); an int-cast yields garbage (this bug hid the icon off-screen and dropped the trailing text). 3. Record an `IconRecord` at the pen (node-local `x`,`y`) into `g_nodeIcons[line]` and advance the pen by the icon width. No draw runs during the build — icons are recorded and **flushed** in the `FUN_005c8fe0` paint co-hook, which computes each icon's pen-space position (line origin `[line+0x70]/[+0x74]` maps node-local → pen, the same translate the glyph copy `FUN_005c8710` applies), converts pen → anchor with the per-axis K (see **Placement coordinates** in Current design), and queues it to `Text::InlineTexturePool` as a placement RELATIVE TO THE OWNING FONTSTRING. The pool applies placements on the next frame tick. 4. Restore `penXYZ[0]` on exit (the original never writes it; the draw builder does NOT reset it between left-justified lines, so leaving it mutated cascade-shifts every following line). ### FontString pipe-doubling — the escape arrives as `||T…||t` The FontString text sanitizer **doubles any pipe that doesn't begin a recognized escape** so it renders as a literal `|`. 1.12 doesn't know `|T`, so a caller's `|Tpath:h|t` reaches the emitter as `||Tpath:h||t` (verified: emitter text length +2, pipes doubled). The detector therefore matches BOTH the doubled form (the real-world case) and a clean `|T` (should one ever arrive undoubled). Normal doubled pipes (`|| `) never match because the next char must be `T`. ### bit-3 batch-clear mode The emitter clears the line's page batches at its top only when node flag `[line+0x5c] & 0x08` is set (the FontString/static case). Calling the original per segment would then wipe all but the last run. Handled by doing the clear ONCE per build (a `len==0` original call with bit 3 still set), then clearing bit 3 so the per-segment calls APPEND, restoring flags on exit. Bit 5 (shadow) isn't set for these nodes, so the only added work is a harmless colour append. Clearing bit 3 has one more consequence: it switches the engine from the UNIFORM colour path (node+0x2c, consulted live at every paint) to baked PER-GLYPH colours the paint uses verbatim. The build-time alpha in colorState is already correct (the engine folds SetTextColor alpha × frame-chain alpha into node+0x2c on every alpha change), but the baked copies never refresh — the flush's alpha mirror keeps them tracking later fades. See **Fade / parent alpha** in Current design. ### Multi-line / multi-icon accumulation The draw builder walks a node's wrapped lines by calling the emitter repeatedly on the SAME node, advancing the text pointer. So the icon list is cleared ONCE per build — on the first wrapped line, detected by `text == [node+0x48]` (the node's text start) — and icons ACCUMULATE across lines. Multiple icons per line fall out of the segmentation loop naturally. ### Vertical centring — font-relative `penXYZ[1]` sits near the text TOP, so the icon centre = `penY + fontHeight * g_centerFrac` (0.6, calibrated in-game across chat + pfUI's bubble). Font height comes from the engine's own `FUN_005c6fa0(flag, [node+0x1c])` (the emitter's glyph-sizing call), so centring holds across font sizes without a fixed pixel nudge. A TALL icon (height > font) centres in its GROWN line (see the tall-icon sections in Current design) — the string-height co-hook adds the overflow, so the extra room sits half above and half below the text. ### Measure / wrap — co-hook the tokenizer Line wrap is decided by the measure/fit functions (`FUN_005c6940`, `FUN_005c7470` via `FUN_005c7260`), which all share the `|`-tokenizer `FUN_005c2810`. Left alone, they count the hidden path text and wrap early. Fix: co-hook the tokenizer — when it's at an inline-texture span, consume the whole span as ONE near-zero-width token so every measure/fit caller ignores the path characters. The emitter detects icons independently (it scans the raw bytes), so the draw path is unaffected. ### Measure width: FIXED at the fs-level choke (`GetStringWidth` counts icons) The tokenizer reports an icon span as a **near-zero-width** token, so at the gxu loop level every measure caller counts the icon as ~0 pixels wide. (The emitter still reserves the render width, so text after an icon positions correctly.) An earlier version of this doc concluded that the gap could not be closed cleanly, because the gxu engine has **no single cold choke**: - `FUN_005c6940` (width), `FUN_005c7470`/`FUN_005c7260` (wrap), and the hit-test loop each tokenize and accrue width independently. - The token contract has no width field. - The per-glyph helpers (`FUN_005cabd0`/`FUN_005c6b70`) are the hottest text functions in the engine. That analysis was right about the gxu level. The choke sits ONE LEVEL UP: **`FUN_00772890` = `CSimpleFontString::GetStringWidthInternal`** (`Offsets::FUN_FONTSTRING_STRING_WIDTH`) is cold, MinHook-safe, and the single funnel for exactly 4 callers: - `Script_GetStringWidth` (0x0079E510) - the GameTooltip auto-size (0x00530640) - the editbox caret positioner (0x0077DE70) - the layout effective-width vmethod (`FUN_00772930` = fs+0x24 vtbl +0x1C, which feeds auto-width fontstring layout) It lazily computes into the `fs+0xFC` cache (anchor units, 0.0 sentinel) via the measure core `FUN_0044D670`, then divides the pen-space result by `fs+0x7C`. The co-hook lives in `src/text/InlineTexture.cpp`. It calls the original, then adds `SumIconAdvances(text) / K` when two gates pass: - `InlineInterceptActive(text)` is true — the **same predicate** the tokenizer hook stands down on, factored into one function so measure and render can never disagree. - The fs is not an editbox: `fs+0x120 & 0x1000` is clear (the fs-level bit `FUN_0044D670` translates into the gxu editbox flag 0x40). The icon sum is computed in TRUE PEN PX — the exact numbers the emitter reserves — and bridged into the getter's return space by the font height known in both spaces: `sumPen × (fontHInt / fontHPen)`. `ResolveFsPenFont` replicates the render chain: `fontHPen = round((fontHInt × fs+0x7C, floored at [0x801628]/rasterY) × rasterY)` (the rebuild's node fontSize + the node ctor's min clamp + the emitter's own height helper), and the outline ink resolves through `face = [[fs+0xE0]+0x20]` — the same object the node stores at +0x44. fs-built nodes are always in snap mode (no fs-flag maps to node bit 7), so the snap-truncated advances are exact. The per-icon advance comes from `IconAdvancePen`, the **same helper** the emitter reserves with — so the measured width matches the rendered width by construction, outline ink and pixel snapping included. (An earlier bridge used the SetPoint push factor `div×1024/mul ≈ 1468` as the intermediate — the units cancelled for `:0` icons, but it couldn't express the truncation or the ink.) Unit trap (hit on first flight): escape sizes are UI PIXELS. Do NOT divide the icon sum by `fs+0x7C` — that field is the layout UI *scale* (~0.68–1.0). The original's own `out / fs+0x7C` applies to a value the measure core already ran through the `FUN_0041AD80` gxu→internal converter, not to raw pixels. The `/0x7C` version measured a 16px icon as +44k px. The hook NEVER writes the `fs+0xFC` cache: the original can serve the cached value, so the icon sum is re-derived and re-added per call (idempotent). The same hook also fixes two layout consumers for free: tooltips auto-size wide enough for icon-bearing lines, and auto-width fontstrings lay out at their true rendered width. ### Wrap: FIXED at the shared stepper (`FUN_TEXT_WRAP_STEPPER` = 0x005C7260) Wrap decisions also measured icons as ~0, so a chat line with prefix icons broke as if the icons were not there and the emitter's real advances ran past the right edge. The choke is the wrap-stepper dispatcher `FUN_005C7260`: it lays out one wrapped line per call, and its exactly 4 callers are EVERY wrap consumer — the draw builder `FUN_005CDC20` (render breaks), the height measure `FUN_005C2070`, the chars-that-fit counter `FUN_005C21C0` (ellipsis), and the break-array computer `FUN_005C2430` (behind `FUN_00772B60`). The co-hook shrinks the `wrapWidth` argument by a **minimal feasible shrink**, gated on the same `InlineInterceptActive` predicate plus the flags editbox bit 0x40 the dispatcher already carries. The stepper reports each probe's measured (icons-at-zero) line width in `outWidth`, which gives a direct feasibility check: the line renders inside the frame iff its icons fit in the shrink plus the spare the break left (`iconSum ≤ s + (probeW − outWidth)`). The hook probes sandboxed (local out-params plus a COPY of the `p10` in/out state byte, so the caller's first-line state is not consumed): s = 0 first (feasible → no shrink at all — the common short-message case), escalate by the measured deficit when infeasible, bisect down after the first feasible hit; ≤8 probes, and with no feasible hit the last escalation target wins (wraps early rather than overflowing). The feasibility check carries a HALF-GLYPH tolerance: an auto-width fontstring (single anchor, no width — e.g. pfUI's addon-list labels) wraps at the icon-inclusive string width our GetStringWidth hook feeds the effective-width vmethod, so its line fits with exactly zero slack, and cross-computation drift between the two hooks' unit chains (plus OUTLINE extras and the trailing-glyph quirk) read "fits exactly" as "1px over" — shrinking a zero-slack line forces a wrap that had no business existing. Genuine icon overflow is ≥ a full icon, so half a glyph separates drift from real overflow. `outBreak` and `outNext − text` are byte counts; `outBreak == len` means the whole text fit. Two rejected earlier schemes, for the record: a naive whole-remaining- text sum shredded an 8-icon line to one word per line, and a fixed-point iteration on the icon count oscillated (a ~55-byte zero-width escape makes the break↔icon-count coupling discontinuous — no fixed point exists). `text` always points at the REMAINING text, so a continuation line whose icons are behind it gets sum = 0. Because all four consumers share the hook, render breaks, `GetStringHeight`, truncation, and break arrays shift together. (A `_classicapi_InlineTexWrap(n)` ring dumped the last 8 icon-bearing calls during bring-up; removed with the other diagnostics in `5e5677b`.) Unit trap #2 (hit TWICE): the stepper's inputs are gxu-normalized, PER AXIS — fontH is normalized-Y (× rasterY = pen px) and wrapWidth/outWidth are normalized-X (× rasterX = pen px). Both caller flavors land there: the draw builder passes node+0x1C/+0x3C (normalized at block creation), and the fs-level callers (the path chat wraps through) x-normalize their widths inside `FUN_0044d670` before gxu. First flight subtracted raw pixels and annihilated the small normalized widths (2-glyph chat fragments). The second converted with `fontH / fontHPx` — a Y-AXIS factor applied to an X-axis width — overshrinking the budget by the render aspect (×1.33 at 4:3, ×2.37 at 2560×1080): icon-bearing chat lines wrapped a word or two early, worse per icon and per aspect. The correct pen-x → width-units factor is `1/rasterX`, and the glyph-relative tolerances use `fontHPx/rasterX` so "half a glyph" means an actual glyph width. **Chat hyperlink hover over inline icons works (verified).** An emote wrapped in a hyperlink — `|Htel:name|h|T…|t|h`, the TwitchEmotes pattern — pops its tooltip when you hover the *icon*, not just adjacent text. The hover region is NOT re-measured on hover: the engine records each hyperlink's screen rect at layout time into a `GXUFONTHYPERLINKINFO` array (32-byte entries: rect + link data) via `FUN_005cd310`, called from the draw builder `FUN_005cdc20` — the same layout pass that runs the line through our co-hooked tokenizer (`FUN_005c2810`) and wrap-stepper (`FUN_005c7260`). So the recorded rect rides the same icon-aware position accounting the wrap fix installs; the icon lands inside the hover region for free, and hovering it fires the frame's `OnHyperlinkEnter`. This is a consequence of the wrap fix, not a separate feature. (Ghidra caveat: the decompile of the `FUN_005cd310` call args is mangled — a pointer-as-float + an uninitialized temp — so this is confirmed by the call path plus in-game test, not the byte-level formula.) **Still icon-blind (accepted residuals):** - Sub-pixel only for a string-final icon: the width hooks report its INK edge (advance minus the trail half-pad/ink — `TrailingIconTrimPen`), matching the engine's own last-glyph convention (the gxu width loop ends on ink, not advance — the source of the old −0.8px measurement, whose previous-glyph advance treatment is semantically CORRECT once an icon renders after it). What remains is the icon region's ±0.5px placement rounding and the base loop's ~0 contribution for the payload-0 icon token. - An fs whose `fs+0xFC` cache was filled while the feature was toggled differently (`_classicapi_InlineTexEnable`) keeps its old base width until the next `SetText`/font change re-dirties it. Debug-toggle-only. **Editbox measure stays raw (by design).** The caret/measure path reads the focused editbox's INPUT buffer in place, and the tokenizer stands down on it per-editbox (`TextInFocusedEditbox` pointer-range test — not a global focus check), so caret math measures the raw `|T…|t` literal the editbox renders. The width hook mirrors that with the `fs+0x120 & 0x1000` editable gate. One marginal wobble: the focused single-line chat editbox's display fontstring carries editable=0 (only multi-line editors set the bit), so the caret positioner's line-boundary branch (multi-line-only in practice) can see an icon-adjusted `FUN_00772890` on it. Closing that costs a per-token content compare, which is not worth it. ### Editbox exclusion — two COMPLEMENTARY signals (bit 6 + focus global) Editable text must show raw, editable `|T…|t` markup, not rendered icons — you edit macros, tweak icon fields, copy/paste texture strings. **This is retail-correct, verified in-game on a modern client:** typing `|TInterface\Icons\INV_Misc_Coin_01:16|t` into the chat entry box OR a macro body shows it **raw** (no icon) — Blizzard neutralizes player-*typed* escape sequences as anti-abuse — while addon/system text (`AddMessage`, `GetCoinTextureString`) renders. Retail's discriminator is the text's SOURCE (trusted vs player-typed), not editbox-vs-display; a shift-clicked item link renders in the chat box because it's inserted through the trusted path, but a typed `|T`/`|c` does not. Our editbox-raw + display-renders split reproduces the same observable outcome. (One mechanism-level divergence we accept: our editbox-raw uses the GLOBAL focus signal below, so while an editbox is focused OTHER display text that rebuilds also briefly shows raw; retail suppresses per-source. Cosmetic, and a per-editbox fix would need hot-path text-buffer matching — not worth it.) 1.12's tokenizer, unlike 4.3.4's, has no per-render texture-disable bit (4.3.4 uses tokenizer flag **0x1000** to kill only `|T`, **0x800** to kill all escapes), and editbox text nodes are NOT distinguishable by class from the render node — the emitter can't reach the owning frame. It takes **two signals together**, not one (an earlier version of this note wrongly called the focus global a redundant "belt-and- suspenders fallback" — removing it renders the chat/copy boxes' `|T` as icons): - **Node flag `[node+0x5c]` bit 6 (0x40) = EDITABLE** — catches the **macro editor** (`MacroFrameText`, flags `0x4D`), which builds its layout once, **un-focused**, so the focus global never sees it. But single-line inputs (chat entry box, `pfChatCopyBox`) have bit 6 **CLEAR** — their nodes are `0x0D`/`0x20D`, identical to display FontStrings — so bit 6 can't catch them. - **Focused-editbox global `DAT_00cf4dc8`** (`InputFocused()`; holds the editbox with keyboard focus, cleared by `ClearFocus` = `FUN_0077e410`) — catches those single-line inputs. It's GLOBAL (true UI-wide, not per-node), which is why, while an editbox is focused, other display text that *rebuilds* also briefly renders raw. That's an accepted tradeoff: there is no per-node signal for single-line inputs, and when you're in an editbox seeing raw markup is what you want anyway. **Why the tokenizer's bit-6 gate is load-bearing for RENDER, not just measure:** when the emitter suppresses an editbox it delegates to the ORIGINAL emitter, which **re-enters the tokenizer** to lay out glyphs (`FUN_005ccbe0` → `FUN_005c2810`). On that render path `flags` is the node's own flags, so bit 0x40 makes the tokenizer stand down and the `|T` draws as literal text. Drop the bit-6 gate and the (un-focused) macro editor draws **BLANK** — the tokenizer eats the span as a zero-width token and the original emitter renders nothing (verified in-game). Focused single-line inputs get the same "don't intercept" via `Suppressed()` → `InputFocused()`. So both the emitter and the tokenizer consult `Suppressed() || bit-6`; the two must agree or you get blank-vs-raw mismatches. (Dead end: **monochrome render flag `DAT_00c2b9dc`** (`FUN_005c8b70` sets it per group) — un-set at MacroFrameText's build time and flickered as a flush gate. Dropped. The editbox class vtable is `0x0081c8c0`, its script-slot resolver `FUN_0077a310` with focus slots at `+0x438`/`+0x440` — useful if a frame-level hook is ever needed.) ### Descriptor fields + the vertical flip `ParseIcon` handles the full positional payload `path:height:width:offsetX:offsetY:texW:texH:left:right:top:bottom:r:g:b`. Texcoords crop a sprite sheet to one cell: `u = left/texW, right/texW`, `v = top/texH, bottom/texH` — e.g. `UI-RaidTargetingIcons` is a 256×256 sheet, 4×2 grid of 64×64, so marker N's cell is `256:256: