// 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 . // Mouse clicks and mouse motion as separate inputs: // `SetMouseClickEnabled`, `SetMouseMotionEnabled`, `SetPropagateMouseClicks` // and their getters, as retail has them (probed, docs/notes/mouse-motion-probe.md). // // Retail runs two walks over the frames under the cursor. Motion goes to the // top motion-enabled frame (Frame::MotionFocus, which skips frames whose // motion is off). A press goes to the top CLICK-enabled frame, whatever holds // the motion: a click on a motion-only frame reaches the click-enabled frame // under it, and a click-only frame takes the press without ever taking the // motion. A frame that propagates clicks passes the press on to the next // click-enabled frame under the cursor; each gets the press and then the // release, top-first. // // 1.12 has one mouse bit (OFF_FRAME_ENABLED_EVENTS bit 2), which puts the // frame in the mouse lists. It stays "click OR motion"; a frame with one half // off is in a set of its own. EnableMouse sets both halves, so it clears // that. IsMouseEnabled is both halves, still answered as the engine answers // it: 1 or nil, which addons compare with other 1/nil values. // // The press handler targets the pressed frame, else the focus (+0x7C); the // focus read is replaced with the click walk. While no frame has a half off // or propagates clicks the walk is the focus read, so nothing changes for a // UI that does not use them. Otherwise the walk reuses what the motion pass // already decided: a frame in the motion focus is hit; a motion-enabled frame // above the first focus frame was probed by the pass and missed; any other // click-enabled frame gets the engine's hit test. The press and release // dispatches run each extra target's button slot after the engine's. #include "frame/MouseInput.h" #include "Common.h" #include "Game.h" #include "Offsets.h" #include "baselib/Ascii.h" #include "frame/Destruction.h" #include "frame/MotionFocus.h" #include "xml/FrameLoad.h" #include #include #include #include #include namespace Frame::MouseInput { namespace { using EnableEvent_t = void(__thiscall *)(void *frame, int kind, int priority); using DisableEvent_t = void(__thiscall *)(void *frame, int kind); using Button_t = void(__thiscall *)(void *frame, const void *event); using HitTest_t = int(__thiscall *)(void *frame, const float *point); using NDCToDDC_t = void(__fastcall *)(float *outX, float *outY, float x, float y); // Frames with their mouse bit on and that half off. std::unordered_set g_clickOff; std::unordered_set g_motionOff; std::unordered_set g_propagatesClicks; struct Press { void *primary = nullptr; std::vector extras; }; Press g_pending; // the click walk's answer for the press being handled Press g_pressed; // the press whose release is outstanding uint8_t *Context() { return Game::Read(Offsets::VAR_UI_CONTEXT_PTR); } void Repick() { if (uint8_t *ctx = Context()) Game::Ref(ctx, Offsets::OFF_UI_CONTEXT_REPICK) = 1; } bool MouseBit(const void *frame) { return (Game::Read(frame, Offsets::OFF_FRAME_ENABLED_EVENTS) >> Offsets::SIMPLE_EVENT_MOUSE & 1) != 0; } bool ClickEnabled(void *frame) { return MouseBit(frame) && g_clickOff.count(frame) == 0; } bool PropagatesClicks(void *frame) { return g_propagatesClicks.count(frame) != 0; } void SetHalves(void *frame, bool click, bool motion) { const bool wasMotion = MotionEnabled(frame); const bool bit = click || motion; if (bit != MouseBit(frame)) { if (bit) reinterpret_cast(Offsets::FUN_FRAME_ENABLE_EVENT)(frame, Offsets::SIMPLE_EVENT_MOUSE, -1); else reinterpret_cast(Offsets::FUN_FRAME_DISABLE_EVENT)(frame, Offsets::SIMPLE_EVENT_MOUSE); } if (bit && !click) g_clickOff.insert(frame); else g_clickOff.erase(frame); if (bit && !motion) g_motionOff.insert(frame); else g_motionOff.erase(frame); if (MotionEnabled(frame) != wasMotion) Repick(); } // The click walk: the top click-enabled frame under the cursor, then the // next ones while the last one taken propagates clicks. void ClickTargets(uint8_t *ctx, std::vector &out) { void *const primary = Game::Read(ctx, Offsets::OFF_UI_CONTEXT_MOUSE_FOCUS); const float *mouse = Game::Ptr(ctx, Offsets::OFF_UI_CONTEXT_MOUSE_POSITION); float point[2] = {0.0f, 0.0f}; reinterpret_cast(Offsets::FUN_COORD_NDC_TO_DDC)(&point[0], &point[1], mouse[0], mouse[1]); const auto hitTest = reinterpret_cast(Offsets::FUN_FRAME_HIT_TEST); bool pastPrimary = primary == nullptr; for (int strata = Offsets::FRAME_STRATA_COUNT - 1; strata >= 0; --strata) { const uint8_t *queue = ctx + Offsets::OFF_UI_CONTEXT_EVENT_QUEUES + (strata + Offsets::FRAME_STRATA_COUNT * Offsets::SIMPLE_EVENT_MOUSE) * Offsets::EVENT_QUEUE_STRIDE; const uint32_t count = Game::Read(queue, Offsets::OFF_EVENT_QUEUE_COUNT); auto *const *nodes = Game::Read(queue, Offsets::OFF_EVENT_QUEUE_DATA); for (uint32_t i = 0; i < count; ++i) { void *frame = Game::Read(nodes[i], 0); if (frame == primary) pastPrimary = true; if (!ClickEnabled(frame)) continue; bool hit; if (Frame::MotionFocus::IsFocus(frame)) hit = true; else if (MotionEnabled(frame) && !pastPrimary) hit = false; else hit = hitTest(frame, point) != 0; if (!hit) continue; out.push_back(frame); if (!PropagatesClicks(frame)) return; } } } void *__stdcall PressTarget(uint8_t *ctx) { g_pending = Press{}; if (g_clickOff.empty() && g_motionOff.empty() && g_propagatesClicks.empty()) return Game::Read(ctx, Offsets::OFF_UI_CONTEXT_MOUSE_FOCUS); std::vector targets; ClickTargets(ctx, targets); if (targets.empty()) return nullptr; g_pending.primary = targets.front(); g_pending.extras.assign(targets.begin() + 1, targets.end()); return g_pending.primary; } void RunButton(void *frame, uintptr_t slot, const void *event) { const void *vtable = Game::Read(frame, 0); Game::Read(vtable, slot)(frame, event); } // Runs a list's button slot; entries a script nulls out are skipped. void RunExtras(std::vector extras, uintptr_t slot, const void *event) { for (void *f : extras) { if (f != nullptr && std::find(g_pressed.extras.begin(), g_pressed.extras.end(), f) != g_pressed.extras.end()) RunButton(f, slot, event); } } void __stdcall PressDispatch(uint8_t * /*ctx*/, void *frame, const void *event) { if (frame == g_pending.primary) g_pressed = g_pending; else if (frame != g_pressed.primary) g_pressed = Press{frame, {}}; g_pending = Press{}; RunButton(frame, Offsets::VTBL_FRAME_ON_MOUSE_DOWN, event); RunExtras(g_pressed.extras, Offsets::VTBL_FRAME_ON_MOUSE_DOWN, event); } void __stdcall ReleaseDispatch(uint8_t * /*ctx*/, void *frame, const void *event) { RunButton(frame, Offsets::VTBL_FRAME_ON_MOUSE_UP, event); if (frame == g_pressed.primary) RunExtras(g_pressed.extras, Offsets::VTBL_FRAME_ON_MOUSE_UP, event); if (Game::Read(event, Offsets::OFF_MOUSE_EVENT_BUTTONS) == 0) g_pressed = Press{}; } // Replaces `mov esi,[ebx+0x7C]; test esi,esi`: context in ebx; the `jz` // after it reads the flags this leaves. __declspec(naked) void PressTargetThunk() { __asm { push ebx call PressTarget mov esi, eax test esi, esi ret } } // Replaces the press's button-down call: frame in esi, event in eax, // context in ebx. __declspec(naked) void PressDispatchThunk() { __asm { push eax push esi push ebx call PressDispatch ret } } // Replaces the release's button-up call: frame in ebx, context in esi, the // event at ebp-0x3C. __declspec(naked) void ReleaseDispatchThunk() { __asm { lea eax, [ebp - 3Ch] push eax push ebx push esi call ReleaseDispatch ret } } const uint8_t kPressTarget[] = {0x8B, 0x73, 0x7C, 0x85, 0xF6}; const uint8_t kPressDispatch[] = {0x8B, 0x16, 0x50, 0x8B, 0xCE, 0xFF, 0x52, 0x68}; const uint8_t kReleaseDispatch[] = {0x8B, 0x03, 0x8D, 0x4D, 0xC4, 0x51, 0x8B, 0xCB, 0xFF, 0x50, 0x6C}; void Forget(void *frame) { for (Press *p : {&g_pending, &g_pressed}) std::replace(p->extras.begin(), p->extras.end(), frame, static_cast(nullptr)); } void OnFrameDestroyed(void *frame) { g_clickOff.erase(frame); g_motionOff.erase(frame); g_propagatesClicks.erase(frame); Forget(frame); } const Frame::Destruction::AutoSubscribe _destructionSub{&OnFrameDestroyed}; // `enableMouseClicks="true"` and `enableMouseMotion="true"` add their half; // `enableMouse="true"`, which the engine has applied by now, already holds // both. `propagateMouseInput="Clicks"` or `"Both"` propagates clicks. void OnFrameNode(void *object, const void *node, void * /*status*/) { const char *clicks = Xml::Attr(node, "enableMouseClicks"); const char *motion = Xml::Attr(node, "enableMouseMotion"); const bool addClick = clicks != nullptr && Game::StringToFlag(clicks); const bool addMotion = motion != nullptr && Game::StringToFlag(motion); if (addClick || addMotion) SetHalves(object, addClick || ClickEnabled(object), addMotion || MotionEnabled(object)); const char *propagate = Xml::Attr(node, "propagateMouseInput"); if (Ascii::EqualCI(propagate, "Clicks") || Ascii::EqualCI(propagate, "Both")) g_propagatesClicks.insert(object); } const Xml::FrameLoad::AutoSubscribe _xmlSub{&OnFrameNode}; int __fastcall Script_EnableMouse(void *L) { reinterpret_cast(Offsets::FUN_SCRIPT_FRAME_ENABLEMOUSE)(L); void *frame = Game::Lua::ResolveFrame(L, 1, false); if (frame != nullptr && (g_clickOff.erase(frame) | g_motionOff.erase(frame)) != 0) Repick(); return 0; } int __fastcall Script_IsMouseEnabled(void *L) { void *frame = Game::Lua::ResolveFrame(L, 1, false); if (frame != nullptr && (g_clickOff.count(frame) != 0 || g_motionOff.count(frame) != 0)) { Game::Lua::PushNil(L); return 1; } return reinterpret_cast(Offsets::FUN_SCRIPT_FRAME_ISMOUSEENABLED)(L); } int __fastcall Script_SetMouseClickEnabled(void *L) { void *frame = Game::Lua::ResolveFrame(L); if (frame == nullptr) return 0; SetHalves(frame, Game::Lua::ToFlag(L, 2), MotionEnabled(frame)); return 0; } int __fastcall Script_SetMouseMotionEnabled(void *L) { void *frame = Game::Lua::ResolveFrame(L); if (frame == nullptr) return 0; SetHalves(frame, ClickEnabled(frame), Game::Lua::ToFlag(L, 2)); return 0; } int __fastcall Script_IsMouseClickEnabled(void *L) { void *frame = Game::Lua::ResolveFrame(L); if (frame == nullptr) return 0; Game::Lua::PushBool(L, ClickEnabled(frame)); return 1; } int __fastcall Script_IsMouseMotionEnabled(void *L) { void *frame = Game::Lua::ResolveFrame(L); if (frame == nullptr) return 0; Game::Lua::PushBool(L, MotionEnabled(frame)); return 1; } int __fastcall Script_SetPropagateMouseClicks(void *L) { void *frame = Game::Lua::ResolveFrame(L); if (frame == nullptr) return 0; if (Game::Lua::ToFlag(L, 2)) g_propagatesClicks.insert(frame); else g_propagatesClicks.erase(frame); return 0; } int __fastcall Script_CanPropagateMouseClicks(void *L) { void *frame = Game::Lua::ResolveFrame(L); if (frame == nullptr) return 0; Game::Lua::PushBool(L, PropagatesClicks(frame)); return 1; } const Game::Lua::FrameMethodEntry g_methods[] = { {"EnableMouse", &Script_EnableMouse}, {"IsMouseEnabled", &Script_IsMouseEnabled}, {"SetMouseClickEnabled", &Script_SetMouseClickEnabled}, {"SetMouseMotionEnabled", &Script_SetMouseMotionEnabled}, {"IsMouseClickEnabled", &Script_IsMouseClickEnabled}, {"IsMouseMotionEnabled", &Script_IsMouseMotionEnabled}, {"SetPropagateMouseClicks", &Script_SetPropagateMouseClicks}, {"CanPropagateMouseClicks", &Script_CanPropagateMouseClicks}, }; const Game::Doc::Field kClickArgs[] = { Game::Doc::Req("enabled", "bool", "When true, the frame takes mouse clicks."), }; const Game::Doc::Field kMotionArgs[] = { Game::Doc::Req("enabled", "bool", "When true, the frame takes mouse motion: OnEnter and OnLeave."), }; const Game::Doc::Field kClickRets[] = { Game::Doc::Req("enabled", "bool", "True when the frame takes mouse clicks."), }; const Game::Doc::Field kMotionRets[] = { Game::Doc::Req("enabled", "bool", "True when the frame takes mouse motion."), }; const Game::Doc::Field kPropagateArgs[] = { Game::Doc::Req("propagate", "bool", "When true, a click on the frame also goes to the next frame under the cursor."), }; const Game::Doc::Field kPropagateRets[] = { Game::Doc::Req("propagate", "bool", "True when the frame passes mouse clicks on."), }; const Game::Doc::Function kSetClick{"Sets whether the frame takes mouse clicks.", kClickArgs, {}}; const Game::Doc::Function kSetMotion{"Sets whether the frame takes mouse motion.", kMotionArgs, {}}; const Game::Doc::Function kIsClick{"Returns whether the frame takes mouse clicks.", {}, kClickRets}; const Game::Doc::Function kIsMotion{"Returns whether the frame takes mouse motion.", {}, kMotionRets}; const Game::Doc::Function kSetPropagate{ "Sets whether a click on the frame also goes to the next frame under the cursor.", kPropagateArgs, {}}; const Game::Doc::Function kCanPropagate{"Returns whether the frame passes mouse clicks on.", {}, kPropagateRets}; const Game::Doc::Method g_methodDocs[] = { {"SetMouseClickEnabled", &kSetClick}, {"SetMouseMotionEnabled", &kSetMotion}, {"IsMouseClickEnabled", &kIsClick}, {"IsMouseMotionEnabled", &kIsMotion}, {"SetPropagateMouseClicks", &kSetPropagate}, {"CanPropagateMouseClicks", &kCanPropagate}, }; void RegisterLuaFunctions() { Common::ReplaceWithCall(Offsets::ADDR_UI_PRESS_TARGET, kPressTarget, sizeof kPressTarget, reinterpret_cast(&PressTargetThunk)); Common::ReplaceWithCall(Offsets::ADDR_UI_PRESS_DISPATCH, kPressDispatch, sizeof kPressDispatch, reinterpret_cast(&PressDispatchThunk)); Common::ReplaceWithCall(Offsets::ADDR_UI_RELEASE_DISPATCH, kReleaseDispatch, sizeof kReleaseDispatch, reinterpret_cast(&ReleaseDispatchThunk)); Game::Lua::RegisterFrameMethods(reinterpret_cast(Offsets::VAR_FRAME_METHOD_REGISTRY), g_methods, static_cast(sizeof(g_methods) / sizeof(g_methods[0])), g_methodDocs, static_cast(sizeof(g_methodDocs) / sizeof(g_methodDocs[0]))); } const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; } // namespace bool MotionEnabled(void *frame) { return MouseBit(frame) && g_motionOff.count(frame) == 0; } void OnInputRemoved(void *frame) { g_pressed.extras.erase(std::remove(g_pressed.extras.begin(), g_pressed.extras.end(), frame), g_pressed.extras.end()); } } // namespace Frame::MouseInput