fix: INFRA memory leak

Author: ThisAMJ

src/Modules.hpp

@@ -11,3 +11,4 @@
 #include "Modules/Surface.hpp"
 #include "Modules/Tier1.hpp"
 #include "Modules/VGui.hpp"
+#include "Modules/VPhysics.hpp"

src/Modules/VPhysics.cpp

@@ -0,0 +1,90 @@
+#include "VPhysics.hpp"
+
+#include "Event.hpp"
+#include "Interface.hpp"
+#include "Offsets.hpp"
+#include "SAR.hpp"
+
+
+// Kinda a silly way to keep track of this, but it works
+// and I'm lazy
+static std::vector<int *> vphysEnvironments;
+static std::vector<int *> vphysEnvironmentsLast;
+
+// INFRA memory leak
+// The game has a "fast load" feature that skips a bunch of stuff, including
+// destroying the old physics environment. This leaks ~4MB (one env) per load.
+// Slow loads destroy the two environments that are in use, and create a new
+// two. We detect this and destroy the old environments that are no longer in
+// use. There are other leaks, but this is the most significant.
+ON_EVENT(SESSION_START) {
+	if (!sar.game->Is(SourceGame_INFRA)) return;
+	vphysEnvironmentsLast = vphysEnvironments;
+	vphysEnvironments = {};
+	for (int i = 0; ; ++i) {
+		int *env = vphysics->GetActivePhysicsEnvironmentByIndex(i);
+		if (!env) break;
+		vphysEnvironments.push_back(env);
+	}
+
+	// console->Print("%d active physics environment(s)\n", (int)vphysEnvironments.size());
+	// int i = 0;
+	// for (const auto &env : vphysEnvironmentsLast) {
+	// 	if (std::find(vphysEnvironments.begin(), vphysEnvironments.end(), env) == vphysEnvironments.end()) {
+	// 		console->ColorMsg(Color(255,96,64), "- %d %p\n", i, env);
+	// 	}
+	// 	i++;
+	// }
+	// i = 0;
+	// for (const auto &env : vphysEnvironments) {
+	// 	if (std::find(vphysEnvironmentsLast.begin(), vphysEnvironmentsLast.end(), env) == vphysEnvironmentsLast.end()) {
+	// 		console->ColorMsg(Color(96,255,64), "+ %d %p\n", i, env);
+	// 	} else {
+	// 		console->Print("  %d %p\n", i, env);
+	// 	}
+	// 	i++;
+	// }
+
+	int newEnvs = 0;
+	for (const auto &env : vphysEnvironments) {
+		if (std::find(vphysEnvironmentsLast.begin(), vphysEnvironmentsLast.end(), env) == vphysEnvironmentsLast.end()) {
+			newEnvs++;
+		}
+	}
+	if (newEnvs == 2) {
+		for (const auto &env : vphysEnvironments) {
+			if (std::find(vphysEnvironmentsLast.begin(), vphysEnvironmentsLast.end(), env) != vphysEnvironmentsLast.end()) {
+				vphysics->DestroyPhysicsEnvironment(env);
+			}
+		}
+	}
+}
+
+int *VPhysics::GetActivePhysicsEnvironmentByIndex(int index) {
+	if (!this->GetActiveEnvironmentByIndex) return nullptr;
+	return this->GetActiveEnvironmentByIndex(this->g_pVphysics->ThisPtr(), index);
+}
+
+void VPhysics::DestroyPhysicsEnvironment(int *env) {
+	if (!this->DestroyEnvironment) return;
+	this->DestroyEnvironment(this->g_pVphysics->ThisPtr(), env);
+}
+
+bool VPhysics::Init() {
+	this->g_pVphysics = Interface::Create(this->Name(), "VPhysics031", false);
+
+	if (Offsets::GetActiveEnvironmentByIndex) {
+		GetActiveEnvironmentByIndex = g_pVphysics->Original<_GetActiveEnvironmentByIndex>(Offsets::GetActiveEnvironmentByIndex);
+	}
+	if (Offsets::DestroyEnvironment) {
+		DestroyEnvironment = g_pVphysics->Original<_DestroyEnvironment>(Offsets::DestroyEnvironment);
+	}
+
+	return this->hasLoaded = this->g_pVphysics;
+}
+
+void VPhysics::Shutdown() {
+	Interface::Delete(this->g_pVphysics);
+}
+
+VPhysics *vphysics;

src/Modules/VPhysics.hpp

@@ -0,0 +1,26 @@
+#pragma once
+#include "Interface.hpp"
+#include "Module.hpp"
+#include "Utils.hpp"
+
+// TODO: Custom fonts
+class VPhysics : public Module {
+public:
+	Interface *g_pVphysics = nullptr;
+
+	using _GetActiveEnvironmentByIndex = int *(__rescall *)(void *thisptr, int index);
+	_GetActiveEnvironmentByIndex GetActiveEnvironmentByIndex = nullptr;
+
+	using _DestroyEnvironment = void(__rescall *)(void *thisptr, void *env);
+	_DestroyEnvironment DestroyEnvironment = nullptr;
+
+public:
+	int *GetActivePhysicsEnvironmentByIndex(int index);
+	void DestroyPhysicsEnvironment(int *env);
+
+	bool Init() override;
+	void Shutdown() override;
+	const char *Name() override { return MODULE("vphysics"); }
+};
+
+extern VPhysics *vphysics;

src/Offsets/INFRA 6905.hpp

@@ -122,6 +122,11 @@ SIGSCAN_WINDOWS(CheckStuck_FloatTime, "FF 15 ? ? ? ? D9 5D ? 8B 4E")
 SIGSCAN_EMPTY(FloorReportalBranch)
 
 
+// VPhysics
+OFFSET_WINDOWS(DestroyEnvironment, 9)
+OFFSET_WINDOWS(GetActiveEnvironmentByIndex, 10)
+
+
 // Steam API
 SIGSCAN_WINDOWS(interfaceMgrSig, "83 3D ? ? ? ? 00 74 ? B0 01")
 OFFSET_WINDOWS(interfaceMgrOff, 2)

src/Offsets/Portal 2 9568.hpp

@@ -511,6 +511,11 @@ SIGSCAN_DEFAULT(FloorReportalBranch, "75 7D 8B 8E C0 04 00 00",
                                      "75 ? 8B 85 ? ? ? ? 8B 0D") // "Portal.open_red" xref(nothing after if) -> CProp_Portal::NewLocation -> first function call CPortal_Base2D::NewLocation -> 4x func call followed by test, [jnz]
 
 
+// VPhysics
+OFFSET_EMPTY(DestroyEnvironment)
+OFFSET_EMPTY(GetActiveEnvironmentByIndex)
+
+
 // Steam API
 SIGSCAN_DEFAULT(interfaceMgrSig, "89 0D ? ? ? ? 85 C9 0F", "")
 OFFSET_DEFAULT(interfaceMgrOff, 2, -1)

src/SAR.cpp

@@ -99,6 +99,7 @@ bool SAR::Load(CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerF
 			this->modules->AddModule<FileSystem>(&fileSystem);
 			this->modules->AddModule<Matchmaking>(&matchmaking);
 			this->modules->AddModule<SteamAPI>(&steam);
+			this->modules->AddModule<VPhysics>(&vphysics);
 			this->modules->InitAll();
 
 			SarInitHandler::RunAll();