Creating fast, real-time 3D applications always involves balancing quality and performance, especially when targeting platforms without top-tier GPUs. One of the main bottlenecks in these scenarios is memory throughput, which can significantly impact performance. The amount of texture data used directly affects memory bandwidth, and hardware texture compression helps alleviate this issue by reducing the required memory bandwidth and footprint.<\/p>\r\n\r\n
All GPUs support block compression formats; however, there is no universal standard that works seamlessly across all platforms. Currently, different GPUs support three major compression formats:<\/p>\r\n\r\n
There are also older mobile compression formats that are still in use today, such as ETC, ETC2, EAC, ATC, and PVRTC. Unfortunately, using BC formats on mobile devices and ASTC on desktops is not feasible, necessitating different data packs for various platforms.<\/p>\r\n\r\n
Compressing textures to BC1-5 formats was relatively straightforward using either the CPU or GPU, as the encoding algorithm was simple. However, the introduction of BC6-7 increased the complexity due to additional compression modes, making the encoding process significantly slower. ASTC formats further increased complexity due to the vast number of modes and the use of integer coding with trits and quints.<\/p>\r\n\r\n
Compressing textures offline and shipping them with the project is common but often suboptimal, especially for dynamic or procedural textures. For instance, GLTF and USD resources typically include embedded JPEG images to reduce asset size, while some algorithms generate procedural textures at runtime. In such cases, fast, real-time compression is necessary.<\/p>\r\n\r\n
Tellusim SDK provides real-time compression for BC1-5, BC6-7, and ASTC formats on all platforms. BC1 texture compression remains a viable option for PCs because BC formats do not have variable block sizes and BC1 is twice as compact as BC7, with excellent compression speed. A practical use case for BC1 compression is in real-time applications like Google Maps<\/a> or XYZ tile<\/a> compression, where it helps minimize memory overhead and reduce compression stalls.<\/p>\r\n\r\n Our SDK provides GPU encoders via the EncoderBC15<\/i>, EncoderBC67<\/i>, and EncoderASTC<\/i> interfaces. Each encoder has specific flags and can be initialized for required formats only since initial kernel compilation can take some time.<\/p>\r\n\r\n The encoder input is a standard texture, and the output is an integer texture in RGBAu16<\/i>\/RGBAu32<\/i> format, with one pixel per block dimension. The application must copy this intermediate integer texture into the final block texture because direct copying to block-compressed formats is typically unsupported. (RGBAu16<\/i> is required only for BC1 and BC4 formats).<\/p>\r\n\r\n Integer textures cannot fully represent all required mipmap levels due to size truncation. This issue needs to be managed manually, either by reducing the number of mipmaps being compressed or by increasing the size of the integer texture. The truncation occurs because the final 1×1 mipmap level in the integer texture represents a 4×4 (or 5×4, 5×5) pixel block, leaving no space for the smallest mipmaps (2×2 and 1×1).<\/p>\r\n\r\n Below is an example of GPU ASTC 5×5 texture compression using the Tellusim SDK:<\/p>\r\n\r\n Additionally, the SDK includes a fast GPU JPEG decompression interface, which significantly accelerates JPEG to BC or ASTC conversions.<\/p>\r\n\r\n\/\/ texture format<\/font>\r\nFormat format = FormatASTC44RGBAu8n;\r\n\r\n\/\/ create intermediate image<\/font>\r\nuint32_t<\/b><\/font> width = src_texture.getWidth();\r\nuint32_t<\/b><\/font> height = src_texture.getHeight();\r\nuint32_t<\/b><\/font> block_width = getFormatBlockWidth(format);\r\nuint32_t<\/b><\/font> block_height = getFormatBlockHeight(format);\r\nImage dest_image = Image(Image::Type2D, FormatRGBAu32, Size(udiv(width, block_width), udiv(height, block_height)));\r\n\r\n\/\/ create intermediate texture<\/font>\r\nTexture dest_texture = device.createTexture(dest_image, Texture::FlagSurface | Texture::FlagSource);\r\nif<\/b><\/font>(!dest_texture) return<\/b><\/font> 1<\/font><\/span>;\r\n\r\n\/\/ dispatch encoder<\/font>\r\n{\r\n Compute compute = device.createCompute();\r\n encoder.dispatch(compute, EncoderASTC::ModeASTC44RGBAu8n, dest_texture, src_texture);\r\n}\r\n\r\n\/\/ flush context<\/font>\r\ncontext.flush();\r\n\r\n\/\/ get intermediate image data<\/font>\r\nif<\/b><\/font>(!device.getTexture(dest_texture, dest_image)) return<\/b><\/font> 1<\/font><\/span>;\r\n\r\n\/\/ copy image data<\/font>\r\nImage image = Image(Image::Type2D, format, Size(width, height));\r\nmemcpy(image.getData(), dest_image.getData(), min(image.getDataSize(), dest_image.getDataSize()));\r\n\r\n\/\/ save encoded image<\/font>\r\nimage.save("texture.astc"<\/font><\/span>);\r\n<\/font><\/pre><\/div>\r\n\r\n