Files
ClassicAPI/src/xml/FrameLoad.h
T
Brues b032dc09ac refactor(texture): shared hooks for the texture constructor and corner store
MinHook takes one hook per address. Texture::Mask hooked the
CSimpleTexture constructor (0x0076FC40) to drop its state when pool memory
is reused, and Texture::Transform hooked the corner store (0x007705B0) to
turn the quad again after each layout. Texture wrap modes and tiling need
both hooks too, so each hook now has an owner that fans out to listeners:

- Texture::Construct runs its listeners before the constructor, on the
  memory it is about to build. Mask listens.
- Texture::CornerStore runs its listeners after the store. Transform
  listens.

The store writes only the corners. The layer batch reads them through a
pointer on every draw, so nothing marks the layer changed.

The XML number parse through SStrToFloat (0x0064AAA0) moves into
Xml::FloatAttr, which NativeSetters and Transform's rotation attributes
now share.
2026-11-01 18:30:32 -06:00

94 lines
4.4 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.
//
// You should have received a copy of the GNU General Public License along with
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
#pragma once
// Shared observer for the engine's frame XML loader FUN_XML_FRAME_LOAD
// (0x00769820) — `__thiscall(loader, node, status)`, where loader is the
// object's layout sub-object (object + OFF_XML_LOADER_SUBOBJECT). Every
// derived frame type's loader calls it first, and template inheritance
// re-enters it per inherited node, so one hook sees every frame element.
//
// MinHook allows ONE hook per address and more than one feature reads frame
// nodes (`Xml::ParentKey`'s parentKey / `<Scripts function=>`, and
// `Frame::Attributes`' `<Attributes>`), so — like `Frame::RunnerHook` and
// `Tick::WorldTick` — this module owns the hook and fans out. Subscribers run
// after the engine has loaded the node, in static-init order, which must not
// matter; `AutoSubscribeBefore` ones run before it (`Xml::Mixin` applies a
// frame's mixins there). Between the two the hook applies the intrinsic
// definition the node builds on (`Xml::Intrinsics::LoadScope`), then runs the
// loader through `Xml::Inherits::LoadFrame`, which reads `inherits` as a list. Declare a file-scope
// static const Xml::FrameLoad::AutoSubscribe _sub{&OnFrameNode};
namespace Xml {
// XML node accessors (OFF_XML_NODE_*): children are an intrusive list.
const void *FirstChild(const void *node);
const void *NextSibling(const void *node);
const char *Tag(const void *node);
bool TagIs(const void *node, const char *tag); // case-insensitive, like the engine's
// The engine's attribute getter; nullptr when the attribute is absent.
const char *Attr(const void *node, const char *name);
// A number attribute through the engine's SStrToFloat (the frame loader's
// `alpha` conversion); false, `out` untouched, when absent or empty.
bool FloatAttr(const void *node, const char *name, float &out);
// The template definition node `inherits=` resolves `name` to
// (FUN_XML_TEMPLATE_LOOKUP); nullptr when no template has that name.
const void *Template(const char *name);
// The context word the template `name` registered under — its owning addon's
// name, or nullptr for the client's own templates and for unknown names.
// 3.3.5 applies a template under this as `lua_gctag`.
const char *TemplateContext(const char *name);
// Loads `node` (with its own `inherits`) onto the frame `object` through the
// object's node loader `(object+0x24)->vtable[+8]` — the call the frame
// loader makes for an inherited node.
void LoadNode(void *object, const void *node, void *status);
// The engine's load-status sink: `status->Add(STATUS_WARNING, fmt, ...)`,
// the same warning the loaders log ("Couldn't find inherited node: %s").
void Warn(void *status, const char *fmt, const char *a, const char *b = nullptr,
const char *c = nullptr);
// Pushes `object`'s Lua wrapper and returns true, registering an unnamed,
// never-exposed object the way the engine's own lazy path does. Pushes
// nothing and returns false for a named object the engine has not registered
// yet (that is its pre-load's job, under the name), or when the wrapper's [0]
// does not point back at `object`.
bool PushWrapper(void *L, void *object);
// parentArray="key": pops the value on top of the stack and appends it to
// parent[key], where parent is the table at the absolute stack index
// `parentIdx`; parent[key] is created on first use.
void AppendToArray(void *L, int parentIdx, const char *key);
namespace FrameLoad {
using Observer = void (*)(void *object, const void *node, void *status);
struct AutoSubscribe {
explicit AutoSubscribe(Observer fn);
Observer fn;
AutoSubscribe *next;
};
// The same, run BEFORE the engine loads the node (and its inherits).
struct AutoSubscribeBefore {
explicit AutoSubscribeBefore(Observer fn);
Observer fn;
AutoSubscribeBefore *next;
};
} // namespace FrameLoad
} // namespace Xml