aboutsummaryrefslogtreecommitdiff
path: root/NorthstarDLL/rpakfilesystem.cpp
blob: b1363589672d077c3ae99ba7af72e5b74ce953ef (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
#include "pch.h"
#include "rpakfilesystem.h"
#include "modmanager.h"
#include "dedicated.h"
#include "tier0.h"

AUTOHOOK_INIT()

// there are more i'm just too lazy to add
struct PakLoadFuncs
{
	void* unk0[3];
	int (*LoadPakAsync)(const char* pPath, void* unknownSingleton, int flags, void* callback0, void* callback1);
	void* unk1[2];
	void* (*UnloadPak)(int iPakHandle, void* callback);
	void* unk2[6];
	void* (*LoadFile)(const char* path); // unsure
	void* unk3[10];
	void* (*ReadFileAsync)(const char* pPath, void* a2);
};

PakLoadFuncs* g_pakLoadApi;

PakLoadManager* g_pPakLoadManager;
void** pUnknownPakLoadSingleton;

int PakLoadManager::LoadPakAsync(const char* pPath, const ePakLoadSource nLoadSource)
{
	int nHandle = g_pakLoadApi->LoadPakAsync(pPath, *pUnknownPakLoadSingleton, 2, nullptr, nullptr);

	// set the load source of the pak we just loaded
	if (nHandle != -1)
		GetPakInfo(nHandle)->m_nLoadSource = nLoadSource;

	return nHandle;
}

void PakLoadManager::UnloadPak(const int nPakHandle)
{
	g_pakLoadApi->UnloadPak(nPakHandle, nullptr);
}

void PakLoadManager::UnloadMapPaks()
{
	for (auto& pair : m_vLoadedPaks)
		if (pair.second.m_nLoadSource == ePakLoadSource::MAP)
			UnloadPak(pair.first);
}

LoadedPak* PakLoadManager::TrackLoadedPak(ePakLoadSource nLoadSource, int nPakHandle, size_t nPakNameHash)
{
	LoadedPak pak;
	pak.m_nLoadSource = nLoadSource;
	pak.m_nPakHandle = nPakHandle;
	pak.m_nPakNameHash = nPakNameHash;

	m_vLoadedPaks.insert(std::make_pair(nPakHandle, pak));
	return &m_vLoadedPaks.at(nPakHandle);
}

void PakLoadManager::RemoveLoadedPak(int nPakHandle)
{
	m_vLoadedPaks.erase(nPakHandle);
}

LoadedPak* PakLoadManager::GetPakInfo(const int nPakHandle)
{
	return &m_vLoadedPaks.at(nPakHandle);
}

int PakLoadManager::GetPakHandle(const size_t nPakNameHash)
{
	for (auto& pair : m_vLoadedPaks)
		if (pair.second.m_nPakNameHash == nPakNameHash)
			return pair.first;

	return -1;
}

int PakLoadManager::GetPakHandle(const char* pPath)
{
	return GetPakHandle(STR_HASH(pPath));
}

void* PakLoadManager::LoadFile(const char* path)
{
	return g_pakLoadApi->LoadFile(path);
}

void HandlePakAliases(char** map)
{
	// convert the pak being loaded to it's aliased one, e.g. aliasing mp_hub_timeshift => sp_hub_timeshift
	for (int64_t i = g_pModManager->m_LoadedMods.size() - 1; i > -1; i--)
	{
		Mod* mod = &g_pModManager->m_LoadedMods[i];
		if (!mod->m_bEnabled)
			continue;

		if (mod->RpakAliases.find(*map) != mod->RpakAliases.end())
		{
			*map = &mod->RpakAliases[*map][0];
			return;
		}
	}
}

void LoadPreloadPaks()
{
	// note, loading from ./ is necessary otherwise paks will load from gamedir/r2/paks
	for (Mod& mod : g_pModManager->m_LoadedMods)
	{
		if (!mod.m_bEnabled)
			continue;

		// need to get a relative path of mod to mod folder
		fs::path modPakPath("./" / mod.m_ModDirectory / "paks");

		for (ModRpakEntry& pak : mod.Rpaks)
			if (pak.m_bAutoLoad)
				g_pPakLoadManager->LoadPakAsync((modPakPath / pak.m_sPakName).string().c_str(), ePakLoadSource::CONSTANT);
	}
}

void LoadPostloadPaks(const char* pPath)
{
	// note, loading from ./ is necessary otherwise paks will load from gamedir/r2/paks
	for (Mod& mod : g_pModManager->m_LoadedMods)
	{
		if (!mod.m_bEnabled)
			continue;

		// need to get a relative path of mod to mod folder
		fs::path modPakPath("./" / mod.m_ModDirectory / "paks");

		for (ModRpakEntry& pak : mod.Rpaks)
			if (pak.m_sLoadAfterPak == pPath)
				g_pPakLoadManager->LoadPakAsync((modPakPath / pak.m_sPakName).string().c_str(), ePakLoadSource::CONSTANT);
	}
}

void LoadCustomMapPaks(char** pakName, bool* bNeedToFreePakName)
{
	// whether the vanilla game has this rpak
	bool bHasOriginalPak = fs::exists(fs::path("r2/paks/Win64/") / *pakName);

	// note, loading from ./ is necessary otherwise paks will load from gamedir/r2/paks
	for (Mod& mod : g_pModManager->m_LoadedMods)
	{
		if (!mod.m_bEnabled)
			continue;

		// need to get a relative path of mod to mod folder
		fs::path modPakPath("./" / mod.m_ModDirectory / "paks");

		for (ModRpakEntry& pak : mod.Rpaks)
		{
			if (!pak.m_bAutoLoad && !pak.m_sPakName.compare(*pakName))
			{
				// if the game doesn't have the original pak, let it handle loading this one as if it was the one it was loading originally
				if (!bHasOriginalPak)
				{
					std::string path = (modPakPath / pak.m_sPakName).string();
					*pakName = new char[path.size() + 1];
					strcpy(*pakName, &path[0]);
					(*pakName)[path.size()] = '\0';

					bHasOriginalPak = true;
					*bNeedToFreePakName =
						true; // we can't free this memory until we're done with the pak, so let whatever's calling this deal with it
				}
				else
					g_pPakLoadManager->LoadPakAsync((modPakPath / pak.m_sPakName).string().c_str(), ePakLoadSource::MAP);
			}
		}
	}
}

// clang-format off
HOOK(LoadPakAsyncHook, LoadPakAsync,
int, __fastcall, (char* pPath, void* unknownSingleton, int flags, void* pCallback0, void* pCallback1))
// clang-format on
{
	HandlePakAliases(&pPath);

	// dont load the pak if it's currently loaded already
	size_t nPathHash = STR_HASH(pPath);
	if (g_pPakLoadManager->GetPakHandle(nPathHash) != -1)
		return -1;

	bool bNeedToFreePakName = false;

	static bool bShouldLoadPaks = true;
	if (bShouldLoadPaks)
	{
		// make a copy of the path for comparing to determine whether we should load this pak on dedi, before it could get overwritten by
		// LoadCustomMapPaks
		std::string originalPath(pPath);

		// disable preloading while we're doing this
		bShouldLoadPaks = false;

		LoadPreloadPaks();
		LoadCustomMapPaks(&pPath, &bNeedToFreePakName);

		bShouldLoadPaks = true;

		// do this after custom paks load and in bShouldLoadPaks so we only ever call this on the root pakload call
		// todo: could probably add some way to flag custom paks to not be loaded on dedicated servers in rpak.json
		if (IsDedicatedServer() && (Tier0::CommandLine()->CheckParm("-nopakdedi") ||
									strncmp(&originalPath[0], "common", 6))) // dedicated only needs common and common_mp
		{
			if (bNeedToFreePakName)
				delete[] pPath;

			spdlog::info("Not loading pak {} for dedicated server", originalPath);
			return -1;
		}
	}

	int iPakHandle = LoadPakAsync(pPath, unknownSingleton, flags, pCallback0, pCallback1);
	spdlog::info("LoadPakAsync {} {}", pPath, iPakHandle);

	// trak the pak
	g_pPakLoadManager->TrackLoadedPak(ePakLoadSource::UNTRACKED, iPakHandle, nPathHash);
	LoadPostloadPaks(pPath);

	if (bNeedToFreePakName)
		delete[] pPath;

	return iPakHandle;
}

// clang-format off
HOOK(UnloadPakHook, UnloadPak,
void*, __fastcall, (int nPakHandle, void* pCallback))
// clang-format on
{
	// stop tracking the pak
	g_pPakLoadManager->RemoveLoadedPak(nPakHandle);

	static bool bShouldUnloadPaks = true;
	if (bShouldUnloadPaks)
	{
		bShouldUnloadPaks = false;
		g_pPakLoadManager->UnloadMapPaks();
		bShouldUnloadPaks = true;
	}

	spdlog::info("UnloadPak {}", nPakHandle);
	return UnloadPak(nPakHandle, pCallback);
}

// we hook this exclusively for resolving stbsp paths, but seemingly it's also used for other stuff like vpk, rpak, mprj and starpak loads
// tbh this actually might be for memory mapped files or something, would make sense i think
// clang-format off
HOOK(ReadFileAsyncHook, ReadFileAsync, 
void*, __fastcall, (const char* pPath, void* pCallback))
// clang-format on
{
	fs::path path(pPath);
	char* allocatedNewPath = nullptr;

	if (path.extension() == ".stbsp")
	{
		fs::path filename = path.filename();
		spdlog::info("LoadStreamBsp: {}", filename.string());

		// resolve modded stbsp path so we can load mod stbsps
		auto modFile = g_pModManager->m_ModFiles.find(g_pModManager->NormaliseModFilePath(fs::path("maps" / filename)));
		if (modFile != g_pModManager->m_ModFiles.end())
		{
			// need to allocate a new string for this
			std::string newPath = (modFile->second.m_pOwningMod->m_ModDirectory / "mod" / modFile->second.m_Path).string();
			allocatedNewPath = new char[newPath.size() + 1];
			strncpy_s(allocatedNewPath, newPath.size() + 1, newPath.c_str(), newPath.size());
			pPath = allocatedNewPath;
		}
	}

	void* ret = ReadFileAsync(pPath, pCallback);
	if (allocatedNewPath)
		delete[] allocatedNewPath;

	return ret;
}

ON_DLL_LOAD("engine.dll", RpakFilesystem, (CModule module))
{
	AUTOHOOK_DISPATCH();

	g_pPakLoadManager = new PakLoadManager;

	g_pakLoadApi = module.Offset(0x5BED78).Deref().As<PakLoadFuncs*>();
	pUnknownPakLoadSingleton = module.Offset(0x7C5E20).As<void**>();

	LoadPakAsyncHook.Dispatch(g_pakLoadApi->LoadPakAsync);
	UnloadPakHook.Dispatch(g_pakLoadApi->UnloadPak);
	ReadFileAsyncHook.Dispatch(g_pakLoadApi->ReadFileAsync);
}