R5Reloaded/r5sdk
1
0
Fork 0
mirror of https://github.com/Mauler125/r5sdk.git synced 2025-02-09 19:15:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

Engine: enforce type name consistency on runtime pak symbols

Browse Source 
Make it consistent with the rest of the code base.
This commit is contained in:
Kawe Mazidjatari 2025-02-03 14:06:45 +01:00
parent 72cbe5bc63
commit c4bf79376e
2 changed files with 36 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
src/engine/cmodel_bsp.cpp
View File

@ -31,13 +31,13 @@
CUtlVector<CUtlString> g_InstalledMaps; CUtlVector<CUtlString> g_InstalledMaps;
CFmtStrN<MAX_MAP_NAME> s_CurrentLevelName; CFmtStrN<MAX_MAP_NAME> s_CurrentLevelName;
static CustomPakData_t s_customPakData; static CustomPakData_s s_customPakData;
static KeyValues* s_pLevelSetKV = nullptr; static KeyValues* s_pLevelSetKV = nullptr;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: load a custom pak and add it to the list // Purpose: load a custom pak and add it to the list
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
PakHandle_t CustomPakData_t::LoadAndAddPak(const char* const pakFile) PakHandle_t CustomPakData_s::LoadAndAddPak(const char* const pakFile)
{ {
if (numHandles >= MAX_CUSTOM_PAKS) if (numHandles >= MAX_CUSTOM_PAKS)
{ {
@ -60,7 +60,7 @@ PakHandle_t CustomPakData_t::LoadAndAddPak(const char* const pakFile)
// NOTE : the array must be kept contiguous; this means that the last pak in // NOTE : the array must be kept contiguous; this means that the last pak in
// the array should always be unloaded fist! // the array should always be unloaded fist!
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void CustomPakData_t::UnloadAndRemovePak(const int index) void CustomPakData_s::UnloadAndRemovePak(const int index)
{ {
const PakHandle_t pakId = handles[index]; const PakHandle_t pakId = handles[index];
assert(pakId != PAK_INVALID_HANDLE); // invalid handles should not be inserted assert(pakId != PAK_INVALID_HANDLE); // invalid handles should not be inserted
@ -75,12 +75,12 @@ void CustomPakData_t::UnloadAndRemovePak(const int index)
// Purpose: preload a custom pak; this keeps it available throughout the // Purpose: preload a custom pak; this keeps it available throughout the
// duration of the process, unless manually removed by user. // duration of the process, unless manually removed by user.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
PakHandle_t CustomPakData_t::PreloadAndAddPak(const char* const pakFile) PakHandle_t CustomPakData_s::PreloadAndAddPak(const char* const pakFile)
{ {
// this must never be called after a non-preloaded pak has been added! // this must never be called after a non-preloaded pak has been added!
// preloaded paks must always appear before custom user requested paks // preloaded paks must always appear before custom user requested paks
// due to the unload order: user-requested -> preloaded -> sdk -> core. // due to the unload order: user-requested -> preloaded -> sdk -> core.
assert(handles[CustomPakData_t::PAK_TYPE_COUNT+numPreload] == PAK_INVALID_HANDLE); assert(handles[CustomPakData_s::PAK_TYPE_COUNT+numPreload] == PAK_INVALID_HANDLE);
const PakHandle_t pakId = LoadAndAddPak(pakFile); const PakHandle_t pakId = LoadAndAddPak(pakFile);
@ -93,7 +93,7 @@ PakHandle_t CustomPakData_t::PreloadAndAddPak(const char* const pakFile)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: unloads all non-preloaded custom pak handles // Purpose: unloads all non-preloaded custom pak handles
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void CustomPakData_t::UnloadAndRemoveNonPreloaded() void CustomPakData_s::UnloadAndRemoveNonPreloaded()
{ {
// Preloaded paks should not be unloaded here, but only right before sdk / // Preloaded paks should not be unloaded here, but only right before sdk /
// engine paks are unloaded. Only unload user requested and level settings // engine paks are unloaded. Only unload user requested and level settings
@ -103,7 +103,7 @@ void CustomPakData_t::UnloadAndRemoveNonPreloaded()
// that of the newer pak. If we remove the newer pak, the engine will try // that of the newer pak. If we remove the newer pak, the engine will try
// and revert the asset to its original state. However we asynchronously // and revert the asset to its original state. However we asynchronously
// unload everything on a single FIFO lock so this is undefined behavior. // unload everything on a single FIFO lock so this is undefined behavior.
for (int i = CustomPakData_t::PAK_TYPE_COUNT+numPreload, n = numHandles; i < n; i++) for (int i = CustomPakData_s::PAK_TYPE_COUNT+numPreload, n = numHandles; i < n; i++)
{ {
UnloadAndRemovePak(i); UnloadAndRemovePak(i);
} }
@ -112,11 +112,11 @@ void CustomPakData_t::UnloadAndRemoveNonPreloaded()
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: unloads all preloaded custom pak handles // Purpose: unloads all preloaded custom pak handles
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void CustomPakData_t::UnloadAndRemovePreloaded() void CustomPakData_s::UnloadAndRemovePreloaded()
{ {
for (int i = 0, n = numPreload; i < n; i++) for (int i = 0, n = numPreload; i < n; i++)
{ {
UnloadAndRemovePak(CustomPakData_t::PAK_TYPE_COUNT + i); UnloadAndRemovePak(CustomPakData_s::PAK_TYPE_COUNT + i);
numPreload--; numPreload--;
} }
} }
@ -124,7 +124,7 @@ void CustomPakData_t::UnloadAndRemovePreloaded()
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: loads the base SDK pak file by type // Purpose: loads the base SDK pak file by type
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
PakHandle_t CustomPakData_t::LoadBasePak(const char* const pakFile, const EPakType type) PakHandle_t CustomPakData_s::LoadBasePak(const char* const pakFile, const PakType_e type)
{ {
const PakHandle_t pakId = g_pakLoadApi->LoadAsync(pakFile, AlignedMemAlloc(), 4, 0); const PakHandle_t pakId = g_pakLoadApi->LoadAsync(pakFile, AlignedMemAlloc(), 4, 0);
@ -138,7 +138,7 @@ PakHandle_t CustomPakData_t::LoadBasePak(const char* const pakFile, const EPakTy
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: unload the SDK base pak file by type // Purpose: unload the SDK base pak file by type
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void CustomPakData_t::UnloadBasePak(const EPakType type) void CustomPakData_s::UnloadBasePak(const PakType_e type)
{ {
const PakHandle_t pakId = handles[type]; const PakHandle_t pakId = handles[type];
@ -274,11 +274,11 @@ void Mod_QueuedPakCacheFrame()
const int numToProcess = startIndex; const int numToProcess = startIndex;
if (startIndex <= CommonPakData_t::PAK_TYPE_LEVEL) if (startIndex <= CommonPakData_s::PAK_TYPE_LEVEL)
{ {
bool keepLoaded = false; bool keepLoaded = false;
int numLeftToProcess = 4; int numLeftToProcess = 4;
CommonPakData_t* data = &g_commonPakData[4]; CommonPakData_s* data = &g_commonPakData[4];
do do
{ {
@ -307,17 +307,17 @@ void Mod_QueuedPakCacheFrame()
switch (numLeftToProcess) switch (numLeftToProcess)
{ {
#ifndef DEDICATED #ifndef DEDICATED
case CommonPakData_t::PAK_TYPE_UI_GM: case CommonPakData_s::PakType_e::PAK_TYPE_UI_GM:
s_customPakData.UnloadBasePak(CustomPakData_t::PAK_TYPE_UI_SDK); s_customPakData.UnloadBasePak(CustomPakData_s::PakType_e::PAK_TYPE_UI_SDK);
break; break;
#endif // !DEDICATED #endif // !DEDICATED
case CommonPakData_t::PAK_TYPE_COMMON: case CommonPakData_s::PakType_e::PAK_TYPE_COMMON:
g_StudioMdlFallbackHandler.Clear(); g_StudioMdlFallbackHandler.Clear();
break; break;
case CommonPakData_t::PAK_TYPE_COMMON_GM: case CommonPakData_s::PakType_e::PAK_TYPE_COMMON_GM:
s_customPakData.UnloadBasePak(CustomPakData_t::PAK_TYPE_COMMON_SDK); s_customPakData.UnloadBasePak(CustomPakData_s::PakType_e::PAK_TYPE_COMMON_SDK);
break; break;
default: default:
@ -326,7 +326,7 @@ void Mod_QueuedPakCacheFrame()
g_pakLoadApi->UnloadAsync(data->pakId); g_pakLoadApi->UnloadAsync(data->pakId);
if (numLeftToProcess == CommonPakData_t::PAK_TYPE_LEVEL) if (numLeftToProcess == CommonPakData_s::PakType_e::PAK_TYPE_LEVEL)
{ {
Mod_UnloadLevelPaks(); // Unload mod pak files. Mod_UnloadLevelPaks(); // Unload mod pak files.
@ -337,7 +337,7 @@ void Mod_QueuedPakCacheFrame()
s_pLevelSetKV = nullptr; s_pLevelSetKV = nullptr;
} }
} }
else if (numLeftToProcess == CommonPakData_t::PAK_TYPE_LOBBY) else if (numLeftToProcess == CommonPakData_s::PakType_e::PAK_TYPE_LOBBY)
{ {
Mod_UnloadPreloadedPaks(); Mod_UnloadPreloadedPaks();
s_customPakData.basePaksLoaded = false; s_customPakData.basePaksLoaded = false;
@ -358,7 +358,7 @@ void Mod_QueuedPakCacheFrame()
} }
*g_pPakPrecacheJobFinished = true; *g_pPakPrecacheJobFinished = true;
CommonPakData_t* commonData = g_commonPakData; CommonPakData_s* commonData = g_commonPakData;
int it = 0; int it = 0;
@ -438,7 +438,7 @@ void Mod_QueuedPakCacheFrame()
} }
} }
if (it == CommonPakData_t::PAK_TYPE_LOBBY) if (it == CommonPakData_s::PakType_e::PAK_TYPE_LOBBY)
{ {
Mod_PreloadPaks(); Mod_PreloadPaks();
s_customPakData.basePaksLoaded = true; s_customPakData.basePaksLoaded = true;
@ -453,11 +453,11 @@ void Mod_QueuedPakCacheFrame()
commonData->pakId = g_pakLoadApi->LoadAsync(name, AlignedMemAlloc(), 4, 0); commonData->pakId = g_pakLoadApi->LoadAsync(name, AlignedMemAlloc(), 4, 0);
#ifndef DEDICATED #ifndef DEDICATED
if (it == CommonPakData_t::PAK_TYPE_UI_GM) if (it == CommonPakData_s::PakType_e::PAK_TYPE_UI_GM)
s_customPakData.LoadBasePak("ui_sdk.rpak", CustomPakData_t::PAK_TYPE_UI_SDK); s_customPakData.LoadBasePak("ui_sdk.rpak", CustomPakData_s::PakType_e::PAK_TYPE_UI_SDK);
#endif // !DEDICATED #endif // !DEDICATED
if (it == CommonPakData_t::PAK_TYPE_COMMON_GM) if (it == CommonPakData_s::PakType_e::PAK_TYPE_COMMON_GM)
s_customPakData.LoadBasePak("common_sdk.rpak", CustomPakData_t::PAK_TYPE_COMMON_SDK); s_customPakData.LoadBasePak("common_sdk.rpak", CustomPakData_s::PakType_e::PAK_TYPE_COMMON_SDK);
CHECK_FOR_FAILURE: CHECK_FOR_FAILURE:

20
src/engine/cmodel_bsp.h
View File

@ -12,9 +12,9 @@ class KeyValues;
// loads for a level, this is used for load/unload management during level // loads for a level, this is used for load/unload management during level
// changes or engine shutdown // changes or engine shutdown
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct CommonPakData_t struct CommonPakData_s
{ {
enum EPakType enum PakType_e
{ {
// the UI pak assigned to the current gamemode (range in GameMode_t) // the UI pak assigned to the current gamemode (range in GameMode_t)
PAK_TYPE_UI_GM = 0, PAK_TYPE_UI_GM = 0,
@ -32,7 +32,7 @@ struct CommonPakData_t
PAK_TYPE_COUNT PAK_TYPE_COUNT
}; };
CommonPakData_t() CommonPakData_s()
{ {
Reset(); Reset();
} }
@ -62,9 +62,9 @@ struct CommonPakData_t
// loaded with the settings KV for that level, these paks are loaded after the // loaded with the settings KV for that level, these paks are loaded after the
// common paks are loaded, but unloaded before the common paks are unloaded // common paks are loaded, but unloaded before the common paks are unloaded
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct CustomPakData_t struct CustomPakData_s
{ {
enum EPakType enum PakType_e
{ {
// the pak that loads after CommonPakData_t::PAK_TYPE_UI_GM has loaded, and // the pak that loads after CommonPakData_t::PAK_TYPE_UI_GM has loaded, and
// unloads before CommonPakData_t::PAK_TYPE_UI_GM gets unloaded // unloads before CommonPakData_t::PAK_TYPE_UI_GM gets unloaded
@ -83,10 +83,10 @@ struct CustomPakData_t
// the absolute max number of custom paks, note that the engine's limit // the absolute max number of custom paks, note that the engine's limit
// could still be reached before this number as game scripts and other // could still be reached before this number as game scripts and other
// code still loads paks such as gladiator cards or load screens // code still loads paks such as gladiator cards or load screens
MAX_CUSTOM_PAKS = (PAK_MAX_LOADED_PAKS - CommonPakData_t::PAK_TYPE_COUNT) MAX_CUSTOM_PAKS = (PAK_MAX_LOADED_PAKS - CommonPakData_s::PAK_TYPE_COUNT)
}; };
CustomPakData_t() CustomPakData_s()
{ {
for (size_t i = 0; i < V_ARRAYSIZE(handles); i++) for (size_t i = 0; i < V_ARRAYSIZE(handles); i++)
{ {
@ -107,8 +107,8 @@ struct CustomPakData_t
void UnloadAndRemoveNonPreloaded(); void UnloadAndRemoveNonPreloaded();
void UnloadAndRemovePreloaded(); void UnloadAndRemovePreloaded();
PakHandle_t LoadBasePak(const char* const pakFile, const EPakType type); PakHandle_t LoadBasePak(const char* const pakFile, const PakType_e type);
void UnloadBasePak(const EPakType type); void UnloadBasePak(const PakType_e type);
private: private:
void UnloadAndRemovePak(const int index); void UnloadAndRemovePak(const int index);
@ -128,7 +128,7 @@ public:
}; };
// array size = CommonPakData_t::PAK_TYPE_COUNT // array size = CommonPakData_t::PAK_TYPE_COUNT
inline CommonPakData_t* g_commonPakData; inline CommonPakData_s* g_commonPakData;
inline void(*v_Mod_LoadPakForMap)(const char* szLevelName); inline void(*v_Mod_LoadPakForMap)(const char* szLevelName);
inline void(*v_Mod_QueuedPakCacheFrame)(void); inline void(*v_Mod_QueuedPakCacheFrame)(void);