KTX1 / ETC2 Compressed textures support (scp-fs2open#7070)

* Initial KTX1/ETC2 support

* Conditional glad include

* remove unused function

* define glenum for non opengl build

* remove unused param

* fix qtbuild

* change ktx format to enum

* use nullptr

* ktx: support the same etc2 formats available in amd compressonator

* add comments and missing include

* correct flag type

* clarify variable name for clang

* cleanup

* update glad loader to GL4.3

Author: Shivansps

code/bmpman/bm_internal.h

@@ -70,7 +70,7 @@ struct bitmap_entry {
 	// Stuff to keep track of usage
 	ubyte preloaded;        //!< If set, then this was loaded from the lst file
 	int   preload_count;    //!< how many times this gets used in game, for unlocking
-	ushort used_flags;       //!< What flags it was accessed thru
+	uint  used_flags;       //!< What flags it was accessed thru
 	int   load_count;
 
 	bitmap bm;              //!< Bitmap info
@@ -93,14 +93,15 @@ struct bitmap_slot {
 };
 
 // image specific lock functions
-void bm_lock_ani( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
-void bm_lock_dds( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
-void bm_lock_png( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
-void bm_lock_apng( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
-void bm_lock_jpg( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
-void bm_lock_pcx( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
-void bm_lock_tga( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags );
-void bm_lock_user( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags, bool convert = true );
+void bm_lock_ani( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
+void bm_lock_dds( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
+void bm_lock_png( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
+void bm_lock_apng( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
+void bm_lock_jpg( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
+void bm_lock_pcx( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
+void bm_lock_tga( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags );
+void bm_lock_user( int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags, bool convert = true );
+void bm_lock_ktx1(int handle, bitmap_slot* bs, bitmap* bmp, int bpp, uint flags);
 
 const size_t BM_BLOCK_SIZE = 4096;
 

code/bmpman/bmpman.cpp

@@ -32,6 +32,7 @@
 #include "tgautils/tgautils.h"
 #include "tracing/Monitor.h"
 #include "tracing/tracing.h"
+#include "ktxutils/ktxutils.h"
 
 #include <cctype>
 #include <climits>
@@ -59,8 +60,8 @@ size_t bm_texture_ram = 0;
 int Bm_paging = 0;
 
 // Extension type lists
-const BM_TYPE bm_type_list[] = { BM_TYPE_DDS, BM_TYPE_TGA, BM_TYPE_PNG, BM_TYPE_JPG, BM_TYPE_PCX };
-const char *bm_ext_list[] = { ".dds", ".tga", ".png", ".jpg", ".pcx" };
+const BM_TYPE bm_type_list[] = { BM_TYPE_DDS, BM_TYPE_TGA, BM_TYPE_PNG, BM_TYPE_JPG, BM_TYPE_PCX, BM_TYPE_KTX };
+const char* bm_ext_list[] = { ".dds", ".tga", ".png", ".jpg", ".pcx", ".ktx" };
 const int BM_NUM_TYPES = sizeof(bm_type_list) / sizeof(bm_type_list[0]);
 
 const BM_TYPE bm_ani_type_list[] = { BM_TYPE_EFF, BM_TYPE_ANI, BM_TYPE_PNG };
@@ -205,7 +206,7 @@ void clear_bm_lookup_cache() {
 /**
  * Converts the bitmap referenced by bmp to the type specified by flags
  */
-static void bm_convert_format(bitmap *bmp, ushort flags);
+static void bm_convert_format(bitmap *bmp, uint flags);
 
 /**
  * Frees a bitmap's data if it can
@@ -639,7 +640,7 @@ int bm_create_3d(int bpp, int w, int h, int d, void* data) {
 	return n;
 }
 
-void bm_convert_format(bitmap *bmp, ushort flags) {
+void bm_convert_format(bitmap *bmp, uint flags) {
 	int idx;
 
 	// no transparency for 24 bpp images
@@ -901,7 +902,7 @@ void bm_get_frame_usage(int *ntotal, int *nnew) {
 #endif
 }
 
-int bm_get_info(int handle, int *w, int * h, ushort* flags, int *nframes, int *fps) {
+int bm_get_info(int handle, int *w, int * h, uint* flags, int *nframes, int *fps) {
 	bitmap * bmp;
 
 	if (!bm_inited) return -1;
@@ -1055,6 +1056,24 @@ int bm_is_compressed(int num) {
 	case BM_TYPE_CUBEMAP_DXT5:
 		return DDS_CUBEMAP_DXT5;
 
+	case BM_TYPE_ETC2_RGB:
+		return KTX_ETC2_RGB;
+
+	case BM_TYPE_ETC2_SRGB:
+		return KTX_ETC2_SRGB;
+
+	case BM_TYPE_ETC2_RGBA_EAC:
+		return KTX_ETC2_RGBA_EAC;
+
+	case BM_TYPE_ETC2_SRGBA_EAC:
+		return KTX_ETC2_SRGBA_EAC;
+
+	case BM_TYPE_ETC2_RGBA1:
+		return KTX_ETC2_RGB_A1;
+
+	case BM_TYPE_ETC2_SRGBA1:
+		return KTX_ETC2_SRGB_A1;
+
 	default:
 		return 0;
 	}
@@ -1148,6 +1167,16 @@ static int bm_load_info(BM_TYPE type, const char *filename, CFILE *img_cfp, int
 			return -1;
 		}
 	}
+	// its a KTX file
+	else if (type == BM_TYPE_KTX) {
+		int ktx_ct;
+		int ktx_error = ktx1_read_header(filename, img_cfp, w, h, bpp, &ktx_ct, mm_lvl, size);
+		if (ktx_error != KTX1_ERROR_NONE) {
+			mprintf(("ktx: could not open '%s'\n", filename));
+			return -1;
+		}
+		*c_type = (BM_TYPE)ktx_ct;
+	}
 	// if its a tga file
 	else if (type == BM_TYPE_TGA) {
 		int tga_error = targa_read_header(filename, img_cfp, w, h, bpp, NULL);
@@ -1361,6 +1390,8 @@ bool bm_load_and_parse_eff(const char *filename, int dir_type, int *nframes, int
 		c_type = BM_TYPE_JPG;
 	} else if (!stricmp(NOX("pcx"), ext)) {
 		c_type = BM_TYPE_PCX;
+	} else if (!stricmp(NOX("ktx"), ext)) {
+		c_type = BM_TYPE_KTX;
 	} else {
 		mprintf(("BMPMAN: Unknown file type in EFF parse!\n"));
 		return false;
@@ -1390,7 +1421,7 @@ bool bm_load_and_parse_eff(const char *filename, int dir_type, int *nframes, int
 /**
 * Lock an image files data into memory
 */
-static int bm_load_image_data(int handle, int bpp, ushort flags, bool nodebug)
+static int bm_load_image_data(int handle, int bpp, uint flags, bool nodebug)
 {
 	BM_TYPE c_type = BM_TYPE_NONE;
 	int true_bpp;
@@ -1482,6 +1513,10 @@ static int bm_load_image_data(int handle, int bpp, ushort flags, bool nodebug)
 			bm_lock_user(handle, bs, bmp, true_bpp, flags, false);
 			break;
 
+		case BM_TYPE_KTX:
+			bm_lock_ktx1(handle, bs, bmp, true_bpp, flags);
+			break;
+
 		default:
 			Warning(LOCATION, "Unsupported type in bm_lock -- %d\n", c_type);
 			return -1;
@@ -1941,7 +1976,7 @@ int bm_load_sub_slow(const char *real_filename, const int num_ext, const char **
 	return -1;
 }
 
-bitmap * bm_lock(int handle, int bpp, ushort flags, bool nodebug) {
+bitmap * bm_lock(int handle, int bpp, uint flags, bool nodebug) {
 	bitmap			*bmp;
 
 	Assertion(bm_inited, "bmpman must be initialized before this function can be called!");
@@ -2038,7 +2073,7 @@ bitmap * bm_lock(int handle, int bpp, ushort flags, bool nodebug) {
 	return bmp;
 }
 
-void bm_lock_ani(int /*handle*/, bitmap_slot *bs, bitmap* /*bmp*/, int bpp, ushort flags) {
+void bm_lock_ani(int /*handle*/, bitmap_slot *bs, bitmap* /*bmp*/, int bpp, uint flags) {
 	anim				*the_anim;
 	anim_instance	*the_anim_instance;
 	bitmap			*bm;
@@ -2164,7 +2199,7 @@ void bm_lock_ani(int /*handle*/, bitmap_slot *bs, bitmap* /*bmp*/, int bpp, usho
 }
 
 
-void bm_lock_apng(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, ushort /*flags*/) {
+void bm_lock_apng(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, uint /*flags*/) {
 	auto be = &bs->entry;
 	int first_frame = be->info.ani.first_frame;
 	auto first_entry = bm_get_entry(first_frame);
@@ -2214,7 +2249,7 @@ void bm_lock_apng(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, ushort
 }
 
 
-void bm_lock_dds(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, ushort /*flags*/) {
+void bm_lock_dds(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, uint /*flags*/) {
 	ubyte *data = NULL;
 	int error;
 	ubyte dds_bpp = 0;
@@ -2278,7 +2313,7 @@ void bm_lock_dds(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, ushort /
 #endif
 }
 
-void bm_lock_jpg(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort /*flags*/) {
+void bm_lock_jpg(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint /*flags*/) {
 	ubyte *data = NULL;
 	int d_size = 0;
 	int jpg_error = JPEG_ERROR_INVALID;
@@ -2325,7 +2360,7 @@ void bm_lock_jpg(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort /*fla
 #endif
 }
 
-void bm_lock_pcx(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags) {
+void bm_lock_pcx(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags) {
 	ubyte *data;
 	int pcx_error;
 	char filename[MAX_FILENAME_LEN];
@@ -2370,7 +2405,7 @@ void bm_lock_pcx(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags
 	bm_convert_format(bmp, flags);
 }
 
-void bm_lock_png(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, ushort /*flags*/) {
+void bm_lock_png(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, uint /*flags*/) {
 	ubyte *data = NULL;
 	//assume 32 bit - libpng should expand everything
 	int d_size;
@@ -2415,7 +2450,7 @@ void bm_lock_png(int handle, bitmap_slot *bs, bitmap *bmp, int /*bpp*/, ushort /
 #endif
 }
 
-void bm_lock_tga(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags) {
+void bm_lock_tga(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags) {
 	ubyte *data = NULL;
 	int byte_size;
 	char filename[MAX_FILENAME_LEN];
@@ -2474,7 +2509,7 @@ void bm_lock_tga(int handle, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags
 	bm_convert_format(bmp, flags);
 }
 
-void bm_lock_user(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, ushort flags, bool convert) {
+void bm_lock_user(int /*handle*/, bitmap_slot *bs, bitmap *bmp, int bpp, uint flags, bool convert) {
 	auto be = &bs->entry;
 
 	// Unload any existing data
@@ -2767,6 +2802,21 @@ void bm_page_in_texture(int bitmapnum, int nframes) {
 			frame_entry->used_flags = BMP_TEX_CUBEMAP;
 			continue;
 
+		case BM_TYPE_ETC2_RGB:
+		case BM_TYPE_ETC2_SRGB:
+			frame_entry->used_flags = BMP_TEX_ETC2_RGB8;
+			continue;
+
+		case BM_TYPE_ETC2_RGBA1:
+		case BM_TYPE_ETC2_SRGBA1:
+			frame_entry->used_flags = BMP_TEX_ETC2_RGBA1;
+			continue;
+
+		case BM_TYPE_ETC2_RGBA_EAC:
+		case BM_TYPE_ETC2_SRGBA_EAC:
+			frame_entry->used_flags = BMP_TEX_ETC2_RGBA8;
+			continue;
+
 		default:
 			continue;
 		}
@@ -2812,6 +2862,21 @@ void bm_page_in_xparent_texture(int bitmapnum, int nframes) {
 			entry->used_flags = BMP_TEX_CUBEMAP;
 			continue;
 
+		case BM_TYPE_ETC2_RGB:
+		case BM_TYPE_ETC2_SRGB:
+			entry->used_flags = BMP_TEX_ETC2_RGB8;
+			continue;
+
+		case BM_TYPE_ETC2_RGBA1:
+		case BM_TYPE_ETC2_SRGBA1:
+			entry->used_flags = BMP_TEX_ETC2_RGBA1;
+			continue;
+
+		case BM_TYPE_ETC2_RGBA_EAC:
+		case BM_TYPE_ETC2_SRGBA_EAC:
+			entry->used_flags = BMP_TEX_ETC2_RGBA8;
+			continue;
+
 		default:
 			continue;
 		}
@@ -3432,3 +3497,47 @@ SDL_Surface* bm_to_sdl_surface(int handle) {
 	return bitmapSurface;
 
 }
+
+// copied bm_lock_dds and adjusted for ktx. missing BIG_ENDIAN
+void bm_lock_ktx1(int handle, bitmap_slot* bs, bitmap* bmp, int bpp, uint flags)
+{
+	(void)bpp;
+	(void)flags;
+	ubyte* data = nullptr;
+	ubyte ktx_bpp = 0;
+	int ktx_error = KTX1_ERROR_NONE;
+	char filename[MAX_FILENAME_LEN];
+
+	auto be = &bs->entry;
+
+	bm_free_data(bs);
+
+	Assert(be->mem_taken > 0);
+	Assert(&be->bm == bmp);
+
+	data = (ubyte*)bm_malloc(handle, be->mem_taken);
+	if (!data)
+		return;
+	memset(data, 0, be->mem_taken);
+
+	// make sure we are using the correct filename in the case of an EFF.
+	// this will populate filename[] whether it's EFF or not
+	EFF_FILENAME_CHECK;
+
+	ktx_error = ktx1_read_bitmap(filename, data, &ktx_bpp);
+
+	if (ktx_error != KTX1_ERROR_NONE) 
+	{
+		mprintf(("KTX: read_bitmap error=%d file='%s'\n", ktx_error, filename));
+		bm_free_data(bs);
+		return;
+	}
+
+	bmp->bpp = ktx_bpp;
+	bmp->data = (ptr_u)data;
+	bmp->flags = 0;
+
+#ifdef BMPMAN_NDEBUG
+	Assert(be->data_size > 0);
+#endif
+}

code/bmpman/bmpman.h

@@ -34,6 +34,7 @@
 
 // Flag positions for bitmap.flags
 // ***** NOTE:  bitmap.flags is an 8-bit value, no more BMP_TEX_* flags can be added unless the type is changed!! ******
+// Update: bitmap.flags type changed to 16-bit
 #define	BMP_AABITMAP        (1<<0)      //!< antialiased bitmap
 #define	BMP_TEX_XPARENT     (1<<1)      //!< transparent texture
 #define	BMP_TEX_OTHER       (1<<2)      //!< so we can identify all "normal" textures
@@ -43,9 +44,14 @@
 #define BMP_TEX_BC7			(1<<6)		//!< BC7  compressed 8r8g8b8a (32bit)
 #define BMP_TEX_CUBEMAP     (1<<7)      //!< a texture made for cubic environment map
 #define BMP_MASK_BITMAP     (1<<8)      //!< a bitmap that will be used for masking mouse interaction. Typically not used in render operations
+#define BMP_TEX_ETC2_RGB8	(1 << 9)	//!< ETC2 RGB compressed	(24bit, no alpha)
+#define BMP_TEX_ETC2_RGBA1	(1 << 10)	//!< ETC2 RGBA1 compressed	(24bit, 1 alpha)
+#define BMP_TEX_ETC2_RGBA8	(1 << 11)	//!< ETC2 RGBA8 compressed	(32bit, 8 alpha)
+
 
 // Combined flags
-#define BMP_TEX_COMP        ( BMP_TEX_DXT1 | BMP_TEX_DXT3 | BMP_TEX_DXT5 | BMP_TEX_BC7 )  //!< Compressed textures
+#define BMP_TEX_COMP		( BMP_TEX_DXT1 | BMP_TEX_DXT3 | BMP_TEX_DXT5 | BMP_TEX_BC7 | BMP_TEX_ETC2_RGB8 |\
+							  BMP_TEX_ETC2_RGBA1 | BMP_TEX_ETC2_RGBA8 )		//!< Compressed textures
 #define BMP_TEX_NONCOMP     ( BMP_TEX_XPARENT | BMP_TEX_OTHER )             //!< Non-compressed textures
 #define	BMP_TEX_ANY         ( BMP_TEX_COMP | BMP_TEX_NONCOMP )              //!< Any texture
 
@@ -81,7 +87,15 @@ enum BM_TYPE
 	BM_TYPE_CUBEMAP_DXT3,   //!< 32-bit cubemap        (compressed cubemap surface)
 	BM_TYPE_CUBEMAP_DXT5,    //!< 32-bit cubemap        (compressed cubemap surface)
 
-	BM_TYPE_3D				//!< 3D in-memory
+	BM_TYPE_3D,				//!< 3D in-memory
+
+	BM_TYPE_KTX,			//!< generic identifier for KTX1
+	BM_TYPE_ETC2_RGB,		//!< 24 bit, no alpha
+	BM_TYPE_ETC2_SRGB,      //!< 24 bit, no alpha, signed
+	BM_TYPE_ETC2_RGBA1,		//!< 24 bit, 1 bit alpha
+	BM_TYPE_ETC2_SRGBA1,    //!< 24 bit, 1 bit alpha, signed
+	BM_TYPE_ETC2_RGBA_EAC,	//!< 32 bit, 8 bit alpha
+	BM_TYPE_ETC2_SRGBA_EAC  //!< 32 bit, 8 bit alpha, signed
 };
 
 /**
@@ -96,7 +110,7 @@ struct bitmap
 	short	rowsize;    //!< What you need to add to go to next row
 	int	bpp;        //!< Requested bitdepth of each pixel. ( 7, 8, 15, 16, 24, 32)
 	int	true_bpp;   //!< The image's actual bitdepth
-	ushort	flags;      //!< Various texture type flags. @see BMPMAN_CONSTANTS
+	uint	flags;      //!< Various texture type flags. @see BMPMAN_CONSTANTS
 	ptr_u	data;       //!< Pointer to data, or maybe offset into VRAM.
 	ubyte *palette;     /**< @brief   Pointer to this bitmap's palette (if it has one).
 	                     *   @details If BMP_NO_PALETTE_MAP flag is cleared, this palette just points to the screen palette. (gr_palette)
@@ -345,7 +359,7 @@ int bm_load_either(const char *filename, int *nframes = NULL, int *fps = NULL, i
  * @returns A pointer to the bitmap that's valid until bm_unlock is called if successful, or
  * @returns NULL if unsuccessful
  */
-bitmap* bm_lock(int handle, int bpp, ushort flags, bool nodebug = false);
+bitmap* bm_lock(int handle, int bpp, uint flags, bool nodebug = false);
 
 /**
  * @brief Returns the image type of the given bitmap handle
@@ -388,7 +402,7 @@ int bm_is_valid(int handle);
  * @returns The handle to the first frame on success, or
  * @returns -1 on failure
  */
-int bm_get_info(int handle, int *w = nullptr, int * h = nullptr, ushort* flags = nullptr, int *nframes = nullptr, int *fps = nullptr);
+int bm_get_info(int handle, int *w = nullptr, int * h = nullptr, uint* flags = nullptr, int *nframes = nullptr, int *fps = nullptr);
 
 /**
  * @brief Gets 3D info on the bitmap indexed by handle.