Ticket #2996: 0007-Say-hello-to-KTX-format.4.patch

binaries/data/mods/mod/hwdetect/hwdetect.js

@@ -317 +317 @@
     if (output.disable_audio !== undefined)
         Engine.SetDisableAudio(output.disable_audio);
 
-    if (output.disable_s3tc !== undefined)
-        Engine.SetDisableS3TC(output.disable_s3tc);
-
     if (output.disable_shadows !== undefined)
         Engine.SetDisableShadows(output.disable_shadows);
 

build/android/qtcreator/common.pri

@@ -10 +10 @@
 DEFINES +=  \
             U_HAVE_STD_STRING \
             CONFIG2_NVTT=0 CONFIG2_MINIUPNPC=1 \
-            CONFIG2_GLES=1 CONFIG2_AUDIO=1
+            CONFIG2_GLES=1 CONFIG2_AUDIO=1 CONFIG2_KTX=1
 
 SRCS_PATH=$$PWD/../../../source
 

source/graphics/HeightMipmap.cpp

@@ -23 +23 @@
 #include "lib/timer.h"
 #include "lib/allocators/shared_ptr.h"
 #include "lib/tex/tex.h"
+#include "lib/ogl.h"
 #include "maths/MathUtil.h"
 #include "ps/Filesystem.h"
 
@@ -224 +225 @@
     const size_t w = m_MapSize;
     const size_t h = m_MapSize * 2;
     const size_t bpp = 8;
-    int flags = TEX_GREY|TEX_TOP_DOWN;
+    int flags = TEX_TOP_DOWN;
 
     const size_t img_size = w * h * bpp/8;
     const size_t hdr_size = tex_hdr_size(filename);
@@ -232 +233 @@
     AllocateAligned(buf, hdr_size+img_size, maxSectorSize);
     void* img = buf.get() + hdr_size;
     Tex t;
-    WARN_IF_ERR(t.wrap(w, h, bpp, flags, buf, hdr_size));
+    WARN_IF_ERR(t.wrap(GL_LUMINANCE, w, h, bpp, flags, buf, hdr_size));
 
     memset(img, 0x00, img_size);
     size_t yoff = 0;

source/graphics/TerrainTextureEntry.cpp

@@ -333 +333 @@
 
     // upload the composite texture
     Tex t;
-    (void)t.wrap(total_w, total_h, 8, TEX_GREY, data, 0);
+    (void)t.wrap(GL_ALPHA, total_w, total_h, 8, 0, data, 0);
     
     // uncomment the following to save a png of the generated texture
     // in the public/ directory, for debugging
@@ -358 +358 @@
     Handle hCompositeAlphaMap = ogl_tex_wrap(&t, g_VFS, key);
     (void)ogl_tex_set_filter(hCompositeAlphaMap, GL_LINEAR);
     (void)ogl_tex_set_wrap  (hCompositeAlphaMap, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
-    ogl_tex_upload(hCompositeAlphaMap, GL_ALPHA, 0, 0);
+    ogl_tex_upload(hCompositeAlphaMap);
     result.m_hCompositeAlphaMap = hCompositeAlphaMap;
     
     m_TerrainAlpha = it;

source/graphics/TextureConverter.cpp

@@ -27 +27 @@
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
 #include "ps/Profiler2.h"
+#include "ps/Util.h"
 #include "ps/XML/Xeromyces.h"
 
 #if CONFIG2_NVTT
@@ -338 +339 @@
     }
 
     // Check whether there's any alpha channel
-    bool hasAlpha = ((tex.m_Flags & TEX_ALPHA) != 0);
+    bool hasAlpha = tex.hasAlpha();
 
     if (settings.format == FMT_ALPHA)
     {
         // Convert to uncompressed 8-bit with no mipmaps
-        if (tex.transform_to((tex.m_Flags | TEX_GREY) & ~(TEX_DXT | TEX_MIPMAPS | TEX_ALPHA)) < 0)
+        tex.m_numberOfMipmapLevels = 1;
+        if (tex.transform(GL_ALPHA) < 0)
         {
             LOGERROR("Failed to transform texture \"%s\"", src.string8());
             return false;
@@ -354 +356 @@
         // TODO: grayscale images will fail on some systems
         // see http://trac.wildfiregames.com/ticket/1640
         // (plain_transform doesn't know how to construct the alpha channel)
-        if (tex.m_Flags & TEX_GREY)
+        if (tex.m_glFormat == GL_LUMINANCE)
         {
             LOGERROR("Failed to convert grayscale texture \"%s\" - only RGB textures are currently supported", src.string8());
             return false;
         }
 
         // Convert to uncompressed BGRA with no mipmaps
-        if (tex.transform_to((tex.m_Flags | TEX_BGR | TEX_ALPHA) & ~(TEX_DXT | TEX_MIPMAPS)) < 0)
+        if (tex.transform(GL_BGRA_EXT) < 0)
         {
             LOGERROR("Failed to transform texture \"%s\"", src.string8());
             return false;
         }
     }
 
+
     // Check if the texture has all alpha=255, so we can automatically
     // switch from DXT3/DXT5 to DXT1 with no loss
     if (hasAlpha)
@@ -519 +522 @@
     shared_ptr<u8> file;
     AllocateAligned(file, size, maxSectorSize);
     memcpy(file.get(), &result->output.buffer[0], size);
-    if (m_VFS->CreateFile(result->dest, file, size) < 0)
+#ifdef CONFIG2_KTX
+    if (result->dest.Extension() == L".ktx")
     {
-        // error writing file
-        ok = false;
-        return true;
+        Tex t;
+        WARN_IF_ERR(t.decode(file, size));
+        tex_write(&t, result->dest, m_VFS);
+    }
+    else
+#endif
+    {
+        if (m_VFS->CreateFile(result->dest, file, size) < 0)
+        {
+            // error writing file
+            ok = false;
+            return true;
+        }
     }
-
     // Succeeded in converting texture
     texture = result->texture;
     dest = result->dest;
     ok = true;
     return true;
-
 #else // #if CONFIG2_NVTT
     return false;
 #endif

source/graphics/TextureManager.cpp

@@ -73 +73 @@
     }
 };
 
+#if CONFIG2_KTX
+# define EXT L".ktx"
+#else
+# define EXT L".dds"
+#endif
 
 class CTextureManagerImpl
 {
     friend class CTexture;
 public:
     CTextureManagerImpl(PIVFS vfs, bool highQuality, bool disableGL) :
-        m_VFS(vfs), m_CacheLoader(vfs, L".dds"), m_DisableGL(disableGL), m_TextureConverter(vfs, highQuality),
+        m_VFS(vfs), m_CacheLoader(vfs, EXT), m_DisableGL(disableGL), m_TextureConverter(vfs, highQuality),
         m_DefaultHandle(0), m_ErrorHandle(0)
     {
         // Initialise some textures that will always be available,
@@ -94 +99 @@
             data.get()[1] = 64;
             data.get()[2] = 64;
             Tex t;
-            (void)t.wrap(1, 1, 24, 0, data, 0);
+            (void)t.wrap(GL_RGB, 1, 1, 24, 0, data, 0);
 
             m_DefaultHandle = ogl_tex_wrap(&t, m_VFS, L"(default texture)");
             (void)ogl_tex_set_filter(m_DefaultHandle, GL_LINEAR);
@@ -111 +116 @@
             data.get()[1] = 0;
             data.get()[2] = 255;
             Tex t;
-            (void)t.wrap(1, 1, 24, 0, data, 0);
+            (void)t.wrap(GL_RGB, 1, 1, 24, 0, data, 0);
 
             m_ErrorHandle = ogl_tex_wrap(&t, m_VFS, L"(error texture)");
             (void)ogl_tex_set_filter(m_ErrorHandle, GL_LINEAR);
@@ -185 +190 @@
             return;
         }
 
-        // Get some flags for later use
-        size_t flags = 0;
-        (void)ogl_tex_get_format(h, &flags, NULL);
-
         // Initialise base colour from the texture
         (void)ogl_tex_get_average_colour(h, &texture->m_BaseColour);
 
@@ -199 +200 @@
         // Prevent ogl_tex automatically generating mipmaps (which is slow and unwanted),
         // by avoiding mipmapped filters unless the source texture already has mipmaps
         GLint filter = texture->m_Properties.m_Filter;
-        if (!(flags & TEX_MIPMAPS))
+        if (ogl_tex_get_number_of_mimaps(h) == 1)
         {
             switch (filter)
             {
@@ -216 +217 @@
         (void)ogl_tex_set_filter(h, filter);
 
         // Upload to GL
-        if (!m_DisableGL && ogl_tex_upload(h, texture->m_Properties.m_Format) < 0)
+        if (!m_DisableGL && ogl_tex_upload(h) < 0)
         {
             LOGERROR("Texture failed to upload: \"%s\"", texture->m_Properties.m_Path.string8());
 
@@ -608 +609 @@
 
 bool CTexture::HasAlpha() const
 {
-    size_t flags = 0;
-    (void)ogl_tex_get_format(m_Handle, &flags, 0);
-    return (flags & TEX_ALPHA) != 0;
+    return ogl_tex_has_alpha(m_Handle);
 }
 
 u32 CTexture::GetBaseColour() const

source/graphics/tests/test_TextureConverter.h

@@ -76 +76 @@
         Tex tex;
         TS_ASSERT_OK(tex.decode(file, fileSize));
 
-        TS_ASSERT_OK(tex.transform_to((tex.m_Flags | TEX_BGR | TEX_ALPHA) & ~(TEX_DXT | TEX_MIPMAPS)));
+        TS_ASSERT_OK(tex.transform(GL_BGRA_EXT));
 
         u8* texdata = tex.get_data();
 

source/lib/config2.h

@@ -111 +111 @@
 # define CONFIG2_NVTT 1
 #endif
 
+#ifndef CONFIG2_KTX
+# define CONFIG2_KTX 1
+#endif
+
 // allow use of lobby
 #ifndef CONFIG2_LOBBY
 # define CONFIG2_LOBBY 1

source/lib/external_libraries/glext_funcs.h

@@ -116 +116 @@
 #define pglGenFramebuffersEXT glGenFramebuffers
 
 #define GL_DEPTH_ATTACHMENT_EXT GL_DEPTH_ATTACHMENT
-#define GL_COLOR_ATTACHMENT0_EXT GL_COLOR_ATTACHMENT0
+#ifndef GL_COLOR_ATTACHMENT0_EXT
+# define GL_COLOR_ATTACHMENT0_EXT GL_COLOR_ATTACHMENT0
+#endif
 #define GL_FRAMEBUFFER_BINDING_EXT GL_FRAMEBUFFER_BINDING
 #define GL_FRAMEBUFFER_COMPLETE_EXT GL_FRAMEBUFFER_COMPLETE
 #define GL_FRAMEBUFFER_EXT GL_FRAMEBUFFER

source/lib/external_libraries/opengl.h

@@ -68 +68 @@
 # endif
 #endif
 
+#ifndef GL_BGR
+# define GL_BGR 0x80E0
+#endif
+
+#ifndef GL_RED
+# define GL_RED 0x1903
+#endif
+
+#ifndef GL_RG
+# define GL_RG 0x8227
+#endif
+
 #endif  // #ifndef INCLUDED_OPENGL

source/lib/res/graphics/cursor.cpp

@@ -65 +65 @@
     RETURN_STATUS_IF_ERR(t.decode(file, fileSize));
 
     // convert to required BGRA format.
-    const size_t flags = (t.m_Flags | TEX_BGR) & ~TEX_DXT;
-    RETURN_STATUS_IF_ERR(t.transform_to(flags));
+    RETURN_STATUS_IF_ERR(t.transform(GL_BGRA_EXT));
     void* bgra_img = t.get_data();
     if(!bgra_img)
         WARN_RETURN(ERR::FAIL);
@@ -93 +92 @@
         RETURN_STATUS_IF_ERR(t.decode(file, fileSize));
 
         // convert to required BGRA format.
-        const size_t flags = (t.m_Flags | TEX_BGR) & ~TEX_DXT;
-        RETURN_STATUS_IF_ERR(t.transform_to(flags));
+        RETURN_STATUS_IF_ERR(t.transform(GL_BGRA_EXT));
         void* bgra_img = t.get_data();
         if(!bgra_img)
             WARN_RETURN(ERR::FAIL);

source/lib/res/graphics/ogl_tex.cpp

@@ -98 +98 @@
     }
 }
 
-
-static bool fmt_is_s3tc(GLenum fmt)
-{
-    switch(fmt)
-    {
-    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-#if !CONFIG2_GLES
-    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-#endif
-        return true;
-    default:
-        return false;
-    }
-}
-
-
-// determine OpenGL texture format, given <bpp> and Tex <flags>.
-static GLint choose_fmt(size_t bpp, size_t flags)
-{
-    const bool alpha = (flags & TEX_ALPHA) != 0;
-    const bool bgr   = (flags & TEX_BGR  ) != 0;
-    const bool grey  = (flags & TEX_GREY ) != 0;
-    const size_t dxt   = flags & TEX_DXT;
-
-    // S3TC
-    if(dxt != 0)
-    {
-        switch(dxt)
-        {
-        case DXT1A:
-            return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
-        case 1:
-            return GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
-#if !CONFIG2_GLES
-        case 3:
-            return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
-        case 5:
-            return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
-#endif
-        default:
-            DEBUG_WARN_ERR(ERR::LOGIC); // invalid DXT value
-            return 0;
-        }
-    }
-
-    // uncompressed
-    switch(bpp)
-    {
-    case 8:
-        ENSURE(grey);
-        return GL_LUMINANCE;
-    case 16:
-        return GL_LUMINANCE_ALPHA;
-    case 24:
-        ENSURE(!alpha);
-#if CONFIG2_GLES
-        // GLES never supports BGR
-        ENSURE(!bgr);
-        return GL_RGB;
-#else
-        return bgr? GL_BGR : GL_RGB;
-#endif
-    case 32:
-        ENSURE(alpha);
-        // GLES can support BGRA via GL_EXT_texture_format_BGRA8888
-        // (TODO: can we rely on support for that extension?)
-        return bgr? GL_BGRA_EXT : GL_RGBA;
-    default:
-        DEBUG_WARN_ERR(ERR::LOGIC); // invalid bpp
-        return 0;
-    }
-
-    UNREACHABLE;
-}
-
-
 //----------------------------------------------------------------------------
 // quality mechanism
 //----------------------------------------------------------------------------
@@ -218 +140 @@
     }
 }
 
-
-// choose an internal format for <fmt> based on the given q_flags.
-static GLint choose_int_fmt(GLenum fmt, int q_flags)
-{
-    // true => 4 bits per component; otherwise, 8
-    const bool half_bpp = (q_flags & OGL_TEX_HALF_BPP) != 0;
-
-    // early-out for S3TC textures: they don't need an internal format
-    // (because upload is via glCompressedTexImage2DARB), but we must avoid
-    // triggering the default case below. we might as well return a
-    // meaningful value (i.e. int_fmt = fmt).
-    if(fmt_is_s3tc(fmt))
-        return fmt;
-
-#if CONFIG2_GLES
-
-    UNUSED2(half_bpp);
-
-    // GLES only supports internal format == external format
-    return fmt;
-
-#else
-
-    switch(fmt)
-    {
-    // 8bpp
-    case GL_LUMINANCE:
-        return half_bpp? GL_LUMINANCE4 : GL_LUMINANCE8;
-    case GL_INTENSITY:
-        return half_bpp? GL_INTENSITY4 : GL_INTENSITY8;
-    case GL_ALPHA:
-        return half_bpp? GL_ALPHA4 : GL_ALPHA8;
-
-    // 16bpp
-    case GL_LUMINANCE_ALPHA:
-        return half_bpp? GL_LUMINANCE4_ALPHA4 : GL_LUMINANCE8_ALPHA8;
-
-    // 24bpp
-    case GL_RGB:
-    case GL_BGR:    // note: BGR can't be used as internal format
-        return half_bpp? GL_RGB4 : GL_RGB8;
-
-    // 32bpp
-    case GL_RGBA:
-    case GL_BGRA:   // note: BGRA can't be used as internal format
-        return half_bpp? GL_RGBA4 : GL_RGBA8;
-
-    default:
-        {
-        wchar_t buf[100];
-        swprintf_s(buf, ARRAY_SIZE(buf), L"choose_int_fmt: fmt 0x%x isn't covered! please add it", fmt);
-        DEBUG_DISPLAY_ERROR(buf);
-        DEBUG_WARN_ERR(ERR::LOGIC); // given fmt isn't covered! please add it.
-        // fall back to a reasonable default
-        return half_bpp? GL_RGB4 : GL_RGB8;
-        }
-    }
-
-    UNREACHABLE;
-
-#endif  // #if CONFIG2_GLES
-}
-
-
 //----------------------------------------------------------------------------
 // texture state to allow seamless reload
 //----------------------------------------------------------------------------
@@ -408 +266 @@
     // allocated by OglTex_reload; indicates the texture is currently uploaded.
     GLuint id;
 
-    // ogl_tex_upload calls choose_fmt to determine these from <t>.
-    // however, its caller may override those values via parameters.
-    // note: these are stored here to allow retrieving via ogl_tex_get_format;
-    // they are only used within ogl_tex_upload.
-    GLenum fmt;
-    GLint int_fmt;
-
     OglTexState state;
 
     // OglTexQualityFlags
@@ -706 +557 @@
 
 // tristate; -1 is undecided
 static int have_auto_mipmap_gen = -1;
-static int have_s3tc = -1;
 static int have_anistropy = -1;
 
 // override the default decision and force/disallow use of the
@@ -718 +568 @@
 
     switch(what)
     {
-    case OGL_TEX_S3TC:
-        have_s3tc = enable;
-        break;
     case OGL_TEX_AUTO_MIPMAP_GEN:
         have_auto_mipmap_gen = enable;
         break;
@@ -735 +582 @@
 
 
 // detect caps (via OpenGL extension list) and give an app_hook the chance to
-// override this (e.g. via list of card/driver combos on which S3TC breaks).
+// override this.
 // called once from the first ogl_tex_upload.
 static void detect_gl_upload_caps()
 {
@@ -748 +595 @@
     {
         have_auto_mipmap_gen = ogl_HaveExtension("GL_SGIS_generate_mipmap");
     }
-    if(have_s3tc == -1)
-    {
-#if CONFIG2_GLES
-        // some GLES implementations have GL_EXT_texture_compression_dxt1
-        // but that only supports DXT1 so we can't use it anyway
-        have_s3tc = 0;
-#else
-        // note: we don't bother checking for GL_S3_s3tc - it is incompatible
-        // and irrelevant (was never widespread).
-        have_s3tc = ogl_HaveExtensions(0, "GL_ARB_texture_compression", "GL_EXT_texture_compression_s3tc", NULL) == 0;
-#endif
-    }
     if(have_anistropy == -1)
     {
         have_anistropy = ogl_HaveExtension("GL_EXT_texture_filter_anisotropic");
@@ -770 +605 @@
     {
         ah_override_gl_upload_caps();
     }
-    // no app hook defined - have our own crack at blacklisting some hardware.
-    else
-    {
-        const std::wstring cardName = gfx::CardName();
-        // rationale: janwas's laptop's S3 card blows up if S3TC is used
-        // (oh, the irony). it'd be annoying to have to share this between all
-        // projects, hence this default implementation here.
-        if(cardName == L"S3 SuperSavage/IXC 1014")
-            ogl_tex_override(OGL_TEX_S3TC, OGL_TEX_DISABLE);
-    }
 }
 
 
@@ -797 +622 @@
     const bool need_mipmaps = are_mipmaps_needed(t->m_Width, t->m_Height, filter);
     // .. does the image data include mipmaps? (stored as separate
     //    images after the regular texels)
-    const bool includes_mipmaps = (t->m_Flags & TEX_MIPMAPS) != 0;
-    // .. is this texture in S3TC format? (more generally, "compressed")
-    const bool is_s3tc = (t->m_Flags & TEX_DXT) != 0;
+    const bool includes_mipmaps = t->m_numberOfMipmapLevels > 1;
+    // .. is this texture compressed ?
+    const bool is_compressed = t->m_glType == 0;
 
-    *plevels_to_skip = TEX_BASE_LEVEL_ONLY;
+    *plevels_to_skip = 0;
     if(!need_mipmaps)
         return INFO::OK;
 
@@ -827 +652 @@
     // rationale: having tex_transform add mipmaps would be slow (since
     // all<->all transforms aren't implemented, it'd have to decompress
     // from S3TC first), and DDS images ought to include mipmaps!
-    else if(is_s3tc)
+    else if(is_compressed)
         return ERR::FAIL;   // NOWARN
     // image is uncompressed and we're on an old OpenGL implementation;
     // we will generate mipmaps in software.
     else
     {
-        RETURN_STATUS_IF_ERR(t->transform_to(t->m_Flags|TEX_MIPMAPS));
+        RETURN_STATUS_IF_ERR(t->transform(t->m_glFormat, TEX_MIPMAPS));
         *plevels_to_skip = 0;   // t contains mipmaps
     }
 
@@ -868 +693 @@
 
 struct UploadParams
 {
+    GLenum type;
     GLenum fmt;
     GLint int_fmt;
     u32* uploaded_size;
 };
 
-static void upload_level(size_t level, size_t level_w, size_t level_h, const u8* RESTRICT level_data, size_t level_data_size, void* RESTRICT cbData)
+static void upload_level(size_t level, size_t UNUSED(face), size_t level_w, size_t level_h, const u8* RESTRICT level_data, size_t level_data_size, void* RESTRICT cbData)
 {
     const UploadParams* up = (const UploadParams*)cbData;
-    glTexImage2D(GL_TEXTURE_2D, (GLint)level, up->int_fmt, (GLsizei)level_w, (GLsizei)level_h, 0, up->fmt, GL_UNSIGNED_BYTE, level_data);
+    glTexImage2D(GL_TEXTURE_2D, (GLint)level, up->int_fmt, (GLsizei)level_w, (GLsizei)level_h, 0, up->fmt, up->type, level_data);
     *up->uploaded_size += (u32)level_data_size;
 }
 
-static void upload_compressed_level(size_t level, size_t level_w, size_t level_h, const u8* RESTRICT level_data, size_t level_data_size, void* RESTRICT cbData)
+static void upload_compressed_level(size_t level, size_t UNUSED(face), size_t level_w, size_t level_h, const u8* RESTRICT level_data, size_t level_data_size, void* RESTRICT cbData)
 {
     const UploadParams* up = (const UploadParams*)cbData;
-    pglCompressedTexImage2DARB(GL_TEXTURE_2D, (GLint)level, up->fmt, (GLsizei)level_w, (GLsizei)level_h, 0, (GLsizei)level_data_size, level_data);
+    pglCompressedTexImage2DARB(GL_TEXTURE_2D, (GLint)level, up->int_fmt, (GLsizei)level_w, (GLsizei)level_h, 0, (GLsizei)level_data_size, level_data);
     *up->uploaded_size += (u32)level_data_size;
 }
 
@@ -891 +717 @@
 // split out of ogl_tex_upload because it was too big.
 //
 // pre: <t> is valid for OpenGL use; texture is bound.
-static void upload_impl(Tex* t, GLenum fmt, GLint int_fmt, int levels_to_skip, u32* uploaded_size)
+static void upload_impl(Tex* t, int levels_to_skip, u32* uploaded_size)
 {
-    const GLsizei w  = (GLsizei)t->m_Width;
-    const GLsizei h  = (GLsizei)t->m_Height;
-    const size_t bpp   = t->m_Bpp;
-    const u8* data = (const u8*)t->get_data();
-    const UploadParams up = { fmt, int_fmt, uploaded_size };
-
-    if(t->m_Flags & TEX_DXT)
-        tex_util_foreach_mipmap(w, h, bpp, data, levels_to_skip, 4, upload_compressed_level, (void*)&up);
+    const UploadParams up = { (GLenum)t->m_glType, (GLenum)t->m_glFormat, (GLint)t->m_glInternalFormat, uploaded_size };
+
+    if(t->m_glType)
+        tex_util_foreach_mipmap(t, levels_to_skip, upload_level, (void*)&up);
     else
-        tex_util_foreach_mipmap(w, h, bpp, data, levels_to_skip, 1, upload_level, (void*)&up);
+        tex_util_foreach_mipmap(t, levels_to_skip, upload_compressed_level, (void*)&up);
 }
 
-
 // upload the texture to OpenGL.
 // if not 0, parameters override the following:
 //   fmt_ovr     : OpenGL format (e.g. GL_RGB) decided from bpp / Tex flags;
@@ -915 +736 @@
 // side effects:
 // - enables texturing on TMU 0 and binds the texture to it;
 // - frees the texel data! see ogl_tex_get_data.
-Status ogl_tex_upload(const Handle ht, GLenum fmt_ovr, int q_flags_ovr, GLint int_fmt_ovr)
+Status ogl_tex_upload(const Handle ht)
 {
     ONCE(detect_gl_upload_caps());
 
     H_DEREF(ht, OglTex, ot);
     Tex* t = &ot->t;
-    ENSURE(q_flags_valid(q_flags_ovr));
     // we don't bother verifying *fmt_ovr - there are too many values
 
     // upload already happened; no work to do.
@@ -931 +751 @@
 
     if(ot->flags & OT_TEX_VALID)
     {
-        // decompress S3TC if that's not supported by OpenGL.
-        if((t->m_Flags & TEX_DXT) && !have_s3tc)
-            (void)t->transform_to(t->m_Flags & ~TEX_DXT);
-
-        // determine fmt and int_fmt, allowing for user override.
-        ot->fmt = choose_fmt(t->m_Bpp, t->m_Flags);
-        if(fmt_ovr) ot->fmt = fmt_ovr;
-        if(q_flags_ovr) ot->q_flags = q_flags_ovr;
-        ot->int_fmt = choose_int_fmt(ot->fmt, ot->q_flags);
-        if(int_fmt_ovr) ot->int_fmt = int_fmt_ovr;
-
         ot->uploaded_size = 0;
 
         // now actually send to OpenGL:
@@ -957 +766 @@
             // (note: if first time, applies our defaults/previous overrides;
             // otherwise, replays all state changes)
             state_latch(&ot->state);
-            upload_impl(t, ot->fmt, ot->int_fmt, levels_to_skip, &ot->uploaded_size);
+            upload_impl(t, levels_to_skip, &ot->uploaded_size);
+        }
+
+        if (glGetError() != GL_NO_ERROR && !t->m_glType) {
+            // the texture is compressed and the GPU don't support it,
+            // let's try decompress it on the CPU
+            RETURN_STATUS_IF_ERR(t->transform(t->m_glFormat, t->m_Flags));
+
+            if (t->m_glType) // is it decompressed?
+                return ogl_tex_upload(ht);
+            ogl_WarnIfError();
         }
-        ogl_WarnIfError();
 
         ot->flags |= OT_IS_UPLOADED;
 
@@ -997 +815 @@
     return INFO::OK;
 }
 
-
-// retrieve TexFlags and the corresponding OpenGL format.
-// the latter is determined during ogl_tex_upload and is 0 before that.
-// all params are optional and filled if non-NULL.
-Status ogl_tex_get_format(Handle ht, size_t* flags, GLenum* fmt)
+size_t ogl_tex_get_number_of_mimaps(Handle ht)
 {
     H_DEREF(ht, OglTex, ot);
-
-    if(flags)
-        *flags = ot->t.m_Flags;
-    if(fmt)
-    {
-        ENSURE(ot->flags & OT_IS_UPLOADED);
-        *fmt = ot->fmt;
-    }
-    return INFO::OK;
+    return ot->t.m_numberOfMipmapLevels;
 }
 
+bool ogl_tex_has_alpha(Handle ht)
+{
+    H_DEREF(ht, OglTex, ot);
+    return ot->t.hasAlpha();
+}
 
 // retrieve pointer to texel data.
 //
@@ -1105 +916 @@
     return INFO::OK;
 }
 
-// apply the specified transforms (as in tex_transform) to the image.
-// must be called before uploading (raises a warning if called afterwards).
-Status ogl_tex_transform(Handle ht, size_t transforms)
-{
-    H_DEREF(ht, OglTex, ot);
-    Status ret = ot->t.transform(transforms);
-    return ret;
-}
-
-
-// change the pixel format to that specified by <new_flags>.
-// (note: this is equivalent to ogl_tex_transform(ht, ht_flags^new_flags).
-Status ogl_tex_transform_to(Handle ht, size_t new_flags)
-{
-    H_DEREF(ht, OglTex, ot);
-    Status ret = ot->t.transform_to(new_flags);
-    return ret;
-}
-
-
-// return whether native S3TC support is available
-bool ogl_tex_has_s3tc()
-{
-    // ogl_tex_upload must be called before this
-    ENSURE(have_s3tc != -1);
-
-    return (have_s3tc != 0);
-}
-
 // return whether anisotropic filtering support is available
 bool ogl_tex_has_anisotropy()
 {

source/lib/res/graphics/ogl_tex.h

@@ -80 +80 @@
 ogl_tex_set_* or ogl_tex_upload parameters.
 
 Finally, provision is made for coping with hardware/drivers lacking support
-for S3TC decompression or mipmap generation: that can be done in software,
+for texture decompression or mipmap generation: that can be done in software,
 if necessary. This avoids the need for alternate asset formats and
 lowers hardware requirements. While such cards probably won't run
 the app very well (due to their age and lack of other capabilities),
@@ -316 +316 @@
 
 enum OglTexOverrides
 {
-    OGL_TEX_S3TC,
     OGL_TEX_AUTO_MIPMAP_GEN,
     OGL_TEX_ANISOTROPY
 };
@@ -352 +351 @@
 * - enables texturing on TMU 0 and binds the texture to it;
 * - frees the texel data! see ogl_tex_get_data.
 */
-extern Status ogl_tex_upload(const Handle ht, GLenum fmt_ovr = 0, int q_flags_ovr = 0, GLint int_fmt_ovr = 0);
+extern Status ogl_tex_upload(const Handle ht);
 
 
 //
@@ -370 +369 @@
 */
 extern Status ogl_tex_get_size(Handle ht, size_t* w, size_t* h, size_t* bpp);
 
+size_t ogl_tex_get_number_of_mimaps(Handle ht);
+
 /**
-* Retrieve pixel format of the texture.
-*
 * @param ht Texture handle
-* @param flags optional; will be filled with TexFlags
-* @param fmt optional; will be filled with GL format
-*        (it is determined during ogl_tex_upload and 0 before then)
-* @return Status
+* @return True is the texture has alpha
 */
-extern Status ogl_tex_get_format(Handle ht, size_t* flags, GLenum* fmt);
+extern bool ogl_tex_has_alpha(Handle ht);
 
 /**
 * Retrieve pixel data of the texture.
@@ -448 +444 @@
 extern Status ogl_tex_get_texture_id(Handle ht, GLuint* id);
 
 /**
-* (partially) Transform pixel format of the texture.
-*
-* @param ht Texture handle.
-* @param flags the TexFlags that are to be @em changed.
-* @return Status
-* @see tex_transform
-*
-* Must be called before uploading (raises a warning if called afterwards).
-*/
-extern Status ogl_tex_transform(Handle ht, size_t flags);
-
-/**
-* Transform pixel format of the texture.
-*
-* @param ht Texture handle.
-* @param new_flags Flags desired new TexFlags indicating pixel format.
-* @return Status
-* @see tex_transform
-*
-* Must be called before uploading (raises a warning if called afterwards).
-*
-* Note: this is equivalent to ogl_tex_transform(ht, ht_flags^new_flags).
-*/
-extern Status ogl_tex_transform_to(Handle ht, size_t new_flags);
-
-/**
- * Return whether native S3TC texture compression support is available.
- * If not, textures will be decompressed automatically, hurting performance.
- *
- * @return true if native S3TC supported.
- *
- * ogl_tex_upload must be called at least once before this.
- */
-extern bool ogl_tex_has_s3tc();
-
-/**
  * Return whether anisotropic filtering support is available.
  * (The anisotropy might still be disabled or overridden by the driver
  * configuration.)

source/lib/res/graphics/tests/test_tex.h

@@ -22 +22 @@
 
 #include "lib/self_test.h"
 
+#include "lib/ogl.h"
 #include "lib/tex/tex.h"
 #include "lib/tex/tex_codec.h"
 #include "lib/allocators/shared_ptr.h"
@@ -42 +43 @@
         {
             // wrap in Tex
             Tex t;
-            TS_ASSERT_OK(t.wrap(w, h, bpp, flags, img, 0));
+            TS_ASSERT_OK(t.wrap(GL_LUMINANCE,w, h, bpp, flags, img, 0));
 
             // encode to file format
             TS_ASSERT_OK(t.encode(extension, &da));
@@ -53 +54 @@
             TS_ASSERT_OK(t.decode(ptr, da.cur_size));
 
             // make sure pixel format gets converted completely to plain
-            TS_ASSERT_OK(t.transform_to(0));
+            TS_ASSERT_OK(t.transform(t.m_glFormat));
 
             // compare img
             TS_ASSERT_SAME_DATA(t.get_data(), img.get(), size);
@@ -72 +73 @@
         // assumes 2x2 box filter algorithm with rounding
         static const u8 mipmap[] = { 0x6C,0x79,0x87 };
         Tex t;
-        TS_ASSERT_OK(t.wrap(2, 2, 24, 0, img, 0));
-        TS_ASSERT_OK(t.transform_to(TEX_MIPMAPS));
+        TS_ASSERT_OK(t.wrap(GL_LUMINANCE,2, 2, 24, 0, img, 0));
+        TS_ASSERT_OK(t.transform(t.m_glFormat, TEX_MIPMAPS));
         const u8* const out_img = t.get_data();
         TS_ASSERT_EQUALS((int)t.img_size(), 12+3);
         TS_ASSERT_SAME_DATA(out_img, imgData, 12);
@@ -85 +86 @@
         shared_ptr<u8> img(new u8[100*100*4], ArrayDeleter());
 
         Tex t;
-        TS_ASSERT_OK(t.wrap(100, 100, 32, TEX_ALPHA, img, 0));
+        TS_ASSERT_OK(t.wrap(GL_RGBA, 100, 100, 32, 0, img, 0));
         TS_ASSERT_EQUALS((int)t.img_size(), 40000);
-
-        // DXT rounds up to 4x4 blocks; DXT1a is 4bpp
-        Tex t2;
-        TS_ASSERT_OK(t2.wrap(97, 97, 4, DXT1A, img, 0));
-        TS_ASSERT_EQUALS((int)t2.img_size(),  5000);
     }
 
     void test_s3tc_decode()
     {
-        const size_t w = 4, h = 4, bpp = 4;
-        const size_t size = w*h/2;
-        shared_ptr<u8> img(new u8[size], ArrayDeleter());
-        memcpy(img.get(), "\xFF\xFF\x00\x00\x00\xAA\xFF\x55", 8); // gradient from white to black
-        const u8 expected[] =
-            "\xFF\xFF\xFF" "\xFF\xFF\xFF" "\xFF\xFF\xFF" "\xFF\xFF\xFF"
-            "\xAA\xAA\xAA" "\xAA\xAA\xAA" "\xAA\xAA\xAA" "\xAA\xAA\xAA"
-            "\x55\x55\x55" "\x55\x55\x55" "\x55\x55\x55" "\x55\x55\x55"
-            "\x00\x00\x00" "\x00\x00\x00" "\x00\x00\x00" "\x00\x00\x00";
-
-        const size_t flags = TEX_DXT&1;
-
-        // wrap in Tex
-        Tex t;
-        TS_ASSERT_OK(t.wrap(w, h, bpp, flags, img, 0));
-
-        // decompress S3TC
-        TS_ASSERT_OK(t.transform_to(0));
-
-        // compare img
-        TS_ASSERT_SAME_DATA(t.get_data(), expected, 48);
+#warning FIXME t.transform needs a full KTX/DDS header.
+
+//      const size_t w = 4, h = 4, bpp = 4;
+//      const size_t size = w*h/2;
+//      shared_ptr<u8> img(new u8[size], ArrayDeleter());
+//      memcpy(img.get(), "\xFF\xFF\x00\x00\x00\xAA\xFF\x55", 8); // gradient from white to black
+//      const u8 expected[] =
+//          "\xFF\xFF\xFF" "\xFF\xFF\xFF" "\xFF\xFF\xFF" "\xFF\xFF\xFF"
+//          "\xAA\xAA\xAA" "\xAA\xAA\xAA" "\xAA\xAA\xAA" "\xAA\xAA\xAA"
+//          "\x55\x55\x55" "\x55\x55\x55" "\x55\x55\x55" "\x55\x55\x55"
+//          "\x00\x00\x00" "\x00\x00\x00" "\x00\x00\x00" "\x00\x00\x00";
+
+//      // wrap in Tex
+//      Tex t;
+//      TS_ASSERT_OK(t.wrap(GL_RGB, w, h, bpp, 0, img, 0));
+//      t.m_glType = 0;
+//      t.m_glInternalFormat = 0x83F0; //GL_COMPRESSED_RGB_S3TC_DXT1_EXT
+
+//      // decompress S3TC
+//      TS_ASSERT_OK(t.transform(t.m_glFormat));
+
+//      // compare img
+//      TS_ASSERT_SAME_DATA(t.get_data(), expected, 48);
     }
 };

source/lib/res/h_mgr.cpp

@@ -134 +134 @@
 //
 
 // chosen so that all current resource structs are covered.
-static const size_t HDATA_USER_SIZE = 104;
+static const size_t HDATA_USER_SIZE = 144;
 
 
 struct HDATA

source/lib/tex/tex.cpp

@@ -33 +33 @@
 
 #include "lib/timer.h"
 #include "lib/bits.h"
+#include "lib/ogl.h"
 #include "lib/allocators/shared_ptr.h"
 #include "lib/sysdep/cpu.h"
 
@@ -57 +58 @@
 //-----------------------------------------------------------------------------
 
 // be careful not to use other tex_* APIs here because they call us.
+
 Status Tex::validate() const
 {
     if(m_Flags & TEX_UNDEFINED_FLAGS)
@@ -79 +81 @@
         WARN_RETURN(ERR::_3);
 
     // flags
-    // .. DXT value
-    const size_t dxt = m_Flags & TEX_DXT;
-    if(dxt != 0 && dxt != 1 && dxt != DXT1A && dxt != 3 && dxt != 5)
+    if ((!m_glType && !m_glInternalFormat) || !m_glFormat)
         WARN_RETURN(ERR::_4);
+
     // .. orientation
     const size_t orientation = m_Flags & TEX_ORIENTATION;
     if(orientation == (TEX_BOTTOM_UP|TEX_TOP_DOWN))
@@ -93 +94 @@
 
 #define CHECK_TEX(t) RETURN_STATUS_IF_ERR((t->validate()))
 
-
-// check if the given texture format is acceptable: 8bpp grey,
-// 24bpp color or 32bpp color+alpha (BGR / upside down are permitted).
-// basically, this is the "plain" format understood by all codecs and
-// tex_codec_plain_transform.
-Status tex_validate_plain_format(size_t bpp, size_t flags)
-{
-    const bool alpha   = (flags & TEX_ALPHA  ) != 0;
-    const bool grey    = (flags & TEX_GREY   ) != 0;
-    const bool dxt     = (flags & TEX_DXT    ) != 0;
-    const bool mipmaps = (flags & TEX_MIPMAPS) != 0;
-
-    if(dxt || mipmaps)
-        WARN_RETURN(ERR::TEX_FMT_INVALID);
-
-    // grey must be 8bpp without alpha, or it's invalid.
-    if(grey)
-    {
-        if(bpp == 8 && !alpha)
-            return INFO::OK;
-        WARN_RETURN(ERR::TEX_FMT_INVALID);
-    }
-
-    if(bpp == 24 && !alpha)
-        return INFO::OK;
-    if(bpp == 32 && alpha)
-        return INFO::OK;
-
-    WARN_RETURN(ERR::TEX_FMT_INVALID);
-}
-
-
 //-----------------------------------------------------------------------------
 // mipmaps
 //-----------------------------------------------------------------------------
 
-void tex_util_foreach_mipmap(size_t w, size_t h, size_t bpp, const u8* pixels, int levels_to_skip, size_t data_padding, MipmapCB cb, void* RESTRICT cbData)
+static Status tex_util_mipmap_level(const Tex* t, size_t level, size_t face, size_t &w, size_t &h, u8 *&mipmapData, size_t &mipmapDataSize)
 {
-    ENSURE(levels_to_skip >= 0 || levels_to_skip == TEX_BASE_LEVEL_ONLY);
+    ENSURE(level < t->m_numberOfMipmapLevels);
+    ENSURE(face < t->m_numberOfFaces);
 
-    size_t level_w = w, level_h = h;
-    const u8* level_data = pixels;
+    w = t->m_Width;
+    h = t->m_Height;
 
-    // we iterate through the loop (necessary to skip over image data),
-    // but do not actually call back until the requisite number of
-    // levels have been skipped (i.e. level == 0).
-    int level = (levels_to_skip == TEX_BASE_LEVEL_ONLY)? 0 : -levels_to_skip;
+    mipmapData = t->get_data();
 
-    // until at level 1x1:
-    for(;;)
+    for(size_t i = 0; i < level; i++)
     {
         // used to skip past this mip level in <data>
-        const size_t level_dataSize = (size_t)(round_up(level_w, data_padding) * round_up(level_h, data_padding) * bpp/8);
+        const size_t level_dataSize = t->m_numberOfFaces * w * h * (t->m_Bpp / 8);
 
-        if(level >= 0)
-            cb((size_t)level, level_w, level_h, level_data, level_dataSize, cbData);
+        mipmapData += level_dataSize;
 
-        level_data += level_dataSize;
-
-        // 1x1 reached - done
-        if(level_w == 1 && level_h == 1)
-            break;
-        level_w /= 2;
-        level_h /= 2;
+        w /= 2;
+        h /= 2;
         // if the texture is non-square, one of the dimensions will become
         // 0 before the other. to satisfy OpenGL's expectations, change it
         // back to 1.
-        if(level_w == 0) level_w = 1;
-        if(level_h == 0) level_h = 1;
-        level++;
+        if(w == 0) w = 1;
+        if(h == 0) h = 1;
+    }
 
-        // special case: no mipmaps, we were only supposed to call for
-        // the base level
-        if(levels_to_skip == TEX_BASE_LEVEL_ONLY)
-            break;
+    mipmapDataSize = w * h * (t->m_Bpp / 8);
+    mipmapData += face * mipmapDataSize;
+
+    return INFO::OK;
+}
+
+
+void tex_util_foreach_mipmap(const Tex *t, int levels_to_skip, MipmapCB cb, void* RESTRICT cbData)
+{
+    ENSURE(levels_to_skip >= 0 && size_t(levels_to_skip) < t->m_numberOfMipmapLevels);
+
+    size_t level_w, level_h;
+    u8* level_data;
+    size_t level_dataSize;
+    for (size_t level = levels_to_skip; level < t->m_numberOfMipmapLevels; level++) {
+        for (size_t face = 0; face < t->m_numberOfFaces; face++) {
+            if (t->mipmapsLevel(level, face, level_w, level_h, level_data, level_dataSize) < 0)
+                return;
+            cb(level - levels_to_skip, face, level_w, level_h, level_data, level_dataSize, cbData);
+        }
     }
 }
 
@@ -183 +159 @@
 };
 
 // uses 2x2 box filter
-static void create_level(size_t level, size_t level_w, size_t level_h, const u8* RESTRICT level_data, size_t level_dataSize, void* RESTRICT cbData)
+static void create_level(size_t level, size_t UNUSED(face), size_t level_w, size_t level_h, const u8* RESTRICT level_data, size_t level_dataSize, void* RESTRICT cbData)
 {
     CreateLevelData* cld = (CreateLevelData*)cbData;
     const size_t src_w = cld->prev_level_w;
@@ -250 +226 @@
 }
 
 
-static Status add_mipmaps(Tex* t, size_t w, size_t h, size_t bpp, void* newData, size_t dataSize)
+static Status add_mipmaps(Tex* t)
 {
+    ENSURE(t->m_glType);
     // this code assumes the image is of POT dimension; we don't
     // go to the trouble of implementing image scaling because
     // the only place this is used (ogl_tex_upload) requires POT anyway.
+    const size_t w = t->m_Width, h = t->m_Height, bpp = t->m_Bpp;
     if(!is_pow2(w) || !is_pow2(h))
         WARN_RETURN(ERR::TEX_INVALID_SIZE);
-    t->m_Flags |= TEX_MIPMAPS;  // must come before tex_img_size!
+
+    t->m_numberOfMipmapLevels = ceil_log2(std::max(t->m_Width, t->m_Height)) + 1;
     const size_t mipmap_size = t->img_size();
     shared_ptr<u8> mipmapData;
     AllocateAligned(mipmapData, mipmap_size);
-    CreateLevelData cld = { bpp/8, w, h, (const u8*)newData, dataSize };
-    tex_util_foreach_mipmap(w, h, bpp, mipmapData.get(), 0, 1, create_level, &cld);
+    CreateLevelData cld = { bpp/8, w, h, t->m_Data.get(), t->m_DataSize };
     t->m_Data = mipmapData;
     t->m_DataSize = mipmap_size;
     t->m_Ofs = 0;
-
+    tex_util_foreach_mipmap(t, 0, create_level, &cld);
     return INFO::OK;
 }
 
+Tex::Tex()
+{
+    m_glType = 0;
+    m_glFormat = 0;
+    m_glInternalFormat = 0;
+    m_numberOfMipmapLevels = 1;
+    m_numberOfFaces = 1;
+    m_mipmapsLevel = &tex_util_mipmap_level;
+}
+
+bool Tex::hasAlpha(size_t glFormat)
+{
+    switch (glFormat) {
+    case GL_ALPHA:
+    case GL_LUMINANCE_ALPHA:
+    case GL_RGBA:
+    case GL_BGRA_EXT:
+        return true;
+    }
+    return false;
+}
+
+size_t Tex::glFormatWithAlpha() const
+{
+    switch (m_glFormat) {
+    case GL_ALPHA:
+        return GL_ALPHA;
+    case GL_LUMINANCE:
+        return GL_LUMINANCE_ALPHA;
+    case GL_RGB:
+    case GL_RGBA:
+        return GL_RGBA;
+    case GL_BGR:
+    case GL_BGRA_EXT:
+        return GL_BGRA_EXT;
+    }
+    return 0;
+}
 
 //-----------------------------------------------------------------------------
 // pixel format conversion (transformation)
@@ -284 +300 @@
 // but is much easier to maintain than providing all<->all conversion paths.
 //
 // somewhat optimized (loops are hoisted, cache associativity accounted for)
-static Status plain_transform(Tex* t, size_t transforms)
-{
-TIMER_ACCRUE(tc_plain_transform);
 
-    // (this is also called directly instead of through ogl_tex, so
-    // we need to validate)
-    CHECK_TEX(t);
-
-    // extract texture info
+static void flipTexture(Tex* t)
+{
     const size_t w = t->m_Width, h = t->m_Height, bpp = t->m_Bpp;
-    const size_t flags = t->m_Flags;
     u8* const srcStorage = t->get_data();
-
-    // sanity checks (not errors, we just can't handle these cases)
-    // .. unknown transform
-    if(transforms & ~(TEX_BGR|TEX_ORIENTATION|TEX_MIPMAPS|TEX_ALPHA))
-        return INFO::TEX_CODEC_CANNOT_HANDLE;
-    // .. data is not in "plain" format
-    RETURN_STATUS_IF_ERR(tex_validate_plain_format(bpp, flags));
-    // .. nothing to do
-    if(!transforms)
-        return INFO::OK;
-
     const size_t srcSize = t->img_size();
-    size_t dstSize = srcSize;
-
-    if(transforms & TEX_ALPHA)
-    {
-        // add alpha channel
-        if(bpp == 24)
-        {
-            dstSize = (srcSize / 3) * 4;
-            t->m_Bpp = 32;
-        }
-        // remove alpha channel
-        else if(bpp == 32)
-        {
-            return INFO::TEX_CODEC_CANNOT_HANDLE;
-        }
-        // can't have alpha with grayscale
-        else
-        {
-            return INFO::TEX_CODEC_CANNOT_HANDLE;
-        }
-    }
-
-    // allocate copy of the image data.
-    // rationale: L1 cache is typically A2 => swapping in-place with a
-    // line buffer leads to thrashing. we'll assume the whole texture*2
-    // fits in cache, allocate a copy, and transfer directly from there.
-    //
-    // this is necessary even when not flipping because the initial data
-    // is read-only.
     shared_ptr<u8> dstStorage;
-    AllocateAligned(dstStorage, dstSize);
+    AllocateAligned(dstStorage, srcSize);
 
     // setup row source/destination pointers (simplifies outer loop)
     u8* dst = (u8*)dstStorage.get();
     const u8* src;
-    const size_t pitch = w * bpp/8; // source bpp (not necessarily dest bpp)
+    const size_t pitch = w * bpp / 8;   // source bpp (not necessarily dest bpp)
     // .. avoid y*pitch multiply in row loop; instead, add row_ofs.
     ssize_t row_ofs = (ssize_t)pitch;
 
-    // flipping rows (0,1,2 -> 2,1,0)
-    if(transforms & TEX_ORIENTATION)
+    src = (const u8*)srcStorage + srcSize - pitch;  // last row
+    row_ofs = -(ssize_t)pitch;
+    for(size_t y = 0; y < h; y++)
     {
-        src = (const u8*)srcStorage+srcSize-pitch;  // last row
-        row_ofs = -(ssize_t)pitch;
-    }
-    // adding/removing alpha channel (can't convert in-place)
-    else if(transforms & TEX_ALPHA)
-    {
-        src = (const u8*)srcStorage;
-    }
-    // do other transforms in-place
-    else
-    {
-        src = (const u8*)dstStorage.get();
-        memcpy(dstStorage.get(), srcStorage, srcSize);
+        memcpy(dst, src, pitch);
+        dst += pitch;
+        src += row_ofs;
     }
 
-    // no conversion necessary
-    if(!(transforms & (TEX_BGR | TEX_ALPHA)))
-    {
-        if(src != dst)  // avoid overlapping memcpy if not flipping rows
-        {
-            for(size_t y = 0; y < h; y++)
-            {
-                memcpy(dst, src, pitch);
-                dst += pitch;
-                src += row_ofs;
-            }
-        }
-    }
-    // RGB -> BGRA, BGR -> RGBA
-    else if(bpp == 24 && (transforms & TEX_ALPHA) && (transforms & TEX_BGR))
-    {
-        for(size_t y = 0; y < h; y++)
-        {
-            for(size_t x = 0; x < w; x++)
-            {
-                // need temporaries in case src == dst (i.e. not flipping)
-                const u8 b = src[0], g = src[1], r = src[2];
-                dst[0] = r; dst[1] = g; dst[2] = b; dst[3] = 0xFF;
-                dst += 4;
-                src += 3;
-            }
-            src += row_ofs - pitch; // flip? previous row : stay
-        }
-    }
-    // RGB -> RGBA, BGR -> BGRA
-    else if(bpp == 24 && (transforms & TEX_ALPHA) && !(transforms & TEX_BGR))
-    {
-        for(size_t y = 0; y < h; y++)
-        {
-            for(size_t x = 0; x < w; x++)
-            {
-                // need temporaries in case src == dst (i.e. not flipping)
-                const u8 r = src[0], g = src[1], b = src[2];
-                dst[0] = r; dst[1] = g; dst[2] = b; dst[3] = 0xFF;
-                dst += 4;
-                src += 3;
-            }
-            src += row_ofs - pitch; // flip? previous row : stay
-        }
-    }
-    // RGB <-> BGR
-    else if(bpp == 24 && !(transforms & TEX_ALPHA))
+    t->m_Data = dstStorage;
+    t->m_Ofs = 0;
+}
+
+static Status rgb2brg(Tex* t)
+{
+    // extract texture info
+    const size_t w = t->m_Width, h = t->m_Height;
+    u8* const srcStorage = t->get_data();
+    const size_t srcSize = t->img_size();
+    size_t dstSize = srcSize;
+    shared_ptr<u8> dstStorage;
+    AllocateAligned(dstStorage, dstSize);
+
+    // setup row source/destination pointers (simplifies outer loop)
+    u8* dst = (u8*)dstStorage.get();
+    const u8* src = (const u8*)dstStorage.get();
+    memcpy(dst, srcStorage, srcSize);
+
+    if(t->m_Bpp == 24)
     {
         for(size_t y = 0; y < h; y++)
         {
@@ -423 +356 @@
                 dst += 3;
                 src += 3;
             }
-            src += row_ofs - pitch; // flip? previous row : stay
         }
     }
     // RGBA <-> BGRA
-    else if(bpp == 32 && !(transforms & TEX_ALPHA))
+    else if(t->m_Bpp == 32)
     {
         for(size_t y = 0; y < h; y++)
         {
@@ -439 +371 @@
                 dst += 4;
                 src += 4;
             }
-            src += row_ofs - pitch; // flip? previous row : stay
         }
     }
     else
@@ -451 +382 @@
     t->m_Data = dstStorage;
     t->m_DataSize = dstSize;
     t->m_Ofs = 0;
+    return INFO::OK;
+}
 
-    if(!(t->m_Flags & TEX_MIPMAPS) && transforms & TEX_MIPMAPS)
-        RETURN_STATUS_IF_ERR(add_mipmaps(t, w, h, bpp, dstStorage.get(), dstSize));
+static Status rgb2rgba(Tex *t)
+{
+    // extract texture info
+    const size_t w = t->m_Width, h = t->m_Height;
+    u8* const srcStorage = t->get_data();
+    const size_t srcSize = t->img_size();
+    size_t dstSize = (srcSize / 3) * 4;
+    shared_ptr<u8> dstStorage;
+    AllocateAligned(dstStorage, dstSize);
 
-    CHECK_TEX(t);
+    // setup row source/destination pointers (simplifies outer loop)
+    u8* dst = (u8*)dstStorage.get();
+    const u8* src = (const u8*)srcStorage;
+
+    for(size_t y = 0; y < h; y++)
+    {
+        for(size_t x = 0; x < w; x++)
+        {
+            // need temporaries in case src == dst (i.e. not flipping)
+            const u8 r = src[0], g = src[1], b = src[2];
+            dst[0] = r; dst[1] = g; dst[2] = b; dst[3] = 0xFF;
+            dst += 4;
+            src += 3;
+        }
+    }
+
+    t->m_Data = dstStorage;
+    t->m_DataSize = dstSize;
+    t->m_Bpp = 32;
+    t->m_Ofs = 0;
     return INFO::OK;
 }
 
+static Status rgb2bgra(Tex *t)
+{
+    // extract texture info
+    const size_t w = t->m_Width, h = t->m_Height;
+    u8* const srcStorage = t->get_data();
+    const size_t srcSize = t->img_size();
+    size_t dstSize = (srcSize / 3) * 4;
+    shared_ptr<u8> dstStorage;
+    AllocateAligned(dstStorage, dstSize);
 
-TIMER_ADD_CLIENT(tc_transform);
+    // setup row source/destination pointers (simplifies outer loop)
+    u8* dst = (u8*)dstStorage.get();
+    const u8* src = (const u8*)srcStorage;
 
-// change the pixel format by flipping the state of all TEX_* flags
-// that are set in transforms.
-Status Tex::transform(size_t transforms)
+    for(size_t y = 0; y < h; y++)
+    {
+        for(size_t x = 0; x < w; x++)
+        {
+            // need temporaries in case src == dst (i.e. not flipping)
+            const u8 r = src[0], g = src[1], b = src[2];
+            dst[0] = b; dst[1] = g; dst[2] = r; dst[3] = 0xFF;
+            dst += 4;
+            src += 3;
+        }
+    }
+
+    t->m_Data = dstStorage;
+    t->m_DataSize = dstSize;
+    t->m_Bpp = 32;
+    t->m_Ofs = 0;
+    return INFO::OK;
+}
+
+static Status bgr2bgra(Tex *t)
 {
-    TIMER_ACCRUE(tc_transform);
-    CHECK_TEX(this);
+    // extract texture info
+    const size_t w = t->m_Width, h = t->m_Height;
+    u8* const srcStorage = t->get_data();
+    const size_t srcSize = t->img_size();
+    size_t dstSize = (srcSize / 3) * 4;
+    shared_ptr<u8> dstStorage;
+    AllocateAligned(dstStorage, dstSize);
+
+    // setup row source/destination pointers (simplifies outer loop)
+    u8* dst = (u8*)dstStorage.get();
+    const u8* src = (const u8*)srcStorage;
+
+    for(size_t y = 0; y < h; y++)
+    {
+        for(size_t x = 0; x < w; x++)
+        {
+            // need temporaries in case src == dst (i.e. not flipping)
+            const u8 b = src[0], g = src[1], r = src[2];
+            dst[0] = b; dst[1] = g; dst[2] = r; dst[3] = 0xFF;
+            dst += 4;
+            src += 3;
+        }
+    }
+
+    t->m_Data = dstStorage;
+    t->m_DataSize = dstSize;
+    t->m_Bpp = 32;
+    t->m_Ofs = 0;
+    return INFO::OK;
+}
 
-    const size_t target_flags = m_Flags ^ transforms;
-    size_t remaining_transforms;
-    for(;;)
+static Status bgr2rgba(Tex *t)
+{
+    // extract texture info
+    const size_t w = t->m_Width, h = t->m_Height;
+    u8* const srcStorage = t->get_data();
+    const size_t srcSize = t->img_size();
+    size_t dstSize = (srcSize / 3) * 4;
+    shared_ptr<u8> dstStorage;
+    AllocateAligned(dstStorage, dstSize);
+
+    // setup row source/destination pointers (simplifies outer loop)
+    u8* dst = (u8*)dstStorage.get();
+    const u8* src = (const u8*)srcStorage;
+
+    for(size_t y = 0; y < h; y++)
     {
-        remaining_transforms = target_flags ^ m_Flags;
-        // we're finished (all required transforms have been done)
-        if(remaining_transforms == 0)
-            return INFO::OK;
+        for(size_t x = 0; x < w; x++)
+        {
+            // need temporaries in case src == dst (i.e. not flipping)
+            const u8 b = src[0], g = src[1], r = src[2];
+            dst[0] = r; dst[1] = g; dst[2] = b; dst[3] = 0xFF;
+            dst += 4;
+            src += 3;
+        }
+    }
+
+    t->m_Data = dstStorage;
+    t->m_DataSize = dstSize;
+    t->m_Bpp = 32;
+    t->m_Ofs = 0;
+    return INFO::OK;
+}
+
+static Status plain_transform(Tex* t, size_t glFormat, int transformFlags)
+{
+TIMER_ACCRUE(tc_plain_transform);
+    if (t->m_glFormat == glFormat && !transformFlags)
+        return INFO::OK;
 
-        Status ret = tex_codec_transform(this, remaining_transforms);
-        if(ret != INFO::OK)
+    if (transformFlags & TEX_ORIENTATION)
+        flipTexture(t);
+
+    if (t->m_glFormat != glFormat) {
+        switch (t->m_glFormat) {
+        case GL_RGB:
+            switch (glFormat) {
+            case GL_BGR:
+                RETURN_STATUS_IF_ERR(rgb2rgba(t));
+                break;
+            case GL_RGBA:
+                RETURN_STATUS_IF_ERR(rgb2rgba(t));
+                break;
+            case GL_BGRA_EXT:
+                RETURN_STATUS_IF_ERR(rgb2bgra(t));
+                break;
+            }
+            break;
+        case GL_BGR:
+            switch (glFormat) {
+            case GL_RGB:
+                RETURN_STATUS_IF_ERR(rgb2brg(t));
+                break;
+            case GL_BGRA_EXT:
+                RETURN_STATUS_IF_ERR(bgr2bgra(t));
+                break;
+            case GL_RGBA:
+                RETURN_STATUS_IF_ERR(bgr2rgba(t));
+                break;
+            default:
+                return INFO::TEX_CODEC_CANNOT_HANDLE;
+            }
             break;
+
+        case GL_RGBA:
+            switch (glFormat) {
+            case GL_BGRA_EXT:
+                RETURN_STATUS_IF_ERR(rgb2brg(t));
+                break;
+            default:
+                return INFO::TEX_CODEC_CANNOT_HANDLE;
+            }
+            break;
+
+        case GL_BGRA_EXT:
+            switch (glFormat) {
+            case GL_RGBA:
+                RETURN_STATUS_IF_ERR(rgb2brg(t));
+                break;
+            default:
+                return INFO::TEX_CODEC_CANNOT_HANDLE;
+            }
+            break;
+
+        default:
+            return INFO::TEX_CODEC_CANNOT_HANDLE;
+        }
+
+        t->m_glInternalFormat = t->m_glFormat = glFormat;
     }
 
-    // last chance
-    RETURN_STATUS_IF_ERR(plain_transform(this, remaining_transforms));
+    if (transformFlags & TEX_MIPMAPS) {
+        if (t->m_numberOfMipmapLevels > 1)
+            t->m_numberOfMipmapLevels = 1;
+        else
+            RETURN_STATUS_IF_ERR(add_mipmaps(t));
+    }
+
+    t->m_mipmapsLevel = 0;
+
+    CHECK_TEX(t);
     return INFO::OK;
 }
 
 
-// change the pixel format to the new format specified by <new_flags>.
-// (note: this is equivalent to transform(t, t->flags^new_flags).
-Status Tex::transform_to(size_t new_flags)
+TIMER_ADD_CLIENT(tc_transform);
+
+
+Status Tex::transform(size_t glFormat, int transformFlags)
 {
-    // transform takes care of validating
-    const size_t transforms = m_Flags ^ new_flags;
-    return transform(transforms);
-}
+    TIMER_ACCRUE(tc_transform);
+    CHECK_TEX(this);
+
+    if (!glFormat)
+        return INFO::TEX_CODEC_CANNOT_HANDLE;
 
+    if (m_glType) // already uncompressed
+        return plain_transform(this, glFormat, transformFlags);
+
+    return tex_codec_transform(this, glFormat, transformFlags);
+}
 
 //-----------------------------------------------------------------------------
 // image orientation
@@ -528 +644 @@
     {
         // flip image if necessary
         size_t transforms = orientation ^ global_orientation;
-        WARN_IF_ERR(plain_transform(t, transforms));
+        WARN_IF_ERR(plain_transform(t, t->m_glFormat, transforms));
     }
 
     // indicate image is at global orientation. this is still done even
@@ -590 +706 @@
 //
 // we need only add bookkeeping information and "wrap" it in
 // our Tex struct, hence the name.
-Status Tex::wrap(size_t w, size_t h, size_t bpp, size_t flags, const shared_ptr<u8>& data, size_t ofs)
+Status Tex::wrap(size_t glFormat, size_t w, size_t h, size_t bpp, size_t flags, const shared_ptr<u8>& data, size_t ofs)
 {
     m_Width    = w;
     m_Height   = h;
@@ -599 +715 @@
     m_Data     = data;
     m_DataSize = ofs + w*h*bpp/8;
     m_Ofs      = ofs;
+    m_glFormat = glFormat;
+    m_glType   = GL_UNSIGNED_BYTE;
+    m_glInternalFormat = glFormat;
+    m_numberOfFaces = 1;
+    m_numberOfMipmapLevels = 1;
 
     CHECK_TEX(this);
     return INFO::OK;
@@ -626 +747 @@
 
 // returns a pointer to the image data (pixels), taking into account any
 // header(s) that may come before it.
-u8* Tex::get_data()
+u8* Tex::get_data() const
 {
     // (can't use normal CHECK_TEX due to u8* return value)
     WARN_IF_ERR(validate());
@@ -641 +762 @@
 u32 Tex::get_average_colour() const
 {
     // require mipmaps
-    if(!(m_Flags & TEX_MIPMAPS))
+    if(m_numberOfMipmapLevels == 1)
         return 0;
 
-    // find the total size of image data
-    size_t size = img_size();
-
-    // compute the size of the last (1x1) mipmap level
-    const size_t data_padding = (m_Flags & TEX_DXT)? 4 : 1;
-    size_t last_level_size = (size_t)(data_padding * data_padding * m_Bpp/8);
-
-    // construct a new texture based on the current one,
-    // but only include the last mipmap level
-    // do this so that we can use the general conversion methods for the pixel data
     Tex basetex = *this;
-    uint8_t *data = new uint8_t[last_level_size];
-    memcpy(data, m_Data.get() + m_Ofs + size - last_level_size, last_level_size);
-    shared_ptr<uint8_t> sdata(data, ArrayDeleter());
-    basetex.wrap(1, 1, m_Bpp, m_Flags, sdata, 0);
 
     // convert to BGRA
-    WARN_IF_ERR(basetex.transform_to(TEX_BGR | TEX_ALPHA));
+    if (INFO::OK != basetex.transform(GL_BGRA_EXT))
+        return 0;
+
+    size_t w, h, last_level_size;
+    u8* levelData = 0;
+    WARN_IF_ERR(basetex.mipmapsLevel(m_numberOfMipmapLevels - 1, m_numberOfFaces -1, w, h, levelData, last_level_size));
 
     // extract components into u32
-    ENSURE(basetex.m_DataSize >= basetex.m_Ofs+4);
-    u8 b = basetex.m_Data.get()[basetex.m_Ofs];
-    u8 g = basetex.m_Data.get()[basetex.m_Ofs+1];
-    u8 r = basetex.m_Data.get()[basetex.m_Ofs+2];
-    u8 a = basetex.m_Data.get()[basetex.m_Ofs+3];
+    u8 b = levelData[0];
+    u8 g = levelData[1];
+    u8 r = levelData[2];
+    u8 a = levelData[3];
     return b + (g << 8) + (r << 16) + (a << 24);
 }
 
 
-static void add_level_size(size_t UNUSED(level), size_t UNUSED(level_w), size_t UNUSED(level_h), const u8* RESTRICT UNUSED(level_data), size_t level_dataSize, void* RESTRICT cbData)
+static void add_level_size(size_t UNUSED(level), size_t UNUSED(face), size_t UNUSED(level_w), size_t UNUSED(level_h), const u8* RESTRICT UNUSED(level_data), size_t level_dataSize, void* RESTRICT cbData)
 {
     size_t* ptotal_size = (size_t*)cbData;
     *ptotal_size += level_dataSize;
@@ -686 +797 @@
 {
     // (can't use normal CHECK_TEX due to size_t return value)
     WARN_IF_ERR(validate());
-
-    const int levels_to_skip = (m_Flags & TEX_MIPMAPS)? 0 : TEX_BASE_LEVEL_ONLY;
-    const size_t data_padding = (m_Flags & TEX_DXT)? 4 : 1;
     size_t out_size = 0;
-    tex_util_foreach_mipmap(m_Width, m_Height, m_Bpp, 0, levels_to_skip, data_padding, add_level_size, &out_size);
+    tex_util_foreach_mipmap(this, 0, add_level_size, &out_size);
     return out_size;
 }
 
+Status Tex::mipmapsLevel(size_t level, size_t face, size_t &width, size_t &height, u8 *&mipmapData, size_t &mipmapDataSize) const
+{
+    MipmapLevel mipmapLevel = m_mipmapsLevel ? m_mipmapsLevel : &tex_util_mipmap_level;
+    return mipmapLevel(this, level, face, width, height, mipmapData, mipmapDataSize);
+}
+
 
 // return the minimum header size (i.e. offset to pixel data) of the
 // file format indicated by <fn>'s extension (that is all it need contain:
@@ -752 +866 @@
 Status Tex::encode(const OsPath& extension, DynArray* da)
 {
     CHECK_TEX(this);
-    WARN_RETURN_STATUS_IF_ERR(tex_validate_plain_format(m_Bpp, m_Flags));
 
     // we could be clever here and avoid the extra alloc if our current
     // memory block ensued from the same kind of texture file. this is

source/lib/tex/tex.h

@@ -57 +57 @@
 priority is minimizing load time), prefer file formats that are
 close to the final pixel format.
 
-1) one of the exceptions is S3TC compressed textures. glCompressedTexImage2D
+1) one of the exceptions is compressed textures. glCompressedTexImage2D
    requires these be passed in their original format; decompressing would be
    counterproductive. In this and similar cases, TexFlags indicates such
    deviations from the plain format.
@@ -109 +109 @@
 #include "lib/file/vfs/vfs_path.h"
 #include "lib/allocators/dynarray.h"
 
-
 namespace ERR
 {
     const Status TEX_UNKNOWN_FORMAT      = -120100;
@@ -140 +139 @@
 enum TexFlags
 {
     /**
-     * flags & TEX_DXT is a field indicating compression.
-     * if 0, the texture is uncompressed;
-     * otherwise, it holds the S3TC type: 1,3,5 or DXT1A.
-     * not converted by default - glCompressedTexImage2D receives
-     * the compressed data.
-     **/
-    TEX_DXT = 0x7,   // mask
-
-    /**
-     * we need a special value for DXT1a to avoid having to consider
-     * flags & TEX_ALPHA to determine S3TC type.
-     * the value is arbitrary; do not rely on it!
-     **/
-    DXT1A = 7,
-
-    /**
-     * indicates B and R pixel components are exchanged. depending on
-     * flags & TEX_ALPHA or bpp, this means either BGR or BGRA.
-     * not converted by default - it's an acceptable format for OpenGL.
-     **/
-    TEX_BGR = 0x08,
-
-    /**
-     * indicates the image contains an alpha channel. this is set for
-     * your convenience - there are many formats containing alpha and
-     * divining this information from them is hard.
-     * (conversion is not applicable here)
-     **/
-    TEX_ALPHA = 0x10,
-
-    /**
-     * indicates the image is 8bpp greyscale. this is required to
-     * differentiate between alpha-only and intensity formats.
-     * not converted by default - it's an acceptable format for OpenGL.
-     **/
-    TEX_GREY = 0x20,
-
-    /**
      * flags & TEX_ORIENTATION is a field indicating orientation,
      * i.e. in what order the pixel rows are stored.
      *
@@ -201 +162 @@
     TEX_UNDEFINED_FLAGS = ~0x1FF
 };
 
+struct Tex;
+
+/**
+ * function pointer used to get each mipmap level/face data.
+ *
+ * The TexCodec should set Tex::m_mipmapLevel to their own function
+ *
+ * @param Tex - the texture struct
+ * @param level - searched level [0..t->m_numberOfMipmapLevels]
+ * @param face - searched face [0..m_numberOfFaces]
+ * @param width - sets the width of the level
+ * @param height - sets the height
+ * @param mipmapData - level & face data
+ * @param mipmapDataSize - level size
+ **/
+typedef Status (*MipmapLevel)(const Tex* t, size_t level, size_t face, size_t &width, size_t &height, u8 *&mipmapData, size_t &mipmapDataSize);
+
+class ITexCodec;
 /**
  * stores all data describing an image.
  * we try to minimize size, since this is stored in OglTex resources
@@ -232 +211 @@
     /// see TexFlags and "Format Conversion" in docs.
     size_t m_Flags;
 
+    /// Set only for uncompressed textures.
+    size_t m_glType;
+
+    /// Set for both, compressed and uncompressed textures.
+    size_t m_glFormat;
+
+    /// Set only for compressed textures
+    size_t m_glInternalFormat;
+
+    ///Possible values 1 or 6
+    size_t m_numberOfFaces;
+
+    /// numberOfMipmapLevels must equal 1 for non-mipmapped textures.
+    /// If numberOfMipmapLevels equals 0, it indicates that a full
+    /// mipmap pyramid should be generated from level 0 at load time
+    /// (this is usually not allowed for compressed formats).
+    size_t m_numberOfMipmapLevels;
+
+    MipmapLevel m_mipmapsLevel; // set it to 0 for default uncompressed mipmap level
+
+    Tex();
+
     ~Tex()
     {
         free();
@@ -297 +298 @@
      * @param ofs
      * @return Status
      **/
-    Status wrap(size_t w, size_t h, size_t bpp, size_t flags, const shared_ptr<u8>& data, size_t ofs);
+    Status wrap(size_t glFormat, size_t w, size_t h, size_t bpp, size_t flags, const shared_ptr<u8>& data, size_t ofs);
     
     //
     // modify image
@@ -305 +306 @@
 
     /**
      * Change the pixel format.
-     *
-     * @param transforms TexFlags that are to be flipped.
+     * @param glFormat new pixel format
+     * @param transforms ORed TransformFlags
      * @return Status
      **/
-    Status transform(size_t transforms);
+    Status transform(size_t glFormat, int transformFlags = 0);
 
-    /**
-     * Change the pixel format (2nd version)
-     * (note: this is equivalent to Tex::transform(t, t-\>flags^new_flags).
-     *
-     * @param new_flags desired new value of TexFlags.
-     * @return Status
-     **/
-    Status transform_to(size_t new_flags);
 
     //
     // return image information
@@ -330 +323 @@
      *
      * @return pointer to data returned by mem_get_ptr (holds reference)!
      **/
-    u8* get_data();
+    u8* get_data() const;
 
     /**
      * return the ARGB value of the 1x1 mipmap level of the texture.
@@ -348 +341 @@
      **/
     size_t img_size() const;
 
+    /**
+     * mothod used to get each mipmap level/face data.
+     *
+     * @param level - searched level [0..t->m_numberOfMipmapLevels]
+     * @param face - searched face [0..m_numberOfFaces]
+     * @param width - sets the width of the level
+     * @param height - sets the height
+     * @param mipmapData - level & face data
+     * @param mipmapDataSize - level size
+     *
+     * @return Status
+     **/
+    Status mipmapsLevel(size_t level, size_t face, size_t &width, size_t &height, u8 *&mipmapData, size_t &mipmapDataSize) const;
+
+    static bool hasAlpha(size_t glFormat);
+    inline bool hasAlpha() const { return hasAlpha(m_glFormat); }
+    size_t glFormatWithAlpha() const;
 };
 
 
@@ -359 +369 @@
  **/
 extern void tex_set_global_orientation(int orientation);
 
-
-/**
- * special value for levels_to_skip: the callback will only be called
- * for the base mipmap level (i.e. 100%)
- **/
-const int TEX_BASE_LEVEL_ONLY = -1;
-
 /**
  * callback function for each mipmap level.
  *
  * @param level number; 0 for base level (i.e. 100%), or the first one
  * in case some were skipped.
+ * @param face number; 0 for base face
  * @param level_w, level_h pixel dimensions (powers of 2, never 0)
  * @param level_data the level's texels
  * @param level_data_size [bytes]
  * @param cbData passed through from tex_util_foreach_mipmap.
  **/
-typedef void (*MipmapCB)(size_t level, size_t level_w, size_t level_h, const u8* RESTRICT level_data, size_t level_data_size, void* RESTRICT cbData);
+typedef void (*MipmapCB)(size_t level, size_t face, size_t level_w, size_t level_h, const u8* RESTRICT level_data, size_t level_data_size, void* RESTRICT cbData);
 
 /**
  * for a series of mipmaps stored from base to highest, call back for
@@ -389 +393 @@
  *        TEX_BASE_LEVEL_ONLY to only call back for the base image.
  *        Rationale: this avoids needing to special case for images with or
  *        without mipmaps.
- * @param data_padding Minimum pixel dimensions of mipmap levels.
- *        This is used in S3TC images, where each level is actually stored in
- *        4x4 blocks. usually 1 to indicate levels are consecutive.
  * @param cb MipmapCB to call.
  * @param cbData Extra data to pass to cb.
  **/
-extern void tex_util_foreach_mipmap(size_t w, size_t h, size_t bpp, const u8* data, int levels_to_skip, size_t data_padding, MipmapCB cb, void* RESTRICT cbData);
-
+extern void tex_util_foreach_mipmap(const Tex *t, int levels_to_skip, MipmapCB cb, void* RESTRICT cbData);
 
 //
 // image writing

source/lib/tex/tex_bmp.cpp

@@ -27 +27 @@
 #include "precompiled.h"
 
 #include "lib/byte_order.h"
+#include "lib/ogl.h"
 #include "tex_codec.h"
 
 #pragma pack(push, 1)
@@ -60 +61 @@
 #define BI_RGB 0        // biCompression
 
 
-Status TexCodecBmp::transform(Tex* UNUSED(t), size_t UNUSED(transforms)) const
+Status TexCodecBmp::transform(Tex* UNUSED(t), size_t UNUSED(glFormat), int UNUSED(flags)) const
 {
     return INFO::TEX_CODEC_CANNOT_HANDLE;
 }
@@ -107 +108 @@
 
     size_t flags = 0;
     flags |= (h_ < 0)? TEX_TOP_DOWN : TEX_BOTTOM_UP;
-    if(bpp > 16)
-        flags |= TEX_BGR;
-    if(bpp == 32)
-        flags |= TEX_ALPHA;
+    switch (bpp) {
+    case 8:
+        t->m_glFormat = GL_ALPHA;
+        break;
+    case 16:
+        t->m_glFormat = GL_LUMINANCE_ALPHA;
+        break;
+    case 24:
+        t->m_glFormat = GL_BGR;
+        break;
+    case 32:
+        t->m_glFormat = GL_BGRA_EXT;
+        break;
+    default:
+        break;
+    }
 
     // sanity checks
     if(compress != BI_RGB)
         WARN_RETURN(ERR::TEX_COMPRESSED);
 
+    t->m_glType = GL_UNSIGNED_BYTE;
     t->m_Width  = w;
     t->m_Height = h;
     t->m_Bpp    = bpp;
     t->m_Flags  = flags;
+    t->m_glInternalFormat = t->m_glFormat;
     return INFO::OK;
 }
 
@@ -131 +146 @@
     const size_t file_size = hdr_size + img_size;
     const i32 h = (t->m_Flags & TEX_TOP_DOWN)? -(i32)t->m_Height : (i32)t->m_Height;
 
-    size_t transforms = t->m_Flags;
-    transforms &= ~TEX_ORIENTATION; // no flip needed - we can set top-down bit.
-    transforms ^= TEX_BGR;          // BMP is native BGR.
-
     const BmpHeader hdr =
     {
         // BITMAPFILEHEADER
@@ -153 +164 @@
         (u32)img_size,      // biSizeImage
         0, 0, 0, 0          // unused (bi?PelsPerMeter, biClr*)
     };
-    return tex_codec_write(t, transforms, &hdr, hdr_size, da);
+    return tex_codec_write(t, (t->hasAlpha() ? GL_BGRA_EXT : GL_BGR), 0, &hdr, hdr_size, da);
 }

source/lib/tex/tex_codec.cpp

@@ -31 +31 @@
 #include <stdlib.h>
 
 #include "lib/allocators/shared_ptr.h" // ArrayDeleter
+#include "lib/ogl.h"
 #include "tex.h"
 
 // Statically allocate all of the codecs...
@@ -39 +40 @@
 TexCodecJpg JpgCodec;
 TexCodecTga TgaCodec;
 TexCodecBmp BmpCodec;
+TexCodecKtx KtxCodec;
+
 // Codecs will be searched in this order
 static const ITexCodec *codecs[] = {(ITexCodec *)&DdsCodec, (ITexCodec *)&PngCodec,
-    (ITexCodec *)&JpgCodec, (ITexCodec *)&TgaCodec, (ITexCodec *)&BmpCodec};
+    (ITexCodec *)&JpgCodec, (ITexCodec *)&TgaCodec, (ITexCodec *)&BmpCodec,
+    (ITexCodec *)&KtxCodec};
 static const int codecs_len = sizeof(codecs) / sizeof(ITexCodec*);
 
 // find codec that recognizes the desired output file extension,
@@ -82 +86 @@
     WARN_RETURN(ERR::TEX_UNKNOWN_FORMAT);
 }
 
-Status tex_codec_transform(Tex* t, size_t transforms)
+Status tex_codec_transform(Tex* t, size_t glFormat, int flags)
 {
     Status ret = INFO::TEX_CODEC_CANNOT_HANDLE;
 
     // find codec that understands the data, and transform
     for(int i = 0; i < codecs_len; ++i)
     {
-        Status err = codecs[i]->transform(t, transforms);
+        Status err = codecs[i]->transform(t, glFormat, flags);
         // success
         if(err == INFO::OK)
             return INFO::OK;
@@ -140 +144 @@
 }
 
 
-Status tex_codec_write(Tex* t, size_t transforms, const void* hdr, size_t hdr_size, DynArray* da)
+Status tex_codec_write(Tex* t, size_t glFormat, int flags, const void* hdr, size_t hdr_size, DynArray* da)
 {
-    RETURN_STATUS_IF_ERR(t->transform(transforms));
+    RETURN_STATUS_IF_ERR(t->transform(glFormat, flags));
 
     void* img_data = t->get_data(); const size_t img_size = t->img_size();
     RETURN_STATUS_IF_ERR(da_append(da, hdr, hdr_size));

source/lib/tex/tex_codec.h

@@ -69 +69 @@
      * transform the texture's pixel format.
      *
      * @param t texture object
-     * @param transforms: OR-ed combination of TEX_* flags that are to
-     * be changed. note: the codec needs only handle situations specific
-     * to its format; generic pixel format transforms are handled by
-     * the caller.
+     * @param glFormat, new (uncompressed) pixel format (GL_ALPHA, GL_RGB, GL_RGBA, GL_LUMINANCE, etc.)
+     * @param filp - true if the image will be flipped vertically
      **/
-    virtual Status transform(Tex* t, size_t transforms) const = 0;
+    virtual Status transform(Tex* t, size_t glFormat, int flags) const = 0;
 
     /**
      * indicate if the data appears to be an instance of this codec's header,
@@ -121 +119 @@
 public:
     virtual Status decode(u8* data, size_t size, Tex* RESTRICT t) const;
     virtual Status encode(Tex* RESTRICT t, DynArray* RESTRICT da) const;
-    virtual Status transform(Tex* t, size_t transforms) const;
+    virtual Status transform(Tex* t, size_t glFormat, int flags) const;
     virtual bool is_hdr(const u8* file) const;
     virtual bool is_ext(const OsPath& extension) const;
     virtual size_t hdr_size(const u8* file) const;
     virtual const wchar_t* get_name() const {
         static const wchar_t *name = L"png";
         return name;
-    };
+    }
 };
 
 class TexCodecJpg:ITexCodec {
 public:
     virtual Status decode(u8* data, size_t size, Tex* RESTRICT t) const;
     virtual Status encode(Tex* RESTRICT t, DynArray* RESTRICT da) const;
-    virtual Status transform(Tex* t, size_t transforms) const;
+    virtual Status transform(Tex* t, size_t glFormat, int flags) const;
     virtual bool is_hdr(const u8* file) const;
     virtual bool is_ext(const OsPath& extension) const;
     virtual size_t hdr_size(const u8* file) const;
     virtual const wchar_t* get_name() const {
         static const wchar_t *name = L"jpg";
         return name;
-    };
+    }
 };
 
 class TexCodecDds:ITexCodec {
 public:
     virtual Status decode(u8* data, size_t size, Tex* RESTRICT t) const;
     virtual Status encode(Tex* RESTRICT t, DynArray* RESTRICT da) const;
-    virtual Status transform(Tex* t, size_t transforms) const;
+    virtual Status transform(Tex* t, size_t glFormat, int flags) const;
     virtual bool is_hdr(const u8* file) const;
     virtual bool is_ext(const OsPath& extension) const;
     virtual size_t hdr_size(const u8* file) const;
     virtual const wchar_t* get_name() const {
         static const wchar_t *name = L"dds";
         return name;
-    };
+    }
 };
 
 class TexCodecTga:ITexCodec {
 public:
     virtual Status decode(u8* data, size_t size, Tex* RESTRICT t) const;
     virtual Status encode(Tex* RESTRICT t, DynArray* RESTRICT da) const;
-    virtual Status transform(Tex* t, size_t transforms) const;
+    virtual Status transform(Tex* t, size_t glFormat, int flags) const;
     virtual bool is_hdr(const u8* file) const;
     virtual bool is_ext(const OsPath& extension) const;
     virtual size_t hdr_size(const u8* file) const;
     virtual const wchar_t* get_name() const {
         static const wchar_t *name = L"tga";
         return name;
-    };
+    }
 };
 
 class TexCodecBmp:ITexCodec {
 public:
     virtual Status decode(u8* data, size_t size, Tex* RESTRICT t) const;
     virtual Status encode(Tex* RESTRICT t, DynArray* RESTRICT da) const;
-    virtual Status transform(Tex* t, size_t transforms) const;
+    virtual Status transform(Tex* t, size_t glFormat, int flags) const;
     virtual bool is_hdr(const u8* file) const;
     virtual bool is_ext(const OsPath& extension) const;
     virtual size_t hdr_size(const u8* file) const;
     virtual const wchar_t* get_name() const {
         static const wchar_t *name = L"bmp";
         return name;
-    };
+    }
+};
+
+class TexCodecKtx:ITexCodec {
+public:
+    virtual Status decode(u8* data, size_t size, Tex* RESTRICT t) const;
+    virtual Status encode(Tex* RESTRICT t, DynArray* RESTRICT da) const;
+    virtual Status transform(Tex* t, size_t glFormat, int flags) const;
+    virtual bool is_hdr(const u8* file) const;
+    virtual bool is_ext(const OsPath& extension) const;
+    virtual size_t hdr_size(const u8* file) const;
+    virtual const wchar_t* get_name() const {
+        static const wchar_t *name = L"ktx";
+        return name;
+    }
 };
 
 /**
@@ -215 +227 @@
  * tries each codec's transform method once, or until one indicates success.
  *
  * @param t texture object
- * @param transforms: OR-ed combination of TEX_* flags that are to
+ * @param transforms: OR-ed combination of TransformFlags that are to
  * be changed.
  * @return Status
  **/
-extern Status tex_codec_transform(Tex* t, size_t transforms);
+extern Status tex_codec_transform(Tex* t, size_t glFormat, int flags);
 
 /**
  * allocate an array of row pointers that point into the given texture data.
@@ -253 +265 @@
  * @param da output data array (will be expanded as necessary)
  * @return Status
  **/
-extern Status tex_codec_write(Tex* t, size_t transforms, const void* hdr, size_t hdr_size, DynArray* da);
+extern Status tex_codec_write(Tex* t, size_t glFormat, int flags, const void* hdr, size_t hdr_size, DynArray* da);
 
 #endif   // #ifndef INCLUDED_TEX_CODEC

source/lib/tex/tex_dds.cpp

@@ -27 +27 @@
 #include "precompiled.h"
 
 #include "lib/byte_order.h"
-#include "lib/bits.h"
+#include "lib/ogl.h"
 #include "lib/timer.h"
 #include "lib/allocators/shared_ptr.h"
 #include "tex_codec.h"
+#include "tex_utils.h"
 
+#ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
+# define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT  0x83F2
+#endif
 
-// NOTE: the convention is bottom-up for DDS, but there's no way to tell.
-
-
-//-----------------------------------------------------------------------------
-// S3TC decompression
-//-----------------------------------------------------------------------------
-
-// note: this code may not be terribly efficient. it's only used to
-// emulate hardware S3TC support - if that isn't available, performance
-// will suffer anyway due to increased video memory usage.
-
-
-// for efficiency, we precalculate as much as possible about a block
-// and store it here.
-class S3tcBlock
-{
-public:
-    S3tcBlock(size_t dxt, const u8* RESTRICT block)
-        : dxt(dxt)
-    {
-        // (careful, 'dxt != 1' doesn't work - there's also DXT1a)
-        const u8* a_block = block;
-        const u8* c_block = (dxt == 3 || dxt == 5)? block+8 : block;
-
-        PrecalculateAlpha(dxt, a_block);
-        PrecalculateColor(dxt, c_block);
-    }
-
-    void WritePixel(size_t pixel_idx, u8* RESTRICT out) const
-    {
-        ENSURE(pixel_idx < 16);
-
-        // pixel index -> color selector (2 bit) -> color
-        const size_t c_selector = access_bit_tbl(c_selectors, pixel_idx, 2);
-        for(int i = 0; i < 3; i++)
-            out[i] = (u8)c[c_selector][i];
-
-        // if no alpha, done
-        if(dxt == 1)
-            return;
-
-        size_t a;
-        if(dxt == 3)
-        {
-            // table of 4-bit alpha entries
-            a = access_bit_tbl(a_bits, pixel_idx, 4);
-            a |= a << 4; // expand to 8 bits (replicate high into low!)
-        }
-        else if(dxt == 5)
-        {
-            // pixel index -> alpha selector (3 bit) -> alpha
-            const size_t a_selector = access_bit_tbl(a_bits, pixel_idx, 3);
-            a = dxt5_a_tbl[a_selector];
-        }
-        // (dxt == DXT1A)
-        else
-            a = c[c_selector][A];
-        out[A] = (u8)(a & 0xFF);
-    }
-
-private:
-    // pixel colors are stored as size_t[4]. size_t rather than u8 protects from
-    // overflow during calculations, and padding to an even size is a bit
-    // more efficient (even though we don't need the alpha component).
-    enum RGBA { R, G, B, A };
-
-    static inline void mix_2_3(size_t dst[4], size_t c0[4], size_t c1[4])
-    {
-        for(int i = 0; i < 3; i++) dst[i] = (c0[i]*2 + c1[i] + 1)/3;
-    }
-
-    static inline void mix_avg(size_t dst[4], size_t c0[4], size_t c1[4])
-    {
-        for(int i = 0; i < 3; i++) dst[i] = (c0[i]+c1[i])/2;
-    }
-
-    template<typename T>
-    static inline size_t access_bit_tbl(T tbl, size_t idx, size_t bit_width)
-    {
-        size_t val = (tbl >> (idx*bit_width)) & bit_mask<T>(bit_width);
-        return val;
-    }
-
-    // extract a range of bits and expand to 8 bits (by replicating
-    // MS bits - see http://www.mindcontrol.org/~hplus/graphics/expand-bits.html ;
-    // this is also the algorithm used by graphics cards when decompressing S3TC).
-    // used to convert 565 to 32bpp RGB.
-    static inline size_t unpack_to_8(u16 c, size_t bits_below, size_t num_bits)
-    {
-        const size_t num_filler_bits = 8-num_bits;
-        const size_t field = (size_t)bits(c, bits_below, bits_below+num_bits-1);
-        const size_t filler = field >> (num_bits-num_filler_bits);
-        return (field << num_filler_bits) | filler;
-    }
-
-    void PrecalculateAlpha(size_t dxt, const u8* RESTRICT a_block)
-    {
-        // read block contents
-        const u8 a0 = a_block[0], a1 = a_block[1];
-        a_bits = read_le64(a_block);    // see below
-
-        if(dxt == 5)
-        {
-            // skip a0,a1 bytes (data is little endian)
-            a_bits >>= 16;
-
-            const bool is_dxt5_special_combination = (a0 <= a1);
-            u8* a = dxt5_a_tbl; // shorthand
-            if(is_dxt5_special_combination)
-            {
-                a[0] = a0;
-                a[1] = a1;
-                a[2] = (4*a0 + 1*a1 + 2)/5;
-                a[3] = (3*a0 + 2*a1 + 2)/5;
-                a[4] = (2*a0 + 3*a1 + 2)/5;
-                a[5] = (1*a0 + 4*a1 + 2)/5;
-                a[6] = 0;
-                a[7] = 255;
-            }
-            else
-            {
-                a[0] = a0;
-                a[1] = a1;
-                a[2] = (6*a0 + 1*a1 + 3)/7;
-                a[3] = (5*a0 + 2*a1 + 3)/7;
-                a[4] = (4*a0 + 3*a1 + 3)/7;
-                a[5] = (3*a0 + 4*a1 + 3)/7;
-                a[6] = (2*a0 + 5*a1 + 3)/7;
-                a[7] = (1*a0 + 6*a1 + 3)/7;
-            }
-        }
-    }
-
-
-    void PrecalculateColor(size_t dxt, const u8* RESTRICT c_block)
-    {
-        // read block contents
-        // .. S3TC reference colors (565 format). the color table is generated
-        //    from some combination of these, depending on their ordering.
-        u16 rc[2];
-        for(int i = 0; i < 2; i++)
-            rc[i] = read_le16(c_block + 2*i);
-        // .. table of 2-bit color selectors
-        c_selectors = read_le32(c_block+4);
-
-        const bool is_dxt1_special_combination = (dxt == 1 || dxt == DXT1A) && rc[0] <= rc[1];
-
-        // c0 and c1 are the values of rc[], converted to 32bpp
-        for(int i = 0; i < 2; i++)
-        {
-            c[i][R] = unpack_to_8(rc[i], 11, 5);
-            c[i][G] = unpack_to_8(rc[i],  5, 6);
-            c[i][B] = unpack_to_8(rc[i],  0, 5);
-        }
-
-        // c2 and c3 are combinations of c0 and c1:
-        if(is_dxt1_special_combination)
-        {
-            mix_avg(c[2], c[0], c[1]);          // c2 = (c0+c1)/2
-            for(int i = 0; i < 3; i++) c[3][i] = 0; // c3 = black
-            c[3][A] = (dxt == DXT1A)? 0 : 255;      // (transparent iff DXT1a)
-        }
-        else
-        {
-            mix_2_3(c[2], c[0], c[1]);          // c2 = 2/3*c0 + 1/3*c1
-            mix_2_3(c[3], c[1], c[0]);          // c3 = 1/3*c0 + 2/3*c1
-        }
-    }
-
-    // the 4 color choices for each pixel (RGBA)
-    size_t c[4][4]; // c[i][RGBA_component]
-
-    // (DXT5 only) the 8 alpha choices
-    u8 dxt5_a_tbl[8];
-
-    // alpha block; interpretation depends on dxt.
-    u64 a_bits;
-
-    // table of 2-bit color selectors
-    u32 c_selectors;
-
-    size_t dxt;
-};
-
-
-struct S3tcDecompressInfo
-{
-    size_t dxt;
-    size_t s3tc_block_size;
-    size_t out_Bpp;
-    u8* out;
-};
-
-static void s3tc_decompress_level(size_t UNUSED(level), size_t level_w, size_t level_h,
-    const u8* RESTRICT level_data, size_t level_data_size, void* RESTRICT cbData)
-{
-    S3tcDecompressInfo* di = (S3tcDecompressInfo*)cbData;
-    const size_t dxt             = di->dxt;
-    const size_t s3tc_block_size = di->s3tc_block_size;
-
-    // note: 1x1 images are legitimate (e.g. in mipmaps). they report their
-    // width as such for glTexImage, but the S3TC data is padded to
-    // 4x4 pixel block boundaries.
-    const size_t blocks_w = DivideRoundUp(level_w, size_t(4));
-    const size_t blocks_h = DivideRoundUp(level_h, size_t(4));
-    const u8* s3tc_data = level_data;
-    ENSURE(level_data_size % s3tc_block_size == 0);
-
-    for(size_t block_y = 0; block_y < blocks_h; block_y++)
-    {
-        for(size_t block_x = 0; block_x < blocks_w; block_x++)
-        {
-            S3tcBlock block(dxt, s3tc_data);
-            s3tc_data += s3tc_block_size;
-
-            size_t pixel_idx = 0;
-            for(int y = 0; y < 4; y++)
-            {
-                // this is ugly, but advancing after x, y and block_y loops
-                // is no better.
-                u8* out = (u8*)di->out + ((block_y*4+y)*blocks_w*4 + block_x*4) * di->out_Bpp;
-                for(int x = 0; x < 4; x++)
-                {
-                    block.WritePixel(pixel_idx, out);
-                    out += di->out_Bpp;
-                    pixel_idx++;
-                }
-            }
-        }
-    }
-
-    ENSURE(s3tc_data == level_data + level_data_size);
-    di->out += blocks_w*blocks_h * 16 * di->out_Bpp;
-}
-
-
-// decompress the given image (which is known to be stored as DXTn)
-// effectively in-place. updates Tex fields.
-static Status s3tc_decompress(Tex* t)
-{
-    // alloc new image memory
-    // notes:
-    // - dxt == 1 is the only non-alpha case.
-    // - adding or stripping alpha channels during transform is not
-    //   our job; we merely output the same pixel format as given
-    //   (tex.cpp's plain transform could cover it, if ever needed).
-    const size_t dxt = t->m_Flags & TEX_DXT;
-    const size_t out_bpp = (dxt != 1)? 32 : 24;
-    const size_t out_size = t->img_size() * out_bpp / t->m_Bpp;
-    shared_ptr<u8> decompressedData;
-    AllocateAligned(decompressedData, out_size, pageSize);
-
-    const size_t s3tc_block_size = (dxt == 3 || dxt == 5)? 16 : 8;
-    S3tcDecompressInfo di = { dxt, s3tc_block_size, out_bpp/8, decompressedData.get() };
-    const u8* s3tc_data = t->get_data();
-    const int levels_to_skip = (t->m_Flags & TEX_MIPMAPS)? 0 : TEX_BASE_LEVEL_ONLY;
-    tex_util_foreach_mipmap(t->m_Width, t->m_Height, t->m_Bpp, s3tc_data, levels_to_skip, 4, s3tc_decompress_level, &di);
-    t->m_Data = decompressedData;
-    t->m_DataSize = out_size;
-    t->m_Ofs = 0;
-    t->m_Bpp = out_bpp;
-    t->m_Flags &= ~TEX_DXT;
-    return INFO::OK;
-}
-
+#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
+# define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT  0x83F3
+#endif
 
 //-----------------------------------------------------------------------------
 // DDS file format
@@ -311 +53 @@
 // DDS_PIXELFORMAT.dwFlags
 // we've seen some DXT3 files that don't have this set (which is nonsense;
 // any image lacking alpha should be stored as DXT1). it's authoritative
-// if fourcc is DXT1 (there's no other way to tell DXT1 and DXT1a apart)
+// if fourcc is DXT1 (there's no other way to tell DXT1 and TEX_COMPRESSED_A apart)
 // and ignored otherwise.
 #define DDPF_ALPHAPIXELS 0x00000001
 #define DDPF_FOURCC      0x00000004
@@ -366 +108 @@
 
 #pragma pack(pop)
 
-
-static bool is_valid_dxt(size_t dxt)
-{
-    switch(dxt)
-    {
-    case 0:
-    case 1:
-    case DXT1A:
-    case 3:
-    case 5:
-        return true;
-    default:
-        return false;
-    }
-}
-
-
 // extract all information from DDS pixel format and store in bpp, flags.
 // pf points to the DDS file's header; all fields must be endian-converted
 // before use.
 // output parameters invalid on failure.
-static Status decode_pf(const DDS_PIXELFORMAT* pf, size_t& bpp, size_t& flags)
+static Status decode_pf(const DDS_PIXELFORMAT* pf, Tex* RESTRICT t)
 {
-    bpp = 0;
-    flags = 0;
+    t->m_Bpp = 0;
+    t->m_Flags = 0;
+
+    t->m_glType = 0;
+    t->m_glFormat = 0;
+    t->m_glInternalFormat = 0;
 
     // check struct size
     if(read_le32(&pf->dwSize) != sizeof(DDS_PIXELFORMAT))
@@ -409 +138 @@
 
         // (checked below; must be set in case below warning is to be
         // skipped)
-        bpp = pf_bpp;
+        t->m_Bpp = pf_bpp;
 
         if(pf_flags & DDPF_ALPHAPIXELS)
         {
             // something weird other than RGBA or BGRA
             if(pf_a_mask != 0xFF000000)
                 WARN_RETURN(ERR::TEX_FMT_INVALID);
-            flags |= TEX_ALPHA;
         }
 
         // make sure component ordering is 0xBBGGRR = RGB (see below)
@@ -432 +160 @@
             WARN_RETURN(ERR::TEX_FMT_INVALID);
         }
 
-        RETURN_STATUS_IF_ERR(tex_validate_plain_format(bpp, (int)flags));
+        switch (pf_bpp) {
+        case 24:
+            t->m_glFormat = GL_RGB;
+            break;
+        case 32:
+            t->m_glFormat = GL_RGBA;
+            break;
+        default:
+            WARN_RETURN(ERR::TEX_FMT_INVALID);
+            break;
+        }
+        t->m_glType = GL_UNSIGNED_BYTE;
+        t->m_glInternalFormat = t->m_glFormat;
     }
     // .. uncompressed 8bpp greyscale
-    else if(pf_flags & DDPF_ALPHAPIXELS)
+    else if((pf_flags & DDPF_ALPHAPIXELS) && !(pf_flags & DDPF_FOURCC))
     {
         const size_t pf_bpp    = (size_t)read_le32(&pf->dwRGBBitCount);
         const size_t pf_a_mask = (size_t)read_le32(&pf->dwABitMask);
 
-        bpp = pf_bpp;
+        t->m_Bpp = pf_bpp;
 
         if(pf_bpp != 8)
             WARN_RETURN(ERR::TEX_FMT_INVALID);
 
         if(pf_a_mask != 0xFF)
             WARN_RETURN(ERR::TEX_FMT_INVALID);
-        flags |= TEX_GREY;
-
-        RETURN_STATUS_IF_ERR(tex_validate_plain_format(bpp, (int)flags));
+        t->m_glType = GL_UNSIGNED_BYTE;
+        t->m_glFormat = GL_ALPHA;
+        t->m_glInternalFormat = t->m_glFormat;
     }
     // .. compressed
     else if(pf_flags & DDPF_FOURCC)
     {
-        // set effective bpp and store DXT format in flags & TEX_DXT.
+        // set effective bpp and store DXT format in flags & TEX_COMPRESSED.
         // no endian conversion necessary - FOURCC() takes care of that.
         switch(pf->dwFourCC)
         {
         case FOURCC('D','X','T','1'):
-            bpp = 4;
-            if(pf_flags & DDPF_ALPHAPIXELS)
-                flags |= DXT1A | TEX_ALPHA;
-            else
-                flags |= 1;
+            t->m_Bpp = 4;
+            if(pf_flags & DDPF_ALPHAPIXELS) {
+                t->m_glFormat = GL_RGBA;
+                t->m_glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+            } else {
+                t->m_glFormat = GL_RGB;
+                t->m_glInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+            }
             break;
+
         case FOURCC('D','X','T','3'):
-            bpp = 8;
-            flags |= 3;
-            flags |= TEX_ALPHA; // see DDPF_ALPHAPIXELS decl
+            t->m_Bpp = 8;
+            t->m_glFormat = GL_RGBA;
+            t->m_glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
             break;
+
         case FOURCC('D','X','T','5'):
-            bpp = 8;
-            flags |= 5;
-            flags |= TEX_ALPHA; // see DDPF_ALPHAPIXELS decl
+            t->m_Bpp = 8;
+            t->m_glFormat = GL_RGBA;
+            t->m_glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
             break;
-
         default:
             WARN_RETURN(ERR::TEX_FMT_INVALID);
         }
@@ -487 +231 @@
     return INFO::OK;
 }
 
+static Status mipmap_level(const Tex* t, size_t level, size_t face, size_t &w, size_t &h, u8* &mipmapData, size_t &mipmapDataSize)
+{
+    ENSURE(level < t->m_numberOfMipmapLevels);
+    ENSURE(face < t->m_numberOfFaces);
+
+    w = t->m_Width;
+    h = t->m_Height;
+
+    mipmapData = t->get_data();
+
+    const size_t dataPadding = t->m_glType ? 1 : 4;
+
+    for(size_t i = 0; i < level; i++)
+    {
+        // used to skip past this mip level in <data>
+        const size_t level_dataSize = t->m_numberOfFaces * (size_t)(round_up(w, dataPadding) * round_up(h, dataPadding) * t->m_Bpp / 8);
+
+        mipmapData += level_dataSize;
+
+        w /= 2;
+        h /= 2;
+        // if the texture is non-square, one of the dimensions will become
+        // 0 before the other. to satisfy OpenGL's expectations, change it
+        // back to 1.
+        if(w == 0) w = 1;
+        if(h == 0) h = 1;
+    }
+
+    mipmapDataSize = (size_t)(round_up(w, dataPadding) * round_up(h, dataPadding) * t->m_Bpp / 8);
+    mipmapData += face * mipmapDataSize;
+
+    return INFO::OK;
+}
+
 
 // extract all information from DDS header and store in w, h, bpp, flags.
 // sd points to the DDS file's header; all fields must be endian-converted
 // before use.
 // output parameters invalid on failure.
-static Status decode_sd(const DDS_HEADER* sd, size_t& w, size_t& h, size_t& bpp, size_t& flags)
+static Status decode_sd(const DDS_HEADER* sd, Tex* RESTRICT t)
 {
     // check header size
     if(read_le32(&sd->dwSize) != sizeof(*sd))
@@ -507 +285 @@
         WARN_RETURN(ERR::TEX_INCOMPLETE_HEADER);
 
     // image dimensions
-    h = (size_t)read_le32(&sd->dwHeight);
-    w = (size_t)read_le32(&sd->dwWidth);
+    t->m_Height = (size_t)read_le32(&sd->dwHeight);
+    t->m_Width = (size_t)read_le32(&sd->dwWidth);
 
     // pixel format
-    RETURN_STATUS_IF_ERR(decode_pf(&sd->ddpf, bpp, flags));
+    RETURN_STATUS_IF_ERR(decode_pf(&sd->ddpf, t));
 
     // if the image is not aligned with the S3TC block size, it is stored
     // with extra pixels on the bottom left to fill up the space, so we need
     // to account for those when calculating how big it should be
     size_t stored_h, stored_w;
-    if(flags & TEX_DXT)
+    if (!t->m_glType)
     {
-        stored_h = Align<4>(h);
-        stored_w = Align<4>(w);
+        stored_h = Align<4>(t->m_Height);
+        stored_w = Align<4>(t->m_Width);
     }
     else
     {
-        stored_h = h;
-        stored_w = w;
+        stored_h = t->m_Height;
+        stored_w = t->m_Width;
     }
 
     // verify pitch or linear size, if given
-    const size_t pitch = stored_w*bpp/8;
+    const size_t pitch = stored_w*t->m_Bpp/8;
     const size_t sd_pitch_or_size = (size_t)read_le32(&sd->dwPitchOrLinearSize);
     if(sd_flags & DDSD_PITCH)
     {
@@ -555 +333 @@
         {
             // mipmap chain is incomplete
             // note: DDS includes the base level in its count, hence +1.
-            if(mipmap_count != ceil_log2(std::max(w,h))+1)
+            if(mipmap_count != ceil_log2(std::max(t->m_Width, t->m_Height))+1)
                 WARN_RETURN(ERR::TEX_FMT_INVALID);
-            flags |= TEX_MIPMAPS;
+            t->m_numberOfFaces = 1;
+            t->m_numberOfMipmapLevels = mipmap_count;
         }
+    } else {
+        t->m_numberOfFaces = 1;
+        t->m_numberOfMipmapLevels = 1;
     }
 
     // check for volume textures
@@ -575 +357 @@
     // .. sanity check: warn if mipmap flag not set (don't bail if not
     // because we've already made the decision).
     const bool mipmap_cap = (sd->dwCaps & DDSCAPS_MIPMAP) != 0;
-    const bool mipmap_flag = (flags & TEX_MIPMAPS) != 0;
+    const bool mipmap_flag = (t->m_numberOfMipmapLevels > 1) != 0;
     ENSURE(mipmap_cap == mipmap_flag);
     // note: we do not check for cubemaps and volume textures (not supported)
     // because the file may still have useful data we can read.
 
+    t->m_mipmapsLevel = &mipmap_level;
     return INFO::OK;
 }
 
@@ -607 +390 @@
 Status TexCodecDds::decode(rpU8 data, size_t UNUSED(size), Tex* RESTRICT t) const
 {
     const DDS_HEADER* sd = (const DDS_HEADER*)(data+4);
-    RETURN_STATUS_IF_ERR(decode_sd(sd, t->m_Width, t->m_Height, t->m_Bpp, t->m_Flags));
+    RETURN_STATUS_IF_ERR(decode_sd(sd, t));
     return INFO::OK;
 }
 
@@ -622 +405 @@
 
 TIMER_ADD_CLIENT(tc_dds_transform);
 
-Status TexCodecDds::transform(Tex* t, size_t transforms) const
+Status TexCodecDds::transform(Tex* t, size_t glFormat, int flags) const
 {
     TIMER_ACCRUE(tc_dds_transform);
 
-    size_t mipmaps = t->m_Flags & TEX_MIPMAPS;
-    size_t dxt = t->m_Flags & TEX_DXT;
-    ENSURE(is_valid_dxt(dxt));
+    if (!is_hdr(t->m_Data.get()))
+        return INFO::TEX_CODEC_CANNOT_HANDLE;
+
 
-    const size_t transform_mipmaps = transforms & TEX_MIPMAPS;
-    const size_t transform_dxt = transforms & TEX_DXT;
     // requesting removal of mipmaps
-    if(mipmaps && transform_mipmaps)
+    if(t->m_numberOfMipmapLevels > 1 && flags & TEX_MIPMAPS)
     {
         // we don't need to actually change anything except the flag - the
         // mipmap levels will just be treated as trailing junk
-        t->m_Flags &= ~TEX_MIPMAPS;
-        return INFO::OK;
+        t->m_numberOfMipmapLevels = 1;
     }
+
     // requesting decompression
-    if(dxt && transform_dxt)
+    if(!t->m_glType && t->m_glInternalFormat)
     {
-        RETURN_STATUS_IF_ERR(s3tc_decompress(t));
-        return INFO::OK;
+        Status ret = TexUtils::decompress(t);
+        if (ret != INFO::OK)
+            return ret;
+        return t->transform(glFormat, flags);
     }
     // both are DXT (unsupported; there are no flags we can change while
     // compressed) or requesting compression (not implemented) or

source/lib/tex/tex_internal.h

@@ -40 +40 @@
  * @param flags TexFlags
  * @return Status
  **/
-extern Status tex_validate_plain_format(size_t bpp, size_t flags);
+extern Status tex_validate_plain_format(size_t bpp, size_t glFormat);
 
 
 /**

source/lib/tex/tex_jpg.cpp

@@ -30 +30 @@
 
 #include "lib/external_libraries/libjpeg.h"
 #include "lib/allocators/shared_ptr.h"
+#include "lib/ogl.h"
 
 #include "tex_codec.h"
 
@@ -423 +424 @@
 //-----------------------------------------------------------------------------
 
 
-Status TexCodecJpg::transform(Tex* UNUSED(t), size_t UNUSED(transforms)) const
+Status TexCodecJpg::transform(Tex* UNUSED(t), size_t UNUSED(glFormat), int UNUSED(flags)) const
 {
     return INFO::TEX_CODEC_CANNOT_HANDLE;
 }
@@ -451 +452 @@
 
     // set libjpg output format. we cannot go with the default because
     // Photoshop writes non-standard CMYK files that must be converted to RGB.
-    size_t flags = 0;
     cinfo->out_color_space = JCS_RGB;
     if(cinfo->num_components == 1)
-    {
-        flags |= TEX_GREY;
         cinfo->out_color_space = JCS_GRAYSCALE;
-    }
 
     // lower quality, but faster
     cinfo->dct_method = JDCT_IFAST;
@@ -503 +500 @@
     if(cinfo->err->num_warnings != 0)
         ret = WARN::TEX_INVALID_DATA;
 
+    size_t glFormat = 0;
+    switch (bpp) {
+    case 8:
+        glFormat = GL_ALPHA;
+        break;
+    case 16:
+        glFormat = GL_LUMINANCE_ALPHA;
+        break;
+    case 24:
+        glFormat = GL_RGB;
+        break;
+    case 32:
+        glFormat = GL_RGBA;
+        break;
+    default:
+        break;
+    }
     // store image info and validate
-    return ret | t->wrap(w,h,bpp,flags,img,0);
+    return ret | t->wrap(glFormat, w, h, bpp, 0, img, 0);
 }
 
 
@@ -527 +541 @@
     jpeg_start_compress(cinfo, TRUE);
 
     // if BGR, convert to RGB.
-    WARN_IF_ERR(t->transform_to(t->m_Flags & ~TEX_BGR));
+    WARN_IF_ERR(t->transform(GL_RGB, t->m_Flags));
 
     const size_t pitch = t->m_Width * t->m_Bpp / 8;
     u8* data = t->get_data();

new file source/lib/tex/tex_ktx.cpp

@@ +1 @@
+/* Copyright (c) 2015 Wildfire Games
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * KTX Khronos Texture format https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec.
+ */
+
+#include "precompiled.h"
+
+#include "lib/bits.h"
+#include "lib/ogl.h"
+#include "lib/timer.h"
+#include "lib/allocators/shared_ptr.h"
+#include "tex_codec.h"
+#include "tex_utils.h"
+#include "lib/byte_order.h"
+
+namespace {
+static const u8 KTX_Magic[] = {
+    0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A
+};
+
+static const u32 KTX_Endian = 0x04030201;
+static const u32 KTX_Endian_Rev = 0x01020304;
+
+struct KTX_Header {
+    u8 identifier[12];
+    u32 endianness;
+    u32 glType;
+    u32 glTypeSize;
+    u32 glFormat;
+    u32 glInternalFormat;
+    u32 glBaseInternalFormat;
+    u32 pixelWidth;
+    u32 pixelHeight;
+    u32 pixelDepth;
+    u32 numberOfArrayElements;
+    u32 numberOfFaces;
+    u32 numberOfMipmapLevels;
+    u32 bytesOfKeyValueData;
+};
+
+#define KTX_HEADER_SIZE 64
+typedef int KTX_header_SIZE_ASSERT [sizeof(KTX_Header) == KTX_HEADER_SIZE];
+
+bool checkKTX(KTX_Header *header)
+{
+    if (memcmp(KTX_Magic, header->identifier, 12))
+        return false;
+
+    if (KTX_Endian_Rev == header->endianness) {
+        // the machine endian is different from file endian, we must swap the header values
+        header->glType = swap32(header->glType);
+        header->glTypeSize = swap32(header->glTypeSize);
+        header->glFormat = swap32(header->glFormat);
+        header->glInternalFormat = swap32(header->glInternalFormat);
+        header->glBaseInternalFormat = swap32(header->glBaseInternalFormat);
+        header->pixelWidth = swap32(header->pixelWidth);
+        header->pixelHeight = swap32(header->pixelHeight);
+        header->pixelDepth = swap32(header->pixelDepth);
+        header->numberOfArrayElements = swap32(header->numberOfArrayElements);
+        header->numberOfFaces = swap32(header->numberOfFaces);
+        header->numberOfMipmapLevels = swap32(header->numberOfMipmapLevels);
+        header->bytesOfKeyValueData = swap32(header->bytesOfKeyValueData);
+    } else if (KTX_Endian != header->endianness) {
+        // the header is invalid
+        return false;
+    }
+
+    if (!header->numberOfMipmapLevels)
+        header->numberOfMipmapLevels = 1;
+
+    if (header->numberOfFaces != 1 && header->numberOfFaces != 6)
+        return false;
+
+    if (KTX_Endian_Rev == header->endianness &&
+            header->glTypeSize != 2 && header->glTypeSize != 4) {
+        return false;
+    }
+    return true;
+}
+
+Status mipmap_level(const Tex* t, size_t level, size_t face, size_t &w, size_t &h, u8 *&mipmapData, size_t &mipmapDataSize)
+{
+    ENSURE(level < t->m_numberOfMipmapLevels);
+    ENSURE(face < t->m_numberOfFaces);
+
+    w = t->m_Width;
+    h = t->m_Height;
+
+    mipmapData = t->get_data();
+    KTX_Header *header = (KTX_Header*)mipmapData;
+    mipmapData += sizeof(KTX_Header) + header->bytesOfKeyValueData;
+
+    for(size_t l = 0; l <= level; l++)
+    {
+        const size_t faces = (l==level) ? face : header->numberOfFaces;
+        for (size_t f = 0; f < faces; f++)
+        {
+            mipmapDataSize = *(u32 *)mipmapData;
+            mipmapDataSize = (mipmapDataSize + 3) & ~(u32)3;
+            mipmapData += mipmapDataSize + 4;
+
+            w /= 2;
+            h /= 2;
+            // if the texture is non-square, one of the dimensions will become
+            // 0 before the other. to satisfy OpenGL's expectations, change it
+            // back to 1.
+            if(w == 0) w = 1;
+            if(h == 0) h = 1;
+        }
+    }
+
+    mipmapDataSize = *(u32 *)mipmapData;
+    mipmapDataSize = (mipmapDataSize + 3) & ~(u32)3;
+    mipmapData += 4;
+    return INFO::OK;
+}
+
+int glTypeSize(size_t glType)
+{
+    switch (glType) {
+    case 0:
+    case GL_UNSIGNED_BYTE:
+        return 1;
+    case GL_UNSIGNED_SHORT:
+        return 2;
+    }
+    ENSURE(false);
+    return 1;
+}
+
+int bppFromGlFormat(size_t glFormat)
+{
+    switch (glFormat) {
+    case GL_ALPHA:
+    case GL_RED:
+    case GL_LUMINANCE:
+        return 8;
+
+    case GL_LUMINANCE_ALPHA:
+    case GL_RG:
+        return 16;
+
+    case GL_RGB:
+    case GL_BGR:
+        return 24;
+
+    case GL_RGBA:
+    case GL_BGRA_EXT:
+        return 32;
+    }
+    ENSURE(false);
+    return 8;
+}
+
+} // namespace
+
+Status TexCodecKtx::decode(u8* data, size_t size, Tex* RESTRICT t) const
+{
+    if (size < sizeof(KTX_Header))
+        return ERR::TEX_INCOMPLETE_HEADER;
+
+    KTX_Header *header = (KTX_Header*)data;
+    if (!checkKTX(header))
+        return ERR::TEX_FMT_INVALID;
+
+    t->m_Ofs = 0;
+    t->m_mipmapsLevel = &mipmap_level;
+    t->m_Flags = 0;
+    t->m_Width = header->pixelWidth;
+    t->m_Height = header->pixelHeight;
+    t->m_glType = header->glType;
+    t->m_glFormat = header->glBaseInternalFormat;
+    t->m_glInternalFormat = header->glInternalFormat;
+    t->m_numberOfMipmapLevels = header->numberOfMipmapLevels;
+    t->m_numberOfFaces = header->numberOfFaces;
+    u32 hdrsize = sizeof(KTX_Header) + header->bytesOfKeyValueData;
+    data += hdrsize;
+
+    if (KTX_Endian_Rev == header->endianness) {
+        size -= hdrsize;
+        // we need to swap the data
+        if (header->glTypeSize == 4) {
+            u32 *ptr = (u32 *)data;
+            for (u32 i = 0; i < size / 4; i++, ptr++)
+                *ptr = swap32(*ptr);
+        } else {
+            u8 *dt = data;
+            for (u32 level = 0; level < header->numberOfMipmapLevels; level++) {
+                u32 faceSize = *(u32 *)dt;
+                faceSize = swap32(faceSize);
+                *(u32 *)dt = faceSize;
+                faceSize = (faceSize + 3) & ~(u32)3;
+                dt += 4;
+                for (u32 face = 0; face < header->numberOfFaces; face++) {
+                    if (header->glTypeSize == 2) {
+                        u16 *ptr = (u16 *)dt;
+                        for (u32 i = 0; i < faceSize / 2; i++, ptr++)
+                            *ptr = swap16(*ptr);
+                    }
+                    dt += faceSize;
+                }
+            }
+        }
+        header->endianness = KTX_Endian;
+    }
+    if (t->m_glType)
+        t->m_Bpp = bppFromGlFormat(t->m_glFormat);
+    else
+        t->m_Bpp = round_up((8*(*(u32 *)data))/(t->m_Width*t->m_Height), size_t(4));
+
+    return INFO::OK;
+}
+
+Status TexCodecKtx::encode(Tex* RESTRICT t, DynArray* RESTRICT da) const
+{
+    size_t sz = t->img_size() + KTX_HEADER_SIZE + 8 * t->m_numberOfFaces * t->m_numberOfMipmapLevels;
+    if (da->max_size_pa < sz) {
+        da_free(da);
+        da_alloc(da, sz);
+        if (da->max_size_pa < sz)
+            return ERR::NO_MEM;
+    }
+
+    KTX_Header header;
+    memcpy(header.identifier, KTX_Magic, 12);
+    header.endianness = KTX_Endian;
+    header.glType = t->m_glType;
+    header.glTypeSize = glTypeSize(t->m_glType);
+    header.glFormat = t->m_glInternalFormat ? 0 : t->m_glFormat;
+    header.glInternalFormat = t->m_glInternalFormat;
+    header.glBaseInternalFormat = t->m_glFormat;
+    header.pixelWidth = t->m_Width;
+    header.pixelHeight = t->m_Height;
+    header.pixelDepth = 0;
+    header.numberOfArrayElements = 0;
+    header.numberOfFaces = t->m_numberOfFaces;
+    header.numberOfMipmapLevels = t->m_numberOfMipmapLevels;
+    header.bytesOfKeyValueData = 0;
+    da_append(da,&header, KTX_HEADER_SIZE);
+    for (size_t l = 0; l < t->m_numberOfMipmapLevels; l++)
+        for (size_t f = 0; f < t->m_numberOfFaces; f++) {
+            size_t width = 0, height = 0;
+            u8 *mipmapData = 0;
+            size_t mipmapDataSize = 0;
+            t->mipmapsLevel(l, f, width, height, mipmapData, mipmapDataSize);
+            u32 sz = mipmapDataSize;
+            da_append(da, &sz, 4);
+            da_append(da, mipmapData, mipmapDataSize);
+            mipmapDataSize = (mipmapDataSize + 3) & ~(u32)3;
+            if (mipmapDataSize != sz)
+                da_append(da, &header, mipmapDataSize - sz);
+        }
+    return INFO::OK;
+}
+
+TIMER_ADD_CLIENT(tc_ktx_transform);
+
+Status TexCodecKtx::transform(Tex* t, size_t glFormat, int flags) const
+{
+    TIMER_ACCRUE(tc_ktx_transform);
+
+    if (!is_hdr(t->m_Data.get()))
+        return INFO::TEX_CODEC_CANNOT_HANDLE;
+
+    // requesting removal of mipmaps
+    if(t->m_numberOfMipmapLevels > 1 && flags & TEX_MIPMAPS)
+    {
+        // we don't need to actually change anything except the flag - the
+        // mipmap levels will just be treated as trailing junk
+        t->m_numberOfMipmapLevels = 1;
+    }
+
+    // requesting decompression
+    if(!t->m_glType && t->m_glInternalFormat)
+    {
+        Status ret = TexUtils::decompress(t);
+        if (ret != INFO::OK)
+            return ret;
+        return t->transform(glFormat, flags);
+    }
+    // both are DXT (unsupported; there are no flags we can change while
+    // compressed) or requesting compression (not implemented) or
+    // both not DXT (nothing we can do) - bail.
+    return INFO::TEX_CODEC_CANNOT_HANDLE;
+}
+
+bool TexCodecKtx::is_hdr(const u8* file) const
+{
+    return memcmp(file, KTX_Magic, 12) == 0;
+}
+
+bool TexCodecKtx::is_ext(const OsPath& extension) const
+{
+    return extension == L".ktx";
+}
+
+size_t TexCodecKtx::hdr_size(const u8* file) const
+{
+    const size_t hdr_size = sizeof(KTX_Header);
+    if(file)
+    {
+        KTX_Header* hdr = (KTX_Header*)file;
+        if (hdr->endianness != KTX_Endian)
+            hdr->bytesOfKeyValueData = swap32(hdr->bytesOfKeyValueData);
+        return hdr_size + hdr->bytesOfKeyValueData;
+    }
+    return hdr_size;
+}

source/lib/tex/tex_png.cpp

@@ -32 +32 @@
 #include "tex_codec.h"
 #include "lib/allocators/shared_ptr.h"
 #include "lib/timer.h"
+#include "lib/ogl.h"
 
 #if MSC_VERSION
 
@@ -107 +108 @@
 
 //-----------------------------------------------------------------------------
 
-Status TexCodecPng::transform(Tex* UNUSED(t), size_t UNUSED(transforms)) const
+Status TexCodecPng::transform(Tex* UNUSED(t), size_t UNUSED(glFormat), int UNUSED(flags)) const
 {
     return INFO::TEX_CODEC_CANNOT_HANDLE;
 }
@@ -130 +131 @@
     const size_t pitch = png_get_rowbytes(png_ptr, info_ptr);
     const u32 bpp = (u32)(pitch/w * 8);
 
-    size_t flags = 0;
-    if(bpp == 32)
-        flags |= TEX_ALPHA;
-    if(colour_type == PNG_COLOR_TYPE_GRAY)
-        flags |= TEX_GREY;
-
-    // make sure format is acceptable
-    if(bit_depth != 8)
-        WARN_RETURN(ERR::TEX_NOT_8BIT_PRECISION);
+    size_t glFormat = 0;
+    switch (bpp) {
+    case 8:
+        glFormat = GL_ALPHA;
+        break;
+    case 16:
+        glFormat = GL_LUMINANCE_ALPHA;
+        break;
+    case 24:
+        glFormat = GL_RGB;
+        break;
+    case 32:
+        glFormat = GL_RGBA;
+        break;
+    default:
+        break;
+    }
     if(colour_type & PNG_COLOR_MASK_PALETTE)
         WARN_RETURN(ERR::TEX_INVALID_COLOR_TYPE);
 
@@ -154 +163 @@
     ENSURE(stream->RemainingSize() == 0);
 
     // store image info and validate
-    return t->wrap(w,h,bpp,flags,data,0);
+    return t->wrap(glFormat, w, h, bpp, 0, data, 0);
 }
 
 
@@ -166 +175 @@
     const size_t pitch = w * t->m_Bpp / 8;
 
     int colour_type;
-    switch(t->m_Flags & (TEX_GREY|TEX_ALPHA))
+    switch(t->m_glFormat)
     {
-    case TEX_GREY|TEX_ALPHA:
+    case GL_ALPHA:
+    case GL_LUMINANCE:
+        colour_type = PNG_COLOR_TYPE_GRAY;
+        break;
+    case GL_LUMINANCE_ALPHA:
         colour_type = PNG_COLOR_TYPE_GRAY_ALPHA;
         break;
-    case TEX_GREY:
-        colour_type = PNG_COLOR_TYPE_GRAY;
+    case GL_RGB:
+        colour_type = PNG_COLOR_TYPE_RGB;
         break;
-    case TEX_ALPHA:
+    case GL_RGBA:
         colour_type = PNG_COLOR_TYPE_RGB_ALPHA;
         break;
     default:
-        colour_type = PNG_COLOR_TYPE_RGB;
-        break;
+        return ERR::TEX_FMT_INVALID;
     }
 
     png_set_write_fn(png_ptr, da, io_write, io_flush);
@@ -190 +202 @@
     std::vector<RowPtr> rows = tex_codec_alloc_rows(data, h, pitch, t->m_Flags, TEX_TOP_DOWN);
 
     // PNG is native RGB.
-    const int png_transforms = (t->m_Flags & TEX_BGR)? PNG_TRANSFORM_BGR : PNG_TRANSFORM_IDENTITY;
+    const int png_transforms = (t->m_glFormat == GL_BGR || t->m_glFormat == GL_BGRA_EXT)? PNG_TRANSFORM_BGR : PNG_TRANSFORM_IDENTITY;
 
     png_set_rows(png_ptr, info_ptr, (png_bytepp)&rows[0]);
     png_write_png(png_ptr, info_ptr, png_transforms, 0);

source/lib/tex/tex_tga.cpp

@@ -29 +29 @@
 #include "lib/byte_order.h"
 #include "tex_codec.h"
 #include "lib/bits.h"
+#include "lib/ogl.h"
 
 #pragma pack(push, 1)
 
@@ -67 +68 @@
 #pragma pack(pop)
 
 
-Status TexCodecTga::transform(Tex* UNUSED(t), size_t UNUSED(transforms)) const
+Status TexCodecTga::transform(Tex* UNUSED(t), size_t UNUSED(glFormat), int UNUSED(flags)) const
 {
     return INFO::TEX_CODEC_CANNOT_HANDLE;
 }
@@ -123 +124 @@
 
     size_t flags = 0;
     flags |= (desc & TGA_TOP_DOWN)? TEX_TOP_DOWN : TEX_BOTTOM_UP;
-    if(desc & 0x0F) // alpha bits
-        flags |= TEX_ALPHA;
-    if(bpp == 8)
-        flags |= TEX_GREY;
-    if(type == TGA_TRUE_COLOUR)
-        flags |= TEX_BGR;
+
+    t->m_glType = GL_UNSIGNED_BYTE;
+
+    switch (bpp) {
+    case 8:
+        t->m_glFormat = GL_ALPHA;
+    case 16:
+        t->m_glFormat = GL_LUMINANCE_ALPHA;
+        break;
+    case 24:
+        t->m_glFormat = (type == TGA_TRUE_COLOUR) ? GL_BGR : GL_RGB;
+        break;
+    case 32:
+        t->m_glFormat = (type == TGA_TRUE_COLOUR) ? GL_BGRA_EXT : GL_RGBA;
+        break;
+    default:
+        return ERR::TEX_FMT_INVALID;
+    }
 
     // sanity checks
     // .. storing right-to-left is just stupid;
@@ -140 +153 @@
     t->m_Height = h;
     t->m_Bpp    = bpp;
     t->m_Flags  = flags;
+    t->m_glInternalFormat = t->m_glFormat;
     return INFO::OK;
 }
 
@@ -149 +163 @@
     u8 img_desc = 0;
     if(t->m_Flags & TEX_TOP_DOWN)
         img_desc |= TGA_TOP_DOWN;
+
     if(t->m_Bpp == 32)
         img_desc |= 8;  // size of alpha channel
-    TgaImgType img_type = (t->m_Flags & TEX_GREY)? TGA_GREY : TGA_TRUE_COLOUR;
 
-    size_t transforms = t->m_Flags;
-    transforms &= ~TEX_ORIENTATION; // no flip needed - we can set top-down bit.
-    transforms ^= TEX_BGR;          // TGA is native BGR.
+    TgaImgType img_type = (t->m_glFormat == GL_ALPHA || t->m_glFormat == GL_LUMINANCE || t->m_glFormat == GL_LUMINANCE_ALPHA)? TGA_GREY : TGA_TRUE_COLOUR;
 
     const TgaHeader hdr =
     {
@@ -170 +182 @@
         img_desc
     };
     const size_t hdr_size = sizeof(hdr);
-    return tex_codec_write(t, transforms, &hdr, hdr_size, da);
+    return tex_codec_write(t, (t->hasAlpha() ? GL_BGRA_EXT : GL_BGR), 0, &hdr, hdr_size, da);
 }
 

new file source/lib/tex/tex_utils.cpp

@@ +1 @@
+/* Copyright (c) 2015 Wildfire Games
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "precompiled.h"
+
+#include "tex_utils.h"
+#include "tex.h"
+#include "lib/bits.h"
+#include "lib/byte_order.h"
+#include "lib/ogl.h"
+#include "lib/allocators/shared_ptr.h"
+
+namespace {
+// NOTE: the convention is bottom-up for DDS, but there's no way to tell.
+
+
+//-----------------------------------------------------------------------------
+// S3TC decompression
+//-----------------------------------------------------------------------------
+
+// note: this code may not be terribly efficient. it's only used to
+// emulate hardware S3TC support - if that isn't available, performance
+// will suffer anyway due to increased video memory usage.
+
+
+// for efficiency, we precalculate as much as possible about a block
+// and store it here.
+class S3tcBlock
+{
+public:
+    S3tcBlock(size_t dxt, const u8* RESTRICT block)
+        : dxt(dxt)
+    {
+        // (careful, 'dxt != 1' doesn't work - there's also DXT1a)
+        const u8* a_block = block;
+        const u8* c_block = (dxt == 3 || dxt == 5)? block+8 : block;
+
+        PrecalculateAlpha(dxt, a_block);
+        PrecalculateColor(dxt, c_block);
+    }
+
+    void WritePixel(size_t pixel_idx, u8* RESTRICT out) const
+    {
+        ENSURE(pixel_idx < 16);
+
+        // pixel index -> color selector (2 bit) -> color
+        const size_t c_selector = access_bit_tbl(c_selectors, pixel_idx, 2);
+        for(int i = 0; i < 3; i++)
+            out[i] = (u8)c[c_selector][i];
+
+        // if no alpha, done
+        if(dxt == 1)
+            return;
+
+        size_t a;
+        if(dxt == 3)
+        {
+            // table of 4-bit alpha entries
+            a = access_bit_tbl(a_bits, pixel_idx, 4);
+            a |= a << 4; // expand to 8 bits (replicate high into low!)
+        }
+        else if(dxt == 5)
+        {
+            // pixel index -> alpha selector (3 bit) -> alpha
+            const size_t a_selector = access_bit_tbl(a_bits, pixel_idx, 3);
+            a = dxt5_a_tbl[a_selector];
+        }
+        // (dxt == TEX_COMPRESSED_A)
+        else
+            a = c[c_selector][A];
+        out[A] = (u8)(a & 0xFF);
+    }
+
+private:
+    // pixel colors are stored as size_t[4]. size_t rather than u8 protects from
+    // overflow during calculations, and padding to an even size is a bit
+    // more efficient (even though we don't need the alpha component).
+    enum RGBA { R, G, B, A };
+
+    static inline void mix_2_3(size_t dst[4], size_t c0[4], size_t c1[4])
+    {
+        for(int i = 0; i < 3; i++) dst[i] = (c0[i]*2 + c1[i] + 1)/3;
+    }
+
+    static inline void mix_avg(size_t dst[4], size_t c0[4], size_t c1[4])
+    {
+        for(int i = 0; i < 3; i++) dst[i] = (c0[i]+c1[i])/2;
+    }
+
+    template<typename T>
+    static inline size_t access_bit_tbl(T tbl, size_t idx, size_t bit_width)
+    {
+        size_t val = (tbl >> (idx*bit_width)) & bit_mask<T>(bit_width);
+        return val;
+    }
+
+    // extract a range of bits and expand to 8 bits (by replicating
+    // MS bits - see http://www.mindcontrol.org/~hplus/graphics/expand-bits.html ;
+    // this is also the algorithm used by graphics cards when decompressing S3TC).
+    // used to convert 565 to 32bpp RGB.
+    static inline size_t unpack_to_8(u16 c, size_t bits_below, size_t num_bits)
+    {
+        const size_t num_filler_bits = 8-num_bits;
+        const size_t field = (size_t)bits(c, bits_below, bits_below+num_bits-1);
+        const size_t filler = field >> (num_bits-num_filler_bits);
+        return (field << num_filler_bits) | filler;
+    }
+
+    void PrecalculateAlpha(size_t dxt, const u8* RESTRICT a_block)
+    {
+        // read block contents
+        const u8 a0 = a_block[0], a1 = a_block[1];
+        a_bits = read_le64(a_block);    // see below
+
+        if(dxt == 5)
+        {
+            // skip a0,a1 bytes (data is little endian)
+            a_bits >>= 16;
+
+            const bool is_dxt5_special_combination = (a0 <= a1);
+            u8* a = dxt5_a_tbl; // shorthand
+            if(is_dxt5_special_combination)
+            {
+                a[0] = a0;
+                a[1] = a1;
+                a[2] = (4*a0 + 1*a1 + 2)/5;
+                a[3] = (3*a0 + 2*a1 + 2)/5;
+                a[4] = (2*a0 + 3*a1 + 2)/5;
+                a[5] = (1*a0 + 4*a1 + 2)/5;
+                a[6] = 0;
+                a[7] = 255;
+            }
+            else
+            {
+                a[0] = a0;
+                a[1] = a1;
+                a[2] = (6*a0 + 1*a1 + 3)/7;
+                a[3] = (5*a0 + 2*a1 + 3)/7;
+                a[4] = (4*a0 + 3*a1 + 3)/7;
+                a[5] = (3*a0 + 4*a1 + 3)/7;
+                a[6] = (2*a0 + 5*a1 + 3)/7;
+                a[7] = (1*a0 + 6*a1 + 3)/7;
+            }
+        }
+    }
+
+
+    void PrecalculateColor(size_t dxt, const u8* RESTRICT c_block)
+    {
+        // read block contents
+        // .. S3TC reference colors (565 format). the color table is generated
+        //    from some combination of these, depending on their ordering.
+        u16 rc[2];
+        for(int i = 0; i < 2; i++)
+            rc[i] = read_le16(c_block + 2*i);
+        // .. table of 2-bit color selectors
+        c_selectors = read_le32(c_block+4);
+
+        const bool is_dxt1_special_combination = (dxt == 1 || dxt == 7) && rc[0] <= rc[1];
+
+        // c0 and c1 are the values of rc[], converted to 32bpp
+        for(int i = 0; i < 2; i++)
+        {
+            c[i][R] = unpack_to_8(rc[i], 11, 5);
+            c[i][G] = unpack_to_8(rc[i],  5, 6);
+            c[i][B] = unpack_to_8(rc[i],  0, 5);
+        }
+
+        // c2 and c3 are combinations of c0 and c1:
+        if(is_dxt1_special_combination)
+        {
+            mix_avg(c[2], c[0], c[1]);          // c2 = (c0+c1)/2
+            for(int i = 0; i < 3; i++) c[3][i] = 0; // c3 = black
+            c[3][A] = (dxt == 7)? 0 : 255;      // (transparent if TEX_COMPRESSED_A)
+        }
+        else
+        {
+            mix_2_3(c[2], c[0], c[1]);          // c2 = 2/3*c0 + 1/3*c1
+            mix_2_3(c[3], c[1], c[0]);          // c3 = 1/3*c0 + 2/3*c1
+        }
+    }
+
+    // the 4 color choices for each pixel (RGBA)
+    size_t c[4][4]; // c[i][RGBA_component]
+
+    // (DXT5 only) the 8 alpha choices
+    u8 dxt5_a_tbl[8];
+
+    // alpha block; interpretation depends on dxt.
+    u64 a_bits;
+
+    // table of 2-bit color selectors
+    u32 c_selectors;
+
+    size_t dxt;
+};
+
+
+struct S3tcDecompressInfo
+{
+    size_t dxt;
+    size_t s3tc_block_size;
+    size_t out_Bpp;
+    u8* out;
+};
+
+#ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
+# define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT  0x83F2
+#endif
+
+#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
+# define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT  0x83F3
+#endif
+
+size_t glFormat2Dxt(size_t format)
+{
+    switch(format) {
+    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+        return 7;
+    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+        return 1;
+    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+        return 3;
+    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+        return 5;
+    }
+    return 0;
+}
+
+void s3tc_decompress_level(size_t UNUSED(level), size_t UNUSED(face), size_t level_w, size_t level_h,
+                                  const u8* RESTRICT level_data, size_t level_data_size, void* RESTRICT cbData)
+{
+    S3tcDecompressInfo* di = (S3tcDecompressInfo*)cbData;
+    const size_t dxt             = di->dxt;
+    const size_t s3tc_block_size = di->s3tc_block_size;
+
+    // note: 1x1 images are legitimate (e.g. in mipmaps). they report their
+    // width as such for glTexImage, but the S3TC data is padded to
+    // 4x4 pixel block boundaries.
+    const size_t blocks_w = DivideRoundUp(level_w, size_t(4));
+    const size_t blocks_h = DivideRoundUp(level_h, size_t(4));
+    const u8* s3tc_data = level_data;
+    ENSURE(level_data_size % s3tc_block_size == 0);
+
+    for(size_t block_y = 0; block_y < blocks_h; block_y++)
+    {
+        for(size_t block_x = 0; block_x < blocks_w; block_x++)
+        {
+            S3tcBlock block(dxt, s3tc_data);
+            s3tc_data += s3tc_block_size;
+
+            size_t pixel_idx = 0;
+            for(int y = 0; y < 4; y++)
+            {
+                // this is ugly, but advancing after x, y and block_y loops
+                // is no better.
+                u8* out = (u8*)di->out + ((block_y*4+y)*blocks_w*4 + block_x*4) * di->out_Bpp;
+                for(int x = 0; x < 4; x++)
+                {
+                    block.WritePixel(pixel_idx, out);
+                    out += di->out_Bpp;
+                    pixel_idx++;
+                }
+            }
+        }
+    }
+
+    ENSURE(s3tc_data == level_data + level_data_size);
+    di->out += blocks_w*blocks_h * 16 * di->out_Bpp;
+}
+
+
+// decompress the given image (which is known to be stored as DXTn)
+// effectively in-place. updates Tex fields.
+Status s3tc_decompress(Tex* t)
+{
+    // alloc new image memory
+    // notes:
+    // - dxt == 1 is the only non-alpha case.
+    // - adding or stripping alpha channels during transform is not
+    //   our job; we merely output the same pixel format as given
+    //   (tex.cpp's plain transform could cover it, if ever needed).
+    const size_t dxt = glFormat2Dxt(t->m_glInternalFormat);
+    const size_t out_bpp = (dxt != 1)? 32 : 24;
+    const size_t out_size = t->img_size() * out_bpp / t->m_Bpp;
+    shared_ptr<u8> decompressedData;
+    AllocateAligned(decompressedData, out_size, pageSize);
+
+    const size_t s3tc_block_size = (dxt == 3 || dxt == 5)? 16 : 8;
+    S3tcDecompressInfo di = { dxt, s3tc_block_size, out_bpp/8, decompressedData.get() };
+    const int levels_to_skip = 0;
+    tex_util_foreach_mipmap(t, levels_to_skip, s3tc_decompress_level, &di);
+    t->m_Data = decompressedData;
+    t->m_DataSize = out_size;
+    t->m_Ofs = 0;
+    t->m_Bpp = out_bpp;
+    t->m_glInternalFormat = t->m_glFormat;
+    t->m_glType = GL_UNSIGNED_BYTE;
+    t->m_mipmapsLevel = 0;
+    return INFO::OK;
+}
+
+
+#define GL_COMPRESSED_R11_EAC                            0x9270
+#define GL_COMPRESSED_SIGNED_R11_EAC                     0x9271
+#define GL_COMPRESSED_RG11_EAC                           0x9272
+#define GL_COMPRESSED_SIGNED_RG11_EAC                    0x9273
+#define GL_COMPRESSED_RGB8_ETC2                          0x9274
+#define GL_COMPRESSED_SRGB8_ETC2                         0x9275
+#define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2      0x9276
+#define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2     0x9277
+#define GL_COMPRESSED_RGBA8_ETC2_EAC                     0x9278
+#define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC              0x9279
+
+}
+
+namespace TexUtils {
+
+Status decompress(Tex *t)
+{
+    if (glFormat2Dxt(t->m_glInternalFormat))
+        return s3tc_decompress(t);
+    return INFO::TEX_CODEC_CANNOT_HANDLE;
+}
+
+}// namespace TexUtils

new file source/lib/tex/tex_utils.h

@@ +1 @@
+/* Copyright (c) 2015 Wildfire Games
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef TEX_DECOMPRESS_H
+#define TEX_DECOMPRESS_H
+
+#include <lib/status.h>
+
+class Tex;
+namespace TexUtils {
+    Status decompress(Tex* t);
+}
+
+#endif // TEX_DECOMPRESS_H

source/main.cpp

@@ -476 +476 @@
         else
             zip = mod.Filename().ChangeExtension(L".zip");
 
-        CArchiveBuilder builder(mod, paths.Cache());
+        CArchiveBuilder builder(mod, paths.Cache(), args.Has("etc2") ? CArchiveBuilder::ETC2 : CArchiveBuilder::S3TC);
 
         // Add mods provided on the command line
         // NOTE: We do not handle mods in the user mod path here

source/ps/GameSetup/Config.cpp

@@ -30 +30 @@
 
 CStrW g_CursorName = L"test";
 
-bool g_NoGLS3TC = false;
 bool g_NoGLAutoMipmap = false;
 bool g_NoGLVBO = false;
 
@@ -91 +90 @@
 {
     CFG_GET_VAL("vsync", g_VSync);
 
-    CFG_GET_VAL("nos3tc", g_NoGLS3TC);
     CFG_GET_VAL("noautomipmap", g_NoGLAutoMipmap);
     CFG_GET_VAL("novbo", g_NoGLVBO);
     CFG_GET_VAL("pauseonfocusloss", g_PauseOnFocusLoss);

source/ps/GameSetup/Config.h

@@ -25 +25 @@
 // prevent various OpenGL features from being used. this allows working
 // around issues like buggy drivers.
 
-// when loading S3TC-compressed texture files, do not pass them directly to 
-// OpenGL; instead, decompress them via software to regular textures.
-// (necessary on JW's S3 laptop graphics card -- oh, the irony)
-extern bool g_NoGLS3TC;
-
 // do not ask OpenGL to create mipmaps; instead, generate them in software
 // and upload them all manually. (potentially helpful for PT's system, where
 // Mesa falsely reports full S3TC support but isn't able to generate mipmaps

source/ps/GameSetup/GameSetup.cpp

@@ -594 +594 @@
 {
     TIMER(L"InitRenderer");
 
-    if(g_NoGLS3TC)
-        ogl_tex_override(OGL_TEX_S3TC, OGL_TEX_DISABLE);
     if(g_NoGLAutoMipmap)
         ogl_tex_override(OGL_TEX_AUTO_MIPMAP_GEN, OGL_TEX_DISABLE);
 

source/ps/GameSetup/HWDetect.cpp

@@ -129 +129 @@
     g_DisableAudio = disabled;
 }
 
-void SetDisableS3TC(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), bool disabled)
-{
-    if (!IsOverridden("nos3tc"))
-        ogl_tex_override(OGL_TEX_S3TC, disabled ? OGL_TEX_DISABLE : OGL_TEX_ENABLE);
-}
-
 void SetDisableShadows(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), bool disabled)
 {
     if (!IsOverridden("shadows"))
@@ -186 +180 @@
     JSAutoRequest rq(cx);
 
     scriptInterface.RegisterFunction<void, bool, &SetDisableAudio>("SetDisableAudio");
-    scriptInterface.RegisterFunction<void, bool, &SetDisableS3TC>("SetDisableS3TC");
     scriptInterface.RegisterFunction<void, bool, &SetDisableShadows>("SetDisableShadows");
     scriptInterface.RegisterFunction<void, bool, &SetDisableShadowPCF>("SetDisableShadowPCF");
     scriptInterface.RegisterFunction<void, bool, &SetDisableAllWater>("SetDisableAllWater");
@@ -719 +712 @@
 #else
         Display* dpy = wminfo.info.x11.gfxdisplay;
 #endif
-        int scrnum = DefaultScreen(dpy);
 
+#if CONFIG2_GLES
+        const char* glxexts = (const char*)glGetString(GL_EXTENSIONS);
+#else
+        int scrnum = DefaultScreen(dpy);
         const char* glxexts = glXQueryExtensionsString(dpy, scrnum);
+#endif
 
         scriptInterface.SetProperty(settings, "glx_extensions", glxexts);
 

source/ps/Util.cpp

@@ -173 +173 @@
 // write the specified texture to disk.
 // note: <t> cannot be made const because the image may have to be
 // transformed to write it out in the format determined by <fn>'s extension.
-Status tex_write(Tex* t, const VfsPath& filename)
+Status tex_write(Tex* t, const VfsPath& filename, PIVFS fs)
 {
     DynArray da;
     RETURN_STATUS_IF_ERR(t->encode(filename.Extension(), &da));
-
+    if (!fs)
+        fs = g_VFS;
     // write to disk
     Status ret = INFO::OK;
     {
         shared_ptr<u8> file = DummySharedPtr(da.base);
-        const ssize_t bytes_written = g_VFS->CreateFile(filename, file, da.pos);
+        const ssize_t bytes_written = fs->CreateFile(filename, file, da.pos);
         if(bytes_written > 0)
             ENSURE(bytes_written == (ssize_t)da.pos);
         else
@@ -218 +219 @@
     {
 #if !CONFIG2_GLES // GLES doesn't support BGR
         fmt = GL_BGR;
-        flags |= TEX_BGR;
 #endif
     }
 
@@ -233 +233 @@
     AllocateAligned(buf, hdr_size+img_size, maxSectorSize);
     GLvoid* img = buf.get() + hdr_size;
     Tex t;
-    if(t.wrap(w, h, bpp, flags, buf, hdr_size) < 0)
+    if(t.wrap(GL_RGB, w, h, bpp, flags, buf, hdr_size) < 0)
         return;
     glReadPixels(0, 0, (GLsizei)w, (GLsizei)h, fmt, GL_UNSIGNED_BYTE, img);
 
@@ -277 +277 @@
     {
 #if !CONFIG2_GLES // GLES doesn't support BGR
         fmt = GL_BGR;
-        flags |= TEX_BGR;
 #endif
     }
 
@@ -295 +294 @@
 
     Tex t;
     GLvoid* img = img_buf.get() + hdr_size;
-    if(t.wrap(img_w, img_h, bpp, flags, img_buf, hdr_size) < 0)
+    if(t.wrap(fmt, img_w, img_h, bpp, flags, img_buf, hdr_size) < 0)
     {
         free(tile_data);
         return;

source/ps/Util.h

@@ -19 +19 @@
 #define PS_UTIL_H
 
 #include "lib/file/vfs/vfs_path.h"
+#include "lib/file/vfs/vfs.h"
 
 struct Tex;
 
@@ -29 +30 @@
 extern void WriteScreenshot(const VfsPath& extension);
 extern void WriteBigScreenshot(const VfsPath& extension, int tiles);
 
-extern Status tex_write(Tex* t, const VfsPath& filename);
+extern Status tex_write(Tex* t, const VfsPath& filename, PIVFS fs = 0);
 
 #endif // PS_UTIL_H

source/ps/VideoMode.cpp

@@ -49 +49 @@
 CVideoMode::CVideoMode() :
     m_IsFullscreen(false), m_IsInitialised(false), m_Window(NULL),
     m_PreferredW(0), m_PreferredH(0), m_PreferredBPP(0), m_PreferredFreq(0),
-    m_ConfigW(0), m_ConfigH(0), m_ConfigBPP(0), m_ConfigFullscreen(false), m_ConfigForceS3TCEnable(true),
+    m_ConfigW(0), m_ConfigH(0), m_ConfigBPP(0), m_ConfigFullscreen(false),
     m_WindowedW(DEFAULT_WINDOW_W), m_WindowedH(DEFAULT_WINDOW_H), m_WindowedX(0), m_WindowedY(0)
 {
     // (m_ConfigFullscreen defaults to false, so users don't get stuck if
@@ -66 +66 @@
     CFG_GET_VAL("yres", m_ConfigH);
     CFG_GET_VAL("bpp", m_ConfigBPP);
     CFG_GET_VAL("display", m_ConfigDisplay);
-    CFG_GET_VAL("force_s3tc_enable", m_ConfigForceS3TCEnable);
 }
 
 bool CVideoMode::SetVideoMode(int w, int h, int bpp, bool fullscreen)
@@ -212 +211 @@
 
     ReadConfig();
 
-    EnableS3TC();
-
     // preferred video mode = current desktop settings
     // (command line params may override these)
     gfx::GetVideoMode(&m_PreferredW, &m_PreferredH, &m_PreferredBPP, &m_PreferredFreq);
@@ -329 +326 @@
 
     ReadConfig();
 
-    EnableS3TC();
-
     m_IsInitialised = true;
 
     return true;
@@ -351 +346 @@
 #endif
 }
 
-void CVideoMode::EnableS3TC()
-{
-    // On Linux we have to try hard to get S3TC compressed texture support.
-    // If the extension is already provided by default, that's fine.
-    // Otherwise we should enable the 'force_s3tc_enable' environment variable
-    // and (re)initialise the video system, so that Mesa provides the extension
-    // (if the driver at least supports decompression).
-    // (This overrides the force_s3tc_enable specified via driconf files.)
-    // Otherwise we should complain to the user, and stop using compressed textures.
-    //
-    // Setting the environment variable causes Mesa to print an ugly message to stderr
-    // ("ATTENTION: default value of option force_s3tc_enable overridden by environment."),
-    // so it'd be nicer to skip that if S3TC will be supported by default,
-    // but reinitialising video is a pain (and it might do weird things when fullscreen)
-    // so we just unconditionally set it (unless our config file explicitly disables it).
-
-#if !(OS_WIN || OS_MACOSX) // (assume Mesa is used for all non-Windows non-Mac platforms)
-    if (m_ConfigForceS3TCEnable)
-        setenv("force_s3tc_enable", "true", 0);
-#endif
-}
-
 bool CVideoMode::ResizeWindow(int w, int h)
 {
     ENSURE(m_IsInitialised);

source/ps/VideoMode.h

@@ -33 +33 @@
     /**
      * Initialise parts of the video mode, for use in Atlas (which uses
      * wxWidgets instead of SDL for GL).
-     * Currently this just tries to enable S3TC.
      */
     bool InitNonSDL();
 
@@ -84 +83 @@
     void ReadConfig();
     int GetBestBPP();
     bool SetVideoMode(int w, int h, int bpp, bool fullscreen);
-    void EnableS3TC();
 
     /**
      * Remember whether Init has been called. (This isn't used for anything
@@ -107 +105 @@
     int m_ConfigBPP;
     int m_ConfigDisplay;
     bool m_ConfigFullscreen;
-    bool m_ConfigForceS3TCEnable;
 
     // If we're fullscreen, size/position of window when we were last windowed (or the default window
     // size/position if we started fullscreen), to support switching back to the old window size/position

source/renderer/Renderer.cpp

@@ -2021 +2021 @@
 
     // upload the composite texture
     Tex t;
-    (void)t.wrap(total_w, total_h, 8, TEX_GREY, data, 0);
+    (void)t.wrap(GL_ALPHA, total_w, total_h, 8, 0, data, 0);
     
     /*VfsPath filename("blendtex.png");
     
@@ -2044 +2044 @@
     m_hCompositeAlphaMap = ogl_tex_wrap(&t, g_VFS, key);
     (void)ogl_tex_set_filter(m_hCompositeAlphaMap, GL_LINEAR);
     (void)ogl_tex_set_wrap  (m_hCompositeAlphaMap, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
-    int ret = ogl_tex_upload(m_hCompositeAlphaMap, GL_ALPHA, 0, 0);
+    int ret = ogl_tex_upload(m_hCompositeAlphaMap);
 
     return ret;
 }

source/renderer/SkyManager.cpp

@@ -73 +73 @@
     m_SkyCubeMap = 0;
 }
 
+#if CONFIG2_KTX
+# define EXT L".ktx"
+#else
+# define EXT L".dds"
+#endif
 
 ///////////////////////////////////////////////////////////////////
 // Load all sky textures
@@ -116 +121 @@
     
     for (size_t i = 0; i < numTextures+1; ++i)
     {
-        VfsPath path = VfsPath("art/textures/skies") / m_SkySet / (Path::String(images[i])+L".dds");
+        VfsPath path = VfsPath("art/textures/skies") / m_SkySet / (Path::String(images[i]) + L".dds");
         
         shared_ptr<u8> file;
         size_t fileSize;
         if (g_VFS->LoadFile(path, file, fileSize) < 0)
         {
-            VfsPath path2 = VfsPath("art/textures/skies") / m_SkySet / (Path::String(images[i])+L".dds.cached.dds");
+            VfsPath path2 = VfsPath("art/textures/skies") / m_SkySet / (Path::String(images[i]) + L".dds.cached" + EXT);
             if (g_VFS->LoadFile(path2, file, fileSize) < 0)
             {
                 glDeleteTextures(1, &m_SkyCubeMap);
@@ -133 +138 @@
         
         Tex tex;
         tex.decode(file, fileSize);
-        
-        tex.transform_to((tex.m_Flags | TEX_BOTTOM_UP | TEX_ALPHA) & ~(TEX_DXT | TEX_MIPMAPS));
+        if (INFO::OK != tex.transform(tex.glFormatWithAlpha(), TEX_ORIENTATION))
+            break;
         
         u8* data = tex.get_data();
         
@@ -155 +160 @@
                 }
             }
             
-            glTexImage2D(types[i], 0, GL_RGB, tex.m_Width, tex.m_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &rotated[0]);
+            glTexImage2D(types[i], 0, GL_RGBA, tex.m_Width, tex.m_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &rotated[0]);
         }
         else
         {
-            glTexImage2D(types[i], 0, GL_RGB, tex.m_Width, tex.m_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
+            glTexImage2D(types[i], 0, GL_RGBA, tex.m_Width, tex.m_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
         }
     }
     

source/simulation2/components/CCmpAIManager.cpp

@@ -24 +24 @@
 
 #include "graphics/Terrain.h"
 #include "lib/timer.h"
+#include "lib/ogl.h"
 #include "lib/tex/tex.h"
 #include "lib/allocators/shared_ptr.h"
 #include "ps/CLogger.h"
@@ -320 +321 @@
         }
         
         const size_t bpp = 8;
-        int flags = TEX_BOTTOM_UP|TEX_GREY;
+        int flags = TEX_BOTTOM_UP;
         
         const size_t img_size = w * h * bpp/8;
         const size_t hdr_size = tex_hdr_size(filename);
         shared_ptr<u8> buf;
         AllocateAligned(buf, hdr_size+img_size, maxSectorSize);
         Tex t;
-        if (t.wrap(w, h, bpp, flags, buf, hdr_size) < 0)
+        if (t.wrap(GL_LUMINANCE, w, h, bpp, flags, buf, hdr_size) < 0)
             return;
         
         u8* img = buf.get() + hdr_size;

source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp

@@ -203 +203 @@
     }
 
     // Convert to uncompressed BGRA with no mipmaps
-    if (tex.transform_to((tex.m_Flags | TEX_BGR | TEX_ALPHA) & ~(TEX_DXT | TEX_MIPMAPS)) < 0)
+    if (tex.transform(GL_BGRA_EXT) < 0)
     {
         LOGERROR("Failed to transform heightmap.");
         return;