src/CGL430Material.cpp

	#include "CGL430Material.h"
	#include "CWindowManager.h"
	#include "COpenGL430Renderer.h"
	#include "CEngine.h"
	#include "CScopeExit.h"
	#include "CImage.h"
	#include "CResourcesManager.h"

	#include "U_String.h"
	#include "U_Files.h"

	#include <fstream>

	namespace //local space (scope)
	{
	COpenGL430Renderer* GetRenderer()
	{
	if(CEngine::GetInstance()->GetStopFlag()) { return nullptr; }

	CWindowManager* winman = CEngine::GetInstance()->Components.GetComponentTyped<CWindowManager>();
	if(!winman) { return nullptr; }

	return dynamic_cast<COpenGL430Renderer*>(winman->Renderer.get());
	}
	}

	CGL430Material::CGL430Material()
	{
	auto renderer = GetRenderer();
	if(renderer) { renderer->RegisterMaterial(this); }
	}

	CGL430Material::~CGL430Material()
	{
	auto renderer = GetRenderer();
	if(renderer)
	{
	renderer->UnregisterMaterial(this);

	glMakeTextureHandleNonResidentARB(DiffuseTextureHandle);
	glDeleteTextures(1, &DiffuseTextureNativeHandle);
	}
	}

	bool CGL430Material::V_Load(const std::filesystem::path& path)
	{
	std::shared_ptr<CImage> diffuseTexture;

	auto resman = CEngine::GetInstance()->Components.GetComponentTyped<CResourcesManager>();
	auto& time = CEngine::GetInstance()->Time;

	auto found_path = FileUtils::find_first_by_name(FileUtils::get_executable_path() / "resources" / "materials", path.string());
	if(!found_path.has_value()) { return false; }

	std::ifstream objfile(found_path.value());
	if (!objfile.is_open()) { return false; }

	CScopeExit streamExiter([&objfile]() { objfile.close(); });

	std::string ReadLine;
	while (!objfile.eof())
	{
	std::getline(objfile, ReadLine, '\n');

	std::vector<std::string> splitted;
	StringUtils::split_str(ReadLine, ' ', splitted);

	std::string cmd = splitted[0];
	std::string param = StringUtils::merge_arg(splitted, 1, splitted.size() - 1);

	//Log::Instance() << "Parsed material property \"" << cmd << "\": \"" << param << "\"\n"; LOGLOG

	if(cmd == "texture")
	{
	//Log::Instance() << "Loading texture " << param << Log::Endl; LOGLOG

	auto res = resman->LoadResource("image", param);
	diffuseTexture = std::dynamic_pointer_cast<CImage>(res);

	CTimePoint now = CEngine::GetInstance()->Time.GetCurrent();
	CTimePoint expires = TIME_EXPR(now + std::chrono::seconds(5));

	resman->Cache.Add(res, expires);

	glGenTextures(1, &DiffuseTextureNativeHandle);
	glBindTexture(GL_TEXTURE_2D, DiffuseTextureNativeHandle);

	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, diffuseTexture->GetSize().x, diffuseTexture->GetSize().y, 0, GL_RGBA, GL_UNSIGNED_BYTE, diffuseTexture->GetRawData());

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

	glGenerateMipmap(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, 0);

	DiffuseTextureHandle = glGetTextureHandleARB(DiffuseTextureNativeHandle);
	glMakeTextureHandleResidentARB(DiffuseTextureHandle);
	}
	else if(cmd == "diffuse")
	{
	DiffuseColor = StringUtils::FromStr<CColor>(param);
	}
	else if(cmd == "shininess")
	{
	Shininess = StringUtils::FromStr<float>(param);
	}
	}
	Log::Instance() << "Material done loading with handles " << DiffuseTextureHandle << " and " << DiffuseTextureNativeHandle << "\n";
	return true;
	}

	std::shared_ptr<CLoadingContext> CGL430Material::CreatePipelineContext(const std::filesystem::path& path)
	{
	return std::make_shared<CGL430MaterialLoadingContext>(this, path);
	}

	void CGL430Material::V_SetupLoadPipeline(CLoadPipeline& pipeline)
	{
	pipeline.push_back //load material data (async)
	(
	{
	[](std::shared_ptr<CLoadingContext> context) -> bool
	{
	auto resman = CEngine::GetInstance()->Components.GetComponentTyped<CResourcesManager>();
	auto& time = CEngine::GetInstance()->Time;

	auto matContext = std::dynamic_pointer_cast<CGL430MaterialLoadingContext>(context);
	auto thisMaterial = dynamic_cast<CGL430Material*>(context->CurrentResource);

	auto& path = context->LoadPath;

	auto found_path = FileUtils::find_first_by_name(FileUtils::get_executable_path() / "resources" / "materials", path.string());
	if(!found_path.has_value()) { return false; }

	std::ifstream objfile(found_path.value());
	if (!objfile.is_open()) { return false; }

	CScopeExit streamExiter([&objfile]() { objfile.close(); });

	std::string ReadLine;
	while (!objfile.eof())
	{
	std::getline(objfile, ReadLine, '\n');

	std::vector<std::string> splitted;
	StringUtils::split_str(ReadLine, ' ', splitted);

	std::string cmd = splitted[0];
	std::string param = StringUtils::merge_arg(splitted, 1, splitted.size() - 1);

	//Log::Instance() << "Parsed material property \"" << cmd << "\": \"" << param << "\"\n"; //LOGLOG

	if(cmd == "texture")
	{
	matContext->DiffusePath = param;
	//Log::Instance() << "Loading texture " << param << Log::Endl; //LOGLOG

	auto img = resman->GetOrCreate("image", param);
	context->RequiredResources.push_back(img);

	//img->Wait(); NO WAITING IN ASYNC THREAD
	}
	else if(cmd == "diffuse")
	{
	thisMaterial->DiffuseColor = StringUtils::FromStr<CColor>(param);
	}
	else if(cmd == "shininess")
	{
	thisMaterial->Shininess = StringUtils::FromStr<float>(param);
	}
	}
	return true;
	},
	true //async (is_async)
	}
	);

	pipeline.push_back //upload image to gpu (sync)
	(
	{
	[](std::shared_ptr<CLoadingContext> context) -> bool
	{
	auto resman = CEngine::GetInstance()->Components.GetComponentTyped<CResourcesManager>();
	auto matContext = std::dynamic_pointer_cast<CGL430MaterialLoadingContext>(context);
	auto thisMaterial = dynamic_cast<CGL430Material*>(context->CurrentResource);

	std::shared_ptr<CResource> _res = nullptr;
	for(auto res : context->RequiredResources)
	{
	//Log::Instance() << "Required res " << res->Name << " with status of " << (int)res->LoadingStatus << Log::Endl;
	if(res->Name == matContext->DiffusePath.stem().string() && res->LoadingStatus == CResource::CLoadingStatus::Done)
	{
	_res = res;
	break;
	}
	}

	if(!_res)
	{
	//Log::ErrInstance() << "NO RES FOR UPLOAD " << matContext->DiffusePath.stem().string() << Log::Endl;
	return false;
	}
	auto diffuseTexture = std::dynamic_pointer_cast<CImage>(_res);

	//&thisMaterial->DiffuseTextureNativeHandle

	glGenTextures(1, &thisMaterial->DiffuseTextureNativeHandle);

	glBindTexture(GL_TEXTURE_2D, thisMaterial->DiffuseTextureNativeHandle);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, diffuseTexture->GetSize().x, diffuseTexture->GetSize().y, 0, GL_RGBA, GL_UNSIGNED_BYTE, diffuseTexture->GetRawData());

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

	glGenerateMipmap(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, 0);

	thisMaterial->DiffuseTextureHandle = glGetTextureHandleARB(thisMaterial->DiffuseTextureNativeHandle);
	glMakeTextureHandleResidentARB(thisMaterial->DiffuseTextureHandle);

	//Log::Instance() << "Uploaded image to gpu\n"; //LOGLOG
	return true;
	},
	false //sync (is_async)
	}
	);
	}

	LINK_RESOURCE_TO_CLASS(CGL430Material, gl430material)