Backups/EGameTools
1
0
Fork 0
mirror of https://github.com/EricPlayZ/EGameTools.git synced 2025-07-18 17:37:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

- Added Disable TAA option

Browse Source 
- Added Vec3/Vec4 support for CVars
This commit is contained in:
EricPlayZ
2025-02-11 03:05:29 +02:00
parent f3ece5c0e5
commit acbcba0a69
6 changed files with 235 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
EGameSDK/VarManagerBase.cpp
View File

@ -1,17 +1,29 @@
#include <EGSDK\Vec4.h>
#include <EGSDK\Engine\VarManagerBase.h>
#include <EGSDK\Engine\VarManagerBase.h>
#include <EGSDK\Engine\VarMapBase.h>
#include <EGSDK\Engine\CVars.h>
#include <EGSDK\Vec4.h>
namespace EGSDK::Engine {
#define StaticAssertValueType static_assert(std::is_same_v<T, std::string> || std::is_same_v<T, float> || std::is_same_v<T, int> || std::is_same_v<T, Vec3> || std::is_same_v<T, Vec4> || std::is_same_v<T, bool>, "Invalid type: value must be string, float, int, Vec3, Vec4 or bool")
template <typename VarMapType, typename VarType>
VarMapType VarManagerBase<VarMapType, VarType>::vars;
VarMapType VarManagerBase<VarMapType, VarType>::vars{};
template <typename VarMapType, typename VarType>
VarMapType VarManagerBase<VarMapType, VarType>::customVars;
VarMapType VarManagerBase<VarMapType, VarType>::customVars{};
template <typename VarMapType, typename VarType>
VarMapType VarManagerBase<VarMapType, VarType>::defaultVars;
VarMapType VarManagerBase<VarMapType, VarType>::defaultVars{};
template <typename VarMapType, typename VarType>
std::recursive_mutex VarManagerBase<VarMapType, VarType>::mutex{};
#ifdef EGameSDK_EXPORTS
template <typename VarMapType, typename VarType>
std::unordered_map<std::string, std::any> VarManagerBase<VarMapType, VarType>::prevVarValueMap{};
template <typename VarMapType, typename VarType>
std::unordered_map<std::string, bool> VarManagerBase<VarMapType, VarType>::prevBoolValueMap{};
template <typename VarMapType, typename VarType>
std::unordered_map<std::string, uint64_t> VarManagerBase<VarMapType, VarType>::varOwnerMap{};
#endif
template <typename VarMapType, typename VarType>
template <typename T>
@ -84,21 +96,78 @@ namespace EGSDK::Engine {
var->SetValue(value);
}
template <typename VarMapType, typename VarType>
template <typename T>
void VarManagerBase<VarMapType, VarType>::ManageVarByBool(const std::string& name, T valueIfTrue, T valueIfFalse, bool boolVal, bool usePreviousVal) {
uint64_t caller = reinterpret_cast<uint64_t>(_ReturnAddress());
std::lock_guard<decltype(mutex)> lock(mutex);
auto ownerIt = varOwnerMap.find(name);
if (ownerIt != varOwnerMap.end() && ownerIt->second != caller)
return;
if (!boolVal && prevBoolValueMap.find(name) == prevBoolValueMap.end())
return;
bool& prevBoolValue = prevBoolValueMap[name];
auto& prevValueAny = prevVarValueMap[name];
if (boolVal) {
if (!prevBoolValue) {
auto varValue = GetVarValue<T>(name);
prevVarValueMap[name] = varValue ? *varValue : T{};
}
ChangeVarFromList(name, valueIfTrue);
prevBoolValue = true;
varOwnerMap[name] = caller;
} else if (prevBoolValue) {
ChangeVarFromList(name, usePreviousVal ? std::any_cast<T>(prevValueAny) : valueIfFalse);
defaultVars.Erase(name);
customVars.Erase(name);
prevVarValueMap.erase(name);
prevBoolValueMap.erase(name);
varOwnerMap.erase(name);
}
}
template <typename VarMapType, typename VarType>
bool VarManagerBase<VarMapType, VarType>::IsVarManagedByBool(const std::string& name) {
std::lock_guard<decltype(mutex)> lock(mutex);
return prevBoolValueMap.find(name) != prevBoolValueMap.end() && prevBoolValueMap[name];
}
template EGameSDK_API class VarManagerBase<CVarMap, CVar>;
template EGameSDK_API float* VarManagerBase<CVarMap, CVar>::GetVarValue<float>(const std::string&);
template EGameSDK_API float* VarManagerBase<CVarMap, CVar>::GetVarValue<float>(CVar*);
template EGameSDK_API int* VarManagerBase<CVarMap, CVar>::GetVarValue<int>(const std::string&);
template EGameSDK_API int* VarManagerBase<CVarMap, CVar>::GetVarValue<int>(CVar*);
template EGameSDK_API Vec3* VarManagerBase<CVarMap, CVar>::GetVarValue<Vec3>(const std::string&);
template EGameSDK_API Vec3* VarManagerBase<CVarMap, CVar>::GetVarValue<Vec3>(CVar*);
template EGameSDK_API Vec4* VarManagerBase<CVarMap, CVar>::GetVarValue<Vec4>(const std::string&);
template EGameSDK_API Vec4* VarManagerBase<CVarMap, CVar>::GetVarValue<Vec4>(CVar*);
template EGameSDK_API float* VarManagerBase<CVarMap, CVar>::GetVarValueFromMap<float>(const std::string&, const CVarMap& map);
template EGameSDK_API int* VarManagerBase<CVarMap, CVar>::GetVarValueFromMap<int>(const std::string&, const CVarMap& map);
template EGameSDK_API Vec3* VarManagerBase<CVarMap, CVar>::GetVarValueFromMap<Vec3>(const std::string&, const CVarMap& map);
template EGameSDK_API Vec4* VarManagerBase<CVarMap, CVar>::GetVarValueFromMap<Vec4>(const std::string&, const CVarMap& map);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVar<float>(const std::string&, float);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVar<float>(CVar*, float);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVar<int>(const std::string&, int);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVar<int>(CVar*, int);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVar<Vec3>(const std::string&, Vec3);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVar<Vec3>(CVar*, Vec3);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVar<Vec4>(const std::string&, Vec4);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVar<Vec4>(CVar*, Vec4);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVarFromList<float>(const std::string&, float);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVarFromList<float>(CVar*, float);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVarFromList<int>(const std::string&, int);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVarFromList<int>(CVar*, int);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVarFromList<Vec3>(const std::string&, Vec3);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVarFromList<Vec3>(CVar*, Vec3);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVarFromList<Vec4>(const std::string&, Vec4);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ChangeVarFromList<Vec4>(CVar*, Vec4);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ManageVarByBool<float>(const std::string& name, float valueIfTrue, float valueIfFalse, bool boolVal, bool usePreviousVal);
template EGameSDK_API void VarManagerBase<CVarMap, CVar>::ManageVarByBool<int>(const std::string& name, int valueIfTrue, int valueIfFalse, bool boolVal, bool usePreviousVal);
}

8
EGameSDK/include/EGSDK/Engine/CVars.h
View File

@ -33,6 +33,14 @@ namespace EGSDK::Engine {
public:
explicit IntCVar(const std::string& name);
};
class EGameSDK_API Vec3CVar : public CVar {
public:
explicit Vec3CVar(const std::string& name);
};
class EGameSDK_API Vec4CVar : public CVar {
public:
explicit Vec4CVar(const std::string& name);
};
class EGameSDK_API CVarMap : public VarMapBase<CVar> {
public:

15
EGameSDK/include/EGSDK/Engine/VarManagerBase.h
View File

@ -1,5 +1,8 @@
#pragma once
#include <string>
#include <any>
#include <mutex>
#include <unordered_map>
#include <EGSDK\Exports.h>
namespace EGSDK::Engine {
@ -10,6 +13,12 @@ namespace EGSDK::Engine {
static VarMapType customVars;
static VarMapType defaultVars;
#ifdef EGameSDK_EXPORTS
static std::unordered_map<std::string, std::any> prevVarValueMap;
static std::unordered_map<std::string, bool> prevBoolValueMap;
static std::unordered_map<std::string, uint64_t> varOwnerMap;
#endif
template <typename T>
static T* GetVarValue(const std::string& name);
template <typename T>
@ -25,5 +34,11 @@ namespace EGSDK::Engine {
static void ChangeVarFromList(const std::string& name, T value);
template <typename T>
static void ChangeVarFromList(VarType* var, T value);
template <typename T>
static void ManageVarByBool(const std::string& name, T valueIfTrue, T valueIfFalse, bool boolVal, bool usePreviousVal = true);
static bool IsVarManagedByBool(const std::string& name);
private:
static std::recursive_mutex mutex;
};
}

60
EGameSDK/src/Engine/CVars.cpp
View File

@ -29,6 +29,26 @@ namespace EGSDK::Engine {
it->second.value = *reinterpret_cast<int*>(it->second.valuePtrs[0]);
return it->second.value;
case VarType::Vec3:
if (it == varValues.end())
return varValues[this].value = Vec3();
if (!it->second.valuePtrs.size())
return it->second.value;
if (!it->second.valuePtrs[0])
return it->second.value;
it->second.value = *reinterpret_cast<Vec3*>(it->second.valuePtrs[0]);
return it->second.value;
case VarType::Vec4:
if (it == varValues.end())
return varValues[this].value = Vec4();
if (!it->second.valuePtrs.size())
return it->second.value;
if (!it->second.valuePtrs[0])
return it->second.value;
it->second.value = *reinterpret_cast<Vec4*>(it->second.valuePtrs[0]);
return it->second.value;
default:
if (it == varValues.end())
return varValues[this].value = 0;
@ -40,23 +60,45 @@ namespace EGSDK::Engine {
switch (GetType()) {
case VarType::Float:
{
if (auto floatVal = std::get_if<float>(&value)) {
if (auto actualValue = std::get_if<float>(&value)) {
for (const auto& ptr : varValues[this].valuePtrs) {
if (ptr)
*reinterpret_cast<float*>(ptr) = *floatVal;
*reinterpret_cast<float*>(ptr) = *actualValue;
}
varValues[this].value = *floatVal;
varValues[this].value = *actualValue;
}
break;
}
case VarType::Int:
{
if (auto intVal = std::get_if<int>(&value)) {
if (auto actualValue = std::get_if<int>(&value)) {
for (const auto& ptr : varValues[this].valuePtrs) {
if (ptr)
*reinterpret_cast<int*>(ptr) = *intVal;
*reinterpret_cast<int*>(ptr) = *actualValue;
}
varValues[this].value = *intVal;
varValues[this].value = *actualValue;
}
break;
}
case VarType::Vec3:
{
if (auto actualValue = std::get_if<Vec3>(&value)) {
for (const auto& ptr : varValues[this].valuePtrs) {
if (ptr)
*reinterpret_cast<Vec3*>(ptr) = *actualValue;
}
varValues[this].value = *actualValue;
}
break;
}
case VarType::Vec4:
{
if (auto actualValue = std::get_if<Vec4>(&value)) {
for (const auto& ptr : varValues[this].valuePtrs) {
if (ptr)
*reinterpret_cast<Vec4*>(ptr) = *actualValue;
}
varValues[this].value = *actualValue;
}
break;
}
@ -73,6 +115,12 @@ namespace EGSDK::Engine {
IntCVar::IntCVar(const std::string& name) : CVar(name) {
SetType(VarType::Int);
}
Vec3CVar::Vec3CVar(const std::string& name) : CVar(name) {
SetType(VarType::Vec3);
}
Vec4CVar::Vec4CVar(const std::string& name) : CVar(name) {
SetType(VarType::Vec4);
}
std::unique_ptr<CVar>& CVarMap::try_emplace(std::unique_ptr<CVar> cVar) {
std::lock_guard<decltype(mutex)> lock(mutex);

28
EGameTools/src/Engine/Engine_Hooks.cpp
View File

@ -292,6 +292,20 @@ namespace EGT::Engine {
EGSDK::Engine::CVars::vars.try_emplace(std::unique_ptr<EGSDK::Engine::CVar>(cVarPtr));
break;
}
case 0x1C8:
{
cVarPtr->SetName(name);
cVarPtr->SetType(EGSDK::Engine::VarType::Vec3);
EGSDK::Engine::CVars::vars.try_emplace(std::unique_ptr<EGSDK::Engine::CVar>(cVarPtr));
break;
}
case 0x1D8:
{
cVarPtr->SetName(name);
cVarPtr->SetType(EGSDK::Engine::VarType::Vec4);
EGSDK::Engine::CVars::vars.try_emplace(std::unique_ptr<EGSDK::Engine::CVar>(cVarPtr));
break;
}
default:
break;
}
@ -331,6 +345,20 @@ namespace EGT::Engine {
cVar->SetValue(*value);
break;
}
case EGSDK::Engine::VarType::Vec3:
{
auto value = EGSDK::Engine::CVars::GetVarValue<EGSDK::Vec3>(customCVar);
if (value)
cVar->SetValue(*value);
break;
}
case EGSDK::Engine::VarType::Vec4:
{
auto value = EGSDK::Engine::CVars::GetVarValue<EGSDK::Vec4>(customCVar);
if (value)
cVar->SetValue(*value);
break;
}
}
return varValuePtr;

61
EGameTools/src/Menu/Misc.cpp
View File

@ -12,15 +12,16 @@ namespace EGT::Menu {
namespace Misc {
ImGui::KeyBindOption disableGamePauseWhileAFK{ false, VK_NONE };
ImGui::KeyBindOption disableHUD{ false, VK_F8 };
ImGui::KeyBindOption disableTAA{ false, VK_NONE };
ImGui::Option disableSavegameCRCCheck{ false };
ImGui::Option disableDataPAKsCRCCheck{ false };
ImGui::Option increaseDataPAKsLimit{ false };
static char rendererCVarsSearchFilter[64];
static void UpdateDisabledOptions() {
auto iLevel = EGSDK::GamePH::LevelDI::Get();
disableHUD.SetChangesAreDisabled(!iLevel || !iLevel->IsLoaded());
static void RendererCVarsUpdate() {
EGSDK::Engine::CVars::ManageVarByBool("i_pp_taa_on", 0, 1, disableTAA.GetValue());
EGSDK::Engine::CVars::ManageVarByBool("i_pp_jitter_on", 0, 1, disableTAA.GetValue());
}
static bool ShouldDisplayVariable(const std::unique_ptr<EGSDK::Engine::CVar>& cVarPtr, const std::string& searchFilter) {
@ -57,6 +58,24 @@ namespace EGT::Menu {
EGSDK::Engine::CVars::ChangeVar(cVar->GetName(), *defValue);
break;
}
case EGSDK::Engine::VarType::Vec3:
{
auto defValue = EGSDK::Engine::CVars::GetVarValueFromMap<EGSDK::Vec3>(cVar->GetName(), EGSDK::Engine::CVars::defaultVars);
if (!defValue)
return;
EGSDK::Engine::CVars::ChangeVar(cVar->GetName(), *defValue);
break;
}
case EGSDK::Engine::VarType::Vec4:
{
auto defValue = EGSDK::Engine::CVars::GetVarValueFromMap<EGSDK::Vec4>(cVar->GetName(), EGSDK::Engine::CVars::defaultVars);
if (!defValue)
return;
EGSDK::Engine::CVars::ChangeVar(cVar->GetName(), *defValue);
break;
}
}
EGSDK::Engine::CVars::defaultVars.Erase(cVar->GetName());
@ -71,6 +90,7 @@ namespace EGT::Menu {
static void RenderRendererCVar(const std::unique_ptr<EGSDK::Engine::CVar>& cVarPtr) {
auto cVar = cVarPtr.get();
ImGui::BeginDisabled(EGSDK::Engine::CVars::IsVarManagedByBool(cVar->GetName()));
switch (cVar->GetType()) {
case EGSDK::Engine::VarType::Float:
{
@ -94,14 +114,37 @@ namespace EGT::Menu {
EGSDK::Engine::CVars::ChangeVarFromList(cVar, newValue);
break;
}
case EGSDK::Engine::VarType::Vec3:
{
auto value = EGSDK::Engine::CVars::GetVarValue<EGSDK::Vec3>(cVar);
if (!value)
return;
auto newValue = *value;
if (ImGui::InputFloat3(cVar->GetName(), reinterpret_cast<float*>(&newValue)))
EGSDK::Engine::CVars::ChangeVarFromList(cVar, newValue);
break;
}
case EGSDK::Engine::VarType::Vec4:
{
auto value = EGSDK::Engine::CVars::GetVarValue<EGSDK::Vec4>(cVar);
if (!value)
return;
auto newValue = *value;
if (ImGui::InputFloat4(cVar->GetName(), reinterpret_cast<float*>(&newValue)))
EGSDK::Engine::CVars::ChangeVarFromList(cVar, newValue);
break;
}
default:
break;
}
ImGui::EndDisabled();
ImGui::SameLine();
std::string restoreBtnName = "Restore##" + std::string(cVar->GetName());
ImGui::BeginDisabled(EGSDK::Engine::CVars::customVars.none_of(cVar->GetName()));
ImGui::BeginDisabled(EGSDK::Engine::CVars::customVars.none_of(cVar->GetName()) || EGSDK::Engine::CVars::IsVarManagedByBool(cVar->GetName()));
if (ImGui::Button(restoreBtnName.c_str(), "Restores renderer cvar to default"))
RestoreVariableToDefault(cVarPtr);
ImGui::EndDisabled();
@ -129,11 +172,18 @@ namespace EGT::Menu {
ImGui::EndDisabled();
}
static void UpdateDisabledOptions() {
auto iLevel = EGSDK::GamePH::LevelDI::Get();
disableHUD.SetChangesAreDisabled(!iLevel || !iLevel->IsLoaded());
}
Tab Tab::instance{};
void Tab::Init() {}
void Tab::Update() {
UpdateDisabledOptions();
RendererCVarsUpdate();
auto iLevel = EGSDK::GamePH::LevelDI::Get();
if (!iLevel)
return;
@ -156,11 +206,12 @@ namespace EGT::Menu {
ImGui::SeparatorText("Misc##Misc");
ImGui::CheckboxHotkey("Disable Game Pause While AFK", &disableGamePauseWhileAFK, "Prevents the game from pausing while you're afk");
ImGui::SameLine();
ImGui::BeginDisabled(disableHUD.GetChangesAreDisabled());
ImGui::CheckboxHotkey("Disable HUD", &disableHUD, "Disables the entire HUD, including any sort of menus like the pause menu");
ImGui::EndDisabled();
ImGui::CheckboxHotkey("Disable TAA", &disableTAA, "Disables the TAA/anti-aliasing (only works if you have upscaling disabled)");
ImGui::SeparatorText("Scripting##Misc");
HandleRendererCVarsList();