Merge pull request #243 from defold/9.0.x-astc-support-webgpu

Add ASTC compressed texture support for WebGPU

Author: JCash

defold-rive/commonsrc/atlas.cpp

@@ -13,6 +13,7 @@
 #include <common/atlas.h>
 #include <common/factory.h>
 #include <common/types.h>
+#include <common/astc.h>
 
 #include <dmsdk/dlib/dstrings.h>
 #include <dmsdk/dlib/hash.h>
@@ -207,6 +208,12 @@ namespace dmRive {
 
     rive::rcp<rive::RenderImage> LoadImageFromMemory(HRenderContext context, void* resource, uint32_t resource_size)
     {
+        // Auto-detect ASTC format
+        if (IsASTCData((const uint8_t*)resource, resource_size))
+        {
+            DEBUGLOG("Loading ASTC texture (%u bytes)", resource_size);
+            return CreateRiveRenderImageASTC(context, resource, resource_size);
+        }
         return CreateRiveRenderImage(context, resource, resource_size);
     }
 
@@ -277,7 +284,7 @@ namespace dmRive {
 
             if (!image)
             {
-                image = CreateRiveRenderImage(m_RiveRenderContext, (void*) inBandBytes.data(), inBandBytes.size());
+                image = LoadImageFromMemory(m_RiveRenderContext, (void*) inBandBytes.data(), inBandBytes.size());
                 DEBUGLOG("  In band asset: file: '%s' data: %u bytes", name.c_str(), (uint32_t)inBandBytes.size());
             }
 

defold-rive/include/common/astc.h

@@ -0,0 +1,75 @@
+// Copyright 2020 The Defold Foundation
+// Licensed under the Defold License version 1.0 (the "License"); you may not use
+// this file except in compliance with the License.
+//
+// You may obtain a copy of the License, together with FAQs at
+// https://www.defold.com/license
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef DM_RIVE_ASTC_H
+#define DM_RIVE_ASTC_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+namespace dmRive
+{
+	static const uint32_t ASTC_MAGIC = 0x5CA1AB13;
+
+	struct ASTCHeader
+	{
+		uint32_t magic;
+		uint8_t  block_width;
+		uint8_t  block_height;
+		uint8_t  block_depth;
+		uint32_t width;
+		uint32_t height;
+		uint32_t depth;
+	};
+
+	// Check if data starts with ASTC magic bytes
+	inline bool IsASTCData(const uint8_t* data, size_t data_size)
+	{
+		if (data_size < 4)
+			return false;
+		uint32_t magic = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
+		return magic == ASTC_MAGIC;
+	}
+
+	// Parse ASTC header from raw data. Returns false if invalid.
+	inline bool ParseASTCHeader(const uint8_t* data, size_t data_size, ASTCHeader* out)
+	{
+		if (data_size < 16 || !IsASTCData(data, data_size))
+			return false;
+
+		out->magic        = ASTC_MAGIC;
+		out->block_width  = data[4];
+		out->block_height = data[5];
+		out->block_depth  = data[6];
+
+		// Dimensions are 24-bit little-endian
+		out->width  = data[7]  | (data[8] << 8)  | (data[9] << 16);
+		out->height = data[10] | (data[11] << 8) | (data[12] << 16);
+		out->depth  = data[13] | (data[14] << 8) | (data[15] << 16);
+
+		return true;
+	}
+
+	// Get pointer to compressed data (after 16-byte header)
+	inline const uint8_t* GetASTCCompressedData(const uint8_t* data)
+	{
+		return data + 16;
+	}
+
+	// Get size of compressed data (total size minus 16-byte header)
+	inline size_t GetASTCCompressedDataSize(size_t total_size)
+	{
+		return total_size > 16 ? total_size - 16 : 0;
+	}
+}
+
+#endif // DM_RIVE_ASTC_H

defold-rive/include/defold/renderer.h

@@ -43,6 +43,7 @@ namespace dmRive
     HRenderContext               NewRenderContext();
     void                         DeleteRenderContext(HRenderContext context);
     rive::rcp<rive::RenderImage> CreateRiveRenderImage(HRenderContext context, void* bytes, uint32_t byte_count);
+    rive::rcp<rive::RenderImage> CreateRiveRenderImageASTC(HRenderContext context, void* bytes, uint32_t byte_count);
     rive::Factory*               GetRiveFactory(HRenderContext context);
     rive::Renderer*              GetRiveRenderer(HRenderContext context);
     rive::Mat2D                  GetViewTransform(HRenderContext context, dmRender::HRenderContext render_context);

defold-rive/src/private/renderer_context.h

@@ -22,6 +22,7 @@ namespace dmRive
 
 		virtual dmGraphics::HTexture GetBackingTexture() = 0;
 		virtual rive::rcp<rive::gpu::Texture> MakeImageTexture(uint32_t width, uint32_t height, uint32_t mipLevelCount, const uint8_t imageDataRGBA[]) = 0;
+		virtual rive::rcp<rive::gpu::Texture> MakeImageTextureASTC(uint32_t width, uint32_t height, uint8_t blockW, uint8_t blockH, const uint8_t astcData[], uint32_t astcDataSize) = 0;
 	};
 
 	IDefoldRiveRenderer* MakeDefoldRiveRendererMetal();

defold-rive/src/private/renderer_context_metal.mm

@@ -1,6 +1,7 @@
 
 #include "renderer_context.h"
 
+#include <dmsdk/dlib/log.h>
 #include <rive/renderer/rive_renderer.hpp>
 #include <rive/renderer/texture.hpp>
 #include <rive/renderer/metal/render_context_metal_impl.h>
@@ -124,6 +125,18 @@ void SetRenderTargetTexture(dmGraphics::HTexture texture) override
             }
         }
 
+        rive::rcp<rive::gpu::Texture> MakeImageTextureASTC(uint32_t width,
+                                                          uint32_t height,
+                                                          uint8_t blockW,
+                                                          uint8_t blockH,
+                                                          const uint8_t astcData[],
+                                                          uint32_t astcDataSize) override
+        {
+            // TODO: Implement ASTC texture loading for Metal
+            dmLogWarning("MakeImageTextureASTC not implemented for Metal");
+            return nullptr;
+        }
+
     private:
         id<MTLDevice>                             m_GPU   = MTLCreateSystemDefaultDevice();
         id<MTLCommandQueue>                       m_Queue;

defold-rive/src/private/renderer_context_opengl.cpp

@@ -173,6 +173,18 @@ namespace dmRive
             return texture;
         }
 
+        rive::rcp<rive::gpu::Texture> MakeImageTextureASTC(uint32_t width,
+                                                          uint32_t height,
+                                                          uint8_t blockW,
+                                                          uint8_t blockH,
+                                                          const uint8_t astcData[],
+                                                          uint32_t astcDataSize) override
+        {
+            // TODO: Implement ASTC texture loading for OpenGL
+            dmLogWarning("MakeImageTextureASTC not implemented for OpenGL");
+            return nullptr;
+        }
+
     private:
 
         void SetDefoldGraphicsState(dmGraphics::State state, bool flag)

defold-rive/src/private/renderer_context_webgpu.cpp

@@ -191,6 +191,78 @@ namespace dmRive
             return texture;
         }
 
+        static wgpu::TextureFormat GetASTCFormat(uint8_t blockW, uint8_t blockH)
+        {
+            // ASTC block sizes mapped to WebGPU sRGB formats (correct for color textures).
+            // NOTE: Linear data (e.g. normal maps) would need Unorm variants instead,
+            // but ASTC files don't contain color space info. For now we assume sRGB.
+            if (blockW == 4 && blockH == 4)   return wgpu::TextureFormat::ASTC4x4UnormSrgb;
+            if (blockW == 5 && blockH == 4)   return wgpu::TextureFormat::ASTC5x4UnormSrgb;
+            if (blockW == 5 && blockH == 5)   return wgpu::TextureFormat::ASTC5x5UnormSrgb;
+            if (blockW == 6 && blockH == 5)   return wgpu::TextureFormat::ASTC6x5UnormSrgb;
+            if (blockW == 6 && blockH == 6)   return wgpu::TextureFormat::ASTC6x6UnormSrgb;
+            if (blockW == 8 && blockH == 5)   return wgpu::TextureFormat::ASTC8x5UnormSrgb;
+            if (blockW == 8 && blockH == 6)   return wgpu::TextureFormat::ASTC8x6UnormSrgb;
+            if (blockW == 8 && blockH == 8)   return wgpu::TextureFormat::ASTC8x8UnormSrgb;
+            if (blockW == 10 && blockH == 5)  return wgpu::TextureFormat::ASTC10x5UnormSrgb;
+            if (blockW == 10 && blockH == 6)  return wgpu::TextureFormat::ASTC10x6UnormSrgb;
+            if (blockW == 10 && blockH == 8)  return wgpu::TextureFormat::ASTC10x8UnormSrgb;
+            if (blockW == 10 && blockH == 10) return wgpu::TextureFormat::ASTC10x10UnormSrgb;
+            if (blockW == 12 && blockH == 10) return wgpu::TextureFormat::ASTC12x10UnormSrgb;
+            if (blockW == 12 && blockH == 12) return wgpu::TextureFormat::ASTC12x12UnormSrgb;
+            return wgpu::TextureFormat::Undefined;
+        }
+
+        rive::rcp<rive::gpu::Texture> MakeImageTextureASTC(uint32_t width,
+                                                          uint32_t height,
+                                                          uint8_t blockW,
+                                                          uint8_t blockH,
+                                                          const uint8_t astcData[],
+                                                          uint32_t astcDataSize) override
+        {
+            wgpu::TextureFormat format = GetASTCFormat(blockW, blockH);
+            if (format == wgpu::TextureFormat::Undefined)
+            {
+                dmLogError("Unsupported ASTC block size %dx%d", blockW, blockH);
+                return nullptr;
+            }
+
+            // All ASTC blocks are 16 bytes regardless of block dimensions
+            uint32_t blocksX = (width + blockW - 1) / blockW;
+            uint32_t blocksY = (height + blockH - 1) / blockH;
+            uint32_t bytesPerRow = blocksX * 16;
+            uint32_t expectedSize = blocksX * blocksY * 16;
+
+            if (astcDataSize < expectedSize)
+            {
+                dmLogError("ASTC data size %u is less than expected %u for %ux%u texture with %dx%d blocks",
+                           astcDataSize, expectedSize, width, height, blockW, blockH);
+                return nullptr;
+            }
+
+            wgpu::TextureDescriptor textureDesc = {
+                .usage = wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::CopyDst,
+                .dimension = wgpu::TextureDimension::e2D,
+                .size = {width, height},
+                .format = format,
+                .mipLevelCount = 1,
+            };
+
+            wgpu::Texture texture = m_Device.CreateTexture(&textureDesc);
+
+            wgpu::TexelCopyTextureInfo dest = {.texture = texture};
+            wgpu::TexelCopyBufferLayout layout = {.bytesPerRow = bytesPerRow};
+            wgpu::Extent3D extent = {width, height};
+
+            m_Queue.WriteTexture(&dest,
+                                 astcData,
+                                 astcDataSize,
+                                 &layout,
+                                 &extent);
+
+            return rive::make_rcp<rive::gpu::TextureWebGPUImpl>(width, height, std::move(texture));
+        }
+
     private:
         std::unique_ptr<rive::gpu::RenderContext> m_RenderContext;
         rive::rcp<rive::gpu::RenderTargetWebGPU>  m_RenderTarget;

defold-rive/src/private/renderer_private.cpp

@@ -5,6 +5,7 @@
 #include <dmsdk/render/render.h>
 
 #include "renderer_context.h"
+#include <common/astc.h>
 #include "defold/renderer.h"
 
 #include <rive/shapes/image.hpp>
@@ -266,6 +267,26 @@ namespace dmRive
         return texture != nullptr ? rive::make_rcp<rive::RiveRenderImage>(std::move(texture)) : nullptr;
     }
 
+    rive::rcp<rive::RenderImage> CreateRiveRenderImageASTC(HRenderContext context, void* bytes, uint32_t byte_count)
+    {
+        DefoldRiveRenderer* renderer = (DefoldRiveRenderer*) context;
+
+        ASTCHeader header;
+        if (!ParseASTCHeader((const uint8_t*)bytes, byte_count, &header))
+        {
+            dmLogError("Failed to parse ASTC header");
+            return nullptr;
+        }
+
+        const uint8_t* astcData = GetASTCCompressedData((const uint8_t*)bytes);
+        size_t astcDataSize = GetASTCCompressedDataSize(byte_count);
+
+        rive::rcp<rive::gpu::Texture> texture = renderer->m_RenderContext->MakeImageTextureASTC(
+            header.width, header.height, header.block_width, header.block_height, astcData, (uint32_t)astcDataSize);
+
+        return texture != nullptr ? rive::make_rcp<rive::RiveRenderImage>(std::move(texture)) : nullptr;
+    }
+
     rive::Mat2D GetViewTransform(HRenderContext context, dmRender::HRenderContext render_context)
     {
         const dmVMath::Matrix4& view_matrix = dmRender::GetViewMatrix(render_context);