feat: drop dat storage of images for gli texture2d

If we want to load and carry around image swith mipmaps and array layers
from disk we need a more flexible data format than a single byte array.

As GLI is a suitable library for loading assets from DDS in the first
place we might as well make gli::texture2d our internal carrier format
for image internals and properties.

This commit removes the previous `dat` member of `image_c`, superseding
it with a GLI texture2d member.

We also take the opportunity to do some drive-by cleanup and fixing
non-virtual dynamic destruction of image_c objects.

Author: zao

CMakeLists.txt

@@ -107,10 +107,12 @@ find_package(unofficial-angle CONFIG REQUIRED)
 find_package(CURL CONFIG REQUIRED)
 find_package(fmt CONFIG REQUIRED)
 find_package(glfw3 CONFIG REQUIRED)
+find_package(gli CONFIG REQUIRED)
 find_package(LuaJIT REQUIRED)
 find_package(PkgConfig REQUIRED)
 find_package(re2 CONFIG REQUIRED)
 find_package(Threads REQUIRED)
+find_package(zstd REQUIRED)
 find_package(ZLIB REQUIRED)
 
 pkg_check_modules(libjxl REQUIRED IMPORTED_TARGET libjxl)
@@ -199,6 +201,7 @@ target_link_libraries(SimpleGraphic
     unofficial::angle::libGLESv2
     fmt::fmt
     glfw
+    gli
     glm::glm
     imgui
     LuaJIT::LuaJIT

engine/core/core_image.cpp

@@ -25,48 +25,79 @@
 #include <jxl/decode_cxx.h>
 #include <jxl/resizable_parallel_runner_cxx.h>
 
-// =======
-// Classes
-// =======
-
-// Generic client data structure, used by JPEG and PNG
-struct clientData_s {
-	IConsole* con;
-	const char* fileName;
-	ioStream_c* io;
-};
+#include <gli/gli.hpp>
 
 // =========
 // Raw Image
 // =========
 
 image_c::image_c(IConsole* conHnd)
 	: con(conHnd)
-{
-	dat = NULL;
-}
-
-image_c::~image_c()
-{
-	Free();
-}
+{}
 
 void image_c::CopyRaw(int inType, dword inWidth, dword inHeight, const byte* inDat)
 {
-	if (dat) delete[] dat;
-	dat = nullptr;
+	// Populate legacy fields
 	comp = inType & 0xF;
 	type = inType;
 	width = inWidth;
 	height = inHeight;
-	dat = new byte[width * height * comp];
-	memcpy(dat, inDat, width * height * comp);
+
+	// Populate gli texture
+	PopulateTex(inDat);
 }
 
 void image_c::Free()
 {
-	delete[] dat;
-	dat = NULL;
+	tex = {};
+}
+
+//TODO(zao): Make this function only care about unpacked source data.
+void image_c::PopulateTex(const byte* dat)
+{
+	gli::format format = gli::format::FORMAT_UNDEFINED;
+	const glm::ivec2 extent{ width, height };
+	size_t dataSize = width * height * comp; // Common default for regular formats.
+
+	const auto PhysicalSize = [](dword width, dword height, dword blockSize, dword side = 4) -> dword {
+		dword numBlocks = ((width + side - 1) / side) * ((height + side - 1) / side);
+		return numBlocks * blockSize;
+		};
+	switch ((imageType_s)type) {
+	case imageType_s::IMGTYPE_NONE:
+		tex = {};
+		return;
+	case imageType_s::IMGTYPE_GRAY:
+		format = gli::format::FORMAT_R8_SRGB_PACK8;
+		break;
+	case imageType_s::IMGTYPE_RGB:
+		format = gli::format::FORMAT_RGB8_SRGB_PACK8;
+		break;
+	case imageType_s::IMGTYPE_RGBA:
+		format = gli::format::FORMAT_RGBA8_SNORM_PACK8;
+		break;
+	case imageType_s::IMGTYPE_RGBA_BC1:
+		format = gli::format::FORMAT_RGBA_DXT1_SRGB_BLOCK8;
+		dataSize = PhysicalSize(width, height, 8);
+		break;
+	case imageType_s::IMGTYPE_RGBA_BC2:
+		format = gli::format::FORMAT_RGBA_DXT3_SRGB_BLOCK16;
+		dataSize = PhysicalSize(width, height, 16);
+		break;
+	case imageType_s::IMGTYPE_RGBA_BC3:
+		format = gli::format::FORMAT_RGBA_DXT5_SRGB_BLOCK16;
+		dataSize = PhysicalSize(width, height, 16);
+		break;
+	case imageType_s::IMGTYPE_RGBA_BC7:
+		format = gli::format::FORMAT_RGBA_BP_SRGB_BLOCK16;
+		dataSize = PhysicalSize(width, height, 16);
+	}
+
+	tex = gli::texture2d(format, extent, 1);
+	if (tex.size(0) == dataSize)
+		memcpy(tex.data(0, 0, 0), dat, dataSize);
+	else
+		assert(tex.size(0) == dataSize);
 }
 
 bool image_c::Load(const char* fileName, std::optional<size_callback_t> sizeCallback)
@@ -176,7 +207,8 @@ bool targa_c::Load(const char* fileName, std::optional<size_callback_t> sizeCall
 	comp = hdr.depth >> 3;
 	type = ittable[it_m][2];
 	int rowSize = width * comp;
-	dat = new byte[height * rowSize];
+	std::vector<byte> datBuf(height * rowSize);
+	byte* dat = datBuf.data();
 	bool flipV = !(hdr.descriptor & 0x20);
 	if (hdr.imgType & 8) {
 		// Decode RLE image
@@ -221,6 +253,8 @@ bool targa_c::Load(const char* fileName, std::optional<size_callback_t> sizeCall
 		}
 	}
 
+	PopulateTex(dat);
+
 	return false;
 }
 
@@ -236,10 +270,13 @@ bool targa_c::Save(const char* fileName)
 		return true;
 	}
 
+	if (is_compressed(tex.format()))
+		return true;
+
 	auto rc = stbi_write_tga_to_func([](void* ctx, void* data, int size) {
 		auto out = (fileOutputStream_c*)ctx;
 		out->Write(data, size);
-		}, &out, width, height, comp, dat);
+		}, &out, width, height, comp, tex.data(0, 0, 0));
 
 	return !rc;
 }
@@ -282,10 +319,10 @@ bool jpeg_c::Load(const char* fileName, std::optional<size_callback_t> sizeCallb
 	height = y;
 	comp = in_comp;
 	type = in_comp == 1 ? IMGTYPE_GRAY : IMGTYPE_RGB;
-	const size_t byteSize = width * height * comp;
-	dat = new byte[byteSize];
-	std::copy_n(data, byteSize, dat);
+
+	PopulateTex(data);
 	stbi_image_free(data);
+
 	return false;
 }
 
@@ -302,10 +339,13 @@ bool jpeg_c::Save(const char* fileName)
 		return true;
 	}
 
+	if (is_compressed(tex.format()))
+		return true;
+
 	int rc = stbi_write_jpg_to_func([](void* ctx, void* data, int size) {
 		auto out = (fileOutputStream_c*)ctx;
 		out->Write(data, size);
-	}, &out, width, height, comp, dat, quality);
+	}, &out, width, height, comp, tex.data(0, 0, 0), quality);
 	return !rc;
 }
 
@@ -344,10 +384,10 @@ bool png_c::Load(const char* fileName, std::optional<size_callback_t> sizeCallba
 		stbi_image_free(data);
 		return true;
 	}
-	const size_t byteSize = width * height * comp;
-	dat = new byte[byteSize];
-	std::copy_n(data, byteSize, dat);
+
+	PopulateTex(data);
 	stbi_image_free(data);
+
 	return false;
 }
 
@@ -366,7 +406,7 @@ bool png_c::Save(const char* fileName)
 	auto rc = stbi_write_png_to_func([](void* ctx, void* data, int size) {
 		auto out = (fileOutputStream_c*)ctx;
 		out->Write(data, size);
-	}, &out, width, height, comp, dat, width * comp);
+	}, &out, width, height, comp, tex.data(0, 0, 0), width * comp);
 
 	return !rc;
 }
@@ -401,10 +441,10 @@ bool gif_c::Load(const char* fileName, std::optional<size_callback_t> sizeCallba
 
 		comp = in_comp;
 		type = IMGTYPE_RGBA;
-		const size_t byteSize = width * height * comp;
-		dat = new byte[byteSize];
-		std::copy_n(data, byteSize, dat);
+
+		PopulateTex(data);
 		stbi_image_free(data);
+
 		return false;
 	}
 }
@@ -449,6 +489,8 @@ bool jpeg_xl_c::Load(const char* fileName, std::optional<size_callback_t> sizeCa
 	JxlDecoderSetInput(dec.get(), fileData.data(), fileData.size());
 	JxlDecoderCloseInput(dec.get());
 
+	std::vector<byte> datBuf;
+
 	while (true) {
 		JxlDecoderStatus status = JxlDecoderProcessInput(dec.get());
 
@@ -484,18 +526,19 @@ bool jpeg_xl_c::Load(const char* fileName, std::optional<size_callback_t> sizeCa
 			size_t bufferSize{};
 			if (JXL_DEC_SUCCESS != JxlDecoderImageOutBufferSize(dec.get(), &format, &bufferSize))
 				return true;
-			dat = new byte[width * height * comp];
-			if (JXL_DEC_SUCCESS != JxlDecoderSetImageOutBuffer(dec.get(), &format, dat, bufferSize))
+			assert(bufferSize == width * height * comp);
+			datBuf.resize(bufferSize);
+			if (JXL_DEC_SUCCESS != JxlDecoderSetImageOutBuffer(dec.get(), &format, datBuf.data(), bufferSize))
 				return true;
 		} break;
 
+		case JXL_DEC_SUCCESS:
 		case JXL_DEC_FULL_IMAGE: {
 			// We don't care about animations, consider loading completed when a full image has obtained.
+			PopulateTex(datBuf.data());
 			return false;
 		} break;
 
-		case JXL_DEC_SUCCESS:
-			return false;
 		default:
 			continue;
 		}

engine/core/core_image.h

@@ -10,29 +10,42 @@
 
 #include <functional>
 #include <optional>
+
+#include <gli/texture2d.hpp>
+
 // Image types
 enum imageType_s {
 	IMGTYPE_NONE = 0x00,
 	IMGTYPE_GRAY = 0x11,
 	IMGTYPE_RGB  = 0x23,
 	IMGTYPE_RGBA = 0x34,
 	IMGTYPE_RGB_DXT1 = 0x63,
-	IMGTYPE_RGBA_DXT1 = 0x74,
-	IMGTYPE_RGBA_DXT3 = 0x84,
-	IMGTYPE_RGBA_DXT5 = 0x94
+	IMGTYPE_RGBA_BC1 = 0x74,
+	IMGTYPE_RGBA_DXT1 = IMGTYPE_RGBA_BC1,
+	IMGTYPE_RGBA_BC2 = 0x84,
+	IMGTYPE_RGBA_DXT3 = IMGTYPE_RGBA_BC2,
+	IMGTYPE_RGBA_BC3 = 0x94,
+	IMGTYPE_RGBA_DXT5 = IMGTYPE_RGBA_BC3,
+	//IMGTYPE_R_BC4 = 0xA4,
+	//IMGTYPE_RG_BC5 = 0xB4,
+	//IMGTYPE_RGBF_BC6H = 0xC4,
+	IMGTYPE_RGBA_BC7 = 0xD4,
 };
 
 // Image
 class image_c {
 public:
-	byte* dat = nullptr;
 	dword width = 0;
 	dword height = 0;
 	int comp = 0;
 	int type = 0;
 
-	image_c(IConsole* conHnd = NULL);
-	~image_c();
+	// This `tex` member supersedes the past raw data and metadata fields in order to hold
+	// both unblocked and blocked texture formats with array layers and mip levels.
+	gli::texture2d tex{};
+
+	explicit image_c(IConsole* conHnd = NULL);
+	virtual ~image_c() = default;
 
 	IConsole* con;
 
@@ -43,6 +56,7 @@ class image_c {
 
 	void CopyRaw(int type, dword width, dword height, const byte* dat);
 	void Free();
+	void PopulateTex(const byte* inDat);
 
 	static image_c* LoaderForFile(IConsole* conHnd, const char* fileName);
 };
@@ -51,7 +65,7 @@ class image_c {
 class targa_c : public image_c {
 public:
 	bool rle;
-	targa_c(IConsole* conHnd): image_c(conHnd) { rle = true; }
+	targa_c(IConsole* conHnd) : image_c(conHnd) { rle = true; }
 	bool Load(const char* fileName, std::optional<size_callback_t> sizeCallback = {}) override;
 	bool Save(const char* fileName) override;
 };
@@ -60,15 +74,15 @@ class targa_c : public image_c {
 class jpeg_c : public image_c {
 public:
 	int quality;
-	jpeg_c(IConsole* conHnd): image_c(conHnd) { quality = 80; }
+	jpeg_c(IConsole* conHnd) : image_c(conHnd) { quality = 80; }
 	bool Load(const char* fileName, std::optional<size_callback_t> sizeCallback = {}) override;
 	bool Save(const char* fileName) override;
 };
 
 // PNG Image
 class png_c : public image_c {
 public:
-	png_c(IConsole* conHnd): image_c(conHnd) { }
+	png_c(IConsole* conHnd) : image_c(conHnd) { }
 	bool Load(const char* fileName, std::optional<size_callback_t> sizeCallback = {}) override;
 	bool Save(const char* fileName) override;
 };
@@ -84,7 +98,7 @@ class jpeg_xl_c : public image_c {
 // GIF Image
 class gif_c : public image_c {
 public:
-	gif_c(IConsole* conHnd): image_c(conHnd) { }
+	gif_c(IConsole* conHnd) : image_c(conHnd) { }
 	bool Load(const char* fileName, std::optional<size_callback_t> sizeCallback = {}) override;
 	bool Save(const char* fileName) override;
 };

engine/render/r_main.cpp

@@ -1880,9 +1880,9 @@ void r_renderer_c::DoScreenshot(image_c* i, const char* ext)
 	// Flip and convert the image to RGB
 	int const readSpan = xs * 4;
 	int	const writeSpan = xs * 3;
-	byte* ss = new byte[writeSize]; // This is a raw pointer as ownership is taken by the image object.
+	std::vector<byte> ss(writeSize); // This is a raw pointer as ownership is taken by the image object.
 	byte* p1 = sbuf.data();
-	byte* p2 = ss + writeSize - writeSpan;
+	byte* p2 = ss.data() + writeSize - writeSpan;
 	for (int y = 0; y < ys; ++y, p2 -= writeSpan * 2) {
 		for (int x = 0; x < xs; ++x) {
 			*p2++ = *p1++; // R
@@ -1894,7 +1894,8 @@ void r_renderer_c::DoScreenshot(image_c* i, const char* ext)
 	sbuf.clear();
 
 	// Set image info
-	i->dat = ss;
+	i->PopulateTex(ss.data());
+	ss.clear();
 	i->width = xs;
 	i->height = ys;
 	i->comp = 3;