206 lines
7.1 KiB
C++
206 lines
7.1 KiB
C++
#include "pch.h"
|
|
#include "filesystem.h"
|
|
#include "hooks.h"
|
|
#include "hookutils.h"
|
|
#include "sourceinterface.h"
|
|
#include "modmanager.h"
|
|
|
|
#include <iostream>
|
|
#include <sstream>
|
|
|
|
// hook forward declares
|
|
typedef FileHandle_t (*ReadFileFromVPKType)(VPKData* vpkInfo, __int64* b, char* filename);
|
|
ReadFileFromVPKType readFileFromVPK;
|
|
FileHandle_t ReadFileFromVPKHook(VPKData* vpkInfo, __int64* b, char* filename);
|
|
|
|
typedef bool (*ReadFromCacheType)(IFileSystem* filesystem, char* path, void* result);
|
|
ReadFromCacheType readFromCache;
|
|
bool ReadFromCacheHook(IFileSystem* filesystem, char* path, void* result);
|
|
|
|
typedef void (*AddSearchPathType)(IFileSystem* fileSystem, const char* pPath, const char* pathID, SearchPathAdd_t addType);
|
|
AddSearchPathType addSearchPathOriginal;
|
|
void AddSearchPathHook(IFileSystem* fileSystem, const char* pPath, const char* pathID, SearchPathAdd_t addType);
|
|
|
|
typedef FileHandle_t (*ReadFileFromFilesystemType)(
|
|
IFileSystem* filesystem, const char* pPath, const char* pOptions, int64_t a4, uint32_t a5);
|
|
ReadFileFromFilesystemType readFileFromFilesystem;
|
|
FileHandle_t ReadFileFromFilesystemHook(IFileSystem* filesystem, const char* pPath, const char* pOptions, int64_t a4, uint32_t a5);
|
|
|
|
typedef VPKData* (*MountVPKType)(IFileSystem* fileSystem, const char* vpkPath);
|
|
MountVPKType mountVPK;
|
|
VPKData* MountVPKHook(IFileSystem* fileSystem, const char* vpkPath);
|
|
|
|
bool readingOriginalFile;
|
|
std::string currentModPath;
|
|
SourceInterface<IFileSystem>* g_Filesystem;
|
|
|
|
void InitialiseFilesystem(HMODULE baseAddress)
|
|
{
|
|
g_Filesystem = new SourceInterface<IFileSystem>("filesystem_stdio.dll", "VFileSystem017");
|
|
|
|
// create hooks
|
|
HookEnabler hook;
|
|
ENABLER_CREATEHOOK(hook, (char*)baseAddress + 0x5CBA0, &ReadFileFromVPKHook, reinterpret_cast<LPVOID*>(&readFileFromVPK));
|
|
ENABLER_CREATEHOOK(
|
|
hook,
|
|
reinterpret_cast<void*>((*g_Filesystem)->m_vtable->ReadFromCache),
|
|
&ReadFromCacheHook,
|
|
reinterpret_cast<LPVOID*>(&readFromCache));
|
|
ENABLER_CREATEHOOK(
|
|
hook,
|
|
reinterpret_cast<void*>((*g_Filesystem)->m_vtable->AddSearchPath),
|
|
&AddSearchPathHook,
|
|
reinterpret_cast<LPVOID*>(&addSearchPathOriginal));
|
|
ENABLER_CREATEHOOK(hook, (char*)baseAddress + 0x15F20, &ReadFileFromFilesystemHook, reinterpret_cast<LPVOID*>(&readFileFromFilesystem));
|
|
ENABLER_CREATEHOOK(
|
|
hook, reinterpret_cast<void*>((*g_Filesystem)->m_vtable->MountVPK), &MountVPKHook, reinterpret_cast<LPVOID*>(&mountVPK));
|
|
}
|
|
|
|
std::string ReadVPKFile(const char* path)
|
|
{
|
|
// read scripts.rson file, todo: check if this can be overwritten
|
|
FileHandle_t fileHandle = (*g_Filesystem)->m_vtable2->Open(&(*g_Filesystem)->m_vtable2, path, "rb", "GAME", 0);
|
|
|
|
std::stringstream fileStream;
|
|
int bytesRead = 0;
|
|
char data[4096];
|
|
do
|
|
{
|
|
bytesRead = (*g_Filesystem)->m_vtable2->Read(&(*g_Filesystem)->m_vtable2, data, (int)std::size(data), fileHandle);
|
|
fileStream.write(data, bytesRead);
|
|
} while (bytesRead == std::size(data));
|
|
|
|
(*g_Filesystem)->m_vtable2->Close(*g_Filesystem, fileHandle);
|
|
|
|
return fileStream.str();
|
|
}
|
|
|
|
std::string ReadVPKOriginalFile(const char* path)
|
|
{
|
|
readingOriginalFile = true;
|
|
std::string ret = ReadVPKFile(path);
|
|
readingOriginalFile = false;
|
|
|
|
return ret;
|
|
}
|
|
|
|
void SetNewModSearchPaths(Mod* mod)
|
|
{
|
|
// put our new path to the head if we need to read from a different mod path
|
|
// in the future we could also determine whether the file we're setting paths for needs a mod dir, or compiled assets
|
|
if (mod != nullptr)
|
|
{
|
|
if ((fs::absolute(mod->ModDirectory) / MOD_OVERRIDE_DIR).string().compare(currentModPath))
|
|
{
|
|
spdlog::info("changing mod search path from {} to {}", currentModPath, mod->ModDirectory.string());
|
|
|
|
addSearchPathOriginal(
|
|
&*(*g_Filesystem), (fs::absolute(mod->ModDirectory) / MOD_OVERRIDE_DIR).string().c_str(), "GAME", PATH_ADD_TO_HEAD);
|
|
currentModPath = (fs::absolute(mod->ModDirectory) / MOD_OVERRIDE_DIR).string();
|
|
}
|
|
}
|
|
else // push compiled to head
|
|
addSearchPathOriginal(&*(*g_Filesystem), fs::absolute(GetCompiledAssetsPath()).string().c_str(), "GAME", PATH_ADD_TO_HEAD);
|
|
}
|
|
|
|
bool TryReplaceFile(char* path, bool shouldCompile)
|
|
{
|
|
if (readingOriginalFile)
|
|
return false;
|
|
|
|
if (shouldCompile)
|
|
(*g_ModManager).CompileAssetsForFile(path);
|
|
|
|
// idk how efficient the lexically normal check is
|
|
// can't just set all /s in path to \, since some paths aren't in writeable memory
|
|
auto file = g_ModManager->m_modFiles.find(fs::path(path).lexically_normal().string());
|
|
if (file != g_ModManager->m_modFiles.end())
|
|
{
|
|
SetNewModSearchPaths(file->second.owningMod);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
FileHandle_t ReadFileFromVPKHook(VPKData* vpkInfo, __int64* b, char* filename)
|
|
{
|
|
// move this to a convar at some point when we can read them in native
|
|
// spdlog::info("ReadFileFromVPKHook {} {}", filename, vpkInfo->path);
|
|
|
|
// there is literally never any reason to compile here, since we'll always compile in ReadFileFromFilesystemHook in the same codepath
|
|
// this is called
|
|
if (TryReplaceFile(filename, false))
|
|
{
|
|
*b = -1;
|
|
return b;
|
|
}
|
|
|
|
return readFileFromVPK(vpkInfo, b, filename);
|
|
}
|
|
|
|
bool ReadFromCacheHook(IFileSystem* filesystem, char* path, void* result)
|
|
{
|
|
// move this to a convar at some point when we can read them in native
|
|
// spdlog::info("ReadFromCacheHook {}", path);
|
|
|
|
if (TryReplaceFile(path, true))
|
|
return false;
|
|
|
|
return readFromCache(filesystem, path, result);
|
|
}
|
|
|
|
void AddSearchPathHook(IFileSystem* fileSystem, const char* pPath, const char* pathID, SearchPathAdd_t addType)
|
|
{
|
|
addSearchPathOriginal(fileSystem, pPath, pathID, addType);
|
|
|
|
// make sure current mod paths are at head
|
|
if (!strcmp(pathID, "GAME") && currentModPath.compare(pPath) && addType == PATH_ADD_TO_HEAD)
|
|
{
|
|
addSearchPathOriginal(fileSystem, currentModPath.c_str(), "GAME", PATH_ADD_TO_HEAD);
|
|
addSearchPathOriginal(fileSystem, GetCompiledAssetsPath().string().c_str(), "GAME", PATH_ADD_TO_HEAD);
|
|
}
|
|
}
|
|
|
|
FileHandle_t ReadFileFromFilesystemHook(IFileSystem* filesystem, const char* pPath, const char* pOptions, int64_t a4, uint32_t a5)
|
|
{
|
|
// this isn't super efficient, but it's necessary, since calling addsearchpath in readfilefromvpk doesn't work, possibly refactor later
|
|
// it also might be possible to hook functions that are called later, idk look into callstack for ReadFileFromVPK
|
|
if (!readingOriginalFile)
|
|
TryReplaceFile((char*)pPath, true);
|
|
|
|
return readFileFromFilesystem(filesystem, pPath, pOptions, a4, a5);
|
|
}
|
|
|
|
VPKData* MountVPKHook(IFileSystem* fileSystem, const char* vpkPath)
|
|
{
|
|
spdlog::info("MountVPK {}", vpkPath);
|
|
VPKData* ret = mountVPK(fileSystem, vpkPath);
|
|
|
|
for (Mod mod : g_ModManager->m_loadedMods)
|
|
{
|
|
if (!mod.Enabled)
|
|
continue;
|
|
|
|
for (ModVPKEntry& vpkEntry : mod.Vpks)
|
|
{
|
|
// if we're autoloading, just load no matter what
|
|
if (!vpkEntry.m_bAutoLoad)
|
|
{
|
|
// resolve vpk name and try to load one with the same name
|
|
// todo: we should be unloading these on map unload manually
|
|
std::string mapName(fs::path(vpkPath).filename().string());
|
|
std::string modMapName(fs::path(vpkEntry.m_sVpkPath.c_str()).filename().string());
|
|
if (mapName.compare(modMapName))
|
|
continue;
|
|
}
|
|
|
|
VPKData* loaded = mountVPK(fileSystem, vpkEntry.m_sVpkPath.c_str());
|
|
if (!ret) // this is primarily for map vpks and stuff, so the map's vpk is what gets returned from here
|
|
ret = loaded;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|