refactoring dll loading code in order to improve dll reloading

Pika/core/pikaRuntime/containerManager/containerManager.cpp

@@ -2,10 +2,11 @@
 #include "containerManager.h"
 #include "containerManager.h"
 #include <globalAllocator/globalAllocator.h>
+#include <unordered_set>
 
 pika::containerId_t pika::ContainerManager::createContainer
 (pika::ContainerInformation containerInformation,
-	pika::DllLoader &dllLoader, pika::LogManager &logManager)
+	pika::LoadedDll &loadedDll, pika::LogManager &logManager)
 {	
 	containerId_t id = ++idCounter;
 	
@@ -17,17 +18,19 @@ pika::containerId_t pika::ContainerManager::createContainer
 	//}
 
 	pika::RuntimeContainer container = {};
+	container.baseContainerName = containerInformation.containerName;
+	
 	container.arena.allocateStaticMemory(containerInformation); //this just allocates the staic memory
 
 	container.allocator.init(malloc(containerInformation.containerStaticInfo.defaultHeapMemorySize),
 		containerInformation.containerStaticInfo.defaultHeapMemorySize);
 
-	dllLoader.bindAllocatorDllRealm(&container.allocator);
+	loadedDll.bindAllocatorDllRealm(&container.allocator);
 	
 	//this calls the constructors (from the dll realm)
-	if (!dllLoader.constructRuntimeContainer(container, containerInformation.containerName.c_str()))
+	if (!loadedDll.constructRuntimeContainer(container, containerInformation.containerName.c_str()))
 	{
-		dllLoader.resetAllocatorDllRealm();
+		loadedDll.resetAllocatorDllRealm();
 
 		logManager.log((std::string("Couldn't construct container: #") + std::to_string(id)).c_str(), pika::logError);
 
@@ -36,7 +39,7 @@ pika::containerId_t pika::ContainerManager::createContainer
 
 		return 0;
 	}
-	dllLoader.resetAllocatorDllRealm();
+	loadedDll.resetAllocatorDllRealm();
 
 
 #pragma region setup requested container info
@@ -46,9 +49,9 @@ pika::containerId_t pika::ContainerManager::createContainer
 #pragma endregion
 
 	
-	dllLoader.bindAllocatorDllRealm(&container.allocator);
+	loadedDll.bindAllocatorDllRealm(&container.allocator);
 	container.pointer->create(container.requestedContainerInfo); //this calls create() (from the dll realm)
-	dllLoader.resetAllocatorDllRealm();//sets the global allocator back to standard (used for runtime realm)
+	loadedDll.resetAllocatorDllRealm();//sets the global allocator back to standard (used for runtime realm)
 
 	runningContainers[id] = container;
 
@@ -59,22 +62,87 @@ void pika::ContainerManager::init()
 {
 }
 
-void pika::ContainerManager::update(pika::DllLoader &dllLoader,
-	pika::Input input, float deltaTime, pika::WindowState windowState)
+void pika::ContainerManager::update(pika::LoadedDll &loadedDll, pika::PikaWindow &window, pika::LogManager &logs)
 {
+	PIKA_DEVELOPMENT_ONLY_ASSERT(loadedDll.dllHand != 0, "dll not loaded when trying to update containers");
+
+#pragma region reload dll
+
+	//if (dllLoader.checkIfShouldReloadDll() || window.input.buttons[pika::Button::P].released())
+	//{
+	//	pika::LoadedDll newDll = {};
+	//
+	//	newDll.tryToloadDllUntillPossible(dllLoader.path);
+	//
+	//	std::cout << "new dll loaded\n";
+	//
+	//	std::vector<pika::ContainerInformation> newContainers;
+	//	newContainers.reserve(100);
+	//
+	//	newDll.getContainerInfoAndCheck(newContainers, logs);
+	//
+	//	//clear containers that dissapeared
+	//	{
+	//		std::unordered_set<std::string> containerNames;
+	//		for (auto &c : newContainers)
+	//		{
+	//			containerNames.insert(c.containerName);
+	//		}
+	//
+	//		std::vector<pika::containerId_t> containersToClean;
+	//		for (auto &i : runningContainers)
+	//		{
+	//			if (containerNames.find(i.second.baseContainerName) ==
+	//				containerNames.end())
+	//			{
+	//				std::string l = "Killed container because it does not exist anymore in dll: " + i.second.baseContainerName
+	//					+ " #" + std::to_string(i.first);
+	//				logs.log(l.c_str(), pika::logError);
+	//
+	//				containersToClean.push_back(i.first);
+	//			}
+	//		}
+	//
+	//		for (auto i : containersToClean)
+	//		{
+	//			destroyContainer(i, dllLoader, logs);
+	//		}
+	//	}
+	//
+	//
+	//
+	//	//set new dll
+	//	dllLoader.loadedDll.unloadDll();
+	//
+	//	dllLoader.loadedDll = newDll;
+	//	loadedContainers = newContainers;
+	//		
+	//	dllLoader.loadedDll.gameplayReload_(window.context);
+	//}
+
+
+	
+#pragma endregion
+
+
+
+#pragma region running containers
 	for (auto &c : runningContainers)
 	{
-		dllLoader.bindAllocatorDllRealm(&c.second.allocator);
-		c.second.pointer->update(input, deltaTime, windowState, c.second.requestedContainerInfo);
-		dllLoader.resetAllocatorDllRealm();
+		loadedDll.bindAllocatorDllRealm(&c.second.allocator);
+		c.second.pointer->update(window.input, window.deltaTime, window.windowState, c.second.requestedContainerInfo);
+		loadedDll.resetAllocatorDllRealm();
 
 	}
+#pragma endregion
 
 }
 
-bool pika::ContainerManager::destroyContainer(containerId_t id, pika::DllLoader &dllLoader,
+bool pika::ContainerManager::destroyContainer(containerId_t id, pika::LoadedDll &loadedDll,
 	pika::LogManager &logManager)
 {
+	PIKA_DEVELOPMENT_ONLY_ASSERT(loadedDll.dllHand != 0, "dll not loaded when trying to destroy container");
+
 	auto c = runningContainers.find(id);
 	if (c == runningContainers.end())
 	{
@@ -83,9 +151,9 @@ bool pika::ContainerManager::destroyContainer(containerId_t id, pika::DllLoader
 		return false;
 	}
 
-	dllLoader.bindAllocatorDllRealm(&c->second.allocator);
-	dllLoader.destructContainer_(&(c->second.pointer), &c->second.arena);
-	dllLoader.resetAllocatorDllRealm();
+	loadedDll.bindAllocatorDllRealm(&c->second.allocator);
+	loadedDll.destructContainer_(&(c->second.pointer), &c->second.arena);
+	loadedDll.resetAllocatorDllRealm();
 
 	c->second.arena.dealocateStaticMemory(); //static memory
 	free(c->second.allocator.originalBaseMemory); //heap memory
@@ -95,11 +163,11 @@ bool pika::ContainerManager::destroyContainer(containerId_t id, pika::DllLoader
 	return true;
 }
 
-void pika::ContainerManager::destroyAllContainers(pika::DllLoader &dllLoader,
+void pika::ContainerManager::destroyAllContainers(pika::LoadedDll &loadedDll,
 	pika::LogManager &logManager)
 {
 	for (auto &c : runningContainers)
 	{
-		destroyContainer(c.first, dllLoader, logManager);
+		destroyContainer(c.first, loadedDll, logManager);
 	}
 }

Pika/core/pikaRuntime/containerManager/containerManager.h

@@ -22,23 +22,23 @@ namespace pika
 
 		containerId_t createContainer(
 			pika::ContainerInformation containerInformation,
-			pika::DllLoader &dllLoader, pika::LogManager &logManager);
+			pika::LoadedDll &dllLoader, pika::LogManager &logManager);
 
 		void init();
 
 		void update(
-			pika::DllLoader &dllLoader,
-			pika::Input input,
-			float deltaTime,
-			pika::WindowState windowState);
+			pika::LoadedDll &dllLoader,
+			pika::PikaWindow &window,
+			pika::LogManager &logs);
 
-		bool destroyContainer(containerId_t id, pika::DllLoader &dllLoader,
+		bool destroyContainer(containerId_t id, pika::LoadedDll &dllLoader,
 			pika::LogManager &logManager);
 
-		void destroyAllContainers(pika::DllLoader &dllLoader,
+		void destroyAllContainers(pika::LoadedDll &dllLoader,
 			pika::LogManager &logManager);
 
 		containerId_t idCounter = 0;
+
 	};
 
 

Pika/core/pikaRuntime/dllLoader/dllLoader.cpp

@@ -3,6 +3,8 @@
 #include <logs/assert.h>
 #include <unordered_set>
 
+static std::filesystem::path dllPath = std::filesystem::current_path();
+
 #ifdef PIKA_DEVELOPMENT
 
 	#ifdef PIKA_WINDOWS
@@ -10,8 +12,6 @@
 	#define NOMINMAX
 	#define WIN32_LEAN_AND_MEAN
 	#include <Windows.h>
-	
-	
 
 	static FILETIME getLastWriteFile(const char *name)
 	{
@@ -30,151 +30,59 @@
 		return(time);
 	}
 
-	
-	bool pika::DllLoader::loadDll(std::filesystem::path path)
-	{
-		p = path;
-
-		std::filesystem::path originalDll = path / "pikaGameplay.dll";
-		std::filesystem::path copyDll = path / "pikaGameplayCopy.dll";
-
-		filetime = getLastWriteFile(originalDll.string().c_str());
-
-
-		std::filesystem::copy(originalDll, copyDll, std::filesystem::copy_options::overwrite_existing);
-
-		dllHand = LoadLibraryA(copyDll.string().c_str());
-
-		if (!dllHand) { return false; }
-
-		gameplayStart_ = (gameplayStart_t *)GetProcAddress(dllHand, "gameplayStart");
-		gameplayReload_ = (gameplayReload_t *)GetProcAddress(dllHand, "gameplayReload");
-		getContainersInfo_ = (getContainersInfo_t *)GetProcAddress(dllHand, "getContainersInfo");
-		constructContainer_ = (constructContainer_t *)GetProcAddress(dllHand, "constructContainer");
-		destructContainer_ = (destructContainer_t *)GetProcAddress(dllHand, "destructContainer");
-		bindAllocator_ = (bindAllocator_t *)GetProcAddress(dllHand, "bindAllocator");;
-		resetAllocator_ = (resetAllocator_t *)GetProcAddress(dllHand, "resetAllocator");;
-		
-
-		if (!gameplayStart_) { return false; }
-		if (!gameplayReload_) { return false; }
-		if (!getContainersInfo_) { return false; }
-		if (!constructContainer_) { return false; }
-		if (!destructContainer_) { return false; }
-		if (!bindAllocator_) { return false; }
-		if (!resetAllocator_) { return false; }
-
-		return	true;
-	}
-	
-	void pika::DllLoader::unloadDll()
-	{
-		FreeLibrary(dllHand);
-	}
-
-	bool pika::DllLoader::reloadDll()
-	{
-		std::filesystem::path originalDll = p / "pikaGameplay.dll";
-		std::filesystem::path copyDll = p / "pikaGameplayCopy.dll";
 
-		FILETIME newFiletime = getLastWriteFile(originalDll.string().c_str());
-
-		if (CompareFileTime(&filetime, &newFiletime) != 0)
-		{
-
-			unloadDll();
-			
-			HANDLE fileCheck;
-			while ((fileCheck = CreateFile(originalDll.string().c_str(),
-				GENERIC_READ | GENERIC_WRITE, NULL, NULL,
-				OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
-			{
-				//Wait till the dll can be oppened. It is possible that the compiler still keeps it busy.
-			}
-			CloseHandle(fileCheck);
-			
-			//try to load
-			while (!loadDll(p)) {};
-
-			return true;
-		}
-
-		return false;
-	}
-	
 	#else
 	#error "pika load dll works only on windows, change configuration to pikaProduction"
 	#endif
 
 
-#elif defined(PIKA_PRODUCTION)
-
-	#include <dll/dllMain.h>
-
-	bool pika::DllLoader::loadDll(std::filesystem::path path)
-	{
-		
-		gameplayStart_ = gameplayStart;
-		gameplayReload_ = gameplayReload;
-		getContainersInfo_ = getContainersInfo;
-		constructContainer_ = constructContainer;
-		destructContainer_ = destructContainer;
-		bindAllocator_ = bindAllocator;
-		resetAllocator_ = resetAllocator;
-
-		return	true;
-	}
-
-	bool pika::DllLoader::reloadDll()
-	{
-		return false;
-	}
-
-	void pika::DllLoader::unloadDll()
-	{
-	}
-
-
 #endif
 
-bool pika::DllLoader::constructRuntimeContainer(RuntimeContainer &c, const char *name)
+
+bool pika::LoadedDll::constructRuntimeContainer(RuntimeContainer &c, const char *name)
 {
+	PIKA_DEVELOPMENT_ONLY_ASSERT(constructContainer_ != nullptr, "dll not loaded");
 	return constructContainer_(&c.pointer, &c.arena, name);
 }
 
-void pika::DllLoader::bindAllocatorDllRealm(pika::memory::FreeListAllocator *allocator)
+
+
+void pika::LoadedDll::bindAllocatorDllRealm(pika::memory::FreeListAllocator *allocator)
 {
+	PIKA_DEVELOPMENT_ONLY_ASSERT(bindAllocator_ != nullptr, "dll not loaded");
 	bindAllocator_(allocator);
 }
 
-void pika::DllLoader::resetAllocatorDllRealm()
+void pika::LoadedDll::resetAllocatorDllRealm()
 {
+	PIKA_DEVELOPMENT_ONLY_ASSERT(resetAllocator_ != nullptr, "dll not loaded");
 	resetAllocator_();
 }
 
-void pika::DllLoader::getContainerInfoAndCheck(std::vector<pika::ContainerInformation> &info, pika::LogManager &logs)
+void pika::LoadedDll::getContainerInfoAndCheck(pika::LogManager &logs)
 {
+	containerInfo.clear();
+	containerInfo.reserve(100);
 
-	getContainersInfo_(info);
-	
 	//todo check for valid containers
+	getContainersInfo_(containerInfo);
 
 	std::unordered_set<std::string> uniqueNames = {};
 
-	for (int i = 0; i < info.size(); i++)
+	for (int i = 0; i < containerInfo.size(); i++)
 	{
 		auto signalError = [&](const char *e)
 		{
-			std::string l = e + info[i].containerName;
+			std::string l = e + containerInfo[i].containerName;
 			logs.log(l.c_str(), pika::logError);
 
-			info.erase(info.begin() + i);
+			containerInfo.erase(containerInfo.begin() + i);
 			i--;
 		};
 
-		if (uniqueNames.find(info[i].containerName) == uniqueNames.end())
+		if (uniqueNames.find(containerInfo[i].containerName) == uniqueNames.end())
 		{
-			uniqueNames.insert(info[i].containerName);
+			uniqueNames.insert(containerInfo[i].containerName);
 		}
 		else
 		{
@@ -182,22 +90,140 @@ void pika::DllLoader::getContainerInfoAndCheck(std::vector<pika::ContainerInform
 			continue;
 		}
 
-		if (info[i].containerStaticInfo._internalNotImplemented)
+		if (containerInfo[i].containerStaticInfo._internalNotImplemented)
 		{
 			signalError("Container did not implement containerInfo function: ");
 			continue;
 		}
 
-		if (info[i].containerStaticInfo.defaultHeapMemorySize < 100)
+		if (containerInfo[i].containerStaticInfo.defaultHeapMemorySize < 100)
 		{
 			signalError("Too little heap memory for container: ");
 			continue;
 		}
 
 	}
+}
+
+
+#ifdef PIKA_DEVELOPMENT
+
+
+bool pika::LoadedDll::loadDll(int id, pika::LogManager &logs)
+{
+	unloadDll();
 
 
+	std::filesystem::path originalDll = dllPath / "pikaGameplay.dll";
+	std::filesystem::path copyDll = dllPath / ( "pikaGameplayCopy" + std::to_string(id) + ".dll");
 
+	filetime = getLastWriteFile(originalDll.string().c_str());
+
+
+	std::filesystem::copy(originalDll, copyDll, std::filesystem::copy_options::overwrite_existing); //todo use windows function here
+	//to be able to catch errors
+
+	dllHand = LoadLibraryA(copyDll.string().c_str());
+
+	if (!dllHand) { return false; }
+
+	gameplayStart_ = (gameplayStart_t *)GetProcAddress(dllHand, "gameplayStart");
+	gameplayReload_ = (gameplayReload_t *)GetProcAddress(dllHand, "gameplayReload");
+	getContainersInfo_ = (getContainersInfo_t *)GetProcAddress(dllHand, "getContainersInfo");
+	constructContainer_ = (constructContainer_t *)GetProcAddress(dllHand, "constructContainer");
+	destructContainer_ = (destructContainer_t *)GetProcAddress(dllHand, "destructContainer");
+	bindAllocator_ = (bindAllocator_t *)GetProcAddress(dllHand, "bindAllocator");;
+	resetAllocator_ = (resetAllocator_t *)GetProcAddress(dllHand, "resetAllocator");;
+
+
+	if (!gameplayStart_) { return false; }
+	if (!gameplayReload_) { return false; }
+	if (!getContainersInfo_) { return false; }
+	if (!constructContainer_) { return false; }
+	if (!destructContainer_) { return false; }
+	if (!bindAllocator_) { return false; }
+	if (!resetAllocator_) { return false; }
+
+	//get container info
+	getContainerInfoAndCheck(logs);
+
+	return	true;
 }
 
-	
+bool pika::LoadedDll::tryToloadDllUntillPossible(int id, pika::LogManager &logs)
+{
+
+	HANDLE fileCheck = {};
+
+	while ((fileCheck = CreateFile((dllPath / "pikaGameplay.dll").string().c_str(),
+		GENERIC_READ | GENERIC_WRITE, NULL, NULL,
+		OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
+	{
+		//Wait till the dll can be oppened. It is possible that the compiler still keeps it busy.
+	}
+	CloseHandle(fileCheck);
+
+	//try to load (we loop since it is still possible that windows thinks that the dll is not available yet)
+	while (!loadDll(id, logs)) {};
+	return true;
+}
+
+void pika::LoadedDll::unloadDll()
+{
+	FreeLibrary(dllHand);
+	dllHand = {};
+	filetime = {};
+	containerInfo.clear();
+}
+
+bool pika::LoadedDll::shouldReloadDll()
+{
+	if (dllHand == 0) { return 0; }
+
+	std::filesystem::path originalDll = dllPath / "pikaGameplay.dll";
+
+	FILETIME newFiletime = getLastWriteFile(originalDll.string().c_str());
+
+	return (CompareFileTime(&filetime, &newFiletime) != 0);
+}
+
+
+
+#elif defined(PIKA_PRODUCTION)
+
+#include <dll/dllMain.h>
+
+bool pika::LoadedDll::loadDll(int id, pika::LogManager &logs)
+{
+
+	gameplayStart_ = gameplayStart;
+	gameplayReload_ = gameplayReload;
+	getContainersInfo_ = getContainersInfo;
+	constructContainer_ = constructContainer;
+	destructContainer_ = destructContainer;
+	bindAllocator_ = bindAllocator;
+	resetAllocator_ = resetAllocator;
+	getContainerInfoAndCheck(logs);
+
+	return	true;
+}
+
+
+bool pika::LoadedDll::tryToloadDllUntillPossible(int id, pika::LogManager &logs)
+{
+	return loadDll(id, logs);
+}
+
+void pika::LoadedDll::unloadDll()
+{
+	containerInfo.clear();
+}
+
+bool pika::LoadedDll::shouldReloadDll()
+{
+	return false;
+}
+
+
+#endif
+

Pika/core/pikaRuntime/dllLoader/dllLoader.h

@@ -38,7 +38,7 @@ typedef BINDALLOCATOR(bindAllocator_t);
 typedef RESETALLOCATOR(resetAllocator_t)
 #undef RESETALLOCATOR
 
-//todo remove windows include 
+
 #ifdef PIKA_WINDOWS
 #define NOMINMAX
 #define WIN32_LEAN_AND_MEAN
@@ -48,8 +48,8 @@ typedef RESETALLOCATOR(resetAllocator_t)
 namespace pika
 {
 
-//this will have only one instance open at a time for now
-struct DllLoader
+
+struct LoadedDll
 {
 	gameplayStart_t *gameplayStart_ = {};
 	gameplayReload_t *gameplayReload_ = {};
@@ -59,26 +59,34 @@ struct DllLoader
 	bindAllocator_t *bindAllocator_ = {};
 	resetAllocator_t *resetAllocator_ = {};
 
-	std::filesystem::path p = {};
-
 #ifdef PIKA_WINDOWS
 	FILETIME filetime = {};
 	HMODULE dllHand = {};
 #endif
 
-	bool loadDll(std::filesystem::path path);
-	bool constructRuntimeContainer(pika::RuntimeContainer &c, const char *name);
-	void bindAllocatorDllRealm(pika::memory::FreeListAllocator *allocator);
-	void resetAllocatorDllRealm();
+	int id = 0;
 
-	void getContainerInfoAndCheck(std::vector<pika::ContainerInformation> &info, pika::LogManager &logs);
+	bool loadDll(int id, pika::LogManager &logs);
+
+	bool tryToloadDllUntillPossible(int id, pika::LogManager &logs);
 
 	void unloadDll();
 
-	//will check if the dll reloaded and reload it
-	bool reloadDll();
+	//no need to call since it is called in load dll function
+	void getContainerInfoAndCheck(pika::LogManager &logs);
+
+	bool shouldReloadDll();
+
+	std::vector<pika::ContainerInformation> containerInfo;
+
+	bool constructRuntimeContainer(pika::RuntimeContainer &c, const char *name);
+
+	void bindAllocatorDllRealm(pika::memory::FreeListAllocator *allocator);
+
+	void resetAllocatorDllRealm();
 
 };
 
 
+
 };

Pika/core/pikaRuntime/pikaMain.cpp

@@ -38,8 +38,8 @@ int main()
 
 #pragma region load dll
 	std::filesystem::path currentPath = std::filesystem::current_path();
-	pika::DllLoader dllLoader;
-	PIKA_PERMA_ASSERT(dllLoader.loadDll(currentPath), "Couldn't load dll");
+	pika::LoadedDll loadedDll;
+	PIKA_PERMA_ASSERT(loadedDll.loadDll(0, logs), "Couldn't load dll");
 #pragma endregion
 	
 #pragma region pika imgui id manager
@@ -68,15 +68,6 @@ int main()
 	window.context.glfwMakeContextCurrentPtr = glfwMakeContextCurrent;
 #pragma endregion
 
-#pragma region init dll reaml
-	dllLoader.gameplayStart_(window.context);
-
-	std::vector<pika::ContainerInformation> loadedContainers;
-	loadedContainers.reserve(100);
-	
-	dllLoader.getContainerInfoAndCheck(loadedContainers, logs);
-#pragma endregion
-
 #pragma region container manager
 
 	pika::ContainerManager containerManager;
@@ -85,6 +76,14 @@ int main()
 
 #pragma endregion
 
+#pragma region init dll reaml
+	loadedDll.gameplayStart_(window.context);
+
+	
+#pragma endregion
+
+
+
 
 #pragma region shortcuts
 	pika::ShortcutManager shortcutManager;
@@ -98,18 +97,12 @@ int main()
 #pragma endregion
 
 	
-	auto container = containerManager.createContainer(loadedContainers[0], dllLoader, logs);
+	auto container = containerManager.createContainer
+		(loadedDll.containerInfo[0], loadedDll, logs);
 
 	while (!window.shouldClose())
 	{
 
-		//todo move this in container manager so we can check for collisions
-	#pragma region reload dll
-		if (dllLoader.reloadDll())
-		{
-			dllLoader.gameplayReload_(window.context);
-		}
-	#pragma endregion
 
 	#pragma region start imgui
 		pika::imguiStartFrame(window.context);
@@ -134,7 +127,7 @@ int main()
 	#pragma endregion
 
 	#pragma region container manager
-		containerManager.update(dllLoader, window.input, window.deltaTime, window.windowState);
+		containerManager.update(loadedDll, window, logs);
 	#pragma endregion
 
 	#pragma region end imgui frame
@@ -151,7 +144,7 @@ int main()
 	
 	}
 
-	containerManager.destroyAllContainers(dllLoader, logs);
+	containerManager.destroyAllContainers(loadedDll, logs);
 
 	return 0;
 }

Pika/core/sharedRuntime/baseContainer.h

@@ -34,6 +34,7 @@ struct Container
 	//this is used to give to the engine basic information about your container.
 	//this function should be pure
 	//this function should not allocate memory
+	//this should not be dependent on anything that is called on create or library initialization
 	static ContainerStaticInfo containerInfo() { ContainerStaticInfo c; c._internalNotImplemented = true; return c; };
 	
 

Pika/gameplay/containers/pikaGameplay.h

@@ -54,7 +54,7 @@ struct Gameplay : public Container
 
 		*r += deltaTime * 4.f;
 
-		renderer.renderRectangle({10, 10, 100, 100}, Colors_Blue, {}, *r);
+		renderer.renderRectangle({10, 10, 100, 100}, Colors_Orange, {}, *r);
 
 		//if (input.lMouse.pressed())
 		//{

Pika/resources/logs.txt

@@ -1,3 +1 @@
-#2022-09-25 21:30:55: test log
-#2022-09-25 21:30:55[warning]: warning log
-#2022-09-25 21:30:55[error]: error log
+#2022-09-26 16:11:33[error]: Killed container because it does not exist anymore in dll:  #1