Merge branch 'main' into kpiascik/shadowtestassert

A zero color target fragment stage implies a depth pass by Filament.
We can create a pipeline without a fragment stage to make it valid.

BUGS=[421933134]

filament/backend/CMakeLists.txt

@@ -273,6 +273,8 @@ if (FILAMENT_SUPPORTS_WEBGPU)
             src/webgpu/WebGPUFence.h
             src/webgpu/WebGPUIndexBuffer.cpp
             src/webgpu/WebGPUIndexBuffer.h
+            src/webgpu/WebGPUMsaaTextureResolver.cpp
+            src/webgpu/WebGPUMsaaTextureResolver.h
             src/webgpu/WebGPUPipelineCreation.cpp
             src/webgpu/WebGPUPipelineCreation.h
             src/webgpu/WebGPUProgram.cpp

filament/backend/src/opengl/ShaderCompilerService.cpp

@@ -66,7 +66,7 @@ static std::string to_string(int const i) { return std::to_string(i); }
 static std::string to_string(float const f) { return "float(" + std::to_string(f) + ")"; }
 
 static void logCompilationError(ShaderStage shaderType, const char* name, GLuint shaderId,
-        CString const& sourceCode) noexcept;
+        Program::ShaderBlob const& sourceCode) noexcept;
 static void logProgramLinkError(char const* name, GLuint program) noexcept;
 
 static void process_GOOGLE_cpp_style_line_directive(OpenGLContext const& context, char* source,
@@ -88,7 +88,7 @@ struct ShaderCompilerService::OpenGLProgramToken : ProgramToken {
     ShaderCompilerService& compiler;
     CString const& name;
     FixedCapacityVector<std::pair<CString, uint8_t>> attributes;
-    shaders_source_t shaderSourceCode;
+    Program::ShaderSource shaderSourceCode;
     void* user = nullptr;
     struct {
         shaders_t shaders{};
@@ -612,7 +612,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
 #ifndef NDEBUG
             // for debugging we return the original shader source (without the modifications we
             // made here), otherwise the line numbers wouldn't match.
-            token->shaderSourceCode[i] = { shader_src, shader_len };
+            token->shaderSourceCode[i] = std::move(shader);
 #endif
             token->gl.shaders[i] = shaderId;
         }
@@ -758,7 +758,8 @@ void ShaderCompilerService::executeTickOps() noexcept {
 
 UTILS_NOINLINE
 /* static */ void logCompilationError(ShaderStage shaderType, const char* name,
-        GLuint const shaderId, UTILS_UNUSED_IN_RELEASE CString const& sourceCode) noexcept {
+        GLuint const shaderId,
+        UTILS_UNUSED_IN_RELEASE Program::ShaderBlob const& sourceCode) noexcept {
 
     { // scope for the temporary string storage
         auto to_string = [](ShaderStage type) -> const char* {
@@ -785,7 +786,8 @@ UTILS_NOINLINE
     }
 
 #ifndef NDEBUG
-    std::string_view const shader{ sourceCode.data(), sourceCode.size() };
+    std::string_view const shader{ reinterpret_cast<const char*>(sourceCode.data()),
+        sourceCode.size() };
     size_t lc = 1;
     size_t start = 0;
     std::string line;

filament/backend/src/opengl/ShaderCompilerService.h

@@ -58,7 +58,6 @@ class ShaderCompilerService {
 public:
     using program_token_t = std::shared_ptr<OpenGLProgramToken>;
     using shaders_t = std::array<GLuint, Program::SHADER_TYPE_COUNT>;
-    using shaders_source_t = std::array<utils::CString, Program::SHADER_TYPE_COUNT>;
 
     explicit ShaderCompilerService(OpenGLDriver& driver);
 

filament/backend/src/vulkan/VulkanStagePool.cpp

@@ -156,27 +156,27 @@ void VulkanStagePool::destroyStage(VulkanStage const*&& stage) {
     delete stage;
 }
 
-VulkanStageImage const* VulkanStagePool::acquireImage(PixelDataFormat format, PixelDataType type,
-        uint32_t width, uint32_t height) {
+fvkmemory::resource_ptr<VulkanStageImage::Resource> VulkanStagePool::acquireImage(
+        PixelDataFormat format, PixelDataType type, uint32_t width, uint32_t height) {
+    // Helper lambda so we can return stage images wrapped as resources that can
+    // be held by command buffers until no longer needed.
+    auto wrapAsResource = [this](VulkanStageImage* image) {
+        auto recycleFn = [this](VulkanStageImage* image) {
+            this->mFreeImages.insert(image);
+        };
+        return fvkmemory::resource_ptr<VulkanStageImage::Resource>::construct(
+            this->mResManager, image, recycleFn);
+    };
+
     const VkFormat vkformat = fvkutils::getVkFormat(format, type);
-    for (auto image : mFreeImages) {
-        if (image->format == vkformat && image->width == width && image->height == height) {
-            mFreeImages.erase(image);
-            image->lastAccessed = mCurrentFrame;
-            mUsedImages.push_back(image);
-            return image;
+    for (auto stageImage : mFreeImages) {
+        if (stageImage->format() == vkformat && stageImage->width() == width && stageImage->height() == height) {
+            mFreeImages.erase(stageImage);
+            stageImage->mLastAccessed = mCurrentFrame;
+            return wrapAsResource(stageImage);
         }
     }
 
-    VulkanStageImage* image = new VulkanStageImage({
-        .format = vkformat,
-        .width = width,
-        .height = height,
-        .lastAccessed = mCurrentFrame,
-    });
-
-    mUsedImages.push_back(image);
-
     const VkImageCreateInfo imageInfo = {
         .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
         .imageType = VK_IMAGE_TYPE_2D,
@@ -194,14 +194,19 @@ VulkanStageImage const* VulkanStagePool::acquireImage(PixelDataFormat format, Pi
         .usage = VMA_MEMORY_USAGE_CPU_TO_GPU
     };
 
+    VkImage image;
+    VmaAllocation memory;
     const UTILS_UNUSED VkResult result = vmaCreateImage(mAllocator, &imageInfo, &allocInfo,
-            &image->image, &image->memory, nullptr);
+            &image, &memory, nullptr);
 
     assert_invariant(result == VK_SUCCESS);
 
     VkImageAspectFlags const aspectFlags = fvkutils::getImageAspect(vkformat);
     VkCommandBuffer const cmdbuffer = mCommands->get().buffer();
 
+    VulkanStageImage* stageImage = new VulkanStageImage(
+        vkformat, width, height, memory, image, mCurrentFrame);
+
     // We use VK_IMAGE_LAYOUT_GENERAL here because the spec says:
     // "Host access to image memory is only well-defined for linear images and for image
     // subresources of those images which are currently in either the
@@ -209,12 +214,13 @@ VulkanStageImage const* VulkanStagePool::acquireImage(PixelDataFormat format, Pi
     // vkGetImageSubresourceLayout for a linear image returns a subresource layout mapping that is
     // valid for either of those image layouts."
     fvkutils::transitionLayout(cmdbuffer, {
-            .image = image->image,
+            .image = stageImage->image(),
             .oldLayout = VulkanLayout::UNDEFINED,
             .newLayout = VulkanLayout::STAGING, // (= VK_IMAGE_LAYOUT_GENERAL)
             .subresources = { aspectFlags, 0, 1, 0, 1 },
         });
-    return image;
+
+    return wrapAsResource(stageImage);
 }
 
 void VulkanStagePool::gc() noexcept {
@@ -262,25 +268,14 @@ void VulkanStagePool::gc() noexcept {
     decltype(mFreeImages) freeImages;
     freeImages.swap(mFreeImages);
     for (auto image : freeImages) {
-        if (image->lastAccessed < evictionTime) {
-            vmaDestroyImage(mAllocator, image->image, image->memory);
+        if (image->mLastAccessed < evictionTime) {
+            vmaDestroyImage(mAllocator, image->image(), image->memory());
             delete image;
         } else {
             mFreeImages.insert(image);
         }
     }
 
-    // Reclaim images that are no longer being used by any command buffer.
-    decltype(mUsedImages) usedImages;
-    usedImages.swap(mUsedImages);
-    for (auto image : usedImages) {
-        if (image->lastAccessed < evictionTime) {
-            image->lastAccessed = mCurrentFrame;
-            mFreeImages.insert(image);
-        } else {
-            mUsedImages.push_back(image);
-        }
-    }
     FVK_SYSTRACE_END();
 }
 
@@ -290,14 +285,8 @@ void VulkanStagePool::terminate() noexcept {
     }
     mStages.clear();
 
-    for (auto image : mUsedImages) {
-        vmaDestroyImage(mAllocator, image->image, image->memory);
-        delete image;
-    }
-    mUsedImages.clear();
-
     for (auto image : mFreeImages) {
-        vmaDestroyImage(mAllocator, image->image, image->memory);
+        vmaDestroyImage(mAllocator, image->image(), image->memory());
         delete image;
     }
     mFreeImages.clear();

filament/backend/src/vulkan/VulkanStagePool.h

@@ -126,13 +126,70 @@ private:
     std::unordered_map<uint32_t, Segment*> mSegments;
 };
 
-struct VulkanStageImage {
-    VkFormat format;
-    uint32_t width;
-    uint32_t height;
-    mutable uint64_t lastAccessed;
-    VmaAllocation memory;
-    VkImage image;
+class VulkanStageImage {
+  public:
+    class Resource : public fvkmemory::Resource {
+      public:
+        using RecycleFn = std::function<void(VulkanStageImage*)>;
+
+        Resource(VulkanStageImage* image, RecycleFn&& onRecycleFn)
+            : mImage(image),
+              mOnRecycleFn(onRecycleFn)
+        {}
+
+        ~Resource() {
+            if (mOnRecycleFn) {
+                mOnRecycleFn(mImage);
+            }
+        }
+
+        inline VkFormat format() const { return mImage->format(); }
+        inline uint32_t width() const { return mImage->width(); }
+        inline uint32_t height() const { return mImage->height(); }
+        inline VmaAllocation memory() const { return mImage->memory(); }
+        inline VkImage image() const { return mImage->image(); }
+
+      private:
+        Resource() = delete;
+        Resource(const Resource& other) = delete;
+        Resource(Resource&& other) = delete;
+        Resource& operator=(const Resource& other) = delete;
+        Resource& operator=(Resource&& other) = delete;
+
+        VulkanStageImage* const mImage;
+        RecycleFn mOnRecycleFn;
+    };
+
+    VulkanStageImage(VkFormat format, uint32_t width, uint32_t height, VmaAllocation memory,
+            VkImage image, uint64_t lastAccessed)
+        : mFormat(format),
+          mWidth(width),
+          mHeight(height),
+          mMemory(memory),
+          mImage(image),
+          mLastAccessed(lastAccessed) {}
+
+    VulkanStageImage(const VulkanStageImage& other) = delete;
+    VulkanStageImage(VulkanStageImage&& other) = delete;
+    VulkanStageImage& operator=(const VulkanStageImage& other) = delete;
+    VulkanStageImage& operator=(VulkanStageImage&& other) = delete;
+
+    inline VkFormat format() const { return mFormat; }
+    inline uint32_t width() const { return mWidth; }
+    inline uint32_t height() const { return mHeight; }
+    inline VmaAllocation memory() const { return mMemory; }
+    inline VkImage image() const { return mImage; }
+
+  private:
+    const VkFormat mFormat;
+    const uint32_t mWidth;
+    const uint32_t mHeight;
+    const VmaAllocation mMemory;
+    const VkImage mImage;
+
+    uint64_t mLastAccessed;
+    // Denote as a friend so that it can update mLastAccessed.
+    friend class VulkanStagePool;
 };
 
 // Manages a pool of stages, periodically releasing stages that have been unused for a while.
@@ -153,7 +210,7 @@ public:
             uint32_t alignment = 0);
 
     // Images have VK_IMAGE_LAYOUT_GENERAL and must not be transitioned to any other layout
-    VulkanStageImage const* acquireImage(PixelDataFormat format, PixelDataType type,
+    fvkmemory::resource_ptr<VulkanStageImage::Resource> acquireImage(PixelDataFormat format, PixelDataType type,
             uint32_t width, uint32_t height);
 
     // Evicts old unused stages and bumps the current frame number.
@@ -193,8 +250,7 @@ private:
     // Use an ordered multimap for quick (capacity => stage) lookups using lower_bound().
     std::multimap<uint32_t, VulkanStage*> mStages;
 
-    std::unordered_set<VulkanStageImage const*> mFreeImages;
-    std::vector<VulkanStageImage const*> mUsedImages;
+    std::unordered_set<VulkanStageImage*> mFreeImages;
 
     // Store the current "time" (really just a frame count) and LRU eviction parameters.
     uint64_t mCurrentFrame = 0;

filament/backend/src/vulkan/VulkanTexture.cpp

@@ -602,15 +602,16 @@ void VulkanTexture::updateImageWithBlit(const PixelBufferDescriptor& data, uint3
     size_t const writeSize = bpp > 0 ? width * height * depth * bpp : data.size;
 
     void* mapped = nullptr;
-    VulkanStageImage const* stage
+    fvkmemory::resource_ptr<VulkanStageImage::Resource> stage
             = mState->mStagePool.acquireImage(data.format, data.type, width, height);
-    vmaMapMemory(mState->mAllocator, stage->memory, &mapped);
+    vmaMapMemory(mState->mAllocator, stage->memory(), &mapped);
     adjustedMemcpy(mapped, data, width, height, depth);
-    vmaUnmapMemory(mState->mAllocator, stage->memory);
-    vmaFlushAllocation(mState->mAllocator, stage->memory, 0, writeSize);
+    vmaUnmapMemory(mState->mAllocator, stage->memory());
+    vmaFlushAllocation(mState->mAllocator, stage->memory(), 0, writeSize);
 
     VulkanCommandBuffer& commands = mState->mCommands->get();
     VkCommandBuffer const cmdbuf = commands.buffer();
+    commands.acquire(stage);
     commands.acquire(fvkmemory::resource_ptr<VulkanTexture>::cast(this));
 
     // TODO: support blit-based format conversion for 3D images and cubemaps.
@@ -633,7 +634,7 @@ void VulkanTexture::updateImageWithBlit(const PixelBufferDescriptor& data, uint3
     VulkanLayout const oldLayout = getLayout(layer, miplevel);
     transitionLayout(&commands, range, newLayout);
 
-    vkCmdBlitImage(cmdbuf, stage->image, fvkutils::getVkLayout(VulkanLayout::TRANSFER_SRC),
+    vkCmdBlitImage(cmdbuf, stage->image(), fvkutils::getVkLayout(VulkanLayout::TRANSFER_SRC),
             mState->mTextureImage, fvkutils::getVkLayout(newLayout), 1, blitRegions, VK_FILTER_NEAREST);
 
     transitionLayout(&commands, range, oldLayout);

filament/backend/src/vulkan/memory/Resource.cpp

@@ -27,6 +27,7 @@ template ResourceType getTypeEnum<VulkanProgram>() noexcept;
 template ResourceType getTypeEnum<VulkanRenderTarget>() noexcept;
 template ResourceType getTypeEnum<VulkanSwapChain>() noexcept;
 template ResourceType getTypeEnum<VulkanStage::Segment>() noexcept;
+template ResourceType getTypeEnum<VulkanStageImage::Resource>() noexcept;
 template ResourceType getTypeEnum<VulkanRenderPrimitive>() noexcept;
 template ResourceType getTypeEnum<VulkanTexture>() noexcept;
 template ResourceType getTypeEnum<VulkanTextureState>() noexcept;
@@ -58,6 +59,9 @@ ResourceType getTypeEnum() noexcept {
     if constexpr (std::is_same_v<D, VulkanStage::Segment>) {
         return ResourceType::STAGE_SEGMENT;
     }
+    if constexpr (std::is_same_v<D, VulkanStageImage::Resource>) {
+        return ResourceType::STAGE_IMAGE;
+    }
     if constexpr (std::is_same_v<D, VulkanRenderPrimitive>) {
         return ResourceType::RENDER_PRIMITIVE;
     }
@@ -105,6 +109,8 @@ std::string getTypeStr(ResourceType type) {
             return "SwapChain";
         case ResourceType::STAGE_SEGMENT:
             return "Stage::Segment";
+        case ResourceType::STAGE_IMAGE:
+            return "Stage::Image";
         case ResourceType::RENDER_PRIMITIVE:
             return "RenderPrimitive";
         case ResourceType::TEXTURE:

filament/backend/src/vulkan/memory/Resource.h

@@ -51,7 +51,8 @@ enum class ResourceType : uint8_t {
     FENCE = 13,
     VULKAN_BUFFER = 14,
     STAGE_SEGMENT = 15,
-    UNDEFINED_TYPE = 16,    // Must be the last enum because we use it for iterating over the enums.
+    STAGE_IMAGE = 16,
+    UNDEFINED_TYPE = 17,    // Must be the last enum because we use it for iterating over the enums.
 };
 
 template<typename D>

filament/backend/src/vulkan/memory/ResourceManager.cpp

@@ -81,6 +81,9 @@ void ResourceManager::destroyWithType(ResourceType type, HandleId id) {
         case ResourceType::STAGE_SEGMENT:
             destruct<VulkanStage::Segment>(Handle<VulkanStage::Segment>(id));
             break;
+        case ResourceType::STAGE_IMAGE:
+            destruct<VulkanStageImage::Resource>(Handle<VulkanStageImage::Resource>(id));
+            break;
         case ResourceType::RENDER_PRIMITIVE:
             destruct<VulkanRenderPrimitive>(Handle<VulkanRenderPrimitive>(id));
             break;

filament/backend/src/webgpu/WebGPUDriver.cpp

@@ -457,8 +457,13 @@ void WebGPUDriver::createRenderTargetR(Handle<HwRenderTarget> renderTargetHandle
         const TargetBufferFlags targetFlags, const uint32_t width, const uint32_t height,
         const uint8_t samples, const uint8_t layerCount, const MRT color,
         const TargetBufferInfo depth, const TargetBufferInfo stencil) {
-    constructHandle<WebGPURenderTarget>(renderTargetHandle, width, height, samples, layerCount,
-            color, depth, stencil, targetFlags);
+    constructHandle<WebGPURenderTarget>(
+            renderTargetHandle, width, height, samples, layerCount, color, depth, stencil,
+            targetFlags,
+            [&](const Handle<HwTexture> textureHandle) {
+                return handleCast<WebGPUTexture>(textureHandle);
+            },
+            mDevice);
 }
 
 void WebGPUDriver::createFenceR(Handle<HwFence> fenceHandle, const int /* dummy */) {
@@ -586,7 +591,7 @@ bool WebGPUDriver::isParallelShaderCompileSupported() {
 }
 
 bool WebGPUDriver::isDepthStencilResolveSupported() {
-    return true;
+    return false;
 }
 
 bool WebGPUDriver::isDepthStencilBlitSupported(const TextureFormat format) {
@@ -819,10 +824,15 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,
     wgpu::TextureView defaultDepthStencilView = nullptr;
     wgpu::TextureFormat defaultDepthStencilFormat = wgpu::TextureFormat::Undefined;
 
+    const bool msaaSidecarsRequired{ renderTarget->getSamples() > 1 &&
+                                     renderTarget->getSampleCountPerAttachment() <= 1 };
+
     std::array<wgpu::TextureView, MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT> customColorViews{};
+    std::array<wgpu::TextureView, customColorViews.size()> customColorMsaaSidecarViews{};
     uint32_t customColorViewCount = 0;
 
     wgpu::TextureView customDepthStencilView = nullptr;
+    wgpu::TextureView customDepthStencilMsaaSidecarTextureView = nullptr;
     wgpu::TextureFormat customDepthStencilFormat = wgpu::TextureFormat::Undefined;
 
     mCurrentRenderTarget = renderTarget;
@@ -833,21 +843,17 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,
         defaultDepthStencilFormat = mSwapChain->getDepthFormat();
 
         if (any(renderTarget->getTargetFlags() & TargetBufferFlags::STENCIL) &&
-            !(defaultDepthStencilFormat == wgpu::TextureFormat::Depth24PlusStencil8 ||
-              defaultDepthStencilFormat == wgpu::TextureFormat::Depth32FloatStencil8 ||
-              defaultDepthStencilFormat == wgpu::TextureFormat::Stencil8)) {
-            FILAMENT_CHECK_POSTCONDITION(false) << "Default render target requested stencil, but swap chain's depth format "
-                                                << (uint32_t)defaultDepthStencilFormat << " does not have a stencil aspect.";
+                !(hasStencil(defaultDepthStencilFormat))) {
+            FILAMENT_CHECK_POSTCONDITION(false)
+                    << "Default render target requested stencil, but swap chain's depth format "
+                    << (uint32_t) defaultDepthStencilFormat << " does not have a stencil aspect.";
         }
 
         if (any(renderTarget->getTargetFlags() & TargetBufferFlags::DEPTH) &&
-            !(defaultDepthStencilFormat == wgpu::TextureFormat::Depth16Unorm ||
-              defaultDepthStencilFormat == wgpu::TextureFormat::Depth32Float ||
-              defaultDepthStencilFormat == wgpu::TextureFormat::Depth24Plus ||
-              defaultDepthStencilFormat == wgpu::TextureFormat::Depth24PlusStencil8 ||
-              defaultDepthStencilFormat == wgpu::TextureFormat::Depth32FloatStencil8)) {
-            FILAMENT_CHECK_POSTCONDITION(false) << "Default render target requested depth, but swap chain's depth format "
-                                                << (uint32_t)defaultDepthStencilFormat << " does not have a depth aspect.";
+                !(hasDepth(defaultDepthStencilFormat))) {
+            FILAMENT_CHECK_POSTCONDITION(false)
+                    << "Default render target requested depth, but swap chain's depth format "
+                    << (uint32_t) defaultDepthStencilFormat << " does not have a depth aspect.";
         }
     } else {
         // Resolve views for custom render target
@@ -863,8 +869,19 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,
                             << ".";
                     const uint8_t mipLevel = colorInfos[i].level;
                     const uint32_t arrayLayer = colorInfos[i].layer;
-                    customColorViews[customColorViewCount++] =
+                    customColorViews[customColorViewCount] =
                             colorTexture->getOrMakeTextureView(mipLevel, arrayLayer);
+                    if (msaaSidecarsRequired) {
+                        const wgpu::TextureView msaaSidecarView{
+                            colorTexture->makeMsaaSidecarTextureViewIfTextureSidecarExists(
+                                    renderTarget->getSamples(), mipLevel, arrayLayer)
+                        };
+                        FILAMENT_CHECK_POSTCONDITION(msaaSidecarView)
+                                << "Could not get a required MSAA sidecar texture view for color "
+                                << customColorViewCount << "?";
+                        customColorMsaaSidecarViews[customColorViewCount] = msaaSidecarView;
+                    }
+                    customColorViewCount++;
                 }
             }
         }
@@ -896,15 +913,21 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,
         if (depthStencilSourceHandle) {
             auto dsTexture = handleCast<WebGPUTexture>(depthStencilSourceHandle);
             if (dsTexture) {
-                customDepthStencilView = dsTexture->getOrMakeTextureView(depthStencilMipLevel, depthStencilArrayLayer);
+                customDepthStencilView = dsTexture->getOrMakeTextureView(depthStencilMipLevel,
+                        depthStencilArrayLayer);
+                if (msaaSidecarsRequired) {
+                    customDepthStencilMsaaSidecarTextureView =
+                            dsTexture->makeMsaaSidecarTextureViewIfTextureSidecarExists(
+                                    renderTarget->getSamples(), depthStencilMipLevel,
+                                    depthStencilArrayLayer);
+                    FILAMENT_CHECK_POSTCONDITION(customDepthStencilMsaaSidecarTextureView)
+                            << "Could not get a required MSAA sidecar texture view for "
+                               "depth/stencil?";
+                }
                 customDepthStencilFormat = dsTexture->getViewFormat();
 
                 if (any(renderTarget->getTargetFlags() & TargetBufferFlags::STENCIL) &&
-                        !(customDepthStencilFormat == wgpu::TextureFormat::Depth24PlusStencil8 ||
-                                customDepthStencilFormat ==
-                                        wgpu::TextureFormat::Depth32FloatStencil8 ||
-                                customDepthStencilFormat ==
-                                        wgpu::TextureFormat::Stencil8)) {
+                        !(hasStencil(customDepthStencilFormat))) {
                     FILAMENT_CHECK_POSTCONDITION(false)
                             << "Custom render target requested stencil, but the provided texture"
                                "format number"
@@ -912,14 +935,7 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,
                             << " does not have a stencil aspect.";
                 }
                 if (any(renderTarget->getTargetFlags() & TargetBufferFlags::DEPTH) &&
-                        !(customDepthStencilFormat == wgpu::TextureFormat::Depth16Unorm ||
-                                customDepthStencilFormat == wgpu::TextureFormat::Depth32Float ||
-                                customDepthStencilFormat ==
-                                        wgpu::TextureFormat::Depth24Plus ||
-                                customDepthStencilFormat ==
-                                        wgpu::TextureFormat::Depth24PlusStencil8 ||
-                                customDepthStencilFormat ==
-                                        wgpu::TextureFormat::Depth32FloatStencil8)) {
+                        !(hasDepth(customDepthStencilFormat))) {
                     FILAMENT_CHECK_POSTCONDITION(false) << "Custom render target requested depth, "
                                                            "but the provided texture format number"
                                                         << (uint32_t) customDepthStencilFormat
@@ -934,8 +950,10 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,
             defaultColorView,
             defaultDepthStencilView,
             customColorViews.data(),
+            customColorMsaaSidecarViews.data(),
             customColorViewCount,
-            customDepthStencilView);
+            customDepthStencilView,
+            customDepthStencilMsaaSidecarTextureView);
 
     mRenderPassEncoder = mCommandEncoder.BeginRenderPass(&renderPassDescriptor);
 
@@ -976,13 +994,13 @@ void WebGPUDriver::makeCurrent(Handle<HwSwapChain> drawSch, Handle<HwSwapChain>
     wgpu::TextureFormat depthFormat = mSwapChain->getDepthFormat();
     TargetBufferFlags newTargetFlags = filament::backend::TargetBufferFlags::NONE;
 
-    //Assuming Color and Depth are always present.
+    //Assuming Color always present in default render target.
     newTargetFlags |= filament::backend::TargetBufferFlags::COLOR;
     if (depthFormat != wgpu::TextureFormat::Undefined) {
-        newTargetFlags |= filament::backend::TargetBufferFlags::DEPTH;
-
-        if (depthFormat == wgpu::TextureFormat::Depth24PlusStencil8 ||
-                depthFormat == wgpu::TextureFormat::Depth32FloatStencil8) {
+        if (hasDepth(depthFormat)) {
+            newTargetFlags |= filament::backend::TargetBufferFlags::DEPTH;
+        }
+        if (hasStencil(depthFormat)) {
             newTargetFlags |= filament::backend::TargetBufferFlags::STENCIL;
         }
     }
@@ -1069,102 +1087,33 @@ void WebGPUDriver::blitDEPRECATED(TargetBufferFlags buffers,
 void WebGPUDriver::resolve(Handle<HwTexture> destinationTextureHandle, const uint8_t sourceLevel,
         const uint8_t sourceLayer, Handle<HwTexture> sourceTextureHandle,
         const uint8_t destinationLevel, const uint8_t destinationLayer) {
-
     FILAMENT_CHECK_PRECONDITION(mCommandEncoder)
             << "Resolve assumes there is a valid command encoder to piggyback on.";
     FILAMENT_CHECK_PRECONDITION(mRenderPassEncoder == nullptr)
             << "Resolve cannot be called during an existing render pass";
-
     const auto sourceTexture{ handleCast<WebGPUTexture>(sourceTextureHandle) };
     const auto destinationTexture{ handleCast<WebGPUTexture>(destinationTextureHandle) };
-
     assert_invariant(sourceTexture);
     assert_invariant(destinationTexture);
-
-    FILAMENT_CHECK_PRECONDITION(destinationTexture->width == sourceTexture->width &&
-                                destinationTexture->height == sourceTexture->height)
-            << "invalid resolve: source and destination sizes don't match";
-
-    FILAMENT_CHECK_PRECONDITION(sourceTexture->samples > 1 && destinationTexture->samples == 1)
-            << "invalid resolve: source.samples=" << +sourceTexture->samples
-            << ", destination.samples=" << +destinationTexture->samples;
-
-    FILAMENT_CHECK_PRECONDITION(sourceTexture->format == destinationTexture->format)
-            << "source and destination texture format don't match";
-
-    FILAMENT_CHECK_PRECONDITION(!isDepthFormat(sourceTexture->format))
-            << "can't resolve depth formats";
-
-    FILAMENT_CHECK_PRECONDITION(!isStencilFormat(sourceTexture->format))
-            << "can't resolve stencil formats";
-
-    FILAMENT_CHECK_PRECONDITION(any(destinationTexture->usage & TextureUsage::BLIT_DST))
-            << "destination texture doesn't have BLIT_DST";
-
-    FILAMENT_CHECK_PRECONDITION(any(sourceTexture->usage & TextureUsage::BLIT_SRC))
-            << "source texture doesn't have BLIT_SRC";
-
-    FILAMENT_CHECK_PRECONDITION(sourceTexture->getTexture().GetUsage() & wgpu::TextureUsage::RenderAttachment)
-            << "source texture usage doesn't have wgpu::TextureUsage::RenderAttachment";
-
-    FILAMENT_CHECK_PRECONDITION(destinationTexture->getTexture().GetUsage() & wgpu::TextureUsage::RenderAttachment)
-            << "destination texture usage doesn't have wgpu::TextureUsage::RenderAttachment";
-
-    FILAMENT_CHECK_PRECONDITION(destinationTexture->getTexture().GetUsage() & wgpu::TextureUsage::TextureBinding)
-            << "destination texture usage doesn't have wgpu::TextureUsage::TextureBinding";
-
-    const wgpu::TextureFormat format{ sourceTexture->getViewFormat() };
-    const wgpu::TextureViewDescriptor sourceTextureViewDescriptor{
-        .label = "resolve_source_texture_view",
-        .format = format,
-        .dimension = sourceTexture->getViewDimension(),
-        .baseMipLevel = sourceLevel,
-        .mipLevelCount = 1,
-        .baseArrayLayer = sourceLayer,
-        .arrayLayerCount = 1,
-        .aspect = sourceTexture->getAspect(),
-        .usage = sourceTexture->getTexture().GetUsage(),
+    const WebGPUMsaaTextureResolver::ResolveRequest request{
+        .commandEncoder = mCommandEncoder,
+        .viewFormat = sourceTexture->getViewFormat(),
+        .source = {
+            .texture = sourceTexture->getTexture(),
+            .viewDimension = sourceTexture->getViewDimension(),
+            .mipLevel = sourceLevel,
+            .layer = sourceLayer,
+            .aspect = sourceTexture->getAspect(),
+        },
+        .destination = {
+            .texture = destinationTexture->getTexture(),
+            .viewDimension = destinationTexture->getViewDimension(),
+            .mipLevel = destinationLevel,
+            .layer = destinationLayer,
+            .aspect = destinationTexture->getAspect(),
+        },
     };
-    const wgpu::TextureView sourceTextureView{ sourceTexture->getTexture().CreateView(
-            &sourceTextureViewDescriptor) };
-    FILAMENT_CHECK_POSTCONDITION(sourceTextureView) << "Failed to create wgpu::TextureView sourceTextureView";
-    const wgpu::TextureViewDescriptor destinationTextureViewDescriptor{
-        .label = "resolve_destination_texture_view",
-        .format = format,
-        .dimension = destinationTexture->getViewDimension(),
-        .baseMipLevel = destinationLevel,
-        .mipLevelCount = 1,
-        .baseArrayLayer = destinationLayer,
-        .arrayLayerCount = 1,
-        .aspect = destinationTexture->getAspect(),
-        .usage = destinationTexture->getTexture().GetUsage(),
-    };
-
-    const wgpu::TextureView destinationTextureView{ destinationTexture->getTexture().CreateView(
-            &destinationTextureViewDescriptor) };
-    FILAMENT_CHECK_POSTCONDITION(destinationTextureView) << "Failed to create wgpu::TextureView destinationTextureView.";
-    const wgpu::RenderPassColorAttachment colorAttachment{
-        .view = sourceTextureView,
-        .depthSlice = wgpu::kDepthSliceUndefined, // being explicit for consistent behavior
-        .resolveTarget = destinationTextureView,
-        .loadOp = wgpu::LoadOp::Load,
-        .storeOp = wgpu::StoreOp::Store,
-        .clearValue = {}, // being explicit for consistent behavior
-    };
-    const wgpu::RenderPassDescriptor renderPassDescriptor{
-        .label = "resolve_render_pass",
-        .colorAttachmentCount = 1,
-        .colorAttachments = &colorAttachment,
-        .depthStencilAttachment = nullptr, // being explicit for consistent behavior
-        .occlusionQuerySet = nullptr,      // being explicit for consistent behavior
-        .timestampWrites = nullptr,        // being explicit for consistent behavior
-    };
-
-    const wgpu::RenderPassEncoder renderPassEncoder{ mCommandEncoder.BeginRenderPass(
-            &renderPassDescriptor) };
-    FILAMENT_CHECK_POSTCONDITION(renderPassEncoder)
-            << "Failed to create wgpu::RenderPassEncoder for WebGPUDriver::resolve";
-    renderPassEncoder.End(); // only the implicit resolve is happening in the pass
+    mMsaaTextureResolver.resolve(request);
 }
 
 void WebGPUDriver::blit(Handle<HwTexture> destinationTextureHandle, const uint8_t sourceLevel,
@@ -1266,12 +1215,6 @@ void WebGPUDriver::bindPipeline(PipelineState const& pipelineState) {
         }
     }
 
-    // TODO: We expected this to be a sane check, however it complains when running shadowtest.
-    //if (program->fragmentShaderModule != nullptr) {
-    //    FILAMENT_CHECK_POSTCONDITION(!pipelineColorFormats.empty())
-    //            << "Render pipeline with fragment shader must have at least one color target "
-    //               "format.";
-    //}
     wgpu::RenderPipeline pipeline = createWebGPURenderPipeline(mDevice, *program, *vertexBufferInfo,
             layout, pipelineState.rasterState, pipelineState.stencilState,
             pipelineState.polygonOffset, pipelineState.primitiveType, pipelineColorFormats,

filament/backend/src/webgpu/WebGPUDriver.h

@@ -19,6 +19,7 @@
 
 #include "WebGPURenderTarget.h"
 #include "webgpu/WebGPUConstants.h"
+#include "webgpu/WebGPUMsaaTextureResolver.h"
 #include "webgpu/WebGPURenderPassMipmapGenerator.h"
 #include <backend/platforms/WebGPUPlatform.h>
 
@@ -56,7 +57,7 @@ public:
     [[nodiscard]] static Driver* create(WebGPUPlatform& platform, const Platform::DriverConfig& driverConfig) noexcept;
 
 private:
-    explicit WebGPUDriver(WebGPUPlatform& platform, const Platform::DriverConfig& driverConfig) noexcept;
+    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);
@@ -80,6 +81,7 @@ private:
     WebGPURenderTarget* mCurrentRenderTarget = nullptr;
     WebGPURenderPassMipmapGenerator mRenderPassMipmapGenerator;
     spd::MipmapGenerator mSpdComputePassMipmapGenerator;
+    WebGPUMsaaTextureResolver mMsaaTextureResolver{};
 
     tsl::robin_map<size_t, wgpu::RenderPipeline> mPipelineMap;
 

filament/backend/src/webgpu/WebGPUMsaaTextureResolver.cpp

@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+
+#include "WebGPUMsaaTextureResolver.h"
+
+#include "WebGPUTexture.h"
+
+#include <utils/Panic.h>
+
+#include <webgpu/webgpu_cpp.h>
+
+namespace filament::backend {
+
+namespace {
+
+void resolveColorTextures(wgpu::CommandEncoder const& commandEncoder,
+        wgpu::TextureView const& sourceTextureView,
+        wgpu::TextureView const& destinationTextureView) {
+    const wgpu::RenderPassColorAttachment colorAttachment{
+        .view = sourceTextureView,
+        .depthSlice = wgpu::kDepthSliceUndefined, // being explicit for consistent behavior
+        .resolveTarget = destinationTextureView,
+        .loadOp = wgpu::LoadOp::Load,
+        .storeOp = wgpu::StoreOp::Store,
+        .clearValue = {}, // being explicit for consistent behavior
+    };
+    const wgpu::RenderPassDescriptor renderPassDescriptor{
+        .label = "resolve_render_pass",
+        .colorAttachmentCount = 1,
+        .colorAttachments = &colorAttachment,
+        .depthStencilAttachment = nullptr, // being explicit for consistent behavior
+        .occlusionQuerySet = nullptr,      // being explicit for consistent behavior
+        .timestampWrites = nullptr,        // being explicit for consistent behavior
+    };
+    const wgpu::RenderPassEncoder renderPassEncoder{ commandEncoder.BeginRenderPass(
+            &renderPassDescriptor) };
+    FILAMENT_CHECK_POSTCONDITION(renderPassEncoder)
+            << "Failed to create wgpu::RenderPassEncoder for WebGPUDriver::resolve";
+    renderPassEncoder.End(); // only the implicit resolve is happening in the pass
+}
+
+} // namespace
+
+void WebGPUMsaaTextureResolver::resolve(ResolveRequest const& request) {
+    ResolveRequest::TextureInfo const& source{ request.source };
+    ResolveRequest::TextureInfo const& destination{ request.destination };
+    FILAMENT_CHECK_PRECONDITION(destination.texture.GetWidth() == source.texture.GetWidth() &&
+                                destination.texture.GetHeight() == source.texture.GetHeight())
+            << "invalid resolve: source and destination sizes don't match";
+
+    FILAMENT_CHECK_PRECONDITION(
+            source.texture.GetSampleCount() > 1 && destination.texture.GetSampleCount() == 1)
+            << "invalid resolve: source.samples=" << source.texture.GetSampleCount()
+            << ", destination.samples=" << destination.texture.GetSampleCount();
+
+    FILAMENT_CHECK_PRECONDITION(source.texture.GetFormat() == destination.texture.GetFormat())
+            << "source and destination texture format don't match";
+    const wgpu::TextureFormat format{ source.texture.GetFormat() };
+
+    FILAMENT_CHECK_PRECONDITION(!hasDepth(format)) << "can't resolve depth formats";
+
+    FILAMENT_CHECK_PRECONDITION(!hasStencil(format)) << "can't resolve stencil formats";
+
+    FILAMENT_CHECK_PRECONDITION(source.texture.GetUsage() & wgpu::TextureUsage::RenderAttachment)
+            << "source texture usage doesn't have wgpu::TextureUsage::RenderAttachment";
+
+    FILAMENT_CHECK_PRECONDITION(
+            destination.texture.GetUsage() & wgpu::TextureUsage::RenderAttachment)
+            << "destination texture usage doesn't have wgpu::TextureUsage::RenderAttachment";
+
+    FILAMENT_CHECK_PRECONDITION(destination.texture.GetUsage() & wgpu::TextureUsage::TextureBinding)
+            << "destination texture usage doesn't have wgpu::TextureUsage::TextureBinding";
+
+    const wgpu::TextureViewDescriptor sourceTextureViewDescriptor{
+        .label = "resolve_source_texture_view",
+        .format = request.viewFormat,
+        .dimension = source.viewDimension,
+        .baseMipLevel = source.mipLevel,
+        .mipLevelCount = 1,
+        .baseArrayLayer = source.layer,
+        .arrayLayerCount = 1,
+        .aspect = source.aspect,
+        .usage = source.texture.GetUsage(),
+    };
+    const wgpu::TextureView sourceTextureView{ source.texture.CreateView(
+            &sourceTextureViewDescriptor) };
+    FILAMENT_CHECK_POSTCONDITION(sourceTextureView)
+            << "Failed to create wgpu::TextureView sourceTextureView";
+    const wgpu::TextureViewDescriptor destinationTextureViewDescriptor{
+        .label = "resolve_destination_texture_view",
+        .format = request.viewFormat,
+        .dimension = destination.viewDimension,
+        .baseMipLevel = destination.mipLevel,
+        .mipLevelCount = 1,
+        .baseArrayLayer = destination.layer,
+        .arrayLayerCount = 1,
+        .aspect = destination.aspect,
+        .usage = destination.texture.GetUsage(),
+    };
+    const wgpu::TextureView destinationTextureView{ destination.texture.CreateView(
+            &destinationTextureViewDescriptor) };
+    FILAMENT_CHECK_POSTCONDITION(destinationTextureView)
+            << "Failed to create wgpu::TextureView destinationTextureView.";
+
+    if (hasDepth(format)) {
+        PANIC_PRECONDITION("DEPTH RESOLVE NOT IMPLEMENTED YET");
+    } else {
+        resolveColorTextures(request.commandEncoder, sourceTextureView, destinationTextureView);
+    }
+}
+
+} // namespace filament::backend

filament/backend/src/webgpu/WebGPUMsaaTextureResolver.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 TNT_FILAMENT_BACKEND_WEBGPUMSAATEXTURERESOLVER_H
+#define TNT_FILAMENT_BACKEND_WEBGPUMSAATEXTURERESOLVER_H
+
+#include <cstdint>
+
+namespace wgpu {
+class CommandEncoder;
+class Texture;
+enum class TextureAspect : uint32_t;
+enum class TextureFormat : uint32_t;
+enum class TextureViewDimension : uint32_t;
+} // namespace wgpu
+
+namespace filament::backend {
+
+class WebGPUTexture;
+
+class WebGPUMsaaTextureResolver final {
+public:
+    struct ResolveRequest final {
+        struct TextureInfo final {
+            wgpu::Texture const& texture;
+            wgpu::TextureViewDimension viewDimension;
+            uint8_t mipLevel;
+            uint8_t layer;
+            wgpu::TextureAspect aspect;
+        };
+        wgpu::CommandEncoder const& commandEncoder;
+        wgpu::TextureFormat viewFormat;
+        TextureInfo source;
+        TextureInfo destination;
+    };
+
+    void resolve(ResolveRequest const&);
+};
+
+} // namespace filament::backend
+
+#endif // TNT_FILAMENT_BACKEND_WEBGPUMSAATEXTURERESOLVER_H

filament/backend/src/webgpu/WebGPUPipelineCreation.cpp

@@ -281,27 +281,32 @@ wgpu::RenderPipeline createWebGPURenderPipeline(wgpu::Device const& device,
         }
     };
     if (program.fragmentShaderModule != nullptr) {
-        fragmentState.module = program.fragmentShaderModule;
-        fragmentState.entryPoint = "main";
-        // see the comment about constants for the vertex state, as the same reasoning applies
-        // here
-        fragmentState.constantCount = 0,
-        fragmentState.constants = nullptr,
-        fragmentState.targetCount = colorFormats.size();
-        fragmentState.targets = colorTargets.data();
-        assert_invariant(fragmentState.targetCount <= MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT);
-        // We expect a fragment shader implies at least one color target if it outputs color.
-        // This should be guaranteed by the caller ensuring colorFormats is not empty.
-        // However, this fails on shadowtest.cpp, TODO investigate why
-        // assert_invariant(fragmentState.targetCount > 0);
-        for (size_t targetIndex = 0; targetIndex < fragmentState.targetCount; targetIndex++) {
-            auto& colorTarget = colorTargets[targetIndex];
-            colorTarget.format = colorFormats[targetIndex];
-            colorTarget.blend = rasterState.hasBlending() ? &blendState : nullptr;
-            colorTarget.writeMask =
-                    rasterState.colorWrite ? wgpu::ColorWriteMask::All : wgpu::ColorWriteMask::None;
+        // According to the WebGPU spec, a pipeline cannot have a fragment stage with zero color
+        // targets. This situation can arise in Filament during depth-only passes (like shadow map
+        // generation) if the material variant still includes a fragment shader.
+        //
+        // To handle this, we check if any color targets are configured for this pipeline. If not, we
+        // create a pipeline *without* a fragment stage. This makes the pipeline valid for a
+        // depth-only pass, allowing depth writes to proceed correctly.
+        if (!colorFormats.empty()) {
+            fragmentState.module = program.fragmentShaderModule;
+            fragmentState.entryPoint = "main";
+            // see the comment about constants for the vertex state, as the same reasoning applies
+            // here
+            fragmentState.constantCount = 0,
+            fragmentState.constants = nullptr,
+            fragmentState.targetCount = colorFormats.size();
+            fragmentState.targets = colorTargets.data();
+            assert_invariant(fragmentState.targetCount <= MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT);
+            for (size_t targetIndex = 0; targetIndex < fragmentState.targetCount; targetIndex++) {
+                auto& colorTarget = colorTargets[targetIndex];
+                colorTarget.format = colorFormats[targetIndex];
+                colorTarget.blend = rasterState.hasBlending() ? &blendState : nullptr;
+                colorTarget.writeMask =
+                        rasterState.colorWrite ? wgpu::ColorWriteMask::All : wgpu::ColorWriteMask::None;
+            }
+            pipelineDescriptor.fragment = &fragmentState;
         }
-        pipelineDescriptor.fragment = &fragmentState;
     }
     const wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pipelineDescriptor);
     FILAMENT_CHECK_POSTCONDITION(pipeline)

filament/backend/src/webgpu/WebGPURenderTarget.cpp

@@ -16,7 +16,11 @@
 
 #include "WebGPURenderTarget.h"
 
+#include "WebGPUTexture.h"
+
+#include "DriverBase.h"
 #include <backend/DriverEnums.h>
+#include <backend/Handle.h>
 #include <backend/TargetBufferInfo.h>
 
 #include <private/backend/BackendUtils.h>
@@ -26,14 +30,97 @@
 
 #include <webgpu/webgpu_cpp.h>
 
+#include <algorithm>
+#include <array>
 #include <cstdint>
+#include <functional>
+#include <string_view>
 
 namespace filament::backend {
 
+namespace {
+
+/**
+ * Panics if the number of samples in the original attachment textures do not match.
+ * @return The number of samples in the original attachment textures (the number/count in each one).
+ *         Returns 0 if there are no attachments.
+ */
+[[nodiscard]] uint8_t createMsaaSidecarTextures(const uint8_t renderTargetSampleCount,
+        const TargetBufferFlags targetFlags, MRT const& colorAttachments,
+        TargetBufferInfo const& depthAttachment, TargetBufferInfo const& stencilAttachment,
+        std::function<WebGPUTexture*(const Handle<HwTexture>)> const& getWebGPUTexture,
+        wgpu::Device const& device) {
+    struct Target final {
+        std::string_view name;
+        TargetBufferFlags flag{ TargetBufferFlags::NONE };
+        size_t colorIndex{ 0 };
+    };
+    // assuming 8 colors. hopefully the following static_assert will get tripped if another
+    // color ever gets added
+    static_assert(
+            (TargetBufferFlags::COLOR0 | TargetBufferFlags::COLOR1 | TargetBufferFlags::COLOR2 |
+                    TargetBufferFlags::COLOR3 | TargetBufferFlags::COLOR4 |
+                    TargetBufferFlags::COLOR5 | TargetBufferFlags::COLOR6 |
+                    TargetBufferFlags::COLOR7) == TargetBufferFlags::COLOR_ALL);
+    const static std::array TARGETS{
+        Target{ .name = "COLOR0", .flag = TargetBufferFlags::COLOR0, .colorIndex = 0 },
+        Target{ .name = "COLOR1", .flag = TargetBufferFlags::COLOR1, .colorIndex = 1 },
+        Target{ .name = "COLOR2", .flag = TargetBufferFlags::COLOR2, .colorIndex = 2 },
+        Target{ .name = "COLOR3", .flag = TargetBufferFlags::COLOR3, .colorIndex = 3 },
+        Target{ .name = "COLOR4", .flag = TargetBufferFlags::COLOR4, .colorIndex = 4 },
+        Target{ .name = "COLOR5", .flag = TargetBufferFlags::COLOR5, .colorIndex = 5 },
+        Target{ .name = "COLOR6", .flag = TargetBufferFlags::COLOR6, .colorIndex = 6 },
+        Target{ .name = "COLOR7", .flag = TargetBufferFlags::COLOR7, .colorIndex = 7 },
+        Target{ .name = "DEPTH", .flag = TargetBufferFlags::DEPTH },
+        Target{ .name = "STENCIL", .flag = TargetBufferFlags::STENCIL },
+    };
+#ifndef NDEBUG
+    for (auto const& target: TARGETS) {
+        assert_invariant(target.colorIndex <= MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT &&
+                         "color index is >= MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT, which should "
+                         "not be possible and could lead to us indexing into the colorAttachments "
+                         "array beyond its bounds.");
+    }
+#endif
+    bool firstAttachment{ true };
+    uint8_t sampleCountPerAttachment{ 0 };
+    for (auto const& target: TARGETS) {
+        if (any(targetFlags & target.flag)) {
+            const Handle<HwTexture> textureHandle{
+                target.flag == TargetBufferFlags::DEPTH
+                        ? depthAttachment.handle
+                        : (target.flag == TargetBufferFlags::STENCIL
+                                          ? stencilAttachment.handle
+                                          : colorAttachments[target.colorIndex].handle)
+            };
+            WebGPUTexture* const texture{ getWebGPUTexture(textureHandle) };
+            assert_invariant(texture != nullptr && "target flag indicate the use of an attachment "
+                                                   "for which we do not have a texture?");
+            if (firstAttachment) {
+                sampleCountPerAttachment = texture->samples;
+                firstAttachment = false;
+            }
+            FILAMENT_CHECK_PRECONDITION(texture->samples == sampleCountPerAttachment)
+                    << target.name << " attachment texture has " << +texture->samples
+                    << " but the other attachment(s) have " << +sampleCountPerAttachment;
+            if (renderTargetSampleCount > 1 && sampleCountPerAttachment == 1) {
+                texture->createMsaaSidecarTextureIfNotAlreadyCreated(renderTargetSampleCount,
+                        device);
+            }
+        }
+    }
+    assert_invariant(sampleCountPerAttachment);
+    return sampleCountPerAttachment;
+}
+
+}  // namespace
+
 WebGPURenderTarget::WebGPURenderTarget(const uint32_t width, const uint32_t height,
         const uint8_t samples, const uint8_t layerCount, MRT const& colorAttachmentsMRT,
         Attachment const& depthAttachmentInfo, Attachment const& stencilAttachmentInfo,
-        TargetBufferFlags const& targetFlags)
+        TargetBufferFlags const& targetFlags,
+        std::function<WebGPUTexture*(const Handle<HwTexture>)> const& getWebGPUTexture,
+        wgpu::Device const& device)
     : HwRenderTarget{ width, height },
       mDefaultRenderTarget{ false },
       mTargetFlags{ targetFlags },
@@ -41,8 +128,11 @@ WebGPURenderTarget::WebGPURenderTarget(const uint32_t width, const uint32_t heig
       mLayerCount{ layerCount },
       mColorAttachments{ colorAttachmentsMRT },
       mDepthAttachment{ depthAttachmentInfo },
-      mStencilAttachment{ stencilAttachmentInfo } {
-    // TODO consider making this an array
+      mStencilAttachment{ stencilAttachmentInfo },
+      mSampleCountPerAttachment{ createMsaaSidecarTextures(mSamples, mTargetFlags,
+              mColorAttachments, mDepthAttachment, mStencilAttachment, getWebGPUTexture, device) } {
+    // TODO consider possibly making this an array (that would avoid a heap allocation, but the
+    //      concern is the size limitation on the handle itself)
     mColorAttachmentDesc.reserve(MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT);
 }
 
@@ -52,8 +142,8 @@ WebGPURenderTarget::WebGPURenderTarget()
       mDefaultRenderTarget{ true },
       mTargetFlags{ TargetBufferFlags::NONE },
       mSamples{ 1 },
-      mLayerCount{ 1 }
-     {}
+      mLayerCount{ 1 },
+      mSampleCountPerAttachment{ 1 } {}
 
 wgpu::LoadOp WebGPURenderTarget::getLoadOperation(RenderPassParams const& params,
         const TargetBufferFlags bufferToOperateOn) {
@@ -77,8 +167,35 @@ wgpu::StoreOp WebGPURenderTarget::getStoreOperation(RenderPassParams const& para
 void WebGPURenderTarget::setUpRenderPassAttachments(wgpu::RenderPassDescriptor& outDescriptor,
         RenderPassParams const& params, wgpu::TextureView const& defaultColorTextureView,
         wgpu::TextureView const& defaultDepthStencilTextureView,
-        wgpu::TextureView const* customColorTextureViews, uint32_t customColorTextureViewCount,
-        wgpu::TextureView const& customDepthStencilTextureView) {
+        wgpu::TextureView const* customColorTextureViews,
+        wgpu::TextureView const* customColorMsaaSidecarTextureViews,
+        uint32_t customColorTextureViewCount,
+        wgpu::TextureView const& customDepthStencilTextureView,
+        wgpu::TextureView const& customDepthStencilMsaaSidecarTextureView) {
+    const bool hasMsaaSidecars{ (customColorTextureViewCount > 0 &&
+                                        customColorMsaaSidecarTextureViews[0]) ||
+                                customDepthStencilMsaaSidecarTextureView };
+    // either all the textures have MSAA sidecars or none of them do
+    if (hasMsaaSidecars) {
+        FILAMENT_CHECK_PRECONDITION(std::all_of(customColorMsaaSidecarTextureViews,
+                customColorMsaaSidecarTextureViews + customColorTextureViewCount,
+                [](wgpu::TextureView const& msaaView) { return msaaView != nullptr; }))
+                << "A color or depth/stencil attachment texture has a MSAA sidecar but at least "
+                   "one other color attachment texture does not.";
+        FILAMENT_CHECK_PRECONDITION(customDepthStencilMsaaSidecarTextureView != nullptr)
+                << "The color attachment texture(s) have MSAA sidecar(s) but the depth/stencil "
+                   "texture does not.";
+    } else {
+        FILAMENT_CHECK_PRECONDITION(std::all_of(customColorMsaaSidecarTextureViews,
+                customColorMsaaSidecarTextureViews + customColorTextureViewCount,
+                [](wgpu::TextureView const& msaaView) { return msaaView == nullptr; }))
+                << "A color or depth/stencil attachment texture does not have a MSAA sidecar but "
+                   "at least one color attachment texture does.";
+        FILAMENT_CHECK_PRECONDITION(customDepthStencilMsaaSidecarTextureView == nullptr)
+                << "Custom color textures for the render target do not have MSAA sidecar(s) but "
+                   "the depth/stencil texture does.";
+    }
+
     mColorAttachmentDesc.clear();
 
     const bool hasDepth = any(mTargetFlags & TargetBufferFlags::DEPTH);
@@ -104,9 +221,10 @@ void WebGPURenderTarget::setUpRenderPassAttachments(wgpu::RenderPassDescriptor&
     } else {
         for (uint32_t i = 0; i < customColorTextureViewCount; ++i) {
             if (customColorTextureViews[i]) {
-                mColorAttachmentDesc.push_back({ .view = customColorTextureViews[i],
-                    .resolveTarget =
-                            nullptr, // We handle MSAA on the WebGPU driver's resolve function
+                const wgpu::TextureView msaaSidecar{ customColorMsaaSidecarTextureViews[i] };
+                mColorAttachmentDesc.push_back({
+                    .view = hasMsaaSidecars ? msaaSidecar : customColorTextureViews[i],
+                    .resolveTarget = hasMsaaSidecars ? customColorTextureViews[i] : nullptr,
                     .loadOp =
                             WebGPURenderTarget::getLoadOperation(params, getTargetBufferFlagsAt(i)),
                     .storeOp = WebGPURenderTarget::getStoreOperation(params,
@@ -132,7 +250,8 @@ void WebGPURenderTarget::setUpRenderPassAttachments(wgpu::RenderPassDescriptor&
             assert_invariant(depthStencilViewToUse);
         } else {
             if (customDepthStencilTextureView) {
-                depthStencilViewToUse = customDepthStencilTextureView;
+                depthStencilViewToUse = hasMsaaSidecars ? customDepthStencilMsaaSidecarTextureView
+                                                        : customDepthStencilTextureView;
             }
         }
 

filament/backend/src/webgpu/WebGPURenderTarget.h

@@ -17,6 +17,8 @@
 #ifndef TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H
 #define TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H
 
+#include "WebGPUTexture.h"
+
 #include "DriverBase.h"
 #include <backend/DriverEnums.h>
 #include <backend/TargetBufferInfo.h>
@@ -24,6 +26,7 @@
 #include <webgpu/webgpu_cpp.h>
 
 #include <cstdint>
+#include <functional>
 #include <vector>
 
 namespace filament::backend {
@@ -34,24 +37,27 @@ public:
 
     WebGPURenderTarget(uint32_t width, uint32_t height, uint8_t samples, uint8_t layerCount,
             MRT const& colorAttachments, Attachment const& depthAttachment,
-            Attachment const& stencilAttachment, TargetBufferFlags const& targetFlags);
+            Attachment const& stencilAttachment, TargetBufferFlags const& targetFlags,
+            std::function<WebGPUTexture*(const Handle<HwTexture>)> const&, wgpu::Device const&);
 
     // Default constructor for the default render target
     WebGPURenderTarget();
 
-    void setUpRenderPassAttachments(
-            wgpu::RenderPassDescriptor& outDescriptor,
+    void setUpRenderPassAttachments(wgpu::RenderPassDescriptor& outDescriptor,
             RenderPassParams const& params,
             // For default render target:
             wgpu::TextureView const& defaultColorTextureView,
             wgpu::TextureView const& defaultDepthStencilTextureView,
             // For custom render targets:
-            wgpu::TextureView const* customColorTextureViews, // Array of views
+            wgpu::TextureView const* customColorTextureViews,            // Array of views
+            wgpu::TextureView const* customColorMsaaSidecarTextureViews, // nullptrs if N/A
             uint32_t customColorTextureViewCount,
-            wgpu::TextureView const& customDepthStencilTextureView);
+            wgpu::TextureView const& customDepthStencilTextureView,
+            wgpu::TextureView const& customDepthStencilMsaaSidecarTextureView /* nullptr if N/A */);
 
     [[nodiscard]] bool isDefaultRenderTarget() const { return mDefaultRenderTarget; }
     [[nodiscard]] uint8_t getSamples() const { return mSamples; }
+    [[nodiscard]] uint8_t getSampleCountPerAttachment() const { return mSampleCountPerAttachment; }
     [[nodiscard]] uint8_t getLayerCount() const { return mLayerCount; }
 
     [[nodiscard]] MRT const& getColorAttachmentInfos() const { return mColorAttachments; }
@@ -78,6 +84,8 @@ private:
     Attachment mDepthAttachment{};
     Attachment mStencilAttachment{};
 
+    uint8_t mSampleCountPerAttachment = 0;
+
     // Cached descriptors for the render pass
     std::vector<wgpu::RenderPassColorAttachment> mColorAttachmentDesc;
     wgpu::RenderPassDepthStencilAttachment mDepthStencilAttachmentDesc{};

filament/backend/src/webgpu/WebGPUTexture.cpp

@@ -402,7 +402,21 @@ WebGPUTexture::WebGPUTexture(WebGPUTexture const* src, const uint8_t baseLevel,
       mDefaultMipLevel{ baseLevel },
       mDefaultBaseArrayLayer{ src->mArrayLayerCount },
       mDefaultTextureView{ makeTextureView(mDefaultMipLevel, levelCount, 0, mDefaultBaseArrayLayer,
-              src->target) } {}
+              src->target) },
+      mMsaaSidecarTexture{ src->mMsaaSidecarTexture } {}
+
+wgpu::Texture const& WebGPUTexture::getMsaaSidecarTexture(const uint8_t sampleCount) const {
+    if (mMsaaSidecarTexture == nullptr) {
+        return mMsaaSidecarTexture; // nullptr (no such sidecar)
+    }
+    FILAMENT_CHECK_PRECONDITION(sampleCount == mMsaaSidecarTexture.GetSampleCount())
+            << "The MSAA sidecar texture has a different sample count ("
+            << mMsaaSidecarTexture.GetSampleCount() << ") than requested (" << +sampleCount
+            << "). Note that this restriction was written when WebGPU only supported msaa "
+               "textures with 4 samples. If that has changed, this implementation should be "
+               "updated (e.g. map of sidecar textures by sampleCount or something).";
+    return mMsaaSidecarTexture;
+}
 
 bool WebGPUTexture::supportsMultipleMipLevelsViaStorageBinding(const wgpu::TextureFormat format) {
     return storageBindingCompatibleFormatForViewFormat(format) != wgpu::TextureFormat::Undefined;
@@ -417,6 +431,68 @@ wgpu::TextureView WebGPUTexture::getOrMakeTextureView(const uint8_t mipLevel,
     return makeTextureView(mipLevel, 1, arrayLayer, 1, target);
 }
 
+void WebGPUTexture::createMsaaSidecarTextureIfNotAlreadyCreated(const uint8_t samples,
+        wgpu::Device const& device) {
+    FILAMENT_CHECK_PRECONDITION(samples > 1) << "Requesting to create a MSAA sidecar texture for "
+                                             << +samples << " samples? Invalid request.";
+    if (mMsaaSidecarTexture) {
+        FILAMENT_CHECK_PRECONDITION(mMsaaSidecarTexture.GetSampleCount() == samples)
+                << "An MSAA sidecar texture has already been created for this texture, but with a "
+                   "different sample count ("
+                << mMsaaSidecarTexture.GetSampleCount() << ") than requested (" << +samples
+                << "). Note that this restriction was written when WebGPU only supported msaa "
+                   "textures with 4 samples. If that has changed, this implementation should be "
+                   "updated (e.g. map of sidecar textures by sampleCount or something).";
+        return; // we already have the sidecar created
+    }
+    const wgpu::TextureDescriptor descriptor{
+        .label = "msaa_sidecar_texture",
+        .usage = mTexture.GetUsage(),
+        .dimension = mTexture.GetDimension(),
+        .size = {
+            .width = mTexture.GetWidth(),
+            .height = mTexture.GetHeight(),
+            .depthOrArrayLayers = mTexture.GetDepthOrArrayLayers(),
+        },
+        .format = mTexture.GetFormat(),
+        .mipLevelCount = mTexture.GetMipLevelCount(),
+        .sampleCount = samples,
+        .viewFormatCount = 1,
+        .viewFormats = &mViewFormat,
+    };
+    mMsaaSidecarTexture = device.CreateTexture(&descriptor);
+    FILAMENT_CHECK_POSTCONDITION(mMsaaSidecarTexture) << "Failed to create MSAA sidecar texture";
+}
+
+wgpu::TextureView WebGPUTexture::makeMsaaSidecarTextureViewIfTextureSidecarExists(
+        const uint8_t samples, const uint8_t mipLevel, const uint32_t arrayLayer) const {
+    if (mMsaaSidecarTexture == nullptr) {
+        return nullptr;
+    }
+    FILAMENT_CHECK_PRECONDITION(mMsaaSidecarTexture.GetSampleCount() == samples)
+            << "An MSAA sidecar texture has already been created for this texture, but with a "
+               "different sample count ("
+            << mMsaaSidecarTexture.GetSampleCount() << ") than requested for view (" << +samples
+            << "). Note that this restriction was written when WebGPU only supported msaa "
+               "textures with 4 samples. If that has changed, this implementation should be "
+               "updated (e.g. map of sidecar textures by sampleCount or something).";
+    const wgpu::TextureViewDescriptor descriptor{
+        .label = "msaa_sidecar_texture_view",
+        .format = mViewFormat,
+        .dimension = mDimension,
+        .baseMipLevel = mipLevel,
+        .mipLevelCount = 1,
+        .baseArrayLayer = arrayLayer,
+        .arrayLayerCount = 1,
+        .aspect = mAspect,
+        .usage = mViewUsage,
+    };
+    const wgpu::TextureView textureView{ mMsaaSidecarTexture.CreateView(&descriptor) };
+    FILAMENT_CHECK_POSTCONDITION(mMsaaSidecarTexture)
+            << "Failed to create MSAA sidecar texture view (" << +samples << " samples)";
+    return textureView;
+}
+
 wgpu::TextureFormat WebGPUTexture::fToWGPUTextureFormat(TextureFormat const& fFormat) {
     switch (fFormat) {
         case TextureFormat::R8:                      return wgpu::TextureFormat::R8Unorm;
@@ -591,16 +667,6 @@ wgpu::TextureFormat WebGPUTexture::fToWGPUTextureFormat(TextureFormat const& fFo
 wgpu::TextureView WebGPUTexture::makeTextureView(const uint8_t& baseLevel,
         const uint8_t& levelCount, const uint32_t& baseArrayLayer, const uint32_t& arrayLayerCount,
         const SamplerType samplerType) const noexcept {
-#if FWGPU_ENABLED(FWGPU_DEBUG_VALIDATION)
-    if (baseLevel > 0 && mMipmapGenerationStrategy == MipmapGenerationStrategy::NONE) {
-        FWGPU_LOGW << "Trying to make a texture view into a level ("
-                   << static_cast<uint32_t>(baseLevel)
-                   << ") for which we cannot generate mip levels. SamplerType "
-                   << to_string(samplerType) << " WebGPU view format "
-                   << webGPUTextureFormatToString(mViewFormat) << " samples "
-                   << static_cast<uint32_t>(samples);
-    }
-#endif
     const wgpu::TextureViewDescriptor textureViewDescriptor{
         .label = getUserTextureViewLabel(target),
         .format = mViewFormat,

filament/backend/src/webgpu/WebGPUTexture.h

@@ -26,6 +26,20 @@
 
 namespace filament::backend {
 
+[[nodiscard]] constexpr bool hasStencil(const wgpu::TextureFormat textureFormat) {
+    return textureFormat == wgpu::TextureFormat::Depth24PlusStencil8 ||
+           textureFormat == wgpu::TextureFormat::Depth32FloatStencil8 ||
+           textureFormat == wgpu::TextureFormat::Stencil8;
+}
+
+[[nodiscard]] constexpr bool hasDepth(const wgpu::TextureFormat textureFormat) {
+    return textureFormat == wgpu::TextureFormat::Depth16Unorm ||
+           textureFormat == wgpu::TextureFormat::Depth32Float ||
+           textureFormat == wgpu::TextureFormat::Depth24Plus ||
+           textureFormat == wgpu::TextureFormat::Depth24PlusStencil8 ||
+           textureFormat == wgpu::TextureFormat::Depth32FloatStencil8;
+}
+
 class WebGPUTexture : public HwTexture {
 public:
     enum class MipmapGenerationStrategy : uint8_t {
@@ -47,6 +61,8 @@ public:
 
     [[nodiscard]] wgpu::Texture const& getTexture() const { return mTexture; }
 
+    [[nodiscard]] wgpu::Texture const& getMsaaSidecarTexture(uint8_t sampleCount) const;
+
     [[nodiscard]] wgpu::TextureView const& getDefaultTextureView() const {
         return mDefaultTextureView;
     }
@@ -62,6 +78,33 @@ public:
         return mMipmapGenerationStrategy;
     }
 
+    /**
+     * Creates the MSAA sidecar texture if it has not already been created.
+     * If the sidecar already exists with a different number of samples this will panic
+     * (at the time of writing this WebGPU only supports MSAA with 4 samples. If this changes, then
+     * multiple sidecars with different number of samples could be supported if needed, but that
+     * level of complexity is not warranted at this time).
+     * Additionally, if samples is <= 1 this will panic as well, as that is not an MSAA texture.
+     * @param samples The number of samples the texture will have
+     */
+    void createMsaaSidecarTextureIfNotAlreadyCreated(uint8_t samples, wgpu::Device const&);
+
+    /**
+     * @param samples The number of samples the underlying texture supports
+     * @param mipLevel The mip level into the underyling texture for which this view will reference
+     * (this view will only have one mip level)
+     * @param arrayLayer The layer into the underyling texture for which this view will reference
+     * (this view will only have one layer)
+     * @return A texture view for the MSAA sidecar texture
+     */
+    wgpu::TextureView makeMsaaSidecarTextureViewIfTextureSidecarExists(uint8_t samples,
+            uint8_t mipLevel, uint32_t arrayLayer) const;
+
+    /**
+     * @return nullptr if a MSAA sidecar texture is not appliable, otherwise a view to one
+     */
+    [[nodiscard]] wgpu::TextureView makeMsaaSidecarTextureView(wgpu::Texture const&, uint8_t mipLevel, uint32_t arrayLayer) const;
+
     [[nodiscard]] static wgpu::TextureFormat fToWGPUTextureFormat(
             filament::backend::TextureFormat const& fFormat);
 
@@ -96,6 +139,11 @@ private:
     uint32_t mDefaultMipLevel = 0;
     uint32_t mDefaultBaseArrayLayer = 0;
     wgpu::TextureView mDefaultTextureView = nullptr;
+    // At the time of writing this, WebGPU only supported 4 samples in a multi-sampled texture.
+    // If that has changed, then consider updating the implementation to have a map of msaa textures
+    // by sampleCount or something like that.
+    // For now that complexity and cost is not warranted due to WebGPU's restrictions.
+    wgpu::Texture mMsaaSidecarTexture = nullptr;
 
     [[nodiscard]] wgpu::TextureView makeTextureView(const uint8_t& baseLevel,
             const uint8_t& levelCount, const uint32_t& baseArrayLayer,

filament/include/filament/MaterialInstance.h

@@ -57,7 +57,8 @@ class UTILS_PUBLIC MaterialInstance : public FilamentAPI {
 
 public:
     using CullingMode = backend::CullingMode;
-    using TransparencyMode = TransparencyMode;
+    // ReSharper disable once CppRedundantQualifier
+    using TransparencyMode = filament::TransparencyMode;
     using DepthFunc = backend::SamplerCompareFunc;
     using StencilCompareFunc = backend::SamplerCompareFunc;
     using StencilOperation = backend::StencilOperation;

filament/src/PostProcessManager.cpp

@@ -2989,7 +2989,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscale(FrameGraph& fg, bool
     }
 
     if (dsrOptions.quality == QualityLevel::LOW) {
-        return upscaleBilinear(fg, translucent, dsrOptions, input, vp, outDesc, filter);
+        return upscaleBilinear(fg, dsrOptions, input, vp, outDesc, filter);
     }
     if (dsrOptions.quality == QualityLevel::MEDIUM) {
         return upscaleSGSR1(fg, sourceHasLuminance, dsrOptions, input, vp, outDesc);
@@ -2997,7 +2997,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscale(FrameGraph& fg, bool
     return upscaleFSR1(fg, dsrOptions, input, vp, outDesc);
 }
 
-FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleBilinear(FrameGraph& fg, bool translucent,
+FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleBilinear(FrameGraph& fg,
         DynamicResolutionOptions dsrOptions, FrameGraphId<FrameGraphTexture> const input,
         filament::Viewport const& vp, FrameGraphTexture::Descriptor const& outDesc,
         SamplerMagFilter filter) noexcept {
@@ -3016,18 +3016,10 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleBilinear(FrameGraph&
                         .attachments = { .color = { data.output } },
                         .clearFlags = TargetBufferFlags::DEPTH });
             },
-            [this, vp, translucent, filter](FrameGraphResources const& resources,
+            [this, vp, filter](FrameGraphResources const& resources,
                     auto const& data, DriverApi& driver) {
                 bindPostProcessDescriptorSet(driver);
 
-                // helper to enable blending
-                auto enableTranslucentBlending = [](PipelineState& pipeline) {
-                    pipeline.rasterState.blendFunctionSrcRGB = BlendFunction::ONE;
-                    pipeline.rasterState.blendFunctionSrcAlpha = BlendFunction::ONE;
-                    pipeline.rasterState.blendFunctionDstRGB = BlendFunction::ONE_MINUS_SRC_ALPHA;
-                    pipeline.rasterState.blendFunctionDstAlpha = BlendFunction::ONE_MINUS_SRC_ALPHA;
-                };
-
                 auto color = resources.getTexture(data.input);
                 auto const& inputDesc = resources.getDescriptor(data.input);
 
@@ -3055,9 +3047,6 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleBilinear(FrameGraph&
                 auto out = resources.getRenderPassInfo();
 
                 auto pipeline = getPipelineState(material.getMaterial(mEngine));
-                if (translucent) {
-                    enableTranslucentBlending(pipeline);
-                }
                 renderFullScreenQuad(out, pipeline, driver);
             });
 
@@ -3065,7 +3054,8 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleBilinear(FrameGraph&
 
     // if we had to take the low quality fallback, we still do the "sharpen pass"
     if (dsrOptions.sharpness > 0.0f) {
-        output = rcas(fg, dsrOptions.sharpness, output, outDesc, translucent);
+        output = rcas(fg, dsrOptions.sharpness, output, outDesc,
+                false /* translucent=false, because dst buffer is allocated */);
     }
 
     // we rely on automatic culling of unused render passes

filament/src/PostProcessManager.h

@@ -257,7 +257,7 @@ public:
             FrameGraphId<FrameGraphTexture> input, Viewport const& vp,
             FrameGraphTexture::Descriptor const& outDesc, backend::SamplerMagFilter filter) noexcept;
 
-    FrameGraphId<FrameGraphTexture> upscaleBilinear(FrameGraph& fg, bool translucent,
+    FrameGraphId<FrameGraphTexture> upscaleBilinear(FrameGraph& fg,
             DynamicResolutionOptions dsrOptions, FrameGraphId<FrameGraphTexture> input,
             Viewport const& vp, FrameGraphTexture::Descriptor const& outDesc,
             backend::SamplerMagFilter filter) noexcept;

filament/src/RenderPass.cpp

@@ -82,8 +82,6 @@ RenderPassBuilder& RenderPassBuilder::customCommand(
 
 RenderPass RenderPassBuilder::build(FEngine const& engine, DriverApi& driver) const {
     assert_invariant(mRenderableSoa);
-    assert_invariant(mScissorViewport.width  <= std::numeric_limits<int32_t>::max());
-    assert_invariant(mScissorViewport.height <= std::numeric_limits<int32_t>::max());
     return RenderPass{ engine, driver, *this };
 }
 
@@ -107,8 +105,7 @@ void RenderPass::DescriptorSetHandleDeleter::operator()(
 RenderPass::RenderPass(FEngine const& engine, DriverApi& driver,
         RenderPassBuilder const& builder) noexcept
         : mRenderableSoa(*builder.mRenderableSoa),
-          mColorPassDescriptorSet(builder.mColorPassDescriptorSet),
-          mScissorViewport(builder.mScissorViewport) {
+          mColorPassDescriptorSet(builder.mColorPassDescriptorSet) {
 
     // compute the number of commands we need
     updateSummedPrimitiveCounts(

filament/src/RenderPass.h

@@ -306,6 +306,12 @@ public:
     // allocated commands ARE NOT freed, they're owned by the Arena
     ~RenderPass() noexcept;
 
+    // Specifies the viewport for the scissor rectangle, that is, the final scissor rect is
+    // offset by the viewport's left-top and clipped to the viewport's width/height.
+    void setScissorViewport(backend::Viewport const viewport) noexcept {
+        mScissorViewport = viewport;
+    }
+
     Command const* begin() const noexcept { return mCommandBegin; }
     Command const* end() const noexcept { return mCommandEnd; }
     bool empty() const noexcept { return begin() == end(); }
@@ -461,7 +467,7 @@ private:
 
     FScene::RenderableSoa const& mRenderableSoa;
     ColorPassDescriptorSet const* const mColorPassDescriptorSet;
-    backend::Viewport const mScissorViewport{ 0, 0, INT32_MAX, INT32_MAX };
+    backend::Viewport mScissorViewport{ 0, 0, INT32_MAX, INT32_MAX };
     Command const* /* const */ mCommandBegin = nullptr;   // Pointer to the first command
     Command const* /* const */ mCommandEnd = nullptr;     // Pointer to one past the last command
     mutable BufferObjectSharedHandle mInstancedUboHandle; // ubo for instanced primitives
@@ -476,7 +482,6 @@ class RenderPassBuilder {
 
     RenderPass::Arena& mArena;
     RenderPass::CommandTypeFlags mCommandTypeFlags{};
-    backend::Viewport mScissorViewport{ 0, 0, INT32_MAX, INT32_MAX };
     FScene::RenderableSoa const* mRenderableSoa = nullptr;
     utils::Range<uint32_t> mVisibleRenderables{};
     math::float3 mCameraPosition{};
@@ -507,13 +512,6 @@ public:
         return *this;
     }
 
-    // Specifies the viewport for the scissor rectangle, that is, the final scissor rect is
-    // offset by the viewport's left-top and clipped to the viewport's width/height.
-    RenderPassBuilder& scissorViewport(backend::Viewport const viewport) noexcept {
-        mScissorViewport = viewport;
-        return *this;
-    }
-
     // specifies the geometry to generate commands for
     RenderPassBuilder& geometry(
             FScene::RenderableSoa const& soa, utils::Range<uint32_t> const vr) noexcept {

filament/src/RendererUtils.cpp

@@ -40,7 +40,6 @@
 #include <utils/Panic.h>
 
 #include <algorithm>
-#include <optional>
 #include <utility>
 
 #include <stddef.h>
@@ -270,87 +269,94 @@ RendererUtils::ColorPassOutput RendererUtils::colorPass(
     };
 }
 
-std::optional<RendererUtils::ColorPassOutput> RendererUtils::refractionPass(
+
+RenderPass::Command const* RendererUtils::getFirstRefractionCommand(
+    RenderPass const& pass) noexcept {
+
+    // find the first refractive object in channel 2
+    RenderPass::Command const* const refraction = std::partition_point(pass.begin(), pass.end(),
+        [](auto const& command) {
+            constexpr uint64_t mask  = RenderPass::CHANNEL_MASK | RenderPass::PASS_MASK;
+            constexpr uint64_t channel = uint64_t(RenderableManager::Builder::DEFAULT_CHANNEL) << RenderPass::CHANNEL_SHIFT;
+            constexpr uint64_t value = channel | uint64_t(RenderPass::Pass::REFRACT);
+            return (command.key & mask) < value;
+        });
+
+    const bool hasScreenSpaceRefraction =
+            (refraction->key & RenderPass::PASS_MASK) == uint64_t(RenderPass::Pass::REFRACT);
+
+    return hasScreenSpaceRefraction ? refraction : nullptr;
+
+}
+
+RendererUtils::ColorPassOutput RendererUtils::refractionPass(
         FrameGraph& fg, FEngine& engine, FView const& view,
         ColorPassInput colorPassInput,
         ColorPassConfig config,
         PostProcessManager::ScreenSpaceRefConfig const& ssrConfig,
         PostProcessManager::ColorGradingConfig const colorGradingConfig,
-        RenderPass const& pass) noexcept {
+        RenderPass const& pass, RenderPass::Command const* const firstRefractionCommand) noexcept {
 
-    // find the first refractive object in channel 2
-    RenderPass::Command const* const refraction = std::partition_point(pass.begin(), pass.end(),
-            [](auto const& command) {
-                constexpr uint64_t mask  = RenderPass::CHANNEL_MASK | RenderPass::PASS_MASK;
-                constexpr uint64_t channel = uint64_t(RenderableManager::Builder::DEFAULT_CHANNEL) << RenderPass::CHANNEL_SHIFT;
-                constexpr uint64_t value = channel | uint64_t(RenderPass::Pass::REFRACT);
-                return (command.key & mask) < value;
-            });
-
-    const bool hasScreenSpaceRefraction =
-            (refraction->key & RenderPass::PASS_MASK) == uint64_t(RenderPass::Pass::REFRACT);
+    assert_invariant(firstRefractionCommand);
+    RenderPass::Command const* const refraction = firstRefractionCommand;
 
     // if there wasn't any refractive object, just skip everything below.
-    if (UTILS_UNLIKELY(hasScreenSpaceRefraction)) {
-        assert_invariant(!colorPassInput.linearColor);
-        assert_invariant(!colorPassInput.depth);
-        config.hasScreenSpaceReflectionsOrRefractions = true;
+    assert_invariant(!colorPassInput.linearColor);
+    assert_invariant(!colorPassInput.depth);
+    config.hasScreenSpaceReflectionsOrRefractions = true;
 
-        PostProcessManager& ppm = engine.getPostProcessManager();
-        auto const opaquePassOutput = colorPass(fg,
-                "Color Pass (opaque)", engine, view, colorPassInput, {
-                        // When rendering the opaques, we need to conserve the sample buffer,
-                        // so create a config that specifies the sample count.
-                        .width = config.physicalViewport.width,
-                        .height = config.physicalViewport.height,
-                        .samples = config.msaa,
-                        .format = config.hdrFormat
-                },
-                config, { .asSubpass = false, .customResolve = false },
-                pass.getExecutor(pass.begin(), refraction));
+    PostProcessManager& ppm = engine.getPostProcessManager();
+    auto const opaquePassOutput = colorPass(fg,
+            "Color Pass (opaque)", engine, view, colorPassInput, {
+                    // When rendering the opaques, we need to conserve the sample buffer,
+                    // so create a config that specifies the sample count.
+                    .width = config.physicalViewport.width,
+                    .height = config.physicalViewport.height,
+                    .samples = config.msaa,
+                    .format = config.hdrFormat
+            },
+            config, { .asSubpass = false, .customResolve = false },
+            pass.getExecutor(pass.begin(), refraction));
 
 
-        // Generate the mipmap chain
-        // Note: we can run some post-processing effects while the "color pass" descriptor set
-        // in bound because only the descriptor 0 (frame uniforms) matters, and it's
-        // present in both.
-        PostProcessManager::generateMipmapSSR(ppm, fg,
-                opaquePassOutput.linearColor,
-                ssrConfig.refraction,
-                true, ssrConfig);
+    // Generate the mipmap chain
+    // Note: we can run some post-processing effects while the "color pass" descriptor set
+    // in bound because only the descriptor 0 (frame uniforms) matters, and it's
+    // present in both.
+    PostProcessManager::generateMipmapSSR(ppm, fg,
+            opaquePassOutput.linearColor,
+            ssrConfig.refraction,
+            true, ssrConfig);
 
-        // Now we're doing the refraction pass proper.
-        // This uses the same framebuffer (color and depth) used by the opaque pass.
-        // For this reason, the `colorBufferDesc` parameter of colorPass() below is only used  for
-        // the width and height.
-        colorPassInput.linearColor = opaquePassOutput.linearColor;
-        colorPassInput.depth = opaquePassOutput.depth;
+    // Now we're doing the refraction pass proper.
+    // This uses the same framebuffer (color and depth) used by the opaque pass.
+    // For this reason, the `colorBufferDesc` parameter of colorPass() below is only used  for
+    // the width and height.
+    colorPassInput.linearColor = opaquePassOutput.linearColor;
+    colorPassInput.depth = opaquePassOutput.depth;
 
-        // Since we're reusing the existing target we don't want to clear any of its buffer.
-        // Important: if this target ended up being an imported target, then the clearFlags
-        // specified here wouldn't apply (the clearFlags of the imported target take precedence),
-        // and we'd end up clearing the opaque pass. This scenario never happens because it is
-        // prevented in Renderer.cpp's final blit.
-        config.clearFlags = TargetBufferFlags::NONE;
-        auto transparentPassOutput = colorPass(fg, "Color Pass (transparent)",
-                engine, view, colorPassInput, {
-                        .width = config.physicalViewport.width,
-                        .height = config.physicalViewport.height },
-                config, colorGradingConfig,
-                pass.getExecutor(refraction, pass.end()));
+    // Since we're reusing the existing target we don't want to clear any of its buffer.
+    // Important: if this target ended up being an imported target, then the clearFlags
+    // specified here wouldn't apply (the clearFlags of the imported target take precedence),
+    // and we'd end up clearing the opaque pass. This scenario never happens because it is
+    // prevented in Renderer.cpp's final blit.
+    config.clearFlags = TargetBufferFlags::NONE;
+    auto transparentPassOutput = colorPass(fg, "Color Pass (transparent)",
+            engine, view, colorPassInput, {
+                    .width = config.physicalViewport.width,
+                    .height = config.physicalViewport.height },
+            config, colorGradingConfig,
+            pass.getExecutor(refraction, pass.end()));
 
-        if (config.msaa > 1 && !colorGradingConfig.asSubpass) {
-            // We need to do a resolve here because later passes (such as color grading or DoF) will
-            // need to sample from 'output'. However, because we have MSAA, we know we're not
-            // sampleable. And this is because in the SSR case, we had to use a renderbuffer to
-            // conserve the multi-sample buffer.
-            transparentPassOutput.linearColor = ppm.resolve(fg, "Resolved Color Buffer",
-                    transparentPassOutput.linearColor, { .levels = 1 });
-        }
-        return transparentPassOutput;
+    if (config.msaa > 1 && !colorGradingConfig.asSubpass) {
+        // We need to do a resolve here because later passes (such as color grading or DoF) will
+        // need to sample from 'output'. However, because we have MSAA, we know we're not
+        // sampleable. And this is because in the SSR case, we had to use a renderbuffer to
+        // conserve the multi-sample buffer.
+        transparentPassOutput.linearColor = ppm.resolve(fg, "Resolved Color Buffer",
+                transparentPassOutput.linearColor, { .levels = 1 });
     }
-
-    return std::nullopt;
+    return transparentPassOutput;
 }
 
 UTILS_NOINLINE

filament/src/RendererUtils.h

@@ -26,18 +26,19 @@
 #include <filament/Viewport.h>
 
 #include <backend/DriverEnums.h>
-#include <backend/PixelBufferDescriptor.h>
+#include <backend/Handle.h>
 
 #include <math/vec2.h>
 #include <math/vec4.h>
 
 #include <stdint.h>
 
-#include <optional>
-#include <utility>
-
 namespace filament {
 
+namespace backend {
+class PixelBufferDescriptor;
+}
+
 class FRenderTarget;
 class FrameGraph;
 class FrameGraph;
@@ -99,18 +100,20 @@ public:
             PostProcessManager::ColorGradingConfig colorGradingConfig,
             RenderPass::Executor passExecutor) noexcept;
 
-    static std::optional<ColorPassOutput> refractionPass(
+    static ColorPassOutput refractionPass(
             FrameGraph& fg, FEngine& engine, FView const& view,
             ColorPassInput colorPassInput,
             ColorPassConfig config,
             PostProcessManager::ScreenSpaceRefConfig const& ssrConfig,
             PostProcessManager::ColorGradingConfig colorGradingConfig,
-            RenderPass const& pass) noexcept;
+            RenderPass const& pass, RenderPass::Command const* firstRefractionCommand) noexcept;
 
     static void readPixels(backend::DriverApi& driver,
             backend::Handle<backend::HwRenderTarget> renderTargetHandle,
             uint32_t xoffset, uint32_t yoffset, uint32_t width, uint32_t height,
             backend::PixelBufferDescriptor&& buffer);
+
+    static RenderPass::Command const* getFirstRefractionCommand(RenderPass const& pass) noexcept;
 };
 
 } // namespace filament

filament/src/details/Engine.h

@@ -98,6 +98,14 @@ namespace filament::fgviewer {
 } // namespace filament::fgviewer
 #endif
 
+// We have added correctness assertions that breaks clients' projects. We add this define to allow
+// for the client's to address these assertions at a more gradual pace.
+#if defined(FILAMENT_RELAXED_CORRECTNESS_ASSERTIONS)
+#define CORRECTNESS_ASSERTION_DEFAULT false
+#else
+#define CORRECTNESS_ASSERTION_DEFAULT true
+#endif
+
 namespace filament {
 
 class Renderer;
@@ -715,10 +723,14 @@ public:
                 bool use_shadow_atlas = false;
             } shadows;
             struct {
-                // TODO: default the following two flags to true.
-                bool assert_material_instance_in_use = false;
-                bool assert_destroy_material_before_material_instance = false;
-                bool assert_vertex_buffer_count_exceeds_8 = false;
+                // TODO: clean-up the following flags (equivalent to setting them to true) when
+                // clients have addressed their usages.
+                bool assert_material_instance_in_use = CORRECTNESS_ASSERTION_DEFAULT;
+                bool assert_destroy_material_before_material_instance =
+                        CORRECTNESS_ASSERTION_DEFAULT;
+                bool assert_vertex_buffer_count_exceeds_8 = CORRECTNESS_ASSERTION_DEFAULT;
+                bool assert_vertex_buffer_attribute_stride_mult_of_4 =
+                        CORRECTNESS_ASSERTION_DEFAULT;
             } debug;
         } engine;
         struct {
@@ -759,6 +771,9 @@ public:
             { "features.engine.debug.assert_vertex_buffer_count_exceeds_8",
               "Assert when a client's number of buffers for a VertexBuffer exceeds 8.",
               &features.engine.debug.assert_vertex_buffer_count_exceeds_8, false },
+            { "features.engine.debug.assert_vertex_buffer_attribute_stride_mult_of_4",
+              "Assert that the attribute stride of a vertex buffer is a multiple of 4.",
+              &features.engine.debug.assert_vertex_buffer_attribute_stride_mult_of_4, false },
     }};
 
     utils::Slice<const FeatureFlag> getFeatureFlags() const noexcept {

filament/src/details/Renderer.cpp

@@ -1125,16 +1125,6 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
     // --------------------------------------------------------------------------------------------
     // Color passes
 
-    // this makes the viewport relative to xvp
-    // FIXME: we should use 'vp' when rendering directly into the swapchain, but that's hard to
-    //        know at this point. This will usually be the case when post-process is disabled.
-    // FIXME: we probably should take the dynamic scaling into account too
-    // if MSAA is enabled, we end-up rendering in an intermediate buffer. This is the only case where
-    // "!hasPostProcess" doesn't guarantee rendering into the swapchain.
-    const bool useIntermediateBuffer = hasPostProcess || msaaOptions.enabled ||
-          (isRenderingMultiview && engine.debug.stereo.combine_multiview_images);
-    passBuilder.scissorViewport(useIntermediateBuffer ? xvp : vp);
-
     // This one doesn't need to be a FrameGraph pass because it always happens by construction
     // (i.e. it won't be culled, unless everything is culled), so no need to complexify things.
     passBuilder.variant(variant);
@@ -1174,8 +1164,35 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
         passBuilder.renderFlags(renderFlags);
     }
 
+    // create the pass, which generates all its commands (this is a heavy operation)
     RenderPass const pass{ passBuilder.build(engine, driver) };
 
+    // now that we have the commands we can figure out if we have refraction commands
+    auto* const firstRefractionCommand = [&view](RenderPass const& pass) {
+        RenderPass::Command const* p = nullptr;
+        if (UTILS_UNLIKELY(view.isScreenSpaceRefractionEnabled() && !pass.empty())) {
+            p = RendererUtils::getFirstRefractionCommand(pass);
+        }
+        return p;
+    }(pass);
+
+    hasScreenSpaceRefraction = firstRefractionCommand != nullptr;
+
+    // this makes the viewport relative to xvp
+    // FIXME: we should use 'vp' when rendering directly into the swapchain, but that's hard to
+    //        know at this point. This will usually be the case when post-process is disabled.
+    // FIXME: we probably should take the dynamic scaling into account too
+    // if MSAA is enabled, we end-up rendering in an intermediate buffer. This is the only case where
+    // "!hasPostProcess" doesn't guarantee rendering into the swapchain.
+    const bool useIntermediateBuffer = hasPostProcess || msaaOptions.enabled ||
+            ssReflectionsOptions.enabled || hasScreenSpaceRefraction ||
+            (isRenderingMultiview && engine.debug.stereo.
+            combine_multiview_images);
+
+    // this is slightly ugly, but conceptually `pass` is const; it's just that we can't set
+    // the scissor viewport during construction
+    const_cast<RenderPass&>(pass).setScissorViewport(useIntermediateBuffer ? xvp : vp);
+
     FrameGraphTexture::Descriptor colorBufferDesc = {
             .width = config.physicalViewport.width,
             .height = config.physicalViewport.height,
@@ -1220,21 +1237,17 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
             },
             colorBufferDesc, config, colorGradingConfigForColor, pass.getExecutor());
 
-    if (view.isScreenSpaceRefractionEnabled() && !pass.empty()) {
+    if (UTILS_UNLIKELY(hasScreenSpaceRefraction)) {
         // This cancels the colorPass() call above if refraction is active.
         // The color pass + refraction + color-grading as subpass if needed
-        auto const output = RendererUtils::refractionPass(fg, mEngine, view, {
+        colorPassOutput = RendererUtils::refractionPass(fg, mEngine, view, {
                         .shadows = blackboard.get<FrameGraphTexture>("shadows"),
                         .ssao = blackboard.get<FrameGraphTexture>("ssao"),
                         .ssr = ssrConfig.ssr,
                         .structure = structure
                 },
-                config, ssrConfig, colorGradingConfigForColor, pass);
-
-        hasScreenSpaceRefraction = output.has_value();
-        if (hasScreenSpaceRefraction) {
-            colorPassOutput = output.value();
-        }
+                config, ssrConfig, colorGradingConfigForColor,
+                pass, firstRefractionCommand);
     }
 
     if (colorGradingConfig.customResolve) {

filament/src/details/Texture.cpp

@@ -386,8 +386,9 @@ void FTexture::setImage(FEngine& engine, size_t const level,
     FILAMENT_CHECK_PRECONDITION(any(mUsage & Texture::Usage::UPLOADABLE))
             << "Texture is not uploadable.";
 
-    FILAMENT_CHECK_PRECONDITION(mSampleCount <= 1) << "Operation not supported with multisample ("
-                                                   << unsigned(mSampleCount) << ") texture.";
+    FILAMENT_CHECK_PRECONDITION(mSampleCount <= 1)
+            << "Operation not supported with multisample ("
+            << unsigned(mSampleCount) << ") texture.";
 
     FILAMENT_CHECK_PRECONDITION(xoffset + width <= valueForLevel(level, mWidth))
             << "xoffset (" << unsigned(xoffset) << ") + width (" << unsigned(width)
@@ -428,28 +429,46 @@ void FTexture::setImage(FEngine& engine, size_t const level,
             << ") > texture depth (" << effectiveTextureDepthOrLayers << ") at level ("
             << unsigned(level) << ")";
 
+    if (UTILS_UNLIKELY(!width || !height || !depth)) {
+        // The operation is a no-op, return immediately. The PixelBufferDescriptor callback
+        // should be called automatically when the object is destroyed.
+        // The precondition check below assumes width, height, depth non null.
+        return;
+    }
+
     if (p.type != PixelDataType::COMPRESSED) {
         using PBD = PixelBufferDescriptor;
         size_t const stride = p.stride ? p.stride : width;
-        size_t const bpp = PBD::computePixelSize(p.format, p.type);
+        size_t const bpp = PBD::computeDataSize(p.format, p.type, 1, 1, 1);
         size_t const bpr = PBD::computeDataSize(p.format, p.type, stride, 1, p.alignment);
-        size_t const pbdWidth = stride;
-        // TODO: PBD should have a "layer stride" (using "depth" as a substitute).
-        size_t const pbdDepth = depth;
-        size_t const pbdHeight = p.size / bpr / pbdDepth;
-        assert_invariant(p.size % bpr == 0 && (p.size / bpr) % pbdDepth == 0);
-
+        size_t const bpl = bpr * height; // TODO: PBD should have a "layer stride"
         // TODO: PBD should have a p.depth (# layers to skip)
-        FILAMENT_CHECK_PRECONDITION(
-                bpp * (pbdWidth - p.left) * (pbdHeight - p.top) * (pbdDepth - 0) >=
-                bpp * width * height * depth)
+
+        /* Calculates the byte offset of the last pixel in a 3D sub-region. */
+        auto const calculateLastPixelOffset = [bpp, bpr, bpl](
+                size_t xoff, size_t yoff, size_t zoff,
+                size_t width, size_t height, size_t depth) {
+            // The 0-indexed coordinates of the last pixel are:
+            // x = xoff + width - 1
+            // y = yoff + height - 1
+            // z = zoff + depth - 1
+            // The offset is calculated as: (z * bpl) + (y * bpr) + (x * bpp)
+            return ((zoff + depth  - 1) * bpl) +
+                   ((yoff + height - 1) * bpr) +
+                   ((xoff + width  - 1) * bpp);
+        };
+
+        size_t const lastPixelOffset = calculateLastPixelOffset(
+                p.left, p.top, 0, width, height, depth);
+
+        // make sure the whole last pixel is in the buffer
+        FILAMENT_CHECK_PRECONDITION(lastPixelOffset + bpp <= p.size)
                 << "buffer overflow: (size=" << size_t(p.size) << ", stride=" << size_t(p.stride)
                 << ", left=" << unsigned(p.left) << ", top=" << unsigned(p.top)
                 << ") smaller than specified region "
                    "{{"
-                << unsigned(xoffset) << "," << unsigned(yoffset) << "," << unsigned(zoffset)
-                << "},{" << unsigned(width) << "," << unsigned(height) << "," << unsigned(depth)
-                << ")}}";
+                << unsigned(xoffset) << "," << unsigned(yoffset) << "," << unsigned(zoffset) << "},{"
+                << unsigned(width) << "," << unsigned(height) << "," << unsigned(depth) << ")}}";
     }
 
     engine.getDriverApi().update3DImage(mHandle, uint8_t(level), xoffset, yoffset, zoffset, width,

filament/src/details/VertexBuffer.cpp

@@ -177,9 +177,15 @@ VertexBuffer* VertexBuffer::Builder::build(Engine& engine) {
                 << "attribute " << j << " offset=" << attributes[j].offset
                 << " is not multiple of 4";
 
-        FILAMENT_CHECK_PRECONDITION((attributes[j].stride & 0x3u) == 0)
-                << "attribute " << j << " stride=" << attributes[j].stride
-                << " is not multiple of 4";
+        FEngine* fengine = static_cast<FEngine*>(&engine);
+        if (fengine->features.engine.debug.assert_vertex_buffer_attribute_stride_mult_of_4) {
+            FILAMENT_CHECK_PRECONDITION((attributes[j].stride & 0x3u) == 0)
+                    << "attribute " << j << " stride=" << attributes[j].stride
+                    << " is not multiple of 4";
+        } else if ((attributes[j].stride & 0x3u) != 0) {
+            LOG(WARNING) << "attribute " << j << " stride=" << attributes[j].stride
+                         << " is not multiple of 4";
+        }
 
         if (engine.getActiveFeatureLevel() == FeatureLevel::FEATURE_LEVEL_0) {
             FILAMENT_CHECK_PRECONDITION(!(attributes[j].flags & Attribute::FLAG_INTEGER_TARGET))

libs/gltfio/src/TangentsJob.cpp

@@ -16,6 +16,7 @@
 
 #include "TangentsJob.h"
 
+#include <cstdlib>
 #include <memory>
 
 #include <geometry/SurfaceOrientation.h>

test/renderdiff/src/compare.py

@@ -14,15 +14,12 @@ def _compare_goldens(base_dir, comparison_dir, out_dir=None):
                   for f in all_files)
   all_results = []
   for test_dir in test_dirs:
-    results_meta = {}
     results = []
-    output_test_dir = None if not out_dir else os.path.join(out_dir, test_dir)
+    output_test_dir = None if not out_dir else os.path.abspath(os.path.join(out_dir, test_dir))
     if output_test_dir:
       mkdir_p(output_test_dir)
     base_test_dir = os.path.abspath(os.path.join(base_dir, test_dir))
     comp_test_dir = os.path.abspath(os.path.join(comparison_dir, test_dir))
-    results_meta['base_dir'] = base_test_dir
-    results_meta['comparison_dir'] = comp_test_dir
     for golden_file in \
         glob.glob(os.path.join(base_test_dir, "*.tif")):
       base_fname = os.path.abspath(golden_file)
@@ -45,8 +42,12 @@ def _compare_goldens(base_dir, comparison_dir, out_dir=None):
         result['result'] = RESULT_OK
       results.append(result)
     if output_test_dir:
-      results_meta['results'] = results
       output_fname = os.path.join(output_test_dir, "compare_results.json")
+      results_meta = {
+        'results': results,
+        'base_dir': os.path.relpath(output_fname, base_test_dir),
+        'comparison_dir': os.path.relpath(output_fname, comp_test_dir),
+      }
       with open(output_fname, 'w') as f:
         f.write(json.dumps(results_meta, indent=2))
       important_print(f'Written comparison results for {test_dir} to \n    {output_fname}')
@@ -64,7 +65,7 @@ if __name__ == '__main__':
   dest = args.dest
   if not dest:
     print('Assume the default renderdiff output folder')
-    dest = os.path.join(os.getcwd(), './out/renderdiff_tests')
+    dest = os.path.join(os.getcwd(), './out/renderdiff')
   assert os.path.exists(dest), f"Destination folder={dest} does not exist."
 
   results = _compare_goldens(args.src, dest, out_dir=args.out)

test/renderdiff/src/viewer.py

@@ -17,6 +17,9 @@ import sys
 import flask
 import pathlib
 import json
+import requests
+import io
+import zipfile
 
 from utils import ArgParseImpl
 
@@ -25,14 +28,163 @@ from flask import Flask, request, make_response, send_from_directory
 DIR = pathlib.Path(__file__).parent.absolute()
 HTML_DIR = os.path.join(DIR, "viewer_html")
 
+# Generated by gemini
+def _download_github_artifacts(pr_number, github_token, output_dir= ".") -> None:
+  """
+  Downloads artifacts associated with a specific GitHub Pull Request.
+
+  This function performs the following steps:
+  1. Fetches the details of the Pull Request to get its head commit SHA.
+  2. Searches for GitHub Actions workflow runs triggered by that specific commit.
+  3. Iterates through successful workflow runs to find and list all associated artifacts.
+  4. Downloads each artifact (which comes as a ZIP file).
+  5. Extracts the contents of each downloaded ZIP file into a unique subdirectory
+  within the specified output directory.
+
+  Args:
+    owner (str): The GitHub repository owner (e.g., "octocat").
+    repo (str): The GitHub repository name (e.g., "Spoon-Knife").
+    pr_number (int): The Pull Request number.
+    output_dir (str): The local directory where downloaded artifacts will be saved.
+            Defaults to the current directory.
+  """
+
+  # Prepare HTTP headers for GitHub API requests
+  headers = {"Accept": "application/vnd.github.v3+json"}
+  if github_token:
+    headers["Authorization"] = f"token {github_token}"
+
+  OWNER_REPO = 'google/filament'
+
+  # --- Step 1: Get PR details to find the head commit SHA ---
+  print(f"Fetching details for PR #{pr_number} in {OWNER_REPO}...")
+  pr_url = f"https://api.github.com/repos/{OWNER_REPO}/pulls/{pr_number}"
+  try:
+    response = requests.get(pr_url, headers=headers)
+    response.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
+    pr_data = response.json()
+    commit_sha = pr_data["head"]["sha"]
+    print(f"PR #{pr_number} is associated with commit SHA: {commit_sha}")
+  except requests.exceptions.HTTPError as e:
+    if e.response.status_code == 404:
+      print(f"Error: PR #{pr_number} not found in {OWNER_REPO}. Please check the PR number, owner, and repository name.")
+    elif e.response.status_code == 403:
+      print(f"Error: Access forbidden to PR #{pr_number}. You might be hitting API rate limits or need a valid GitHub Token.")
+    else:
+      print(f"An HTTP error occurred while fetching PR details: {e}")
+    return # Exit function on error
+  except requests.exceptions.RequestException as e:
+    print(f"A network error occurred while fetching PR details: {e}")
+    return # Exit function on error
+
+  # --- Step 2: Find workflow runs associated with the commit SHA ---
+  print(f"Searching for workflow runs for commit SHA: {commit_sha}...")
+  workflow_runs_url = f"https://api.github.com/repos/{OWNER_REPO}/actions/runs"
+  # Filter by head_sha and event='pull_request' for precision
+  params = {"head_sha": commit_sha, "event": "pull_request"}
+  try:
+    response = requests.get(workflow_runs_url, headers=headers, params=params)
+    response.raise_for_status()
+    runs_data = response.json()
+    workflow_runs = runs_data.get("workflow_runs", [])
+
+    if not workflow_runs:
+      print(f"No workflow runs found directly associated with PR #{pr_number} (commit SHA: {commit_sha}).")
+      print("This might happen if the workflow was triggered by a push after the PR was opened,")
+      print("or if the PR head branch was updated without triggering a new workflow run with this exact SHA.")
+      print("Consider checking GitHub Actions runs manually for this PR's branch on GitHub.")
+      return None
+
+    # Filter for runs that completed successfully
+    successful_runs = [run for run in workflow_runs if run.get("conclusion") == "success" and run.get("status") == "completed"]
+    if not successful_runs:
+      print(f"No *successful and completed* workflow runs found for PR #{pr_number} with commit SHA {commit_sha}. Exiting.")
+      return None
+
+  except requests.exceptions.HTTPError as e:
+    print(f"An HTTP error occurred while searching for workflow runs: {e}")
+    return None
+  except requests.exceptions.RequestException as e:
+    print(f"A network error occurred while searching for workflow runs: {e}")
+    return None
+
+  # Create the main output directory if it doesn't exist
+  os.makedirs(output_dir, exist_ok=True)
+  print(f"Ensuring output directory exists: {os.path.abspath(output_dir)}")
+
+  downloaded_any_artifact = False # Flag to track if any artifact was downloaded
+
+  # --- Step 3 & 4: List and Download Artifacts for each successful run ---
+  for run in successful_runs:
+    run_id = run["id"]
+    run_name = run["name"]
+    print(f"\nProcessing workflow run '{run_name}' (ID: {run_id})...")
+
+    artifacts_url = f"https://api.github.com/repos/{OWNER_REPO}/actions/runs/{run_id}/artifacts"
+    try:
+      response = requests.get(artifacts_url, headers=headers)
+      response.raise_for_status()
+      artifacts_data = response.json()
+      artifacts = artifacts_data.get("artifacts", [])
+
+      if not artifacts:
+        print(f"  No artifacts found for workflow run ID {run_id}.")
+        continue # Move to the next workflow run
+
+      for artifact in artifacts:
+        artifact_id = artifact["id"]
+        artifact_name = artifact["name"]
+        archive_download_url = artifact["archive_download_url"]
+
+        print(f"  Found artifact: '{artifact_name}' (ID: {artifact_id})")
+
+        # Perform the download request
+        print(f"  Downloading '{artifact_name}'...")
+        # Use a copy of headers and specific Accept for ZIP download
+        download_headers = headers.copy()
+        download_headers["Accept"] = "application/vnd.github.v3+zip"
+        download_response = requests.get(archive_download_url, headers=download_headers, stream=True)
+        download_response.raise_for_status() # Check for errors in download
+
+        # --- Step 5: Extract the contents ---
+        # Use BytesIO to handle the zip file content in memory without saving to a temporary file
+        with io.BytesIO(download_response.content) as zip_buffer:
+          try:
+            with zipfile.ZipFile(zip_buffer, 'r') as zip_ref:
+              # Create a unique subdirectory for each artifact to avoid file name conflicts
+              extract_path = os.path.join(output_dir, f"{artifact_name}_{artifact_id}")
+              os.makedirs(extract_path, exist_ok=True)
+              zip_ref.extractall(extract_path)
+              print(f"  Successfully extracted '{artifact_name}' to '{extract_path}/'")
+              downloaded_any_artifact = True
+          except zipfile.BadZipFile:
+            print(f"  Error: Downloaded file for '{artifact_name}' is not a valid zip file. Skipping extraction.")
+          except Exception as e:
+            print(f"  An error occurred during extraction of '{artifact_name}': {e}")
+    except requests.exceptions.HTTPError as e:
+      print(f"  An HTTP error occurred while fetching artifacts for run {run_id}: {e}")
+      if e.response.status_code == 403:
+        print("  This often means you need a GitHub Personal Access Token with 'repo' scope (even for public repos for artifact downloads).")
+      continue # Continue processing the next workflow run
+    except requests.exceptions.RequestException as e:
+      print(f"  A network error occurred while fetching artifacts for run {run_id}: {e}")
+      continue # Continue processing the next workflow run
+
+  if not downloaded_any_artifact:
+    print("\nNo artifacts were downloaded for the specified PR.")
+  else:
+    print("\nAll available artifacts have been processed.")
+  return 'Done'
+
 def _create_app(config):
   app = Flask(__name__)
 
   client_config = config.copy()
-  base_dir = client_config['base_dir']
-  comparison_dir = client_config['comparison_dir']
   diff_dir = client_config['diff_dir']
 
+  base_dir = os.path.join(diff_dir, client_config['base_dir'])
+  comparison_dir = os.path.join(diff_dir, client_config['comparison_dir'])
+
   del client_config['base_dir']
   del client_config['comparison_dir']
   del client_config['diff_dir']
@@ -67,12 +219,37 @@ def _create_app(config):
 if __name__ == '__main__':
   PORT = 8901
   parser = ArgParseImpl()
-  parser.add_argument('--diff', help='Diff directory', required=True)
+  parser.add_argument('--diff', type=str, help='Diff result directory')
+  parser.add_argument('--pr_number', type=str, help='Pull request artifacts to examine')
+  parser.add_argument('--github_token', type=str, help='Necessary for pull PR artifacts')
   args, _ = parser.parse_known_args(sys.argv[1:])
 
-  with open(os.path.join(args.diff, 'compare_results.json'), 'r') as f:
+  if not args.diff and not args.pr_number:
+    print('Need to specify either a diff result directory or a Pull Request number')
+    exit(1)
+
+  if args.diff and args.pr_number:
+    print('Cannot specify both a diff result directory and a Pull Request number')
+    exit(1)
+
+  fdir = args.diff
+  if args.pr_number:
+    if not args.github_token:
+      print('Must provide --github_token to be able to download artifacts')
+      exit(1)
+    output_dir = f'/tmp/filament-pr{args.pr_number}-rdiff-result'
+    res = _download_github_artifacts(args.pr_number, args.github_token, output_dir)
+    if not res:
+      print('Failed to retrieve PR artifacts')
+      exit(1)
+
+    # TODO: Clean up the following so that we're not so specific on the paths diffs/presubmit
+    directory_name = list(os.listdir(output_dir))[0]
+    fdir = os.path.join(os.path.join(output_dir, directory_name), 'diffs/presubmit')
+
+  with open(os.path.join(fdir, 'compare_results.json'), 'r') as f:
     config = json.loads(f.read())
-  config['diff_dir'] = os.path.abspath(args.diff)
+  config['diff_dir'] = os.path.abspath(fdir)
 
   app = _create_app(config)
   from waitress import serve