integrated 3D library

Pika/core/pikaRuntime/containerManager/containerManager.cpp

@@ -414,11 +414,13 @@ void pika::ContainerManager::update(pika::LoadedDll &loadedDll, pika::PikaWindow
 					ImVec2 vMin = ImGui::GetWindowContentRegionMin();
 					windowInput.mouseX -= windowPos.x + vMin.x;
 					windowInput.mouseY -= windowPos.y + vMin.y;
-				
-					//todo	
+
+
 					//https://github.com/ocornut/imgui/issues/5882
+					ImGuiViewport *viewPort = ImGui::GetWindowViewport();
 					auto io = ImGui::GetIO();
-					windowInput.hasFocus = ImGui::IsWindowFocused() && !io.AppFocusLost;
+					//windowInput.hasFocus = ImGui::GetPlatformIO().Platform_GetWindowFocus(viewPort) && !io.AppFocusLost;
+					windowInput.hasFocus = windowInput.hasFocus && !io.AppFocusLost;
 				}
 				
 

Pika/core/sharedRuntime/baseContainer.h

@@ -7,6 +7,8 @@
 #include <staticVector.h>
 #include <pikaGL/frameBuffer.h>
 #include <pikaConsoleManager/pikaConsoleWindow.h>
+#include <globalAllocator/globalAllocator.h>
+#include <fstream>
 
 #define READENTIREFILE(x) bool x(const char* name, void* buffer, size_t size)
 typedef READENTIREFILE(readEntireFile_t);
@@ -47,24 +49,100 @@ struct RequestedContainerInfo
 		return true;
 	}
 
-	//todo implement
-	bool readEntireFile(const char *name, void *buffer, size_t size)
+	bool readEntireFileBinary(const char *name, void *buffer, size_t size)
 	{
 		//PIKA_DEVELOPMENT_ONLY_ASSERT(readEntireFilePointer, "read entire file pointer not assigned");
+		bool success = true;
+
+		pika::memory::setGlobalAllocatorToStandard();
+		{
+			std::ifstream f(name, std::ios::binary);
+
+			if (!f.is_open())
+			{
+				success = false;
+			}
+			else
+			{
+				f.read((char*)buffer, size);
+				f.close();
+			}
+		}
+		pika::memory::setGlobalAllocator(mainAllocator);
+
+		return success;
+	}
 
-		//bool rez = readEntireFilePointer(name, buffer, size);
-
-		//pika::memory::setGlobalAllocator(mainAllocator);
-
-		//return rez;
+	bool readEntireFile(const char *name, void *buffer, size_t size)
+	{
+		//PIKA_DEVELOPMENT_ONLY_ASSERT(readEntireFilePointer, "read entire file pointer not assigned");
+		bool success = true;
+
+		pika::memory::setGlobalAllocatorToStandard();
+		{
+			std::ifstream f(name);
+
+			if (!f.is_open())
+			{
+				success = false;
+			}
+			else
+			{
+				f.read((char *)buffer, size);
+				f.close();
+			}
+		}
+		pika::memory::setGlobalAllocator(mainAllocator);
+
+		return success;
 	}
 
-	bool getFileSize(const char *name, size_t &size)
+	bool getFileSizeBinary(const char *name, size_t &size)
 	{
 		//PIKA_DEVELOPMENT_ONLY_ASSERT(getFileSizePointer, "get file size pointer not assigned");
 
+		bool success = true;
+		size = 0;
+
+		//todo push pop allocator or use that pointer thing (and don't forget to only use explicit allocators calls or sthing)
+		pika::memory::setGlobalAllocatorToStandard();
+		{
+			std::ifstream f(name, std::ifstream::ate | std::ifstream::binary);
+			if (!f.is_open())
+			{
+				success = false;
+			}
+			else
+			{
+				size = f.tellg();
+				f.close();
+			}
+		}
+		pika::memory::setGlobalAllocator(mainAllocator);
+
+		return size;
+	}
 
-
+	bool getFileSize(const char *name, size_t &size)
+	{
+		bool success = true;
+		size = 0;
+		pika::memory::setGlobalAllocatorToStandard();
+		{
+			std::ifstream f(name, std::ifstream::ate);
+			if (!f.is_open())
+			{
+				success = false;
+			}
+			else
+			{
+				size = f.tellg();
+				f.close();
+			}
+		}
+		pika::memory::setGlobalAllocator(mainAllocator);
+
+		return size;
 	}
 };
 

Pika/gameplay/containers/threedtest.h

@@ -15,6 +15,62 @@ void inline errorCallbackCustom(std::string err, void *userData)
 	data->consoleWrite(err.c_str());
 }
 
+std::string inline readEntireFileCustom(const char *fileName, bool &couldNotOpen, void *userData)
+{
+	RequestedContainerInfo *data = (RequestedContainerInfo *)userData;
+	couldNotOpen = false;
+
+	size_t size = 0;
+	if (!data->getFileSize(fileName, size))
+	{
+		couldNotOpen = true;
+		return "";
+	}
+
+	std::string buffer;
+	buffer.resize(size+1);
+
+	if (!data->readEntireFile(fileName, &buffer.at(0), size))
+	{
+		couldNotOpen = true;
+		return "";
+	}
+
+	return buffer;
+}
+
+std::vector<char> inline readEntireFileBinaryCustom(const char *fileName, bool &couldNotOpen, void *userData)
+{
+	RequestedContainerInfo *data = (RequestedContainerInfo *)userData;
+	couldNotOpen = false;
+
+	size_t size = 0;
+	if (!data->getFileSizeBinary(fileName, size))
+	{
+		couldNotOpen = true;
+		return {};
+	}
+
+	std::vector<char> buffer;
+	buffer.resize(size + 1, 0);
+
+	if (!data->readEntireFileBinary(fileName, &buffer.at(0), size))
+	{
+		couldNotOpen = true;
+		return {};
+	}
+
+	return buffer;
+}
+
+bool inline defaultFileExistsCustom(const char *fileName, void *userData)
+{
+	RequestedContainerInfo *data = (RequestedContainerInfo *)userData;
+	size_t s=0;
+	return data->getFileSizeBinary(fileName, s);
+}
+
+
 struct ThreeDTest: public Container
 {
 
@@ -38,12 +94,17 @@ struct ThreeDTest: public Container
 	void create(RequestedContainerInfo &requestedInfo)
 	{
 	
-		glEnable(GL_DEBUG_OUTPUT);
-		glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
-		glDebugMessageCallback(gl3d::glDebugOutput, &renderer.errorReporter);
-		glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
+		//glEnable(GL_DEBUG_OUTPUT);
+		//glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
+		//glDebugMessageCallback(gl3d::glDebugOutput, &renderer.errorReporter);
+		//glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
 
 		renderer.setErrorCallback(&errorCallbackCustom, &requestedInfo);
+		renderer.fileOpener.userData = &requestedInfo;
+		renderer.fileOpener.readEntireFileBinaryCallback = readEntireFileBinaryCustom;
+		renderer.fileOpener.readEntireFileCallback = readEntireFileCustom;
+		renderer.fileOpener.fileExistsCallback = defaultFileExistsCustom;
+
 		renderer.init(1, 1, requestedInfo.requestedFBO.fbo);
 		//renderer.skyBox = renderer.atmosfericScattering({0.2,1,0.3}, {0.9,0.1,0.1}, {0.4, 0.4, 0.8}, 0.8f); //todo a documentation
 		//todo api for skybox stuff
@@ -58,6 +119,7 @@ struct ThreeDTest: public Container
 			PIKA_RESOURCES_PATH "/skyBoxes/ocean/back.jpg"};
 
 		renderer.skyBox = renderer.loadSkyBox(names, requestedInfo.requestedFBO.fbo);
+		//renderer.skyBox.color = {0.2,0.3,0.8};
 
 	}
 
@@ -66,6 +128,10 @@ struct ThreeDTest: public Container
 	{
 		glDebugMessageCallback(gl3d::glDebugOutput, &renderer.errorReporter);
 		renderer.setErrorCallback(&errorCallbackCustom, &requestedInfo);
+		renderer.fileOpener.userData = &requestedInfo;
+		renderer.fileOpener.readEntireFileBinaryCallback = readEntireFileBinaryCustom;
+		renderer.fileOpener.readEntireFileCallback = readEntireFileCustom;
+		renderer.fileOpener.fileExistsCallback = defaultFileExistsCustom;
 
 
 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

Pika/pluggins/pluggins/immageViewer.h

@@ -30,14 +30,31 @@ struct ImmageViewer: public Container
 	{
 		
 
+		//pika::memory::setGlobalAllocatorToStandard();
+		//{
+		//	texture.loadFromFile(PIKA_RESOURCES_PATH "map.png", true, true);
+		//}
+		//pika::memory::setGlobalAllocator(requestedInfo.mainAllocator);
 
-		pika::memory::setGlobalAllocatorToStandard();
+
+		size_t size = 0;
+		if (!requestedInfo.getFileSizeBinary(PIKA_RESOURCES_PATH "map.png", size))
 		{
-			texture.loadFromFile(PIKA_RESOURCES_PATH "map.png", true, true);
+			//return 0; //todo
+		}
+		
+		unsigned char *buffer = new unsigned char[size];
+		
+		if (!requestedInfo.readEntireFileBinary(PIKA_RESOURCES_PATH "map.png", buffer, size))
+		{
+			//no need to clear memory since the engine clears it for us
+			//return 0; //todo
 		}
-		pika::memory::setGlobalAllocator(requestedInfo.mainAllocator);
-
 		
+		texture.createFromFileData(buffer, size, true, true);
+		
+		delete[] buffer;
+
 	}
 
 	void update(pika::Input input, pika::WindowState windowState,

Pika/resources/logs.txt

@@ -1,15 +1,4 @@
-#2022-11-15 19:40:40: Created container: Gameplay
-#2022-11-15 19:40:56: Loaded snapshot
-#2022-11-15 19:40:59: Loaded snapshot
-#2022-11-15 19:41:02: Loaded snapshot
-#2022-11-15 19:41:04: Loaded snapshot
-#2022-11-15 19:41:07: Loaded snapshot
-#2022-11-15 19:41:10: Loaded snapshot
-#2022-11-15 19:41:13: Loaded snapshot
-#2022-11-15 19:41:16: Loaded snapshot
-#2022-11-15 19:41:18: Loaded snapshot
-#2022-11-15 19:41:21: Loaded snapshot
-#2022-11-15 19:41:23: Loaded snapshot
-#2022-11-15 19:41:26: Loaded snapshot
-#2022-11-15 19:41:29: Loaded snapshot
-#2022-11-15 19:41:32: Destroyed continer: Gameplay #1
+#2022-11-18 11:38:17: Created container: Gameplay
+#2022-11-18 11:38:20: Created container: ThreeDTest
+#2022-11-18 11:38:30: Destroyed continer: Gameplay #1
+#2022-11-18 11:38:30: Destroyed continer: ThreeDTest #2

Pika/thirdparty/gl3d/gl3d.cpp

@@ -1,6 +1,6 @@
 ////////////////////////////////////////////////
 //gl32 --Vlad Luta -- 
-//built on 2022-11-14
+//built on 2022-11-18
 ////////////////////////////////////////////////
 
 #include "gl3d.h"
@@ -23766,7 +23766,6 @@ namespace tinygltf
 //#include <cassert>
 #ifndef TINYGLTF_NO_FS
 #include <cstdio>
-#include <fstream>
 #endif
 #include <sstream>
 
@@ -25110,9 +25109,15 @@ namespace tinygltf
 	#endif
 	}
 
+	//removed default write
+
 	bool ReadWholeFile(std::vector<unsigned char> *out, std::string *err,
 		const std::string &filepath, void *)
 	{
+		assert(0);
+
+		/*
+
 	#ifdef TINYGLTF_ANDROID_LOAD_FROM_ASSETS
 		if (asset_manager)
 		{
@@ -25204,11 +25209,19 @@ namespace tinygltf
 
 		return true;
 	#endif
+
+	*/
+		return false;
+
 	}
 
+	//removed writing data
+
 	bool WriteWholeFile(std::string *err, const std::string &filepath,
 		const std::vector<unsigned char> &contents, void *)
 	{
+		assert(0);
+		/*
 	#ifdef _WIN32
 	#if defined(__GLIBCXX__)  // mingw
 		int file_descriptor = _wopen(UTF8ToWchar(filepath).c_str(),
@@ -25243,7 +25256,7 @@ namespace tinygltf
 			}
 			return false;
 		}
-
+		*/
 		return true;
 	}
 
@@ -29683,9 +29696,14 @@ namespace tinygltf
 		}
 	}
 
+	//removed writing data
+
 	static bool SerializeGltfBufferData(const std::vector<unsigned char> &data,
 		const std::string &binFilename)
 	{
+		assert(0);
+
+		/*
 	#ifdef _WIN32
 	#if defined(__GLIBCXX__)  // mingw
 		int file_descriptor = _wopen(UTF8ToWchar(binFilename).c_str(),
@@ -29716,6 +29734,7 @@ namespace tinygltf
 			// size 0 will be still valid buffer data.
 			// write empty file.
 		}
+		*/
 		return true;
 	}
 
@@ -30795,9 +30814,14 @@ namespace tinygltf
 		return true;
 	}
 
+	//removed writing data
+
 	static bool WriteGltfFile(const std::string &output,
 		const std::string &content)
 	{
+		assert(0);
+
+		/*
 	#ifdef _WIN32
 	#if defined(_MSC_VER)
 		std::ofstream gltfFile(UTF8ToWchar(output).c_str());
@@ -30817,6 +30841,8 @@ namespace tinygltf
 		if (!gltfFile.is_open()) return false;
 	#endif
 		return WriteGltfStream(gltfFile, content);
+		*/
+		return 0;
 	}
 
 	static void WriteBinaryGltfStream(std::ostream &stream,
@@ -30889,10 +30915,15 @@ namespace tinygltf
 		}
 	}
 
+	//removed writing data
+
 	static void WriteBinaryGltfFile(const std::string &output,
 		const std::string &content,
 		const std::vector<unsigned char> &binBuffer)
 	{
+		assert(0);
+
+		/*
 	#ifdef _WIN32
 	#if defined(_MSC_VER)
 		std::ofstream gltfFile(UTF8ToWchar(output).c_str(), std::ios::binary);
@@ -30909,6 +30940,7 @@ namespace tinygltf
 		std::ofstream gltfFile(output.c_str(), std::ios::binary);
 	#endif
 		WriteBinaryGltfStream(gltfFile, content, binBuffer);
+		*/
 	}
 
 	bool TinyGLTF::WriteGltfSceneToStream(Model *model, std::ostream &stream,
@@ -31261,6 +31293,21 @@ void gl3d::defaultErrorCallback(std::string err, void *userData)
 {
 }
 
+std::string gl3d::defaultReadEntireFile(const char* fileName, bool &couldNotOpen, void *userData)
+{
+	return "";
+}
+
+std::vector<char> gl3d::defaultReadEntireFileBinary(const char *fileName, bool &couldNotOpen, void *userData)
+{
+	return {};
+}
+
+bool gl3d::defaultFileExists(const char *fileName, void *userData)
+{
+	return {};
+}
+
 #pragma endregion
 
 
@@ -31286,12 +31333,19 @@ void gl3d::defaultErrorCallback(std::string err, void *userData)
 namespace gl3d
 {
 
-	std::string GpuTexture::loadTextureFromFile(const char *file, int quality, int channels)
+	std::string GpuTexture::loadTextureFromFile(const char *file, FileOpener &fileOpener, int quality, int channels)
 	{
-	
-		int w, h, nrChannels;
+		
+		bool couldNotOpen = 0;
+		auto content = fileOpener.binary(file, couldNotOpen);
+		if (couldNotOpen)
+		{
+			return std::string("Could not open file: ") + file;
+		}
+
+		int w=0, h=0, nrChannels=0;
 		stbi_set_flip_vertically_on_load(true);
-		unsigned char *data = stbi_load(file, &w, &h, &nrChannels, channels);
+		unsigned char *data = stbi_load_from_memory((unsigned char*)content.data(), content.size(), &w, &h, &nrChannels, channels);
 	
 		if (!data)
 		{
@@ -31701,7 +31755,7 @@ namespace gl3d
 #pragma region Shader
 #define GL3D_LOAD_SHADERS_FROM_HEADER_ONLY
 
-#include <fstream>
+
 #include <unordered_map>
 
 namespace gl3d
@@ -34096,7 +34150,7 @@ namespace gl3d
 
 	};
 	
-	GLint createShaderFromFile(const char* source, GLenum shaderType, ErrorReporter &errorReporter)
+	GLint createShaderFromFile(const char* source, GLenum shaderType, ErrorReporter &errorReporter, FileOpener &fileOpener)
 	{
 		std::string newFileName;
 		std::string strSource = source;
@@ -34122,46 +34176,31 @@ namespace gl3d
 
 #else
 
-	GLint createShaderFromFile(const char* source, GLenum shaderType, ErrorReporter &errorReporter)
+	GLint createShaderFromFile(const char* name, GLenum shaderType, ErrorReporter &errorReporter, FileOpener &fileOpener)
 	{
-		std::ifstream file;
-		file.open(source);
+		bool err = 0;
+		auto fileContent = fileOpener(name, err);
 
-		if (!file.is_open())
+		if (err)
 		{
-			errorReporter.callErrorCallback(std::string("Error openning file: ") + source);
+			errorReporter.callErrorCallback(std::string("Error openning file: ") + name);
 			return 0;
 		}
-
-		GLint size = 0;
-		file.seekg(0, file.end);
-		size = file.tellg();
-		file.seekg(0, file.beg);
-
-		char* fileContent = new char[size+1] {};
-
-		file.read(fileContent, size);
-
-
-		file.close();
-
-		auto rez = createShaderFromData(fileContent, shaderType, errorReporter);
-
-		delete[] fileContent;
+		auto rez = createShaderFromData(fileContent.c_str(), shaderType, errorReporter);
 
 		return rez;
-
 	}
 
 #endif
 
 
 
-	bool Shader::loadShaderProgramFromFile(const char *vertexShader, const char *fragmentShader, ErrorReporter &errorReporter)
+	bool Shader::loadShaderProgramFromFile(const char *vertexShader, const char *fragmentShader,
+		ErrorReporter &errorReporter, FileOpener &fileOpener)
 	{
 
-		auto vertexId = createShaderFromFile(vertexShader, GL_VERTEX_SHADER, errorReporter);
-		auto fragmentId = createShaderFromFile(fragmentShader, GL_FRAGMENT_SHADER, errorReporter);
+		auto vertexId = createShaderFromFile(vertexShader, GL_VERTEX_SHADER, errorReporter, fileOpener);
+		auto fragmentId = createShaderFromFile(fragmentShader, GL_FRAGMENT_SHADER, errorReporter, fileOpener);
 
 
 		if (vertexId == 0 || fragmentId == 0)
@@ -34208,12 +34247,12 @@ namespace gl3d
 	}
 
 	bool Shader::loadShaderProgramFromFile(const char *vertexShader, const char *geometryShader, const char *fragmentShader,
-		ErrorReporter &errorReporter)
+		ErrorReporter &errorReporter, FileOpener &fileOpener)
 	{
 
-		auto vertexId = createShaderFromFile(vertexShader, GL_VERTEX_SHADER, errorReporter);
-		auto geometryId = createShaderFromFile(geometryShader, GL_GEOMETRY_SHADER, errorReporter);
-		auto fragmentId = createShaderFromFile(fragmentShader, GL_FRAGMENT_SHADER, errorReporter);
+		auto vertexId = createShaderFromFile(vertexShader, GL_VERTEX_SHADER, errorReporter, fileOpener);
+		auto geometryId = createShaderFromFile(geometryShader, GL_GEOMETRY_SHADER, errorReporter, fileOpener);
+		auto fragmentId = createShaderFromFile(fragmentShader, GL_FRAGMENT_SHADER, errorReporter, fileOpener);
 
 		if (vertexId == 0 || fragmentId == 0 || geometryId == 0)
 		{
@@ -34323,12 +34362,12 @@ namespace gl3d
 
 
 	//todo move
-	std::string LightShader::create(ErrorReporter &errorReporter)
+	std::string LightShader::create(ErrorReporter &errorReporter, FileOpener &fileOpener)
 	{
 		std::string error = "";
 
 	#pragma region brdf texture
-		error += brdfTexture.loadTextureFromFile("resources/BRDFintegrationMap.png", TextureLoadQuality::leastPossible, 3);
+		error += brdfTexture.loadTextureFromFile("resources/BRDFintegrationMap.png", fileOpener, TextureLoadQuality::leastPossible, 3);
 		glBindTexture(GL_TEXTURE_2D, brdfTexture.id);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
@@ -34338,7 +34377,7 @@ namespace gl3d
 
 		if (!error.empty()) { error += "\n"; };
 
-		prePass.shader.loadShaderProgramFromFile("shaders/deferred/zPrePass.vert", "shaders/deferred/zPrePass.frag", errorReporter);
+		prePass.shader.loadShaderProgramFromFile("shaders/deferred/zPrePass.vert", "shaders/deferred/zPrePass.frag", errorReporter, fileOpener);
 		prePass.u_transform = getUniform(prePass.shader.id, "u_transform", errorReporter);
 		prePass.u_albedoSampler = getUniform(prePass.shader.id, "u_albedoSampler", errorReporter);
 		prePass.u_hasTexture = getUniform(prePass.shader.id, "u_hasTexture", errorReporter);
@@ -34348,7 +34387,7 @@ namespace gl3d
 
 
 		pointShadowShader.shader.loadShaderProgramFromFile("shaders/shadows/pointShadow.vert",
-			"shaders/shadows/pointShadow.geom", "shaders/shadows/pointShadow.frag", errorReporter);
+			"shaders/shadows/pointShadow.geom", "shaders/shadows/pointShadow.frag", errorReporter, fileOpener);
 		pointShadowShader.u_albedoSampler = getUniform(pointShadowShader.shader.id, "u_albedoSampler", errorReporter);
 		pointShadowShader.u_farPlane = getUniform(pointShadowShader.shader.id, "u_farPlane", errorReporter);
 		pointShadowShader.u_hasTexture = getUniform(pointShadowShader.shader.id, "u_hasTexture", errorReporter);
@@ -34362,7 +34401,8 @@ namespace gl3d
 
 
 
-		geometryPassShader.loadShaderProgramFromFile("shaders/deferred/geometryPass.vert", "shaders/deferred/geometryPass.frag", errorReporter);
+		geometryPassShader.loadShaderProgramFromFile("shaders/deferred/geometryPass.vert",
+			"shaders/deferred/geometryPass.frag", errorReporter, fileOpener);
 		//geometryPassShader.bind();
 
 		u_transform = getUniform(geometryPassShader.id, "u_transform", errorReporter);
@@ -34387,7 +34427,8 @@ namespace gl3d
 		glShaderStorageBlockBinding(geometryPassShader.id, u_jointTransforms, internal::JointsTransformBlockBinding);		//todo define or enums for this
 		
 
-		lightingPassShader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/deferred/lightingPass.frag", errorReporter);
+		lightingPassShader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/deferred/lightingPass.frag",
+			errorReporter, fileOpener);
 		lightingPassShader.bind();
 
 		light_u_normals = getUniform(lightingPassShader.id, "u_normals", errorReporter);
@@ -34791,13 +34832,12 @@ namespace gl3d
 	}
 
 
-	void LoadedModelData::load(const char *file, ErrorReporter &errorReporter, float scale)
+	void LoadedModelData::load(const char *file, ErrorReporter &errorReporter, FileOpener &fileOpener, float scale)
 	{
-		stbi_set_flip_vertically_on_load(true);
+		stbi_set_flip_vertically_on_load(true); //gltf and obj files hold textures flipped diferently...
 		bool shouldFlipUVs = 0;
 
-
-		loader.LoadFile(file, errorReporter, &shouldFlipUVs);
+		loader.LoadFile(file, errorReporter, fileOpener, &shouldFlipUVs);
 
 		//parse path
 		path = file;
@@ -35209,31 +35249,31 @@ namespace gl3d
 		*this = GraphicModel{};
 	}
 
-	void SkyBoxLoaderAndDrawer::createGpuData(ErrorReporter &errorReporter, GLuint frameBuffer)
+	void SkyBoxLoaderAndDrawer::createGpuData(ErrorReporter &errorReporter, FileOpener &fileOpener, GLuint frameBuffer)
 	{
-		normalSkyBox.shader.loadShaderProgramFromFile("shaders/skyBox/skyBox.vert", "shaders/skyBox/skyBox.frag", errorReporter);
+		normalSkyBox.shader.loadShaderProgramFromFile("shaders/skyBox/skyBox.vert", "shaders/skyBox/skyBox.frag", errorReporter, fileOpener);
 		normalSkyBox.samplerUniformLocation = getUniform(normalSkyBox.shader.id, "u_skybox", errorReporter);
 		normalSkyBox.modelViewUniformLocation = getUniform(normalSkyBox.shader.id, "u_viewProjection", errorReporter);
 		normalSkyBox.u_ambient = getUniform(normalSkyBox.shader.id, "u_ambient", errorReporter);
 		normalSkyBox.u_skyBoxPresent = getUniform(normalSkyBox.shader.id, "u_skyBoxPresent", errorReporter);
 		
-		hdrtoCubeMap.shader.loadShaderProgramFromFile("shaders/skyBox/hdrToCubeMap.vert", "shaders/skyBox/hdrToCubeMap.frag", errorReporter);
+		hdrtoCubeMap.shader.loadShaderProgramFromFile("shaders/skyBox/hdrToCubeMap.vert", "shaders/skyBox/hdrToCubeMap.frag", errorReporter, fileOpener);
 		hdrtoCubeMap.u_equirectangularMap = getUniform(hdrtoCubeMap.shader.id, "u_equirectangularMap", errorReporter);
 		hdrtoCubeMap.modelViewUniformLocation = getUniform(hdrtoCubeMap.shader.id, "u_viewProjection", errorReporter);
 
-		convolute.shader.loadShaderProgramFromFile("shaders/skyBox/hdrToCubeMap.vert", "shaders/skyBox/convolute.frag", errorReporter);
+		convolute.shader.loadShaderProgramFromFile("shaders/skyBox/hdrToCubeMap.vert", "shaders/skyBox/convolute.frag", errorReporter, fileOpener);
 		convolute.u_environmentMap = getUniform(convolute.shader.id, "u_environmentMap", errorReporter);
 		convolute.modelViewUniformLocation = getUniform(convolute.shader.id, "u_viewProjection", errorReporter);
 		convolute.u_sampleQuality = getUniform(convolute.shader.id, "u_sampleQuality", errorReporter);
 
-		preFilterSpecular.shader.loadShaderProgramFromFile("shaders/skyBox/hdrToCubeMap.vert", "shaders/skyBox/preFilterSpecular.frag", errorReporter);
+		preFilterSpecular.shader.loadShaderProgramFromFile("shaders/skyBox/hdrToCubeMap.vert", "shaders/skyBox/preFilterSpecular.frag", errorReporter, fileOpener);
 		preFilterSpecular.modelViewUniformLocation = getUniform(preFilterSpecular.shader.id, "u_viewProjection", errorReporter);
 		preFilterSpecular.u_environmentMap = getUniform(preFilterSpecular.shader.id, "u_environmentMap", errorReporter);
 		preFilterSpecular.u_roughness = getUniform(preFilterSpecular.shader.id, "u_roughness", errorReporter);
 		preFilterSpecular.u_sampleCount = getUniform(preFilterSpecular.shader.id, "u_sampleCount", errorReporter);
 
 		atmosphericScatteringShader.shader.loadShaderProgramFromFile("shaders/skyBox/hdrToCubeMap.vert",
-			"shaders/skyBox/atmosphericScattering.frag", errorReporter);
+			"shaders/skyBox/atmosphericScattering.frag", errorReporter, fileOpener);
 		atmosphericScatteringShader.u_lightPos = getUniform(atmosphericScatteringShader.shader.id, "u_lightPos", errorReporter);
 		atmosphericScatteringShader.u_g = getUniform(atmosphericScatteringShader.shader.id, "u_g", errorReporter);
 		atmosphericScatteringShader.u_color1 = getUniform(atmosphericScatteringShader.shader.id, "u_color1", errorReporter);
@@ -35261,7 +35301,8 @@ namespace gl3d
 
 	}
 
-	void SkyBoxLoaderAndDrawer::loadTexture(const char *names[6], SkyBox &skyBox, ErrorReporter &errorReporter, GLuint frameBuffer)
+	void SkyBoxLoaderAndDrawer::loadTexture(const char *names[6], SkyBox &skyBox, ErrorReporter &errorReporter, FileOpener &fileOpener,
+		GLuint frameBuffer)
 	{
 		skyBox = {};
 
@@ -35270,11 +35311,22 @@ namespace gl3d
 
 		for (unsigned int i = 0; i < 6; i++)
 		{
-			int w, h, nrChannels;
-			unsigned char *data;
+			int w=0, h=0, nrChannels=0;
+			unsigned char *data=0;
 
 			stbi_set_flip_vertically_on_load(false);
-			data = stbi_load(names[i], &w, &h, &nrChannels, 3);
+
+
+			bool couldNotOpen = 0;
+			auto content = fileOpener.binary(names[i], couldNotOpen);
+			if (couldNotOpen)
+			{
+				errorReporter.callErrorCallback(std::string("Could not open file: ") + names[i]);
+				glDeleteTextures(1, &skyBox.texture);
+				return;
+			}
+
+			data = stbi_load_from_memory((unsigned char*)content.data(), content.size(), &w, &h, &nrChannels, 3);
 
 			if (data)
 			{
@@ -35305,17 +35357,26 @@ namespace gl3d
 		createConvolutedAndPrefilteredTextureData(skyBox, frameBuffer);
 	}
 
-	void SkyBoxLoaderAndDrawer::loadTexture(const char *name, SkyBox &skyBox, ErrorReporter &errorReporter,
+	void SkyBoxLoaderAndDrawer::loadTexture(const char *name, SkyBox &skyBox, ErrorReporter &errorReporter, FileOpener &fileOpener,
 		GLuint frameBuffer, int format)
 	{
 		skyBox = {};
 
-		int width, height, nrChannels;
-		unsigned char *data;
-
+		int width=0, height=0, nrChannels=0;
+		unsigned char *data=0;
 
 		stbi_set_flip_vertically_on_load(false);
-		data = stbi_load(name, &width, &height, &nrChannels, 3);
+
+		bool couldNotOpen = 0;
+		auto content = fileOpener.binary(name, couldNotOpen);
+		if (couldNotOpen)
+		{
+			errorReporter.callErrorCallback(std::string("Could not open file: ") + name);
+			glDeleteTextures(1, &skyBox.texture);
+			return;
+		}
+
+		data = stbi_load_from_memory((unsigned char *)content.data(), content.size(), &width, &height, &nrChannels, 3);
 
 		if (!data) { errorReporter.callErrorCallback(std::string("err loading ") + name); return; }
 
@@ -35470,15 +35531,27 @@ namespace gl3d
 
 	}
 
-	void SkyBoxLoaderAndDrawer::loadHDRtexture(const char *name, ErrorReporter &errorReporter, SkyBox &skyBox, GLuint frameBuffer)
+	void SkyBoxLoaderAndDrawer::loadHDRtexture(const char *name, ErrorReporter &errorReporter,
+		FileOpener &fileOpener, SkyBox &skyBox, GLuint frameBuffer)
 	{
 		skyBox = {};
 
-		int width, height, nrChannels;
-		float *data;
+		int width=0, height=0, nrChannels=0;
+		float *data=0;
 
 		stbi_set_flip_vertically_on_load(true);
-		data = stbi_loadf(name, &width, &height, &nrChannels, 0);
+		
+		bool couldNotOpen = 0;
+		auto content = fileOpener.binary(name, couldNotOpen);
+		if (couldNotOpen)
+		{
+			errorReporter.callErrorCallback(std::string("Could not open file: ") + name);
+			glDeleteTextures(1, &skyBox.texture);
+			return;
+		}
+
+		data = stbi_loadf_from_memory((unsigned char *)content.data(), content.size(), &width, &height, &nrChannels, 3);
+
 		if (!data) { errorReporter.callErrorCallback(std::string("err loading ") + name); return; }
 
 
@@ -35855,13 +35928,13 @@ namespace gl3d
 		glEnable(GL_DEPTH_TEST);
 		glDisable(GL_BLEND);
 
-		errorReporter.callErrorCallback(internal.lightShader.create(errorReporter));
+		errorReporter.callErrorCallback(internal.lightShader.create(errorReporter, fileOpener));
 		vao.createVAOs();
-		internal.skyBoxLoaderAndDrawer.createGpuData(errorReporter, frameBuffer);
+		internal.skyBoxLoaderAndDrawer.createGpuData(errorReporter, fileOpener, frameBuffer);
 
 
 		internal.showNormalsProgram.shader.loadShaderProgramFromFile("shaders/showNormals.vert",
-		"shaders/showNormals.geom", "shaders/showNormals.frag", errorReporter);
+		"shaders/showNormals.geom", "shaders/showNormals.frag", errorReporter, fileOpener);
 
 		//todo error report here + make this work :)))
 		internal.showNormalsProgram.modelTransformLocation = glGetUniformLocation(internal.showNormalsProgram.shader.id, "u_modelTransform");
@@ -35879,16 +35952,16 @@ namespace gl3d
 		//defaultTexture.loadTextureFromMemory(textureData, 2, 2, 4, TextureLoadQuality::leastPossible);
 
 		internal.gBuffer.create(x, y, errorReporter, frameBuffer);
-		internal.ssao.create(x, y, errorReporter, frameBuffer);
-		postProcess.create(x, y, errorReporter, frameBuffer);
+		internal.ssao.create(x, y, errorReporter, fileOpener, frameBuffer);
+		postProcess.create(x, y, errorReporter, fileOpener, frameBuffer);
 		directionalShadows.create(frameBuffer);
 		spotShadows.create(frameBuffer);
 		pointShadows.create(frameBuffer);
-		renderDepthMap.create(errorReporter, frameBuffer);
-		antiAlias.create(x, y, errorReporter);
+		renderDepthMap.create(errorReporter, fileOpener, frameBuffer);
+		antiAlias.create(x, y, errorReporter, fileOpener);
 		adaptiveResolution.create(x, y);
 
-		internal.pBRtextureMaker.init(errorReporter);
+		internal.pBRtextureMaker.init(errorReporter, fileOpener);
 	}
 
 	ErrorCallback_t *Renderer3D::setErrorCallback(ErrorCallback_t *errorCallback, void *userData)
@@ -36113,7 +36186,8 @@ namespace gl3d
 
 					if (!mat.map_Pr.empty())
 					{
-						renderer.errorReporter.callErrorCallback(roughness.loadTextureFromFile(std::string(path + mat.map_Pr).c_str(), dontSet, 1));
+						renderer.errorReporter.callErrorCallback(
+							roughness.loadTextureFromFile(std::string(path + mat.map_Pr).c_str(), renderer.fileOpener, dontSet, 1));
 						glBindTexture(GL_TEXTURE_2D, roughness.id);
 						glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 						glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@@ -36122,7 +36196,8 @@ namespace gl3d
 					GpuTexture metallic{};
 					if (!mat.map_Pm.empty())
 					{
-						renderer.errorReporter.callErrorCallback(metallic.loadTextureFromFile(std::string(path + mat.map_Pm).c_str(), dontSet, 1));
+						renderer.errorReporter.callErrorCallback(metallic.loadTextureFromFile(
+							std::string(path + mat.map_Pm).c_str(), renderer.fileOpener, dontSet, 1));
 						glBindTexture(GL_TEXTURE_2D, metallic.id);
 						glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 						glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@@ -36131,7 +36206,8 @@ namespace gl3d
 					GpuTexture ambientOcclusion{};
 					if (!mat.map_Ka.empty())
 					{
-						renderer.errorReporter.callErrorCallback(ambientOcclusion.loadTextureFromFile(std::string(path + mat.map_Ka).c_str(), dontSet, 1));
+						renderer.errorReporter.callErrorCallback(ambientOcclusion.loadTextureFromFile(
+							std::string(path + mat.map_Ka).c_str(), renderer.fileOpener, dontSet, 1));
 						glBindTexture(GL_TEXTURE_2D, ambientOcclusion.id);
 						glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 						glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@@ -36299,7 +36375,7 @@ namespace gl3d
 	{
 
 		objl::Loader loader;
-		if (!loader.LoadMaterials(file, errorReporter)) 
+		if (!loader.LoadMaterials(file, errorReporter, fileOpener)) 
 		{
 			errorReporter.callErrorCallback("err loading: " + file);
 			return {};
@@ -36634,7 +36710,7 @@ namespace gl3d
 	Model Renderer3D::loadModel(std::string path, GLuint frameBuffer, float scale)
 	{
 
-		gl3d::LoadedModelData model(path.c_str(), errorReporter, scale);
+		gl3d::LoadedModelData model(path.c_str(), errorReporter, fileOpener, scale);
 		if(model.loader.LoadedMeshes.empty())
 		{
 			errorReporter.callErrorCallback("err loading " + path);
@@ -40876,21 +40952,21 @@ namespace gl3d
 	SkyBox Renderer3D::loadSkyBox(const char *names[6], GLuint frameBuffer)
 	{
 		SkyBox skyBox = {};
-		internal.skyBoxLoaderAndDrawer.loadTexture(names, skyBox, errorReporter, frameBuffer);
+		internal.skyBoxLoaderAndDrawer.loadTexture(names, skyBox, errorReporter, fileOpener, frameBuffer);
 		return skyBox;
 	}
 
 	SkyBox Renderer3D::loadSkyBox(const char *name, int format)
 	{
 		SkyBox skyBox = {};
-		internal.skyBoxLoaderAndDrawer.loadTexture(name, skyBox, errorReporter, format);
+		internal.skyBoxLoaderAndDrawer.loadTexture(name, skyBox, errorReporter, fileOpener, format);
 		return skyBox;
 	}
 
 	SkyBox Renderer3D::loadHDRSkyBox(const char *name, GLuint frameBuffer)
 	{
 		SkyBox skyBox = {};
-		internal.skyBoxLoaderAndDrawer.loadHDRtexture(name, errorReporter, skyBox, frameBuffer);
+		internal.skyBoxLoaderAndDrawer.loadHDRtexture(name, errorReporter, fileOpener, skyBox, frameBuffer);
 		return skyBox;
 	}
 
@@ -40911,7 +40987,8 @@ namespace gl3d
 		return a + f * (b - a);
 	}
 
-	void Renderer3D::InternalStruct::SSAO::create(int w, int h, ErrorReporter &errorReporter, GLuint frameBuffer)
+	void Renderer3D::InternalStruct::SSAO::create(int w, int h, ErrorReporter &errorReporter,
+		FileOpener &fileOpener, GLuint frameBuffer)
 	{
 		std::uniform_real_distribution<float> randomFloats(0.0f, 1.0f);
 		std::uniform_real_distribution<float> randomFloatsSmaller(0.1f, 0.9f); //avoid ssao artefacts
@@ -40971,7 +41048,7 @@ namespace gl3d
 		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ssaoColorBuffer, 0);
 
 
-		shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/ssao/ssao.frag", errorReporter);
+		shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/ssao/ssao.frag", errorReporter, fileOpener);
 
 
 		u_projection = getUniform(shader.id, "u_projection", errorReporter);
@@ -40992,7 +41069,7 @@ namespace gl3d
 		glUniformBlockBinding(shader.id, u_SSAODATA, internal::SSAODataBlockBinding);
 		
 		//blur
-		blurShader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/ssao/blur.frag", errorReporter);
+		blurShader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/ssao/blur.frag", errorReporter, fileOpener);
 		
 		glGenFramebuffers(1, &blurBuffer);
 		glBindFramebuffer(GL_FRAMEBUFFER, blurBuffer);
@@ -41027,7 +41104,7 @@ namespace gl3d
 	
 	}
 
-	void Renderer3D::PostProcess::create(int w, int h, ErrorReporter &errorReporter, GLuint frameBuffer)
+	void Renderer3D::PostProcess::create(int w, int h, ErrorReporter &errorReporter, FileOpener &fileOpener, GLuint frameBuffer)
 	{
 		glGenFramebuffers(1, &fbo);
 		glBindFramebuffer(GL_FRAMEBUFFER, fbo);
@@ -41057,7 +41134,8 @@ namespace gl3d
 
 
 		
-		postProcessShader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/postProcess.frag", errorReporter);
+		postProcessShader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/postProcess.frag", 
+			errorReporter, fileOpener);
 		u_colorTexture = getUniform(postProcessShader.id, "u_colorTexture", errorReporter);
 		u_bloomTexture = getUniform(postProcessShader.id, "u_bloomTexture", errorReporter);
 		u_bloomNotBluredTexture = getUniform(postProcessShader.id, "u_bloomNotBluredTexture", errorReporter);
@@ -41069,30 +41147,30 @@ namespace gl3d
 		u_ssao = getUniform(postProcessShader.id, "u_ssao", errorReporter);
 
 
-		gausianBLurShader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/gausianBlur.frag", errorReporter);
+		gausianBLurShader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/gausianBlur.frag", errorReporter, fileOpener);
 		u_toBlurcolorInput = getUniform(gausianBLurShader.id, "u_toBlurcolorInput", errorReporter);
 		u_horizontal = getUniform(gausianBLurShader.id, "u_horizontal", errorReporter);
 		u_mip = getUniform(gausianBLurShader.id, "u_mip", errorReporter);
 		u_texel = getUniform(gausianBLurShader.id, "u_texel", errorReporter);
 
-		filterShader.shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/filter.frag", errorReporter);
+		filterShader.shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/filter.frag", errorReporter, fileOpener);
 		filterShader.u_exposure = getUniform(filterShader.shader.id, "u_exposure", errorReporter);
 		filterShader.u_texture = getUniform(filterShader.shader.id, "u_texture", errorReporter);
 		filterShader.u_tresshold = getUniform(filterShader.shader.id, "u_tresshold", errorReporter);
 
-		addMips.shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/addMips.frag", errorReporter);
+		addMips.shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/addMips.frag", errorReporter, fileOpener);
 		addMips.u_mip = getUniform(addMips.shader.id, "u_mip", errorReporter);
 		addMips.u_texture= getUniform(addMips.shader.id, "u_texture", errorReporter);
 
-		addMipsBlur.shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/addMipsBlur.frag", errorReporter);
+		addMipsBlur.shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/addMipsBlur.frag", errorReporter, fileOpener);
 		addMipsBlur.u_mip = getUniform(addMipsBlur.shader.id, "u_mip", errorReporter);
 		addMipsBlur.u_texture = getUniform(addMipsBlur.shader.id, "u_texture", errorReporter);
 
-		filterDown.shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/filterDown.frag", errorReporter);
+		filterDown.shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/filterDown.frag", errorReporter, fileOpener);
 		filterDown.u_mip = getUniform(filterDown.shader.id, "u_mip", errorReporter);
 		filterDown.u_texture = getUniform(filterDown.shader.id, "u_texture", errorReporter);
 
-		chromaticAberation.shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/chromaticAberation.frag", errorReporter);
+		chromaticAberation.shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/postProcess/chromaticAberation.frag", errorReporter, fileOpener);
 		chromaticAberation.u_finalColorTexture = getUniform(chromaticAberation.shader.id, "u_finalColorTexture", errorReporter);
 		chromaticAberation.u_windowSize = getUniform(chromaticAberation.shader.id, "u_windowSize", errorReporter);
 		chromaticAberation.u_strength = getUniform(chromaticAberation.shader.id, "u_strength", errorReporter);
@@ -41187,9 +41265,9 @@ namespace gl3d
 
 	}
 
-	void Renderer3D::InternalStruct::PBRtextureMaker::init(ErrorReporter &errorReporter)
+	void Renderer3D::InternalStruct::PBRtextureMaker::init(ErrorReporter &errorReporter, FileOpener &fileOpener)
 	{
-		shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/modelLoader/mergePBRmat.frag", errorReporter);
+		shader.loadShaderProgramFromFile("shaders/drawQuads.vert", "shaders/modelLoader/mergePBRmat.frag", errorReporter, fileOpener);
 		glGenFramebuffers(1, &fbo);
 	}
 
@@ -41203,7 +41281,7 @@ namespace gl3d
 
 		skyBoxLoaderAndDrawer.draw(viewProjMat, s,
 			lightShader.lightPassUniformBlockCpuData.exposure,
-			lightShader.lightPassUniformBlockCpuData.ambientLight);
+			s.color);
 	}
 
 	void Renderer3D::InternalStruct::renderSkyBoxBefore(Camera& c, SkyBox& s)
@@ -41216,7 +41294,7 @@ namespace gl3d
 
 		skyBoxLoaderAndDrawer.drawBefore(viewProjMat, s,
 			lightShader.lightPassUniformBlockCpuData.exposure,
-			lightShader.lightPassUniformBlockCpuData.ambientLight);
+			s.color);
 	}
 
 	//todo use the max w h to create it
@@ -41419,11 +41497,11 @@ namespace gl3d
 	}
 
 
-	void Renderer3D::AntiAlias::create(int w, int h, ErrorReporter &errorReporter)
+	void Renderer3D::AntiAlias::create(int w, int h, ErrorReporter &errorReporter, FileOpener &fileOpener)
 	{
 
 		shader.loadShaderProgramFromFile("shaders/drawQuads.vert",
-			"shaders/aa/fxaa.frag", errorReporter);
+			"shaders/aa/fxaa.frag", errorReporter, fileOpener);
 		u_texture = getUniform(shader.id, "u_texture", errorReporter);
 
 		u_FXAAData = glGetUniformBlockIndex(shader.id, "u_FXAAData");
@@ -41436,14 +41514,14 @@ namespace gl3d
 		glBindBuffer(GL_UNIFORM_BUFFER, 0);
 
 		noAAshader.loadShaderProgramFromFile("shaders/drawQuads.vert",
-			"shaders/aa/noaa.frag", errorReporter);
+			"shaders/aa/noaa.frag", errorReporter, fileOpener);
 		noAAu_texture = getUniform(noAAshader.id, "u_texture", errorReporter);
 
 
 
 	}
 
-	void Renderer3D::RenderDepthMap::create(ErrorReporter &errorReporter, GLuint frameBuffer)
+	void Renderer3D::RenderDepthMap::create(ErrorReporter &errorReporter, FileOpener &fileOpener, GLuint frameBuffer)
 	{
 		glGenFramebuffers(1, &fbo);
 		glBindFramebuffer(GL_FRAMEBUFFER, fbo);
@@ -41464,7 +41542,7 @@ namespace gl3d
 		}
 
 		shader.loadShaderProgramFromFile
-			("shaders/drawQuads.vert", "shaders/drawDepth.frag", errorReporter);
+			("shaders/drawQuads.vert", "shaders/drawDepth.frag", errorReporter, fileOpener);
 		u_depth = getUniform(shader.id, "u_depth", errorReporter);
 		
 		glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);

Pika/thirdparty/gl3d/gl3d/gl3d.h

@@ -1,6 +1,6 @@
 ////////////////////////////////////////////////
 //gl32 --Vlad Luta -- 
-//built on 2022-11-14
+//built on 2022-11-18
 ////////////////////////////////////////////////
 
 
@@ -16,6 +16,8 @@
 #include <glad/glad.h>
 #include <stb_image/stb_image.h>
 
+
+
 #include <glm/vec4.hpp>
 #include <glm/vec3.hpp>
 #include <glm/mat4x4.hpp>
@@ -219,14 +221,22 @@ namespace gl3d
 #pragma once
 
 #include <string>
+#include <vector>
+
 
 namespace gl3d
 {
 
 	void defaultErrorCallback(std::string err, void *userData);
+	std::string defaultReadEntireFile(const char *fileName, bool &couldNotOpen, void *userData);
+	std::vector<char> defaultReadEntireFileBinary(const char *fileName, bool &couldNotOpen, void *userData);
+	bool defaultFileExists(const char *fileName, void *userData);
 
 	using ErrorCallback_t = decltype(defaultErrorCallback);
-	
+	using ReadEntireFile_t = decltype(defaultReadEntireFile);
+	using ReadEntireFileBinart_t = decltype(defaultReadEntireFileBinary);
+	using FileExists_t = decltype(defaultFileExists);
+
 	struct ErrorReporter
 	{
 		ErrorCallback_t *currentErrorCallback = defaultErrorCallback;
@@ -235,6 +245,31 @@ namespace gl3d
 		void callErrorCallback(std::string s);
 	};
 
+
+
+	struct FileOpener
+	{
+		ReadEntireFile_t *readEntireFileCallback = defaultReadEntireFile;
+		ReadEntireFileBinart_t *readEntireFileBinaryCallback = defaultReadEntireFileBinary;
+		FileExists_t *fileExistsCallback = defaultFileExists;
+		void *userData = nullptr;
+
+		std::string operator()(const char *fileName, bool &couldNotOpen)
+		{
+			return readEntireFileCallback(fileName, couldNotOpen, userData);
+		}
+
+		std::vector<char> binary(const char *fileName, bool &couldNotOpen)
+		{
+			return readEntireFileBinaryCallback(fileName, couldNotOpen, userData);
+		}
+
+		bool exists(const char *fileName)
+		{
+			return fileExistsCallback(fileName, userData);
+		}
+	};
+
 };
 #pragma endregion
 
@@ -24105,7 +24140,6 @@ namespace tinygltf
 //#include <cassert>
 #ifndef TINYGLTF_NO_FS
 #include <cstdio>
-#include <fstream>
 #endif
 #include <sstream>
 
@@ -25449,9 +25483,15 @@ namespace tinygltf
 	#endif
 	}
 
+	//removed default write
+
 	bool ReadWholeFile(std::vector<unsigned char> *out, std::string *err,
 		const std::string &filepath, void *)
 	{
+		assert(0);
+
+		/*
+
 	#ifdef TINYGLTF_ANDROID_LOAD_FROM_ASSETS
 		if (asset_manager)
 		{
@@ -25543,11 +25583,19 @@ namespace tinygltf
 
 		return true;
 	#endif
+
+	*/
+		return false;
+
 	}
 
+	//removed writing data
+
 	bool WriteWholeFile(std::string *err, const std::string &filepath,
 		const std::vector<unsigned char> &contents, void *)
 	{
+		assert(0);
+		/*
 	#ifdef _WIN32
 	#if defined(__GLIBCXX__)  // mingw
 		int file_descriptor = _wopen(UTF8ToWchar(filepath).c_str(),
@@ -25582,7 +25630,7 @@ namespace tinygltf
 			}
 			return false;
 		}
-
+		*/
 		return true;
 	}
 
@@ -30022,9 +30070,14 @@ namespace tinygltf
 		}
 	}
 
+	//removed writing data
+
 	static bool SerializeGltfBufferData(const std::vector<unsigned char> &data,
 		const std::string &binFilename)
 	{
+		assert(0);
+
+		/*
 	#ifdef _WIN32
 	#if defined(__GLIBCXX__)  // mingw
 		int file_descriptor = _wopen(UTF8ToWchar(binFilename).c_str(),
@@ -30055,6 +30108,7 @@ namespace tinygltf
 			// size 0 will be still valid buffer data.
 			// write empty file.
 		}
+		*/
 		return true;
 	}
 
@@ -31134,9 +31188,14 @@ namespace tinygltf
 		return true;
 	}
 
+	//removed writing data
+
 	static bool WriteGltfFile(const std::string &output,
 		const std::string &content)
 	{
+		assert(0);
+
+		/*
 	#ifdef _WIN32
 	#if defined(_MSC_VER)
 		std::ofstream gltfFile(UTF8ToWchar(output).c_str());
@@ -31156,6 +31215,8 @@ namespace tinygltf
 		if (!gltfFile.is_open()) return false;
 	#endif
 		return WriteGltfStream(gltfFile, content);
+		*/
+		return 0;
 	}
 
 	static void WriteBinaryGltfStream(std::ostream &stream,
@@ -31228,10 +31289,15 @@ namespace tinygltf
 		}
 	}
 
+	//removed writing data
+
 	static void WriteBinaryGltfFile(const std::string &output,
 		const std::string &content,
 		const std::vector<unsigned char> &binBuffer)
 	{
+		assert(0);
+
+		/*
 	#ifdef _WIN32
 	#if defined(_MSC_VER)
 		std::ofstream gltfFile(UTF8ToWchar(output).c_str(), std::ios::binary);
@@ -31248,6 +31314,7 @@ namespace tinygltf
 		std::ofstream gltfFile(output.c_str(), std::ios::binary);
 	#endif
 		WriteBinaryGltfStream(gltfFile, content, binBuffer);
+		*/
 	}
 
 	bool TinyGLTF::WriteGltfSceneToStream(Model *model, std::ostream &stream,
@@ -31455,9 +31522,8 @@ namespace tinygltf
 
 // String - STD String Library
 #include <string>
+#include <sstream>
 
-// fStream - STD File I/O Library
-#include <fstream>
 
 // Math.h - STD math Library
 #include <math.h>
@@ -31960,6 +32026,31 @@ namespace objl
 		}
 	}
 
+	inline bool customFileExists(const std::string &abs_filename, void *userData)
+	{
+		gl3d::FileOpener *fileOpener = (gl3d::FileOpener *)userData;
+
+		return fileOpener->exists(abs_filename.c_str());
+	}
+
+	inline bool customGLTFReadWholeFile(std::vector<unsigned char> *out, std::string *err,
+		const std::string &filepath, void *userData)
+	{
+		gl3d::FileOpener *fileOpener = (gl3d::FileOpener *)userData;
+
+		bool couldNotOpen = false;
+		auto rez = fileOpener->binary(filepath.c_str(), couldNotOpen);
+
+		if (couldNotOpen)
+		{
+			*err = "Error, could not open file: " + filepath;
+			return 0;
+		}
+		
+		out->assign(rez.begin(), rez.end());
+		return 1;
+	}
+
 	// Class: Loader
 	//
 	// Description: The OBJ Model Loader
@@ -31975,23 +32066,23 @@ namespace objl
 		//
 		// If the file is unable to be found
 		// or unable to be loaded return false
-		bool LoadFile(std::string Path, gl3d::ErrorReporter &reporter, bool *outShouldFlipUV = 0)
+		bool LoadFile(std::string Path, gl3d::ErrorReporter &reporter, gl3d::FileOpener &fileOpener, bool *outShouldFlipUV = 0)
 		{
 			if (outShouldFlipUV) { *outShouldFlipUV = 0; }
 
 			// If the file is not an .obj file return false
 			if (Path.substr(Path.size() - 4, 4) == ".obj")
 			{
-				return loadObj(Path, reporter);
+				return loadObj(Path, reporter, fileOpener);
 			}
 			else if (Path.substr(Path.size() - 5, 5) == ".gltf") 
 			{
 				if (outShouldFlipUV) { *outShouldFlipUV = 1; }
-				return loadGltf(Path, reporter, 0);
+				return loadGltf(Path, reporter, fileOpener, 0);
 			}else if (Path.substr(Path.size() - 4, 4) == ".glb")
 			{
 				if (outShouldFlipUV) { *outShouldFlipUV = 1; }
-				return loadGltf(Path, reporter, 1);
+				return loadGltf(Path, reporter, fileOpener, 1);
 			}
 			else
 			{
@@ -32013,11 +32104,21 @@ namespace objl
 			}
 		};
 
-		bool loadGltf(const std::string &Path, gl3d::ErrorReporter &errorReporter, bool glb = 0)
+		bool loadGltf(const std::string &Path, gl3d::ErrorReporter &errorReporter,
+			gl3d::FileOpener &fileOpener, bool glb = 0)
 		{
-
 			tinygltf::Model model;
 			tinygltf::TinyGLTF loader;
+			
+			tinygltf::FsCallbacks callBacks;
+
+			callBacks.ExpandFilePath = tinygltf::ExpandFilePath;
+			callBacks.FileExists = customFileExists;
+			callBacks.ReadWholeFile = customGLTFReadWholeFile;
+			callBacks.WriteWholeFile = tinygltf::WriteWholeFile;
+			callBacks.user_data = &fileOpener;
+
+			loader.SetFsCallbacks(callBacks);
 
 			std::string err;
 			std::string warn;
@@ -32874,14 +32975,19 @@ namespace objl
 
 		}
 
-		bool loadObj(const std::string &Path, gl3d::ErrorReporter &repoter)
+		bool loadObj(const std::string &Path, gl3d::ErrorReporter &repoter, gl3d::FileOpener &fileOpener)
 		{
 
-			std::ifstream file(Path);
 
-			if (!file.is_open())
+			bool couldNotOpen = 0;
+			auto fileContent = fileOpener(Path.c_str(), couldNotOpen);
+
+			if (couldNotOpen)
 				return false;
 
+			std::stringstream stream;
+			stream.str(std::move(fileContent));
+
 			//todo delete materials or make sure you can't load over things
 			LoadedMeshes.clear();
 
@@ -32905,7 +33011,7 @@ namespace objl
 		#endif
 
 			std::string curline;
-			while (std::getline(file, curline))
+			while (std::getline(stream, curline))
 			{
 			#ifdef OBJL_CONSOLE_OUTPUT
 				if ((outputIndicator = ((outputIndicator + 1) % outputEveryNth)) == 1)
@@ -33104,7 +33210,7 @@ namespace objl
 				#endif
 
 					// Load Materials
-					LoadMaterials(pathtomat, repoter);
+					LoadMaterials(pathtomat, repoter, fileOpener);
 				}
 			}
 
@@ -33124,7 +33230,7 @@ namespace objl
 				LoadedMeshes.push_back(tempMesh);
 			}
 
-			file.close();
+			stream.clear();
 
 			// Set Materials for each Mesh
 			for (int i = 0; i < MeshMatNames.size(); i++)
@@ -33165,20 +33271,21 @@ namespace objl
 		std::vector<Material> LoadedMaterials;
 
 		// Load Materials from .mtl file
-		bool LoadMaterials(std::string path, gl3d::ErrorReporter &errorReporter)
+		bool LoadMaterials(std::string path, gl3d::ErrorReporter &errorReporter, gl3d::FileOpener &fileOpener)
 		{
 			// If the file is not a material file return false
 			if (path.substr(path.size() - 4, path.size()) != ".mtl")
 				return false;
 
-			std::ifstream file(path);
-
-			// If the file is not found return false
-			if (!file.is_open())
+			bool couldNotOpen = 0;
+			auto fileContent = fileOpener(path.c_str(), couldNotOpen);
+			if (couldNotOpen)
 			{
 				errorReporter.callErrorCallback("error loading mtl file: " + path);
 				return false;
 			}
+			std::stringstream stream;
+			stream.str(std::move(fileContent));
 
 			Material tempMaterial;
 
@@ -33186,7 +33293,7 @@ namespace objl
 
 			// Go through each line looking for material variables
 			std::string curline;
-			while (std::getline(file, curline))
+			while (std::getline(stream, curline))
 			{
 				auto firstToken = algorithm::firstToken(curline);
 
@@ -33704,6 +33811,7 @@ namespace objl
 #pragma once
 #include <glm/vec2.hpp>
 
+
 #include <string>
 
 namespace gl3d
@@ -33726,7 +33834,7 @@ namespace gl3d
 		//GpuTexture(const char *file) { loadTextureFromFile(file); };
 
 		//returns error
-		std::string loadTextureFromFile(const char *file, int quality = maxQuality, int channels = 4);
+		std::string loadTextureFromFile(const char *file, FileOpener &fileOpener, int quality = maxQuality, int channels = 4);
 		void loadTextureFromMemory(void* data, int w, int h, int chanels = 4, int quality = maxQuality);
 		void loadTextureFromMemoryAndCheckAlpha
 			(void *data, int w, int h, int &alpha, int &alphaWithData, int chanels = 4, int quality = maxQuality);
@@ -33803,9 +33911,9 @@ namespace gl3d
 	{
 		GLuint id = 0;
 
-		bool loadShaderProgramFromFile(const char *vertexShader, const char *fragmentShader, ErrorReporter &errorReporter);
+		bool loadShaderProgramFromFile(const char *vertexShader, const char *fragmentShader, ErrorReporter &errorReporter, FileOpener &fileOpener);
 		bool loadShaderProgramFromFile(const char *vertexShader, 
-			const char *geometryShader, const char *fragmentShader, ErrorReporter &errorReporter);
+			const char *geometryShader, const char *fragmentShader, ErrorReporter &errorReporter, FileOpener &fileOpener);
 
 		void bind();
 
@@ -33817,7 +33925,7 @@ namespace gl3d
 	//todo this will probably dissapear
 	struct LightShader
 	{
-		std::string create(ErrorReporter &errorReporter);
+		std::string create(ErrorReporter &errorReporter, FileOpener &fileOpener);
 
 		void getSubroutines(ErrorReporter &errorReporter);
 
@@ -34091,9 +34199,10 @@ namespace gl3d
 	struct LoadedModelData
 	{
 		LoadedModelData() = default;
-		LoadedModelData(const char *file, ErrorReporter &errorReporter ,float scale = 1.f) { load(file, errorReporter, scale); }
+		LoadedModelData(const char *file, ErrorReporter &errorReporter, 
+			FileOpener &fileOpener, float scale = 1.f) { load(file, errorReporter, fileOpener, scale); }
 
-		void load(const char *file, ErrorReporter &errorReporter, float scale = 1.f);
+		void load(const char *file, ErrorReporter &errorReporter, FileOpener &fileOpener, float scale = 1.f);
 
 		objl::Loader loader;
 		std::string path;
@@ -34245,7 +34354,7 @@ namespace gl3d
 		GLuint vertexBuffer = 0;
 		GLuint captureFBO;
 
-		void createGpuData(ErrorReporter &errorReporter, GLuint frameBuffer);
+		void createGpuData(ErrorReporter &errorReporter, FileOpener &fileOpener,  GLuint frameBuffer);
 
 		struct
 		{
@@ -34302,9 +34411,9 @@ namespace gl3d
 			BottomOfTheCrossLeft,
 		};
 
-		void loadTexture(const char *names[6], SkyBox &skyBox, ErrorReporter &errorReporter, GLuint frameBuffer);
-		void loadTexture(const char *name, SkyBox &skyBox, ErrorReporter &errorReporter, GLuint frameBuffer, int format = 0);
-		void loadHDRtexture(const char *name, ErrorReporter &errorReporter, SkyBox &skyBox, GLuint frameBuffer);
+		void loadTexture(const char *names[6], SkyBox &skyBox, ErrorReporter &errorReporter, FileOpener &fileOpener, GLuint frameBuffer);
+		void loadTexture(const char *name, SkyBox &skyBox, ErrorReporter &errorReporter, FileOpener &fileOpener, GLuint frameBuffer, int format = 0);
+		void loadHDRtexture(const char *name, ErrorReporter &errorReporter, FileOpener &fileOpener, SkyBox &skyBox, GLuint frameBuffer);
 		void atmosphericScattering(glm::vec3 sun, glm::vec3 color1, glm::vec3 color2, float g, SkyBox& skyBox,
 			GLuint frameBuffer);
 
@@ -34404,6 +34513,7 @@ namespace gl3d
 		void init(int x, int y, GLuint frameBuffer);
 		
 		ErrorReporter errorReporter;
+		FileOpener fileOpener;
 
 		ErrorCallback_t *setErrorCallback(ErrorCallback_t *errorCallback, void *userData);
 		ErrorCallback_t *getErrorCallback();
@@ -34417,7 +34527,7 @@ namespace gl3d
 
 		Material createMaterial(Material m, GLuint frameBuffer);
 
-		std::vector<Material> loadMaterial(std::string file, GLuint frameBuffer);
+		std::vector<Material> loadMaterial(std::string file,  GLuint frameBuffer);
 
 		bool deleteMaterial(Material m);  
 		bool copyMaterialData(Material dest, Material source);
@@ -34734,7 +34844,7 @@ namespace gl3d
 				Shader shader;
 				GLuint fbo;
 
-				void init(ErrorReporter &errorReporter);
+				void init(ErrorReporter &errorReporter, FileOpener &fileOpener);
 
 				GLuint createRMAtexture(
 					GpuTexture roughness, GpuTexture metallic, GpuTexture ambientOcclusion, 
@@ -34818,7 +34928,7 @@ namespace gl3d
 				{
 					//https://learnopengl.com/Advanced-Lighting/SSAO
 
-					void create(int w, int h, ErrorReporter &errorReporter, GLuint frameBuffer);
+					void create(int w, int h, ErrorReporter &errorReporter, FileOpener &fileOpener, GLuint frameBuffer);
 					void resize(int w, int h);
 
 					glm::ivec2 currentDimensions = {};
@@ -34959,7 +35069,7 @@ namespace gl3d
 
 			GLuint colorBuffers[2]; // 0 for color, 1 for bloom
 			GLuint bluredColorBuffer[2];
-			void create(int w, int h, ErrorReporter &errorReporter, GLuint frameBuffer);
+			void create(int w, int h, ErrorReporter &errorReporter, FileOpener &fileOpener, GLuint frameBuffer);
 			void resize(int w, int h);
 			glm::ivec2 currentDimensions = {};
 			int currentMips = 1;
@@ -35007,7 +35117,7 @@ namespace gl3d
 		{
 			Shader shader;
 			Shader noAAshader;
-			void create(int w, int h, ErrorReporter &errorReporter);
+			void create(int w, int h, ErrorReporter &errorReporter, FileOpener &fileOpener);
 
 			GLuint u_texture;
 			GLuint noAAu_texture;
@@ -35076,7 +35186,7 @@ namespace gl3d
 		//todo remove or implement properly
 		struct RenderDepthMap
 		{
-			void create(ErrorReporter &errorReporter, GLuint frameBuffer);
+			void create(ErrorReporter &errorReporter, FileOpener &fileOpener, GLuint frameBuffer);
 
 			Shader shader;
 			GLint u_depth = -1;