2917 lines
113 KiB
C++
2917 lines
113 KiB
C++
#include <RED4ext/Api/ApiVersion.hpp>
|
|
#include <RED4ext/Api/v1/EMainReason.hpp>
|
|
#include <RED4ext/Api/v1/PluginHandle.hpp>
|
|
#include <RED4ext/Api/v1/PluginInfo.hpp>
|
|
#include <RED4ext/Api/v1/Runtime.hpp>
|
|
#include <RED4ext/Api/v1/Version.hpp>
|
|
#include <RED4ext/Common.hpp>
|
|
|
|
#include <windows.h>
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <chrono>
|
|
#include <cstring>
|
|
#include <cstdint>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <initializer_list>
|
|
#include <mutex>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <string_view>
|
|
|
|
namespace RED4ext::v1
|
|
{
|
|
struct Logger
|
|
{
|
|
void (*Trace)(PluginHandle aHandle, const char* aMessage);
|
|
void (*TraceF)(PluginHandle aHandle, const char* aFormat, ...);
|
|
void (*TraceW)(PluginHandle aHandle, const wchar_t* aMessage);
|
|
void (*TraceWF)(PluginHandle aHandle, const wchar_t* aFormat, ...);
|
|
void (*Debug)(PluginHandle aHandle, const char* aMessage);
|
|
void (*DebugF)(PluginHandle aHandle, const char* aFormat, ...);
|
|
void (*DebugW)(PluginHandle aHandle, const wchar_t* aMessage);
|
|
void (*DebugWF)(PluginHandle aHandle, const wchar_t* aFormat, ...);
|
|
void (*Info)(PluginHandle aHandle, const char* aMessage);
|
|
void (*InfoF)(PluginHandle aHandle, const char* aFormat, ...);
|
|
void (*InfoW)(PluginHandle aHandle, const wchar_t* aMessage);
|
|
void (*InfoWF)(PluginHandle aHandle, const wchar_t* aFormat, ...);
|
|
void (*Warn)(PluginHandle aHandle, const char* aMessage);
|
|
void (*WarnF)(PluginHandle aHandle, const char* aFormat, ...);
|
|
void (*WarnW)(PluginHandle aHandle, const wchar_t* aMessage);
|
|
void (*WarnWF)(PluginHandle aHandle, const wchar_t* aFormat, ...);
|
|
void (*Error)(PluginHandle aHandle, const char* aMessage);
|
|
void (*ErrorF)(PluginHandle aHandle, const char* aFormat, ...);
|
|
void (*ErrorW)(PluginHandle aHandle, const wchar_t* aMessage);
|
|
void (*ErrorWF)(PluginHandle aHandle, const wchar_t* aFormat, ...);
|
|
void (*Critical)(PluginHandle aHandle, const char* aMessage);
|
|
void (*CriticalF)(PluginHandle aHandle, const char* aFormat, ...);
|
|
void (*CriticalW)(PluginHandle aHandle, const wchar_t* aMessage);
|
|
void (*CriticalWF)(PluginHandle aHandle, const wchar_t* aFormat, ...);
|
|
};
|
|
|
|
struct GameState
|
|
{
|
|
bool (*OnEnter)(void* aApp);
|
|
bool (*OnUpdate)(void* aApp);
|
|
bool (*OnExit)(void* aApp);
|
|
};
|
|
|
|
struct GameStates
|
|
{
|
|
bool (*Add)(PluginHandle aHandle, uint32_t aType, GameState* aState);
|
|
};
|
|
|
|
struct Hooking
|
|
{
|
|
bool (*Attach)(PluginHandle aHandle, void* aTarget, void* aDetour, void** aOriginal);
|
|
bool (*Detach)(PluginHandle aHandle, void* aTarget);
|
|
};
|
|
|
|
struct Scripts
|
|
{
|
|
bool (*Add)(PluginHandle aHandle, const wchar_t* aPath);
|
|
bool (*RegisterNeverRefType)(const char* aType);
|
|
bool (*RegisterMixedRefType)(const char* aType);
|
|
};
|
|
|
|
struct Sdk;
|
|
|
|
struct Sdk
|
|
{
|
|
SemVer* runtime;
|
|
Logger* logger;
|
|
Hooking* hooking;
|
|
GameStates* gameStates;
|
|
Scripts* scripts;
|
|
};
|
|
}
|
|
|
|
namespace
|
|
{
|
|
constexpr uint32_t kGameStateRunning = 2;
|
|
constexpr bool kEnableVerboseJournalListenerHooks = false;
|
|
constexpr bool kEnableVerboseRouteObserverHooks = false;
|
|
constexpr bool kEnableVerboseMappinRouteState = false;
|
|
constexpr uintptr_t kGpsSystemTickRva = 0x0E6B62C;
|
|
constexpr uintptr_t kJournalTrackEntryImplRva = 0x05944FC;
|
|
constexpr uintptr_t kJournalListenerArrayOffset = 0x210;
|
|
constexpr uintptr_t kJournalListenerCountOffset = 0x21C;
|
|
constexpr uintptr_t kMappinSystemResolverRva = 0x02BB840;
|
|
constexpr uintptr_t kFrameMappinPathWrapperRva = 0x27C4314;
|
|
constexpr uintptr_t kFrameMappinPathCoreRva = 0x27BC1EC;
|
|
constexpr uintptr_t kSetSelectedMappinWrapperRva = 0x27C4A38;
|
|
constexpr uintptr_t kSetSelectedMappinByIdWrapperRva = 0x27C4944;
|
|
constexpr uintptr_t kSetSelectedMappinByPositionWrapperRva = 0x27C49C4;
|
|
constexpr uintptr_t kSetSelectedMappinCoreRva = 0x27C1684;
|
|
constexpr uintptr_t kTrackCustomPositionMappinWrapperRva = 0x27C4AAC;
|
|
constexpr uintptr_t kTrackCustomPositionMappinCoreRva = 0x27C2318;
|
|
constexpr uintptr_t kUntrackCustomPositionMappinWrapperRva = 0x27C4BA0;
|
|
constexpr uintptr_t kTrackMappinWrapperRva = 0x27C4AB4;
|
|
constexpr uintptr_t kTrackMappinCoreRva = 0x27C11D0;
|
|
constexpr uintptr_t kSetMappinTrackingAlternativeWrapperRva = 0x1246794;
|
|
constexpr uintptr_t kMappinUpdateCustomPositionSlotOffset = 0x1F0;
|
|
constexpr uintptr_t kMappinSetTrackedSlotOffset = 0x220;
|
|
constexpr uintptr_t kMappinClearTrackedSlotOffset = 0x228;
|
|
constexpr uintptr_t kMappinFramePathSlotOffset = 0x280;
|
|
constexpr uintptr_t kMappinPositionQuerySlotOffset = 0x2E0;
|
|
constexpr uintptr_t kMappinCreateCustomPositionSlotOffset = 0x2F0;
|
|
constexpr uintptr_t kMappinReleaseQuerySlotOffset = 0x368;
|
|
constexpr uintptr_t kMappinActiveRouteSlotOffset = 0x3A8;
|
|
constexpr uintptr_t kJournalListenerObjectiveVt28Rva = 0x0EA89A8;
|
|
constexpr uintptr_t kJournalListenerObjectiveVt30Rva = 0x0EA8958;
|
|
constexpr uintptr_t kJournalListenerRouteVt28Rva = 0x0E63F80;
|
|
constexpr uintptr_t kJournalListenerRouteVt30Rva = 0x0E63E6C;
|
|
constexpr uintptr_t kJournalListenerRouteAltVt28Rva = 0x0E63F00;
|
|
constexpr uintptr_t kJournalListenerRouteAltVt30Rva = 0x08D136C;
|
|
constexpr uintptr_t kJournalListenerUiVt28Rva = 0x0431A34;
|
|
constexpr uintptr_t kJournalListenerUiVt30Rva = 0x055A4E4;
|
|
constexpr uintptr_t kJournalListenerTrackerVt28Rva = 0x14DE238;
|
|
constexpr uintptr_t kJournalRouteBridgeRva = 0x0598250;
|
|
constexpr uintptr_t kMappinRouteEventEnqueueRva = 0x13763D8;
|
|
constexpr uintptr_t kMappinRouteEventHandlerRva = 0x0AA62D0;
|
|
constexpr uintptr_t kMappinRouteActivateRva = 0x0AA6330;
|
|
constexpr uintptr_t kMappinRouteDeactivateRva = 0x27ABD7C;
|
|
constexpr uintptr_t kRouteBuildCandidateRva = 0x05625A4;
|
|
constexpr uintptr_t kRouteObserver0ActivateRva = 0x0AA6610;
|
|
constexpr uintptr_t kRouteObserver1ActivateRva = 0x0AA6628;
|
|
constexpr uintptr_t kRouteObserver23ActivateRva = 0x0AA63E0;
|
|
constexpr uintptr_t kRouteObserver0DeactivateRva = 0x27B10C0;
|
|
constexpr uintptr_t kRouteObserver1DeactivateRva = 0x295D4A0;
|
|
constexpr uintptr_t kRouteObserver23DeactivateRva = 0x286A85C;
|
|
constexpr uintptr_t kObserver1SystemTypeGlobalRva = 0x342F6A8;
|
|
constexpr uintptr_t kObserver1ServiceLookupRva = 0x0287C44;
|
|
constexpr uintptr_t kObserver1ServiceRouteLookupSlotOffset = 0x220;
|
|
constexpr uintptr_t kRunGpsQueryBodyRva = 0x29BD128;
|
|
constexpr uintptr_t kUpdateGpsQueryBodyRva = 0x29BD254;
|
|
constexpr uintptr_t kGpsQuerySubmitRva = 0x070A42C;
|
|
constexpr uintptr_t kGpsQueryDispatchRva = 0x070A570;
|
|
constexpr uintptr_t kGpsQueryResultFetchRva = 0x07094B8;
|
|
constexpr uintptr_t kGpsQueryStatusRva = 0x0AA5704;
|
|
|
|
HMODULE gModule = nullptr;
|
|
std::mutex gLogMutex;
|
|
RED4ext::v1::PluginHandle gHandle = nullptr;
|
|
const RED4ext::v1::Sdk* gSdk = nullptr;
|
|
uint32_t gUpdateLogCount = 0;
|
|
bool gScannedExecutable = false;
|
|
uint32_t gGpsTickLogCount = 0;
|
|
uint32_t gJournalTrackEntryLogCount = 0;
|
|
uint32_t gJournalTrackEntryListenerDumpCount = 0;
|
|
uint32_t gFrameMappinPathWrapperLogCount = 0;
|
|
uint32_t gFrameMappinPathCoreLogCount = 0;
|
|
uint32_t gSetSelectedMappinWrapperLogCount = 0;
|
|
uint32_t gSetSelectedMappinByIdWrapperLogCount = 0;
|
|
uint32_t gSetSelectedMappinByPositionWrapperLogCount = 0;
|
|
uint32_t gSetSelectedMappinCoreLogCount = 0;
|
|
uint32_t gTrackCustomPositionMappinWrapperLogCount = 0;
|
|
uint32_t gTrackCustomPositionMappinCoreLogCount = 0;
|
|
uint32_t gUntrackCustomPositionMappinWrapperLogCount = 0;
|
|
uint32_t gTrackMappinWrapperLogCount = 0;
|
|
uint32_t gTrackMappinCoreLogCount = 0;
|
|
uint32_t gSetMappinTrackingAlternativeLogCount = 0;
|
|
uint32_t gMappinSystemSlotLogCount = 0;
|
|
uint32_t gMappinUpdateCustomPositionLogCount = 0;
|
|
uint32_t gMappinSetTrackedLogCount = 0;
|
|
uint32_t gMappinClearTrackedLogCount = 0;
|
|
uint32_t gMappinFramePathLogCount = 0;
|
|
uint32_t gMappinPositionQueryLogCount = 0;
|
|
uint32_t gMappinCreateCustomPositionLogCount = 0;
|
|
uint32_t gMappinReleaseQueryLogCount = 0;
|
|
uint32_t gMappinActiveRouteLogCount = 0;
|
|
uint32_t gJournalListenerObjectiveVt28LogCount = 0;
|
|
uint32_t gJournalListenerObjectiveVt30LogCount = 0;
|
|
uint32_t gJournalListenerRouteVt28LogCount = 0;
|
|
uint32_t gJournalListenerRouteVt30LogCount = 0;
|
|
uint32_t gJournalListenerRouteAltVt28LogCount = 0;
|
|
uint32_t gJournalListenerRouteAltVt30LogCount = 0;
|
|
uint32_t gJournalListenerUiVt28LogCount = 0;
|
|
uint32_t gJournalListenerUiVt30LogCount = 0;
|
|
uint32_t gJournalListenerTrackerVt28LogCount = 0;
|
|
uint32_t gJournalRouteBridgeLogCount = 0;
|
|
uint32_t gMappinRouteEventEnqueueLogCount = 0;
|
|
uint32_t gMappinRouteEventHandlerLogCount = 0;
|
|
uint32_t gMappinRouteActivateLogCount = 0;
|
|
uint32_t gMappinRouteDeactivateLogCount = 0;
|
|
uint32_t gRouteBuildCandidateLogCount = 0;
|
|
uint32_t gRouteObserver0ActivateLogCount = 0;
|
|
uint32_t gRouteObserver1ActivateLogCount = 0;
|
|
uint32_t gRouteObserver23ActivateLogCount = 0;
|
|
uint32_t gRouteObserver0DeactivateLogCount = 0;
|
|
uint32_t gRouteObserver1DeactivateLogCount = 0;
|
|
uint32_t gRouteObserver23DeactivateLogCount = 0;
|
|
uint32_t gObserver1ServiceLookupLogCount = 0;
|
|
uint32_t gObserver1ServiceRouteLookupLogCount = 0;
|
|
uint32_t gRunGpsQueryBodyLogCount = 0;
|
|
uint32_t gUpdateGpsQueryBodyLogCount = 0;
|
|
uint32_t gGpsQuerySubmitLogCount = 0;
|
|
uint32_t gGpsQueryDispatchLogCount = 0;
|
|
uint32_t gGpsQueryResultFetchLogCount = 0;
|
|
uint32_t gGpsQueryStatusLogCount = 0;
|
|
uint64_t gLogStartTick = 0;
|
|
uint64_t gLogFrequency = 0;
|
|
void* gMappinSetTrackedTarget = nullptr;
|
|
void* gMappinClearTrackedTarget = nullptr;
|
|
void* gMappinUpdateCustomPositionTarget = nullptr;
|
|
void* gMappinFramePathTarget = nullptr;
|
|
void* gMappinPositionQueryTarget = nullptr;
|
|
void* gMappinCreateCustomPositionTarget = nullptr;
|
|
void* gMappinReleaseQueryTarget = nullptr;
|
|
void* gMappinActiveRouteTarget = nullptr;
|
|
void* gObserver1ServiceRouteLookupTarget = nullptr;
|
|
bool gMappinSlotHookAttachAttempted = false;
|
|
bool gObserver1ServiceRouteLookupHookAttachAttempted = false;
|
|
|
|
struct TrackedGpsQuery
|
|
{
|
|
bool active = false;
|
|
uint32_t id = 0;
|
|
void* manager = nullptr;
|
|
uintptr_t submitReturnRva = 0;
|
|
uint32_t submitCall = 0;
|
|
uint32_t resultFetchCalls = 0;
|
|
uint32_t statusCalls = 0;
|
|
};
|
|
|
|
std::mutex gTrackedGpsQueryMutex;
|
|
std::array<TrackedGpsQuery, 32> gTrackedGpsQueries{};
|
|
uint32_t gTrackedGpsQueryNext = 0;
|
|
|
|
using ProbeFunc = void (*)(void* aThis, void* a2, void* a3, void* a4);
|
|
using JournalTrackEntryFunc = void (*)(void* aThis, void* aEntryHandle);
|
|
using ScriptNativeVoidFunc = void (*)(void* aThis, void* aStack, void* aResult);
|
|
using MappinSystemResolverFunc = void* (*)(void* aThis);
|
|
using FrameMappinPathCoreFunc = void (*)(void* aThis, uint32_t aPathKind, void* a3, void* aPathRect);
|
|
using SetSelectedMappinCoreFunc = void (*)(void* aThis, void* aMappinHandle);
|
|
using TrackCustomPositionMappinCoreFunc = void (*)(void* aThis);
|
|
using TrackMappinCoreFunc = void (*)(void* aThis, void* aMappinHandle);
|
|
using MappinUpdateCustomPositionFunc = void (*)(void* aSystem, void* aHandle, void* aPositionData);
|
|
using MappinSetTrackedFunc = void (*)(void* aSystem, void* aMappinId);
|
|
using MappinClearTrackedFunc = void (*)(void* aSystem);
|
|
using MappinFramePathFunc = void (*)(void* aSystem, uint32_t aPathKind, void* aResult);
|
|
using MappinPositionQueryFunc = void* (*)(void* aSystem, void* a2, void* a3, void* a4, void* a5);
|
|
using MappinCreateCustomPositionFunc = void* (*)(void* aSystem, void* aName, void* aParams, void* aPositionData);
|
|
using MappinReleaseQueryFunc = void (*)(void* aSystem, void* aHandle);
|
|
using MappinActiveRouteFunc = void* (*)(void* aSystem);
|
|
using JournalListenerCallbackFunc = void (*)(void* aListener, void* aEvent);
|
|
using JournalRouteBridgeFunc = bool (*)(void* aThis, void* aEntryHandle);
|
|
using MappinRouteEventEnqueueFunc = void (*)(void* aSystem, uint32_t aRouteId, uint8_t aActive);
|
|
using MappinRouteEventHandlerFunc = void (*)(void* aEvent, void* aRouteHandle);
|
|
using MappinRouteToggleFunc = void (*)(void* aSystem, uint64_t aRouteKey);
|
|
using RouteBuildCandidateFunc = void (*)(void* aThis, uint32_t aRouteId, uint32_t aAltRouteId,
|
|
uint32_t aPreviousRouteId, void* aRoutePositionData,
|
|
void* aPrimaryDescriptor, void* aSecondaryDescriptor, void* aRouteData88,
|
|
void* aRouteData108, void* aRouteData114, uint8_t aFlag,
|
|
uint32_t aMode);
|
|
using RouteObserverCallbackFunc = void (*)(void* aObserver, void* aRouteEntry);
|
|
using Observer1ServiceLookupFunc = void* (*)(void* aServiceOwner, void* aSystemType);
|
|
using Observer1ServiceRouteLookupFunc = void (*)(void* aService, void* aOut, uint32_t aRouteId);
|
|
using RunGpsQueryBodyFunc = bool (*)(void* aThis, void* aStart, void* aEnd, int32_t* aOutQueryId);
|
|
using UpdateGpsQueryBodyFunc = bool (*)(void* aThis, uint32_t aQueryId, void* aOutPoints, void* aOutError);
|
|
using GpsQuerySubmitFunc = int32_t (*)(void* aManager, void* aQuery);
|
|
using GpsQueryDispatchFunc = void (*)(void* aRuntimeQuery, void* aTargetPosition, void* aArg3, void* aArg4);
|
|
using GpsQueryResultFetchFunc = bool (*)(void* aManager, uint32_t aQueryId, void* aOutPath);
|
|
using GpsQueryStatusFunc = int32_t (*)(void* aManager, uint32_t aQueryId);
|
|
ProbeFunc gOriginalGpsSystemTick = nullptr;
|
|
JournalTrackEntryFunc gOriginalJournalTrackEntry = nullptr;
|
|
ScriptNativeVoidFunc gOriginalFrameMappinPathWrapper = nullptr;
|
|
FrameMappinPathCoreFunc gOriginalFrameMappinPathCore = nullptr;
|
|
ScriptNativeVoidFunc gOriginalSetSelectedMappinWrapper = nullptr;
|
|
ScriptNativeVoidFunc gOriginalSetSelectedMappinByIdWrapper = nullptr;
|
|
ScriptNativeVoidFunc gOriginalSetSelectedMappinByPositionWrapper = nullptr;
|
|
SetSelectedMappinCoreFunc gOriginalSetSelectedMappinCore = nullptr;
|
|
ScriptNativeVoidFunc gOriginalTrackCustomPositionMappinWrapper = nullptr;
|
|
TrackCustomPositionMappinCoreFunc gOriginalTrackCustomPositionMappinCore = nullptr;
|
|
ScriptNativeVoidFunc gOriginalUntrackCustomPositionMappinWrapper = nullptr;
|
|
ScriptNativeVoidFunc gOriginalTrackMappinWrapper = nullptr;
|
|
TrackMappinCoreFunc gOriginalTrackMappinCore = nullptr;
|
|
ScriptNativeVoidFunc gOriginalSetMappinTrackingAlternativeWrapper = nullptr;
|
|
MappinUpdateCustomPositionFunc gOriginalMappinUpdateCustomPosition = nullptr;
|
|
MappinSetTrackedFunc gOriginalMappinSetTracked = nullptr;
|
|
MappinClearTrackedFunc gOriginalMappinClearTracked = nullptr;
|
|
MappinFramePathFunc gOriginalMappinFramePath = nullptr;
|
|
MappinPositionQueryFunc gOriginalMappinPositionQuery = nullptr;
|
|
MappinCreateCustomPositionFunc gOriginalMappinCreateCustomPosition = nullptr;
|
|
MappinReleaseQueryFunc gOriginalMappinReleaseQuery = nullptr;
|
|
MappinActiveRouteFunc gOriginalMappinActiveRoute = nullptr;
|
|
JournalListenerCallbackFunc gOriginalJournalListenerObjectiveVt28 = nullptr;
|
|
JournalListenerCallbackFunc gOriginalJournalListenerObjectiveVt30 = nullptr;
|
|
JournalListenerCallbackFunc gOriginalJournalListenerRouteVt28 = nullptr;
|
|
JournalListenerCallbackFunc gOriginalJournalListenerRouteVt30 = nullptr;
|
|
JournalListenerCallbackFunc gOriginalJournalListenerRouteAltVt28 = nullptr;
|
|
JournalListenerCallbackFunc gOriginalJournalListenerRouteAltVt30 = nullptr;
|
|
JournalListenerCallbackFunc gOriginalJournalListenerUiVt28 = nullptr;
|
|
JournalListenerCallbackFunc gOriginalJournalListenerUiVt30 = nullptr;
|
|
JournalListenerCallbackFunc gOriginalJournalListenerTrackerVt28 = nullptr;
|
|
JournalRouteBridgeFunc gOriginalJournalRouteBridge = nullptr;
|
|
MappinRouteEventEnqueueFunc gOriginalMappinRouteEventEnqueue = nullptr;
|
|
MappinRouteEventHandlerFunc gOriginalMappinRouteEventHandler = nullptr;
|
|
MappinRouteToggleFunc gOriginalMappinRouteActivate = nullptr;
|
|
MappinRouteToggleFunc gOriginalMappinRouteDeactivate = nullptr;
|
|
RouteBuildCandidateFunc gOriginalRouteBuildCandidate = nullptr;
|
|
RouteObserverCallbackFunc gOriginalRouteObserver0Activate = nullptr;
|
|
RouteObserverCallbackFunc gOriginalRouteObserver1Activate = nullptr;
|
|
RouteObserverCallbackFunc gOriginalRouteObserver23Activate = nullptr;
|
|
RouteObserverCallbackFunc gOriginalRouteObserver0Deactivate = nullptr;
|
|
RouteObserverCallbackFunc gOriginalRouteObserver1Deactivate = nullptr;
|
|
RouteObserverCallbackFunc gOriginalRouteObserver23Deactivate = nullptr;
|
|
Observer1ServiceLookupFunc gOriginalObserver1ServiceLookup = nullptr;
|
|
Observer1ServiceRouteLookupFunc gOriginalObserver1ServiceRouteLookup = nullptr;
|
|
RunGpsQueryBodyFunc gOriginalRunGpsQueryBody = nullptr;
|
|
UpdateGpsQueryBodyFunc gOriginalUpdateGpsQueryBody = nullptr;
|
|
GpsQuerySubmitFunc gOriginalGpsQuerySubmit = nullptr;
|
|
GpsQueryDispatchFunc gOriginalGpsQueryDispatch = nullptr;
|
|
GpsQueryResultFetchFunc gOriginalGpsQueryResultFetch = nullptr;
|
|
GpsQueryStatusFunc gOriginalGpsQueryStatus = nullptr;
|
|
|
|
std::filesystem::path GetLogPath()
|
|
{
|
|
wchar_t modulePath[MAX_PATH]{};
|
|
if (gModule && GetModuleFileNameW(gModule, modulePath, MAX_PATH) > 0)
|
|
{
|
|
auto path = std::filesystem::path(modulePath);
|
|
return path.parent_path() / L"EdgeWeightGPS.log";
|
|
}
|
|
|
|
return std::filesystem::path(L"red4ext") / L"plugins" / L"EdgeWeightGPS" / L"EdgeWeightGPS.log";
|
|
}
|
|
|
|
void Log(std::string_view aMessage)
|
|
{
|
|
std::lock_guard lock(gLogMutex);
|
|
|
|
auto now = std::chrono::system_clock::now();
|
|
auto time = std::chrono::system_clock::to_time_t(now);
|
|
std::tm localTime{};
|
|
localtime_s(&localTime, &time);
|
|
|
|
std::ofstream out(GetLogPath(), std::ios::app);
|
|
if (!out)
|
|
{
|
|
return;
|
|
}
|
|
|
|
uint64_t elapsedMs = 0;
|
|
if (gLogStartTick && gLogFrequency)
|
|
{
|
|
LARGE_INTEGER counter{};
|
|
QueryPerformanceCounter(&counter);
|
|
elapsedMs = static_cast<uint64_t>((counter.QuadPart - gLogStartTick) * 1000 / gLogFrequency);
|
|
}
|
|
|
|
out << std::put_time(&localTime, "%Y-%m-%d %H:%M:%S") << "." << std::setw(3) << std::setfill('0')
|
|
<< elapsedMs % 1000 << std::setfill(' ') << " +" << elapsedMs << "ms " << aMessage << "\n";
|
|
}
|
|
|
|
void LogRed4ext(std::string_view aMessage)
|
|
{
|
|
Log(aMessage);
|
|
|
|
if (gSdk && gSdk->logger && gSdk->logger->Info && gHandle)
|
|
{
|
|
std::string text(aMessage);
|
|
gSdk->logger->Info(gHandle, text.c_str());
|
|
}
|
|
}
|
|
|
|
uintptr_t GetImageBase()
|
|
{
|
|
return reinterpret_cast<uintptr_t>(GetModuleHandleW(nullptr));
|
|
}
|
|
|
|
uintptr_t GetImageEnd()
|
|
{
|
|
const auto imageBase = GetImageBase();
|
|
if (!imageBase)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
const auto* dos = reinterpret_cast<const IMAGE_DOS_HEADER*>(imageBase);
|
|
if (dos->e_magic != IMAGE_DOS_SIGNATURE)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
const auto* nt = reinterpret_cast<const IMAGE_NT_HEADERS*>(imageBase + dos->e_lfanew);
|
|
if (nt->Signature != IMAGE_NT_SIGNATURE)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return imageBase + nt->OptionalHeader.SizeOfImage;
|
|
}
|
|
|
|
bool IsInImage(const void* aPointer)
|
|
{
|
|
const auto imageBase = GetImageBase();
|
|
const auto imageEnd = GetImageEnd();
|
|
const auto address = reinterpret_cast<uintptr_t>(aPointer);
|
|
return imageBase && imageEnd && address >= imageBase && address < imageEnd;
|
|
}
|
|
|
|
bool TryGetImageRva(const void* aPointer, uintptr_t& aRva)
|
|
{
|
|
if (!IsInImage(aPointer))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
aRva = reinterpret_cast<uintptr_t>(aPointer) - GetImageBase();
|
|
return true;
|
|
}
|
|
|
|
void AppendPointerWithRva(std::ostringstream& aLine, const char* aLabel, const void* aPointer)
|
|
{
|
|
aLine << " " << aLabel << "=" << aPointer;
|
|
|
|
if (IsInImage(aPointer))
|
|
{
|
|
const auto imageBase = GetImageBase();
|
|
const auto address = reinterpret_cast<uintptr_t>(aPointer);
|
|
aLine << " " << aLabel << "_rva=0x" << std::hex << (address - imageBase) << std::dec;
|
|
}
|
|
}
|
|
|
|
void AppendReturnRva(std::ostringstream& aLine, const void* aReturnAddress)
|
|
{
|
|
if (IsInImage(aReturnAddress))
|
|
{
|
|
const auto imageBase = GetImageBase();
|
|
const auto address = reinterpret_cast<uintptr_t>(aReturnAddress);
|
|
aLine << " ret_rva=0x" << std::hex << (address - imageBase) << std::dec;
|
|
}
|
|
}
|
|
|
|
void AppendHexValue(std::ostringstream& aLine, const char* aLabel, uint64_t aValue)
|
|
{
|
|
aLine << " " << aLabel << "=0x" << std::hex << aValue << std::dec;
|
|
}
|
|
|
|
void LogHookCall(const char* aName, uint32_t aCount, void* aThis, void* a2, void* a3, void* a4)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook " << aName << " call=" << aCount << " this=" << aThis << " a2=" << a2 << " a3=" << a3
|
|
<< " a4=" << a4;
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void LogScriptNativeCall(const char* aName, uint32_t aCount, void* aThis, void* aStack, void* aResult)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook " << aName << " call=" << aCount << " this=" << aThis << " stack=" << aStack
|
|
<< " result=" << aResult;
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void LogFrameMappinPathCoreCall(uint32_t aCount, void* aThis, uint32_t aPathKind, void* a3, void* aPathRect)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook FrameMappinPathCore call=" << aCount << " this=" << aThis << " pathKind=" << aPathKind
|
|
<< " a3=" << a3 << " pathRect=" << aPathRect;
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void LogSetSelectedMappinCoreCall(uint32_t aCount, void* aThis, void* aMappinHandle)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook SetSelectedMappinCore call=" << aCount << " this=" << aThis
|
|
<< " mappinHandle=" << aMappinHandle;
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void LogTrackCustomPositionMappinCoreCall(uint32_t aCount, void* aThis)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook TrackCustomPositionMappinCore call=" << aCount << " this=" << aThis;
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void LogTrackMappinCoreCall(uint32_t aCount, void* aThis, void* aMappinHandle)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook TrackMappinCore call=" << aCount << " this=" << aThis << " mappinHandle=" << aMappinHandle;
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void LogMappinSystemSlots(uint32_t aCount, void* aSystem, void* aVtable)
|
|
{
|
|
auto* vtable = reinterpret_cast<uint8_t*>(aVtable);
|
|
auto readSlot = [vtable](uintptr_t aOffset) -> void* {
|
|
if (!vtable)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
return *reinterpret_cast<void**>(vtable + aOffset);
|
|
};
|
|
|
|
std::ostringstream line;
|
|
line << "mappin-system slots call=" << aCount;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendPointerWithRva(line, "vtable", aVtable);
|
|
AppendPointerWithRva(line, "slot1f0", readSlot(kMappinUpdateCustomPositionSlotOffset));
|
|
AppendPointerWithRva(line, "slot220", readSlot(kMappinSetTrackedSlotOffset));
|
|
AppendPointerWithRva(line, "slot228", readSlot(kMappinClearTrackedSlotOffset));
|
|
AppendPointerWithRva(line, "slot250", readSlot(0x250));
|
|
AppendPointerWithRva(line, "slot280", readSlot(kMappinFramePathSlotOffset));
|
|
AppendPointerWithRva(line, "slot2e0", readSlot(kMappinPositionQuerySlotOffset));
|
|
AppendPointerWithRva(line, "slot2f0", readSlot(kMappinCreateCustomPositionSlotOffset));
|
|
AppendPointerWithRva(line, "slot368", readSlot(kMappinReleaseQuerySlotOffset));
|
|
AppendPointerWithRva(line, "slot3a8", readSlot(kMappinActiveRouteSlotOffset));
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void InspectAndHookMappinSystem(void* aThis);
|
|
|
|
const char* ReasonToString(RED4ext::v1::EMainReason aReason)
|
|
{
|
|
switch (aReason)
|
|
{
|
|
case RED4ext::v1::EMainReason::Load:
|
|
return "Load";
|
|
case RED4ext::v1::EMainReason::Unload:
|
|
return "Unload";
|
|
}
|
|
|
|
return "Unknown";
|
|
}
|
|
|
|
bool IsReadablePage(DWORD aProtect)
|
|
{
|
|
if ((aProtect & PAGE_GUARD) != 0 || (aProtect & PAGE_NOACCESS) != 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const auto baseProtect = aProtect & 0xFF;
|
|
return baseProtect == PAGE_READONLY || baseProtect == PAGE_READWRITE || baseProtect == PAGE_WRITECOPY ||
|
|
baseProtect == PAGE_EXECUTE_READ || baseProtect == PAGE_EXECUTE_READWRITE ||
|
|
baseProtect == PAGE_EXECUTE_WRITECOPY;
|
|
}
|
|
|
|
bool IsReadableMemory(const void* aPointer, size_t aSize)
|
|
{
|
|
if (!aPointer || aSize == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const auto begin = reinterpret_cast<uintptr_t>(aPointer);
|
|
const auto end = begin + aSize;
|
|
if (end < begin)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto cursor = begin;
|
|
while (cursor < end)
|
|
{
|
|
MEMORY_BASIC_INFORMATION mbi{};
|
|
if (!VirtualQuery(reinterpret_cast<const void*>(cursor), &mbi, sizeof(mbi)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (mbi.State != MEM_COMMIT || !IsReadablePage(mbi.Protect))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const auto regionEnd = reinterpret_cast<uintptr_t>(mbi.BaseAddress) + mbi.RegionSize;
|
|
if (regionEnd <= cursor)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
cursor = regionEnd;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template<typename T>
|
|
bool TryReadMemory(const void* aPointer, T& aValue)
|
|
{
|
|
if (!IsReadableMemory(aPointer, sizeof(T)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
aValue = *reinterpret_cast<const T*>(aPointer);
|
|
return true;
|
|
}
|
|
|
|
void* ReadPointerField(void* aObject, uintptr_t aOffset)
|
|
{
|
|
void* value = nullptr;
|
|
if (!aObject)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aObject) + aOffset), value);
|
|
return value;
|
|
}
|
|
|
|
void* GetObserver1SystemType()
|
|
{
|
|
return ReadPointerField(reinterpret_cast<void*>(GetImageBase() + kObserver1SystemTypeGlobalRva), 0x00);
|
|
}
|
|
|
|
void AppendObjectVtableSlots(std::ostringstream& aLine, void* aObject, std::initializer_list<uintptr_t> aSlots)
|
|
{
|
|
auto* vtable = ReadPointerField(aObject, 0);
|
|
AppendPointerWithRva(aLine, "vtable", vtable);
|
|
if (!IsInImage(vtable))
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (const auto slot : aSlots)
|
|
{
|
|
auto* target = vtable ? ReadPointerField(vtable, slot) : nullptr;
|
|
std::ostringstream label;
|
|
label << "slot" << std::hex << slot;
|
|
const auto labelText = label.str();
|
|
AppendPointerWithRva(aLine, labelText.c_str(), target);
|
|
}
|
|
}
|
|
|
|
void AppendPointerField(std::ostringstream& aLine, const char* aLabel, void* aObject, uintptr_t aOffset)
|
|
{
|
|
AppendPointerWithRva(aLine, aLabel, ReadPointerField(aObject, aOffset));
|
|
}
|
|
|
|
void AppendUint32Field(std::ostringstream& aLine, const char* aLabel, void* aObject, uintptr_t aOffset)
|
|
{
|
|
uint32_t value = 0;
|
|
const auto hasValue = aObject && TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aObject) + aOffset),
|
|
value);
|
|
aLine << " " << aLabel << "=";
|
|
if (hasValue)
|
|
{
|
|
aLine << value << "/0x" << std::hex << value << std::dec;
|
|
}
|
|
else
|
|
{
|
|
aLine << "<unreadable>";
|
|
}
|
|
}
|
|
|
|
void AppendUint16Field(std::ostringstream& aLine, const char* aLabel, void* aObject, uintptr_t aOffset)
|
|
{
|
|
uint16_t value = 0;
|
|
const auto hasValue = aObject && TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aObject) + aOffset),
|
|
value);
|
|
aLine << " " << aLabel << "=";
|
|
if (hasValue)
|
|
{
|
|
aLine << value << "/0x" << std::hex << value << std::dec;
|
|
}
|
|
else
|
|
{
|
|
aLine << "<unreadable>";
|
|
}
|
|
}
|
|
|
|
void AppendUint64Field(std::ostringstream& aLine, const char* aLabel, void* aObject, uintptr_t aOffset)
|
|
{
|
|
uint64_t value = 0;
|
|
const auto hasValue = aObject && TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aObject) + aOffset),
|
|
value);
|
|
aLine << " " << aLabel << "=";
|
|
if (hasValue)
|
|
{
|
|
aLine << value << "/0x" << std::hex << value << std::dec;
|
|
}
|
|
else
|
|
{
|
|
aLine << "<unreadable>";
|
|
}
|
|
}
|
|
|
|
void AppendByteField(std::ostringstream& aLine, const char* aLabel, void* aObject, uintptr_t aOffset)
|
|
{
|
|
uint8_t value = 0;
|
|
const auto hasValue = aObject && TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aObject) + aOffset),
|
|
value);
|
|
aLine << " " << aLabel << "=";
|
|
if (hasValue)
|
|
{
|
|
aLine << static_cast<uint32_t>(value);
|
|
}
|
|
else
|
|
{
|
|
aLine << "<unreadable>";
|
|
}
|
|
}
|
|
|
|
void AppendBytesField(std::ostringstream& aLine, const char* aLabel, void* aObject, uintptr_t aOffset, size_t aSize)
|
|
{
|
|
const auto* address = aObject ? reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aObject) + aOffset) : nullptr;
|
|
aLine << " " << aLabel << "=";
|
|
if (!address || !IsReadableMemory(address, aSize))
|
|
{
|
|
aLine << "<unreadable>";
|
|
return;
|
|
}
|
|
|
|
const auto flags = aLine.flags();
|
|
const auto fill = aLine.fill();
|
|
aLine << std::hex << std::setfill('0');
|
|
for (size_t index = 0; index < aSize; ++index)
|
|
{
|
|
const auto byte = *(reinterpret_cast<const uint8_t*>(address) + index);
|
|
aLine << std::setw(2) << static_cast<uint32_t>(byte);
|
|
}
|
|
aLine.flags(flags);
|
|
aLine.fill(fill);
|
|
}
|
|
|
|
void AppendBytesPointer(std::ostringstream& aLine, const char* aLabel, const void* aPointer, size_t aSize)
|
|
{
|
|
aLine << " " << aLabel << "=";
|
|
if (!aPointer || reinterpret_cast<uintptr_t>(aPointer) < 0x10000 || !IsReadableMemory(aPointer, aSize))
|
|
{
|
|
aLine << "<unreadable>";
|
|
return;
|
|
}
|
|
|
|
const auto flags = aLine.flags();
|
|
const auto fill = aLine.fill();
|
|
aLine << std::hex << std::setfill('0');
|
|
for (size_t index = 0; index < aSize; ++index)
|
|
{
|
|
const auto byte = *(reinterpret_cast<const uint8_t*>(aPointer) + index);
|
|
aLine << std::setw(2) << static_cast<uint32_t>(byte);
|
|
}
|
|
aLine.flags(flags);
|
|
aLine.fill(fill);
|
|
}
|
|
|
|
struct Vector4Value
|
|
{
|
|
float x;
|
|
float y;
|
|
float z;
|
|
float w;
|
|
};
|
|
|
|
struct Vector3Value
|
|
{
|
|
float x;
|
|
float y;
|
|
float z;
|
|
};
|
|
|
|
void AppendVector3Pointer(std::ostringstream& aLine, const char* aLabel, const void* aVector)
|
|
{
|
|
Vector3Value value{};
|
|
aLine << " " << aLabel << "=";
|
|
if (aVector && TryReadMemory(aVector, value))
|
|
{
|
|
aLine << "(" << value.x << "," << value.y << "," << value.z << ")";
|
|
}
|
|
else
|
|
{
|
|
aLine << "<unreadable>";
|
|
}
|
|
}
|
|
|
|
void AppendVector4Pointer(std::ostringstream& aLine, const char* aLabel, const void* aVector)
|
|
{
|
|
Vector4Value value{};
|
|
aLine << " " << aLabel << "=";
|
|
if (aVector && TryReadMemory(aVector, value))
|
|
{
|
|
aLine << "(" << value.x << "," << value.y << "," << value.z << "," << value.w << ")";
|
|
}
|
|
else
|
|
{
|
|
aLine << "<unreadable>";
|
|
}
|
|
}
|
|
|
|
void AppendVector4Field(std::ostringstream& aLine, const char* aLabel, void* aObject, uintptr_t aOffset)
|
|
{
|
|
if (!aObject)
|
|
{
|
|
aLine << " " << aLabel << "=<null>";
|
|
return;
|
|
}
|
|
|
|
AppendVector4Pointer(aLine, aLabel, reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aObject) + aOffset));
|
|
}
|
|
|
|
void AppendVector3ListCandidate(std::ostringstream& aLine, const char* aPrefix, void* aObject, uintptr_t aDataOffset,
|
|
uintptr_t aCountOffset, uintptr_t aStride)
|
|
{
|
|
uint32_t count = 0;
|
|
auto* data = ReadPointerField(aObject, aDataOffset);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aObject) + aCountOffset), count);
|
|
|
|
const auto dataLabel = std::string(aPrefix) + "_data";
|
|
const auto countLabel = std::string(aPrefix) + "_count";
|
|
AppendPointerWithRva(aLine, dataLabel.c_str(), data);
|
|
aLine << " " << countLabel << "=" << count;
|
|
|
|
if (!data || reinterpret_cast<uintptr_t>(data) < 0x10000 || count == 0 || count > 10000)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AppendVector3Pointer(aLine, (std::string(aPrefix) + "_first3").c_str(), data);
|
|
if (count > 1)
|
|
{
|
|
AppendVector3Pointer(aLine, (std::string(aPrefix) + "_last3").c_str(),
|
|
reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(data) +
|
|
static_cast<uintptr_t>(count - 1) * aStride));
|
|
}
|
|
}
|
|
|
|
void AppendVectorListCandidate(std::ostringstream& aLine, const char* aPrefix, void* aObject, uintptr_t aDataOffset,
|
|
uintptr_t aCountOffset, uintptr_t aStride)
|
|
{
|
|
uint32_t count = 0;
|
|
auto* data = ReadPointerField(aObject, aDataOffset);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aObject) + aCountOffset), count);
|
|
|
|
const auto dataLabel = std::string(aPrefix) + "_data";
|
|
const auto countLabel = std::string(aPrefix) + "_count";
|
|
AppendPointerWithRva(aLine, dataLabel.c_str(), data);
|
|
aLine << " " << countLabel << "=" << count;
|
|
|
|
if (!data || reinterpret_cast<uintptr_t>(data) < 0x10000 || count == 0 || count > 10000)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AppendVector4Pointer(aLine, (std::string(aPrefix) + "_first").c_str(), data);
|
|
if (count > 1)
|
|
{
|
|
AppendVector4Pointer(aLine, (std::string(aPrefix) + "_last").c_str(),
|
|
reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(data) +
|
|
static_cast<uintptr_t>(count - 1) * aStride));
|
|
}
|
|
}
|
|
|
|
void AppendPathBufferSummary(std::ostringstream& aLine, const char* aPrefix, void* aPathBuffer)
|
|
{
|
|
AppendPointerWithRva(aLine, aPrefix, aPathBuffer);
|
|
if (!aPathBuffer)
|
|
{
|
|
return;
|
|
}
|
|
|
|
uint32_t count = 0;
|
|
auto* data = ReadPointerField(aPathBuffer, 0x30);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aPathBuffer) + 0x3C), count);
|
|
|
|
aLine << " " << aPrefix << "_count=" << count;
|
|
AppendPointerWithRva(aLine, (std::string(aPrefix) + "_data").c_str(), data);
|
|
|
|
if (!data || count == 0 || count > 100000)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AppendVector4Pointer(aLine, (std::string(aPrefix) + "_first").c_str(), data);
|
|
if (count > 1)
|
|
{
|
|
AppendVector4Pointer(aLine, (std::string(aPrefix) + "_last").c_str(),
|
|
reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(data) +
|
|
static_cast<uintptr_t>(count - 1) * 12));
|
|
}
|
|
}
|
|
|
|
void AppendGpsResultElementArraySummary(std::ostringstream& aLine, const char* aPrefix, void* aResultObject)
|
|
{
|
|
uint32_t capacity = 0;
|
|
uint32_t count = 0;
|
|
auto* data = ReadPointerField(aResultObject, 0x28);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aResultObject) + 0x30), capacity);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aResultObject) + 0x34), count);
|
|
|
|
const auto prefix = std::string(aPrefix);
|
|
aLine << " " << prefix << "_ptr28_capacity30=" << capacity;
|
|
aLine << " " << prefix << "_ptr28_count34=" << count;
|
|
|
|
if (!data || reinterpret_cast<uintptr_t>(data) < 0x10000 || count == 0 || count > 256)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const auto rawSize = std::min<size_t>(0x80, static_cast<size_t>(count) * sizeof(void*));
|
|
AppendBytesPointer(aLine, (prefix + "_ptr28_ptrsRaw").c_str(), data, rawSize);
|
|
|
|
const auto appendElement = [&](uint32_t aIndex, const char* aLabel) {
|
|
auto* element = ReadPointerField(data, static_cast<uintptr_t>(aIndex) * sizeof(void*));
|
|
const auto elementPrefix = prefix + "_ptr28_" + aLabel;
|
|
AppendPointerWithRva(aLine, elementPrefix.c_str(), element);
|
|
if (!element || reinterpret_cast<uintptr_t>(element) < 0x10000)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AppendPointerField(aLine, (elementPrefix + "_f68").c_str(), element, 0x68);
|
|
AppendUint32Field(aLine, (elementPrefix + "_u74").c_str(), element, 0x74);
|
|
AppendPointerField(aLine, (elementPrefix + "_f90").c_str(), element, 0x90);
|
|
AppendUint32Field(aLine, (elementPrefix + "_u98").c_str(), element, 0x98);
|
|
|
|
uint32_t sampleCount = 0;
|
|
auto* samples = ReadPointerField(element, 0x68);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(element) + 0x74), sampleCount);
|
|
if (samples && reinterpret_cast<uintptr_t>(samples) >= 0x10000 && sampleCount > 0 && sampleCount <= 4096)
|
|
{
|
|
const auto sampleRawSize = std::min<size_t>(0x20, static_cast<size_t>(sampleCount) * 0x08);
|
|
AppendBytesPointer(aLine, (elementPrefix + "_f68raw").c_str(), samples, sampleRawSize);
|
|
}
|
|
};
|
|
|
|
const auto firstLimit = std::min<uint32_t>(count, 4);
|
|
for (uint32_t index = 0; index < firstLimit; ++index)
|
|
{
|
|
appendElement(index, ("elem" + std::to_string(index)).c_str());
|
|
}
|
|
if (count > firstLimit)
|
|
{
|
|
appendElement(count - 1, "last");
|
|
}
|
|
}
|
|
|
|
void AppendGpsResultObjectSummary(std::ostringstream& aLine, const char* aPrefix, void* aResultObject)
|
|
{
|
|
if (!aResultObject)
|
|
{
|
|
aLine << " " << aPrefix << "_result=<null>";
|
|
return;
|
|
}
|
|
|
|
AppendBytesField(aLine, (std::string(aPrefix) + "_bytes20").c_str(), aResultObject, 0x20, 0x40);
|
|
AppendUint32Field(aLine, (std::string(aPrefix) + "_u20").c_str(), aResultObject, 0x20);
|
|
AppendUint32Field(aLine, (std::string(aPrefix) + "_u24").c_str(), aResultObject, 0x24);
|
|
AppendPointerField(aLine, (std::string(aPrefix) + "_ptr28").c_str(), aResultObject, 0x28);
|
|
AppendVector3ListCandidate(aLine, (std::string(aPrefix) + "_vec28s12").c_str(), aResultObject, 0x28, 0x30, 12);
|
|
AppendVectorListCandidate(aLine, (std::string(aPrefix) + "_vec28s16").c_str(), aResultObject, 0x28, 0x30, 16);
|
|
AppendVectorListCandidate(aLine, (std::string(aPrefix) + "_vec20").c_str(), aResultObject, 0x20, 0x2C, 12);
|
|
AppendVectorListCandidate(aLine, (std::string(aPrefix) + "_vec20s16").c_str(), aResultObject, 0x20, 0x2C, 16);
|
|
AppendUint32Field(aLine, (std::string(aPrefix) + "_u2c").c_str(), aResultObject, 0x2C);
|
|
AppendUint64Field(aLine, (std::string(aPrefix) + "_u30").c_str(), aResultObject, 0x30);
|
|
AppendUint32Field(aLine, (std::string(aPrefix) + "_u30lo").c_str(), aResultObject, 0x30);
|
|
AppendUint32Field(aLine, (std::string(aPrefix) + "_u34hi").c_str(), aResultObject, 0x34);
|
|
AppendGpsResultElementArraySummary(aLine, aPrefix, aResultObject);
|
|
AppendVectorListCandidate(aLine, (std::string(aPrefix) + "_vec38").c_str(), aResultObject, 0x38, 0x3C, 12);
|
|
AppendUint16Field(aLine, (std::string(aPrefix) + "_flags40").c_str(), aResultObject, 0x40);
|
|
AppendByteField(aLine, (std::string(aPrefix) + "_state42").c_str(), aResultObject, 0x42);
|
|
AppendUint64Field(aLine, (std::string(aPrefix) + "_u48").c_str(), aResultObject, 0x48);
|
|
AppendUint64Field(aLine, (std::string(aPrefix) + "_u50").c_str(), aResultObject, 0x50);
|
|
}
|
|
|
|
void TrackGpsQuery(uint32_t aQueryId, void* aManager, uintptr_t aSubmitReturnRva, uint32_t aSubmitCall)
|
|
{
|
|
if (aQueryId == UINT32_MAX)
|
|
{
|
|
return;
|
|
}
|
|
|
|
std::lock_guard lock(gTrackedGpsQueryMutex);
|
|
|
|
for (auto& query : gTrackedGpsQueries)
|
|
{
|
|
if (query.active && query.id == aQueryId && query.manager == aManager)
|
|
{
|
|
query.submitReturnRva = aSubmitReturnRva;
|
|
query.submitCall = aSubmitCall;
|
|
return;
|
|
}
|
|
}
|
|
|
|
auto& query = gTrackedGpsQueries[gTrackedGpsQueryNext++ % gTrackedGpsQueries.size()];
|
|
query.active = true;
|
|
query.id = aQueryId;
|
|
query.manager = aManager;
|
|
query.submitReturnRva = aSubmitReturnRva;
|
|
query.submitCall = aSubmitCall;
|
|
query.resultFetchCalls = 0;
|
|
query.statusCalls = 0;
|
|
}
|
|
|
|
bool NoteTrackedGpsQueryResultFetch(uint32_t aQueryId, void* aManager, TrackedGpsQuery& aSnapshot,
|
|
uint32_t& aPerQueryCall)
|
|
{
|
|
std::lock_guard lock(gTrackedGpsQueryMutex);
|
|
|
|
for (auto& query : gTrackedGpsQueries)
|
|
{
|
|
if (!query.active || query.id != aQueryId || query.manager != aManager)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
aPerQueryCall = query.resultFetchCalls++;
|
|
aSnapshot = query;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool NoteTrackedGpsQueryStatus(uint32_t aQueryId, void* aManager, TrackedGpsQuery& aSnapshot,
|
|
uint32_t& aPerQueryCall)
|
|
{
|
|
std::lock_guard lock(gTrackedGpsQueryMutex);
|
|
|
|
for (auto& query : gTrackedGpsQueries)
|
|
{
|
|
if (!query.active || query.id != aQueryId || query.manager != aManager)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
aPerQueryCall = query.statusCalls++;
|
|
aSnapshot = query;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void AppendTrackedGpsQuery(std::ostringstream& aLine, const TrackedGpsQuery& aQuery)
|
|
{
|
|
aLine << " submitCall=" << aQuery.submitCall << " submitRetRva=0x" << std::hex << aQuery.submitReturnRva
|
|
<< std::dec;
|
|
}
|
|
|
|
void AppendRouteRefFields(std::ostringstream& aLine, const char* aPrefix, void* aRouteRef)
|
|
{
|
|
AppendPointerWithRva(aLine, aPrefix, aRouteRef);
|
|
if (!aRouteRef)
|
|
{
|
|
return;
|
|
}
|
|
|
|
std::array<uintptr_t, 7> offsets{0x00, 0x08, 0x10, 0x18, 0x30, 0x40, 0x48};
|
|
for (const auto offset : offsets)
|
|
{
|
|
std::ostringstream label;
|
|
label << aPrefix << "_f" << std::hex << offset;
|
|
const auto labelText = label.str();
|
|
AppendPointerField(aLine, labelText.c_str(), aRouteRef, offset);
|
|
}
|
|
}
|
|
|
|
void LogMappinRouteCollections(const char* aName, uint32_t aCount, void* aSystem)
|
|
{
|
|
if (!kEnableVerboseMappinRouteState)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!aSystem)
|
|
{
|
|
return;
|
|
}
|
|
|
|
void* activeRouteMap = nullptr;
|
|
uint32_t activeRouteCount = 0;
|
|
uint32_t activeRouteFlags = 0;
|
|
void* observerBase = nullptr;
|
|
uint32_t observerCount = 0;
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aSystem) + 0x1A0), activeRouteMap);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aSystem) + 0x1AC), activeRouteCount);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aSystem) + 0x1B0), activeRouteFlags);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aSystem) + 0x288), observerBase);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aSystem) + 0x294), observerCount);
|
|
|
|
std::ostringstream line;
|
|
line << "mappin-route-state " << aName << " call=" << aCount;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendPointerWithRva(line, "activeRouteMap", activeRouteMap);
|
|
line << " activeRouteCount=" << activeRouteCount << " activeRouteFlags=0x" << std::hex << activeRouteFlags
|
|
<< std::dec;
|
|
AppendPointerWithRva(line, "observerBase", observerBase);
|
|
line << " observerCount=" << observerCount;
|
|
LogRed4ext(line.str());
|
|
|
|
if (!observerBase || observerCount == 0 || observerCount > 128)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const auto cappedCount = std::min(observerCount, 4u);
|
|
for (uint32_t index = 0; index < cappedCount; ++index)
|
|
{
|
|
auto* observer = ReadPointerField(observerBase, index * 0x10);
|
|
std::ostringstream observerLine;
|
|
observerLine << "mappin-route-observer " << aName << " call=" << aCount << " index=" << index;
|
|
AppendPointerWithRva(observerLine, "observer", observer);
|
|
AppendObjectVtableSlots(observerLine, observer, {0x48, 0x50});
|
|
LogRed4ext(observerLine.str());
|
|
}
|
|
}
|
|
|
|
void LogRouteObserverContext(const char* aName, uint32_t aCount, void* aObserver, void* aRouteEntry)
|
|
{
|
|
auto* observerInner = ReadPointerField(aObserver, 0x08);
|
|
auto* observerInnerServiceOwner = ReadPointerField(observerInner, 0x18);
|
|
auto* observer1SystemType = GetObserver1SystemType();
|
|
auto* routeObject = ReadPointerField(aRouteEntry, 0x00);
|
|
|
|
std::ostringstream line;
|
|
line << "hook " << aName << " call=" << aCount;
|
|
AppendPointerWithRva(line, "observer", aObserver);
|
|
AppendPointerWithRva(line, "observerInner", observerInner);
|
|
AppendPointerWithRva(line, "observerInnerServiceOwner", observerInnerServiceOwner);
|
|
AppendPointerWithRva(line, "observer1SystemType342f6a8", observer1SystemType);
|
|
AppendPointerWithRva(line, "routeEntry", aRouteEntry);
|
|
AppendPointerWithRva(line, "routeObject", routeObject);
|
|
AppendPointerField(line, "routeEntry_f08", aRouteEntry, 0x08);
|
|
AppendPointerField(line, "routeEntry_f10", aRouteEntry, 0x10);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
|
|
std::ostringstream observerLine;
|
|
observerLine << "route-observer-object " << aName << " call=" << aCount;
|
|
AppendPointerWithRva(observerLine, "observer", aObserver);
|
|
AppendObjectVtableSlots(observerLine, aObserver, {0x48, 0x50});
|
|
LogRed4ext(observerLine.str());
|
|
|
|
if (observerInner)
|
|
{
|
|
std::ostringstream innerLine;
|
|
innerLine << "route-observer-inner " << aName << " call=" << aCount;
|
|
AppendPointerWithRva(innerLine, "observerInner", observerInner);
|
|
AppendObjectVtableSlots(innerLine, observerInner, {0x08});
|
|
AppendPointerField(innerLine, "field18", observerInner, 0x18);
|
|
AppendPointerField(innerLine, "field180", observerInner, 0x180);
|
|
AppendPointerField(innerLine, "field1a0", observerInner, 0x1A0);
|
|
AppendPointerField(innerLine, "field1c0", observerInner, 0x1C0);
|
|
AppendPointerField(innerLine, "field1e0", observerInner, 0x1E0);
|
|
AppendPointerField(innerLine, "field1e8", observerInner, 0x1E8);
|
|
AppendPointerField(innerLine, "field1f0", observerInner, 0x1F0);
|
|
LogRed4ext(innerLine.str());
|
|
}
|
|
|
|
if (observerInnerServiceOwner)
|
|
{
|
|
std::ostringstream serviceOwnerLine;
|
|
serviceOwnerLine << "route-observer-service-owner " << aName << " call=" << aCount;
|
|
AppendPointerWithRva(serviceOwnerLine, "serviceOwner", observerInnerServiceOwner);
|
|
AppendObjectVtableSlots(serviceOwnerLine, observerInnerServiceOwner, {0x08});
|
|
LogRed4ext(serviceOwnerLine.str());
|
|
}
|
|
|
|
if (!routeObject)
|
|
{
|
|
return;
|
|
}
|
|
|
|
std::ostringstream routeLine;
|
|
routeLine << "route-observer-route-object " << aName << " call=" << aCount;
|
|
AppendPointerWithRva(routeLine, "routeObject", routeObject);
|
|
AppendObjectVtableSlots(routeLine, routeObject, {0x140, 0x188, 0x198, 0x1A8});
|
|
AppendPointerField(routeLine, "field40", routeObject, 0x40);
|
|
AppendPointerField(routeLine, "field48", routeObject, 0x48);
|
|
AppendPointerField(routeLine, "field78", routeObject, 0x78);
|
|
AppendUint32Field(routeLine, "field80", routeObject, 0x80);
|
|
AppendByteField(routeLine, "active84", routeObject, 0x84);
|
|
AppendUint32Field(routeLine, "field8C", routeObject, 0x8C);
|
|
AppendUint32Field(routeLine, "field90", routeObject, 0x90);
|
|
AppendPointerField(routeLine, "field98", routeObject, 0x98);
|
|
AppendPointerField(routeLine, "field88", routeObject, 0x88);
|
|
AppendPointerField(routeLine, "fieldF8", routeObject, 0xF8);
|
|
AppendPointerField(routeLine, "field120", routeObject, 0x120);
|
|
AppendByteField(routeLine, "fieldE2", routeObject, 0xE2);
|
|
LogRed4ext(routeLine.str());
|
|
}
|
|
|
|
void LogRouteEventFields(const char* aName, uint32_t aCount, void* aEvent)
|
|
{
|
|
uint32_t routeId = 0;
|
|
uint8_t active = 0;
|
|
void* system = nullptr;
|
|
if (aEvent)
|
|
{
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aEvent) + 0x18), routeId);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aEvent) + 0x20), system);
|
|
TryReadMemory(reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(aEvent) + 0x28), active);
|
|
}
|
|
|
|
std::ostringstream line;
|
|
line << "route-event-fields " << aName << " call=" << aCount << " routeId=" << routeId << " active="
|
|
<< static_cast<uint32_t>(active);
|
|
AppendPointerWithRva(line, "event", aEvent);
|
|
AppendPointerWithRva(line, "system", system);
|
|
AppendObjectVtableSlots(line, aEvent, {0x20, 0x28, 0x30});
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void LogJournalListenerContext(const char* aName, uint32_t aCount, void* aListener, void* aEvent)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook " << aName << " call=" << aCount;
|
|
AppendPointerWithRva(line, "listener", aListener);
|
|
AppendPointerWithRva(line, "event", aEvent);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
|
|
auto* field08 = ReadPointerField(aListener, 0x08);
|
|
auto* field18 = ReadPointerField(aListener, 0x18);
|
|
auto* field20 = ReadPointerField(aListener, 0x20);
|
|
auto* field70 = ReadPointerField(aListener, 0x70);
|
|
auto* field78 = ReadPointerField(aListener, 0x78);
|
|
AppendPointerWithRva(line, "field08", field08);
|
|
AppendPointerWithRva(line, "field18", field18);
|
|
AppendPointerWithRva(line, "field20", field20);
|
|
AppendPointerWithRva(line, "field70", field70);
|
|
AppendPointerWithRva(line, "field78", field78);
|
|
LogRed4ext(line.str());
|
|
|
|
if (field70)
|
|
{
|
|
std::ostringstream owner;
|
|
owner << "journal-listener-context " << aName << " call=" << aCount;
|
|
AppendPointerWithRva(owner, "field70", field70);
|
|
AppendObjectVtableSlots(owner, field70, {0x1C8, 0x218, 0x230, 0x238, 0x240, 0x248, 0x340, 0x348, 0x358});
|
|
LogRed4ext(owner.str());
|
|
}
|
|
|
|
if (field78 && field78 != field70)
|
|
{
|
|
std::ostringstream service;
|
|
service << "journal-listener-context " << aName << " call=" << aCount;
|
|
AppendPointerWithRva(service, "field78", field78);
|
|
AppendObjectVtableSlots(service, field78,
|
|
{0x1C8, 0x218, 0x220, 0x230, 0x238, 0x240, 0x248, 0x340, 0x348, 0x358});
|
|
LogRed4ext(service.str());
|
|
}
|
|
}
|
|
|
|
void ScanRegionForString(const uint8_t* aRegionBegin, size_t aRegionSize, uintptr_t aImageBase, const char* aNeedle,
|
|
uint32_t& aMatches)
|
|
{
|
|
constexpr uint32_t kMaxMatchesPerNeedle = 8;
|
|
|
|
const auto needleSize = std::strlen(aNeedle);
|
|
if (needleSize == 0 || aRegionSize < needleSize || aMatches >= kMaxMatchesPerNeedle)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const auto* cursor = aRegionBegin;
|
|
const auto* regionEnd = aRegionBegin + aRegionSize;
|
|
|
|
while (cursor + needleSize <= regionEnd && aMatches < kMaxMatchesPerNeedle)
|
|
{
|
|
if (std::memcmp(cursor, aNeedle, needleSize) == 0)
|
|
{
|
|
const auto rva = reinterpret_cast<uintptr_t>(cursor) - aImageBase;
|
|
std::ostringstream line;
|
|
line << "exe-string match needle=\"" << aNeedle << "\" rva=0x" << std::hex << rva << std::dec;
|
|
LogRed4ext(line.str());
|
|
++aMatches;
|
|
cursor += needleSize;
|
|
continue;
|
|
}
|
|
|
|
++cursor;
|
|
}
|
|
}
|
|
|
|
void ScanExecutableStrings()
|
|
{
|
|
if (gScannedExecutable)
|
|
{
|
|
return;
|
|
}
|
|
gScannedExecutable = true;
|
|
|
|
const auto imageBase = reinterpret_cast<uintptr_t>(GetModuleHandleW(nullptr));
|
|
if (!imageBase)
|
|
{
|
|
LogRed4ext("exe-string scan skipped: main module unavailable");
|
|
return;
|
|
}
|
|
|
|
const auto* dos = reinterpret_cast<const IMAGE_DOS_HEADER*>(imageBase);
|
|
if (dos->e_magic != IMAGE_DOS_SIGNATURE)
|
|
{
|
|
LogRed4ext("exe-string scan skipped: bad DOS header");
|
|
return;
|
|
}
|
|
|
|
const auto* nt = reinterpret_cast<const IMAGE_NT_HEADERS*>(imageBase + dos->e_lfanew);
|
|
if (nt->Signature != IMAGE_NT_SIGNATURE)
|
|
{
|
|
LogRed4ext("exe-string scan skipped: bad NT header");
|
|
return;
|
|
}
|
|
|
|
const auto imageSize = static_cast<size_t>(nt->OptionalHeader.SizeOfImage);
|
|
std::ostringstream header;
|
|
header << "exe-string scan begin base=0x" << std::hex << imageBase << " size=0x" << imageSize << std::dec;
|
|
LogRed4ext(header.str());
|
|
|
|
constexpr std::array<const char*, 21> kNeedles{
|
|
"GPSSystem/Tick",
|
|
"GPSSystem",
|
|
"GPSSettings",
|
|
"RunGPSQuery",
|
|
"UpdateGPSQuery",
|
|
"gameuiGPSGameController",
|
|
"OnSetHasGPSPortal",
|
|
"IsGPSPortal",
|
|
"m_cookedGpsData",
|
|
"gameCookedGpsMappinData",
|
|
"GetNavigationFunctionalTests",
|
|
"TrafficSystem_Pathfinding",
|
|
"TrafficSystem_PathMap",
|
|
"Pathfinding Algorithm Failed",
|
|
"No Path Found in Traffic",
|
|
"PathFindingFailed",
|
|
"worldTrafficLanePlayerGPSInfo",
|
|
"worldTrafficPersistentResource",
|
|
"worldTrafficConnectivityOutLane",
|
|
};
|
|
|
|
for (const auto* needle : kNeedles)
|
|
{
|
|
uint32_t matches = 0;
|
|
uintptr_t cursor = imageBase;
|
|
const uintptr_t end = imageBase + imageSize;
|
|
|
|
while (cursor < end)
|
|
{
|
|
MEMORY_BASIC_INFORMATION mbi{};
|
|
if (!VirtualQuery(reinterpret_cast<const void*>(cursor), &mbi, sizeof(mbi)))
|
|
{
|
|
break;
|
|
}
|
|
|
|
const auto regionBegin = reinterpret_cast<uintptr_t>(mbi.BaseAddress);
|
|
const auto regionEnd = regionBegin + mbi.RegionSize;
|
|
if (mbi.State == MEM_COMMIT && mbi.Type == MEM_IMAGE && IsReadablePage(mbi.Protect))
|
|
{
|
|
const auto scanBegin = std::max(regionBegin, imageBase);
|
|
const auto scanEnd = std::min(regionEnd, end);
|
|
if (scanBegin < scanEnd)
|
|
{
|
|
ScanRegionForString(reinterpret_cast<const uint8_t*>(scanBegin), scanEnd - scanBegin, imageBase,
|
|
needle, matches);
|
|
}
|
|
}
|
|
|
|
if (regionEnd <= cursor)
|
|
{
|
|
break;
|
|
}
|
|
cursor = regionEnd;
|
|
}
|
|
|
|
if (matches == 0)
|
|
{
|
|
std::ostringstream line;
|
|
line << "exe-string no match needle=\"" << needle << "\"";
|
|
LogRed4ext(line.str());
|
|
}
|
|
}
|
|
|
|
LogRed4ext("exe-string scan end");
|
|
}
|
|
|
|
void DetourGpsSystemTick(void* aThis, void* a2, void* a3, void* a4)
|
|
{
|
|
if (gGpsTickLogCount < 8)
|
|
{
|
|
LogHookCall("GPSSystem/Tick", gGpsTickLogCount, aThis, a2, a3, a4);
|
|
++gGpsTickLogCount;
|
|
}
|
|
|
|
if (gOriginalGpsSystemTick)
|
|
{
|
|
gOriginalGpsSystemTick(aThis, a2, a3, a4);
|
|
}
|
|
}
|
|
|
|
void LogJournalListeners(uint32_t aCallCount, void* aThis)
|
|
{
|
|
constexpr uint32_t kMaxListenerDumps = 16;
|
|
constexpr uint32_t kMaxListenersPerDump = 24;
|
|
constexpr uint32_t kSuspiciousListenerCount = 512;
|
|
|
|
if (gJournalTrackEntryListenerDumpCount >= kMaxListenerDumps || !aThis)
|
|
{
|
|
return;
|
|
}
|
|
|
|
uintptr_t listenerBase = 0;
|
|
uint32_t listenerCount = 0;
|
|
const auto objectAddress = reinterpret_cast<uintptr_t>(aThis);
|
|
const auto hasBase = TryReadMemory(reinterpret_cast<const void*>(objectAddress + kJournalListenerArrayOffset),
|
|
listenerBase);
|
|
const auto hasCount = TryReadMemory(reinterpret_cast<const void*>(objectAddress + kJournalListenerCountOffset),
|
|
listenerCount);
|
|
|
|
std::ostringstream header;
|
|
header << "journal-listeners dump=" << gJournalTrackEntryListenerDumpCount << " call=" << aCallCount
|
|
<< " hasBase=" << hasBase << " hasCount=" << hasCount << " count=" << listenerCount;
|
|
AppendPointerWithRva(header, "base", reinterpret_cast<const void*>(listenerBase));
|
|
LogRed4ext(header.str());
|
|
|
|
++gJournalTrackEntryListenerDumpCount;
|
|
|
|
if (!hasBase || !hasCount || !listenerBase || listenerCount > kSuspiciousListenerCount)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const auto cappedCount = std::min(listenerCount, kMaxListenersPerDump);
|
|
for (uint32_t index = 0; index < cappedCount; ++index)
|
|
{
|
|
void* listener = nullptr;
|
|
void* vtable = nullptr;
|
|
void* callback28 = nullptr;
|
|
void* callback30 = nullptr;
|
|
void* callback50 = nullptr;
|
|
|
|
const auto listenerAddress = reinterpret_cast<const void*>(listenerBase + index * sizeof(void*));
|
|
const auto hasListener = TryReadMemory(listenerAddress, listener);
|
|
const auto hasVtable = hasListener && TryReadMemory(listener, vtable);
|
|
if (hasVtable && vtable)
|
|
{
|
|
const auto vtableAddress = reinterpret_cast<uintptr_t>(vtable);
|
|
TryReadMemory(reinterpret_cast<const void*>(vtableAddress + 0x28), callback28);
|
|
TryReadMemory(reinterpret_cast<const void*>(vtableAddress + 0x30), callback30);
|
|
TryReadMemory(reinterpret_cast<const void*>(vtableAddress + 0x50), callback50);
|
|
}
|
|
|
|
std::ostringstream line;
|
|
line << "journal-listener call=" << aCallCount << " index=" << index << " hasListener=" << hasListener
|
|
<< " hasVtable=" << hasVtable;
|
|
AppendPointerWithRva(line, "listener", listener);
|
|
AppendPointerWithRva(line, "vtable", vtable);
|
|
AppendPointerWithRva(line, "vt28", callback28);
|
|
AppendPointerWithRva(line, "vt30", callback30);
|
|
AppendPointerWithRva(line, "vt50", callback50);
|
|
LogRed4ext(line.str());
|
|
}
|
|
}
|
|
|
|
void DetourJournalTrackEntry(void* aThis, void* aEntryHandle)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 96;
|
|
|
|
const auto callCount = gJournalTrackEntryLogCount;
|
|
if (callCount < kMaxCalls)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook JournalManager::TrackEntry impl call=" << callCount;
|
|
AppendPointerWithRva(line, "this", aThis);
|
|
AppendPointerWithRva(line, "entryHandle", aEntryHandle);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
|
|
++gJournalTrackEntryLogCount;
|
|
}
|
|
|
|
if (gOriginalJournalTrackEntry)
|
|
{
|
|
gOriginalJournalTrackEntry(aThis, aEntryHandle);
|
|
}
|
|
}
|
|
|
|
void DispatchJournalListenerCallback(const char* aName, uint32_t& aCounter, JournalListenerCallbackFunc aOriginal,
|
|
void* aListener, void* aEvent)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 64;
|
|
|
|
if (aCounter < kMaxCalls)
|
|
{
|
|
LogJournalListenerContext(aName, aCounter, aListener, aEvent);
|
|
++aCounter;
|
|
}
|
|
|
|
if (aOriginal)
|
|
{
|
|
aOriginal(aListener, aEvent);
|
|
}
|
|
}
|
|
|
|
void DetourJournalListenerObjectiveVt28(void* aListener, void* aEvent)
|
|
{
|
|
DispatchJournalListenerCallback("JournalListener::Objective vt28", gJournalListenerObjectiveVt28LogCount,
|
|
gOriginalJournalListenerObjectiveVt28, aListener, aEvent);
|
|
}
|
|
|
|
void DetourJournalListenerObjectiveVt30(void* aListener, void* aEvent)
|
|
{
|
|
DispatchJournalListenerCallback("JournalListener::Objective vt30", gJournalListenerObjectiveVt30LogCount,
|
|
gOriginalJournalListenerObjectiveVt30, aListener, aEvent);
|
|
}
|
|
|
|
void DetourJournalListenerRouteVt28(void* aListener, void* aEvent)
|
|
{
|
|
DispatchJournalListenerCallback("JournalListener::Route vt28", gJournalListenerRouteVt28LogCount,
|
|
gOriginalJournalListenerRouteVt28, aListener, aEvent);
|
|
}
|
|
|
|
void DetourJournalListenerRouteVt30(void* aListener, void* aEvent)
|
|
{
|
|
DispatchJournalListenerCallback("JournalListener::Route vt30", gJournalListenerRouteVt30LogCount,
|
|
gOriginalJournalListenerRouteVt30, aListener, aEvent);
|
|
}
|
|
|
|
void DetourJournalListenerRouteAltVt28(void* aListener, void* aEvent)
|
|
{
|
|
DispatchJournalListenerCallback("JournalListener::RouteAlt vt28", gJournalListenerRouteAltVt28LogCount,
|
|
gOriginalJournalListenerRouteAltVt28, aListener, aEvent);
|
|
}
|
|
|
|
void DetourJournalListenerRouteAltVt30(void* aListener, void* aEvent)
|
|
{
|
|
DispatchJournalListenerCallback("JournalListener::RouteAlt vt30", gJournalListenerRouteAltVt30LogCount,
|
|
gOriginalJournalListenerRouteAltVt30, aListener, aEvent);
|
|
}
|
|
|
|
void DetourJournalListenerUiVt28(void* aListener, void* aEvent)
|
|
{
|
|
DispatchJournalListenerCallback("JournalListener::UI vt28", gJournalListenerUiVt28LogCount,
|
|
gOriginalJournalListenerUiVt28, aListener, aEvent);
|
|
}
|
|
|
|
void DetourJournalListenerUiVt30(void* aListener, void* aEvent)
|
|
{
|
|
DispatchJournalListenerCallback("JournalListener::UI vt30", gJournalListenerUiVt30LogCount,
|
|
gOriginalJournalListenerUiVt30, aListener, aEvent);
|
|
}
|
|
|
|
void DetourJournalListenerTrackerVt28(void* aListener, void* aEvent)
|
|
{
|
|
DispatchJournalListenerCallback("JournalListener::Tracker vt28", gJournalListenerTrackerVt28LogCount,
|
|
gOriginalJournalListenerTrackerVt28, aListener, aEvent);
|
|
}
|
|
|
|
bool DetourJournalRouteBridge(void* aThis, void* aEntryHandle)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 64;
|
|
|
|
const auto callCount = gJournalRouteBridgeLogCount;
|
|
const auto shouldLog = callCount < kMaxCalls;
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook JournalRouteBridge::Update candidate call=" << callCount;
|
|
AppendPointerWithRva(line, "this", aThis);
|
|
AppendPointerWithRva(line, "entryHandle", aEntryHandle);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
AppendPointerField(line, "field10", aThis, 0x10);
|
|
AppendPointerField(line, "field18", aThis, 0x18);
|
|
AppendPointerField(line, "field20", aThis, 0x20);
|
|
AppendByteField(line, "field30", aThis, 0x30);
|
|
AppendUint32Field(line, "field34", aThis, 0x34);
|
|
AppendUint32Field(line, "field38", aThis, 0x38);
|
|
LogRed4ext(line.str());
|
|
++gJournalRouteBridgeLogCount;
|
|
}
|
|
|
|
bool result = false;
|
|
if (gOriginalJournalRouteBridge)
|
|
{
|
|
result = gOriginalJournalRouteBridge(aThis, aEntryHandle);
|
|
}
|
|
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook JournalRouteBridge::Update candidate result call=" << callCount << " value="
|
|
<< static_cast<uint32_t>(result);
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void DetourMappinRouteEventEnqueue(void* aSystem, uint32_t aRouteId, uint8_t aActive)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 64;
|
|
|
|
if (gMappinRouteEventEnqueueLogCount < kMaxCalls)
|
|
{
|
|
const auto callCount = gMappinRouteEventEnqueueLogCount;
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::RouteEventEnqueue slot240 call=" << callCount << " routeId=" << aRouteId
|
|
<< " active=" << static_cast<uint32_t>(aActive);
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
LogMappinRouteCollections("enqueue-before", callCount, aSystem);
|
|
++gMappinRouteEventEnqueueLogCount;
|
|
}
|
|
|
|
if (gOriginalMappinRouteEventEnqueue)
|
|
{
|
|
gOriginalMappinRouteEventEnqueue(aSystem, aRouteId, aActive);
|
|
}
|
|
}
|
|
|
|
void DetourMappinRouteEventHandler(void* aEvent, void* aRouteHandle)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 64;
|
|
|
|
if (gMappinRouteEventHandlerLogCount < kMaxCalls)
|
|
{
|
|
const auto callCount = gMappinRouteEventHandlerLogCount;
|
|
void* routeOwner = ReadPointerField(aRouteHandle, 0);
|
|
const auto routeKey = reinterpret_cast<uint64_t>(ReadPointerField(routeOwner, 0x40));
|
|
|
|
std::ostringstream line;
|
|
line << "hook MappinRouteEvent::Handle call=" << callCount;
|
|
AppendPointerWithRva(line, "event", aEvent);
|
|
AppendPointerWithRva(line, "routeHandle", aRouteHandle);
|
|
AppendPointerWithRva(line, "routeOwner", routeOwner);
|
|
AppendHexValue(line, "routeKey", routeKey);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
LogRouteEventFields("handler-before", callCount, aEvent);
|
|
++gMappinRouteEventHandlerLogCount;
|
|
}
|
|
|
|
if (gOriginalMappinRouteEventHandler)
|
|
{
|
|
gOriginalMappinRouteEventHandler(aEvent, aRouteHandle);
|
|
}
|
|
}
|
|
|
|
void DetourMappinRouteActivate(void* aSystem, uint64_t aRouteKey)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 64;
|
|
|
|
if (gMappinRouteActivateLogCount < kMaxCalls)
|
|
{
|
|
const auto callCount = gMappinRouteActivateLogCount;
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::RouteActivate call=" << callCount;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendHexValue(line, "routeKey", aRouteKey);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
LogMappinRouteCollections("activate-before", callCount, aSystem);
|
|
++gMappinRouteActivateLogCount;
|
|
}
|
|
|
|
if (gOriginalMappinRouteActivate)
|
|
{
|
|
gOriginalMappinRouteActivate(aSystem, aRouteKey);
|
|
}
|
|
}
|
|
|
|
void DetourMappinRouteDeactivate(void* aSystem, uint64_t aRouteKey)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 64;
|
|
|
|
if (gMappinRouteDeactivateLogCount < kMaxCalls)
|
|
{
|
|
const auto callCount = gMappinRouteDeactivateLogCount;
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::RouteDeactivate call=" << callCount;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendHexValue(line, "routeKey", aRouteKey);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
LogMappinRouteCollections("deactivate-before", callCount, aSystem);
|
|
++gMappinRouteDeactivateLogCount;
|
|
}
|
|
|
|
if (gOriginalMappinRouteDeactivate)
|
|
{
|
|
gOriginalMappinRouteDeactivate(aSystem, aRouteKey);
|
|
}
|
|
}
|
|
|
|
void DetourRouteBuildCandidate(void* aThis, uint32_t aRouteId, uint32_t aAltRouteId, uint32_t aPreviousRouteId,
|
|
void* aRoutePositionData, void* aPrimaryDescriptor, void* aSecondaryDescriptor,
|
|
void* aRouteData88, void* aRouteData108, void* aRouteData114, uint8_t aFlag,
|
|
uint32_t aMode)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 64;
|
|
|
|
if (gRouteBuildCandidateLogCount < kMaxCalls)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook RouteBuildCandidate 0x5625a4 call=" << gRouteBuildCandidateLogCount
|
|
<< " routeId=" << aRouteId << " altRouteId=" << aAltRouteId
|
|
<< " previousRouteId=" << aPreviousRouteId << " flag=" << static_cast<uint32_t>(aFlag)
|
|
<< " mode=" << aMode;
|
|
AppendPointerWithRva(line, "this", aThis);
|
|
AppendPointerWithRva(line, "routePositionData", aRoutePositionData);
|
|
AppendPointerWithRva(line, "primaryDescriptor", aPrimaryDescriptor);
|
|
AppendPointerWithRva(line, "secondaryDescriptor", aSecondaryDescriptor);
|
|
AppendPointerWithRva(line, "routeData88", aRouteData88);
|
|
AppendPointerWithRva(line, "routeData108", aRouteData108);
|
|
AppendPointerWithRva(line, "routeData114", aRouteData114);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gRouteBuildCandidateLogCount;
|
|
}
|
|
|
|
if (gOriginalRouteBuildCandidate)
|
|
{
|
|
gOriginalRouteBuildCandidate(aThis, aRouteId, aAltRouteId, aPreviousRouteId, aRoutePositionData,
|
|
aPrimaryDescriptor, aSecondaryDescriptor, aRouteData88, aRouteData108,
|
|
aRouteData114, aFlag, aMode);
|
|
}
|
|
}
|
|
|
|
void DispatchRouteObserverCallback(const char* aName, uint32_t& aCounter, RouteObserverCallbackFunc aOriginal,
|
|
void* aObserver, void* aRouteEntry)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 96;
|
|
|
|
if (aCounter < kMaxCalls)
|
|
{
|
|
LogRouteObserverContext(aName, aCounter, aObserver, aRouteEntry);
|
|
++aCounter;
|
|
}
|
|
|
|
if (aOriginal)
|
|
{
|
|
aOriginal(aObserver, aRouteEntry);
|
|
}
|
|
}
|
|
|
|
void DetourRouteObserver0Activate(void* aObserver, void* aRouteEntry)
|
|
{
|
|
DispatchRouteObserverCallback("RouteObserver0::Activate slot48", gRouteObserver0ActivateLogCount,
|
|
gOriginalRouteObserver0Activate, aObserver, aRouteEntry);
|
|
}
|
|
|
|
void DetourRouteObserver1Activate(void* aObserver, void* aRouteEntry)
|
|
{
|
|
DispatchRouteObserverCallback("RouteObserver1::Activate slot48", gRouteObserver1ActivateLogCount,
|
|
gOriginalRouteObserver1Activate, aObserver, aRouteEntry);
|
|
}
|
|
|
|
void DetourRouteObserver23Activate(void* aObserver, void* aRouteEntry)
|
|
{
|
|
DispatchRouteObserverCallback("RouteObserver23::Activate slot48", gRouteObserver23ActivateLogCount,
|
|
gOriginalRouteObserver23Activate, aObserver, aRouteEntry);
|
|
}
|
|
|
|
void DetourRouteObserver0Deactivate(void* aObserver, void* aRouteEntry)
|
|
{
|
|
DispatchRouteObserverCallback("RouteObserver0::Deactivate slot50", gRouteObserver0DeactivateLogCount,
|
|
gOriginalRouteObserver0Deactivate, aObserver, aRouteEntry);
|
|
}
|
|
|
|
void DetourRouteObserver1Deactivate(void* aObserver, void* aRouteEntry)
|
|
{
|
|
DispatchRouteObserverCallback("RouteObserver1::Deactivate slot50", gRouteObserver1DeactivateLogCount,
|
|
gOriginalRouteObserver1Deactivate, aObserver, aRouteEntry);
|
|
}
|
|
|
|
void DetourRouteObserver23Deactivate(void* aObserver, void* aRouteEntry)
|
|
{
|
|
DispatchRouteObserverCallback("RouteObserver23::Deactivate slot50", gRouteObserver23DeactivateLogCount,
|
|
gOriginalRouteObserver23Deactivate, aObserver, aRouteEntry);
|
|
}
|
|
|
|
void DetourFrameMappinPathWrapper(void* aThis, void* aStack, void* aResult)
|
|
{
|
|
if (gFrameMappinPathWrapperLogCount < 64)
|
|
{
|
|
LogScriptNativeCall("FrameMappinPathWrapper", gFrameMappinPathWrapperLogCount, aThis, aStack, aResult);
|
|
++gFrameMappinPathWrapperLogCount;
|
|
}
|
|
|
|
InspectAndHookMappinSystem(aThis);
|
|
|
|
if (gOriginalFrameMappinPathWrapper)
|
|
{
|
|
gOriginalFrameMappinPathWrapper(aThis, aStack, aResult);
|
|
}
|
|
}
|
|
|
|
void DetourFrameMappinPathCore(void* aThis, uint32_t aPathKind, void* a3, void* aPathRect)
|
|
{
|
|
if (gFrameMappinPathCoreLogCount < 64)
|
|
{
|
|
LogFrameMappinPathCoreCall(gFrameMappinPathCoreLogCount, aThis, aPathKind, a3, aPathRect);
|
|
++gFrameMappinPathCoreLogCount;
|
|
}
|
|
|
|
InspectAndHookMappinSystem(aThis);
|
|
|
|
if (gOriginalFrameMappinPathCore)
|
|
{
|
|
gOriginalFrameMappinPathCore(aThis, aPathKind, a3, aPathRect);
|
|
}
|
|
}
|
|
|
|
void DetourSetSelectedMappinWrapper(void* aThis, void* aStack, void* aResult)
|
|
{
|
|
if (gSetSelectedMappinWrapperLogCount < 64)
|
|
{
|
|
LogScriptNativeCall("SetSelectedMappinWrapper", gSetSelectedMappinWrapperLogCount, aThis, aStack, aResult);
|
|
++gSetSelectedMappinWrapperLogCount;
|
|
}
|
|
|
|
InspectAndHookMappinSystem(aThis);
|
|
|
|
if (gOriginalSetSelectedMappinWrapper)
|
|
{
|
|
gOriginalSetSelectedMappinWrapper(aThis, aStack, aResult);
|
|
}
|
|
}
|
|
|
|
void DetourSetSelectedMappinByIdWrapper(void* aThis, void* aStack, void* aResult)
|
|
{
|
|
if (gSetSelectedMappinByIdWrapperLogCount < 64)
|
|
{
|
|
LogScriptNativeCall("SetSelectedMappinByIdWrapper", gSetSelectedMappinByIdWrapperLogCount, aThis, aStack,
|
|
aResult);
|
|
++gSetSelectedMappinByIdWrapperLogCount;
|
|
}
|
|
|
|
InspectAndHookMappinSystem(aThis);
|
|
|
|
if (gOriginalSetSelectedMappinByIdWrapper)
|
|
{
|
|
gOriginalSetSelectedMappinByIdWrapper(aThis, aStack, aResult);
|
|
}
|
|
}
|
|
|
|
void DetourSetSelectedMappinByPositionWrapper(void* aThis, void* aStack, void* aResult)
|
|
{
|
|
if (gSetSelectedMappinByPositionWrapperLogCount < 64)
|
|
{
|
|
LogScriptNativeCall("SetSelectedMappinByPositionWrapper", gSetSelectedMappinByPositionWrapperLogCount, aThis,
|
|
aStack, aResult);
|
|
++gSetSelectedMappinByPositionWrapperLogCount;
|
|
}
|
|
|
|
InspectAndHookMappinSystem(aThis);
|
|
|
|
if (gOriginalSetSelectedMappinByPositionWrapper)
|
|
{
|
|
gOriginalSetSelectedMappinByPositionWrapper(aThis, aStack, aResult);
|
|
}
|
|
}
|
|
|
|
void DetourSetSelectedMappinCore(void* aThis, void* aMappinHandle)
|
|
{
|
|
if (gSetSelectedMappinCoreLogCount < 64)
|
|
{
|
|
LogSetSelectedMappinCoreCall(gSetSelectedMappinCoreLogCount, aThis, aMappinHandle);
|
|
++gSetSelectedMappinCoreLogCount;
|
|
}
|
|
|
|
InspectAndHookMappinSystem(aThis);
|
|
|
|
if (gOriginalSetSelectedMappinCore)
|
|
{
|
|
gOriginalSetSelectedMappinCore(aThis, aMappinHandle);
|
|
}
|
|
}
|
|
|
|
void DetourTrackCustomPositionMappinWrapper(void* aThis, void* aStack, void* aResult)
|
|
{
|
|
if (gTrackCustomPositionMappinWrapperLogCount < 64)
|
|
{
|
|
LogScriptNativeCall("TrackCustomPositionMappinWrapper", gTrackCustomPositionMappinWrapperLogCount, aThis,
|
|
aStack, aResult);
|
|
++gTrackCustomPositionMappinWrapperLogCount;
|
|
}
|
|
|
|
InspectAndHookMappinSystem(aThis);
|
|
|
|
if (gOriginalTrackCustomPositionMappinWrapper)
|
|
{
|
|
gOriginalTrackCustomPositionMappinWrapper(aThis, aStack, aResult);
|
|
}
|
|
}
|
|
|
|
void DetourTrackCustomPositionMappinCore(void* aThis)
|
|
{
|
|
if (gTrackCustomPositionMappinCoreLogCount < 64)
|
|
{
|
|
LogTrackCustomPositionMappinCoreCall(gTrackCustomPositionMappinCoreLogCount, aThis);
|
|
++gTrackCustomPositionMappinCoreLogCount;
|
|
}
|
|
|
|
InspectAndHookMappinSystem(aThis);
|
|
|
|
if (gOriginalTrackCustomPositionMappinCore)
|
|
{
|
|
gOriginalTrackCustomPositionMappinCore(aThis);
|
|
}
|
|
}
|
|
|
|
void DetourUntrackCustomPositionMappinWrapper(void* aThis, void* aStack, void* aResult)
|
|
{
|
|
if (gUntrackCustomPositionMappinWrapperLogCount < 64)
|
|
{
|
|
LogScriptNativeCall("UntrackCustomPositionMappinWrapper", gUntrackCustomPositionMappinWrapperLogCount, aThis,
|
|
aStack, aResult);
|
|
++gUntrackCustomPositionMappinWrapperLogCount;
|
|
}
|
|
|
|
InspectAndHookMappinSystem(aThis);
|
|
|
|
if (gOriginalUntrackCustomPositionMappinWrapper)
|
|
{
|
|
gOriginalUntrackCustomPositionMappinWrapper(aThis, aStack, aResult);
|
|
}
|
|
}
|
|
|
|
void DetourTrackMappinWrapper(void* aThis, void* aStack, void* aResult)
|
|
{
|
|
if (gTrackMappinWrapperLogCount < 64)
|
|
{
|
|
LogScriptNativeCall("TrackMappinWrapper", gTrackMappinWrapperLogCount, aThis, aStack, aResult);
|
|
++gTrackMappinWrapperLogCount;
|
|
}
|
|
|
|
if (gOriginalTrackMappinWrapper)
|
|
{
|
|
gOriginalTrackMappinWrapper(aThis, aStack, aResult);
|
|
}
|
|
}
|
|
|
|
void DetourTrackMappinCore(void* aThis, void* aMappinHandle)
|
|
{
|
|
if (gTrackMappinCoreLogCount < 64)
|
|
{
|
|
LogTrackMappinCoreCall(gTrackMappinCoreLogCount, aThis, aMappinHandle);
|
|
++gTrackMappinCoreLogCount;
|
|
}
|
|
|
|
InspectAndHookMappinSystem(aThis);
|
|
|
|
if (gOriginalTrackMappinCore)
|
|
{
|
|
gOriginalTrackMappinCore(aThis, aMappinHandle);
|
|
}
|
|
}
|
|
|
|
void DetourSetMappinTrackingAlternativeWrapper(void* aThis, void* aStack, void* aResult)
|
|
{
|
|
if (gSetMappinTrackingAlternativeLogCount < 64)
|
|
{
|
|
LogScriptNativeCall("SetMappinTrackingAlternativeWrapper", gSetMappinTrackingAlternativeLogCount, aThis,
|
|
aStack, aResult);
|
|
++gSetMappinTrackingAlternativeLogCount;
|
|
}
|
|
|
|
if (gOriginalSetMappinTrackingAlternativeWrapper)
|
|
{
|
|
gOriginalSetMappinTrackingAlternativeWrapper(aThis, aStack, aResult);
|
|
}
|
|
}
|
|
|
|
void DetourMappinUpdateCustomPosition(void* aSystem, void* aHandle, void* aPositionData)
|
|
{
|
|
if (gMappinUpdateCustomPositionLogCount < 32)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::UpdateCustomPosition slot1f0 call=" << gMappinUpdateCustomPositionLogCount;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendPointerWithRva(line, "handle", aHandle);
|
|
AppendPointerWithRva(line, "positionData", aPositionData);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gMappinUpdateCustomPositionLogCount;
|
|
}
|
|
|
|
if (gOriginalMappinUpdateCustomPosition)
|
|
{
|
|
gOriginalMappinUpdateCustomPosition(aSystem, aHandle, aPositionData);
|
|
}
|
|
}
|
|
|
|
void DetourMappinSetTracked(void* aSystem, void* aMappinId)
|
|
{
|
|
if (gMappinSetTrackedLogCount < 64)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::SetTracked slot220 call=" << gMappinSetTrackedLogCount;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendPointerWithRva(line, "mappinId", aMappinId);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gMappinSetTrackedLogCount;
|
|
}
|
|
|
|
if (gOriginalMappinSetTracked)
|
|
{
|
|
gOriginalMappinSetTracked(aSystem, aMappinId);
|
|
}
|
|
}
|
|
|
|
void DetourMappinClearTracked(void* aSystem)
|
|
{
|
|
if (gMappinClearTrackedLogCount < 64)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::ClearTracked slot228 call=" << gMappinClearTrackedLogCount;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gMappinClearTrackedLogCount;
|
|
}
|
|
|
|
if (gOriginalMappinClearTracked)
|
|
{
|
|
gOriginalMappinClearTracked(aSystem);
|
|
}
|
|
}
|
|
|
|
void DetourMappinFramePath(void* aSystem, uint32_t aPathKind, void* aResult)
|
|
{
|
|
if (gMappinFramePathLogCount < 32)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::FramePath slot280 call=" << gMappinFramePathLogCount
|
|
<< " pathKind=" << aPathKind;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendPointerWithRva(line, "result", aResult);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gMappinFramePathLogCount;
|
|
}
|
|
|
|
if (gOriginalMappinFramePath)
|
|
{
|
|
gOriginalMappinFramePath(aSystem, aPathKind, aResult);
|
|
}
|
|
}
|
|
|
|
void* DetourMappinPositionQuery(void* aSystem, void* a2, void* a3, void* a4, void* a5)
|
|
{
|
|
const auto shouldLog = gMappinPositionQueryLogCount < 32;
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::PositionQuery slot2e0 call=" << gMappinPositionQueryLogCount;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendPointerWithRva(line, "a2", a2);
|
|
AppendPointerWithRva(line, "a3", a3);
|
|
AppendPointerWithRva(line, "a4", a4);
|
|
AppendPointerWithRva(line, "a5", a5);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gMappinPositionQueryLogCount;
|
|
}
|
|
|
|
void* result = nullptr;
|
|
if (gOriginalMappinPositionQuery)
|
|
{
|
|
result = gOriginalMappinPositionQuery(aSystem, a2, a3, a4, a5);
|
|
}
|
|
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::PositionQuery slot2e0 result";
|
|
AppendPointerWithRva(line, "value", result);
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void* DetourMappinCreateCustomPosition(void* aSystem, void* aName, void* aParams, void* aPositionData)
|
|
{
|
|
const auto shouldLog = gMappinCreateCustomPositionLogCount < 32;
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::CreateCustomPosition slot2f0 call=" << gMappinCreateCustomPositionLogCount;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendPointerWithRva(line, "name", aName);
|
|
AppendPointerWithRva(line, "params", aParams);
|
|
AppendPointerWithRva(line, "positionData", aPositionData);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gMappinCreateCustomPositionLogCount;
|
|
}
|
|
|
|
void* result = nullptr;
|
|
if (gOriginalMappinCreateCustomPosition)
|
|
{
|
|
result = gOriginalMappinCreateCustomPosition(aSystem, aName, aParams, aPositionData);
|
|
}
|
|
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::CreateCustomPosition slot2f0 result";
|
|
AppendPointerWithRva(line, "value", result);
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void DetourMappinReleaseQuery(void* aSystem, void* aHandle)
|
|
{
|
|
if (gMappinReleaseQueryLogCount < 32)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::ReleaseQuery slot368 call=" << gMappinReleaseQueryLogCount;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendPointerWithRva(line, "handle", aHandle);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gMappinReleaseQueryLogCount;
|
|
}
|
|
|
|
if (gOriginalMappinReleaseQuery)
|
|
{
|
|
gOriginalMappinReleaseQuery(aSystem, aHandle);
|
|
}
|
|
}
|
|
|
|
void* DetourMappinActiveRoute(void* aSystem)
|
|
{
|
|
const auto shouldLog = gMappinActiveRouteLogCount < 32;
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::ActiveRoute slot3a8 call=" << gMappinActiveRouteLogCount;
|
|
AppendPointerWithRva(line, "system", aSystem);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gMappinActiveRouteLogCount;
|
|
}
|
|
|
|
void* result = nullptr;
|
|
if (gOriginalMappinActiveRoute)
|
|
{
|
|
result = gOriginalMappinActiveRoute(aSystem);
|
|
}
|
|
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook MappinSystem::ActiveRoute slot3a8 result";
|
|
AppendPointerWithRva(line, "value", result);
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool DetourRunGpsQueryBody(void* aThis, void* aStart, void* aEnd, int32_t* aOutQueryId)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 96;
|
|
|
|
const auto callCount = gRunGpsQueryBodyLogCount;
|
|
const auto shouldLog = callCount < kMaxCalls;
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook RunGPSQuery body 0x29bd128 call=" << callCount;
|
|
AppendPointerWithRva(line, "this", aThis);
|
|
AppendPointerWithRva(line, "outQueryId", aOutQueryId);
|
|
AppendVector4Pointer(line, "start", aStart);
|
|
AppendVector4Pointer(line, "end", aEnd);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gRunGpsQueryBodyLogCount;
|
|
}
|
|
|
|
bool result = false;
|
|
if (gOriginalRunGpsQueryBody)
|
|
{
|
|
result = gOriginalRunGpsQueryBody(aThis, aStart, aEnd, aOutQueryId);
|
|
}
|
|
|
|
if (shouldLog)
|
|
{
|
|
int32_t queryId = 0;
|
|
const auto hasQueryId = aOutQueryId && TryReadMemory(aOutQueryId, queryId);
|
|
|
|
std::ostringstream line;
|
|
line << "hook RunGPSQuery body result call=" << callCount << " value=" << static_cast<uint32_t>(result)
|
|
<< " hasQueryId=" << hasQueryId;
|
|
if (hasQueryId)
|
|
{
|
|
line << " queryId=" << queryId;
|
|
}
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool DetourUpdateGpsQueryBody(void* aThis, uint32_t aQueryId, void* aOutPoints, void* aOutError)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 128;
|
|
|
|
const auto callCount = gUpdateGpsQueryBodyLogCount;
|
|
const auto shouldLog = callCount < kMaxCalls;
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook UpdateGPSQuery body 0x29bd254 call=" << callCount << " queryId=" << aQueryId;
|
|
AppendPointerWithRva(line, "this", aThis);
|
|
AppendPointerWithRva(line, "outPoints", aOutPoints);
|
|
AppendPointerWithRva(line, "outError", aOutError);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gUpdateGpsQueryBodyLogCount;
|
|
}
|
|
|
|
bool result = false;
|
|
if (gOriginalUpdateGpsQueryBody)
|
|
{
|
|
result = gOriginalUpdateGpsQueryBody(aThis, aQueryId, aOutPoints, aOutError);
|
|
}
|
|
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook UpdateGPSQuery body result call=" << callCount << " value=" << static_cast<uint32_t>(result);
|
|
AppendPathBufferSummary(line, "cachedPath", ReadPointerField(aThis, 0x58));
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int32_t DetourGpsQuerySubmit(void* aManager, void* aQuery)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 128;
|
|
|
|
const auto returnAddress = __builtin_return_address(0);
|
|
uintptr_t returnRva = 0;
|
|
TryGetImageRva(returnAddress, returnRva);
|
|
|
|
const auto callCount = gGpsQuerySubmitLogCount;
|
|
const auto shouldLog = callCount < kMaxCalls;
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook GPSQuerySubmit 0x70a42c call=" << callCount;
|
|
AppendPointerWithRva(line, "manager", aManager);
|
|
AppendPointerWithRva(line, "query", aQuery);
|
|
AppendUint32Field(line, "query_f00", aQuery, 0x00);
|
|
AppendUint32Field(line, "query_f04", aQuery, 0x04);
|
|
AppendUint32Field(line, "query_f08", aQuery, 0x08);
|
|
AppendUint32Field(line, "query_f0c", aQuery, 0x0C);
|
|
AppendUint32Field(line, "query_fcc", aQuery, 0xCC);
|
|
AppendVector4Field(line, "query_pos58", aQuery, 0x58);
|
|
AppendReturnRva(line, returnAddress);
|
|
LogRed4ext(line.str());
|
|
++gGpsQuerySubmitLogCount;
|
|
}
|
|
|
|
int32_t result = -1;
|
|
if (gOriginalGpsQuerySubmit)
|
|
{
|
|
result = gOriginalGpsQuerySubmit(aManager, aQuery);
|
|
}
|
|
|
|
if (result >= 0)
|
|
{
|
|
TrackGpsQuery(static_cast<uint32_t>(result), aManager, returnRva, callCount);
|
|
}
|
|
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook GPSQuerySubmit result call=" << callCount << " queryId=" << result;
|
|
AppendUint32Field(line, "manager_nextIdD4", aManager, 0xD4);
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void DetourGpsQueryDispatch(void* aRuntimeQuery, void* aTargetPosition, void* aArg3, void* aArg4)
|
|
{
|
|
constexpr uint32_t kMaxCalls = 128;
|
|
|
|
if (gGpsQueryDispatchLogCount < kMaxCalls)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook GPSQueryDispatch 0x70a570 call=" << gGpsQueryDispatchLogCount;
|
|
AppendPointerWithRva(line, "runtimeQuery", aRuntimeQuery);
|
|
AppendPointerWithRva(line, "arg3", aArg3);
|
|
AppendPointerWithRva(line, "arg4", aArg4);
|
|
AppendUint32Field(line, "runtimeQuery_state138", aRuntimeQuery, 0x138);
|
|
AppendUint32Field(line, "runtimeQuery_bank13c", aRuntimeQuery, 0x13C);
|
|
AppendVector4Pointer(line, "target", aTargetPosition);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gGpsQueryDispatchLogCount;
|
|
}
|
|
|
|
if (gOriginalGpsQueryDispatch)
|
|
{
|
|
gOriginalGpsQueryDispatch(aRuntimeQuery, aTargetPosition, aArg3, aArg4);
|
|
}
|
|
}
|
|
|
|
bool DetourGpsQueryResultFetch(void* aManager, uint32_t aQueryId, void* aOutPath)
|
|
{
|
|
constexpr uint32_t kMaxUntrackedSamples = 32;
|
|
constexpr uint32_t kMaxTrackedSamplesPerQuery = 24;
|
|
|
|
const auto callCount = gGpsQueryResultFetchLogCount++;
|
|
const auto returnAddress = __builtin_return_address(0);
|
|
|
|
bool result = false;
|
|
if (gOriginalGpsQueryResultFetch)
|
|
{
|
|
result = gOriginalGpsQueryResultFetch(aManager, aQueryId, aOutPath);
|
|
}
|
|
|
|
TrackedGpsQuery trackedQuery{};
|
|
uint32_t perQueryCall = 0;
|
|
const auto isTracked = NoteTrackedGpsQueryResultFetch(aQueryId, aManager, trackedQuery, perQueryCall);
|
|
const auto shouldLog = (isTracked && (perQueryCall < kMaxTrackedSamplesPerQuery || result)) ||
|
|
(!isTracked && callCount < kMaxUntrackedSamples && aQueryId < 2);
|
|
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook GPSQueryResultFetch 0x7094b8 call=" << callCount << " queryId=" << aQueryId
|
|
<< " tracked=" << static_cast<uint32_t>(isTracked) << " perQueryCall=" << perQueryCall
|
|
<< " value=" << static_cast<uint32_t>(result);
|
|
if (isTracked)
|
|
{
|
|
AppendTrackedGpsQuery(line, trackedQuery);
|
|
}
|
|
AppendPointerWithRva(line, "manager", aManager);
|
|
AppendPointerWithRva(line, "outPath", aOutPath);
|
|
AppendReturnRva(line, returnAddress);
|
|
AppendPathBufferSummary(line, "outPath", aOutPath);
|
|
if (result && isTracked && trackedQuery.submitReturnRva == 0x8D20D4)
|
|
{
|
|
AppendGpsResultObjectSummary(line, "gpsResult", aOutPath);
|
|
}
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int32_t DetourGpsQueryStatus(void* aManager, uint32_t aQueryId)
|
|
{
|
|
constexpr uint32_t kMaxUntrackedSamples = 32;
|
|
constexpr uint32_t kMaxTrackedSamplesPerQuery = 24;
|
|
|
|
const auto callCount = gGpsQueryStatusLogCount++;
|
|
const auto returnAddress = __builtin_return_address(0);
|
|
|
|
int32_t result = 0;
|
|
if (gOriginalGpsQueryStatus)
|
|
{
|
|
result = gOriginalGpsQueryStatus(aManager, aQueryId);
|
|
}
|
|
|
|
TrackedGpsQuery trackedQuery{};
|
|
uint32_t perQueryCall = 0;
|
|
const auto isTracked = NoteTrackedGpsQueryStatus(aQueryId, aManager, trackedQuery, perQueryCall);
|
|
const auto shouldLog = (isTracked && (perQueryCall < kMaxTrackedSamplesPerQuery || result != 0)) ||
|
|
(!isTracked && callCount < kMaxUntrackedSamples && aQueryId < 2);
|
|
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook GPSQueryStatus 0xaa5704 call=" << callCount << " queryId=" << aQueryId
|
|
<< " tracked=" << static_cast<uint32_t>(isTracked) << " perQueryCall=" << perQueryCall
|
|
<< " value=" << result;
|
|
if (isTracked)
|
|
{
|
|
AppendTrackedGpsQuery(line, trackedQuery);
|
|
}
|
|
AppendPointerWithRva(line, "manager", aManager);
|
|
AppendReturnRva(line, returnAddress);
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void AttachProbeHook(const char* aName, uintptr_t aRva, void* aDetour, void** aOriginal)
|
|
{
|
|
if (!gSdk || !gSdk->hooking || !gSdk->hooking->Attach)
|
|
{
|
|
LogRed4ext("hook attach skipped: RED4ext hooking API unavailable");
|
|
return;
|
|
}
|
|
|
|
auto* target = reinterpret_cast<void*>(GetImageBase() + aRva);
|
|
const auto attached = gSdk->hooking->Attach(gHandle, target, aDetour, aOriginal);
|
|
|
|
std::ostringstream line;
|
|
line << "hook attach " << aName << " target=" << target << " rva=0x" << std::hex << aRva << std::dec
|
|
<< " result=" << (attached ? "ok" : "failed") << " original=" << (aOriginal ? *aOriginal : nullptr);
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void AttachAbsoluteHook(const char* aName, void* aTarget, void* aDetour, void** aOriginal)
|
|
{
|
|
if (!gSdk || !gSdk->hooking || !gSdk->hooking->Attach)
|
|
{
|
|
LogRed4ext("absolute hook attach skipped: RED4ext hooking API unavailable");
|
|
return;
|
|
}
|
|
|
|
if (!aTarget)
|
|
{
|
|
std::ostringstream line;
|
|
line << "absolute hook attach skipped " << aName << ": target=null";
|
|
LogRed4ext(line.str());
|
|
return;
|
|
}
|
|
|
|
const auto attached = gSdk->hooking->Attach(gHandle, aTarget, aDetour, aOriginal);
|
|
|
|
std::ostringstream line;
|
|
line << "absolute hook attach " << aName;
|
|
AppendPointerWithRva(line, "target", aTarget);
|
|
line << " result=" << (attached ? "ok" : "failed");
|
|
AppendPointerWithRva(line, "original", aOriginal ? *aOriginal : nullptr);
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void DetachProbeHook(const char* aName, uintptr_t aRva)
|
|
{
|
|
if (!gSdk || !gSdk->hooking || !gSdk->hooking->Detach)
|
|
{
|
|
return;
|
|
}
|
|
|
|
auto* target = reinterpret_cast<void*>(GetImageBase() + aRva);
|
|
const auto detached = gSdk->hooking->Detach(gHandle, target);
|
|
|
|
std::ostringstream line;
|
|
line << "hook detach " << aName << " target=" << target << " result=" << (detached ? "ok" : "failed");
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void DetachAbsoluteHook(const char* aName, void* aTarget)
|
|
{
|
|
if (!gSdk || !gSdk->hooking || !gSdk->hooking->Detach || !aTarget)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const auto detached = gSdk->hooking->Detach(gHandle, aTarget);
|
|
|
|
std::ostringstream line;
|
|
line << "absolute hook detach " << aName;
|
|
AppendPointerWithRva(line, "target", aTarget);
|
|
line << " result=" << (detached ? "ok" : "failed");
|
|
LogRed4ext(line.str());
|
|
}
|
|
|
|
void DetourObserver1ServiceRouteLookup(void* aService, void* aOut, uint32_t aRouteId)
|
|
{
|
|
const auto shouldLog = gObserver1ServiceRouteLookupLogCount < 96;
|
|
const auto callCount = gObserver1ServiceRouteLookupLogCount;
|
|
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook Observer1Service::RouteLookup slot220 call=" << callCount << " routeId=" << aRouteId
|
|
<< "/0x" << std::hex << aRouteId << std::dec;
|
|
AppendPointerWithRva(line, "service", aService);
|
|
AppendPointerWithRva(line, "out", aOut);
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gObserver1ServiceRouteLookupLogCount;
|
|
}
|
|
|
|
if (gOriginalObserver1ServiceRouteLookup)
|
|
{
|
|
gOriginalObserver1ServiceRouteLookup(aService, aOut, aRouteId);
|
|
}
|
|
|
|
if (shouldLog)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook Observer1Service::RouteLookup slot220 result call=" << callCount;
|
|
AppendPointerField(line, "out_f00", aOut, 0x00);
|
|
AppendPointerField(line, "out_f08", aOut, 0x08);
|
|
AppendPointerField(line, "out_f10", aOut, 0x10);
|
|
|
|
auto* routeData = ReadPointerField(aOut, 0x00);
|
|
if (routeData)
|
|
{
|
|
AppendPointerWithRva(line, "routeData", routeData);
|
|
AppendPointerField(line, "routeData_f40", routeData, 0x40);
|
|
AppendPointerField(line, "routeData_f48", routeData, 0x48);
|
|
AppendPointerField(line, "routeData_f50", routeData, 0x50);
|
|
AppendPointerField(line, "routeData_f58", routeData, 0x58);
|
|
}
|
|
|
|
LogRed4ext(line.str());
|
|
}
|
|
}
|
|
|
|
void MaybeAttachObserver1ServiceRouteLookup(void* aService)
|
|
{
|
|
if (gObserver1ServiceRouteLookupHookAttachAttempted || !aService)
|
|
{
|
|
return;
|
|
}
|
|
|
|
auto* vtable = ReadPointerField(aService, 0x00);
|
|
if (!IsInImage(vtable))
|
|
{
|
|
return;
|
|
}
|
|
|
|
gObserver1ServiceRouteLookupTarget =
|
|
ReadPointerField(vtable, kObserver1ServiceRouteLookupSlotOffset);
|
|
if (!gObserver1ServiceRouteLookupTarget)
|
|
{
|
|
return;
|
|
}
|
|
|
|
gObserver1ServiceRouteLookupHookAttachAttempted = true;
|
|
AttachAbsoluteHook("Observer1Service::RouteLookup slot220", gObserver1ServiceRouteLookupTarget,
|
|
reinterpret_cast<void*>(&DetourObserver1ServiceRouteLookup),
|
|
reinterpret_cast<void**>(&gOriginalObserver1ServiceRouteLookup));
|
|
}
|
|
|
|
void* DetourObserver1ServiceLookup(void* aServiceOwner, void* aSystemType)
|
|
{
|
|
void* result = nullptr;
|
|
if (gOriginalObserver1ServiceLookup)
|
|
{
|
|
result = gOriginalObserver1ServiceLookup(aServiceOwner, aSystemType);
|
|
}
|
|
|
|
auto* observer1SystemType = GetObserver1SystemType();
|
|
if (!observer1SystemType || aSystemType != observer1SystemType)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
if (gObserver1ServiceLookupLogCount < 96)
|
|
{
|
|
std::ostringstream line;
|
|
line << "hook Observer1ServiceLookup 0x287c44 call=" << gObserver1ServiceLookupLogCount;
|
|
AppendPointerWithRva(line, "serviceOwner", aServiceOwner);
|
|
AppendPointerWithRva(line, "systemType", aSystemType);
|
|
AppendPointerWithRva(line, "result", result);
|
|
AppendObjectVtableSlots(line, result, {0x218, 0x220, 0x228, 0x230, 0x238, 0x240});
|
|
AppendReturnRva(line, __builtin_return_address(0));
|
|
LogRed4ext(line.str());
|
|
++gObserver1ServiceLookupLogCount;
|
|
}
|
|
|
|
MaybeAttachObserver1ServiceRouteLookup(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
void InspectAndHookMappinSystem(void* aThis)
|
|
{
|
|
auto* resolver = reinterpret_cast<MappinSystemResolverFunc>(GetImageBase() + kMappinSystemResolverRva);
|
|
void* system = resolver ? resolver(aThis) : nullptr;
|
|
auto* vtable = system ? *reinterpret_cast<void***>(system) : nullptr;
|
|
|
|
if (gMappinSystemSlotLogCount < 16)
|
|
{
|
|
LogMappinSystemSlots(gMappinSystemSlotLogCount, system, vtable);
|
|
++gMappinSystemSlotLogCount;
|
|
}
|
|
|
|
if (gMappinSlotHookAttachAttempted || !vtable)
|
|
{
|
|
return;
|
|
}
|
|
|
|
gMappinSlotHookAttachAttempted = true;
|
|
gMappinUpdateCustomPositionTarget =
|
|
*reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(vtable) + kMappinUpdateCustomPositionSlotOffset);
|
|
gMappinSetTrackedTarget =
|
|
*reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(vtable) + kMappinSetTrackedSlotOffset);
|
|
gMappinClearTrackedTarget =
|
|
*reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(vtable) + kMappinClearTrackedSlotOffset);
|
|
gMappinFramePathTarget =
|
|
*reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(vtable) + kMappinFramePathSlotOffset);
|
|
gMappinPositionQueryTarget =
|
|
*reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(vtable) + kMappinPositionQuerySlotOffset);
|
|
gMappinCreateCustomPositionTarget =
|
|
*reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(vtable) + kMappinCreateCustomPositionSlotOffset);
|
|
gMappinReleaseQueryTarget =
|
|
*reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(vtable) + kMappinReleaseQuerySlotOffset);
|
|
gMappinActiveRouteTarget =
|
|
*reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(vtable) + kMappinActiveRouteSlotOffset);
|
|
|
|
AttachAbsoluteHook("MappinSystem::UpdateCustomPosition slot1f0", gMappinUpdateCustomPositionTarget,
|
|
reinterpret_cast<void*>(&DetourMappinUpdateCustomPosition),
|
|
reinterpret_cast<void**>(&gOriginalMappinUpdateCustomPosition));
|
|
AttachAbsoluteHook("MappinSystem::SetTracked slot220", gMappinSetTrackedTarget,
|
|
reinterpret_cast<void*>(&DetourMappinSetTracked),
|
|
reinterpret_cast<void**>(&gOriginalMappinSetTracked));
|
|
AttachAbsoluteHook("MappinSystem::ClearTracked slot228", gMappinClearTrackedTarget,
|
|
reinterpret_cast<void*>(&DetourMappinClearTracked),
|
|
reinterpret_cast<void**>(&gOriginalMappinClearTracked));
|
|
AttachAbsoluteHook("MappinSystem::FramePath slot280", gMappinFramePathTarget,
|
|
reinterpret_cast<void*>(&DetourMappinFramePath),
|
|
reinterpret_cast<void**>(&gOriginalMappinFramePath));
|
|
AttachAbsoluteHook("MappinSystem::PositionQuery slot2e0", gMappinPositionQueryTarget,
|
|
reinterpret_cast<void*>(&DetourMappinPositionQuery),
|
|
reinterpret_cast<void**>(&gOriginalMappinPositionQuery));
|
|
AttachAbsoluteHook("MappinSystem::CreateCustomPosition slot2f0", gMappinCreateCustomPositionTarget,
|
|
reinterpret_cast<void*>(&DetourMappinCreateCustomPosition),
|
|
reinterpret_cast<void**>(&gOriginalMappinCreateCustomPosition));
|
|
AttachAbsoluteHook("MappinSystem::ReleaseQuery slot368", gMappinReleaseQueryTarget,
|
|
reinterpret_cast<void*>(&DetourMappinReleaseQuery),
|
|
reinterpret_cast<void**>(&gOriginalMappinReleaseQuery));
|
|
AttachAbsoluteHook("MappinSystem::ActiveRoute slot3a8", gMappinActiveRouteTarget,
|
|
reinterpret_cast<void*>(&DetourMappinActiveRoute),
|
|
reinterpret_cast<void**>(&gOriginalMappinActiveRoute));
|
|
}
|
|
|
|
bool OnRunningEnter(void* aApp)
|
|
{
|
|
std::ostringstream line;
|
|
line << "GameState Running OnEnter app=" << aApp;
|
|
LogRed4ext(line.str());
|
|
return true;
|
|
}
|
|
|
|
bool OnRunningUpdate(void* aApp)
|
|
{
|
|
if (gUpdateLogCount < 5)
|
|
{
|
|
std::ostringstream line;
|
|
line << "GameState Running OnUpdate app=" << aApp << " count=" << gUpdateLogCount;
|
|
LogRed4ext(line.str());
|
|
++gUpdateLogCount;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool OnRunningExit(void* aApp)
|
|
{
|
|
std::ostringstream line;
|
|
line << "GameState Running OnExit app=" << aApp;
|
|
LogRed4ext(line.str());
|
|
return true;
|
|
}
|
|
|
|
RED4ext::v1::GameState gRunningState{
|
|
.OnEnter = OnRunningEnter,
|
|
.OnUpdate = OnRunningUpdate,
|
|
.OnExit = OnRunningExit,
|
|
};
|
|
}
|
|
|
|
BOOL APIENTRY DllMain(HMODULE aModule, DWORD aReason, LPVOID)
|
|
{
|
|
if (aReason == DLL_PROCESS_ATTACH)
|
|
{
|
|
gModule = aModule;
|
|
LARGE_INTEGER frequency{};
|
|
LARGE_INTEGER counter{};
|
|
QueryPerformanceFrequency(&frequency);
|
|
QueryPerformanceCounter(&counter);
|
|
gLogFrequency = static_cast<uint64_t>(frequency.QuadPart);
|
|
gLogStartTick = static_cast<uint64_t>(counter.QuadPart);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
RED4EXT_C_EXPORT bool RED4EXT_CALL Main(RED4ext::v1::PluginHandle aHandle, RED4ext::v1::EMainReason aReason,
|
|
const RED4ext::v1::Sdk* aSdk)
|
|
{
|
|
gHandle = aHandle;
|
|
gSdk = aSdk;
|
|
|
|
std::ostringstream line;
|
|
line << "EdgeWeightGPS Main reason=" << ReasonToString(aReason) << " handle=" << aHandle << " sdk=" << aSdk;
|
|
if (aSdk && aSdk->runtime)
|
|
{
|
|
line << " runtime=" << static_cast<uint32_t>(aSdk->runtime->major) << "." << aSdk->runtime->minor << "."
|
|
<< aSdk->runtime->patch;
|
|
}
|
|
LogRed4ext(line.str());
|
|
|
|
if (aReason == RED4ext::v1::EMainReason::Load && aSdk && aSdk->gameStates && aSdk->gameStates->Add)
|
|
{
|
|
const auto added = aSdk->gameStates->Add(aHandle, kGameStateRunning, &gRunningState);
|
|
LogRed4ext(added ? "registered Running game-state callbacks" : "failed to register Running game-state callbacks");
|
|
|
|
AttachProbeHook("RunGPSQuery body 0x29bd128", kRunGpsQueryBodyRva,
|
|
reinterpret_cast<void*>(&DetourRunGpsQueryBody),
|
|
reinterpret_cast<void**>(&gOriginalRunGpsQueryBody));
|
|
AttachProbeHook("UpdateGPSQuery body 0x29bd254", kUpdateGpsQueryBodyRva,
|
|
reinterpret_cast<void*>(&DetourUpdateGpsQueryBody),
|
|
reinterpret_cast<void**>(&gOriginalUpdateGpsQueryBody));
|
|
AttachProbeHook("GPSQuerySubmit 0x70a42c", kGpsQuerySubmitRva,
|
|
reinterpret_cast<void*>(&DetourGpsQuerySubmit),
|
|
reinterpret_cast<void**>(&gOriginalGpsQuerySubmit));
|
|
AttachProbeHook("GPSQueryDispatch 0x70a570", kGpsQueryDispatchRva,
|
|
reinterpret_cast<void*>(&DetourGpsQueryDispatch),
|
|
reinterpret_cast<void**>(&gOriginalGpsQueryDispatch));
|
|
AttachProbeHook("GPSQueryResultFetch 0x7094b8", kGpsQueryResultFetchRva,
|
|
reinterpret_cast<void*>(&DetourGpsQueryResultFetch),
|
|
reinterpret_cast<void**>(&gOriginalGpsQueryResultFetch));
|
|
AttachProbeHook("GPSQueryStatus 0xaa5704", kGpsQueryStatusRva,
|
|
reinterpret_cast<void*>(&DetourGpsQueryStatus),
|
|
reinterpret_cast<void**>(&gOriginalGpsQueryStatus));
|
|
AttachProbeHook("GPSSystem/Tick", kGpsSystemTickRva, reinterpret_cast<void*>(&DetourGpsSystemTick),
|
|
reinterpret_cast<void**>(&gOriginalGpsSystemTick));
|
|
AttachProbeHook("JournalManager::TrackEntry impl", kJournalTrackEntryImplRva,
|
|
reinterpret_cast<void*>(&DetourJournalTrackEntry),
|
|
reinterpret_cast<void**>(&gOriginalJournalTrackEntry));
|
|
if (kEnableVerboseJournalListenerHooks)
|
|
{
|
|
AttachProbeHook("JournalListener::Objective vt28", kJournalListenerObjectiveVt28Rva,
|
|
reinterpret_cast<void*>(&DetourJournalListenerObjectiveVt28),
|
|
reinterpret_cast<void**>(&gOriginalJournalListenerObjectiveVt28));
|
|
AttachProbeHook("JournalListener::Objective vt30", kJournalListenerObjectiveVt30Rva,
|
|
reinterpret_cast<void*>(&DetourJournalListenerObjectiveVt30),
|
|
reinterpret_cast<void**>(&gOriginalJournalListenerObjectiveVt30));
|
|
AttachProbeHook("JournalListener::Route vt28", kJournalListenerRouteVt28Rva,
|
|
reinterpret_cast<void*>(&DetourJournalListenerRouteVt28),
|
|
reinterpret_cast<void**>(&gOriginalJournalListenerRouteVt28));
|
|
AttachProbeHook("JournalListener::Route vt30", kJournalListenerRouteVt30Rva,
|
|
reinterpret_cast<void*>(&DetourJournalListenerRouteVt30),
|
|
reinterpret_cast<void**>(&gOriginalJournalListenerRouteVt30));
|
|
AttachProbeHook("JournalListener::RouteAlt vt28", kJournalListenerRouteAltVt28Rva,
|
|
reinterpret_cast<void*>(&DetourJournalListenerRouteAltVt28),
|
|
reinterpret_cast<void**>(&gOriginalJournalListenerRouteAltVt28));
|
|
AttachProbeHook("JournalListener::RouteAlt vt30", kJournalListenerRouteAltVt30Rva,
|
|
reinterpret_cast<void*>(&DetourJournalListenerRouteAltVt30),
|
|
reinterpret_cast<void**>(&gOriginalJournalListenerRouteAltVt30));
|
|
AttachProbeHook("JournalListener::UI vt28", kJournalListenerUiVt28Rva,
|
|
reinterpret_cast<void*>(&DetourJournalListenerUiVt28),
|
|
reinterpret_cast<void**>(&gOriginalJournalListenerUiVt28));
|
|
AttachProbeHook("JournalListener::UI vt30", kJournalListenerUiVt30Rva,
|
|
reinterpret_cast<void*>(&DetourJournalListenerUiVt30),
|
|
reinterpret_cast<void**>(&gOriginalJournalListenerUiVt30));
|
|
AttachProbeHook("JournalListener::Tracker vt28", kJournalListenerTrackerVt28Rva,
|
|
reinterpret_cast<void*>(&DetourJournalListenerTrackerVt28),
|
|
reinterpret_cast<void**>(&gOriginalJournalListenerTrackerVt28));
|
|
}
|
|
AttachProbeHook("JournalRouteBridge::Update candidate", kJournalRouteBridgeRva,
|
|
reinterpret_cast<void*>(&DetourJournalRouteBridge),
|
|
reinterpret_cast<void**>(&gOriginalJournalRouteBridge));
|
|
AttachProbeHook("MappinSystem::RouteEventEnqueue slot240", kMappinRouteEventEnqueueRva,
|
|
reinterpret_cast<void*>(&DetourMappinRouteEventEnqueue),
|
|
reinterpret_cast<void**>(&gOriginalMappinRouteEventEnqueue));
|
|
AttachProbeHook("MappinRouteEvent::Handle", kMappinRouteEventHandlerRva,
|
|
reinterpret_cast<void*>(&DetourMappinRouteEventHandler),
|
|
reinterpret_cast<void**>(&gOriginalMappinRouteEventHandler));
|
|
AttachProbeHook("MappinSystem::RouteActivate", kMappinRouteActivateRva,
|
|
reinterpret_cast<void*>(&DetourMappinRouteActivate),
|
|
reinterpret_cast<void**>(&gOriginalMappinRouteActivate));
|
|
AttachProbeHook("MappinSystem::RouteDeactivate", kMappinRouteDeactivateRva,
|
|
reinterpret_cast<void*>(&DetourMappinRouteDeactivate),
|
|
reinterpret_cast<void**>(&gOriginalMappinRouteDeactivate));
|
|
AttachProbeHook("RouteBuildCandidate 0x5625a4", kRouteBuildCandidateRva,
|
|
reinterpret_cast<void*>(&DetourRouteBuildCandidate),
|
|
reinterpret_cast<void**>(&gOriginalRouteBuildCandidate));
|
|
if (kEnableVerboseRouteObserverHooks)
|
|
{
|
|
AttachProbeHook("RouteObserver0::Activate slot48", kRouteObserver0ActivateRva,
|
|
reinterpret_cast<void*>(&DetourRouteObserver0Activate),
|
|
reinterpret_cast<void**>(&gOriginalRouteObserver0Activate));
|
|
AttachProbeHook("RouteObserver1::Activate slot48", kRouteObserver1ActivateRva,
|
|
reinterpret_cast<void*>(&DetourRouteObserver1Activate),
|
|
reinterpret_cast<void**>(&gOriginalRouteObserver1Activate));
|
|
AttachProbeHook("RouteObserver23::Activate slot48", kRouteObserver23ActivateRva,
|
|
reinterpret_cast<void*>(&DetourRouteObserver23Activate),
|
|
reinterpret_cast<void**>(&gOriginalRouteObserver23Activate));
|
|
AttachProbeHook("RouteObserver0::Deactivate slot50", kRouteObserver0DeactivateRva,
|
|
reinterpret_cast<void*>(&DetourRouteObserver0Deactivate),
|
|
reinterpret_cast<void**>(&gOriginalRouteObserver0Deactivate));
|
|
AttachProbeHook("RouteObserver1::Deactivate slot50", kRouteObserver1DeactivateRva,
|
|
reinterpret_cast<void*>(&DetourRouteObserver1Deactivate),
|
|
reinterpret_cast<void**>(&gOriginalRouteObserver1Deactivate));
|
|
AttachProbeHook("RouteObserver23::Deactivate slot50", kRouteObserver23DeactivateRva,
|
|
reinterpret_cast<void*>(&DetourRouteObserver23Deactivate),
|
|
reinterpret_cast<void**>(&gOriginalRouteObserver23Deactivate));
|
|
}
|
|
AttachProbeHook("FrameMappinPathWrapper", kFrameMappinPathWrapperRva,
|
|
reinterpret_cast<void*>(&DetourFrameMappinPathWrapper),
|
|
reinterpret_cast<void**>(&gOriginalFrameMappinPathWrapper));
|
|
AttachProbeHook("FrameMappinPathCore", kFrameMappinPathCoreRva,
|
|
reinterpret_cast<void*>(&DetourFrameMappinPathCore),
|
|
reinterpret_cast<void**>(&gOriginalFrameMappinPathCore));
|
|
AttachProbeHook("SetSelectedMappinWrapper", kSetSelectedMappinWrapperRva,
|
|
reinterpret_cast<void*>(&DetourSetSelectedMappinWrapper),
|
|
reinterpret_cast<void**>(&gOriginalSetSelectedMappinWrapper));
|
|
AttachProbeHook("SetSelectedMappinByIdWrapper", kSetSelectedMappinByIdWrapperRva,
|
|
reinterpret_cast<void*>(&DetourSetSelectedMappinByIdWrapper),
|
|
reinterpret_cast<void**>(&gOriginalSetSelectedMappinByIdWrapper));
|
|
AttachProbeHook("SetSelectedMappinByPositionWrapper", kSetSelectedMappinByPositionWrapperRva,
|
|
reinterpret_cast<void*>(&DetourSetSelectedMappinByPositionWrapper),
|
|
reinterpret_cast<void**>(&gOriginalSetSelectedMappinByPositionWrapper));
|
|
AttachProbeHook("SetSelectedMappinCore", kSetSelectedMappinCoreRva,
|
|
reinterpret_cast<void*>(&DetourSetSelectedMappinCore),
|
|
reinterpret_cast<void**>(&gOriginalSetSelectedMappinCore));
|
|
AttachProbeHook("TrackCustomPositionMappinWrapper", kTrackCustomPositionMappinWrapperRva,
|
|
reinterpret_cast<void*>(&DetourTrackCustomPositionMappinWrapper),
|
|
reinterpret_cast<void**>(&gOriginalTrackCustomPositionMappinWrapper));
|
|
AttachProbeHook("TrackCustomPositionMappinCore", kTrackCustomPositionMappinCoreRva,
|
|
reinterpret_cast<void*>(&DetourTrackCustomPositionMappinCore),
|
|
reinterpret_cast<void**>(&gOriginalTrackCustomPositionMappinCore));
|
|
AttachProbeHook("UntrackCustomPositionMappinWrapper", kUntrackCustomPositionMappinWrapperRva,
|
|
reinterpret_cast<void*>(&DetourUntrackCustomPositionMappinWrapper),
|
|
reinterpret_cast<void**>(&gOriginalUntrackCustomPositionMappinWrapper));
|
|
AttachProbeHook("TrackMappinWrapper", kTrackMappinWrapperRva,
|
|
reinterpret_cast<void*>(&DetourTrackMappinWrapper),
|
|
reinterpret_cast<void**>(&gOriginalTrackMappinWrapper));
|
|
AttachProbeHook("TrackMappinCore", kTrackMappinCoreRva, reinterpret_cast<void*>(&DetourTrackMappinCore),
|
|
reinterpret_cast<void**>(&gOriginalTrackMappinCore));
|
|
AttachProbeHook("SetMappinTrackingAlternativeWrapper", kSetMappinTrackingAlternativeWrapperRva,
|
|
reinterpret_cast<void*>(&DetourSetMappinTrackingAlternativeWrapper),
|
|
reinterpret_cast<void**>(&gOriginalSetMappinTrackingAlternativeWrapper));
|
|
}
|
|
|
|
if (aReason == RED4ext::v1::EMainReason::Unload)
|
|
{
|
|
DetachProbeHook("RunGPSQuery body 0x29bd128", kRunGpsQueryBodyRva);
|
|
DetachProbeHook("UpdateGPSQuery body 0x29bd254", kUpdateGpsQueryBodyRva);
|
|
DetachProbeHook("GPSQuerySubmit 0x70a42c", kGpsQuerySubmitRva);
|
|
DetachProbeHook("GPSQueryDispatch 0x70a570", kGpsQueryDispatchRva);
|
|
DetachProbeHook("GPSQueryResultFetch 0x7094b8", kGpsQueryResultFetchRva);
|
|
DetachProbeHook("GPSQueryStatus 0xaa5704", kGpsQueryStatusRva);
|
|
DetachProbeHook("GPSSystem/Tick", kGpsSystemTickRva);
|
|
DetachProbeHook("JournalManager::TrackEntry impl", kJournalTrackEntryImplRva);
|
|
if (kEnableVerboseJournalListenerHooks)
|
|
{
|
|
DetachProbeHook("JournalListener::Objective vt28", kJournalListenerObjectiveVt28Rva);
|
|
DetachProbeHook("JournalListener::Objective vt30", kJournalListenerObjectiveVt30Rva);
|
|
DetachProbeHook("JournalListener::Route vt28", kJournalListenerRouteVt28Rva);
|
|
DetachProbeHook("JournalListener::Route vt30", kJournalListenerRouteVt30Rva);
|
|
DetachProbeHook("JournalListener::RouteAlt vt28", kJournalListenerRouteAltVt28Rva);
|
|
DetachProbeHook("JournalListener::RouteAlt vt30", kJournalListenerRouteAltVt30Rva);
|
|
DetachProbeHook("JournalListener::UI vt28", kJournalListenerUiVt28Rva);
|
|
DetachProbeHook("JournalListener::UI vt30", kJournalListenerUiVt30Rva);
|
|
DetachProbeHook("JournalListener::Tracker vt28", kJournalListenerTrackerVt28Rva);
|
|
}
|
|
DetachProbeHook("JournalRouteBridge::Update candidate", kJournalRouteBridgeRva);
|
|
DetachProbeHook("MappinSystem::RouteEventEnqueue slot240", kMappinRouteEventEnqueueRva);
|
|
DetachProbeHook("MappinRouteEvent::Handle", kMappinRouteEventHandlerRva);
|
|
DetachProbeHook("MappinSystem::RouteActivate", kMappinRouteActivateRva);
|
|
DetachProbeHook("MappinSystem::RouteDeactivate", kMappinRouteDeactivateRva);
|
|
DetachProbeHook("RouteBuildCandidate 0x5625a4", kRouteBuildCandidateRva);
|
|
if (kEnableVerboseRouteObserverHooks)
|
|
{
|
|
DetachProbeHook("RouteObserver0::Activate slot48", kRouteObserver0ActivateRva);
|
|
DetachProbeHook("RouteObserver1::Activate slot48", kRouteObserver1ActivateRva);
|
|
DetachProbeHook("RouteObserver23::Activate slot48", kRouteObserver23ActivateRva);
|
|
DetachProbeHook("RouteObserver0::Deactivate slot50", kRouteObserver0DeactivateRva);
|
|
DetachProbeHook("RouteObserver1::Deactivate slot50", kRouteObserver1DeactivateRva);
|
|
DetachProbeHook("RouteObserver23::Deactivate slot50", kRouteObserver23DeactivateRva);
|
|
}
|
|
DetachProbeHook("FrameMappinPathWrapper", kFrameMappinPathWrapperRva);
|
|
DetachProbeHook("FrameMappinPathCore", kFrameMappinPathCoreRva);
|
|
DetachProbeHook("SetSelectedMappinWrapper", kSetSelectedMappinWrapperRva);
|
|
DetachProbeHook("SetSelectedMappinByIdWrapper", kSetSelectedMappinByIdWrapperRva);
|
|
DetachProbeHook("SetSelectedMappinByPositionWrapper", kSetSelectedMappinByPositionWrapperRva);
|
|
DetachProbeHook("SetSelectedMappinCore", kSetSelectedMappinCoreRva);
|
|
DetachProbeHook("TrackCustomPositionMappinWrapper", kTrackCustomPositionMappinWrapperRva);
|
|
DetachProbeHook("TrackCustomPositionMappinCore", kTrackCustomPositionMappinCoreRva);
|
|
DetachProbeHook("UntrackCustomPositionMappinWrapper", kUntrackCustomPositionMappinWrapperRva);
|
|
DetachProbeHook("TrackMappinWrapper", kTrackMappinWrapperRva);
|
|
DetachProbeHook("TrackMappinCore", kTrackMappinCoreRva);
|
|
DetachProbeHook("SetMappinTrackingAlternativeWrapper", kSetMappinTrackingAlternativeWrapperRva);
|
|
DetachAbsoluteHook("MappinSystem::UpdateCustomPosition slot1f0", gMappinUpdateCustomPositionTarget);
|
|
DetachAbsoluteHook("MappinSystem::SetTracked slot220", gMappinSetTrackedTarget);
|
|
DetachAbsoluteHook("MappinSystem::ClearTracked slot228", gMappinClearTrackedTarget);
|
|
DetachAbsoluteHook("MappinSystem::FramePath slot280", gMappinFramePathTarget);
|
|
DetachAbsoluteHook("MappinSystem::PositionQuery slot2e0", gMappinPositionQueryTarget);
|
|
DetachAbsoluteHook("MappinSystem::CreateCustomPosition slot2f0", gMappinCreateCustomPositionTarget);
|
|
DetachAbsoluteHook("MappinSystem::ReleaseQuery slot368", gMappinReleaseQueryTarget);
|
|
DetachAbsoluteHook("MappinSystem::ActiveRoute slot3a8", gMappinActiveRouteTarget);
|
|
DetachAbsoluteHook("Observer1Service::RouteLookup slot220", gObserver1ServiceRouteLookupTarget);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
RED4EXT_C_EXPORT void RED4EXT_CALL Query(RED4ext::v1::PluginInfo* aInfo)
|
|
{
|
|
aInfo->name = L"EdgeWeightGPS";
|
|
aInfo->author = L"salt+Codex";
|
|
aInfo->version = RED4ext::v1::SemVer{0, 1, 0, {0, 0}};
|
|
aInfo->runtime = RED4ext::v1::FileVer{3, 0, 80, 51928};
|
|
aInfo->sdk = RED4ext::v1::SemVer{0, 5, 0, {0, 0}};
|
|
}
|
|
|
|
RED4EXT_C_EXPORT uint32_t RED4EXT_CALL Supports()
|
|
{
|
|
return RED4EXT_API_VERSION_1_COMPAT_0;
|
|
}
|