src/managers/HookSystemManager.hpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#pragma once

#include "../defines.hpp"

#include <unordered_map>
#include <any>
#include <array>
#include <list>

#include <csetjmp>

#include "../plugins/PluginAPI.hpp"

// global typedef for hooked functions. Passes itself as a ptr when called, and `data` additionally.

typedef std::function<void(void*, SCallbackInfo& info, std::any data)> HOOK_CALLBACK_FN;

struct SCallbackFNPtr {
    WP<HOOK_CALLBACK_FN> fn;
    HANDLE               handle = nullptr;
};

#define EMIT_HOOK_EVENT(name, param)                                                                                                                                               \
    {                                                                                                                                                                              \
        static auto* const PEVENTVEC = g_pHookSystem->getVecForEvent(name);                                                                                                        \
        SCallbackInfo      info;                                                                                                                                                   \
        g_pHookSystem->emit(PEVENTVEC, info, param);                                                                                                                               \
    }

#define EMIT_HOOK_EVENT_CANCELLABLE(name, param)                                                                                                                                   \
    {                                                                                                                                                                              \
        static auto* const PEVENTVEC = g_pHookSystem->getVecForEvent(name);                                                                                                        \
        SCallbackInfo      info;                                                                                                                                                   \
        g_pHookSystem->emit(PEVENTVEC, info, param);                                                                                                                               \
        if (info.cancelled)                                                                                                                                                        \
            return;                                                                                                                                                                \
    }

class CHookSystemManager {
  public:
    CHookSystemManager();

    // returns the pointer to the function.
    // losing this pointer (letting it get destroyed)
    // will equal to unregistering the callback.
    [[nodiscard("Losing this pointer instantly unregisters the callback")]] SP<HOOK_CALLBACK_FN> hookDynamic(const std::string& event, HOOK_CALLBACK_FN fn,
                                                                                                             HANDLE handle = nullptr);
    void                                                                                         unhook(SP<HOOK_CALLBACK_FN> fn);

    void                         emit(std::vector<SCallbackFNPtr>* const callbacks, SCallbackInfo& info, std::any data = 0);
    std::vector<SCallbackFNPtr>* getVecForEvent(const std::string& event);

    bool                         m_bCurrentEventPlugin = false;
    jmp_buf                      m_jbHookFaultJumpBuf;

  private:
    std::unordered_map<std::string, std::vector<SCallbackFNPtr>> m_mRegisteredHooks;
};

inline std::unique_ptr<CHookSystemManager> g_pHookSystem;