Move compressed textures loading to a separate self-contained library

src/external/rl_gputex.h

@@ -0,0 +1,818 @@
+/**********************************************************************************************
+*
+*   rl_gputex - GPU compressed textures loading and saving
+*
+*   DESCRIPTION:
+*
+*     Load GPU compressed image data from image files provided as memory data arrays,
+*     data is loaded compressed, ready to be loaded into GPU.
+*
+*     Note that some file formats (DDS, PVR, KTX) also support uncompressed data storage.
+*     In those cases data is loaded uncompressed and format is returned.
+* 
+*   TODO:
+*     - Implement raylib function: rlGetGlTextureFormats(), required by rl_save_ktx_to_memory()
+*     - Review rl_load_ktx_from_memory() to support KTX v2.2 specs
+*
+*   CONFIGURATION:
+*
+*   #define RL_GPUTEX_SUPPORT_DDS
+*   #define RL_GPUTEX_SUPPORT_PKM
+*   #define RL_GPUTEX_SUPPORT_KTX
+*   #define RL_GPUTEX_SUPPORT_PVR
+*   #define RL_GPUTEX_SUPPORT_ASTC
+*       Define desired file formats to be supported
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2013-2022 Ramon Santamaria (@raysan5)
+*
+*   This software is provided "as-is", without any express or implied warranty. In no event
+*   will the authors be held liable for any damages arising from the use of this software.
+*
+*   Permission is granted to anyone to use this software for any purpose, including commercial
+*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
+*
+*     1. The origin of this software must not be misrepresented; you must not claim that you
+*     wrote the original software. If you use this software in a product, an acknowledgment
+*     in the product documentation would be appreciated but is not required.
+*
+*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
+*     as being the original software.
+*
+*     3. This notice may not be removed or altered from any source distribution.
+*
+**********************************************************************************************/
+
+#ifndef RL_GPUTEX_H
+#define RL_GPUTEX_H
+
+#ifndef RLAPI
+    #define RLAPI       // Functions defined as 'extern' by default (implicit specifiers)
+#endif
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+#if defined(__cplusplus)
+extern "C" {            // Prevents name mangling of functions
+#endif
+
+// Load image data from memory data files
+RLAPI void *rl_load_dds_from_memory(const unsigned char *file_data, unsigned int file_size, int *width, int *height, int *format, int *mips);
+RLAPI void *rl_load_pkm_from_memory(const unsigned char *file_data, unsigned int file_size, int *width, int *height, int *format, int *mips);
+RLAPI void *rl_load_ktx_from_memory(const unsigned char *file_data, unsigned int file_size, int *width, int *height, int *format, int *mips);
+RLAPI void *rl_load_pvr_from_memory(const unsigned char *file_data, unsigned int file_size, int *width, int *height, int *format, int *mips);
+RLAPI void *rl_load_astc_from_memory(const unsigned char *file_data, unsigned int file_size, int *width, int *height, int *format, int *mips);
+
+RLAPI int rl_save_ktx_to_memory(const char *fileName, void *data, int width, int height, int format, int mipmaps);  // Save image data as KTX file
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // RL_GPUTEX_H
+
+
+/***********************************************************************************
+*
+*   RL_GPUTEX IMPLEMENTATION
+*
+************************************************************************************/
+
+#if defined(RL_GPUTEX_IMPLEMENTATION)
+
+// Simple log system to avoid RPNG_LOG() calls if required
+// NOTE: Avoiding those calls, also avoids const strings memory usage
+#define RL_GPUTEX_SHOW_LOG_INFO
+#if defined(RL_GPUTEX_SHOW_LOG_INFO) && !defined(LOG)
+#define LOG(...) printf(__VA_ARGS__)
+#else
+#define LOG(...)
+#endif
+
+//----------------------------------------------------------------------------------
+// Module Internal Functions Declaration
+//----------------------------------------------------------------------------------
+// Get pixel data size in bytes for certain pixel format
+static int get_pixel_data_size(int width, int height, int format);
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+#if defined(RL_GPUTEX_SUPPORT_DDS)
+// Loading DDS from memory image data (compressed or uncompressed)
+void *rl_load_dds_from_memory(const unsigned char *file_data, unsigned int file_size, int *width, int *height, int *format, int *mips)
+{
+    void *image_data = NULL;        // Image data pointer
+    int image_pixel_size = 0;       // Image pixel size
+
+    unsigned char *file_data_ptr = (unsigned char *)file_data;
+
+    // Required extension:
+    // GL_EXT_texture_compression_s3tc
+
+    // Supported tokens (defined by extensions)
+    // GL_COMPRESSED_RGB_S3TC_DXT1_EXT      0x83F0
+    // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT     0x83F1
+    // GL_COMPRESSED_RGBA_S3TC_DXT3_EXT     0x83F2
+    // GL_COMPRESSED_RGBA_S3TC_DXT5_EXT     0x83F3
+
+    #define FOURCC_DXT1 0x31545844  // Equivalent to "DXT1" in ASCII
+    #define FOURCC_DXT3 0x33545844  // Equivalent to "DXT3" in ASCII
+    #define FOURCC_DXT5 0x35545844  // Equivalent to "DXT5" in ASCII
+
+    // DDS Pixel Format
+    typedef struct {
+        unsigned int size;
+        unsigned int flags;
+        unsigned int fourcc;
+        unsigned int rgb_bit_count;
+        unsigned int r_bit_mask;
+        unsigned int g_bit_mask;
+        unsigned int b_bit_mask;
+        unsigned int a_bit_mask;
+    } dds_pixel_format;
+
+    // DDS Header (124 bytes)
+    typedef struct {
+        unsigned int size;
+        unsigned int flags;
+        unsigned int height;
+        unsigned int width;
+        unsigned int pitch_or_linear_size;
+        unsigned int depth;
+        unsigned int mipmap_count;
+        unsigned int reserved1[11];
+        dds_pixel_format ddspf;
+        unsigned int caps;
+        unsigned int caps2;
+        unsigned int caps3;
+        unsigned int caps4;
+        unsigned int reserved2;
+    } dds_header;
+
+    if (file_data_ptr != NULL)
+    {
+        // Verify the type of file
+        unsigned char *dds_header_id = file_data_ptr;
+        file_data_ptr += 4;
+
+        if ((dds_header_id[0] != 'D') || (dds_header_id[1] != 'D') || (dds_header_id[2] != 'S') || (dds_header_id[3] != ' '))
+        {
+            LOG("WARNING: IMAGE: DDS file data not valid");
+        }
+        else
+        {
+            dds_header *header = (dds_header *)file_data_ptr;
+
+            file_data_ptr += sizeof(dds_header);        // Skip header
+
+            *width = header->width;
+            *height = header->height;
+            image_pixel_size = header->width*header->height;
+
+            if (header->mipmap_count == 0) *mips = 1;   // Parameter not used
+            else *mips = header->mipmap_count;
+
+            if (header->ddspf.rgb_bit_count == 16)      // 16bit mode, no compressed
+            {
+                if (header->ddspf.flags == 0x40)        // No alpha channel
+                {
+                    int data_size = image_pixel_size*sizeof(unsigned short);
+                    image_data = RL_MALLOC(data_size);
+
+                    memcpy(image_data, file_data_ptr, data_size);
+
+                    *format = PIXELFORMAT_UNCOMPRESSED_R5G6B5;
+                }
+                else if (header->ddspf.flags == 0x41)           // With alpha channel
+                {
+                    if (header->ddspf.a_bit_mask == 0x8000)     // 1bit alpha
+                    {
+                        int data_size = image_pixel_size*sizeof(unsigned short);
+                        image_data = RL_MALLOC(data_size);
+
+                        memcpy(image_data, file_data_ptr, data_size);
+
+                        unsigned char alpha = 0;
+
+                        // NOTE: Data comes as A1R5G5B5, it must be reordered to R5G5B5A1
+                        for (int i = 0; i < image_pixel_size; i++)
+                        {
+                            alpha = ((unsigned short *)image_data)[i] >> 15;
+                            ((unsigned short *)image_data)[i] = ((unsigned short *)image_data)[i] << 1;
+                            ((unsigned short *)image_data)[i] += alpha;
+                        }
+
+                        *format = PIXELFORMAT_UNCOMPRESSED_R5G5B5A1;
+                    }
+                    else if (header->ddspf.a_bit_mask == 0xf000)   // 4bit alpha
+                    {
+                        int data_size = image_pixel_size*sizeof(unsigned short);
+                        image_data = RL_MALLOC(data_size);
+
+                        memcpy(image_data, file_data_ptr, data_size);
+
+                        unsigned char alpha = 0;
+
+                        // NOTE: Data comes as A4R4G4B4, it must be reordered R4G4B4A4
+                        for (int i = 0; i < image_pixel_size; i++)
+                        {
+                            alpha = ((unsigned short *)image_data)[i] >> 12;
+                            ((unsigned short *)image_data)[i] = ((unsigned short *)image_data)[i] << 4;
+                            ((unsigned short *)image_data)[i] += alpha;
+                        }
+
+                        *format = PIXELFORMAT_UNCOMPRESSED_R4G4B4A4;
+                    }
+                }
+            }
+            else if (header->ddspf.flags == 0x40 && header->ddspf.rgb_bit_count == 24)   // DDS_RGB, no compressed
+            {
+                int data_size = image_pixel_size*3*sizeof(unsigned char);
+                image_data = RL_MALLOC(data_size);
+
+                memcpy(image_data, file_data_ptr, data_size);
+
+                *format = PIXELFORMAT_UNCOMPRESSED_R8G8B8;
+            }
+            else if (header->ddspf.flags == 0x41 && header->ddspf.rgb_bit_count == 32) // DDS_RGBA, no compressed
+            {
+                int data_size = image_pixel_size*4*sizeof(unsigned char);
+                image_data = RL_MALLOC(data_size);
+
+                memcpy(image_data, file_data_ptr, data_size);
+
+                unsigned char blue = 0;
+
+                // NOTE: Data comes as A8R8G8B8, it must be reordered R8G8B8A8 (view next comment)
+                // DirecX understand ARGB as a 32bit DWORD but the actual memory byte alignment is BGRA
+                // So, we must realign B8G8R8A8 to R8G8B8A8
+                for (int i = 0; i < image_pixel_size*4; i += 4)
+                {
+                    blue = ((unsigned char *)image_data)[i];
+                    ((unsigned char *)image_data)[i] = ((unsigned char *)image_data)[i + 2];
+                    ((unsigned char *)image_data)[i + 2] = blue;
+                }
+
+                *format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
+            }
+            else if (((header->ddspf.flags == 0x04) || (header->ddspf.flags == 0x05)) && (header->ddspf.fourcc > 0)) // Compressed
+            {
+                int data_size = 0;
+
+                // Calculate data size, including all mipmaps
+                if (header->mipmap_count > 1) data_size = header->pitch_or_linear_size*2;
+                else data_size = header->pitch_or_linear_size;
+
+                image_data = RL_MALLOC(data_size*sizeof(unsigned char));
+
+                memcpy(image_data, file_data_ptr, data_size);
+
+                switch (header->ddspf.fourcc)
+                {
+                    case FOURCC_DXT1:
+                    {
+                        if (header->ddspf.flags == 0x04) *format = PIXELFORMAT_COMPRESSED_DXT1_RGB;
+                        else *format = PIXELFORMAT_COMPRESSED_DXT1_RGBA;
+                    } break;
+                    case FOURCC_DXT3: *format = PIXELFORMAT_COMPRESSED_DXT3_RGBA; break;
+                    case FOURCC_DXT5: *format = PIXELFORMAT_COMPRESSED_DXT5_RGBA; break;
+                    default: break;
+                }
+            }
+        }
+    }
+
+    return image_data;
+}
+#endif
+
+#if defined(RL_GPUTEX_SUPPORT_PKM)
+// Loading PKM image data (ETC1/ETC2 compression)
+// NOTE: KTX is the standard Khronos Group compression format (ETC1/ETC2, mipmaps)
+// PKM is a much simpler file format used mainly to contain a single ETC1/ETC2 compressed image (no mipmaps)
+void *rl_load_pkm_from_memory(const unsigned char *file_data, unsigned int file_size, int *width, int *height, int *format, int *mips)
+{
+    void *image_data = NULL;        // Image data pointer
+
+    unsigned char *file_data_ptr = (unsigned char *)file_data;
+
+    // Required extensions:
+    // GL_OES_compressed_ETC1_RGB8_texture  (ETC1) (OpenGL ES 2.0)
+    // GL_ARB_ES3_compatibility  (ETC2/EAC) (OpenGL ES 3.0)
+
+    // Supported tokens (defined by extensions)
+    // GL_ETC1_RGB8_OES                 0x8D64
+    // GL_COMPRESSED_RGB8_ETC2          0x9274
+    // GL_COMPRESSED_RGBA8_ETC2_EAC     0x9278
+
+    // PKM file (ETC1) Header (16 bytes)
+    typedef struct {
+        char id[4];                 // "PKM "
+        char version[2];            // "10" or "20"
+        unsigned short format;      // Data format (big-endian) (Check list below)
+        unsigned short width;       // Texture width (big-endian) (orig_width rounded to multiple of 4)
+        unsigned short height;      // Texture height (big-endian) (orig_height rounded to multiple of 4)
+        unsigned short orig_width;   // Original width (big-endian)
+        unsigned short orig_height;  // Original height (big-endian)
+    } pkm_header;
+
+    // Formats list
+    // version 10: format: 0=ETC1_RGB, [1=ETC1_RGBA, 2=ETC1_RGB_MIP, 3=ETC1_RGBA_MIP] (not used)
+    // version 20: format: 0=ETC1_RGB, 1=ETC2_RGB, 2=ETC2_RGBA_OLD, 3=ETC2_RGBA, 4=ETC2_RGBA1, 5=ETC2_R, 6=ETC2_RG, 7=ETC2_SIGNED_R, 8=ETC2_SIGNED_R
+
+    // NOTE: The extended width and height are the widths rounded up to a multiple of 4.
+    // NOTE: ETC is always 4bit per pixel (64 bit for each 4x4 block of pixels)
+
+    if (file_data_ptr != NULL)
+    {
+        pkm_header *header = (pkm_header *)file_data_ptr;
+
+        if ((header->id[0] != 'P') || (header->id[1] != 'K') || (header->id[2] != 'M') || (header->id[3] != ' '))
+        {
+            LOG("WARNING: IMAGE: PKM file data not valid");
+        }
+        else
+        {
+            file_data_ptr += sizeof(pkm_header);   // Skip header
+
+            // NOTE: format, width and height come as big-endian, data must be swapped to little-endian
+            header->format = ((header->format & 0x00FF) << 8) | ((header->format & 0xFF00) >> 8);
+            header->width = ((header->width & 0x00FF) << 8) | ((header->width & 0xFF00) >> 8);
+            header->height = ((header->height & 0x00FF) << 8) | ((header->height & 0xFF00) >> 8);
+
+            *width = header->width;
+            *height = header->height;
+            *mips = 1;
+
+            int bpp = 4;
+            if (header->format == 3) bpp = 8;
+
+            int data_size = (*width)*(*height)*bpp/8;  // Total data size in bytes
+
+            image_data = RL_MALLOC(data_size*sizeof(unsigned char));
+
+            memcpy(image_data, file_data_ptr, data_size);
+
+            if (header->format == 0) *format = PIXELFORMAT_COMPRESSED_ETC1_RGB;
+            else if (header->format == 1) *format = PIXELFORMAT_COMPRESSED_ETC2_RGB;
+            else if (header->format == 3) *format = PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA;
+        }
+    }
+
+    return image_data;
+}
+#endif
+
+#if defined(RL_GPUTEX_SUPPORT_KTX)
+// Load KTX compressed image data (ETC1/ETC2 compression)
+// TODO: Review KTX loading, many things changed!
+void *rl_load_ktx_from_memory(const unsigned char *file_data, unsigned int file_size, int *width, int *height, int *format, int *mips)
+{
+    void *image_data = NULL;        // Image data pointer
+
+    unsigned char *file_data_ptr = (unsigned char *)file_data;
+
+    // Required extensions:
+    // GL_OES_compressed_ETC1_RGB8_texture  (ETC1)
+    // GL_ARB_ES3_compatibility  (ETC2/EAC)
+
+    // Supported tokens (defined by extensions)
+    // GL_ETC1_RGB8_OES                 0x8D64
+    // GL_COMPRESSED_RGB8_ETC2          0x9274
+    // GL_COMPRESSED_RGBA8_ETC2_EAC     0x9278
+
+    // KTX file Header (64 bytes)
+    // v1.1 - https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
+    // v2.0 - http://github.khronos.org/KTX-Specification/
+
+    // KTX 1.1 Header
+    // TODO: Support KTX 2.2 specs!
+    typedef struct {
+        char id[12];                            // Identifier: "«KTX 11»\r\n\x1A\n"
+        unsigned int endianness;                // Little endian: 0x01 0x02 0x03 0x04
+        unsigned int gl_type;                   // For compressed textures, glType must equal 0
+        unsigned int gl_type_size;              // For compressed texture data, usually 1
+        unsigned int gl_format;                 // For compressed textures is 0
+        unsigned int gl_internal_format;        // Compressed internal format
+        unsigned int gl_base_internal_format;   // Same as glFormat (RGB, RGBA, ALPHA...)
+        unsigned int width;                     // Texture image width in pixels
+        unsigned int height;                    // Texture image height in pixels
+        unsigned int depth;                     // For 2D textures is 0
+        unsigned int elements;                  // Number of array elements, usually 0
+        unsigned int faces;                     // Cubemap faces, for no-cubemap = 1
+        unsigned int mipmap_levels;             // Non-mipmapped textures = 1
+        unsigned int key_value_data_size;       // Used to encode any arbitrary data...
+    } ktx_header;
+
+    // NOTE: Before start of every mipmap data block, we have: unsigned int data_size
+
+    if (file_data_ptr != NULL)
+    {
+        ktx_header *header = (ktx_header *)file_data_ptr;
+
+        if ((header->id[1] != 'K') || (header->id[2] != 'T') || (header->id[3] != 'X') ||
+            (header->id[4] != ' ') || (header->id[5] != '1') || (header->id[6] != '1'))
+        {
+            LOG("WARNING: IMAGE: KTX file data not valid");
+        }
+        else
+        {
+            file_data_ptr += sizeof(ktx_header);           // Move file data pointer
+
+            *width = header->width;
+            *height = header->height;
+            *mips = header->mipmap_levels;
+
+            file_data_ptr += header->key_value_data_size; // Skip value data size
+
+            int data_size = ((int *)file_data_ptr)[0];
+            file_data_ptr += sizeof(int);
+
+            image_data = RL_MALLOC(data_size*sizeof(unsigned char));
+
+            memcpy(image_data, file_data_ptr, data_size);
+
+            if (header->gl_internal_format == 0x8D64) *format = PIXELFORMAT_COMPRESSED_ETC1_RGB;
+            else if (header->gl_internal_format == 0x9274) *format = PIXELFORMAT_COMPRESSED_ETC2_RGB;
+            else if (header->gl_internal_format == 0x9278) *format = PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA;
+
+            // TODO: Support uncompressed data formats? Right now it returns format = 0!
+        }
+    }
+
+    return image_data;
+}
+
+// Save image data as KTX file
+// NOTE: By default KTX 1.1 spec is used, 2.0 is still on draft (01Oct2018)
+// TODO: Review KTX saving, many things changed!
+int rl_save_ktx(const char *file_name, void *data, int width, int height, int format, int mipmaps)
+{
+    // KTX file Header (64 bytes)
+    // v1.1 - https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
+    // v2.0 - http://github.khronos.org/KTX-Specification/ - Final specs by 2021-04-18
+    typedef struct {
+        char id[12];                            // Identifier: "«KTX 11»\r\n\x1A\n"         // KTX 2.0: "«KTX 22»\r\n\x1A\n"
+        unsigned int endianness;                // Little endian: 0x01 0x02 0x03 0x04
+        unsigned int gl_type;                   // For compressed textures, glType must equal 0
+        unsigned int gl_type_size;              // For compressed texture data, usually 1
+        unsigned int gl_format;                 // For compressed textures is 0
+        unsigned int gl_internal_format;        // Compressed internal format
+        unsigned int gl_base_internal_format;   // Same as glFormat (RGB, RGBA, ALPHA...)   // KTX 2.0: UInt32 vkFormat
+        unsigned int width;                     // Texture image width in pixels
+        unsigned int height;                    // Texture image height in pixels
+        unsigned int depth;                     // For 2D textures is 0
+        unsigned int elements;                  // Number of array elements, usually 0
+        unsigned int faces;                     // Cubemap faces, for no-cubemap = 1
+        unsigned int mipmap_levels;             // Non-mipmapped textures = 1
+        unsigned int key_value_data_size;       // Used to encode any arbitrary data...     // KTX 2.0: UInt32 levelOrder - ordering of the mipmap levels, usually 0
+                                                                                            // KTX 2.0: UInt32 supercompressionScheme - 0 (None), 1 (Crunch CRN), 2 (Zlib DEFLATE)...
+        // KTX 2.0 defines additional header elements...
+    } ktx_header;
+
+    // Calculate file data_size required
+    int data_size = sizeof(ktx_header);
+
+    for (int i = 0, width = width, height = height; i < mipmaps; i++)
+    {
+        data_size += get_pixel_data_size(width, height, format);
+        width /= 2; height /= 2;
+    }
+
+    unsigned char *file_data = RL_CALLOC(data_size, 1);
+    unsigned char *file_data_ptr = file_data;
+
+    ktx_header header = { 0 };
+
+    // KTX identifier (v1.1)
+    //unsigned char id[12] = { '«', 'K', 'T', 'X', ' ', '1', '1', '»', '\r', '\n', '\x1A', '\n' };
+    //unsigned char id[12] = { 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A };
+
+    const char ktx_identifier[12] = { 0xAB, 'K', 'T', 'X', ' ', '1', '1', 0xBB, '\r', '\n', 0x1A, '\n' };
+
+    // Get the image header
+    memcpy(header.id, ktx_identifier, 12);  // KTX 1.1 signature
+    header.endianness = 0;
+    header.gl_type = 0;                     // Obtained from format
+    header.gl_type_size = 1;
+    header.gl_format = 0;                   // Obtained from format
+    header.gl_internal_format = 0;          // Obtained from format
+    header.gl_base_internal_format = 0;
+    header.width = width;
+    header.height = height;
+    header.depth = 0;
+    header.elements = 0;
+    header.faces = 1;
+    header.mipmap_levels = mipmaps;         // If it was 0, it means mipmaps should be generated on loading (not for compressed formats)
+    header.key_value_data_size = 0;         // No extra data after the header
+
+    rlGetGlTextureFormats(format, &header.gl_internal_format, &header.gl_format, &header.gl_type);   // rlgl module function
+    header.gl_base_internal_format = header.gl_format;    // KTX 1.1 only
+
+    // NOTE: We can save into a .ktx all PixelFormats supported by raylib, including compressed formats like DXT, ETC or ASTC
+
+    if (header.gl_format == -1) LOG("WARNING: IMAGE: GL format not supported for KTX export (%i)", header.gl_format);
+    else
+    {
+        memcpy(file_data_ptr, &header, sizeof(ktx_header));
+        file_data_ptr += sizeof(ktx_header);
+
+        int temp_width = width;
+        int temp_height = height;
+        int data_offset = 0;
+
+        // Save all mipmaps data
+        for (int i = 0; i < mipmaps; i++)
+        {
+            unsigned int data_size = get_pixel_data_size(temp_width, temp_height, format);
+
+            memcpy(file_data_ptr, &data_size, sizeof(unsigned int));
+            memcpy(file_data_ptr + 4, (unsigned char *)data + data_offset, data_size);
+
+            temp_width /= 2;
+            temp_height /= 2;
+            data_offset += data_size;
+            file_data_ptr += (4 + data_size);
+        }
+    }
+
+    // Save file data to file
+    int success = false;
+    FILE *file = fopen(file_name, "wb");
+
+    if (file != NULL)
+    {
+        unsigned int count = (unsigned int)fwrite(file_data, sizeof(unsigned char), data_size, file);
+
+        if (count == 0) LOG("WARNING: FILEIO: [%s] Failed to write file", file_name);
+        else if (count != data_size) LOG("WARNING: FILEIO: [%s] File partially written", file_name);
+        else LOG("INFO: FILEIO: [%s] File saved successfully", file_name);
+
+        int result = fclose(file);
+        if (result == 0) success = true;
+    }
+    else LOG("WARNING: FILEIO: [%s] Failed to open file", file_name);
+
+    RL_FREE(file_data);    // Free file data buffer
+
+    // If all data has been written correctly to file, success = 1
+    return success;
+}
+#endif
+
+#if defined(RL_GPUTEX_SUPPORT_PVR)
+// Loading PVR image data (uncompressed or PVRT compression)
+// NOTE: PVR v2 not supported, use PVR v3 instead
+void *rl_load_pvr_from_memory(const unsigned char *file_data, unsigned int file_size, int *width, int *height, int *format, int *mips)
+{
+    void *image_data = NULL;        // Image data pointer
+
+    unsigned char *file_data_ptr = (unsigned char *)file_data;
+
+    // Required extension:
+    // GL_IMG_texture_compression_pvrtc
+
+    // Supported tokens (defined by extensions)
+    // GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG       0x8C00
+    // GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG      0x8C02
+
+#if 0   // Not used...
+    // PVR file v2 Header (52 bytes)
+    typedef struct {
+        unsigned int headerLength;
+        unsigned int height;
+        unsigned int width;
+        unsigned int numMipmaps;
+        unsigned int flags;
+        unsigned int dataLength;
+        unsigned int bpp;
+        unsigned int bitmaskRed;
+        unsigned int bitmaskGreen;
+        unsigned int bitmaskBlue;
+        unsigned int bitmaskAlpha;
+        unsigned int pvrTag;
+        unsigned int numSurfs;
+    } PVRHeaderV2;
+#endif
+
+    // PVR file v3 Header (52 bytes)
+    // NOTE: After it could be metadata (15 bytes?)
+    typedef struct {
+        char id[4];
+        unsigned int flags;
+        unsigned char channels[4];      // pixelFormat high part
+        unsigned char channel_depth[4];  // pixelFormat low part
+        unsigned int color_space;
+        unsigned int channel_type;
+        unsigned int height;
+        unsigned int width;
+        unsigned int depth;
+        unsigned int num_surfaces;
+        unsigned int num_faces;
+        unsigned int num_mipmaps;
+        unsigned int metadata_size;
+    } pvr_header;
+
+#if 0   // Not used...
+    // Metadata (usually 15 bytes)
+    typedef struct {
+        unsigned int devFOURCC;
+        unsigned int key;
+        unsigned int data_size;      // Not used?
+        unsigned char *data;        // Not used?
+    } PVRMetadata;
+#endif
+
+    if (file_data_ptr != NULL)
+    {
+        // Check PVR image version
+        unsigned char pvr_version = file_data_ptr[0];
+
+        // Load different PVR data formats
+        if (pvr_version == 0x50)
+        {
+            pvr_header *header = (pvr_header *)file_data_ptr;
+
+            if ((header->id[0] != 'P') || (header->id[1] != 'V') || (header->id[2] != 'R') || (header->id[3] != 3))
+            {
+                LOG("WARNING: IMAGE: PVR file data not valid");
+            }
+            else
+            {
+                file_data_ptr += sizeof(pvr_header);   // Skip header
+
+                *width = header->width;
+                *height = header->height;
+                *mips = header->num_mipmaps;
+
+                // Check data format
+                if (((header->channels[0] == 'l') && (header->channels[1] == 0)) && (header->channel_depth[0] == 8)) *format = PIXELFORMAT_UNCOMPRESSED_GRAYSCALE;
+                else if (((header->channels[0] == 'l') && (header->channels[1] == 'a')) && ((header->channel_depth[0] == 8) && (header->channel_depth[1] == 8))) *format = PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA;
+                else if ((header->channels[0] == 'r') && (header->channels[1] == 'g') && (header->channels[2] == 'b'))
+                {
+                    if (header->channels[3] == 'a')
+                    {
+                        if ((header->channel_depth[0] == 5) && (header->channel_depth[1] == 5) && (header->channel_depth[2] == 5) && (header->channel_depth[3] == 1)) *format = PIXELFORMAT_UNCOMPRESSED_R5G5B5A1;
+                        else if ((header->channel_depth[0] == 4) && (header->channel_depth[1] == 4) && (header->channel_depth[2] == 4) && (header->channel_depth[3] == 4)) *format = PIXELFORMAT_UNCOMPRESSED_R4G4B4A4;
+                        else if ((header->channel_depth[0] == 8) && (header->channel_depth[1] == 8) && (header->channel_depth[2] == 8) && (header->channel_depth[3] == 8)) *format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
+                    }
+                    else if (header->channels[3] == 0)
+                    {
+                        if ((header->channel_depth[0] == 5) && (header->channel_depth[1] == 6) && (header->channel_depth[2] == 5)) *format = PIXELFORMAT_UNCOMPRESSED_R5G6B5;
+                        else if ((header->channel_depth[0] == 8) && (header->channel_depth[1] == 8) && (header->channel_depth[2] == 8)) *format = PIXELFORMAT_UNCOMPRESSED_R8G8B8;
+                    }
+                }
+                else if (header->channels[0] == 2) *format = PIXELFORMAT_COMPRESSED_PVRT_RGB;
+                else if (header->channels[0] == 3) *format = PIXELFORMAT_COMPRESSED_PVRT_RGBA;
+
+                file_data_ptr += header->metadata_size;    // Skip meta data header
+
+                // Calculate data size (depends on format)
+                int bpp = 0;
+                switch (*format)
+                {
+                    case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break;
+                    case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
+                    case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
+                    case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
+                    case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break;
+                    case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break;
+                    case PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break;
+                    case PIXELFORMAT_COMPRESSED_PVRT_RGB:
+                    case PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break;
+                    default: break;
+                }
+
+                int data_size = (*width)*(*height)*bpp/8;  // Total data size in bytes
+                image_data = RL_MALLOC(data_size*sizeof(unsigned char));
+
+                memcpy(image_data, file_data_ptr, data_size);
+            }
+        }
+        else if (pvr_version == 52) LOG("INFO: IMAGE: PVRv2 format not supported, update your files to PVRv3");
+    }
+
+    return image_data;
+}
+#endif
+
+#if defined(RL_GPUTEX_SUPPORT_ASTC)
+// Load ASTC compressed image data (ASTC compression)
+void *rl_load_astc_from_memory(const unsigned char *file_data, unsigned int file_size, int *width, int *height, int *format, int *mips)
+{
+    void *image_data = NULL;        // Image data pointer
+
+    unsigned char *file_data_ptr = (unsigned char *)file_data;
+
+    // Required extensions:
+    // GL_KHR_texture_compression_astc_hdr
+    // GL_KHR_texture_compression_astc_ldr
+
+    // Supported tokens (defined by extensions)
+    // GL_COMPRESSED_RGBA_ASTC_4x4_KHR      0x93b0
+    // GL_COMPRESSED_RGBA_ASTC_8x8_KHR      0x93b7
+
+    // ASTC file Header (16 bytes)
+    typedef struct {
+        unsigned char id[4];        // Signature: 0x13 0xAB 0xA1 0x5C
+        unsigned char blockX;       // Block X dimensions
+        unsigned char blockY;       // Block Y dimensions
+        unsigned char blockZ;       // Block Z dimensions (1 for 2D images)
+        unsigned char width[3];     // void *width in pixels (24bit value)
+        unsigned char height[3];    // void *height in pixels (24bit value)
+        unsigned char length[3];    // void *Z-size (1 for 2D images)
+    } astc_header;
+
+    if (file_data_ptr != NULL)
+    {
+        astc_header *header = (astc_header *)file_data_ptr;
+
+        if ((header->id[3] != 0x5c) || (header->id[2] != 0xa1) || (header->id[1] != 0xab) || (header->id[0] != 0x13))
+        {
+            LOG("WARNING: IMAGE: ASTC file data not valid");
+        }
+        else
+        {
+            file_data_ptr += sizeof(astc_header);   // Skip header
+
+            // NOTE: Assuming Little Endian (could it be wrong?)
+            *width = 0x00000000 | ((int)header->width[2] << 16) | ((int)header->width[1] << 8) | ((int)header->width[0]);
+            *height = 0x00000000 | ((int)header->height[2] << 16) | ((int)header->height[1] << 8) | ((int)header->height[0]);
+            *mips = 1;      // NOTE: ASTC format only contains one mipmap level
+
+            // NOTE: Each block is always stored in 128bit so we can calculate the bpp
+            int bpp = 128/(header->blockX*header->blockY);
+
+            // NOTE: Currently we only support 2 blocks configurations: 4x4 and 8x8
+            if ((bpp == 8) || (bpp == 2))
+            {
+                int data_size = (*width)*(*height)*bpp/8;  // Data size in bytes
+
+                image_data = RL_MALLOC(data_size*sizeof(unsigned char));
+
+                memcpy(image_data, file_data_ptr, data_size);
+
+                if (bpp == 8) *format = PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA;
+                else if (bpp == 2) *format = PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA;
+            }
+            else LOG("WARNING: IMAGE: ASTC block size configuration not supported");
+        }
+    }
+
+    return image_data;
+}
+#endif
+
+//----------------------------------------------------------------------------------
+// Module Internal Functions Definition
+//----------------------------------------------------------------------------------
+// Get pixel data size in bytes for certain pixel format
+static int get_pixel_data_size(int width, int height, int format)
+{
+    int data_size = 0;       // Size in bytes
+    int bpp = 0;            // Bits per pixel
+
+    switch (format)
+    {
+    case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break;
+    case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
+    case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
+    case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
+    case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break;
+    case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break;
+    case PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break;
+    case PIXELFORMAT_UNCOMPRESSED_R32: bpp = 32; break;
+    case PIXELFORMAT_UNCOMPRESSED_R32G32B32: bpp = 32*3; break;
+    case PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: bpp = 32*4; break;
+    case PIXELFORMAT_COMPRESSED_DXT1_RGB:
+    case PIXELFORMAT_COMPRESSED_DXT1_RGBA:
+    case PIXELFORMAT_COMPRESSED_ETC1_RGB:
+    case PIXELFORMAT_COMPRESSED_ETC2_RGB:
+    case PIXELFORMAT_COMPRESSED_PVRT_RGB:
+    case PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break;
+    case PIXELFORMAT_COMPRESSED_DXT3_RGBA:
+    case PIXELFORMAT_COMPRESSED_DXT5_RGBA:
+    case PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA:
+    case PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: bpp = 8; break;
+    case PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: bpp = 2; break;
+    default: break;
+    }
+
+    data_size = width*height*bpp/8;  // Total data size in bytes
+
+    // Most compressed formats works on 4x4 blocks,
+    // if texture is smaller, minimum dataSize is 8 or 16
+    if ((width < 4) && (height < 4))
+    {
+        if ((format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) && (format < PIXELFORMAT_COMPRESSED_DXT3_RGBA)) data_size = 8;
+        else if ((format >= PIXELFORMAT_COMPRESSED_DXT3_RGBA) && (format < PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)) data_size = 16;
+    }
+
+    return data_size;
+}
+
+#endif // RL_GPUTEX_IMPLEMENTATION

src/rtextures.c

@@ -104,6 +104,22 @@
     #define STBI_NO_HDR
 #endif
 
+#if defined(SUPPORT_FILEFORMAT_DDS)
+    #define RL_GPUTEX_SUPPORT_DDS
+#endif
+#if defined(SUPPORT_FILEFORMAT_PKM)
+    #define RL_GPUTEX_SUPPORT_PKM
+#endif
+#if defined(SUPPORT_FILEFORMAT_KTX)
+    #define RL_GPUTEX_SUPPORT_KTX
+#endif
+#if defined(SUPPORT_FILEFORMAT_PVR)
+    #define RL_GPUTEX_SUPPORT_PVR
+#endif
+#if defined(SUPPORT_FILEFORMAT_ASTC)
+    #define RL_GPUTEX_SUPPORT_ASTC
+#endif
+
 // Image fileformats not supported by default
 #define STBI_NO_PIC
 #define STBI_NO_PNM             // Image format .ppm and .pgm
@@ -130,6 +146,17 @@
                                             // NOTE: Used to read image data (multiple formats support)
 #endif
 
+#if (defined(SUPPORT_FILEFORMAT_DDS) || \
+     defined(SUPPORT_FILEFORMAT_PKM) || \
+     defined(SUPPORT_FILEFORMAT_KTX) || \
+     defined(SUPPORT_FILEFORMAT_PVR) || \
+     defined(SUPPORT_FILEFORMAT_ASTC))
+
+    #define RL_GPUTEX_IMPLEMENTATION
+    #include "external/rl_gputex.h"         // Required for: rl_load_xxx_from_memory()
+                                            // NOTE: Used to read compressed textures data (multiple formats support)
+#endif
+
 #if defined(SUPPORT_FILEFORMAT_QOI)
     #define QOI_MALLOC RL_MALLOC
     #define QOI_FREE RL_FREE
@@ -185,23 +212,6 @@
 //----------------------------------------------------------------------------------
 // Module specific Functions Declaration
 //----------------------------------------------------------------------------------
-#if defined(SUPPORT_FILEFORMAT_DDS)
-static Image LoadDDS(const unsigned char *fileData, unsigned int fileSize);   // Load DDS file data
-#endif
-#if defined(SUPPORT_FILEFORMAT_PKM)
-static Image LoadPKM(const unsigned char *fileData, unsigned int fileSize);   // Load PKM file data
-#endif
-#if defined(SUPPORT_FILEFORMAT_KTX)
-static Image LoadKTX(const unsigned char *fileData, unsigned int fileSize);   // Load KTX file data
-static int SaveKTX(Image image, const char *fileName);  // Save image data as KTX file
-#endif
-#if defined(SUPPORT_FILEFORMAT_PVR)
-static Image LoadPVR(const unsigned char *fileData, unsigned int fileSize);   // Load PVR file data
-#endif
-#if defined(SUPPORT_FILEFORMAT_ASTC)
-static Image LoadASTC(const unsigned char *fileData, unsigned int fileSize);  // Load ASTC file data
-#endif
-
 static Vector4 *LoadImageDataNormalized(Image image);       // Load pixel data from image as Vector4 array (float normalized)
 
 //----------------------------------------------------------------------------------
@@ -333,7 +343,7 @@ Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, i
 #if defined(SUPPORT_FILEFORMAT_PSD)
         || (strcmp(fileType, ".psd") == 0)
 #endif
-       )
+        )
     {
 #if defined(STBI_REQUIRED)
         // NOTE: Using stb_image to load images (Supports multiple image formats)
@@ -390,19 +400,35 @@ Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, i
     }
 #endif
 #if defined(SUPPORT_FILEFORMAT_DDS)
-    else if (strcmp(fileType, ".dds") == 0) image = LoadDDS(fileData, dataSize);
+    else if (strcmp(fileType, ".dds") == 0)
+    {
+        int format = 0;
+        image.data = rl_load_dds_from_memory(fileData, dataSize, &image.width, &image.height, &image.format, &image.mipmaps);
+    }
 #endif
 #if defined(SUPPORT_FILEFORMAT_PKM)
-    else if (strcmp(fileType, ".pkm") == 0) image = LoadPKM(fileData, dataSize);
+    else if (strcmp(fileType, ".pkm") == 0)
+    {
+        image.data = rl_load_pkm_from_memory(fileData, dataSize, &image.width, &image.height, &image.format, &image.mipmaps);
+    }
 #endif
 #if defined(SUPPORT_FILEFORMAT_KTX)
-    else if (strcmp(fileType, ".ktx") == 0) image = LoadKTX(fileData, dataSize);
+    else if (strcmp(fileType, ".ktx") == 0)
+    {
+        image.data = rl_load_ktx_from_memory(fileData, dataSize, &image.width, &image.height, &image.format, &image.mipmaps);
+    }
 #endif
 #if defined(SUPPORT_FILEFORMAT_PVR)
-    else if (strcmp(fileType, ".pvr") == 0) image = LoadPVR(fileData, dataSize);
+    else if (strcmp(fileType, ".pvr") == 0)
+    {
+        image.data = rl_load_pvr_from_memory(fileData, dataSize, &image.width, &image.height, &image.format, &image.mipmaps);
+    }
 #endif
 #if defined(SUPPORT_FILEFORMAT_ASTC)
-    else if (strcmp(fileType, ".astc") == 0) image = LoadASTC(fileData, dataSize);
+    else if (strcmp(fileType, ".astc") == 0)
+    {
+        image.data = rl_load_astc_from_memory(fileData, dataSize, &image.width, &image.height, &image.format, &image.mipmaps);
+    }
 #endif
     else TRACELOG(LOG_WARNING, "IMAGE: Data format not supported");
 
@@ -528,7 +554,10 @@ bool ExportImage(Image image, const char *fileName)
     }
 #endif
 #if defined(SUPPORT_FILEFORMAT_KTX)
-    else if (IsFileExtension(fileName, ".ktx")) success = SaveKTX(image, fileName);
+    else if (IsFileExtension(fileName, ".ktx"))
+    {
+        success = rl_save_ktx(fileName, image.data, image.width, image.height, image.format, image.mipmaps);
+    }
 #endif
     else if (IsFileExtension(fileName, ".raw"))
     {
@@ -3253,104 +3282,6 @@ void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color
     DrawTexturePro(texture, source, dest, origin, 0.0f, tint);
 }
 
-// Draw texture quad with tiling and offset parameters
-// NOTE: Tiling and offset should be provided considering normalized texture values [0..1]
-// i.e tiling = { 1.0f, 1.0f } refers to all texture, offset = { 0.5f, 0.5f } moves texture origin to center
-void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint)
-{
-    // WARNING: This solution only works if TEXTURE_WRAP_REPEAT is supported,
-    // NPOT textures supported is required and OpenGL ES 2.0 could not support it
-    Rectangle source = { offset.x*texture.width, offset.y*texture.height, tiling.x*texture.width, tiling.y*texture.height };
-    Vector2 origin = { 0.0f, 0.0f };
-
-    DrawTexturePro(texture, source, quad, origin, 0.0f, tint);
-}
-
-// Draw part of a texture (defined by a rectangle) with rotation and scale tiled into dest.
-// NOTE: For tilling a whole texture DrawTextureQuad() is better
-void DrawTextureTiled(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, float scale, Color tint)
-{
-    if ((texture.id <= 0) || (scale <= 0.0f)) return;  // Wanna see a infinite loop?!...just delete this line!
-    if ((source.width == 0) || (source.height == 0)) return;
-
-    int tileWidth = (int)(source.width*scale), tileHeight = (int)(source.height*scale);
-    if ((dest.width < tileWidth) && (dest.height < tileHeight))
-    {
-        // Can fit only one tile
-        DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)dest.width/tileWidth)*source.width, ((float)dest.height/tileHeight)*source.height},
-                    (Rectangle){dest.x, dest.y, dest.width, dest.height}, origin, rotation, tint);
-    }
-    else if (dest.width <= tileWidth)
-    {
-        // Tiled vertically (one column)
-        int dy = 0;
-        for (;dy+tileHeight < dest.height; dy += tileHeight)
-        {
-            DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)dest.width/tileWidth)*source.width, source.height}, (Rectangle){dest.x, dest.y + dy, dest.width, (float)tileHeight}, origin, rotation, tint);
-        }
-
-        // Fit last tile
-        if (dy < dest.height)
-        {
-            DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)dest.width/tileWidth)*source.width, ((float)(dest.height - dy)/tileHeight)*source.height},
-                        (Rectangle){dest.x, dest.y + dy, dest.width, dest.height - dy}, origin, rotation, tint);
-        }
-    }
-    else if (dest.height <= tileHeight)
-    {
-        // Tiled horizontally (one row)
-        int dx = 0;
-        for (;dx+tileWidth < dest.width; dx += tileWidth)
-        {
-            DrawTexturePro(texture, (Rectangle){source.x, source.y, source.width, ((float)dest.height/tileHeight)*source.height}, (Rectangle){dest.x + dx, dest.y, (float)tileWidth, dest.height}, origin, rotation, tint);
-        }
-
-        // Fit last tile
-        if (dx < dest.width)
-        {
-            DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)(dest.width - dx)/tileWidth)*source.width, ((float)dest.height/tileHeight)*source.height},
-                        (Rectangle){dest.x + dx, dest.y, dest.width - dx, dest.height}, origin, rotation, tint);
-        }
-    }
-    else
-    {
-        // Tiled both horizontally and vertically (rows and columns)
-        int dx = 0;
-        for (;dx+tileWidth < dest.width; dx += tileWidth)
-        {
-            int dy = 0;
-            for (;dy+tileHeight < dest.height; dy += tileHeight)
-            {
-                DrawTexturePro(texture, source, (Rectangle){dest.x + dx, dest.y + dy, (float)tileWidth, (float)tileHeight}, origin, rotation, tint);
-            }
-
-            if (dy < dest.height)
-            {
-                DrawTexturePro(texture, (Rectangle){source.x, source.y, source.width, ((float)(dest.height - dy)/tileHeight)*source.height},
-                    (Rectangle){dest.x + dx, dest.y + dy, (float)tileWidth, dest.height - dy}, origin, rotation, tint);
-            }
-        }
-
-        // Fit last column of tiles
-        if (dx < dest.width)
-        {
-            int dy = 0;
-            for (;dy+tileHeight < dest.height; dy += tileHeight)
-            {
-                DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)(dest.width - dx)/tileWidth)*source.width, source.height},
-                        (Rectangle){dest.x + dx, dest.y + dy, dest.width - dx, (float)tileHeight}, origin, rotation, tint);
-            }
-
-            // Draw final tile in the bottom right corner
-            if (dy < dest.height)
-            {
-                DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)(dest.width - dx)/tileWidth)*source.width, ((float)(dest.height - dy)/tileHeight)*source.height},
-                    (Rectangle){dest.x + dx, dest.y + dy, dest.width - dx, dest.height - dy}, origin, rotation, tint);
-            }
-        }
-    }
-}
-
 // Draw a part of a texture (defined by a rectangle) with 'pro' parameters
 // NOTE: origin is relative to destination rectangle size
 void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint)
@@ -3474,6 +3405,104 @@ void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2
     }
 }
 
+// Draw texture quad with tiling and offset parameters
+// NOTE: Tiling and offset should be provided considering normalized texture values [0..1]
+// i.e tiling = { 1.0f, 1.0f } refers to all texture, offset = { 0.5f, 0.5f } moves texture origin to center
+void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint)
+{
+    // WARNING: This solution only works if TEXTURE_WRAP_REPEAT is supported,
+    // NPOT textures supported is required and OpenGL ES 2.0 could not support it
+    Rectangle source = { offset.x*texture.width, offset.y*texture.height, tiling.x*texture.width, tiling.y*texture.height };
+    Vector2 origin = { 0.0f, 0.0f };
+
+    DrawTexturePro(texture, source, quad, origin, 0.0f, tint);
+}
+
+// Draw part of a texture (defined by a rectangle) with rotation and scale tiled into dest.
+// NOTE: For tilling a whole texture DrawTextureQuad() is better
+void DrawTextureTiled(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, float scale, Color tint)
+{
+    if ((texture.id <= 0) || (scale <= 0.0f)) return;  // Wanna see a infinite loop?!...just delete this line!
+    if ((source.width == 0) || (source.height == 0)) return;
+
+    int tileWidth = (int)(source.width*scale), tileHeight = (int)(source.height*scale);
+    if ((dest.width < tileWidth) && (dest.height < tileHeight))
+    {
+        // Can fit only one tile
+        DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)dest.width/tileWidth)*source.width, ((float)dest.height/tileHeight)*source.height},
+                    (Rectangle){dest.x, dest.y, dest.width, dest.height}, origin, rotation, tint);
+    }
+    else if (dest.width <= tileWidth)
+    {
+        // Tiled vertically (one column)
+        int dy = 0;
+        for (;dy+tileHeight < dest.height; dy += tileHeight)
+        {
+            DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)dest.width/tileWidth)*source.width, source.height}, (Rectangle){dest.x, dest.y + dy, dest.width, (float)tileHeight}, origin, rotation, tint);
+        }
+
+        // Fit last tile
+        if (dy < dest.height)
+        {
+            DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)dest.width/tileWidth)*source.width, ((float)(dest.height - dy)/tileHeight)*source.height},
+                        (Rectangle){dest.x, dest.y + dy, dest.width, dest.height - dy}, origin, rotation, tint);
+        }
+    }
+    else if (dest.height <= tileHeight)
+    {
+        // Tiled horizontally (one row)
+        int dx = 0;
+        for (;dx+tileWidth < dest.width; dx += tileWidth)
+        {
+            DrawTexturePro(texture, (Rectangle){source.x, source.y, source.width, ((float)dest.height/tileHeight)*source.height}, (Rectangle){dest.x + dx, dest.y, (float)tileWidth, dest.height}, origin, rotation, tint);
+        }
+
+        // Fit last tile
+        if (dx < dest.width)
+        {
+            DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)(dest.width - dx)/tileWidth)*source.width, ((float)dest.height/tileHeight)*source.height},
+                        (Rectangle){dest.x + dx, dest.y, dest.width - dx, dest.height}, origin, rotation, tint);
+        }
+    }
+    else
+    {
+        // Tiled both horizontally and vertically (rows and columns)
+        int dx = 0;
+        for (;dx+tileWidth < dest.width; dx += tileWidth)
+        {
+            int dy = 0;
+            for (;dy+tileHeight < dest.height; dy += tileHeight)
+            {
+                DrawTexturePro(texture, source, (Rectangle){dest.x + dx, dest.y + dy, (float)tileWidth, (float)tileHeight}, origin, rotation, tint);
+            }
+
+            if (dy < dest.height)
+            {
+                DrawTexturePro(texture, (Rectangle){source.x, source.y, source.width, ((float)(dest.height - dy)/tileHeight)*source.height},
+                    (Rectangle){dest.x + dx, dest.y + dy, (float)tileWidth, dest.height - dy}, origin, rotation, tint);
+            }
+        }
+
+        // Fit last column of tiles
+        if (dx < dest.width)
+        {
+            int dy = 0;
+            for (;dy+tileHeight < dest.height; dy += tileHeight)
+            {
+                DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)(dest.width - dx)/tileWidth)*source.width, source.height},
+                        (Rectangle){dest.x + dx, dest.y + dy, dest.width - dx, (float)tileHeight}, origin, rotation, tint);
+            }
+
+            // Draw final tile in the bottom right corner
+            if (dy < dest.height)
+            {
+                DrawTexturePro(texture, (Rectangle){source.x, source.y, ((float)(dest.width - dx)/tileWidth)*source.width, ((float)(dest.height - dy)/tileHeight)*source.height},
+                    (Rectangle){dest.x + dx, dest.y + dy, dest.width - dx, dest.height - dy}, origin, rotation, tint);
+            }
+        }
+    }
+}
+
 // Draws a texture (or part of it) that stretches or shrinks nicely using n-patch info
 void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint)
 {
@@ -4106,678 +4135,6 @@ int GetPixelDataSize(int width, int height, int format)
 //----------------------------------------------------------------------------------
 // Module specific Functions Definition
 //----------------------------------------------------------------------------------
-#if defined(SUPPORT_FILEFORMAT_DDS)
-// Loading DDS image data (compressed or uncompressed)
-static Image LoadDDS(const unsigned char *fileData, unsigned int fileSize)
-{
-    unsigned char *fileDataPtr = (unsigned char *)fileData;
-
-    // Required extension:
-    // GL_EXT_texture_compression_s3tc
-
-    // Supported tokens (defined by extensions)
-    // GL_COMPRESSED_RGB_S3TC_DXT1_EXT      0x83F0
-    // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT     0x83F1
-    // GL_COMPRESSED_RGBA_S3TC_DXT3_EXT     0x83F2
-    // GL_COMPRESSED_RGBA_S3TC_DXT5_EXT     0x83F3
-
-    #define FOURCC_DXT1 0x31545844  // Equivalent to "DXT1" in ASCII
-    #define FOURCC_DXT3 0x33545844  // Equivalent to "DXT3" in ASCII
-    #define FOURCC_DXT5 0x35545844  // Equivalent to "DXT5" in ASCII
-
-    // DDS Pixel Format
-    typedef struct {
-        unsigned int size;
-        unsigned int flags;
-        unsigned int fourCC;
-        unsigned int rgbBitCount;
-        unsigned int rBitMask;
-        unsigned int gBitMask;
-        unsigned int bBitMask;
-        unsigned int aBitMask;
-    } DDSPixelFormat;
-
-    // DDS Header (124 bytes)
-    typedef struct {
-        unsigned int size;
-        unsigned int flags;
-        unsigned int height;
-        unsigned int width;
-        unsigned int pitchOrLinearSize;
-        unsigned int depth;
-        unsigned int mipmapCount;
-        unsigned int reserved1[11];
-        DDSPixelFormat ddspf;
-        unsigned int caps;
-        unsigned int caps2;
-        unsigned int caps3;
-        unsigned int caps4;
-        unsigned int reserved2;
-    } DDSHeader;
-
-    Image image = { 0 };
-
-    if (fileDataPtr != NULL)
-    {
-        // Verify the type of file
-        unsigned char *ddsHeaderId = fileDataPtr;
-        fileDataPtr += 4;
-
-        if ((ddsHeaderId[0] != 'D') || (ddsHeaderId[1] != 'D') || (ddsHeaderId[2] != 'S') || (ddsHeaderId[3] != ' '))
-        {
-            TRACELOG(LOG_WARNING, "IMAGE: DDS file data not valid");
-        }
-        else
-        {
-            DDSHeader *ddsHeader = (DDSHeader *)fileDataPtr;
-
-            TRACELOGD("IMAGE: DDS file data info:");
-            TRACELOGD("    > Header size:        %i", sizeof(DDSHeader));
-            TRACELOGD("    > Pixel format size:  %i", ddsHeader->ddspf.size);
-            TRACELOGD("    > Pixel format flags: 0x%x", ddsHeader->ddspf.flags);
-            TRACELOGD("    > File format:        0x%x", ddsHeader->ddspf.fourCC);
-            TRACELOGD("    > File bit count:     0x%x", ddsHeader->ddspf.rgbBitCount);
-
-            fileDataPtr += sizeof(DDSHeader);   // Skip header
-
-            image.width = ddsHeader->width;
-            image.height = ddsHeader->height;
-
-            if (ddsHeader->mipmapCount == 0) image.mipmaps = 1;      // Parameter not used
-            else image.mipmaps = ddsHeader->mipmapCount;
-
-            if (ddsHeader->ddspf.rgbBitCount == 16)     // 16bit mode, no compressed
-            {
-                if (ddsHeader->ddspf.flags == 0x40)         // no alpha channel
-                {
-                    int dataSize = image.width*image.height*sizeof(unsigned short);
-                    image.data = (unsigned short *)RL_MALLOC(dataSize);
-
-                    memcpy(image.data, fileDataPtr, dataSize);
-
-                    image.format = PIXELFORMAT_UNCOMPRESSED_R5G6B5;
-                }
-                else if (ddsHeader->ddspf.flags == 0x41)        // with alpha channel
-                {
-                    if (ddsHeader->ddspf.aBitMask == 0x8000)    // 1bit alpha
-                    {
-                        int dataSize = image.width*image.height*sizeof(unsigned short);
-                        image.data = (unsigned short *)RL_MALLOC(dataSize);
-
-                        memcpy(image.data, fileDataPtr, dataSize);
-
-                        unsigned char alpha = 0;
-
-                        // NOTE: Data comes as A1R5G5B5, it must be reordered to R5G5B5A1
-                        for (int i = 0; i < image.width*image.height; i++)
-                        {
-                            alpha = ((unsigned short *)image.data)[i] >> 15;
-                            ((unsigned short *)image.data)[i] = ((unsigned short *)image.data)[i] << 1;
-                            ((unsigned short *)image.data)[i] += alpha;
-                        }
-
-                        image.format = PIXELFORMAT_UNCOMPRESSED_R5G5B5A1;
-                    }
-                    else if (ddsHeader->ddspf.aBitMask == 0xf000)   // 4bit alpha
-                    {
-                        int dataSize = image.width*image.height*sizeof(unsigned short);
-                        image.data = (unsigned short *)RL_MALLOC(dataSize);
-
-                        memcpy(image.data, fileDataPtr, dataSize);
-
-                        unsigned char alpha = 0;
-
-                        // NOTE: Data comes as A4R4G4B4, it must be reordered R4G4B4A4
-                        for (int i = 0; i < image.width*image.height; i++)
-                        {
-                            alpha = ((unsigned short *)image.data)[i] >> 12;
-                            ((unsigned short *)image.data)[i] = ((unsigned short *)image.data)[i] << 4;
-                            ((unsigned short *)image.data)[i] += alpha;
-                        }
-
-                        image.format = PIXELFORMAT_UNCOMPRESSED_R4G4B4A4;
-                    }
-                }
-            }
-            else if (ddsHeader->ddspf.flags == 0x40 && ddsHeader->ddspf.rgbBitCount == 24)   // DDS_RGB, no compressed
-            {
-                int dataSize = image.width*image.height*3*sizeof(unsigned char);
-                image.data = (unsigned short *)RL_MALLOC(dataSize);
-
-                memcpy(image.data, fileDataPtr, dataSize);
-
-                image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8;
-            }
-            else if (ddsHeader->ddspf.flags == 0x41 && ddsHeader->ddspf.rgbBitCount == 32) // DDS_RGBA, no compressed
-            {
-                int dataSize = image.width*image.height*4*sizeof(unsigned char);
-                image.data = (unsigned short *)RL_MALLOC(dataSize);
-
-                memcpy(image.data, fileDataPtr, dataSize);
-
-                unsigned char blue = 0;
-
-                // NOTE: Data comes as A8R8G8B8, it must be reordered R8G8B8A8 (view next comment)
-                // DirecX understand ARGB as a 32bit DWORD but the actual memory byte alignment is BGRA
-                // So, we must realign B8G8R8A8 to R8G8B8A8
-                for (int i = 0; i < image.width*image.height*4; i += 4)
-                {
-                    blue = ((unsigned char *)image.data)[i];
-                    ((unsigned char *)image.data)[i] = ((unsigned char *)image.data)[i + 2];
-                    ((unsigned char *)image.data)[i + 2] = blue;
-                }
-
-                image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
-            }
-            else if (((ddsHeader->ddspf.flags == 0x04) || (ddsHeader->ddspf.flags == 0x05)) && (ddsHeader->ddspf.fourCC > 0)) // Compressed
-            {
-                int dataSize = 0;
-
-                // Calculate data size, including all mipmaps
-                if (ddsHeader->mipmapCount > 1) dataSize = ddsHeader->pitchOrLinearSize*2;
-                else dataSize = ddsHeader->pitchOrLinearSize;
-
-                image.data = (unsigned char *)RL_MALLOC(dataSize*sizeof(unsigned char));
-
-                memcpy(image.data, fileDataPtr, dataSize);
-
-                switch (ddsHeader->ddspf.fourCC)
-                {
-                    case FOURCC_DXT1:
-                    {
-                        if (ddsHeader->ddspf.flags == 0x04) image.format = PIXELFORMAT_COMPRESSED_DXT1_RGB;
-                        else image.format = PIXELFORMAT_COMPRESSED_DXT1_RGBA;
-                    } break;
-                    case FOURCC_DXT3: image.format = PIXELFORMAT_COMPRESSED_DXT3_RGBA; break;
-                    case FOURCC_DXT5: image.format = PIXELFORMAT_COMPRESSED_DXT5_RGBA; break;
-                    default: break;
-                }
-            }
-        }
-    }
-
-    return image;
-}
-#endif
-
-#if defined(SUPPORT_FILEFORMAT_PKM)
-// Loading PKM image data (ETC1/ETC2 compression)
-// NOTE: KTX is the standard Khronos Group compression format (ETC1/ETC2, mipmaps)
-// PKM is a much simpler file format used mainly to contain a single ETC1/ETC2 compressed image (no mipmaps)
-static Image LoadPKM(const unsigned char *fileData, unsigned int fileSize)
-{
-    unsigned char *fileDataPtr = (unsigned char *)fileData;
-
-    // Required extensions:
-    // GL_OES_compressed_ETC1_RGB8_texture  (ETC1) (OpenGL ES 2.0)
-    // GL_ARB_ES3_compatibility  (ETC2/EAC) (OpenGL ES 3.0)
-
-    // Supported tokens (defined by extensions)
-    // GL_ETC1_RGB8_OES                 0x8D64
-    // GL_COMPRESSED_RGB8_ETC2          0x9274
-    // GL_COMPRESSED_RGBA8_ETC2_EAC     0x9278
-
-    // PKM file (ETC1) Header (16 bytes)
-    typedef struct {
-        char id[4];                 // "PKM "
-        char version[2];            // "10" or "20"
-        unsigned short format;      // Data format (big-endian) (Check list below)
-        unsigned short width;       // Texture width (big-endian) (origWidth rounded to multiple of 4)
-        unsigned short height;      // Texture height (big-endian) (origHeight rounded to multiple of 4)
-        unsigned short origWidth;   // Original width (big-endian)
-        unsigned short origHeight;  // Original height (big-endian)
-    } PKMHeader;
-
-    // Formats list
-    // version 10: format: 0=ETC1_RGB, [1=ETC1_RGBA, 2=ETC1_RGB_MIP, 3=ETC1_RGBA_MIP] (not used)
-    // version 20: format: 0=ETC1_RGB, 1=ETC2_RGB, 2=ETC2_RGBA_OLD, 3=ETC2_RGBA, 4=ETC2_RGBA1, 5=ETC2_R, 6=ETC2_RG, 7=ETC2_SIGNED_R, 8=ETC2_SIGNED_R
-
-    // NOTE: The extended width and height are the widths rounded up to a multiple of 4.
-    // NOTE: ETC is always 4bit per pixel (64 bit for each 4x4 block of pixels)
-
-    Image image = { 0 };
-
-    if (fileDataPtr != NULL)
-    {
-        PKMHeader *pkmHeader = (PKMHeader *)fileDataPtr;
-
-        if ((pkmHeader->id[0] != 'P') || (pkmHeader->id[1] != 'K') || (pkmHeader->id[2] != 'M') || (pkmHeader->id[3] != ' '))
-        {
-            TRACELOG(LOG_WARNING, "IMAGE: PKM file data not valid");
-        }
-        else
-        {
-            fileDataPtr += sizeof(PKMHeader);   // Skip header
-
-            // NOTE: format, width and height come as big-endian, data must be swapped to little-endian
-            pkmHeader->format = ((pkmHeader->format & 0x00FF) << 8) | ((pkmHeader->format & 0xFF00) >> 8);
-            pkmHeader->width = ((pkmHeader->width & 0x00FF) << 8) | ((pkmHeader->width & 0xFF00) >> 8);
-            pkmHeader->height = ((pkmHeader->height & 0x00FF) << 8) | ((pkmHeader->height & 0xFF00) >> 8);
-
-            TRACELOGD("IMAGE: PKM file data info:");
-            TRACELOGD("    > Image width:  %i", pkmHeader->width);
-            TRACELOGD("    > Image height: %i", pkmHeader->height);
-            TRACELOGD("    > Image format: %i", pkmHeader->format);
-
-            image.width = pkmHeader->width;
-            image.height = pkmHeader->height;
-            image.mipmaps = 1;
-
-            int bpp = 4;
-            if (pkmHeader->format == 3) bpp = 8;
-
-            int dataSize = image.width*image.height*bpp/8;  // Total data size in bytes
-
-            image.data = (unsigned char *)RL_MALLOC(dataSize*sizeof(unsigned char));
-
-            memcpy(image.data, fileDataPtr, dataSize);
-
-            if (pkmHeader->format == 0) image.format = PIXELFORMAT_COMPRESSED_ETC1_RGB;
-            else if (pkmHeader->format == 1) image.format = PIXELFORMAT_COMPRESSED_ETC2_RGB;
-            else if (pkmHeader->format == 3) image.format = PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA;
-        }
-    }
-
-    return image;
-}
-#endif
-
-#if defined(SUPPORT_FILEFORMAT_KTX)
-// Load KTX compressed image data (ETC1/ETC2 compression)
-// TODO: Review KTX loading, many things changed!
-static Image LoadKTX(const unsigned char *fileData, unsigned int fileSize)
-{
-    unsigned char *fileDataPtr = (unsigned char *)fileData;
-
-    // Required extensions:
-    // GL_OES_compressed_ETC1_RGB8_texture  (ETC1)
-    // GL_ARB_ES3_compatibility  (ETC2/EAC)
-
-    // Supported tokens (defined by extensions)
-    // GL_ETC1_RGB8_OES                 0x8D64
-    // GL_COMPRESSED_RGB8_ETC2          0x9274
-    // GL_COMPRESSED_RGBA8_ETC2_EAC     0x9278
-
-    // KTX file Header (64 bytes)
-    // v1.1 - https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
-    // v2.0 - http://github.khronos.org/KTX-Specification/
-
-    // TODO: Support KTX 2.2 specs!
-
-    typedef struct {
-        char id[12];                        // Identifier: "«KTX 11»\r\n\x1A\n"
-        unsigned int endianness;            // Little endian: 0x01 0x02 0x03 0x04
-        unsigned int glType;                // For compressed textures, glType must equal 0
-        unsigned int glTypeSize;            // For compressed texture data, usually 1
-        unsigned int glFormat;              // For compressed textures is 0
-        unsigned int glInternalFormat;      // Compressed internal format
-        unsigned int glBaseInternalFormat;  // Same as glFormat (RGB, RGBA, ALPHA...)
-        unsigned int width;                 // Texture image width in pixels
-        unsigned int height;                // Texture image height in pixels
-        unsigned int depth;                 // For 2D textures is 0
-        unsigned int elements;              // Number of array elements, usually 0
-        unsigned int faces;                 // Cubemap faces, for no-cubemap = 1
-        unsigned int mipmapLevels;          // Non-mipmapped textures = 1
-        unsigned int keyValueDataSize;      // Used to encode any arbitrary data...
-    } KTXHeader;
-
-    // NOTE: Before start of every mipmap data block, we have: unsigned int dataSize
-
-    Image image = { 0 };
-
-    if (fileDataPtr != NULL)
-    {
-        KTXHeader *ktxHeader = (KTXHeader *)fileDataPtr;
-
-        if ((ktxHeader->id[1] != 'K') || (ktxHeader->id[2] != 'T') || (ktxHeader->id[3] != 'X') ||
-            (ktxHeader->id[4] != ' ') || (ktxHeader->id[5] != '1') || (ktxHeader->id[6] != '1'))
-        {
-            TRACELOG(LOG_WARNING, "IMAGE: KTX file data not valid");
-        }
-        else
-        {
-            fileDataPtr += sizeof(KTXHeader);           // Move file data pointer
-
-            image.width = ktxHeader->width;
-            image.height = ktxHeader->height;
-            image.mipmaps = ktxHeader->mipmapLevels;
-
-            TRACELOGD("IMAGE: KTX file data info:");
-            TRACELOGD("    > Image width:  %i", ktxHeader->width);
-            TRACELOGD("    > Image height: %i", ktxHeader->height);
-            TRACELOGD("    > Image format: 0x%x", ktxHeader->glInternalFormat);
-
-            fileDataPtr += ktxHeader->keyValueDataSize; // Skip value data size
-
-            int dataSize = ((int *)fileDataPtr)[0];
-            fileDataPtr += sizeof(int);
-
-            image.data = (unsigned char *)RL_MALLOC(dataSize*sizeof(unsigned char));
-
-            memcpy(image.data, fileDataPtr, dataSize);
-
-            if (ktxHeader->glInternalFormat == 0x8D64) image.format = PIXELFORMAT_COMPRESSED_ETC1_RGB;
-            else if (ktxHeader->glInternalFormat == 0x9274) image.format = PIXELFORMAT_COMPRESSED_ETC2_RGB;
-            else if (ktxHeader->glInternalFormat == 0x9278) image.format = PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA;
-
-            // TODO: Support uncompressed data formats? Right now it returns format = 0!
-        }
-    }
-
-    return image;
-}
-
-// Save image data as KTX file
-// NOTE: By default KTX 1.1 spec is used, 2.0 is still on draft (01Oct2018)
-// TODO: Review KTX saving, many things changed!
-static int SaveKTX(Image image, const char *fileName)
-{
-    // KTX file Header (64 bytes)
-    // v1.1 - https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
-    // v2.0 - http://github.khronos.org/KTX-Specification/ - Final specs by 2021-04-18
-    typedef struct {
-        char id[12];                        // Identifier: "«KTX 11»\r\n\x1A\n"             // KTX 2.0: "«KTX 22»\r\n\x1A\n"
-        unsigned int endianness;            // Little endian: 0x01 0x02 0x03 0x04
-        unsigned int glType;                // For compressed textures, glType must equal 0
-        unsigned int glTypeSize;            // For compressed texture data, usually 1
-        unsigned int glFormat;              // For compressed textures is 0
-        unsigned int glInternalFormat;      // Compressed internal format
-        unsigned int glBaseInternalFormat;  // Same as glFormat (RGB, RGBA, ALPHA...)       // KTX 2.0: UInt32 vkFormat
-        unsigned int width;                 // Texture image width in pixels
-        unsigned int height;                // Texture image height in pixels
-        unsigned int depth;                 // For 2D textures is 0
-        unsigned int elements;              // Number of array elements, usually 0
-        unsigned int faces;                 // Cubemap faces, for no-cubemap = 1
-        unsigned int mipmapLevels;          // Non-mipmapped textures = 1
-        unsigned int keyValueDataSize;      // Used to encode any arbitrary data...         // KTX 2.0: UInt32 levelOrder - ordering of the mipmap levels, usually 0
-                                                                                            // KTX 2.0: UInt32 supercompressionScheme - 0 (None), 1 (Crunch CRN), 2 (Zlib DEFLATE)...
-        // KTX 2.0 defines additional header elements...
-    } KTXHeader;
-
-    // Calculate file dataSize required
-    int dataSize = sizeof(KTXHeader);
-
-    for (int i = 0, width = image.width, height = image.height; i < image.mipmaps; i++)
-    {
-        dataSize += GetPixelDataSize(width, height, image.format);
-        width /= 2; height /= 2;
-    }
-
-    unsigned char *fileData = RL_CALLOC(dataSize, 1);
-    unsigned char *fileDataPtr = fileData;
-
-    KTXHeader ktxHeader = { 0 };
-
-    // KTX identifier (v1.1)
-    //unsigned char id[12] = { '«', 'K', 'T', 'X', ' ', '1', '1', '»', '\r', '\n', '\x1A', '\n' };
-    //unsigned char id[12] = { 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A };
-
-    const char ktxIdentifier[12] = { 0xAB, 'K', 'T', 'X', ' ', '1', '1', 0xBB, '\r', '\n', 0x1A, '\n' };
-
-    // Get the image header
-    memcpy(ktxHeader.id, ktxIdentifier, 12);  // KTX 1.1 signature
-    ktxHeader.endianness = 0;
-    ktxHeader.glType = 0;                     // Obtained from image.format
-    ktxHeader.glTypeSize = 1;
-    ktxHeader.glFormat = 0;                   // Obtained from image.format
-    ktxHeader.glInternalFormat = 0;           // Obtained from image.format
-    ktxHeader.glBaseInternalFormat = 0;
-    ktxHeader.width = image.width;
-    ktxHeader.height = image.height;
-    ktxHeader.depth = 0;
-    ktxHeader.elements = 0;
-    ktxHeader.faces = 1;
-    ktxHeader.mipmapLevels = image.mipmaps;   // If it was 0, it means mipmaps should be generated on loading (not for compressed formats)
-    ktxHeader.keyValueDataSize = 0;           // No extra data after the header
-
-    rlGetGlTextureFormats(image.format, &ktxHeader.glInternalFormat, &ktxHeader.glFormat, &ktxHeader.glType);   // rlgl module function
-    ktxHeader.glBaseInternalFormat = ktxHeader.glFormat;    // KTX 1.1 only
-
-    // NOTE: We can save into a .ktx all PixelFormats supported by raylib, including compressed formats like DXT, ETC or ASTC
-
-    if (ktxHeader.glFormat == -1) TRACELOG(LOG_WARNING, "IMAGE: GL format not supported for KTX export (%i)", ktxHeader.glFormat);
-    else
-    {
-        memcpy(fileDataPtr, &ktxHeader, sizeof(KTXHeader));
-        fileDataPtr += sizeof(KTXHeader);
-
-        int width = image.width;
-        int height = image.height;
-        int dataOffset = 0;
-
-        // Save all mipmaps data
-        for (int i = 0; i < image.mipmaps; i++)
-        {
-            unsigned int dataSize = GetPixelDataSize(width, height, image.format);
-
-            memcpy(fileDataPtr, &dataSize, sizeof(unsigned int));
-            memcpy(fileDataPtr + 4, (unsigned char *)image.data + dataOffset, dataSize);
-
-            width /= 2;
-            height /= 2;
-            dataOffset += dataSize;
-            fileDataPtr += (4 + dataSize);
-        }
-    }
-
-    int success = SaveFileData(fileName, fileData, dataSize);
-
-    RL_FREE(fileData);    // Free file data buffer
-
-    // If all data has been written correctly to file, success = 1
-    return success;
-}
-#endif
-
-#if defined(SUPPORT_FILEFORMAT_PVR)
-// Loading PVR image data (uncompressed or PVRT compression)
-// NOTE: PVR v2 not supported, use PVR v3 instead
-static Image LoadPVR(const unsigned char *fileData, unsigned int fileSize)
-{
-    unsigned char *fileDataPtr = (unsigned char *)fileData;
-
-    // Required extension:
-    // GL_IMG_texture_compression_pvrtc
-
-    // Supported tokens (defined by extensions)
-    // GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG       0x8C00
-    // GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG      0x8C02
-
-#if 0   // Not used...
-    // PVR file v2 Header (52 bytes)
-    typedef struct {
-        unsigned int headerLength;
-        unsigned int height;
-        unsigned int width;
-        unsigned int numMipmaps;
-        unsigned int flags;
-        unsigned int dataLength;
-        unsigned int bpp;
-        unsigned int bitmaskRed;
-        unsigned int bitmaskGreen;
-        unsigned int bitmaskBlue;
-        unsigned int bitmaskAlpha;
-        unsigned int pvrTag;
-        unsigned int numSurfs;
-    } PVRHeaderV2;
-#endif
-
-    // PVR file v3 Header (52 bytes)
-    // NOTE: After it could be metadata (15 bytes?)
-    typedef struct {
-        char id[4];
-        unsigned int flags;
-        unsigned char channels[4];      // pixelFormat high part
-        unsigned char channelDepth[4];  // pixelFormat low part
-        unsigned int colorSpace;
-        unsigned int channelType;
-        unsigned int height;
-        unsigned int width;
-        unsigned int depth;
-        unsigned int numSurfaces;
-        unsigned int numFaces;
-        unsigned int numMipmaps;
-        unsigned int metaDataSize;
-    } PVRHeaderV3;
-
-#if 0   // Not used...
-    // Metadata (usually 15 bytes)
-    typedef struct {
-        unsigned int devFOURCC;
-        unsigned int key;
-        unsigned int dataSize;      // Not used?
-        unsigned char *data;        // Not used?
-    } PVRMetadata;
-#endif
-
-    Image image = { 0 };
-
-    if (fileDataPtr != NULL)
-    {
-        // Check PVR image version
-        unsigned char pvrVersion = fileDataPtr[0];
-
-        // Load different PVR data formats
-        if (pvrVersion == 0x50)
-        {
-            PVRHeaderV3 *pvrHeader = (PVRHeaderV3 *)fileDataPtr;
-
-            if ((pvrHeader->id[0] != 'P') || (pvrHeader->id[1] != 'V') || (pvrHeader->id[2] != 'R') || (pvrHeader->id[3] != 3))
-            {
-                TRACELOG(LOG_WARNING, "IMAGE: PVR file data not valid");
-            }
-            else
-            {
-                fileDataPtr += sizeof(PVRHeaderV3);   // Skip header
-
-                image.width = pvrHeader->width;
-                image.height = pvrHeader->height;
-                image.mipmaps = pvrHeader->numMipmaps;
-
-                // Check data format
-                if (((pvrHeader->channels[0] == 'l') && (pvrHeader->channels[1] == 0)) && (pvrHeader->channelDepth[0] == 8)) image.format = PIXELFORMAT_UNCOMPRESSED_GRAYSCALE;
-                else if (((pvrHeader->channels[0] == 'l') && (pvrHeader->channels[1] == 'a')) && ((pvrHeader->channelDepth[0] == 8) && (pvrHeader->channelDepth[1] == 8))) image.format = PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA;
-                else if ((pvrHeader->channels[0] == 'r') && (pvrHeader->channels[1] == 'g') && (pvrHeader->channels[2] == 'b'))
-                {
-                    if (pvrHeader->channels[3] == 'a')
-                    {
-                        if ((pvrHeader->channelDepth[0] == 5) && (pvrHeader->channelDepth[1] == 5) && (pvrHeader->channelDepth[2] == 5) && (pvrHeader->channelDepth[3] == 1)) image.format = PIXELFORMAT_UNCOMPRESSED_R5G5B5A1;
-                        else if ((pvrHeader->channelDepth[0] == 4) && (pvrHeader->channelDepth[1] == 4) && (pvrHeader->channelDepth[2] == 4) && (pvrHeader->channelDepth[3] == 4)) image.format = PIXELFORMAT_UNCOMPRESSED_R4G4B4A4;
-                        else if ((pvrHeader->channelDepth[0] == 8) && (pvrHeader->channelDepth[1] == 8) && (pvrHeader->channelDepth[2] == 8) && (pvrHeader->channelDepth[3] == 8)) image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
-                    }
-                    else if (pvrHeader->channels[3] == 0)
-                    {
-                        if ((pvrHeader->channelDepth[0] == 5) && (pvrHeader->channelDepth[1] == 6) && (pvrHeader->channelDepth[2] == 5)) image.format = PIXELFORMAT_UNCOMPRESSED_R5G6B5;
-                        else if ((pvrHeader->channelDepth[0] == 8) && (pvrHeader->channelDepth[1] == 8) && (pvrHeader->channelDepth[2] == 8)) image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8;
-                    }
-                }
-                else if (pvrHeader->channels[0] == 2) image.format = PIXELFORMAT_COMPRESSED_PVRT_RGB;
-                else if (pvrHeader->channels[0] == 3) image.format = PIXELFORMAT_COMPRESSED_PVRT_RGBA;
-
-                fileDataPtr += pvrHeader->metaDataSize;    // Skip meta data header
-
-                // Calculate data size (depends on format)
-                int bpp = 0;
-                switch (image.format)
-                {
-                    case PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break;
-                    case PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
-                    case PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
-                    case PIXELFORMAT_UNCOMPRESSED_R5G6B5:
-                    case PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break;
-                    case PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break;
-                    case PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break;
-                    case PIXELFORMAT_COMPRESSED_PVRT_RGB:
-                    case PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break;
-                    default: break;
-                }
-
-                int dataSize = image.width*image.height*bpp/8;  // Total data size in bytes
-                image.data = (unsigned char *)RL_MALLOC(dataSize*sizeof(unsigned char));
-
-                memcpy(image.data, fileDataPtr, dataSize);
-            }
-        }
-        else if (pvrVersion == 52) TRACELOG(LOG_INFO, "IMAGE: PVRv2 format not supported, update your files to PVRv3");
-    }
-
-    return image;
-}
-#endif
-
-#if defined(SUPPORT_FILEFORMAT_ASTC)
-// Load ASTC compressed image data (ASTC compression)
-static Image LoadASTC(const unsigned char *fileData, unsigned int fileSize)
-{
-    unsigned char *fileDataPtr = (unsigned char *)fileData;
-
-    // Required extensions:
-    // GL_KHR_texture_compression_astc_hdr
-    // GL_KHR_texture_compression_astc_ldr
-
-    // Supported tokens (defined by extensions)
-    // GL_COMPRESSED_RGBA_ASTC_4x4_KHR      0x93b0
-    // GL_COMPRESSED_RGBA_ASTC_8x8_KHR      0x93b7
-
-    // ASTC file Header (16 bytes)
-    typedef struct {
-        unsigned char id[4];        // Signature: 0x13 0xAB 0xA1 0x5C
-        unsigned char blockX;       // Block X dimensions
-        unsigned char blockY;       // Block Y dimensions
-        unsigned char blockZ;       // Block Z dimensions (1 for 2D images)
-        unsigned char width[3];     // Image width in pixels (24bit value)
-        unsigned char height[3];    // Image height in pixels (24bit value)
-        unsigned char length[3];    // Image Z-size (1 for 2D images)
-    } ASTCHeader;
-
-    Image image = { 0 };
-
-    if (fileDataPtr != NULL)
-    {
-        ASTCHeader *astcHeader = (ASTCHeader *)fileDataPtr;
-
-        if ((astcHeader->id[3] != 0x5c) || (astcHeader->id[2] != 0xa1) || (astcHeader->id[1] != 0xab) || (astcHeader->id[0] != 0x13))
-        {
-            TRACELOG(LOG_WARNING, "IMAGE: ASTC file data not valid");
-        }
-        else
-        {
-            fileDataPtr += sizeof(ASTCHeader);   // Skip header
-
-            // NOTE: Assuming Little Endian (could it be wrong?)
-            image.width = 0x00000000 | ((int)astcHeader->width[2] << 16) | ((int)astcHeader->width[1] << 8) | ((int)astcHeader->width[0]);
-            image.height = 0x00000000 | ((int)astcHeader->height[2] << 16) | ((int)astcHeader->height[1] << 8) | ((int)astcHeader->height[0]);
-
-            TRACELOGD("IMAGE: ASTC file data info:");
-            TRACELOGD("    > Image width:  %i", image.width);
-            TRACELOGD("    > Image height: %i", image.height);
-            TRACELOGD("    > Image blocks: %ix%i", astcHeader->blockX, astcHeader->blockY);
-
-            image.mipmaps = 1;      // NOTE: ASTC format only contains one mipmap level
-
-            // NOTE: Each block is always stored in 128bit so we can calculate the bpp
-            int bpp = 128/(astcHeader->blockX*astcHeader->blockY);
-
-            // NOTE: Currently we only support 2 blocks configurations: 4x4 and 8x8
-            if ((bpp == 8) || (bpp == 2))
-            {
-                int dataSize = image.width*image.height*bpp/8;  // Data size in bytes
-
-                image.data = (unsigned char *)RL_MALLOC(dataSize*sizeof(unsigned char));
-
-                memcpy(image.data, fileDataPtr, dataSize);
-
-                if (bpp == 8) image.format = PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA;
-                else if (bpp == 2) image.format = PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA;
-            }
-            else TRACELOG(LOG_WARNING, "IMAGE: ASTC block size configuration not supported");
-        }
-    }
-
-    return image;
-}
-#endif
-
 // Get pixel data from image as Vector4 array (float normalized)
 static Vector4 *LoadImageDataNormalized(Image image)
 {