fix(texture): correct vertex-offset units and the corner-store contract (#26)

* fix(texture): correct vertex-offset units and the corner-store contract

The SetVertexOffset/SetRotation corner writes were wrong in four coupled
ways, found by driving pixel-ruler and wedge fixtures against a raw
corner-array readback:

- Offsets converted px->anchor with the global 1024-normalized factor
  alone, so a region scaled 0.9 got every offset 1/0.9 too large (a 24px
  request measured at 26.67px). Offsets are now stored in the caller's
  LOCAL pixels and folded through the region's live effective scale
  (+0x7C) inside WriteCorners, which also makes them track later scale
  changes. Verified at two scale points (0.9 and 0.45): a 24px offset
  lands at 24.00px on both.

- The anchor space is Y-DOWN (a rect reads top=0.222 < bottom=0.277),
  so +offsetY -- up, the retail contract -- is numerically negative
  there. It was added positive, sending every vertical offset the wrong
  way.

- The draw consumes the +0xD4 array with y INVERTED about the rect's
  horizontal midline, and CULLS a quad whose slot y-parity flips: quads
  stored at their target positions rendered as exact y-mirrors of the
  stored corners, and mirroring the values in place culled every
  transformed quad, including a plain rotated square. Each corner's
  mirrored data is therefore written into its VERTICAL PARTNER's slot
  (BL<->TL, BR<->TR): positions land on target after the draw's flip,
  and the slot parity keeps the winding the draw accepts. For an
  axis-aligned rect this degenerates to exactly what the engine itself
  writes -- which is why none of it was visible on plain rects or
  centered squares, both mirror-invariant as point sets.

- With that store contract, the y-down-transposed rotation matrix is
  the one that renders a positive angle counter-clockwise (settled with
  a rotated-bar fixture; squares and near-equilateral arrows are
  direction-blind).

Only regions carrying an active transform are affected: the corner-store
co-hook passes untracked regions through unchanged.

* feat(texture): GetCorners debug binding

texture:GetCorners() returns the raw drawn-quad corner array (+0xD4)
and the resolved layout rect -- 12 numbers, no unit conversion.
Diagnostic tooling: comparing stored corners against rendered pixels is
what made the corner-store contract measurable from Lua. Kept for
future transform triage; note that with the mirrored-partner store the
raw values deliberately differ from the on-screen positions.
This commit is contained in:
fuffc
2026-08-18 17:34:08 -05:00
committed by GitHub
parent 6b13368e65
commit 3ab690ac53
+85 -23
View File
@@ -25,11 +25,12 @@
// transform is written once and costs nothing per frame; a moving/resizing
// region re-transforms automatically.
//
// Units: rotation is scale-invariant, but a vertex offset has a magnitude, so
// the Lua offset (UI coordinate units, like SetPoint's x/y) is converted to the
// engine's internal layout space with the same factor Tooltip::LinePool uses for
// engine SetPoint (px * MUL / (DIV * 1024)). +offsetY is up (WoW UI space is
// Y-up — the same convention that makes a positive rotation angle turn CCW).
// Units: rotation is scale-invariant, but a vertex offset has a magnitude. The
// Lua offset is in the texture's LOCAL pixels (like SetPoint's x/y), stored
// raw, and converted to the engine's internal layout space inside WriteCorners
// — see the y-down and effective-scale notes there. The retail contract holds
// at the API surface: +offsetY moves a corner up on screen, a positive angle
// turns counter-clockwise on screen.
//
// Corner order at +0xD4 is BL, TL, BR, TR. Retail's vertex indices map onto
// those slots via VertexSlot(); the UPPER_LEFT_VERTEX / … globals are published
@@ -57,8 +58,8 @@ namespace {
struct Xf {
float angle = 0.0f; // radians, 0 = no rotation
float cxN = 0.5f, cyN = 0.5f; // rotation pivot, normalized in the rect
float offX[4] = {0, 0, 0, 0}; // per-corner offset, internal units, BL/TL/BR/TR
float offY[4] = {0, 0, 0, 0};
float offX[4] = {0, 0, 0, 0}; // per-corner offset, CALLER's local px
float offY[4] = {0, 0, 0, 0}; // (+y up), BL/TL/BR/TR; converted at write
bool active() const {
if (angle != 0.0f)
@@ -81,9 +82,10 @@ using GetRect_t = int(__fastcall *)(void *anchor, void *edx, float *outRect);
// FUN_REGION_TEXCOORD_CROP — __thiscall(region, float rect[4]) (rect in/out).
using Crop_t = void(__fastcall *)(void *region, void *edx, float *rect);
// UI coordinate units → internal layout space (the same conversion
// Tooltip::LinePool applies before calling engine SetPoint; inverse of
// FontString::Metrics's InternalToPixel).
// 1024-normalized UI pixels → internal layout (anchor) units — the same
// conversion Tooltip::LinePool applies before calling engine SetPoint. A
// region's LOCAL pixels must be folded through its effective scale (+0x7C)
// before this factor applies; WriteCorners does that.
float PixelToInternal(float px) {
const float mul = *reinterpret_cast<const float *>(Offsets::VAR_UI_COORD_SCALE_MUL);
const float div = *reinterpret_cast<const float *>(Offsets::VAR_UI_COORD_SCALE_DIV);
@@ -91,13 +93,6 @@ float PixelToInternal(float px) {
return 0.0f;
return px * mul / (div * Offsets::UI_COORD_SCALE_UNIT);
}
float InternalToPixel(float v) {
const float mul = *reinterpret_cast<const float *>(Offsets::VAR_UI_COORD_SCALE_MUL);
const float div = *reinterpret_cast<const float *>(Offsets::VAR_UI_COORD_SCALE_DIV);
if (mul == 0.0f)
return 0.0f;
return v * div * Offsets::UI_COORD_SCALE_UNIT / mul;
}
// Retail vertex index → our +0xD4 corner slot (BL=0, TL=1, BR=2, TR=3). The
// index values (UPPER_LEFT_VERTEX = 1, …) are the FrameXML-style globals defined
@@ -115,21 +110,61 @@ int VertexSlot(int vertexIndex) {
// Given the region's axis-aligned edges, compute the four transformed corner
// positions (rotate about the pivot, then add the per-corner offsets) and write
// them to region+0xD4. Corner order: BL, TL, BR, TR.
//
// The corner/anchor space is Y-DOWN — a box's rect reads top NUMERICALLY
// SMALLER than bottom (verified in-game via the GetCorners probe: t=0.222,
// b=0.277). Two consequences the math below encodes:
// - the retail contract is "positive angle = counter-clockwise ON SCREEN",
// which lands CCW through the mirrored-partner store below with the
// y-down-transposed rotation matrix (settled by a rotated-bar fixture:
// the standard matrix rendered clockwise);
// - the retail contract is "+offsetY = up on screen", which is numerically
// NEGATIVE here.
// Offsets are stored in the caller's LOCAL pixels and converted at write time:
// PixelToInternal maps 1024-normalized UI pixels to anchor units, so the
// region's live effective-scale chain (+0x7C) folds local px into that space
// first. Without it a region scaled 0.9 got every offset 1/0.9 too large
// (verified in-game: a 24px offset landed at 26.7px). Reading the scale at
// write time keeps offsets correct across later scale changes.
void WriteCorners(void *region, float left, float right, float top, float bottom,
const Xf &xf) {
const float cx = left + xf.cxN * (right - left);
const float cy = bottom + xf.cyN * (top - bottom);
const float c = std::cos(xf.angle);
const float s = std::sin(xf.angle);
float scale = *reinterpret_cast<const float *>(
reinterpret_cast<const char *>(region) + Offsets::OFF_REGION_EFFECTIVE_SCALE);
if (!(scale > 0.0f))
scale = 1.0f;
const float xs[4] = {left, left, right, right};
const float ys[4] = {bottom, top, bottom, top};
float *base = reinterpret_cast<float *>(
reinterpret_cast<char *>(region) + Offsets::OFF_SIMPLETEXTURE_CORNERS);
// Compute each corner's TARGET rect-space position first.
float tx[4], ty[4];
for (int i = 0; i < 4; ++i) {
const float dx = xs[i] - cx;
const float dy = ys[i] - cy;
base[i * 3 + 0] = cx + dx * c - dy * s + xf.offX[i]; // x
base[i * 3 + 1] = cy + dx * s + dy * c + xf.offY[i]; // y
tx[i] = cx + dx * c + dy * s + PixelToInternal(xf.offX[i] * scale);
ty[i] = cy - dx * s + dy * c - PixelToInternal(xf.offY[i] * scale);
}
// The draw consumes this array with y INVERTED about the rect's horizontal
// midline (a vertex stored at rect-space y renders at (top+bottom)-y), and
// it CULLS a quad whose slot parity flips (mirroring values in place made
// every fixture vanish -- inverted winding). Both established empirically
// via the 2026-08-18 texprobe fixture series: offset quads rendered as
// exact y-mirrors of their stored corners, the engine's own axis-aligned
// stores being mirror-invariant as a point set is what kept it invisible
// for plain rects and rotated squares. So each corner's mirrored data is
// written into its VERTICAL PARTNER's slot (BL<->TL, BR<->TR): positions
// land on target after the draw's flip, and the slot y-parity stays the
// engine's, keeping the winding it draws. For an axis-aligned rect this
// degenerates to exactly what the engine itself writes.
const float mid = top + bottom;
for (int i = 0; i < 4; ++i) {
const int p = i ^ 1; // vertical partner slot
base[i * 3 + 0] = tx[p];
base[i * 3 + 1] = mid - ty[p];
// z (base[i*3 + 2]) is left at 0 — the store/ctor already zeroed it.
}
}
@@ -413,8 +448,8 @@ int __fastcall Script_SetVertexOffset(void *L) {
? static_cast<float>(Game::Lua::ToNumber(L, 4))
: 0.0f;
Xf xf = Current(tex);
xf.offX[slot] = PixelToInternal(ox);
xf.offY[slot] = PixelToInternal(oy);
xf.offX[slot] = ox;
xf.offY[slot] = oy;
UpdateAndApply(tex, xf);
return 0;
}
@@ -431,16 +466,43 @@ int __fastcall Script_GetVertexOffset(void *L) {
return 0;
}
const Xf xf = Current(tex);
Game::Lua::PushNumber(L, InternalToPixel(xf.offX[slot]));
Game::Lua::PushNumber(L, InternalToPixel(xf.offY[slot]));
Game::Lua::PushNumber(L, xf.offX[slot]);
Game::Lua::PushNumber(L, xf.offY[slot]);
return 2;
}
// Debug binding: dump the drawn-quad corner array (+0xD4) and the resolved
// layout rect, raw internal units, no conversion. Returns 12 numbers:
// BLx,BLy, TLx,TLy, BRx,BRy, TRx,TRy, rectTop, rectLeft, rectBottom, rectRight.
// Diagnostic-only — for corner-transform triage from Lua.
int __fastcall Script_GetCorners(void *L) {
void *tex = nullptr;
if (Game::Lua::Type(L, 1) == Game::Lua::TYPE_TABLE)
tex = Game::Lua::ResolveObject(L, 1);
if (tex == nullptr) {
Game::Lua::Error(L, "Usage: texture:GetCorners()");
return 0;
}
const float *base = reinterpret_cast<const float *>(
reinterpret_cast<char *>(tex) + Offsets::OFF_SIMPLETEXTURE_CORNERS);
for (int i = 0; i < 4; ++i) {
Game::Lua::PushNumber(L, base[i * 3 + 0]);
Game::Lua::PushNumber(L, base[i * 3 + 1]);
}
float rect[4] = {0, 0, 0, 0};
void *anchor = reinterpret_cast<char *>(tex) + Offsets::OFF_REGION_ANCHOR;
reinterpret_cast<GetRect_t>(Offsets::FUN_REGION_GET_RECT)(anchor, nullptr, rect);
for (int i = 0; i < 4; ++i)
Game::Lua::PushNumber(L, rect[i]);
return 12;
}
const Game::Lua::FrameMethodEntry g_methods[] = {
{"SetRotation", &Script_SetRotation},
{"GetRotation", &Script_GetRotation},
{"SetVertexOffset", &Script_SetVertexOffset},
{"GetVertexOffset", &Script_GetVertexOffset},
{"GetCorners", &Script_GetCorners},
};
// FontString rotation: same GetRotation reader, a fontstring-specific