Generate mipmaps when requested, deferring as needed

Author: bridgewaterrobbie

filament/backend/src/webgpu/WebGPUDriver.cpp

@@ -694,7 +694,61 @@ void WebGPUDriver::setupExternalImage2(Platform::ExternalImageHandleRef image) {
 void WebGPUDriver::setExternalStream(Handle<HwTexture> th, Handle<HwStream> sh) {
 }
 
-void WebGPUDriver::generateMipmaps(Handle<HwTexture> th) { }
+void WebGPUDriver::generateMipmaps(Handle<HwTexture> th) {
+    if (!mCommandEncoder) {
+        mMipQueue.push_back(th);
+        return;
+    }
+    auto* texture = handleCast<WGPUTexture>(th);
+    assert_invariant(texture);
+    wgpu::Texture wgpuTexture = texture->getTexture();
+    assert_invariant(wgpuTexture);
+
+    FILAMENT_CHECK_PRECONDITION(wgpuTexture.GetUsage() & wgpu::TextureUsage::CopySrc)
+            << "Texture intended for mipmap generation (as source) must have CopySrc usage.";
+    FILAMENT_CHECK_PRECONDITION(wgpuTexture.GetUsage() & wgpu::TextureUsage::CopyDst)
+            << "Texture intended for mipmap generation (as destination) must have CopyDst usage.";
+
+    uint32_t mipLevelCount = wgpuTexture.GetMipLevelCount();
+    if (mipLevelCount <= 1) {
+        return;
+    }
+
+    uint32_t width = wgpuTexture.GetWidth();
+    uint32_t height = wgpuTexture.GetHeight();
+    // For 3D textures, depth is > 1. For 2D/Cube/Array, effectively 1 for mip-level copies.
+    uint32_t depth =
+            (texture->target == SamplerType::SAMPLER_3D) ? wgpuTexture.GetDepthOrArrayLayers() : 1;
+
+    for (uint32_t mipLevel = 0; mipLevel < mipLevelCount - 1; ++mipLevel) {
+        wgpu::TexelCopyTextureInfo sourceCopyInfo{
+            .texture = wgpuTexture,
+            .mipLevel = mipLevel,
+            .aspect = texture->getAspect(),
+        };
+
+        wgpu::TexelCopyTextureInfo destinationCopyInfo{
+            .texture = wgpuTexture,
+            .mipLevel = mipLevel + 1,
+            .aspect = texture->getAspect(),
+        };
+
+        uint32_t dstWidth = std::max(1u, width >> 1);
+        uint32_t dstHeight = std::max(1u, height >> 1);
+        uint32_t dstDepth = std::max(1u, depth >> 1);
+
+        wgpu::Extent3D copySize{ .width = dstWidth,
+            .height = dstHeight,
+            .depthOrArrayLayers = (texture->target == SamplerType::SAMPLER_3D)
+                                          ? dstDepth
+                                          : texture->getArrayLayerCount() };
+        mCommandEncoder.CopyTextureToTexture(&sourceCopyInfo, &destinationCopyInfo, &copySize);
+
+        width = dstWidth;
+        height = dstHeight;
+        depth = dstDepth;
+    }
+}
 
 void WebGPUDriver::compilePrograms(CompilerPriorityQueue priority,
         CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
@@ -804,6 +858,12 @@ void WebGPUDriver::makeCurrent(Handle<HwSwapChain> drawSch, Handle<HwSwapChain>
         .label = "command_encoder"
     };
     mCommandEncoder = mDevice.CreateCommandEncoder(&commandEncoderDescriptor);
+    if (!mMipQueue.empty()) {
+        for (auto& handle: mMipQueue) {
+            generateMipmaps(handle);
+        }
+        mMipQueue.clear();
+    }
     assert_invariant(mCommandEncoder);
 }
 

filament/backend/src/webgpu/WebGPUDriver.h

@@ -70,6 +70,7 @@ class WebGPUDriver final : public DriverBase {
     WebGPUSwapChain* mSwapChain = nullptr;
     uint64_t mNextFakeHandle = 1;
     wgpu::CommandEncoder mCommandEncoder = nullptr;
+    std::vector<Handle<HwTexture>> mMipQueue;
     wgpu::TextureView mTextureView = nullptr;
     wgpu::RenderPassEncoder mRenderPassEncoder = nullptr;
     wgpu::CommandBuffer mCommandBuffer = nullptr;

filament/backend/src/webgpu/WebGPUHandles.h

@@ -184,6 +184,7 @@ class WGPUTexture : public HwTexture {
     [[nodiscard]] const wgpu::Texture& getTexture() const { return mTexture; }
     [[nodiscard]] const wgpu::TextureView& getTextureView() const { return mTexureView; }
     [[nodiscard]] wgpu::TextureFormat getFormat() const { return mFormat; }
+    [[nodiscard]] uint32_t getArrayLayerCount() const { return mArrayLayerCount; }
 
     static wgpu::TextureFormat fToWGPUTextureFormat(
             filament::backend::TextureFormat const& fFormat);