Sampler creation as part of the driver

filament/backend/src/webgpu/WebGPUDriver.cpp

@@ -374,9 +374,7 @@ Handle<HwTexture> WebGPUDriver::createTextureS() noexcept {
     return allocHandle<WGPUTexture>();
 }
 
-Handle<HwTexture> WebGPUDriver::importTextureS() noexcept {
-    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
-}
+Handle<HwTexture> WebGPUDriver::importTextureS() noexcept { return allocHandle<WGPUTexture>(); }
 
 Handle<HwProgram> WebGPUDriver::createProgramS() noexcept {
     return allocHandle<WGPUProgram>();
@@ -395,7 +393,7 @@ Handle<HwIndexBuffer> WebGPUDriver::createIndexBufferS() noexcept {
 }
 
 Handle<HwTexture> WebGPUDriver::createTextureViewS() noexcept {
-    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUTexture>();
 }
 
 Handle<HwBufferObject> WebGPUDriver::createBufferObjectS() noexcept {
@@ -423,7 +421,7 @@ Handle<HwVertexBufferInfo> WebGPUDriver::createVertexBufferInfoS() noexcept {
 }
 
 Handle<HwTexture> WebGPUDriver::createTextureViewSwizzleS() noexcept {
-    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUTexture>();
 }
 
 Handle<HwRenderTarget> WebGPUDriver::createDefaultRenderTargetS() noexcept {
@@ -435,15 +433,15 @@ Handle<HwDescriptorSetLayout> WebGPUDriver::createDescriptorSetLayoutS() noexcep
 }
 
 Handle<HwTexture> WebGPUDriver::createTextureExternalImageS() noexcept {
-    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUTexture>();
 }
 
 Handle<HwTexture> WebGPUDriver::createTextureExternalImage2S() noexcept {
-    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUTexture>();
 }
 
 Handle<HwTexture> WebGPUDriver::createTextureExternalImagePlaneS() noexcept {
-    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUTexture>();
 }
 
 void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow, uint64_t flags) {
@@ -497,30 +495,46 @@ void WebGPUDriver::createBufferObjectR(Handle<HwBufferObject> boh, uint32_t byte
 
 void WebGPUDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint8_t levels,
         TextureFormat format, uint8_t samples, uint32_t w, uint32_t h, uint32_t depth,
-        TextureUsage usage) {}
+        TextureUsage usage) {
+    constructHandle<WGPUTexture>(th, target, levels, format, samples, w, h, depth, usage, mDevice);
+}
 
 void WebGPUDriver::createTextureViewR(Handle<HwTexture> th, Handle<HwTexture> srch,
-        uint8_t baseLevel, uint8_t levelCount) {}
+        uint8_t baseLevel, uint8_t levelCount) {
+    auto source = handleCast<WGPUTexture>(srch);
+
+    constructHandle<WGPUTexture>(th, source, baseLevel, levelCount);
+}
 
 void WebGPUDriver::createTextureViewSwizzleR(Handle<HwTexture> th, Handle<HwTexture> srch,
         backend::TextureSwizzle r, backend::TextureSwizzle g, backend::TextureSwizzle b,
-        backend::TextureSwizzle a) {}
+        backend::TextureSwizzle a) {
+    PANIC_POSTCONDITION("Swizzle WebGPU Texture is not supported");
+}
 
 void WebGPUDriver::createTextureExternalImage2R(Handle<HwTexture> th, backend::SamplerType target,
         backend::TextureFormat format, uint32_t width, uint32_t height, backend::TextureUsage usage,
-        Platform::ExternalImageHandleRef externalImage) {}
+        Platform::ExternalImageHandleRef externalImage) {
+    PANIC_POSTCONDITION("External WebGPU Texture is not supported");
+}
 
 void WebGPUDriver::createTextureExternalImageR(Handle<HwTexture> th, backend::SamplerType target,
         backend::TextureFormat format, uint32_t width, uint32_t height, backend::TextureUsage usage,
-        void* externalImage) {}
+        void* externalImage) {
+    PANIC_POSTCONDITION("External WebGPU Texture is not supported");
+}
 
 void WebGPUDriver::createTextureExternalImagePlaneR(Handle<HwTexture> th,
         backend::TextureFormat format, uint32_t width, uint32_t height, backend::TextureUsage usage,
-        void* image, uint32_t plane) {}
+        void* image, uint32_t plane) {
+    PANIC_POSTCONDITION("External WebGPU Texture is not supported");
+}
 
 void WebGPUDriver::importTextureR(Handle<HwTexture> th, intptr_t id, SamplerType target,
         uint8_t levels, TextureFormat format, uint8_t samples, uint32_t w, uint32_t h,
-        uint32_t depth, TextureUsage usage) {}
+        uint32_t depth, TextureUsage usage) {
+    PANIC_POSTCONDITION("Import WebGPU Texture is not supported");
+}
 
 void WebGPUDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph, Handle<HwVertexBuffer> vbh,
         Handle<HwIndexBuffer> ibh, PrimitiveType pt) {
@@ -597,7 +611,7 @@ FenceStatus WebGPUDriver::getFenceStatus(Handle<HwFence> fh) {
 // We create all textures using VK_IMAGE_TILING_OPTIMAL, so our definition of "supported" is that
 // the GPU supports the given texture format with non-zero optimal tiling features.
 bool WebGPUDriver::isTextureFormatSupported(TextureFormat format) {
-    return true;
+    return WGPUTexture::fToWGPUTextureFormat(format) != wgpu::TextureFormat::Undefined;
 }
 
 bool WebGPUDriver::isTextureSwizzleSupported() {
@@ -958,24 +972,22 @@ void WebGPUDriver::updateDescriptorSetBuffer(Handle<HwDescriptorSet> dsh,
 
 void WebGPUDriver::updateDescriptorSetTexture(Handle<HwDescriptorSet> dsh,
         backend::descriptor_binding_t binding, Handle<HwTexture> th, SamplerParams params) {
-    /*
     auto bindGroup = handleCast<WebGPUDescriptorSet>(dsh);
     auto texture = handleCast<WGPUTexture>(th);
 
-    // TODO very high odds badd assumptions are in here about handling HwTexture. Revisit with more
-    // understanding. Right now assuming there is a wgpu::TextureView filled in
     if (!bindGroup->getIsLocked()) {
+        // Dawn will cache duplicate samplers, so we don't strictly need to maintain a cache.
+        //  Making a cache might save us minor perf by reducing param translation
+        auto sampler = makeSampler(params);
         // TODO making assumptions that size and offset mean the same thing here.
         wgpu::BindGroupEntry tEntry{ .binding = static_cast<uint32_t>(binding * 2),
-            .textureView = texture->texView };
+            .textureView = texture->getTexView() };
         bindGroup->addEntry(tEntry.binding, std::move(tEntry));
 
         wgpu::BindGroupEntry sEntry{ .binding = static_cast<uint32_t>(binding * 2 + 1),
-            .sampler = texture->sampler };
+            .sampler = sampler };
         bindGroup->addEntry(sEntry.binding, std::move(sEntry));
     }
-    //TODO Just the setup, this function stilll needs the rest of logic implemented
-     */
 }
 
 void WebGPUDriver::bindDescriptorSet(Handle<HwDescriptorSet> dsh, backend::descriptor_set_t set,
@@ -987,5 +999,121 @@ void WebGPUDriver::bindDescriptorSet(Handle<HwDescriptorSet> dsh, backend::descr
 
 void WebGPUDriver::setDebugTag(HandleBase::HandleId handleId, utils::CString tag) {
 }
+wgpu::Sampler WebGPUDriver::makeSampler(SamplerParams const& params) {
+    wgpu::SamplerDescriptor desc;
+
+    desc.label = "TODO";
+    desc.addressModeU = fWrapModeToWAddressMode(params.wrapS);
+    desc.addressModeV = fWrapModeToWAddressMode(params.wrapR);
+    desc.addressModeW = fWrapModeToWAddressMode(params.wrapT);
+    switch (params.filterMag) {
+        case SamplerMagFilter::NEAREST: {
+            desc.magFilter = wgpu::FilterMode::Nearest;
+            break;
+        }
+        case SamplerMagFilter::LINEAR: {
+            desc.magFilter = wgpu::FilterMode::Linear;
+            break;
+        }
+    }
+    switch (params.filterMin) {
+        case SamplerMinFilter::NEAREST: {
+            desc.minFilter = wgpu::FilterMode::Nearest;
+            // Metal Driver uses an explicit not-mipmapped value webgpu lacks. Nearest should
+            // suffice
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
+            break;
+        }
+        case SamplerMinFilter::LINEAR: {
+            desc.minFilter = wgpu::FilterMode::Linear;
+            // Metal Driver uses an explicit not-mipmapped value webgpu lacks. Nearest should
+            // suffice
+
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
+            break;
+        }
+        case SamplerMinFilter::NEAREST_MIPMAP_NEAREST: {
+            desc.minFilter = wgpu::FilterMode::Nearest;
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
+            break;
+        }
+        case SamplerMinFilter::LINEAR_MIPMAP_NEAREST: {
+            desc.minFilter = wgpu::FilterMode::Linear;
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
+
+            break;
+        }
+        case SamplerMinFilter::NEAREST_MIPMAP_LINEAR: {
+            desc.minFilter = wgpu::FilterMode::Nearest;
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Linear;
+
+            break;
+        }
+        case SamplerMinFilter::LINEAR_MIPMAP_LINEAR: {
+            desc.minFilter = wgpu::FilterMode::Linear;
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Linear;
+            break;
+        }
+    }
+    switch (params.compareFunc) {
+        case SamplerCompareFunc::LE: {
+            desc.compare = wgpu::CompareFunction::LessEqual;
+            break;
+        }
+        case SamplerCompareFunc::GE: {
+            desc.compare = wgpu::CompareFunction::GreaterEqual;
+            break;
+        }
+        case SamplerCompareFunc::L: {
+            desc.compare = wgpu::CompareFunction::Less;
+            break;
+        }
+        case SamplerCompareFunc::G: {
+            desc.compare = wgpu::CompareFunction::Greater;
+            break;
+        }
+        case SamplerCompareFunc::E: {
+            desc.compare = wgpu::CompareFunction::Equal;
+            break;
+        }
+        case SamplerCompareFunc::NE: {
+            desc.compare = wgpu::CompareFunction::NotEqual;
+            break;
+        }
+        case SamplerCompareFunc::A: {
+            desc.compare = wgpu::CompareFunction::Always;
+            break;
+        }
+        case SamplerCompareFunc::N: {
+            desc.compare = wgpu::CompareFunction::Never;
+            break;
+        }
+    }
+
+    desc.maxAnisotropy = 1u << params.anisotropyLog2;
+
+
+    // Unused: Filament's compareMode, WGPU lodMinClamp/lodMaxClamp
+
+    return mDevice.CreateSampler();
+}
+wgpu::AddressMode WebGPUDriver::fWrapModeToWAddressMode(const SamplerWrapMode& fWrapMode) {
+    switch (fWrapMode) {
+        case SamplerWrapMode::CLAMP_TO_EDGE: {
+            return wgpu::AddressMode::ClampToEdge;
+            break;
+        }
+        case SamplerWrapMode::REPEAT: {
+            return wgpu::AddressMode::Repeat;
+            break;
+        }
+        case SamplerWrapMode::MIRRORED_REPEAT: {
+            return wgpu::AddressMode::MirrorRepeat;
+            break;
+        }
+    }
+    return wgpu::AddressMode::Undefined;
+}
+
 
 } // namespace filament

filament/backend/src/webgpu/WebGPUDriver.h

@@ -56,7 +56,8 @@ private:
     explicit WebGPUDriver(WebGPUPlatform& platform, const Platform::DriverConfig& driverConfig) noexcept;
     [[nodiscard]] ShaderModel getShaderModel() const noexcept final;
     [[nodiscard]] ShaderLanguage getShaderLanguage() const noexcept final;
-
+    [[nodiscard]] wgpu::Sampler makeSampler(SamplerParams const& params);
+    [[nodiscard]] static wgpu::AddressMode fWrapModeToWAddressMode(const filament::backend::SamplerWrapMode& fUsage);
     template<typename GPUBufferObject>
     void updateGPUBuffer(GPUBufferObject* gpuBufferObject, BufferDescriptor&& bufferDescriptor,
             uint32_t byteOffset) {

filament/backend/src/webgpu/WebGPUHandles.cpp

@@ -267,10 +267,14 @@ WebGPUDescriptorSetLayout::~WebGPUDescriptorSetLayout() {}
 
 WebGPUDescriptorSet::WebGPUDescriptorSet(const wgpu::BindGroupLayout& layout, uint layoutSize)
     : mLayout(layout),
-      entries(layoutSize, wgpu::BindGroupEntry{}) {
+      entries(layoutSize, wgpu::BindGroupEntry{.buffer = nullptr, .sampler = nullptr, .textureView = nullptr}) {
     // Establish the size of entries based on the layout. This should be reliable and efficient.
 }
-WebGPUDescriptorSet::~WebGPUDescriptorSet() {}
+WebGPUDescriptorSet::~WebGPUDescriptorSet() {
+    mBindGroup = nullptr;
+    mLayout = nullptr;
+    entries.clear();
+}
 
 wgpu::BindGroup WebGPUDescriptorSet::lockAndReturn(const wgpu::Device& device) {
     if (mBindGroup) {
@@ -292,6 +296,364 @@ void WebGPUDescriptorSet::addEntry(uint index, wgpu::BindGroupEntry&& entry) {
     }
     // TODO: Putting some level of trust that Filament is not going to reuse indexes or go past the
     // layout index for efficiency. Add guards if wrong.
-    entries[index] = std::move(entry);
+    entries.emplace_back(std::move(entry));
 }
+// From createTextureR
+WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat format, uint8_t samples,
+        uint32_t width, uint32_t height, uint32_t depth, TextureUsage usage,
+        wgpu::Device device) noexcept {
+
+    // First the texture aspect
+    wgpu::TextureDescriptor desc;
+
+    switch (target) {
+        case SamplerType::SAMPLER_CUBEMAP:
+        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
+        case SamplerType::SAMPLER_2D:
+        case SamplerType::SAMPLER_2D_ARRAY:
+        // Should be safe to assume external is 2d
+        case SamplerType::SAMPLER_EXTERNAL: {
+            desc.dimension = wgpu::TextureDimension::e2D;
+            break;
+        }
+        case SamplerType::SAMPLER_3D: {
+            desc.dimension = wgpu::TextureDimension::e3D;
+            break;
+        }
+    }
+    desc.size = { .width = width, .height = height, .depthOrArrayLayers = depth };
+    desc.format = fToWGPUTextureFormat(format);
+    assert_invariant(desc.format != wgpu::TextureFormat::Undefined);
+
+    // WGPU requires this to be true. Filament should comply
+    assert(samples == 1 || samples || 4);
+
+    desc.sampleCount = samples;
+    desc.usage = fToWGPUTextureUsage(usage);
+    desc.mipLevelCount = levels;
+
+    // TODO Is this fine? Could do all-the-things, a naive mapping or get something from Filament
+    desc.viewFormats = nullptr;
+
+    texture = device.CreateTexture(&desc);
+
+    // TODO should a default levelCount be something other than 0? Sample count?
+    texView = makeTextureView(0, 1);
+}
+// From createTextureViewR
+WGPUTexture::WGPUTexture(WGPUTexture* src, uint8_t baseLevel, uint8_t levelCount) noexcept {
+    texture = src->texture;
+    texView = makeTextureView(baseLevel, levelCount);
+}
+
+wgpu::TextureUsage WGPUTexture::fToWGPUTextureUsage(const TextureUsage& fUsage) {
+    wgpu::TextureUsage retUsage = wgpu::TextureUsage::None;
+
+    // Basing this mapping off of VulkanTexture.cpp's getUsage func and suggestions from Gemini
+    // TODO Validate assumptions, revisit if issues.
+    if (any(TextureUsage::BLIT_SRC & fUsage)) {
+        retUsage |= wgpu::TextureUsage::CopySrc;
+    }
+    if (any((TextureUsage::BLIT_DST | TextureUsage::UPLOADABLE) & fUsage)) {
+        retUsage |= wgpu::TextureUsage::CopyDst;
+    }
+    if (any(TextureUsage::SAMPLEABLE & fUsage)) {
+        retUsage |= wgpu::TextureUsage::TextureBinding;
+    }
+    // WGPU Render attachment covers either color or stencil situation dependant
+    // NOTE: Depth attachment isn't used this way in Vulkan but logically maps to WGPU docs. If
+    // issues, investigate here.
+    if (any((TextureUsage::COLOR_ATTACHMENT | TextureUsage::STENCIL_ATTACHMENT |
+                    TextureUsage::DEPTH_ATTACHMENT) &
+                fUsage)) {
+        retUsage |= wgpu::TextureUsage::RenderAttachment;
+    }
+
+    // This is from Vulkan logic- if there are any issues try disabling this first, allows perf
+    // benefit though
+    const bool useTransientAttachment =
+            // Usage consists of attachment flags only.
+            none(fUsage & ~TextureUsage::ALL_ATTACHMENTS) &&
+            // Usage contains at least one attachment flag.
+            any(fUsage & TextureUsage::ALL_ATTACHMENTS) &&
+            // Depth resolve cannot use transient attachment because it uses a custom shader.
+            // TODO: see VulkanDriver::isDepthStencilResolveSupported() to know when to remove this
+            // restriction.
+            // Note that the custom shader does not resolve stencil. We do need to move to vk 1.2
+            // and above to be able to support stencil resolve (along with depth).
+            !(any(fUsage & TextureUsage::DEPTH_ATTACHMENT) && samples > 1);
+    if (useTransientAttachment) {
+        retUsage |= wgpu::TextureUsage::TransientAttachment;
+    }
+    // NOTE: Unused wgpu flags:
+    //  StorageBinding
+    //  StorageAttachment
+
+    // NOTE: Unused Filament flags:
+    //  SUBPASS_INPUT VK goes to input attachment which we don't support right now
+    //  PROTECTED
+    return retUsage;
+}
+wgpu::TextureFormat WGPUTexture::fToWGPUTextureFormat(const TextureFormat& fUsage) {
+    switch (fUsage) {
+        case filament::backend::TextureFormat::R8:
+            return wgpu::TextureFormat::R8Unorm;
+        case filament::backend::TextureFormat::R8_SNORM:
+            return wgpu::TextureFormat::R8Snorm;
+        case filament::backend::TextureFormat::R8UI:
+            return wgpu::TextureFormat::R8Uint;
+        case filament::backend::TextureFormat::R8I:
+            return wgpu::TextureFormat::R8Sint;
+        case filament::backend::TextureFormat::STENCIL8:
+            return wgpu::TextureFormat::Stencil8;
+        case filament::backend::TextureFormat::R16F:
+            return wgpu::TextureFormat::R16Float;
+        case filament::backend::TextureFormat::R16UI:
+            return wgpu::TextureFormat::R16Uint;
+        case filament::backend::TextureFormat::R16I:
+            return wgpu::TextureFormat::R16Sint;
+        case filament::backend::TextureFormat::RG8:
+            return wgpu::TextureFormat::RG8Unorm;
+        case filament::backend::TextureFormat::RG8_SNORM:
+            return wgpu::TextureFormat::RG8Snorm;
+        case filament::backend::TextureFormat::RG8UI:
+            return wgpu::TextureFormat::RG8Uint;
+        case filament::backend::TextureFormat::RG8I:
+            return wgpu::TextureFormat::RG8Sint;
+        case filament::backend::TextureFormat::R32F:
+            return wgpu::TextureFormat::R32Float;
+        case filament::backend::TextureFormat::R32UI:
+            return wgpu::TextureFormat::R32Uint;
+        case filament::backend::TextureFormat::R32I:
+            return wgpu::TextureFormat::R32Sint;
+        case filament::backend::TextureFormat::RG16F:
+            return wgpu::TextureFormat::RG16Float;
+        case filament::backend::TextureFormat::RG16UI:
+            return wgpu::TextureFormat::RG16Uint;
+        case filament::backend::TextureFormat::RG16I:
+            return wgpu::TextureFormat::RG16Sint;
+        case filament::backend::TextureFormat::RGBA8:
+            return wgpu::TextureFormat::RGBA8Unorm;
+        case filament::backend::TextureFormat::SRGB8_A8:
+            return wgpu::TextureFormat::RGBA8UnormSrgb;
+        case filament::backend::TextureFormat::RGBA8_SNORM:
+            return wgpu::TextureFormat::RGBA8Snorm;
+        case filament::backend::TextureFormat::RGBA8UI:
+            return wgpu::TextureFormat::RGBA8Uint;
+        case filament::backend::TextureFormat::RGBA8I:
+            return wgpu::TextureFormat::RGBA8Sint;
+        case filament::backend::TextureFormat::DEPTH16:
+            return wgpu::TextureFormat::Depth16Unorm;
+        case filament::backend::TextureFormat::DEPTH24:
+            return wgpu::TextureFormat::Depth24Plus;
+        case filament::backend::TextureFormat::DEPTH32F:
+            return wgpu::TextureFormat::Depth32Float;
+        case filament::backend::TextureFormat::DEPTH24_STENCIL8:
+            return wgpu::TextureFormat::Depth24PlusStencil8;
+        case filament::backend::TextureFormat::DEPTH32F_STENCIL8:
+            return wgpu::TextureFormat::Depth32FloatStencil8;
+        case filament::backend::TextureFormat::RG32F:
+            return wgpu::TextureFormat::RG32Float;
+        case filament::backend::TextureFormat::RG32UI:
+            return wgpu::TextureFormat::RG32Uint;
+        case filament::backend::TextureFormat::RG32I:
+            return wgpu::TextureFormat::RG32Sint;
+        case filament::backend::TextureFormat::RGBA16F:
+            return wgpu::TextureFormat::RGBA16Float;
+        case filament::backend::TextureFormat::RGBA16UI:
+            return wgpu::TextureFormat::RGBA16Uint;
+        case filament::backend::TextureFormat::RGBA16I:
+            return wgpu::TextureFormat::RGBA16Sint;
+        case filament::backend::TextureFormat::RGBA32F:
+            return wgpu::TextureFormat::RGBA32Float;
+        case filament::backend::TextureFormat::RGBA32UI:
+            return wgpu::TextureFormat::RGBA32Uint;
+        case filament::backend::TextureFormat::RGBA32I:
+            return wgpu::TextureFormat::RGBA32Sint;
+        case filament::backend::TextureFormat::EAC_R11:
+            return wgpu::TextureFormat::EACR11Unorm;
+        case filament::backend::TextureFormat::EAC_R11_SIGNED:
+            return wgpu::TextureFormat::EACR11Snorm;
+        case filament::backend::TextureFormat::EAC_RG11:
+            return wgpu::TextureFormat::EACRG11Unorm;
+        case filament::backend::TextureFormat::EAC_RG11_SIGNED:
+            return wgpu::TextureFormat::EACRG11Snorm;
+        case filament::backend::TextureFormat::ETC2_RGB8:
+            return wgpu::TextureFormat::ETC2RGB8Unorm;
+        case filament::backend::TextureFormat::ETC2_SRGB8:
+            return wgpu::TextureFormat::ETC2RGB8UnormSrgb;
+        case filament::backend::TextureFormat::ETC2_RGB8_A1:
+            return wgpu::TextureFormat::ETC2RGB8A1Unorm;
+        case filament::backend::TextureFormat::ETC2_SRGB8_A1:
+            return wgpu::TextureFormat::ETC2RGB8A1UnormSrgb;
+        case filament::backend::TextureFormat::ETC2_EAC_RGBA8:
+            return wgpu::TextureFormat::ETC2RGBA8Unorm;
+        case filament::backend::TextureFormat::ETC2_EAC_SRGBA8:
+            return wgpu::TextureFormat::ETC2RGBA8UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_4x4:
+            return wgpu::TextureFormat::ASTC4x4Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_4x4:
+            return wgpu::TextureFormat::ASTC4x4UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_5x4:
+            return wgpu::TextureFormat::ASTC5x4Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_5x4:
+            return wgpu::TextureFormat::ASTC5x4UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_5x5:
+            return wgpu::TextureFormat::ASTC5x5Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_5x5:
+            return wgpu::TextureFormat::ASTC5x5UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_6x5:
+            return wgpu::TextureFormat::ASTC6x5Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_6x5:
+            return wgpu::TextureFormat::ASTC6x5UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_6x6:
+            return wgpu::TextureFormat::ASTC6x6Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_6x6:
+            return wgpu::TextureFormat::ASTC6x6UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_8x5:
+            return wgpu::TextureFormat::ASTC8x5Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_8x5:
+            return wgpu::TextureFormat::ASTC8x5UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_8x6:
+            return wgpu::TextureFormat::ASTC8x6Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_8x6:
+            return wgpu::TextureFormat::ASTC8x6UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_8x8:
+            return wgpu::TextureFormat::ASTC8x8Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_8x8:
+            return wgpu::TextureFormat::ASTC8x8UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_10x5:
+            return wgpu::TextureFormat::ASTC10x5Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_10x5:
+            return wgpu::TextureFormat::ASTC10x5UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_10x6:
+            return wgpu::TextureFormat::ASTC10x6Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_10x6:
+            return wgpu::TextureFormat::ASTC10x6UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_10x8:
+            return wgpu::TextureFormat::ASTC10x8Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_10x8:
+            return wgpu::TextureFormat::ASTC10x8UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_10x10:
+            return wgpu::TextureFormat::ASTC10x10Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_10x10:
+            return wgpu::TextureFormat::ASTC10x10UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_12x10:
+            return wgpu::TextureFormat::ASTC12x10Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_12x10:
+            return wgpu::TextureFormat::ASTC12x10UnormSrgb;
+        case filament::backend::TextureFormat::RGBA_ASTC_12x12:
+            return wgpu::TextureFormat::ASTC12x12Unorm;
+        case filament::backend::TextureFormat::SRGB8_ALPHA8_ASTC_12x12:
+            return wgpu::TextureFormat::ASTC12x12UnormSrgb;
+        case filament::backend::TextureFormat::RED_RGTC1:
+            return wgpu::TextureFormat::BC4RUnorm;
+        case filament::backend::TextureFormat::SIGNED_RED_RGTC1:
+            return wgpu::TextureFormat::BC4RSnorm;
+        case filament::backend::TextureFormat::RED_GREEN_RGTC2:
+            return wgpu::TextureFormat::BC5RGUnorm;
+        case filament::backend::TextureFormat::SIGNED_RED_GREEN_RGTC2:
+            return wgpu::TextureFormat::BC5RGSnorm;
+        case filament::backend::TextureFormat::RGB_BPTC_UNSIGNED_FLOAT:
+            return wgpu::TextureFormat::BC6HRGBUfloat;
+        case filament::backend::TextureFormat::RGB_BPTC_SIGNED_FLOAT:
+            return wgpu::TextureFormat::BC6HRGBFloat;
+        case filament::backend::TextureFormat::RGBA_BPTC_UNORM:
+            return wgpu::TextureFormat::BC7RGBAUnorm;
+        case filament::backend::TextureFormat::SRGB_ALPHA_BPTC_UNORM:
+            return wgpu::TextureFormat::BC7RGBAUnormSrgb;
+        case filament::backend::TextureFormat::RGB565:
+            // No direct mapping in wgpu. Could potentially map to RGBA8Unorm
+            // and discard the alpha and lower precision.
+            return wgpu::TextureFormat::Undefined;
+        case filament::backend::TextureFormat::RGB9_E5:
+            return wgpu::TextureFormat::RGB9E5Ufloat;
+        case filament::backend::TextureFormat::RGB5_A1:
+            // No direct mapping in wgpu. Could potentially map to RGBA8Unorm
+            // and handle the packing/unpacking in shaders.
+            return wgpu::TextureFormat::Undefined;
+        case filament::backend::TextureFormat::RGBA4:
+            // No direct mapping in wgpu. Could potentially map to RGBA8Unorm
+            // and handle the packing/unpacking in shaders.
+            return wgpu::TextureFormat::Undefined;
+        case filament::backend::TextureFormat::RGB8:
+            // No direct sRGB equivalent in wgpu without alpha.
+            return wgpu::TextureFormat::RGBA8Unorm;
+        case filament::backend::TextureFormat::SRGB8:
+            // No direct sRGB equivalent in wgpu without alpha.
+            return wgpu::TextureFormat::RGBA8UnormSrgb;
+        case filament::backend::TextureFormat::RGB8_SNORM:
+            // No direct mapping in wgpu without alpha.
+            return wgpu::TextureFormat::RGBA8Snorm;
+        case filament::backend::TextureFormat::RGB8UI:
+            // No direct mapping in wgpu without alpha.
+            return wgpu::TextureFormat::RGBA8Uint;
+        case filament::backend::TextureFormat::RGB8I:
+            // No direct mapping in wgpu without alpha.
+            return wgpu::TextureFormat::RGBA8Sint;
+        case filament::backend::TextureFormat::R11F_G11F_B10F:
+            return wgpu::TextureFormat::RG11B10Ufloat;
+        case filament::backend::TextureFormat::UNUSED:
+            return wgpu::TextureFormat::Undefined;
+        case filament::backend::TextureFormat::RGB10_A2:
+            return wgpu::TextureFormat::RGB10A2Unorm;
+        case filament::backend::TextureFormat::RGB16F:
+            // No direct mapping in wgpu without alpha.
+            return wgpu::TextureFormat::RGBA16Float;
+        case filament::backend::TextureFormat::RGB16UI:
+            // No direct mapping in wgpu without alpha.
+            return wgpu::TextureFormat::RGBA16Uint;
+        case filament::backend::TextureFormat::RGB16I:
+            // No direct mapping in wgpu without alpha.
+            return wgpu::TextureFormat::RGBA16Sint;
+        case filament::backend::TextureFormat::RGB32F:
+            // No direct mapping in wgpu without alpha.
+            return wgpu::TextureFormat::RGBA32Float;
+        case filament::backend::TextureFormat::RGB32UI:
+            // No direct mapping in wgpu without alpha.
+            return wgpu::TextureFormat::RGBA32Uint;
+        case filament::backend::TextureFormat::RGB32I:
+            // No direct mapping in wgpu without alpha.
+            return wgpu::TextureFormat::RGBA32Sint;
+        case filament::backend::TextureFormat::DXT1_RGB:
+            return wgpu::TextureFormat::BC1RGBAUnorm;
+        case filament::backend::TextureFormat::DXT1_RGBA:
+            return wgpu::TextureFormat::BC1RGBAUnorm;
+        case filament::backend::TextureFormat::DXT3_RGBA:
+            return wgpu::TextureFormat::BC2RGBAUnorm;
+        case filament::backend::TextureFormat::DXT5_RGBA:
+            return wgpu::TextureFormat::BC3RGBAUnorm;
+        case filament::backend::TextureFormat::DXT1_SRGB:
+            return wgpu::TextureFormat::BC1RGBAUnormSrgb;
+        case filament::backend::TextureFormat::DXT1_SRGBA:
+            return wgpu::TextureFormat::BC1RGBAUnormSrgb;
+        case filament::backend::TextureFormat::DXT3_SRGBA:
+            return wgpu::TextureFormat::BC2RGBAUnormSrgb;
+        case filament::backend::TextureFormat::DXT5_SRGBA:
+            return wgpu::TextureFormat::BC3RGBAUnormSrgb;
+    }
+}
+
+wgpu::TextureView WGPUTexture::makeTextureView(const uint8_t& baseLevel,
+        const uint8_t& levelCount) {
+    wgpu::TextureViewDescriptor desc;
+    desc.baseMipLevel = baseLevel;
+    desc.mipLevelCount = levelCount;
+
+    // baseArrayLayer is required, making a guess
+    desc.baseArrayLayer = 0;
+    // Have not found an analouge to aspect in other drivers, but ALL should be unrestrictive.
+    // TODO Can we make this better?
+    desc.aspect = wgpu::TextureAspect::All;
+
+    // The rest of the properties should be fine to leave as default, using the texture params.
+    desc.label = "TODO";
+
+    desc.format = wgpu::TextureFormat::Undefined;
+    desc.dimension = wgpu::TextureViewDimension::Undefined;
+    desc.usage = wgpu::TextureUsage::None;
+
+    return texture.CreateView(&desc);
+}
+
 }// namespace filament::backend

filament/backend/src/webgpu/WebGPUHandles.h

@@ -132,21 +132,28 @@ private:
     wgpu::BindGroup mBindGroup;
 };
 
-// TODO: Currently WGPUTexture is not used by WebGPU for useful task.
-// Update the struct when used by WebGPU driver.
-struct WGPUTexture : public HwTexture {
+class WGPUTexture : public HwTexture {
+public:
     WGPUTexture(SamplerType target, uint8_t levels, TextureFormat format, uint8_t samples,
-            uint32_t width, uint32_t height, uint32_t depth, TextureUsage usage) noexcept;
+            uint32_t width, uint32_t height, uint32_t depth, TextureUsage usage,
+            wgpu::Device device) noexcept;
 
-    // constructors for creating texture views
-    WGPUTexture(WGPUTexture const* src, uint8_t baseLevel, uint8_t levelCount) noexcept;
+    WGPUTexture(WGPUTexture* src, uint8_t baseLevel, uint8_t levelCount) noexcept;
 
+    const wgpu::Texture& getTexture() const { return texture; }
+    const wgpu::TextureView& getTexView() const { return texView; }
+
+    // Public to allow checking for support of a texture format
+    static wgpu::TextureFormat fToWGPUTextureFormat(const filament::backend::TextureFormat& fUsage);
+
+private:
+    wgpu::TextureView makeTextureView(const uint8_t& baseLevel, const uint8_t& levelCount);
+    // CreateTextureR has info for a texture and sampler. Texture Views are needed for binding,
+    // along with a sampler Current plan: Inherit the sampler and Texture to always exist (It is a
+    // ref counted pointer) when making views. View is optional
     wgpu::Texture texture = nullptr;
-    // TODO: Adding this but not yet setting it up. Filament "Textures" are combined image samplers,
-    // rep both.
-    wgpu::Sampler sampler = nullptr;
-    //TODO: Not sure all the ways HwTexture is used. Overloading like this might be entirely wrong.
     wgpu::TextureView texView = nullptr;
+    wgpu::TextureUsage fToWGPUTextureUsage(const filament::backend::TextureUsage& fUsage);
 };
 
 struct WGPURenderPrimitive : public HwRenderPrimitive {
@@ -170,7 +177,7 @@ struct WGPURenderTarget : public HwRenderTarget {
         Attachment(WGPUTexture* gpuTexture, uint8_t level = 0, uint16_t layer = 0)
             : level(level),
               layer(layer),
-              texture(gpuTexture->texture),
+              texture(gpuTexture->getTexture()),
               mWGPUTexture(gpuTexture) {}
 
         uint8_t level = 0;

filament/backend/src/webgpu/platform/WebGPUPlatform.cpp

@@ -99,10 +99,9 @@ wgpu::Adapter WebGPUPlatform::requestAdapter(wgpu::Surface const& surface) {
 
 wgpu::Device WebGPUPlatform::requestDevice(wgpu::Adapter const& adapter) {
     // TODO consider passing limits
-    constexpr std::array desiredFeatures = {
-        wgpu::FeatureName::DepthClipControl,
-        wgpu::FeatureName::Depth32FloatStencil8,
-        wgpu::FeatureName::CoreFeaturesAndLimits };
+    constexpr std::array desiredFeatures = { wgpu::FeatureName::DepthClipControl,
+        wgpu::FeatureName::Depth32FloatStencil8, wgpu::FeatureName::CoreFeaturesAndLimits,
+        wgpu::FeatureName::TransientAttachments };
     std::vector<wgpu::FeatureName> requiredFeatures;
     requiredFeatures.reserve(desiredFeatures.size());
     wgpu::SupportedFeatures supportedFeatures;