mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-15 23:50:38 +00:00
Every engine frame method validates its `self` in three steps before
touching it: lua_type == table, resolve to the CFrameScriptObject, then
the IsA(typeId) vmethod at vtable+0x10. We did the first two and skipped
the third, so ResolveObject handed back a pointer for ANY frame and the
method cast it to whatever type it expected.
That was reachable from plain Lua, not just through a mirror or a hook.
The per-type method dispatcher is an __index handler that rawgeti's the
method closure out of the Lua registry, so frame methods are ordinary
first-class values, and
GameTooltip.SetSpellByID(ShapeshiftButton1, 133)
reached the tooltip builder with a Button, writing tooltip fields through
Button memory. The engine refuses that same call with "Wrong object type
for member function".
Game::Lua::ResolveTypedObject runs the engine's prologue and raises the
engine's own three error strings, read from .data rather than reinvented.
FrameScriptTypeId mirrors the lazy id assignment, so a check is valid
before any stock method of the type has run. Seven per-type wrappers stop
a call site pairing a method with the wrong class's id, and
ResolveTypedObjectAny covers a method that more than one type reaches.
45 call sites across 19 files now gate self. model/DisplayInfo.cpp had
already worked this out for Model alone and loses its private copy.
Type ids are per CLASS, one shared by all of that class's methods. Each
was read from the prologue of a method that can only belong to its class:
a base-class method registered into several tables carries the BASE id, so
sampling GetObjectType or GetDrawLayer would have produced a gate that
accepts unrelated types. Frame comes from Script_RegisterEvent and Texture
from Script_SetDesaturated, both cross-checked against the first entry of
their table.
Deliberately left ungated: the binding `owner` in bindings/Api.cpp and the
three co-hook sites in texture/Atlas.cpp. Each only uses the pointer as an
identity key and never casts it, so a gate would tighten the contract for
no safety gain -- and raising inside a co-hook would fire before the
original ran.
Verified in-game: the Button-as-tooltip call now raises the engine's
error; a Button still reaches a Frame-registry method
(button:SetAttribute round-trips), so IsA does accept derived types; and
fontstring:GetRotation() still answers -- that reader is registered on
both the Texture and FontString registries and needs the id pair rather
than the Texture id alone.
410 lines
19 KiB
C++
410 lines
19 KiB
C++
// This file is part of ClassicAPI.
|
||
//
|
||
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
||
// of the GNU General Public License as published by the Free Software Foundation, either
|
||
// version 3 of the License, or (at your option) any later version.
|
||
//
|
||
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
||
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||
// PURPOSE. See the GNU General Public License for more details.
|
||
|
||
// FontString metric backports.
|
||
//
|
||
// 1.12's FontString method table (32 entries at 0x0087C1D8, registry context
|
||
// VAR_FONTSTRING_METHOD_REGISTRY) ships GetStringWidth but none of the later
|
||
// metric bindings. The engine already has every internal getter — these are
|
||
// the thin Lua bindings Blizzard never wrote for 1.12:
|
||
//
|
||
// GetStringHeight() — 2.3.0 binding; internal getter
|
||
// FUN_FONTSTRING_STRING_HEIGHT (wrap-aware,
|
||
// lines×fontH + (lines−1)×spacing, cache
|
||
// fs+0x100, 0 for empty text).
|
||
// GetUnboundedStringWidth() — the substring measure with the WHOLE string
|
||
// (FUN_FONTSTRING_MEASURE_SUBSTRING, len 0 =
|
||
// strlen): the string's width with no wrap cap.
|
||
// Icon-aware for free — the call routes through
|
||
// text/InlineTexture.cpp's co-hook.
|
||
// GetWrappedWidth() — the RENDERED width: the widest wrapped line
|
||
// (the tooltip auto-size's own recipe — break
|
||
// array + per-segment substring measures).
|
||
// GetNumLines() — the node's built line count (render truth,
|
||
// OFF_TEXT_NODE_BUILT_LINES) once painted; for
|
||
// an unbuilt node, the engine's own break-array
|
||
// computer (FUN_FONTSTRING_BREAK_ARRAY — also
|
||
// icon-aware via the wrap-stepper co-hook).
|
||
// GetLineHeight() — the fs font height via the same getter the
|
||
// rebuild feeds the text node (FUN_007727b0);
|
||
// excludes spacing, like retail (GetSpacing is
|
||
// its own method).
|
||
// IsTruncated() — did the engine cut the text off with an
|
||
// ellipsis? Reads the render's own output: the
|
||
// built text node's copy of the laid-out string
|
||
// (OFF_TEXT_NODE_TEXT) vs the source. Same
|
||
// "displayed vs full" comparison retail does; no
|
||
// reconstruction of the fit/wrap/maxLines logic.
|
||
// Reflects the last rendered layout (the display-
|
||
// text resolver's rect is zero until a render, so
|
||
// a Lua-time re-call cannot see the bound).
|
||
// SetMaxLines(n)/GetMaxLines() — cap the fontstring to n wrapped lines; text
|
||
// past the cap is ellipsized. Writes the engine's
|
||
// own per-fontstring maxLines field (fs+0x128,
|
||
// already honored by the truncation resolver) and
|
||
// re-invalidates the layout like SetText does.
|
||
// 1.12 has no SetWordWrap, so SetMaxLines(1) is
|
||
// how you get a single-line, ellipsized label.
|
||
// SetFormattedText(fmt,...) — string.format + SetText convenience. The format
|
||
// runs through the engine's OWN str_format C
|
||
// function (FUN_LUA_STR_FORMAT) under pcall — NOT
|
||
// _G.string.format, so an addon replacing
|
||
// string.format can't hijack it (matches retail).
|
||
// The set goes through FUN_FONTSTRING_SET_TEXT,
|
||
// keeping the sanitizer/pipe handling identical to
|
||
// SetText.
|
||
//
|
||
// Push conversion mirrors Script_GetStringWidth (0x0079E510): resolve self,
|
||
// call the internal getter, convert anchor units → UI pixels, push.
|
||
//
|
||
// No inline-icon adjustment lives HERE: the width/height internal getters are
|
||
// already icon-adjusted by their co-hooks (calling the hooked VA routes
|
||
// through the detour), and icons never change GetLineHeight.
|
||
|
||
#include "Game.h"
|
||
#include "Offsets.h"
|
||
|
||
#include <cstdint>
|
||
#include <cstring>
|
||
|
||
namespace FontString::Metrics {
|
||
namespace {
|
||
|
||
// FUN_FONTSTRING_STRING_HEIGHT — ECX = fs, no stack args, float in x87 ST0.
|
||
using StringHeightInternal_t = float(__fastcall *)(void *fs);
|
||
// FUN_FONTSTRING_MEASURE_SUBSTRING — __thiscall(fs, text, len); dummy-EDX form.
|
||
using MeasureSubstring_t = float(__fastcall *)(void *fs, void *edx, const char *text, int len);
|
||
// FUN_FONTSTRING_FONT_HEIGHT — __thiscall(fs, mode-on-stack); dummy-EDX form.
|
||
using FsFontHeight_t = float(__fastcall *)(void *fs, void *edx, int mode);
|
||
// FUN_FONTSTRING_BREAK_ARRAY — __thiscall(fs, text, wrapWidth, outBreaks, cap).
|
||
using BreakArray_t = uint32_t(__fastcall *)(void *fs, void *edx, const char *text, float width,
|
||
int *outBreaks, int cap);
|
||
// FUN_FONTSTRING_SET_TEXT — __thiscall(fs, text, flag = 0); dummy-EDX form.
|
||
using FsSetText_t = void(__fastcall *)(void *fs, void *edx, const char *text, int flag);
|
||
// FUN_HANDLE_RELEASE — DecRef a ref-counted handle. __fastcall(handle).
|
||
using HandleRelease_t = void(__fastcall *)(void *handle);
|
||
// FUN_FONTSTRING_LAYOUT_INVALIDATE — region layout invalidate. __thiscall(region,
|
||
// int); dummy-EDX form.
|
||
using LayoutInvalidate_t = void(__fastcall *)(void *region, void *edx, int arg);
|
||
|
||
// Invalidate a fontstring's layout exactly as SetText (FUN_00771D80) does after
|
||
// a content change, so a layout-affecting property change (max lines) takes
|
||
// effect on the next draw: drop the cached measures, release the built node,
|
||
// clear the layout-dirty bit, and notify the region to re-lay-out. Re-calling
|
||
// SetText would NOT work — it early-outs when the text string is unchanged.
|
||
void InvalidateLayout(void *fs) {
|
||
Game::Ref<float>(fs, Offsets::OFF_FONTSTRING_WIDTH_CACHE) = 0.0f;
|
||
Game::Ref<float>(fs, Offsets::OFF_FONTSTRING_HEIGHT_CACHE) = 0.0f;
|
||
void *block = Game::Read<void *>(fs, Offsets::OFF_FONTSTRING_TEXT_BLOCK);
|
||
if (block != nullptr) {
|
||
reinterpret_cast<HandleRelease_t>(Offsets::FUN_HANDLE_RELEASE)(block);
|
||
Game::Ref<void *>(fs, Offsets::OFF_FONTSTRING_TEXT_BLOCK) = nullptr;
|
||
}
|
||
Game::Ref<uint32_t>(fs, Offsets::OFF_FONTSTRING_DIRTY_FLAGS) &= ~1u;
|
||
void *region = reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(fs) + 0x24);
|
||
reinterpret_cast<LayoutInvalidate_t>(Offsets::FUN_FONTSTRING_LAYOUT_INVALIDATE)(
|
||
region, nullptr, 0);
|
||
}
|
||
|
||
// Anchor units → UI pixels: `FUN_0041AE40(FUN_0041AD70() × DAT_007FFD68 × v)`
|
||
// = v × [VAR_UI_COORD_SCALE_DIV] × 1024 / [VAR_UI_COORD_SCALE_MUL] — the exact
|
||
// push chain Script_GetStringWidth uses (the inverse of
|
||
// Tooltip::LinePool::PixelToInternal).
|
||
double InternalToPixel(float v) {
|
||
const float mul = Game::Read<float>(Offsets::VAR_UI_COORD_SCALE_MUL);
|
||
const float div = Game::Read<float>(Offsets::VAR_UI_COORD_SCALE_DIV);
|
||
if (mul == 0.0f)
|
||
return 0.0;
|
||
return static_cast<double>(v) * div * Offsets::UI_COORD_SCALE_UNIT / mul;
|
||
}
|
||
|
||
// The fs's wrap budget in the units FUN_FONTSTRING_BREAK_ARRAY expects
|
||
// (width-getter units — it multiplies by fs+0x7C itself before gxu, verified
|
||
// decompile), or 0 when the rect is unresolved. rectWidth ÷ scale, calibrated
|
||
// EMPIRICALLY against the render with a three-point probe (a 100px box at
|
||
// scale ~0.91, text whose candidate lines measure 78.1 / 94.6 / 101.6px):
|
||
// raw rectW → effective budget ~91px → broke one word EARLY,
|
||
// rectW/scale² → effective budget ~110px → broke one word LATE,
|
||
// rectW/scale → effective budget 100px → breaks exactly where the
|
||
// render does (94.6 ≤ 100 < 101.6).
|
||
// All three observations fit budget_px = pxOf(param) × scale, pinning the
|
||
// single ÷scale. (A pure paper derivation from the rebuild's node budget
|
||
// predicted /scale² — one hop of that chain models the live behaviour wrong;
|
||
// the probe is the arbiter.)
|
||
float WrapBudget(void *fs) {
|
||
const float *rc = Game::Ptr<const float>(fs, Offsets::OFF_REGION_RECT);
|
||
float width = (rc[3] > rc[1]) ? (rc[3] - rc[1]) : (rc[1] - rc[3]);
|
||
const float s = Game::Read<float>(fs, Offsets::OFF_LAYOUT_SCALE);
|
||
if (width > 0.0f && s > 0.0f)
|
||
width /= s;
|
||
return width;
|
||
}
|
||
|
||
// Shared self-resolve for every method here.
|
||
void *ResolveSelf(void *L, const char *usage) {
|
||
void *fs = nullptr;
|
||
if (Game::Lua::Type(L, 1) == Game::Lua::TYPE_TABLE)
|
||
fs = Game::Lua::ResolveFontString(L, 1, /*raiseError=*/false);
|
||
if (fs == nullptr)
|
||
Game::Lua::Error(L, "%s", usage);
|
||
return fs;
|
||
}
|
||
|
||
int __fastcall Script_GetStringHeight(void *L) {
|
||
void *fs = ResolveSelf(L, "Usage: fontstring:GetStringHeight()");
|
||
if (fs == nullptr)
|
||
return 0;
|
||
const float h = reinterpret_cast<StringHeightInternal_t>(
|
||
Offsets::FUN_FONTSTRING_STRING_HEIGHT)(fs);
|
||
Game::Lua::PushNumber(L, InternalToPixel(h));
|
||
return 1;
|
||
}
|
||
|
||
int __fastcall Script_GetUnboundedStringWidth(void *L) {
|
||
void *fs = ResolveSelf(L, "Usage: fontstring:GetUnboundedStringWidth()");
|
||
if (fs == nullptr)
|
||
return 0;
|
||
const char *text = Game::Read<const char *>(fs, Offsets::OFF_FONTSTRING_TEXT);
|
||
if (text == nullptr || *text == '\0') {
|
||
Game::Lua::PushNumber(L, 0.0);
|
||
return 1;
|
||
}
|
||
const float w = reinterpret_cast<MeasureSubstring_t>(
|
||
Offsets::FUN_FONTSTRING_MEASURE_SUBSTRING)(fs, nullptr, text, 0);
|
||
Game::Lua::PushNumber(L, InternalToPixel(w));
|
||
return 1;
|
||
}
|
||
|
||
int __fastcall Script_GetNumLines(void *L) {
|
||
void *fs = ResolveSelf(L, "Usage: fontstring:GetNumLines()");
|
||
if (fs == nullptr)
|
||
return 0;
|
||
const char *text = Game::Read<const char *>(fs, Offsets::OFF_FONTSTRING_TEXT);
|
||
if (text == nullptr || *text == '\0') {
|
||
Game::Lua::PushNumber(L, 0.0);
|
||
return 1;
|
||
}
|
||
// Render truth first: the built node's line count. Zero until the node
|
||
// paints once (hidden fs, mid-rebuild) — fall back below.
|
||
void *block = Game::Read<void *>(fs, Offsets::OFF_FONTSTRING_TEXT_BLOCK);
|
||
if (block != nullptr) {
|
||
void *node = Game::Read<void *>(block, Offsets::OFF_TEXTBLOCK_NODE);
|
||
if (node != nullptr) {
|
||
const int built = Game::Read<int>(node, Offsets::OFF_TEXT_NODE_BUILT_LINES);
|
||
if (built > 0) {
|
||
Game::Lua::PushNumber(L, static_cast<double>(built));
|
||
return 1;
|
||
}
|
||
}
|
||
}
|
||
// Unbuilt: the engine's own break-array computer, fed the fs's wrap
|
||
// budget (see WrapBudget's scale note). An unresolved rect (0 width)
|
||
// means no wrap constraint exists yet — one line, like a fresh
|
||
// single-anchor fs.
|
||
const float width = WrapBudget(fs);
|
||
if (width <= 0.0f) {
|
||
Game::Lua::PushNumber(L, 1.0);
|
||
return 1;
|
||
}
|
||
int breaks[64];
|
||
uint32_t lines = reinterpret_cast<BreakArray_t>(Offsets::FUN_FONTSTRING_BREAK_ARRAY)(
|
||
fs, nullptr, text, width, breaks, 64);
|
||
if (lines > 64u)
|
||
lines = 64u;
|
||
if (lines == 0u)
|
||
lines = 1u;
|
||
Game::Lua::PushNumber(L, static_cast<double>(lines));
|
||
return 1;
|
||
}
|
||
|
||
int __fastcall Script_GetWrappedWidth(void *L) {
|
||
void *fs = ResolveSelf(L, "Usage: fontstring:GetWrappedWidth()");
|
||
if (fs == nullptr)
|
||
return 0;
|
||
const char *text = Game::Read<const char *>(fs, Offsets::OFF_FONTSTRING_TEXT);
|
||
if (text == nullptr || *text == '\0') {
|
||
Game::Lua::PushNumber(L, 0.0);
|
||
return 1;
|
||
}
|
||
auto measure =
|
||
reinterpret_cast<MeasureSubstring_t>(Offsets::FUN_FONTSTRING_MEASURE_SUBSTRING);
|
||
// The fs's wrap budget (see WrapBudget's scale note). Without one
|
||
// (unresolved rect) nothing wraps, and the rendered width IS the
|
||
// one-line width.
|
||
const float budget = WrapBudget(fs);
|
||
if (budget <= 0.0f) {
|
||
Game::Lua::PushNumber(L, InternalToPixel(measure(fs, nullptr, text, 0)));
|
||
return 1;
|
||
}
|
||
// The tooltip auto-size's own recipe (FUN_00530640): break positions from
|
||
// the break-array computer, then the widest per-segment measure. Both
|
||
// callees are icon-aware through their co-hooks, and a segment-final icon
|
||
// reports its ink edge — so this is the rendered width, wrap and icons
|
||
// included.
|
||
int breaks[64];
|
||
uint32_t segs = reinterpret_cast<BreakArray_t>(Offsets::FUN_FONTSTRING_BREAK_ARRAY)(
|
||
fs, nullptr, text, budget, breaks, 64);
|
||
if (segs > 64u)
|
||
segs = 64u;
|
||
if (segs <= 1u) {
|
||
Game::Lua::PushNumber(L, InternalToPixel(measure(fs, nullptr, text, 0)));
|
||
return 1;
|
||
}
|
||
int len = 0;
|
||
while (len < 0x4000 && text[len] != '\0')
|
||
++len;
|
||
float widest = 0.0f;
|
||
for (uint32_t i = 0; i < segs; ++i) {
|
||
const int start = breaks[i];
|
||
int end = (i + 1 < segs) ? breaks[i + 1] : len;
|
||
if (start < 0 || start >= end || end > len)
|
||
continue;
|
||
// A segment runs to the NEXT segment's start, which includes the
|
||
// whitespace the wrap consumed — the render never draws it, and a
|
||
// trailing space also flips the last real letter from ink to
|
||
// full-advance treatment (+~1.5px, measured). Trim to what renders.
|
||
while (end > start && (text[end - 1] == ' ' || text[end - 1] == '\n' ||
|
||
text[end - 1] == '\r' || text[end - 1] == '\t'))
|
||
--end;
|
||
if (start >= end)
|
||
continue;
|
||
const float w = measure(fs, nullptr, text + start, end - start);
|
||
if (w > widest)
|
||
widest = w;
|
||
}
|
||
Game::Lua::PushNumber(L, InternalToPixel(widest));
|
||
return 1;
|
||
}
|
||
|
||
int __fastcall Script_GetLineHeight(void *L) {
|
||
void *fs = ResolveSelf(L, "Usage: fontstring:GetLineHeight()");
|
||
if (fs == nullptr)
|
||
return 0;
|
||
const float h = reinterpret_cast<FsFontHeight_t>(Offsets::FUN_FONTSTRING_FONT_HEIGHT)(
|
||
fs, nullptr, 1);
|
||
Game::Lua::PushNumber(L, InternalToPixel(h));
|
||
return 1;
|
||
}
|
||
|
||
int __fastcall Script_IsTruncated(void *L) {
|
||
void *fs = ResolveSelf(L, "Usage: fontstring:IsTruncated()");
|
||
if (fs == nullptr)
|
||
return 0;
|
||
// Retail computes this by running the display-text resolver and strcmp'ing
|
||
// its result against the source (5.4.8 inner fn 0x0045E001). 1.12's resolver
|
||
// needs the LAID-OUT rect (fs+0x64), which is zero until a render pass, so a
|
||
// Lua-time re-call always sees an unbounded box and never truncates. Read the
|
||
// render's OWN output instead: the built text node keeps a copy of exactly
|
||
// the string it laid out (OFF_TEXT_NODE_TEXT) — the ellipsized "<prefix>..."
|
||
// form on truncation, else the source verbatim. So this reflects the last
|
||
// rendered layout (the fontstring must have drawn once), matching retail's
|
||
// "displayed vs full" semantics.
|
||
bool truncated = false;
|
||
void *block = Game::Read<void *>(fs, Offsets::OFF_FONTSTRING_TEXT_BLOCK);
|
||
const char *src = Game::Read<const char *>(fs, Offsets::OFF_FONTSTRING_TEXT);
|
||
if (block != nullptr && src != nullptr) {
|
||
void *node = Game::Read<void *>(block, Offsets::OFF_TEXTBLOCK_NODE);
|
||
const char *shown =
|
||
(node != nullptr) ? Game::Read<const char *>(node, Offsets::OFF_TEXT_NODE_TEXT)
|
||
: nullptr;
|
||
if (shown != nullptr) {
|
||
// A truncated display is exactly <source-prefix> + "...". Require the
|
||
// "..." suffix, a length strictly shorter than the source, and a
|
||
// matching byte-prefix. This rejects a STALE node — one left from a
|
||
// previous, different text after a fresh SetText, not yet re-laid-out
|
||
// — which would otherwise read as a truncation of the new text.
|
||
const size_t nlen = std::strlen(shown);
|
||
const size_t slen = std::strlen(src);
|
||
if (nlen >= 3 && nlen < slen && shown[nlen - 3] == '.' &&
|
||
shown[nlen - 2] == '.' && shown[nlen - 1] == '.' &&
|
||
std::memcmp(shown, src, nlen - 3) == 0)
|
||
truncated = true;
|
||
}
|
||
}
|
||
Game::Lua::PushBool(L, truncated);
|
||
return 1;
|
||
}
|
||
|
||
int __fastcall Script_SetMaxLines(void *L) {
|
||
void *fs = ResolveSelf(L, "Usage: fontstring:SetMaxLines(maxLines)");
|
||
if (fs == nullptr)
|
||
return 0;
|
||
// <= 0 or a non-number means "no cap" — the engine treats 0 as unlimited.
|
||
int maxLines = 0;
|
||
if (Game::Lua::IsNumber(L, 2)) {
|
||
const double n = Game::Lua::ToNumber(L, 2);
|
||
if (n > 0.0)
|
||
maxLines = static_cast<int>(n);
|
||
}
|
||
if (maxLines != Game::Read<int>(fs, Offsets::OFF_FONTSTRING_MAX_LINES)) {
|
||
Game::Ref<int>(fs, Offsets::OFF_FONTSTRING_MAX_LINES) = maxLines;
|
||
InvalidateLayout(fs);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int __fastcall Script_GetMaxLines(void *L) {
|
||
void *fs = ResolveSelf(L, "Usage: fontstring:GetMaxLines()");
|
||
if (fs == nullptr)
|
||
return 0;
|
||
Game::Lua::PushNumber(
|
||
L, static_cast<double>(Game::Read<int>(fs, Offsets::OFF_FONTSTRING_MAX_LINES)));
|
||
return 1;
|
||
}
|
||
|
||
int __fastcall Script_SetFormattedText(void *L) {
|
||
void *fs = nullptr;
|
||
if (Game::Lua::Type(L, 1) == Game::Lua::TYPE_TABLE)
|
||
fs = Game::Lua::ResolveFontString(L, 1, /*raiseError=*/false);
|
||
if (fs == nullptr || !Game::Lua::IsString(L, 2)) {
|
||
Game::Lua::Error(L, "Usage: fontstring:SetFormattedText(\"format\"[, ...])");
|
||
return 0;
|
||
}
|
||
const int top = Game::Lua::GetTop(L);
|
||
Game::Lua::CheckStack(L, top + 4);
|
||
Game::Lua::PushCClosure(
|
||
L, reinterpret_cast<Game::Lua::CFunction>(Offsets::FUN_LUA_STR_FORMAT), 0);
|
||
for (int i = 2; i <= top; ++i)
|
||
Game::Lua::PushValue(L, i);
|
||
if (Game::Lua::PCall(L, top - 1, 1, 0) != 0) {
|
||
const char *msg = Game::Lua::ToString(L, -1);
|
||
Game::Lua::Error(L, "%s", (msg != nullptr) ? msg : "SetFormattedText: format failed");
|
||
return 0;
|
||
}
|
||
const char *result = Game::Lua::ToString(L, -1);
|
||
reinterpret_cast<FsSetText_t>(Offsets::FUN_FONTSTRING_SET_TEXT)(
|
||
fs, nullptr, (result != nullptr) ? result : "", 0);
|
||
Game::Lua::SetTop(L, top);
|
||
return 0;
|
||
}
|
||
|
||
const Game::Lua::FrameMethodEntry g_methods[] = {
|
||
{"GetStringHeight", &Script_GetStringHeight},
|
||
{"GetUnboundedStringWidth", &Script_GetUnboundedStringWidth},
|
||
{"GetWrappedWidth", &Script_GetWrappedWidth},
|
||
{"GetNumLines", &Script_GetNumLines},
|
||
{"GetLineHeight", &Script_GetLineHeight},
|
||
{"IsTruncated", &Script_IsTruncated},
|
||
{"SetMaxLines", &Script_SetMaxLines},
|
||
{"GetMaxLines", &Script_GetMaxLines},
|
||
{"SetFormattedText", &Script_SetFormattedText},
|
||
};
|
||
|
||
void RegisterLuaFunctions() {
|
||
Game::Lua::RegisterFrameMethods(
|
||
reinterpret_cast<void *>(Offsets::VAR_FONTSTRING_METHOD_REGISTRY), g_methods,
|
||
static_cast<int>(sizeof(g_methods) / sizeof(g_methods[0])));
|
||
}
|
||
|
||
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
||
|
||
} // namespace
|
||
} // namespace FontString::Metrics
|