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

cleaned up CVars, added Disable TAA to config

Browse Source
This commit is contained in:
EricPlayZ
2025-02-13 00:49:45 +02:00
parent acbcba0a69
commit 3017ec4d53
6 changed files with 215 additions and 284 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
EGameSDK/VarManagerBase.cpp
View File

@ -1,11 +1,8 @@
#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{};
template <typename VarMapType, typename VarType>
@ -25,149 +22,36 @@ namespace EGSDK::Engine {
std::unordered_map<std::string, uint64_t> VarManagerBase<VarMapType, VarType>::varOwnerMap{};
#endif
template <typename VarMapType, typename VarType>
template <typename T>
T* VarManagerBase<VarMapType, VarType>::GetVarValue(const std::string& name) {
StaticAssertValueType;
auto var = vars.Find(name);
return var ? std::get_if<T>(&var->GetValue()) : nullptr;
}
template <typename VarMapType, typename VarType>
template <typename T>
T* VarManagerBase<VarMapType, VarType>::GetVarValue(VarType* var) {
StaticAssertValueType;
return var ? std::get_if<T>(&var->GetValue()) : nullptr;
}
template <typename VarMapType, typename VarType>
template <typename T>
T* VarManagerBase<VarMapType, VarType>::GetVarValueFromMap(const std::string& name, const VarMapType& map) {
StaticAssertValueType;
auto var = map.Find(name);
return var ? std::get_if<T>(&var->GetValue()) : nullptr;
}
template <typename VarMapType, typename VarType>
template <typename T>
void VarManagerBase<VarMapType, VarType>::ChangeVar(const std::string& name, T value) {
StaticAssertValueType;
auto var = vars.Find(name);
if (var)
var->SetValue(value);
}
template <typename VarMapType, typename VarType>
template <typename T>
void VarManagerBase<VarMapType, VarType>::ChangeVar(VarType* var, T value) {
StaticAssertValueType;
if (var)
var->SetValue(value);
}
template <typename VarMapType, typename VarType>
template <typename T>
void VarManagerBase<VarMapType, VarType>::ChangeVarFromList(const std::string& name, T value) {
StaticAssertValueType;
auto var = vars.Find(name);
if (!var)
return;
ChangeVarFromList<T>(var, value);
}
template <typename VarMapType, typename VarType>
template <typename T>
void VarManagerBase<VarMapType, VarType>::ChangeVarFromList(VarType* var, T value) {
StaticAssertValueType;
if (!var)
return;
auto customVar = customVars.Find(var->GetName());
auto defVar = defaultVars.Find(var->GetName());
if (!customVar)
customVar = customVars.try_emplace(std::make_unique<VarType>(var->GetName(), var->GetType())).get();
if (!defVar) {
defVar = defaultVars.try_emplace(std::make_unique<VarType>(var->GetName(), var->GetType())).get();
if (auto varValue = GetVarValue<T>(var); defVar && varValue)
defVar->SetValue(*varValue);
}
if (customVar)
customVar->SetValue(value);
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 <typename VarMapType, typename VarType>
bool VarManagerBase<VarMapType, VarType>::DoesVarHaveCustomValue(const std::string& name) {
return !customVars.none_of(cVar->GetName());
}
template <typename VarMapType, typename VarType>
bool VarManagerBase<VarMapType, VarType>::AreAnyVarsPresent() {
return !vars.empty();
}
template <typename VarMapType, typename VarType>
bool VarManagerBase<VarMapType, VarType>::AreAnyCustomVarsPresent() {
return !customVars.empty();
}
template <typename VarMapType, typename VarType>
bool VarManagerBase<VarMapType, VarType>::AreAllCustomVarsManagedByBool() {
bool allManagedByBool = true;
customVars.ForEach([&allManagedByBool](const std::unique_ptr<VarType>& varPtr) {
if (!IsVarManagedByBool(varPtr->GetName())) {
allManagedByBool = false;
return;
}
});
return allManagedByBool;
}
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);
}

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

@ -3,9 +3,17 @@
#include <any>
#include <mutex>
#include <unordered_map>
#include <intrin.h>
#include <variant>
#include <EGSDK\Exports.h>
#include <EGSDK\Vec3.h>
#include <EGSDK\Vec4.h>
#pragma intrinsic(_ReturnAddress)
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>
class EGameSDK_API VarManagerBase {
public:
@ -13,32 +21,129 @@ namespace EGSDK::Engine {
static VarMapType customVars;
static VarMapType defaultVars;
#ifdef EGameSDK_EXPORTS
template <typename T>
static T* GetVarValue(const std::string& name) {
StaticAssertValueType;
auto var = vars.Find(name);
return var ? std::get_if<T>(&var->GetValue()) : nullptr;
}
template <typename T>
static T* GetVarValue(VarType* var) {
StaticAssertValueType;
return var ? std::get_if<T>(&var->GetValue()) : nullptr;
}
template <typename T>
static T* GetVarValueFromMap(const std::string& name, const VarMapType& map) {
StaticAssertValueType;
auto var = map.Find(name);
return var ? std::get_if<T>(&var->GetValue()) : nullptr;
}
template <typename T>
static void ChangeVar(const std::string& name, T value) {
StaticAssertValueType;
auto var = vars.Find(name);
if (var)
var->SetValue(value);
}
template <typename T>
static void ChangeVar(VarType* var, T value) {
StaticAssertValueType;
if (var)
var->SetValue(value);
}
template <typename T>
static void ChangeVarFromList(const std::string& name, T value) {
StaticAssertValueType;
auto var = vars.Find(name);
if (!var)
return;
ChangeVarFromList<T>(var, value);
}
template <typename T>
static void ChangeVarFromList(VarType* var, T value) {
StaticAssertValueType;
if (!var)
return;
auto customVar = customVars.Find(var->GetName());
auto defVar = defaultVars.Find(var->GetName());
if (!customVar)
customVar = customVars.try_emplace(std::make_unique<VarType>(var->GetName(), var->GetType())).get();
if (!defVar) {
defVar = defaultVars.try_emplace(std::make_unique<VarType>(var->GetName(), var->GetType())).get();
if (auto varValue = GetVarValue<T>(var); defVar && varValue)
defVar->SetValue(*varValue);
}
if (customVar)
customVar->SetValue(value);
var->SetValue(value);
}
template <typename T>
static void ManageVarByBool(const std::string& name, T valueIfTrue, T valueIfFalse, bool boolVal, bool usePreviousVal = true) {
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);
}
}
static bool IsVarManagedByBool(const std::string& name);
static bool DoesVarHaveCustomValue(const std::string& name);
static bool AreAnyVarsPresent();
static bool AreAnyCustomVarsPresent();
static bool AreAllCustomVarsManagedByBool();
template <typename T>
static void RestoreVariableToDefault(VarType* var) {
if (IsVarManagedByBool(var->GetName()))
return;
auto defValue = GetVarValueFromMap<T>(var->GetName(), defaultVars);
if (!defValue)
return;
ChangeVar(var->GetName(), *defValue);
defaultVars.Erase(var->GetName());
customVars.Erase(var->GetName());
}
private:
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>
static T* GetVarValue(VarType* var);
template <typename T>
static T* GetVarValueFromMap(const std::string& name, const VarMapType& map);
template <typename T>
static void ChangeVar(const std::string& name, T value);
template <typename T>
static void ChangeVar(VarType* var, T value);
template <typename T>
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;
};
#undef StaticAssertValueType
}

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

@ -8,101 +8,66 @@ namespace EGSDK::Engine {
VarValueType& CVar::GetValue() {
std::lock_guard<decltype(mutex)> lock(mutex);
auto it = varValues.find(this);
if (it == varValues.end()) {
switch (GetType()) {
case VarType::Float:
return varValues[this].value = 0.0f;
break;
case VarType::Int:
return varValues[this].value = 0;
break;
case VarType::Vec3:
return varValues[this].value = Vec3();
break;
case VarType::Vec4:
return varValues[this].value = Vec4();
break;
default:
return varValues[this].value = 0;
break;
}
}
auto& varData = it->second;
if (varData.valuePtrs.empty())
return varData.value;
auto ptr = varData.valuePtrs[0];
if (!ptr)
return varData.value;
switch (GetType()) {
case VarType::Float:
if (it == varValues.end())
return varValues[this].value = 0.0f;
if (!it->second.valuePtrs.size())
return it->second.value;
if (!it->second.valuePtrs[0])
return it->second.value;
it->second.value = *reinterpret_cast<float*>(it->second.valuePtrs[0]);
return it->second.value;
return varData.value = *reinterpret_cast<float*>(ptr);
case VarType::Int:
if (it == varValues.end())
return varValues[this].value = 0;
if (!it->second.valuePtrs.size())
return it->second.value;
if (!it->second.valuePtrs[0])
return it->second.value;
it->second.value = *reinterpret_cast<int*>(it->second.valuePtrs[0]);
return it->second.value;
return varData.value = *reinterpret_cast<int*>(ptr);
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;
return varData.value = *reinterpret_cast<Vec3*>(ptr);
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;
return varData.value = *reinterpret_cast<Vec4*>(ptr);
default:
if (it == varValues.end())
return varValues[this].value = 0;
return it->second.value;
}
}
void CVar::SetValue(const VarValueType& value) {
std::lock_guard<decltype(mutex)> lock(mutex);
switch (GetType()) {
case VarType::Float:
{
if (auto actualValue = std::get_if<float>(&value)) {
for (const auto& ptr : varValues[this].valuePtrs) {
if (ptr)
*reinterpret_cast<float*>(ptr) = *actualValue;
std::lock_guard lock(mutex);
auto& varData = varValues[this];
std::visit([&](auto&& val) {
using T = std::decay_t<decltype(val)>;
if constexpr (std::is_same_v<T, float> || std::is_same_v<T, int> || std::is_same_v<T, Vec3> || std::is_same_v<T, Vec4>) {
for (auto* ptr : varData.valuePtrs) {
if (ptr) {
if constexpr (std::is_same_v<T, float>)
*reinterpret_cast<float*>(ptr) = val;
else if constexpr (std::is_same_v<T, int>)
*reinterpret_cast<int*>(ptr) = val;
else if constexpr (std::is_same_v<T, Vec3>)
*reinterpret_cast<Vec3*>(ptr) = val;
else if constexpr (std::is_same_v<T, Vec4>)
*reinterpret_cast<Vec4*>(ptr) = val;
}
varValues[this].value = *actualValue;
}
break;
varData.value = val;
}
case VarType::Int:
{
if (auto actualValue = std::get_if<int>(&value)) {
for (const auto& ptr : varValues[this].valuePtrs) {
if (ptr)
*reinterpret_cast<int*>(ptr) = *actualValue;
}
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;
}
}
}, value);
}
void CVar::AddValuePtr(uint64_t* ptr) {
std::lock_guard<decltype(mutex)> lock(mutex);

1
EGameTools/include/EGT/Menu/Misc.h
View File

@ -5,6 +5,7 @@ namespace EGT::Menu {
namespace Misc {
extern ImGui::KeyBindOption disableGamePauseWhileAFK;
extern ImGui::KeyBindOption disableHUD;
extern ImGui::KeyBindOption disableTAA;
extern ImGui::Option disableSavegameCRCCheck;
extern ImGui::Option disableDataPAKsCRCCheck;
extern ImGui::Option increaseDataPAKsLimit;

2
EGameTools/src/Config/Config.cpp
View File

@ -74,6 +74,7 @@ namespace EGT::Config {
{ "Menu:Keybinds", "TeleportToSelectedLocationToggleKey", Menu::Teleport::teleportToSelectedLocation.ToStringVKeyMap(), &Menu::Teleport::teleportToSelectedLocation, String },
{ "Menu:Keybinds", "TeleportToCoordsToggleKey", Menu::Teleport::teleportToCoords.ToStringVKeyMap(), &Menu::Teleport::teleportToCoords, String },
{ "Menu:Keybinds", "DisableHUDToggleKey", Menu::Misc::disableHUD.ToStringVKeyMap(), &Menu::Misc::disableHUD, String },
{ "Menu:Keybinds", "DisableTAAToggleKey", Menu::Misc::disableTAA.ToStringVKeyMap(), &Menu::Misc::disableTAA, String },
{ "Menu:Keybinds", "DisableGamePauseWhileAFKToggleKey", Menu::Misc::disableGamePauseWhileAFK.ToStringVKeyMap(), &Menu::Misc::disableGamePauseWhileAFK, String },
{ "Menu:Keybinds", "FreezeTimeToggleKey", Menu::World::freezeTime.ToStringVKeyMap(), &Menu::World::freezeTime, String },
{ "Menu:Keybinds", "SlowMotionToggleKey", Menu::World::slowMotion.ToStringVKeyMap(), &Menu::World::slowMotion, String },
@ -116,6 +117,7 @@ namespace EGT::Config {
{ "Camera:Misc", "DisableHeadCorrection", Menu::Camera::disableHeadCorrection.GetValue(), &Menu::Camera::disableHeadCorrection, OPTION },
{ "Teleport:SavedLocations", "SavedTeleportLocations", Menu::Teleport::savedTeleportLocationsStr, &Menu::Teleport::savedTeleportLocations, String },
{ "Misc:Misc", "DisableGamePauseWhileAFK", Menu::Misc::disableGamePauseWhileAFK.GetValue(), &Menu::Misc::disableGamePauseWhileAFK, OPTION },
{ "Misc:Misc", "DisableTAA", Menu::Misc::disableTAA.GetValue(), &Menu::Misc::disableTAA, OPTION },
{ "Misc:GameChecks", "DisableSavegameCRCCheck", Menu::Misc::disableSavegameCRCCheck.GetValue(), &Menu::Misc::disableSavegameCRCCheck, OPTION },
{ "Misc:GameChecks", "DisableDataPAKsCRCCheck", Menu::Misc::disableDataPAKsCRCCheck.GetValue(), &Menu::Misc::disableDataPAKsCRCCheck, OPTION },
{ "Misc:GameChecks", "IncreaseDataPAKsLimit", Menu::Misc::increaseDataPAKsLimit.GetValue(), &Menu::Misc::increaseDataPAKsLimit, OPTION },

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

@ -36,50 +36,28 @@ namespace EGT::Menu {
return lowerKey.find(lowerFilter) != std::string::npos;
}
static void RestoreVariableToDefault(const std::unique_ptr<EGSDK::Engine::CVar>& cVarPtr) {
if (EGSDK::Engine::CVars::IsVarManagedByBool(cVarPtr->GetName()))
return;
auto cVar = cVarPtr.get();
ImGui_impl::DeferredActions::Add([cVar]() {
switch (cVar->GetType()) {
case EGSDK::Engine::VarType::Float:
{
auto defValue = EGSDK::Engine::CVars::GetVarValueFromMap<float>(cVar->GetName(), EGSDK::Engine::CVars::defaultVars);
if (!defValue)
return;
EGSDK::Engine::CVars::ChangeVar(cVar->GetName(), *defValue);
EGSDK::Engine::CVars::RestoreVariableToDefault<float>(cVar);
break;
}
case EGSDK::Engine::VarType::Int:
{
auto defValue = EGSDK::Engine::CVars::GetVarValueFromMap<int>(cVar->GetName(), EGSDK::Engine::CVars::defaultVars);
if (!defValue)
return;
EGSDK::Engine::CVars::ChangeVar(cVar->GetName(), *defValue);
EGSDK::Engine::CVars::RestoreVariableToDefault<int>(cVar);
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);
EGSDK::Engine::CVars::RestoreVariableToDefault<EGSDK::Vec3>(cVar);
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);
EGSDK::Engine::CVars::RestoreVariableToDefault<EGSDK::Vec4>(cVar);
break;
default:
break;
}
}
EGSDK::Engine::CVars::defaultVars.Erase(cVar->GetName());
EGSDK::Engine::CVars::customVars.Erase(cVar->GetName());
});
}
static void RestoreVariablesToDefault() {
@ -97,7 +75,6 @@ namespace EGT::Menu {
auto value = EGSDK::Engine::CVars::GetVarValue<float>(cVar);
if (!value)
return;
auto newValue = *value;
if (ImGui::InputFloat(cVar->GetName(), &newValue))
EGSDK::Engine::CVars::ChangeVarFromList(cVar, newValue);
@ -108,7 +85,6 @@ namespace EGT::Menu {
auto value = EGSDK::Engine::CVars::GetVarValue<int>(cVar);
if (!value)
return;
auto newValue = *value;
if (ImGui::InputInt(cVar->GetName(), &newValue))
EGSDK::Engine::CVars::ChangeVarFromList(cVar, newValue);
@ -119,7 +95,6 @@ namespace EGT::Menu {
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);
@ -130,7 +105,6 @@ namespace EGT::Menu {
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);
@ -144,17 +118,17 @@ namespace EGT::Menu {
ImGui::SameLine();
std::string restoreBtnName = "Restore##" + std::string(cVar->GetName());
ImGui::BeginDisabled(EGSDK::Engine::CVars::customVars.none_of(cVar->GetName()) || EGSDK::Engine::CVars::IsVarManagedByBool(cVar->GetName()));
ImGui::BeginDisabled(EGSDK::Engine::CVars::DoesVarHaveCustomValue(cVar->GetName()) || EGSDK::Engine::CVars::IsVarManagedByBool(cVar->GetName()));
if (ImGui::Button(restoreBtnName.c_str(), "Restores renderer cvar to default"))
RestoreVariableToDefault(cVarPtr);
ImGui::EndDisabled();
}
static void HandleRendererCVarsList() {
ImGui::BeginDisabled(EGSDK::Engine::CVars::vars.empty());
ImGui::BeginDisabled(EGSDK::Engine::CVars::AreAnyVarsPresent());
if (ImGui::CollapsingHeader("Renderer CVars list", ImGuiTreeNodeFlags_None)) {
ImGui::Indent();
ImGui::BeginDisabled(EGSDK::Engine::CVars::customVars.empty());
ImGui::BeginDisabled(EGSDK::Engine::CVars::AreAnyCustomVarsPresent() || !EGSDK::Engine::CVars::AreAllCustomVarsManagedByBool());
if (ImGui::Button("Restore variables to default"))
RestoreVariablesToDefault();
ImGui::EndDisabled();