feat: use paths and string keys in texture library

The texture library needs string keys to identify "shaders", they remain
narrow UTF-8 as all image paths in use are ASCII and while there's now
proper path use for texture loading it doesn't need to permeate quite
that far into that kind of performance-sensitive place.

Author: zao

engine/render.h

@@ -77,7 +77,7 @@ class r_IRenderer {
 	virtual void	BeginFrame() = 0;
 	virtual void	EndFrame() = 0;
 
-	virtual r_shaderHnd_c* RegisterShader(const char* name, int flags) = 0;
+	virtual r_shaderHnd_c* RegisterShader(std::string_view name, int flags) = 0;
 	virtual r_shaderHnd_c* RegisterShaderFromImage(std::unique_ptr<image_c> img, int flags) = 0;
 	virtual void	GetShaderImageSize(r_shaderHnd_c* hnd, int &width, int &height) = 0;
 	virtual void	SetShaderLoadingPriority(r_shaderHnd_c* hnd, int pri) = 0;

engine/render/r_main.cpp

@@ -45,40 +45,39 @@ enum r_takeScreenshot_e {
 class r_shader_c {
 public:
 	r_renderer_c* renderer;
-	char* name;
+	std::string name;
 	dword		nameHash;
 	int			refCount;
 	r_tex_c* tex;
 
-	r_shader_c(r_renderer_c* renderer, const char* shname, int flags);
-	r_shader_c(r_renderer_c* renderer, const char* shname, int flags, std::unique_ptr<image_c> img);
+	r_shader_c(r_renderer_c* renderer, std::string_view shname, int flags);
+	r_shader_c(r_renderer_c* renderer, std::string_view shname, int flags, std::unique_ptr<image_c> img);
 	~r_shader_c();
 };
 
-r_shader_c::r_shader_c(r_renderer_c* renderer, const char* shname, int flags)
+r_shader_c::r_shader_c(r_renderer_c* renderer, std::string_view shname, int flags)
 	: renderer(renderer)
 {
-	name = AllocString(shname);
-	nameHash = StringHash(shname, 0xFFFF);
+	name = shname;
+	nameHash = StringHash(name.c_str(), 0xFFFF);
 	refCount = 0;
 	tex = new r_tex_c(renderer->texMan, name, flags);
 	if (tex->error) {
-		renderer->sys->con->Warning("couldn't load texture '%s'", name);
+		renderer->sys->con->Warning("couldn't load texture '%s'", name.c_str());
 	}
 }
 
-r_shader_c::r_shader_c(r_renderer_c* renderer, const char* shname, int flags, std::unique_ptr<image_c> img)
+r_shader_c::r_shader_c(r_renderer_c* renderer, std::string_view shname, int flags, std::unique_ptr<image_c> img)
 	: renderer(renderer)
 {
-	name = AllocString(shname);
-	nameHash = StringHash(shname, 0xFFFF);
+	name = shname;
+	nameHash = StringHash(name.c_str(), 0xFFFF);
 	refCount = 0;
 	tex = new r_tex_c(renderer->texMan, std::move(img), flags);
 }
 
 r_shader_c::~r_shader_c()
 {
-	FreeString(name);
 	delete tex;
 }
 
@@ -1570,19 +1569,20 @@ void r_renderer_c::PurgeShaders()
 	}
 }
 
-r_shaderHnd_c* r_renderer_c::RegisterShader(const char* shname, int flags)
+r_shaderHnd_c* r_renderer_c::RegisterShader(std::string_view shname, int flags)
 {
-	if (*shname == 0) {
+	if (shname.empty()) {
 		return NULL;
 	}
 
-	dword nameHash = StringHash(shname, 0xFFFF);
+	std::string name(shname);
+	dword nameHash = StringHash(name, 0xFFFF);
 	int newId = -1;
 	for (int s = 0; s < numShader; s++) {
 		if (!shaderList[s]) {
 			newId = s;
 		}
-		else if (shaderList[s]->nameHash == nameHash && _stricmp(shname, shaderList[s]->name) == 0 && shaderList[s]->tex->flags == flags) {
+		else if (shaderList[s]->nameHash == nameHash && _stricmp(name.c_str(), shaderList[s]->name.c_str()) == 0 && shaderList[s]->tex->flags == flags) {
 			// Shader already exists, return a new handle for it
 			// Ensure texture is loaded as soon as possible
 			shaderList[s]->tex->ForceLoad();
@@ -1930,7 +1930,7 @@ void r_renderer_c::DoScreenshot(image_c* i, int type, const char* ext)
 	// Flip and convert the image to RGB
 	int const readSpan = xs * 4;
 	int	const writeSpan = xs * 3;
-	std::vector<byte> ss(writeSize); // This is a raw pointer as ownership is taken by the image object.
+	std::vector<byte> ss(writeSize);
 	byte* p1 = sbuf.data();
 	byte* p2 = ss.data() + writeSize - writeSpan;
 	for (int y = 0; y < ys; ++y, p2 -= writeSpan * 2) {
@@ -1949,26 +1949,23 @@ void r_renderer_c::DoScreenshot(image_c* i, int type, const char* ext)
 
 	time_t curTime;
 	time(&curTime);
-	std::string ssname = fmt::format(CFG_DATAPATH "Screenshots/{:%m%d%y_%H%M%S}.{}",
-		fmt::localtime(curTime), ext);
-	// curTimeSt.tm_mon+1, curTimeSt.tm_mday, curTimeSt.tm_year%100,
-	// curTimeSt.tm_hour, curTimeSt.tm_min, curTimeSt.tm_sec, ext);
+	auto ssPath = std::filesystem::u8path(fmt::format(CFG_DATAPATH "Screenshots/{:%m%d%y_%H%M%S}.{}",
+		fmt::localtime(curTime), ext));
 
 
 	// Make folder if it doesn't exist
 	std::error_code ec;
-	std::filesystem::create_directory(CFG_DATAPATH "Screenshots", ec);
+	std::filesystem::create_directories(ssPath.parent_path(), ec);
 	if (ec) {
 		sys->con->Print("Couldn't create screenshot folder!\n");
 		return;
 	}
 
-	if (i->Save(ssname.c_str())) {
+	if (i->Save(ssPath)) {
 		sys->con->Print("Couldn't write screenshot!\n");
 		return;
 	}
-
-	sys->con->Print(fmt::format("Wrote screenshot to {}\n", ssname).c_str());
+	sys->con->Print(fmt::format("Wrote screenshot to {}\n", ssPath.u8string()).c_str());
 }
 
 r_renderer_c::RenderTarget& r_renderer_c::GetDrawRenderTarget()

engine/render/r_main.h

@@ -73,7 +73,7 @@ class r_renderer_c: public r_IRenderer, public conCmdHandler_c {
 	void	BeginFrame();
 	void	EndFrame();
 
-	r_shaderHnd_c* RegisterShader(const char* shname, int flags);
+	r_shaderHnd_c* RegisterShader(std::string_view shname, int flags);
 	r_shaderHnd_c* RegisterShaderFromImage(std::unique_ptr<image_c> img, int flags);
 	void	GetShaderImageSize(r_shaderHnd_c* hnd, int &width, int &height);
 	void	SetShaderLoadingPriority(r_shaderHnd_c* hnd, int pri);

engine/render/r_texture.cpp

@@ -294,7 +294,7 @@ static void T_ResampleImage(byte* in, dword in_w, dword in_h, int in_comp, byte*
 // OpenGL Texture Class
 // ====================
 
-r_tex_c::r_tex_c(r_ITexManager* manager, const char* fileName, int flags)
+r_tex_c::r_tex_c(r_ITexManager* manager, std::string_view fileName, int flags)
 {
 	Init(manager, fileName, flags);
 
@@ -307,7 +307,7 @@ r_tex_c::r_tex_c(r_ITexManager* manager, const char* fileName, int flags)
 
 r_tex_c::r_tex_c(r_ITexManager* manager, std::unique_ptr<image_c> img, int flags)
 {
-	Init(manager, NULL, flags);
+	Init(manager, {}, flags);
 
 	// Direct upload
 	img = BuildMipSet(std::move(img));
@@ -322,7 +322,7 @@ r_tex_c::~r_tex_c()
 	glDeleteTextures(1, &texId);
 }
 
-void r_tex_c::Init(r_ITexManager* i_manager, const char* i_fileName, int i_flags)
+void r_tex_c::Init(r_ITexManager* i_manager, std::string_view i_fileName, int i_flags)
 {
 	manager = (t_manager_c*)i_manager;
 	renderer = manager->renderer;
@@ -331,7 +331,7 @@ void r_tex_c::Init(r_ITexManager* i_manager, const char* i_fileName, int i_flags
 	loadPri = 0;
 	texId = 0;
 	flags = i_flags;
-	fileName = i_fileName ? i_fileName : "";
+	fileName = i_fileName;
 	fileWidth = 0;
 	fileHeight = 0;
 }
@@ -482,15 +482,15 @@ void r_tex_c::LoadFile()
 	}
 
 	// Try to load image file using appropriate loader
-	std::string loadPath = fileName;
-	img = std::unique_ptr<image_c>(image_c::LoaderForFile(renderer->sys->con, loadPath.c_str()));
+	auto path = std::filesystem::u8path(fileName);
+	img = std::unique_ptr<image_c>(image_c::LoaderForFile(renderer->sys->con, path));
 	if (img) {
 		auto sizeCallback = [this](int width, int height) {
 			this->fileWidth = width;
 			this->fileHeight = height;
 			this->status = SIZE_KNOWN;
 		};
-		error = img->Load(loadPath.c_str(), sizeCallback);
+		error = img->Load(path, sizeCallback);
 		if ( !error ) {
 			stackLayers = img->tex.layers();
 			const bool is_async = !!(flags & TF_ASYNC);

engine/render/r_texture.h

@@ -39,7 +39,7 @@ class r_tex_c {
 	GLenum target{};
 	size_t stackLayers = 1;
 
-	r_tex_c(class r_ITexManager* manager, const char* fileName, int flags);
+	r_tex_c(class r_ITexManager* manager, std::string_view fileName, int flags);
 	r_tex_c(class r_ITexManager* manager, std::unique_ptr<image_c> img, int flags);
 	~r_tex_c();
 
@@ -57,7 +57,7 @@ class r_tex_c {
 private:
 	class t_manager_c* manager;
 	class r_renderer_c* renderer;
-	void	Init(class r_ITexManager* manager, const char* fileName, int flags);
+	void	Init(class r_ITexManager* manager, std::string_view fileName, int flags);
 	void	Upload(image_c& img, int flags);
 	std::unique_ptr<image_c> BuildMipSet(std::unique_ptr<image_c> img);
 };

ui_api.cpp

@@ -299,15 +299,14 @@ SG_LUA_CPP_FUN_BEGIN(NewArtHandle)
 
 	int n = lua_gettop(L);
 	ui->LExpect(L, n >= 1, "Usage: NewArtHandle(fileName)");
-	std::filesystem::path filePath = reader.ArgToString(1);
+	std::filesystem::path filePath = std::filesystem::u8path(reader.ArgToString(1));
 	if (filePath.is_relative())
 		filePath = ui->scriptWorkDir / filePath;
-	std::string fileName = filePath.generic_string();
-	std::unique_ptr<image_c> img(image_c::LoaderForFile(ui->sys->con, fileName.c_str()));
+	std::unique_ptr<image_c> img(image_c::LoaderForFile(ui->sys->con, filePath));
 	if (!img)
 		return 0;
 
-	if (img->Load(fileName.c_str()))
+	if (img->Load(filePath))
 		return 0;
 
 	const auto format = img->tex.format();
@@ -398,38 +397,35 @@ SG_LUA_CPP_FUN_BEGIN(imgHandleLoad)
 	int n = lua_gettop(L);
 	ui->LExpect(L, n >= 1, "Usage: imgHandle:Load(fileName[, flag1[, flag2...]])");
 	ui->LExpect(L, lua_isstring(L, 1), "imgHandle:Load() argument 1: expected string, got %s", luaL_typename(L, 1));
-	const char* fileName = lua_tostring(L, 1);
-	char fullFileName[512];
-	if (strchr(fileName, ':') || !ui->scriptWorkDir) {
-		strcpy(fullFileName, fileName);
-	}
-	else {
-		sprintf(fullFileName, "%s/%s", ui->scriptWorkDir, fileName);
+	auto fileName = std::filesystem::u8path(lua_tostring(L, 1));
+	if (!fileName.is_absolute() && !ui->scriptWorkDir.empty()) {
+		fileName = ui->scriptWorkDir / fileName;
 	}
 	delete imgHandle->hnd;
 	int flags = TF_NOMIPMAP;
 	for (int f = 2; f <= n; f++) {
 		if (!lua_isstring(L, f)) {
 			continue;
 		}
-		const char* flag = lua_tostring(L, f);
-		if (!strcmp(flag, "ASYNC")) {
+		std::string flag = lua_tostring(L, f);
+		if (flag == "ASYNC") {
 			flags |= TF_ASYNC;
 		}
-		else if (!strcmp(flag, "CLAMP")) {
+		else if (flag == "CLAMP") {
 			flags |= TF_CLAMP;
 		}
-		else if (!strcmp(flag, "MIPMAP")) {
+		else if (flag == "MIPMAP") {
 			flags &= ~TF_NOMIPMAP;
 		}
-		else if (!strcmp(flag, "NEAREST")) {
+		else if (flag == "NEAREST") {
 			flags |= TF_NEAREST;
 		}
 		else {
-			ui->LExpect(L, 0, "imgHandle:Load(): unrecognised flag '%s'", flag);
+			ui->LExpect(L, 0, "imgHandle:Load(): unrecognised flag '%s'", flag.c_str());
 		}
 	}
-	imgHandle->hnd = ui->renderer->RegisterShader(fullFileName, flags);
+	// TODO(LV): should we use u8path throughout here, to support any callers that use paths outside of working directory?
+	imgHandle->hnd = ui->renderer->RegisterShader(fileName.u8string(), flags);
 	return 0;
 }
 SG_LUA_CPP_FUN_END()