Stash old version of rebind logic to still be able to play with it.

Avoid running the inline pass without merge return on WebGPU
Split and rebind combined image samplers for WebGPU API target
2025-03-31 17:12:39 -04:00 · 2025-03-31 16:57:43 -04:00 · 2025-03-31 16:50:22 -04:00 · 2025-03-31 16:41:49 -04:00 · 2025-03-31 16:41:49 -04:00 · 2025-03-31 16:41:49 -04:00
9315 changed files with 2043512 additions and 346249 deletions
@@ -19,8 +19,6 @@ jobs:

    steps:
      - uses: actions/checkout@v4.1.6
-        with:
-          fetch-depth: 0
      - name: Run build script
        run: |
          WORKFLOW_OS=`echo \`uname\` | sed "s/Darwin/mac/" | tr [:upper:] [:lower:]`
@@ -46,8 +44,6 @@ jobs:

    steps:
      - uses: actions/checkout@v4.1.6
-        with:
-          fetch-depth: 0
      - uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
@@ -64,8 +60,6 @@ jobs:

    steps:
      - uses: actions/checkout@v4.1.6
-        with:
-          fetch-depth: 0
      - name: Run build script
        run: |
          cd build/ios && printf "y" | ./build.sh presubmit
@@ -128,31 +122,3 @@ jobs:
        run: source ./build/linux/ci-common.sh && ./build.sh -W debug test_filamat filament
      - name: Run test
        run: ./out/cmake-debug/libs/filamat/test_filamat --gtest_filter=MaterialCompiler.Wgsl*
-
-  code-correcteness:
-    name: code-correctness
-    runs-on: 'macos-14-xlarge'
-    steps:
-      - uses: actions/checkout@v4.1.6
-        with:
-          fetch-depth: 0
-      - name: Set up Homebrew
-        id: set-up-homebrew
-        uses: Homebrew/actions/setup-homebrew@master
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.x'
-      - name: Install prerequisites
-        run: |
-          pip install pyyaml
-          brew install llvm
-          sudo ln -s "$(brew --prefix llvm)/bin/clang-tidy" "/usr/local/bin/clang-tidy"
-      - name: Run build script
-        # We need to build before clang-tidy can run analysis
-        run: |
-          # This will build for all three desktop backends on mac
-          ./build.sh -p desktop debug gltf_viewer
-      - name: Run test
-        run: |
-          bash test/code-correctness/test.sh
@@ -334,9 +334,6 @@ if (MSVC)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_STANDARD} /W0 /Zc:__cplusplus")
 else()
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_STANDARD} -fstrict-aliasing -Wno-unknown-pragmas -Wno-unused-function -Wno-deprecated-declarations")
-    if (APPLE)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nullability-extension")
-    endif()
 endif()

 if (FILAMENT_USE_EXTERNAL_GLES3)
@@ -7,5 +7,3 @@ for next branch cut* header.
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).

 ## Release notes for next branch cut
-
- Fix build/compile errors when upgrading to MacOS 15.4
@@ -31,7 +31,7 @@ repositories {
 }

 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.59.0'
+    implementation 'com.google.android.filament:filament-android:1.58.2'
 }
 ```

@@ -51,7 +51,7 @@ Here are all the libraries available in the group `com.google.android.filament`:
 iOS projects can use CocoaPods to install the latest release:

 ```shell
-pod 'Filament', '~> 1.59.0'
+pod 'Filament', '~> 1.58.2'
 ```

 ## Documentation
@@ -7,9 +7,6 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).

-## v1.59.1
-
-
 ## v1.59.0

 - materials: five custom variables (varyings) are now available on the condition that the `color` attribute is not requested (b/404930099). [⚠️ **New Material Version**]
@@ -142,12 +142,6 @@ abstract class MaterialCompiler extends TaskWithBinary {
                if (!exclude_vulkan) {
                    matcArgs += ['-a', 'vulkan']
                }
-                def include_webgpu = providers
-                        .gradleProperty("com.google.android.filament.include-webgpu")
-                        .forUseAtConfigurationTime().present
-                if (include_webgpu) {
-                    matcArgs += ['-a', 'webgpu', '--variant-filter=skinning,stereo']
-                }

                def mat_no_opt = providers
                        .gradleProperty("com.google.android.filament.matnopt")
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.59.0
+VERSION_NAME=1.58.2

 POM_DESCRIPTION=Real-time physically based rendering engine for Android.

@@ -177,6 +177,29 @@ endif()
 if (FILAMENT_SUPPORTS_VULKAN)
    list(APPEND SRCS
            include/backend/platforms/VulkanPlatform.h
+            src/vulkan/VulkanDescriptorSetCache.cpp
+            src/vulkan/VulkanDescriptorSetCache.h
+            src/vulkan/VulkanDescriptorSetLayoutCache.cpp
+            src/vulkan/VulkanDescriptorSetLayoutCache.h
+            src/vulkan/VulkanPipelineLayoutCache.cpp
+            src/vulkan/VulkanPipelineLayoutCache.h
+            src/vulkan/memory/ResourceManager.cpp
+            src/vulkan/memory/ResourceManager.h
+            src/vulkan/memory/ResourcePointer.h
+            src/vulkan/memory/Resource.cpp
+            src/vulkan/memory/Resource.h
+            src/vulkan/platform/VulkanPlatform.cpp
+            src/vulkan/platform/VulkanPlatformSwapChainImpl.cpp
+            src/vulkan/platform/VulkanPlatformSwapChainImpl.h
+            src/vulkan/utils/Conversion.cpp
+            src/vulkan/utils/Conversion.h
+            src/vulkan/utils/Definitions.h
+            src/vulkan/utils/Helper.h
+            src/vulkan/utils/Image.h
+            src/vulkan/utils/Image.cpp
+            src/vulkan/utils/Spirv.h
+            src/vulkan/utils/Spirv.cpp
+            src/vulkan/utils/StaticVector.h
            src/vulkan/VulkanAsyncHandles.h
            src/vulkan/VulkanBlitter.cpp
            src/vulkan/VulkanBlitter.h
@@ -187,56 +210,29 @@ if (FILAMENT_SUPPORTS_VULKAN)
            src/vulkan/VulkanConstants.h
            src/vulkan/VulkanContext.cpp
            src/vulkan/VulkanContext.h
-            src/vulkan/VulkanDescriptorSetCache.cpp
-            src/vulkan/VulkanDescriptorSetCache.h
-            src/vulkan/VulkanDescriptorSetLayoutCache.cpp
-            src/vulkan/VulkanDescriptorSetLayoutCache.h
            src/vulkan/VulkanDriver.cpp
            src/vulkan/VulkanDriver.h
            src/vulkan/VulkanDriverFactory.h
-            src/vulkan/VulkanExternalImageManager.cpp
-            src/vulkan/VulkanExternalImageManager.h
            src/vulkan/VulkanFboCache.cpp
            src/vulkan/VulkanFboCache.h
            src/vulkan/VulkanHandles.cpp
            src/vulkan/VulkanHandles.h
-            src/vulkan/VulkanMemory.cpp
            src/vulkan/VulkanMemory.h
+            src/vulkan/VulkanMemory.cpp
            src/vulkan/VulkanPipelineCache.cpp
            src/vulkan/VulkanPipelineCache.h
-            src/vulkan/VulkanPipelineLayoutCache.cpp
-            src/vulkan/VulkanPipelineLayoutCache.h
            src/vulkan/VulkanQueryManager.cpp
            src/vulkan/VulkanQueryManager.h
-            src/vulkan/VulkanReadPixels.cpp
-            src/vulkan/VulkanReadPixels.h
            src/vulkan/VulkanSamplerCache.cpp
            src/vulkan/VulkanSamplerCache.h
            src/vulkan/VulkanStagePool.cpp
            src/vulkan/VulkanStagePool.h
            src/vulkan/VulkanSwapChain.cpp
            src/vulkan/VulkanSwapChain.h
+            src/vulkan/VulkanReadPixels.cpp
+            src/vulkan/VulkanReadPixels.h
            src/vulkan/VulkanTexture.cpp
            src/vulkan/VulkanTexture.h
-            src/vulkan/VulkanYcbcrConversionCache.cpp
-            src/vulkan/VulkanYcbcrConversionCache.h
-            src/vulkan/memory/Resource.cpp
-            src/vulkan/memory/Resource.h
-            src/vulkan/memory/ResourceManager.cpp
-            src/vulkan/memory/ResourceManager.h
-            src/vulkan/memory/ResourcePointer.h
-            src/vulkan/platform/VulkanPlatform.cpp
-            src/vulkan/platform/VulkanPlatformSwapChainImpl.cpp
-            src/vulkan/platform/VulkanPlatformSwapChainImpl.h
-            src/vulkan/utils/Conversion.cpp
-            src/vulkan/utils/Conversion.h
-            src/vulkan/utils/Definitions.h
-            src/vulkan/utils/Helper.h
-            src/vulkan/utils/Image.cpp
-            src/vulkan/utils/Image.h
-            src/vulkan/utils/Spirv.cpp
-            src/vulkan/utils/Spirv.h
-            src/vulkan/utils/StaticVector.h
    )
    if (LINUX OR WIN32)
        list(APPEND SRCS src/vulkan/platform/VulkanPlatformLinuxWindows.cpp)
@@ -257,8 +253,6 @@ if (FILAMENT_SUPPORTS_WEBGPU)
            src/webgpu/WebGPUConstants.h
            src/webgpu/WebGPUDriver.cpp
            src/webgpu/WebGPUDriver.h
-            src/webgpu/WebGPUSwapChain.cpp
-            src/webgpu/WebGPUSwapChain.h
    )
    if (WIN32)
        list(APPEND SRCS src/webgpu/platform/WebGPUPlatformWindows.cpp)
@@ -308,11 +302,6 @@ target_include_directories(${TARGET} PUBLIC ${PUBLIC_HDR_DIR})
 # add this subproject to the Filament folder
 set_target_properties(${TARGET} PROPERTIES FOLDER Filament)

-# we need to export the headers properly for backend.lib on windows
-if (WIN32 AND FILAMENT_SUPPORTS_WEBGPU)
-    target_compile_definitions(${TARGET} PRIVATE "WGPU_IMPLEMENTATION")
-endif()
-
 # ==================================================================================================
 # Expose a header-only target to minimize dependencies.
 # ==================================================================================================
@@ -508,7 +497,6 @@ if (APPLE OR LINUX)
        test/ImageExpectations.cpp
        test/Lifetimes.cpp
        test/Shader.cpp
-        test/SharedShaders.cpp
        test/test_FeedbackLoops.cpp
        test/test_Blit.cpp
        test/test_MissingRequiredAttributes.cpp
@@ -149,13 +149,6 @@ public:
         *      - PlatformEGLAndroid
         */
        bool assertNativeWindowIsValid = false;
-
-        /**
-         * The action to take if a Drawable cannot be acquired. If true, the
-         * frame is aborted instead of panic. This is only supported for:
-         *      - PlatformMetal
-         */
-        bool metalDisablePanicOnDrawableFailure = false;
    };

    Platform() noexcept;
@@ -104,6 +104,10 @@ public:

        // Semaphore to be signaled once the image is available.
        VkSemaphore imageReadySemaphore = VK_NULL_HANDLE;
+
+        // A function called right before vkQueueSubmit. After this call, the image must be 
+        // available. This pointer can be null if imageReadySemaphore is not VK_NULL_HANDLE.
+        std::function<void(SwapChainPtr handle)> explicitImageReadyWait = nullptr;
    };

    VulkanPlatform();
@@ -294,16 +298,6 @@ public:
    VkQueue getProtectedGraphicsQueue() const noexcept;

    struct ExternalImageMetadata {
-        /**
-         * The Filament texture format.
-         */
-        TextureFormat filamentFormat;
-
-        /**
-         * The Filament texture usage.
-         */
-        TextureUsage filamentUsage;
-
        /**
         * The width of the external image
         */
@@ -314,6 +308,11 @@ public:
         */
        uint32_t height;

+        /**
+         * The layerCount of the external image
+         */
+        uint32_t layerCount;
+
        /**
         * The layer count of the external image
         */
@@ -329,6 +328,11 @@ public:
         */
        VkFormat format;

+        /**
+         * An external buffer can be protected. This tells you if it is.
+         */
+        bool isProtected;
+
        /**
         * The type of external format (opaque int) if used.
         */
@@ -348,44 +352,21 @@ public:
         * Heap information
         */
        uint32_t memoryTypeBits;
-
-        /**
-         * Ycbcr conversion components
-         */
-        VkComponentMapping ycbcrConversionComponents;
-
-        /**
-         * Ycbcr model
-         */
-        VkSamplerYcbcrModelConversion ycbcrModel;
-
-        /**
-         * Ycbcr range
-         */
-        VkSamplerYcbcrRange ycbcrRange;
-
-        /**
-         * Ycbcr x chroma offset
-         */
-        VkChromaLocation xChromaOffset;
-
-        /**
-         * Ycbcr y chroma offset
-         */
-        VkChromaLocation yChromaOffset;
    };
-
-
-    // Note that the image metadata might change per-frame, hence we need a method for extracting
-    // it.
-    virtual ExternalImageMetadata extractExternalImageMetadata(ExternalImageHandleRef image) const {
-        return {};
-    }
+    virtual ExternalImageMetadata getExternalImageMetadata(ExternalImageHandleRef externalImage);

    using ImageData = std::pair<VkImage, VkDeviceMemory>;
-    virtual ImageData createVkImageFromExternal(ExternalImageHandleRef image) const {
-        return { VK_NULL_HANDLE, VK_NULL_HANDLE };
-    }
+    virtual ImageData createExternalImageData(ExternalImageHandleRef externalImage,
+            const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex,
+            VkImageUsageFlags usage);
+
+    virtual VkSampler createExternalSampler(SamplerYcbcrConversion chroma,
+            SamplerParams sampler,
+            uint32_t internalFormat);
+
+    virtual VkImageView createExternalImageView(SamplerYcbcrConversion chroma,
+            uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
+            VkImageViewType viewType, VkComponentMapping swizzle);

 protected:
    virtual ExtensionSet getSwapchainInstanceExtensions() const;
@@ -398,6 +379,20 @@ private:
    // Platform dependent helper methods
    static ExtensionSet getSwapchainInstanceExtensionsImpl();

+    static ExternalImageMetadata getExternalImageMetadataImpl(ExternalImageHandleRef externalImage,
+            VkDevice device);
+
+    static ImageData createExternalImageDataImpl(ExternalImageHandleRef externalImage,
+            VkDevice device, const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex,
+            VkImageUsageFlags usage);
+    static VkSampler createExternalSamplerImpl(VkDevice device,
+            SamplerYcbcrConversion chroma, SamplerParams sampler,
+            uint32_t internalFormat);
+    static VkImageView createExternalImageViewImpl(VkDevice device,
+            SamplerYcbcrConversion chroma, uint32_t internalFormat, VkImage image,
+            VkImageSubresourceRange range, VkImageViewType viewType,
+            VkComponentMapping swizzle);
+
    // Platform dependent helper methods
    static SurfaceBundle createVkSurfaceKHRImpl(void* nativeWindow, VkInstance instance,
            uint64_t flags) noexcept;
@@ -26,7 +26,7 @@ namespace filament::backend {

 class VulkanPlatformAndroid : public VulkanPlatform {
 public:
-    ExternalImageHandle UTILS_PUBLIC createExternalImage(AHardwareBuffer const* buffer,
+    Platform::ExternalImageHandle UTILS_PUBLIC createExternalImage(AHardwareBuffer const* buffer,
            bool sRGB) noexcept;

    struct UTILS_PUBLIC ExternalImageDescAndroid {
@@ -39,26 +39,31 @@ public:
    ExternalImageDescAndroid UTILS_PUBLIC getExternalImageDesc(
            ExternalImageHandleRef externalImage) const noexcept;

-    virtual ExternalImageMetadata extractExternalImageMetadata(
-            ExternalImageHandleRef image) const override;
-
-    virtual ImageData createVkImageFromExternal(ExternalImageHandleRef image) const override;
-
 protected:
-    virtual ExtensionSet getSwapchainInstanceExtensions() const override;
-
-    using SurfaceBundle = VulkanPlatform::SurfaceBundle;
-    virtual SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
-            uint64_t flags) const noexcept override;
-
-private:
    struct ExternalImageVulkanAndroid : public Platform::ExternalImage {
        AHardwareBuffer* aHardwareBuffer = nullptr;
        bool sRGB = false;
+        unsigned int width;  // Texture width
+        unsigned int height; // Texture height
+        TextureFormat format;// Texture format
+        TextureUsage usage;  // Texture usage flags

    protected:
        ~ExternalImageVulkanAndroid() override;
    };
+
+    virtual ExternalImageMetadata getExternalImageMetadata(ExternalImageHandleRef externalImage);
+
+    using ImageData = VulkanPlatform::ImageData;
+    virtual ImageData createExternalImageData(ExternalImageHandleRef externalImage,
+            const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex,
+            VkImageUsageFlags usage);
+
+    virtual ExtensionSet getSwapchainInstanceExtensions() const;
+
+    using SurfaceBundle = VulkanPlatform::SurfaceBundle;
+    virtual SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
+            uint64_t flags) const noexcept;
 };

 }// namespace filament::backend
@@ -40,11 +40,9 @@
 #include <stddef.h>
 #include <stdint.h>

-#define HandleAllocatorGL   HandleAllocator<32,  96, 184>    // ~4520 / pool / MiB
-#define HandleAllocatorVK   HandleAllocator<64, 160, 312>    // ~1820 / pool / MiB
-#define HandleAllocatorMTL  HandleAllocator<32,  64, 552>    // ~1660 / pool / MiB
-// TODO WebGPU examine right size of handles
-#define HandleAllocatorWGPU HandleAllocator<64, 160, 552>    // ~1820 / pool / MiB
+#define HandleAllocatorGL  HandleAllocator<32,  96, 184>    // ~4520 / pool / MiB
+#define HandleAllocatorVK  HandleAllocator<64, 160, 312>    // ~1820 / pool / MiB
+#define HandleAllocatorMTL HandleAllocator<32,  64, 552>    // ~1660 / pool / MiB

 namespace filament::backend {

@@ -211,8 +211,4 @@ template class HandleAllocatorVK;
 template class HandleAllocatorMTL;
 #endif

-#if defined (FILAMENT_SUPPORTS_WEBGPU)
-template class HandleAllocatorWGPU;
-#endif
-
 } // namespace filament::backend
@@ -45,9 +45,6 @@ PlatformMetal::~PlatformMetal() noexcept {
 }

 Driver* PlatformMetal::createDriver(void* /*sharedContext*/, const Platform::DriverConfig& driverConfig) noexcept {
-    pImpl->mDrawableFailureBehavior = driverConfig.metalDisablePanicOnDrawableFailure
-            ? DrawableFailureBehavior::ABORT_FRAME
-            : DrawableFailureBehavior::PANIC;
    return MetalDriverFactory::create(this, driverConfig);
 }

@@ -17,6 +17,9 @@
 #include "VulkanBlitter.h"
 #include "VulkanCommands.h"
 #include "VulkanContext.h"
+#include "VulkanFboCache.h"
+#include "VulkanHandles.h"
+#include "VulkanSamplerCache.h"
 #include "VulkanTexture.h"
 #include "vulkan/utils/Image.h"

@@ -24,6 +24,13 @@

 namespace filament::backend {

+class VulkanBuffer;
+class VulkanFboCache;
+class VulkanPipelineCache;
+class VulkanSamplerCache;
+
+struct VulkanProgram;
+
 class VulkanBlitter {
 public:
    VulkanBlitter(VkPhysicalDevice physicalDevice, VulkanCommands* commands) noexcept;
@@ -93,7 +93,7 @@
 #endif

 #ifndef NDEBUG
-#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE | FVK_DEBUG_FORWARDED_FLAG | FVK_DEBUG_VALIDATION)
+#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE | FVK_DEBUG_FORWARDED_FLAG)
 #else
 #define FVK_DEBUG_FLAGS 0
 #endif
@@ -56,9 +56,9 @@ VkImageView VulkanAttachment::getImageView() {
    assert_invariant(texture);
    VkImageSubresourceRange range = getSubresourceRange();
    if (range.layerCount > 1) {
-        return texture->getAttachmentView(range, VK_IMAGE_VIEW_TYPE_2D_ARRAY);
+        return texture->getMultiviewAttachmentView(range);
    }
-    return texture->getAttachmentView(range, VK_IMAGE_VIEW_TYPE_2D);
+    return texture->getAttachmentView(range);
 }

 bool VulkanAttachment::isDepth() const {
@@ -68,11 +68,11 @@ bool VulkanAttachment::isDepth() const {
 VkImageSubresourceRange VulkanAttachment::getSubresourceRange() const {
    assert_invariant(texture);
    return {
-        .aspectMask = texture->getImageAspect(),
-        .baseMipLevel = uint32_t(level),
-        .levelCount = 1,
-        .baseArrayLayer = uint32_t(layer),
-        .layerCount = layerCount,
+            .aspectMask = texture->getImageAspect(),
+            .baseMipLevel = uint32_t(level),
+            .levelCount = 1,
+            .baseArrayLayer = uint32_t(layer),
+            .layerCount = layerCount,
    };
 }

@@ -17,6 +17,7 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANCONTEXT_H
 #define TNT_FILAMENT_BACKEND_VULKANCONTEXT_H

+#include "VulkanConstants.h"
 #include "vulkan/utils/Image.h"
 #include "vulkan/utils/Definitions.h"

@@ -29,6 +30,8 @@

 #include <bluevk/BlueVK.h>

+#include <memory>
+
 VK_DEFINE_HANDLE(VmaAllocator)
 VK_DEFINE_HANDLE(VmaPool)

@@ -70,11 +73,13 @@ struct VulkanRenderPass {
 // context are stored in VulkanPlatform.
 struct VulkanContext {
 public:
-    static uint32_t selectMemoryType(VkPhysicalDeviceMemoryProperties const& memoryProperties,
-            uint32_t flags, VkFlags reqs) {
+    inline uint32_t selectMemoryType(uint32_t flags, VkFlags reqs) const {
+        if ((reqs & VK_MEMORY_PROPERTY_PROTECTED_BIT) != 0) {
+            assert_invariant(isProtectedMemorySupported() == true);
+        }
        for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
            if (flags & 1) {
-                if ((memoryProperties.memoryTypes[i].propertyFlags & reqs) == reqs) {
+                if ((mMemoryProperties.memoryTypes[i].propertyFlags & reqs) == reqs) {
                    return i;
                }
            }
@@ -83,13 +88,6 @@ public:
        return (uint32_t) VK_MAX_MEMORY_TYPES;
    }

-    inline uint32_t selectMemoryType(uint32_t flags, VkFlags reqs) const {
-        if ((reqs & VK_MEMORY_PROPERTY_PROTECTED_BIT) != 0) {
-            assert_invariant(isProtectedMemorySupported());
-        }
-        return selectMemoryType(mMemoryProperties, flags, reqs);
-    }
-
    inline fvkutils::VkFormatList const& getAttachmentDepthStencilFormats() const {
        return mDepthStencilFormats;
    }
@@ -123,7 +121,7 @@ public:
    }

    inline bool isMultiviewEnabled() const noexcept {
-        return mPhysicalDeviceVk11Features.multiview == VK_TRUE;
+        return mMultiviewEnabled;
    }

    inline bool isClipDistanceSupported() const noexcept {
@@ -147,9 +145,6 @@ private:
    VkPhysicalDeviceProperties2 mPhysicalDeviceProperties = {
        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
    };
-    VkPhysicalDeviceVulkan11Features mPhysicalDeviceVk11Features = {
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
-    };
    VkPhysicalDeviceFeatures2 mPhysicalDeviceFeatures = {
        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
    };
@@ -162,6 +157,7 @@ private:
    };
    bool mDebugMarkersSupported = false;
    bool mDebugUtilsSupported = false;
+    bool mMultiviewEnabled = false;
    bool mLazilyAllocatedMemorySupported = false;
    bool mProtectedMemorySupported = false;

@@ -260,6 +260,7 @@ VulkanDescriptorSetCache::~VulkanDescriptorSetCache() = default;

 void VulkanDescriptorSetCache::terminate() noexcept{
    mDescriptorPool.reset();
+    clearHistory();
 }

 // bind() is not really binding the set but just stashing until we have all the info
@@ -282,25 +283,18 @@ void VulkanDescriptorSetCache::commit(VulkanCommandBuffer* commands,
    fvkutils::DescriptorSetMask curMask = setMask;

    auto& updateSets = mStashedSets;
-    bool const pipelineLayoutIsSame = mLastBoundInfo.pipelineLayout == pipelineLayout;
+    auto& lastBoundSets = mLastBoundInfo.boundSets;

-    if (pipelineLayoutIsSame) {
-        auto& lastBoundSets = mLastBoundInfo.boundSets;
-        setMask.forEachSetBit([&](size_t index) {
-            if (!updateSets[index] || updateSets[index] == lastBoundSets[index]) {
-                curMask.unset(index);
-            }
-        });
-        if (curMask.none() &&
-                mLastBoundInfo.setMask == setMask && mLastBoundInfo.boundSets == updateSets) {
-            return;
+    setMask.forEachSetBit([&](size_t index) {
+        if (!updateSets[index] || updateSets[index] == lastBoundSets[index]) {
+            curMask.unset(index);
        }
-    } else {
-        setMask.forEachSetBit([&](size_t index) {
-            if (!updateSets[index]) {
-                curMask.unset(index);
-            }
-        });
+    });
+
+    if (curMask.none() &&
+            (mLastBoundInfo.pipelineLayout == pipelineLayout && mLastBoundInfo.setMask == setMask &&
+                    mLastBoundInfo.boundSets == updateSets)) {
+        return;
    }

    curMask.forEachSetBit([&updateSets, commands, pipelineLayout](size_t index) {
@@ -308,7 +302,7 @@ void VulkanDescriptorSetCache::commit(VulkanCommandBuffer* commands,
        auto set = updateSets[index];
        VkCommandBuffer const cmdbuffer = commands->buffer();
        vkCmdBindDescriptorSets(cmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, index,
-                1, &set->getVkSet(), set->uniqueDynamicUboCount, set->getOffsets()->data());
+                1, &set->vkSet, set->uniqueDynamicUboCount, set->getOffsets()->data());
        commands->acquire(set);
    });

@@ -336,7 +330,8 @@ void VulkanDescriptorSetCache::updateBuffer(fvkmemory::resource_ptr<VulkanDescri
    }
    VkWriteDescriptorSet const descriptorWrite = {
        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-        .dstSet = set->getVkSet(),
+        .pNext = nullptr,
+        .dstSet = set->vkSet,
        .dstBinding = binding,
        .descriptorCount = 1,
        .descriptorType = type,
@@ -349,25 +344,26 @@ void VulkanDescriptorSetCache::updateBuffer(fvkmemory::resource_ptr<VulkanDescri
 void VulkanDescriptorSetCache::updateSampler(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
        uint8_t binding, fvkmemory::resource_ptr<VulkanTexture> texture,
        VkSampler sampler) noexcept {
-    VkImageSubresourceRange range = texture->getPrimaryViewRange();
+    VkDescriptorImageInfo info{
+        .sampler = sampler,
+    };
+    VkImageSubresourceRange const range = texture->getPrimaryViewRange();
    VkImageViewType const expectedType = texture->getViewType();
    if (any(texture->usage & TextureUsage::DEPTH_ATTACHMENT) &&
            expectedType == VK_IMAGE_VIEW_TYPE_2D) {
        // If the sampler is part of a mipmapped depth texture, where one of the level *can* be
-        // an attachment, then the range for this view has exactly one level and one layer.
-        range.levelCount = 1;
-        range.layerCount = 1;
+        // an attachment, then the sampler for this texture has the same view properties as a
+        // view for an attachment. Therefore, we can use getAttachmentView to get a
+        // corresponding VkImageView.
+        info.imageView = texture->getAttachmentView(range);
+    } else {
+        info.imageView = texture->getViewForType(range, expectedType);
    }
-    VkDescriptorImageInfo info{
-        .sampler = sampler,
-        .imageView = texture->getView(range),
-        .imageLayout = fvkutils::getVkLayout(texture->getDefaultLayout()),
-    };
-
+    info.imageLayout = fvkutils::getVkLayout(texture->getDefaultLayout());
    VkWriteDescriptorSet const descriptorWrite = {
        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
        .pNext = nullptr,
-        .dstSet = set->getVkSet(),
+        .dstSet = set->vkSet,
        .dstBinding = binding,
        .descriptorCount = 1,
        .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
@@ -385,10 +381,10 @@ void VulkanDescriptorSetCache::updateInputAttachment(

 fvkmemory::resource_ptr<VulkanDescriptorSet> VulkanDescriptorSetCache::createSet(
        Handle<HwDescriptorSet> handle, fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout) {
-    auto const vkSet = getVkSet(layout);
+    auto const vkSet = mDescriptorPool->obtainSet(layout);
    auto const& count = layout->count;
    auto const vklayout = layout->getVkLayout();
-    auto set = fvkmemory::resource_ptr<VulkanDescriptorSet>::make(mResourceManager, handle,
+    return fvkmemory::resource_ptr<VulkanDescriptorSet>::make(mResourceManager, handle, vkSet,
            layout->bitmask.dynamicUbo, layout->count.dynamicUbo,
            [vkSet, count, vklayout, this](VulkanDescriptorSet*) {
                // Note that mDescriptorPool could be gone due to terminate (when the backend shuts
@@ -397,20 +393,10 @@ fvkmemory::resource_ptr<VulkanDescriptorSet> VulkanDescriptorSetCache::createSet
                    mDescriptorPool->recycle(count, vklayout, vkSet);
                }
            });
-    set->setVkSet(vkSet);
-    return set;
 }

-VkDescriptorSet VulkanDescriptorSetCache::getVkSet(
-        fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout) {
-    return mDescriptorPool->obtainSet(layout);
+void VulkanDescriptorSetCache::clearHistory() {
+    mStashedSets = {};
 }

-void VulkanDescriptorSetCache::manualRecyle(VulkanDescriptorSetLayout::Count const& count,
-        VkDescriptorSetLayout vklayout, VkDescriptorSet vkSet) {
-    mDescriptorPool->recycle(count, vklayout, vkSet);
-}
-
-void VulkanDescriptorSetCache::gc() { mStashedSets = {}; }
-
 } // namespace filament::backend
@@ -41,8 +41,6 @@ public:
            VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT;

    using DescriptorSetLayoutArray = VulkanDescriptorSetLayout::DescriptorSetLayoutArray;
-    using DescriptorSetArray =
-            std::array<fvkmemory::resource_ptr<VulkanDescriptorSet>, UNIQUE_DESCRIPTOR_SET_COUNT>;

    VulkanDescriptorSetCache(VkDevice device, fvkmemory::ResourceManager* resourceManager);
    ~VulkanDescriptorSetCache();
@@ -70,21 +68,14 @@ public:
    fvkmemory::resource_ptr<VulkanDescriptorSet> createSet(Handle<HwDescriptorSet> handle,
            fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout);

-    // This method is only meant to be used with external samplers (or internally within this
-    // class).
-    VkDescriptorSet getVkSet(fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout);
-
-    // This method is only meant to be used with external samplers.
-    void manualRecyle(VulkanDescriptorSetLayout::Count const& count, VkDescriptorSetLayout vklayout,
-            VkDescriptorSet vkSet);
-
-    DescriptorSetArray const& getBoundSets() const { return mStashedSets; }
-
-    void gc();
+    void clearHistory();

 private:
    class DescriptorInfinitePool;

+    using DescriptorSetArray =
+            std::array<fvkmemory::resource_ptr<VulkanDescriptorSet>, UNIQUE_DESCRIPTOR_SET_COUNT>;
+
    VkDevice mDevice;
    fvkmemory::ResourceManager* mResourceManager;
    std::unique_ptr<DescriptorInfinitePool> mDescriptorPool;
@@ -18,8 +18,6 @@

 #include "VulkanHandles.h"

-#include <utils/Hash.h>
-
 namespace filament::backend {

 namespace {
@@ -60,56 +58,6 @@ uint32_t appendBindings(VkDescriptorSetLayoutBinding* toBind, VkDescriptorType t
    return count;
 }

-uint32_t appendSamplerBindings(VkDescriptorSetLayoutBinding* toBind,
-        fvkutils::SamplerBitmask const& mask, fvkutils::SamplerBitmask const& external,
-        utils::FixedCapacityVector<VkSampler> const& immutableSamplers) {
-    using Bitmask = fvkutils::SamplerBitmask;
-    uint32_t count = 0;
-    Bitmask alreadySeen;
-    uint8_t immutableIndex = 0;
-    size_t const immutableSamplerCount = immutableSamplers.size();
-    mask.forEachSetBit([&](size_t index) {
-        VkShaderStageFlags stages = 0;
-        uint32_t binding = 0;
-        if (index < fvkutils::getFragmentStageShift<Bitmask>()) {
-            binding = (uint32_t) index;
-            stages |= VK_SHADER_STAGE_VERTEX_BIT;
-            auto fragIndex = index + fvkutils::getFragmentStageShift<Bitmask>();
-            if (mask.test(fragIndex)) {
-                stages |= VK_SHADER_STAGE_FRAGMENT_BIT;
-                alreadySeen.set(fragIndex);
-            }
-        } else if (!alreadySeen.test(index)) {
-            // We are in fragment stage bits
-            binding = (uint32_t) (index - fvkutils::getFragmentStageShift<Bitmask>());
-            stages |= VK_SHADER_STAGE_FRAGMENT_BIT;
-        }
-
-        if (stages) {
-            toBind[count++] = {
-                .binding = binding,
-                .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-                .descriptorCount = 1,
-                .stageFlags = stages,
-                .pImmutableSamplers = external[index] && immutableSamplerCount > immutableIndex
-                                              ? &immutableSamplers[immutableIndex++]
-                                              : nullptr,
-            };
-        }
-    });
-    return count;
-}
-
-uint64_t computeImmutableSamplerHash(utils::FixedCapacityVector<VkSampler> const& samplers) {
-    size_t const size = samplers.size();
-    if (size == 0) {
-        return 0;
-    } else if (size == 1) {
-        return (uint64_t) samplers[0];
-    }
-    return utils::hash::murmur3((uint32_t*) samplers.data(), samplers.size() * 2, 0);
-}
-
 } // anonymous namespace

 VulkanDescriptorSetLayoutCache::VulkanDescriptorSetLayoutCache(VkDevice device,
@@ -125,44 +73,37 @@ void VulkanDescriptorSetLayoutCache::terminate() noexcept {
    }
 }

-VkDescriptorSetLayout VulkanDescriptorSetLayoutCache::getVkLayout(
-        VulkanDescriptorSetLayout::Bitmask const& bitmasks,
-        utils::FixedCapacityVector<VkSampler> immutableSamplers) {
-    LayoutKey key = {
-        .bitmask = bitmasks,
-        .immutableSamplerHash = computeImmutableSamplerHash(immutableSamplers),
-    };
-    if (auto itr = mVkLayouts.find(key); itr != mVkLayouts.end()) {
-        return itr->second;
-    }
-
-    VkDescriptorSetLayoutBinding toBind[VulkanDescriptorSetLayout::MAX_BINDINGS];
-    uint32_t count = 0;
-    count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
-            bitmasks.dynamicUbo);
-    count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, bitmasks.ubo);
-    count += appendSamplerBindings(&toBind[count], bitmasks.sampler, bitmasks.externalSampler,
-            immutableSamplers);
-    count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
-            bitmasks.inputAttachment);
-
-    assert_invariant(count != 0 && "Need at least one binding for descriptor set layout.");
-    VkDescriptorSetLayoutCreateInfo dlinfo = {
-        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-        .bindingCount = count,
-        .pBindings = toBind,
-    };
-    VkDescriptorSetLayout vklayout;
-    vkCreateDescriptorSetLayout(mDevice, &dlinfo, VKALLOC, &vklayout);
-    mVkLayouts[key] = vklayout;
-    return vklayout;
-}
-
 fvkmemory::resource_ptr<VulkanDescriptorSetLayout> VulkanDescriptorSetLayoutCache::createLayout(
        Handle<HwDescriptorSetLayout> handle, backend::DescriptorSetLayout&& info) {
    auto layout = fvkmemory::resource_ptr<VulkanDescriptorSetLayout>::make(mResourceManager, handle,
            info);
-    layout->setVkLayout(getVkLayout(layout->bitmask));
+    VkDescriptorSetLayout vklayout = VK_NULL_HANDLE;
+    auto const& bitmasks = layout->bitmask;
+    if (auto itr = mVkLayouts.find(bitmasks); itr != mVkLayouts.end()) {
+        vklayout = itr->second;
+    } else {
+        VkDescriptorSetLayoutBinding toBind[VulkanDescriptorSetLayout::MAX_BINDINGS];
+        uint32_t count = 0;
+        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
+                bitmasks.dynamicUbo);
+        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, bitmasks.ubo);
+        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                bitmasks.sampler);
+        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+                bitmasks.inputAttachment);
+
+        assert_invariant(count != 0 && "Need at least one binding for descriptor set layout.");
+        VkDescriptorSetLayoutCreateInfo dlinfo = {
+            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+            .pNext = nullptr,
+            .bindingCount = count,
+            .pBindings = toBind,
+        };
+
+        vkCreateDescriptorSetLayout(mDevice, &dlinfo, VKALLOC, &vklayout);
+        mVkLayouts[bitmasks] = vklayout;
+    }
+    layout->setVkLayout(vklayout);
    return layout;
 }

@@ -26,11 +26,12 @@
 #include <backend/TargetBufferInfo.h>

 #include <utils/bitset.h>
-#include <utils/FixedCapacityVector.h>

 #include <bluevk/BlueVK.h>
 #include <tsl/robin_map.h>

+#include <memory>
+
 namespace filament::backend {

 class VulkanDescriptorSetLayoutCache {
@@ -40,34 +41,21 @@ public:

    void terminate() noexcept;

-    // Just a wrapper around getVkLayout()
    fvkmemory::resource_ptr<VulkanDescriptorSetLayout> createLayout(
            Handle<HwDescriptorSetLayout> handle, backend::DescriptorSetLayout&& info);

-    // This method is meant to be used with external samplers
-    VkDescriptorSetLayout getVkLayout(VulkanDescriptorSetLayout::Bitmask const& bitmasks,
-            utils::FixedCapacityVector<VkSampler> immutableSamplers = {});
-
 private:
    VkDevice mDevice;
    fvkmemory::ResourceManager* mResourceManager;

-    struct LayoutKey {
-        // this describes the layout using bitset.
-        VulkanDescriptorSetLayout::Bitmask bitmask = {};
-        // number of immutable samplers can be arbitrary; so we hash them into 64-bit.
-        uint64_t immutableSamplerHash = 0;
-    };
-    static_assert(sizeof(LayoutKey) == 48);
-
-    using LayoutKeyHashFn = utils::hash::MurmurHashFn<LayoutKey>;
-    struct LayoutKeyEqual {
-        bool operator()(LayoutKey const& k1, LayoutKey const& k2) const {
-            return k1.bitmask == k2.bitmask && k1.immutableSamplerHash == k2.immutableSamplerHash;
-        }
+    using BitmaskGroup = VulkanDescriptorSetLayout::Bitmask;
+    using BitmaskGroupHashFn = utils::hash::MurmurHashFn<BitmaskGroup>;
+    struct BitmaskGroupEqual {
+        bool operator()(BitmaskGroup const& k1, BitmaskGroup const& k2) const { return k1 == k2; }
    };

-    tsl::robin_map<LayoutKey, VkDescriptorSetLayout, LayoutKeyHashFn, LayoutKeyEqual> mVkLayouts;
+    tsl::robin_map<BitmaskGroup, VkDescriptorSetLayout, BitmaskGroupHashFn, BitmaskGroupEqual>
+            mVkLayouts;
 };

 } // namespace filament::backend
@@ -25,12 +25,10 @@
 #include "VulkanHandles.h"
 #include "VulkanMemory.h"
 #include "VulkanTexture.h"
-#include "vulkan/VulkanSamplerCache.h"
 #include "vulkan/memory/ResourceManager.h"
 #include "vulkan/memory/ResourcePointer.h"
 #include "vulkan/utils/Conversion.h"
 #include "vulkan/utils/Definitions.h"
-#include "vulkan/vulkan_core.h"

 #include <backend/DriverEnums.h>
 #include <backend/platforms/VulkanPlatform.h>
@@ -200,7 +198,9 @@ Dispatcher VulkanDriver::getDispatcher() const noexcept {
 VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& context,
        Platform::DriverConfig const& driverConfig) noexcept
    : mPlatform(platform),
-      mResourceManager(driverConfig.handleArenaSize, driverConfig.disableHandleUseAfterFreeCheck,
+      mResourceManager(
+              driverConfig.handleArenaSize,
+              driverConfig.disableHandleUseAfterFreeCheck,
              driverConfig.disableHeapHandleTags),
      mAllocator(createAllocator(mPlatform->getInstance(), mPlatform->getPhysicalDevice(),
              mPlatform->getDevice())),
@@ -212,15 +212,12 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
      mPipelineCache(mPlatform->getDevice()),
      mStagePool(mAllocator, &mCommands),
      mFramebufferCache(mPlatform->getDevice()),
-      mYcbcrConversionCache(mPlatform->getDevice()),
      mSamplerCache(mPlatform->getDevice()),
      mBlitter(mPlatform->getPhysicalDevice(), &mCommands),
      mReadPixels(mPlatform->getDevice()),
      mDescriptorSetLayoutCache(mPlatform->getDevice(), &mResourceManager),
      mDescriptorSetCache(mPlatform->getDevice(), &mResourceManager),
      mQueryManager(mPlatform->getDevice()),
-      mExternalImageManager(platform, &mSamplerCache, &mYcbcrConversionCache, &mDescriptorSetCache,
-              &mDescriptorSetLayoutCache),
      mIsSRGBSwapChainSupported(mPlatform->getCustomization().isSRGBSwapChainSupported),
      mStereoscopicType(driverConfig.stereoscopicType) {

@@ -313,7 +310,7 @@ void VulkanDriver::terminate() {

    mCurrentSwapChain = {};
    mDefaultRenderTarget = {};
-    mPipelineState = {};
+    mBoundPipeline = {};

    mQueryManager.terminate();

@@ -325,10 +322,6 @@ void VulkanDriver::terminate() {

    mCommands.terminate();

-    // Must come before samplerCache, ycbcrConversionCache, descriptorSetCache,
-    // descriptorSetLayoutCache
-    mExternalImageManager.terminate();
-
    mStagePool.terminate();
    mPipelineCache.terminate();
    mFramebufferCache.reset();
@@ -370,7 +363,7 @@ void VulkanDriver::collectGarbage() {
    FVK_SYSTRACE_SCOPE();
    // Command buffers need to be submitted and completed before other resources can be gc'd.
    mCommands.gc();
-    mDescriptorSetCache.gc();
+    mDescriptorSetCache.clearHistory();
    mStagePool.gc();
    mFramebufferCache.gc();
    mPipelineCache.gc();
@@ -385,10 +378,6 @@ void VulkanDriver::beginFrame(int64_t monotonic_clock_ns,
        int64_t refreshIntervalNs, uint32_t frameId) {
    FVK_PROFILE_MARKER(PROFILE_NAME_BEGINFRAME);
    // Do nothing.
-
-    if (mAppState.hasExternalSamplers()) {
-        mExternalImageManager.onBeginFrame();
-    }
 }

 void VulkanDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch, CallbackHandler* handler,
@@ -429,16 +418,8 @@ void VulkanDriver::updateDescriptorSetTexture(
    auto set = resource_ptr<VulkanDescriptorSet>::cast(&mResourceManager, dsh);
    auto texture = resource_ptr<VulkanTexture>::cast(&mResourceManager, th);

-    if (mExternalImageManager.isExternallySampledTexture(texture)) {
-        mExternalImageManager.bindExternallySampledTexture(set, binding, texture, params);
-        mAppState.hasBoundExternalImages = true;
-    } else {
-        VulkanSamplerCache::Params cacheParams = {
-            .sampler = params,
-        };
-        VkSampler const vksampler = mSamplerCache.getSampler(cacheParams);
-        mDescriptorSetCache.updateSampler(set, binding, texture, vksampler);
-    }
+    VkSampler const vksampler = mSamplerCache.getSampler(params);
+    mDescriptorSetCache.updateSampler(set, binding, texture, vksampler);
 }

 void VulkanDriver::flush(int) {
@@ -575,35 +556,39 @@ void VulkanDriver::createTextureExternalImage2R(Handle<HwTexture> th, backend::S
        backend::TextureFormat format, uint32_t width, uint32_t height, backend::TextureUsage usage,
        Platform::ExternalImageHandleRef externalImage) {
    FVK_SYSTRACE_SCOPE();
-    auto const& metadata = mPlatform->extractExternalImageMetadata(externalImage);
-
-    // In theory the following are reasonable expectations, but in practice it's hard for client's
-    // to match up the dimensions of the texture with that of the AHB.
-    // assert_invariant(width == metadata.width);
-    // assert_invariant(height == metadata.height);
-    // assert_invariant(format == metadata.filamentFormat);
-    // assert_invariant(fvkutils::getVkFormat(format) == metadata.format);
-
-    VkImage vkimg;
-    VkDeviceMemory deviceMemory;
-    std::tie(vkimg, deviceMemory) = mPlatform->createVkImageFromExternal(externalImage);
-
-    VkSamplerYcbcrConversion conversion =
-            mExternalImageManager.getVkSamplerYcbcrConversion(metadata);
-
-    auto texture = resource_ptr<VulkanTexture>::make(&mResourceManager, th, mContext,
-            mPlatform->getDevice(), mAllocator, &mResourceManager, &mCommands, vkimg, deviceMemory,
-            metadata.format, conversion, metadata.samples, metadata.width, metadata.height,
-            metadata.layers, usage, mStagePool);
-
-    if (conversion != VK_NULL_HANDLE) {
-        mExternalImageManager.addExternallySampledTexture(texture, externalImage);
+    const auto& metadata = mPlatform->getExternalImageMetadata(externalImage);
+    if (metadata.isProtected) {
+        usage |= backend::TextureUsage::PROTECTED;
    }

-    // Unlike uploaded textures or swapchains, we need to explicit transition this
-    // texture into the read layout.
-    auto& commands = mCommands.get();
-    texture->transitionLayout(&commands, texture->getPrimaryViewRange(), VulkanLayout::READ_ONLY);
+    VkImageUsageFlags vkUsage = metadata.usage;
+    if (any(usage & TextureUsage::BLIT_SRC)) {
+        vkUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    }
+
+    if (any(usage & (TextureUsage::BLIT_DST & TextureUsage::UPLOADABLE))) {
+        vkUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    }
+
+    assert_invariant(width == metadata.width);
+    assert_invariant(height == metadata.height);
+    assert_invariant(fvkutils::getVkFormat(format) == metadata.format);
+
+    VkMemoryPropertyFlags const requiredMemoryFlags = any(usage & TextureUsage::UPLOADABLE)
+                                                              ? VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
+                                                              : VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+    uint32_t const memoryTypeIndex =
+            mContext.selectMemoryType(metadata.memoryTypeBits, requiredMemoryFlags);
+    FILAMENT_CHECK_POSTCONDITION(memoryTypeIndex != VK_MAX_MEMORY_TYPES)
+            << "failed to find a valid memory type for external image memory.";
+
+    const auto& data =
+            mPlatform->createExternalImageData(externalImage, metadata, memoryTypeIndex, vkUsage);
+
+    auto texture = resource_ptr<VulkanTexture>::make(&mResourceManager, th, mPlatform->getDevice(),
+            mAllocator, &mResourceManager, &mCommands, data.first, data.second, metadata.format,
+            metadata.samples, metadata.width, metadata.height, metadata.layerCount, usage,
+            mStagePool);

    texture.inc();
 }
@@ -612,14 +597,13 @@ void VulkanDriver::createTextureExternalImageR(Handle<HwTexture> th, backend::Sa
        backend::TextureFormat format, uint32_t width, uint32_t height, backend::TextureUsage usage,
        void* externalImage) {
    FVK_SYSTRACE_SCOPE();
-    assert_invariant(false && "Not supported in Vulkan backend");
+
    // not supported in this backend
 }

 void VulkanDriver::createTextureExternalImagePlaneR(Handle<HwTexture> th,
        backend::TextureFormat format, uint32_t width, uint32_t height, backend::TextureUsage usage,
        void* image, uint32_t plane) {
-    assert_invariant(false && "Not supported in Vulkan backend");
 }

 void VulkanDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
@@ -627,7 +611,6 @@ void VulkanDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
        TextureFormat format, uint8_t samples, uint32_t w, uint32_t h, uint32_t depth,
        TextureUsage usage) {
    // not supported in this backend
-    assert_invariant(false && "Not supported in Vulkan backend");
 }

 void VulkanDriver::destroyTexture(Handle<HwTexture> th) {
@@ -636,8 +619,6 @@ void VulkanDriver::destroyTexture(Handle<HwTexture> th) {
    }
    auto texture = resource_ptr<VulkanTexture>::cast(&mResourceManager, th);
    texture.dec();
-
-    mExternalImageManager.removeExternallySampledTexture(texture);
 }

 void VulkanDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {
@@ -806,11 +787,6 @@ void VulkanDriver::createDescriptorSetR(Handle<HwDescriptorSet> dsh,
            fvkmemory::resource_ptr<VulkanDescriptorSetLayout>::cast(&mResourceManager, dslh);
    auto set = mDescriptorSetCache.createSet(dsh, layout);
    set.inc();
-
-    if (layout->hasExternalSamplers()) {
-        mAppState.hasExternalSamplerLayouts = true;
-        mExternalImageManager.addDescriptorSet(layout, set);
-    }
 }

 Handle<HwVertexBufferInfo> VulkanDriver::createVertexBufferInfoS() noexcept {
@@ -930,19 +906,11 @@ void VulkanDriver::destroyTimerQuery(Handle<HwTimerQuery> tqh) {
 void VulkanDriver::destroyDescriptorSetLayout(Handle<HwDescriptorSetLayout> dslh) {
    auto layout = resource_ptr<VulkanDescriptorSetLayout>::cast(&mResourceManager, dslh);
    layout.dec();
-
-    if (layout->hasExternalSamplers()) {
-        mExternalImageManager.removeDescriptorSetLayout(layout);
-    }
 }

 void VulkanDriver::destroyDescriptorSet(Handle<HwDescriptorSet> dsh) {
    auto set = resource_ptr<VulkanDescriptorSet>::cast(&mResourceManager, dsh);
    set.dec();
-
-    if (mAppState.hasExternalSamplers()) {
-        mExternalImageManager.removeDescriptorSet(set);
-    }
 }

 Handle<HwStream> VulkanDriver::createStreamNative(void* nativeStream) {
@@ -1503,6 +1471,7 @@ void VulkanDriver::endRenderPass(int) {
    // pipeline barrier between framebuffer writes and shader reads.
    rt->emitBarriersEndRenderPass(*mCurrentRenderPass.commandBuffer);

+    mRenderPassFboInfo = {};
    mCurrentRenderPass.renderTarget = {};
    mCurrentRenderPass.renderPass = VK_NULL_HANDLE;

@@ -1562,10 +1531,10 @@ void VulkanDriver::commit(Handle<HwSwapChain> sch) {

 void VulkanDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
        backend::PushConstantVariant value) {
-    assert_invariant(mPipelineState.program && "Expect a program when writing to push constants");
+    assert_invariant(mBoundPipeline.program && "Expect a program when writing to push constants");
    assert_invariant(mCurrentRenderPass.commandBuffer && "Should be called within a renderpass");
-    mPipelineState.program->writePushConstant(mCurrentRenderPass.commandBuffer->buffer(),
-            mPipelineState.pipelineLayout, stage, index, value);
+    mBoundPipeline.program->writePushConstant(mCurrentRenderPass.commandBuffer->buffer(),
+            mBoundPipeline.pipelineLayout, stage, index, value);
 }

 void VulkanDriver::insertEventMarker(char const* string) {
@@ -1744,27 +1713,6 @@ void VulkanDriver::blitDEPRECATED(TargetBufferFlags buffers,
 }

 void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {
-    // We need to determine whether to delay bindning until draw().
-    mPipelineState.bindInDraw.first = false;
-    if (mAppState.hasExternalSamplers()) {
-        auto& layouts = pipelineState.pipelineLayout.setLayout;
-        auto haveExternalSamplers = [&](auto hwHandle) {
-            if (!hwHandle) {
-                return false;
-            }
-            auto layout =
-                    resource_ptr<VulkanDescriptorSetLayout>::cast(&mResourceManager, hwHandle);
-            return layout->hasExternalSamplers();
-        };
-        if (std::any_of(layouts.begin(), layouts.end(), haveExternalSamplers)) {
-            mPipelineState.bindInDraw = { true, pipelineState };
-            return;
-        }
-    }
-    bindPipelineImpl(pipelineState);
-}
-
-void VulkanDriver::bindPipelineImpl(PipelineState const& pipelineState) {
    FVK_SYSTRACE_SCOPE();
    auto commands = mCurrentRenderPass.commandBuffer;
    auto vbi = resource_ptr<VulkanVertexBufferInfo>::cast(&mResourceManager,
@@ -1833,11 +1781,10 @@ void VulkanDriver::bindPipelineImpl(PipelineState const& pipelineState) {

    constexpr uint8_t descriptorSetMaskTable[4] = {0x1, 0x3, 0x7, 0xF};

-    mPipelineState = {
+    mBoundPipeline = {
        .program = program,
        .pipelineLayout = pipelineLayout,
        .descriptorSetMask = fvkutils::DescriptorSetMask(descriptorSetMaskTable[layoutCount]),
-        .bindInDraw = {false, {}},
    };

    mPipelineCache.bindLayout(pipelineLayout);
@@ -1884,24 +1831,14 @@ void VulkanDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
    FVK_SYSTRACE_SCOPE();
    VkCommandBuffer cmdbuffer = mCurrentRenderPass.commandBuffer->buffer();

-    if (mAppState.hasExternalSamplers()) {
-        auto const& [bindInDraw, pipelineSt] = mPipelineState.bindInDraw;
-        bool const hasUpdated =
-                mExternalImageManager.prepareBindSets(mDescriptorSetCache.getBoundSets());
-        if (bindInDraw || hasUpdated) {
-            bindPipelineImpl(pipelineSt);
-        }
-        mPipelineState.bindInDraw.first = false;
-    }
-
    mDescriptorSetCache.commit(mCurrentRenderPass.commandBuffer,
-            mPipelineState.pipelineLayout,
-            mPipelineState.descriptorSetMask);
+            mBoundPipeline.pipelineLayout,
+            mBoundPipeline.descriptorSetMask);

    // Finally, make the actual draw call. TODO: support subranges
-    uint32_t const firstIndex = indexOffset;
-    constexpr int32_t vertexOffset = 0;
-    constexpr uint32_t firstInstId = 0;
+    const uint32_t firstIndex = indexOffset;
+    const int32_t vertexOffset = 0;
+    const uint32_t firstInstId = 0;

    vkCmdDrawIndexed(cmdbuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstId);
 }
@@ -27,10 +27,8 @@
 #include "VulkanSamplerCache.h"
 #include "VulkanStagePool.h"
 #include "VulkanQueryManager.h"
-#include "VulkanYcbcrConversionCache.h"
 #include "vulkan/VulkanDescriptorSetCache.h"
 #include "vulkan/VulkanDescriptorSetLayoutCache.h"
-#include "vulkan/VulkanExternalImageManager.h"
 #include "vulkan/VulkanPipelineLayoutCache.h"
 #include "vulkan/memory/ResourceManager.h"
 #include "vulkan/memory/ResourcePointer.h"
@@ -120,7 +118,6 @@ private:

 private:
    void collectGarbage();
-    void bindPipelineImpl(PipelineState const& pipelineState);

    VulkanPlatform* mPlatform = nullptr;
    fvkmemory::ResourceManager mResourceManager;
@@ -138,36 +135,27 @@ private:
    VulkanPipelineCache mPipelineCache;
    VulkanStagePool mStagePool;
    VulkanFboCache mFramebufferCache;
-    VulkanYcbcrConversionCache mYcbcrConversionCache;
    VulkanSamplerCache mSamplerCache;
    VulkanBlitter mBlitter;
    VulkanReadPixels mReadPixels;
    VulkanDescriptorSetLayoutCache mDescriptorSetLayoutCache;
    VulkanDescriptorSetCache mDescriptorSetCache;
    VulkanQueryManager mQueryManager;
-    VulkanExternalImageManager mExternalImageManager;

    // This is necessary for us to write to push constants after binding a pipeline.
    struct {
-        // For push constant
        resource_ptr<VulkanProgram> program;
-        // For push commiting dynamic ubos in draw()
        VkPipelineLayout pipelineLayout;
        fvkutils::DescriptorSetMask descriptorSetMask;
+    } mBoundPipeline = {};

-        std::pair<bool, PipelineState> bindInDraw = {false, {}};
-    } mPipelineState = {};
-
+    // We need to store information about a render pass to enable better barriers at the end of a
+    // renderpass.
    struct {
-        // This tracks whether the app has seen external samplers bound to a the descriptor set.
-        // This will force bindPipeline to take a slow path.
-        bool hasExternalSamplerLayouts = false;
-        bool hasBoundExternalImages = false;
-
-        bool hasExternalSamplers() const noexcept {
-            return hasExternalSamplerLayouts && hasBoundExternalImages;
-        }
-    } mAppState;
+        using AttachmentArray =
+                fvkutils::StaticVector<VulkanAttachment, MAX_RENDERTARGET_ATTACHMENT_TEXTURES>;
+        AttachmentArray attachments;
+    } mRenderPassFboInfo = {};

    bool const mIsSRGBSwapChainSupported;
    backend::StereoscopicType const mStereoscopicType;
@@ -1,280 +0,0 @@
-/*
- * 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 "VulkanExternalImageManager.h"
-
-#include "VulkanDescriptorSetCache.h"
-#include "VulkanDescriptorSetLayoutCache.h"
-#include "VulkanSamplerCache.h"
-#include "VulkanYcbcrConversionCache.h"
-#include "vulkan/memory/ResourcePointer.h"
-#include "vulkan/utils/Conversion.h"
-
-#include <backend/platforms/VulkanPlatform.h>
-
-#include <algorithm>
-
-namespace filament::backend {
-
-namespace {
-
-template<typename T>
-void erase(std::vector<T>& v, std::function<bool(T const&)> f) {
-    auto newEnd = std::remove_if(v.begin(), v.end(), f);
-    v.erase(newEnd, v.end());
-}
-
-} // anonymous
-
-VulkanExternalImageManager::VulkanExternalImageManager(VulkanPlatform* platform,
-        VulkanSamplerCache* samplerCache, VulkanYcbcrConversionCache* ycbcrConversionCache,
-        VulkanDescriptorSetCache* setCache, VulkanDescriptorSetLayoutCache* layoutCache)
-    : mPlatform(platform),
-      mSamplerCache(samplerCache),
-      mYcbcrConversionCache(ycbcrConversionCache),
-      mDescriptorSetCache(setCache),
-      mDescriptorSetLayoutCache(layoutCache) {
-}
-
-VulkanExternalImageManager::~VulkanExternalImageManager() = default;
-
-void VulkanExternalImageManager::terminate() {
-    mSetAndLayouts.clear();
-    mSetBindings.clear();
-    mImages.clear();
-}
-
-void VulkanExternalImageManager::onBeginFrame() {
-    std::for_each(mImages.begin(), mImages.end(), [](ImageData& image) {
-        image.hasBeenValidated = false;
-    });
-}
-
-bool VulkanExternalImageManager::prepareBindSets(SetArray const& sets) {
-    bool hasUpdated = false;
-    for (auto set: sets) {
-        if (!set) {
-            continue;
-        }
-        if (auto itr = std::find_if(mSetAndLayouts.begin(), mSetAndLayouts.end(),
-                    [&](auto const& setAndLayout) { return setAndLayout.first == set; });
-                itr != mSetAndLayouts.end()) {
-            hasUpdated = updateSetAndLayout(itr->first, itr->second) || hasUpdated;
-        }
-    }
-    return hasUpdated;
-}
-
-bool VulkanExternalImageManager::updateSetAndLayout(
-        fvkmemory::resource_ptr<VulkanDescriptorSet> set,
-        fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout) {
-    auto findImage = [&](fvkmemory::resource_ptr<VulkanTexture> texture) -> ImageData* {
-        auto itr = std::find_if(mImages.begin(), mImages.end(), [&](ImageData const& data) {
-            return data.ptr == texture;
-        });
-        assert_invariant(itr != mImages.end());
-        return &(*itr);
-    };
-
-    //std::vector<std::pair<uint8_t, ImageData*>> externalImages;
-    utils::FixedCapacityVector<std::pair<uint8_t, VkSampler>> samplerAndBindings;
-    samplerAndBindings.reserve(MAX_SAMPLER_COUNT);
-
-    bool hasImageUpdates = false;
-    for (auto& bindingInfo : mSetBindings) {
-        if (bindingInfo.set != set) {
-            continue;
-        }
-        auto imageData = findImage(bindingInfo.image);
-        hasImageUpdates = updateImage(imageData) || hasImageUpdates;
-
-        auto samplerParams = bindingInfo.samplerParams;
-        // according to spec, these must match chromaFilter
-        // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCreateInfo.html#VUID-VkSamplerCreateInfo-minFilter-01645
-        samplerParams.filterMag = SamplerMagFilter::NEAREST;
-        samplerParams.filterMin = SamplerMinFilter::NEAREST;
-
-        auto sampler = mSamplerCache->getSampler({
-            .sampler = samplerParams,
-            .conversion = imageData->conversion,
-        });
-        samplerAndBindings.push_back({ bindingInfo.binding, sampler });
-    }
-
-    // We need to sort by binding number
-    std::sort(samplerAndBindings.begin(), samplerAndBindings.end());
-
-    utils::FixedCapacityVector<VkSampler> outSamplers;
-    outSamplers.reserve(MAX_SAMPLER_COUNT);
-    std::for_each(samplerAndBindings.begin(), samplerAndBindings.end(),
-            [&](auto const& b) { outSamplers.push_back(b.second); });
-
-    VkDescriptorSetLayout const oldLayout = layout->getVkLayout();
-    VkDescriptorSetLayout const newLayout =
-            mDescriptorSetLayoutCache->getVkLayout(layout->bitmask, outSamplers);
-    bool const hasLayoutUpdate = oldLayout != newLayout;
-    layout->setVkLayout(newLayout);
-
-    assert_invariant(
-            (!hasImageUpdates && !hasLayoutUpdate) ||
-            (hasImageUpdates && hasLayoutUpdate));
-
-    if (!hasLayoutUpdate) {
-        return false;
-    }
-
-    auto foldBitsInHalf = [](auto bitset) {
-        constexpr size_t BITMASK_LOWER_BITS_LEN = sizeof(bitset) * 4;
-        decltype(bitset) outBitset;
-        bitset.forEachSetBit([&](size_t index) { outBitset.set(index % BITMASK_LOWER_BITS_LEN); });
-        return outBitset;
-    };
-    // We need to build a new descriptor set from the new layout
-    VkDescriptorSet oldSet = set->getVkSet();
-    VkDescriptorSet newSet = mDescriptorSetCache->getVkSet(layout);
-
-    using Bitmask = fvkutils::UniformBufferBitmask;
-    static_assert(sizeof(Bitmask) * 8 == fvkutils::MAX_DESCRIPTOR_SET_BITMASK_BITS);
-
-    auto const ubo = layout->bitmask.ubo | layout->bitmask.dynamicUbo;
-    auto const samplers = layout->bitmask.sampler & (~layout->bitmask.externalSampler);
-
-    // each bitmask denotes a binding index, and separated into two stages - vertex and buffer
-    // We fold the two stages into just the lower half of the bits to denote a combined set of
-    // bindings.
-    Bitmask const copyBindings = foldBitsInHalf(ubo | samplers);
-
-    // TODO: fix the size for better memory
-    std::vector<VkCopyDescriptorSet> copies;
-    copyBindings.forEachSetBit([&](size_t index) {
-        copies.push_back({
-            .sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET,
-            .srcSet = oldSet,
-            .srcBinding = (uint32_t) index,
-            .dstSet = newSet,
-            .dstBinding = (uint32_t) index,
-            .descriptorCount = 1,
-        });
-    });
-    vkUpdateDescriptorSets(mPlatform->getDevice(), 0, nullptr, copies.size(), copies.data());
-
-    set->setVkSet(newSet);
-
-    // We need to release the vkset, which is no longer used, back into the pool.
-    mDescriptorSetCache->manualRecyle(layout->count, oldLayout, oldSet);
-
-    // We need to update the external samplers in the set
-    for (auto& bindingInfo: mSetBindings) {
-        if (bindingInfo.set != set) {
-            continue;
-        }
-        mDescriptorSetCache->updateSampler(set, bindingInfo.binding, bindingInfo.image,
-                VK_NULL_HANDLE);
-    }
-    return true;
-}
-
-VkSamplerYcbcrConversion VulkanExternalImageManager::getVkSamplerYcbcrConversion(
-        VulkanPlatform::ExternalImageMetadata const& metadata) {
-    // This external image does not require external sampler (YUV conversion).
-    if (metadata.externalFormat == 0) {
-        return VK_NULL_HANDLE;
-    }
-    VulkanYcbcrConversionCache::Params ycbcrParams = {
-        .conversion = {
-            .ycbcrModel = fvkutils::getYcbcrModelConversionFilament(metadata.ycbcrModel),
-            .r = fvkutils::getSwizzleFilament(metadata.ycbcrConversionComponents.r, 0),
-            .g = fvkutils::getSwizzleFilament(metadata.ycbcrConversionComponents.g, 1),
-            .b = fvkutils::getSwizzleFilament(metadata.ycbcrConversionComponents.b, 2),
-            .a = fvkutils::getSwizzleFilament(metadata.ycbcrConversionComponents.a, 3),
-            .ycbcrRange = fvkutils::getYcbcrRangeFilament(metadata.ycbcrRange),
-            .xChromaOffset = fvkutils::getChromaLocationFilament(metadata.xChromaOffset),
-            .yChromaOffset = fvkutils::getChromaLocationFilament(metadata.yChromaOffset),
-
-            // Unclear where to get the chromaFilter, we just assume it's nearest.
-            .chromaFilter = SamplerMagFilter::NEAREST,
-        },
-        .format = metadata.filamentFormat,
-        .externalFormat = metadata.externalFormat,
-    };
-    return mYcbcrConversionCache->getConversion(ycbcrParams);
-}
-
-bool VulkanExternalImageManager::updateImage(ImageData* image) {
-    if (image->hasBeenValidated) {
-        return false;
-    }
-    image->hasBeenValidated = true;
-
-    auto metadata = mPlatform->extractExternalImageMetadata(image->platformHandle);
-    auto vkYcbcr = getVkSamplerYcbcrConversion(metadata);
-    if (vkYcbcr == image->conversion) {
-        return false;
-    }
-
-    image->ptr->setYcbcrConversion(vkYcbcr, metadata.externalFormat != 0);
-    image->conversion = vkYcbcr;
-    return true;
-}
-
-void VulkanExternalImageManager::addDescriptorSet(
-        fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout,
-        fvkmemory::resource_ptr<VulkanDescriptorSet> set) {
-    mSetAndLayouts.push_back({set, layout});
-}
-
-void VulkanExternalImageManager::removeDescriptorSet(
-        fvkmemory::resource_ptr<VulkanDescriptorSet> inSet) {
-    erase<SetAndLayout>(mSetAndLayouts,
-            [&](auto const& setLayout) { return (setLayout.first == inSet); });
-    erase<SetBindingInfo>(mSetBindings,
-            [&](auto const& bindingInfo) { return (bindingInfo.set == inSet); });
-}
-
-void VulkanExternalImageManager::removeDescriptorSetLayout(
-        fvkmemory::resource_ptr<VulkanDescriptorSetLayout> inLayout) {
-    erase<SetAndLayout>(mSetAndLayouts,
-            [&](auto const& setLayout) { return (setLayout.second == inLayout); });
-}
-
-void VulkanExternalImageManager::bindExternallySampledTexture(
-        fvkmemory::resource_ptr<VulkanDescriptorSet> set, uint8_t bindingPoint,
-        fvkmemory::resource_ptr<VulkanTexture> image, SamplerParams samplerParams) {
-    // Should we do duplicate validation here?
-    mSetBindings.push_back({ bindingPoint, image, set, samplerParams });
-}
-
-void VulkanExternalImageManager::addExternallySampledTexture(
-        fvkmemory::resource_ptr<VulkanTexture> image,
-        Platform::ExternalImageHandleRef platformHandleRef) {
-    mImages.push_back({ image, platformHandleRef, false });
-}
-
-void VulkanExternalImageManager::removeExternallySampledTexture(
-        fvkmemory::resource_ptr<VulkanTexture> image) {
-    erase<SetBindingInfo>(mSetBindings,
-            [&](auto const& bindingInfo) { return (bindingInfo.image == image); });
-    erase<ImageData>(mImages, [&](auto const& imageData) { return imageData.ptr == image; });
-}
-
-bool VulkanExternalImageManager::isExternallySampledTexture(
-        fvkmemory::resource_ptr<VulkanTexture> image) const {
-    return std::find_if(mImages.begin(), mImages.end(),
-                   [&](auto const& imageData) { return imageData.ptr == image; }) != mImages.end();
-}
-
-
-} // namesapce filament::backend
@@ -1,115 +0,0 @@
-/*
- * 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_CACHING_VULKANEXTERNALIMAGEMANAGER_H
-#define TNT_FILAMENT_BACKEND_CACHING_VULKANEXTERNALIMAGEMANAGER_H
-
-#include "VulkanHandles.h"
-
-#include <backend/DriverEnums.h>
-
-#include <array>
-#include <vector>
-
-namespace filament::backend {
-
-class VulkanYcbcrConversionCache;
-class VulkanSamplerCache;
-class VulkanDescriptorSetLayoutCache;
-class VulkanDescriptorSetCache;
-
-// Manages the logic of external images and their quirks wrt Vulikan.
-class VulkanExternalImageManager {
-public:
-
-    VulkanExternalImageManager(
-            VulkanPlatform* platform,
-            VulkanSamplerCache* samplerCache,
-            VulkanYcbcrConversionCache* ycbcrConversionCache,
-            VulkanDescriptorSetCache* setCache,
-            VulkanDescriptorSetLayoutCache* layoutCache);
-
-    ~VulkanExternalImageManager();
-
-    void terminate();
-
-    void onBeginFrame();
-
-    using SetArray = std::array<fvkmemory::resource_ptr<VulkanDescriptorSet>,
-            VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;
-
-    // This sets the currently bound layouts objects for the pipeline
-    bool prepareBindSets(SetArray const& layouts);
-
-    void addDescriptorSet(fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout,
-            fvkmemory::resource_ptr<VulkanDescriptorSet> set);
-
-    void removeDescriptorSetLayout(fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout);
-
-    void removeDescriptorSet(fvkmemory::resource_ptr<VulkanDescriptorSet> set);
-
-    void bindExternallySampledTexture(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
-            uint8_t bindingPoint, fvkmemory::resource_ptr<VulkanTexture> image,
-            SamplerParams samplerParams);
-
-    void addExternallySampledTexture(fvkmemory::resource_ptr<VulkanTexture> image,
-            Platform::ExternalImageHandleRef platformHandleRef);
-
-    void removeExternallySampledTexture(fvkmemory::resource_ptr<VulkanTexture> image);
-
-    bool isExternallySampledTexture(fvkmemory::resource_ptr<VulkanTexture> image) const;
-
-    VkSamplerYcbcrConversion getVkSamplerYcbcrConversion(
-            VulkanPlatform::ExternalImageMetadata const& metadata);
-
-private:
-
-    struct ImageData {
-        fvkmemory::resource_ptr<VulkanTexture> ptr;
-        Platform::ExternalImageHandle platformHandle;
-        bool hasBeenValidated = false; // indicates whether the image has been validated *this frame*
-        VkSamplerYcbcrConversion conversion = VK_NULL_HANDLE;
-    };
-
-    bool updateSetAndLayout(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
-            fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout);
-    bool updateImage(ImageData* imageData);
-
-    VulkanPlatform* mPlatform;
-    VulkanSamplerCache* mSamplerCache;
-    VulkanYcbcrConversionCache* mYcbcrConversionCache;
-    VulkanDescriptorSetCache* mDescriptorSetCache;
-    VulkanDescriptorSetLayoutCache* mDescriptorSetLayoutCache;
-
-    using SetAndLayout = std::pair<fvkmemory::resource_ptr<VulkanDescriptorSet>,
-            fvkmemory::resource_ptr<VulkanDescriptorSetLayout>>;
-
-    struct SetBindingInfo {
-        uint8_t binding = 0;
-        fvkmemory::resource_ptr<VulkanTexture> image;
-        fvkmemory::resource_ptr<VulkanDescriptorSet> set;
-        SamplerParams samplerParams;
-    };
-
-    // Use vectors instead of hash maps because we only expect small number of entries.
-    std::vector<SetAndLayout> mSetAndLayouts;
-    std::vector<SetBindingInfo> mSetBindings;
-    std::vector<ImageData> mImages;
-};
-
-} // filament::backend
-
-#endif // TNT_FILAMENT_BACKEND_CACHING_VULKANEXTERNALIMAGEMANAGER_H
@@ -30,7 +30,6 @@

 #include <backend/platforms/VulkanPlatform.h>

-#include <utils/compiler.h> // UTILS_FALLTHROUGH
 #include <utils/Panic.h>    // ASSERT_POSTCONDITION

 using namespace bluevk;
@@ -90,9 +89,8 @@ BitmaskGroup fromBackendLayout(DescriptorSetLayout const& layout) {
                }
                break;
            }
+            // TODO: properly handle external sampler
            case DescriptorType::SAMPLER_EXTERNAL:
-                fromStageFlags(binding.stageFlags, binding.binding, mask.externalSampler);
-                UTILS_FALLTHROUGH;
            case DescriptorType::SAMPLER: {
                fromStageFlags(binding.stageFlags, binding.binding, mask.sampler);
                break;
@@ -66,21 +66,18 @@ struct VulkanDescriptorSetLayout : public HwDescriptorSetLayout, fvkmemory::Reso

    // The bitmask representation of a set layout.
    struct Bitmask {
+        // TODO: better utiltize the space below and use bitset instead.
        fvkutils::UniformBufferBitmask ubo;         // 8 bytes
        fvkutils::UniformBufferBitmask dynamicUbo;  // 8 bytes
        fvkutils::SamplerBitmask sampler;           // 8 bytes
        fvkutils::InputAttachmentBitmask inputAttachment; // 8 bytes

-        // This is a subset of the bitmask.sampler field.
-        fvkutils::SamplerBitmask externalSampler; // 8 bytes
-
        bool operator==(Bitmask const& right) const {
            return ubo == right.ubo && dynamicUbo == right.dynamicUbo && sampler == right.sampler &&
-                   inputAttachment == right.inputAttachment &&
-                   externalSampler == right.externalSampler;
+                   inputAttachment == right.inputAttachment;
        }
    };
-    static_assert(sizeof(Bitmask) == 40);
+    static_assert(sizeof(Bitmask) == 32);

    // This is a convenience struct to quickly check layout compatibility in terms of descriptor set
    // pools.
@@ -122,16 +119,10 @@ struct VulkanDescriptorSetLayout : public HwDescriptorSetLayout, fvkmemory::Reso

    VulkanDescriptorSetLayout(DescriptorSetLayout const& layout);

-    // Note that we don't destroy the vklayout. This is done by the layout cache.
    ~VulkanDescriptorSetLayout() = default;

-    VkDescriptorSetLayout const& getVkLayout() const noexcept { return mVkLayout; }
-
-    // It is possible to have the layout switch out due to AHardwarebuffer (external image) format
-    // changes.
-    void setVkLayout(VkDescriptorSetLayout vklayout) noexcept { mVkLayout = vklayout; }
-
-    bool hasExternalSamplers() const noexcept { return bitmask.externalSampler.count() > 0; }
+    VkDescriptorSetLayout getVkLayout() const { return mVkLayout; }
+    void setVkLayout(VkDescriptorSetLayout vklayout) { mVkLayout = vklayout; }

    Bitmask const bitmask;
    Count const count;
@@ -146,11 +137,12 @@ public:
    // can use to repackage the vk handle.
    using OnRecycle = std::function<void(VulkanDescriptorSet*)>;

-    VulkanDescriptorSet(
+    VulkanDescriptorSet(VkDescriptorSet rawSet,
            fvkutils::UniformBufferBitmask const& dynamicUboMask,
            uint8_t uniqueDynamicUboCount,
            OnRecycle&& onRecycleFn)
-        : dynamicUboMask(dynamicUboMask),
+        : vkSet(rawSet),
+          dynamicUboMask(dynamicUboMask),
          uniqueDynamicUboCount(uniqueDynamicUboCount),
          mOnRecycleFn(std::move(onRecycleFn)) {}

@@ -160,13 +152,6 @@ public:
        }
    }

-    VkDescriptorSet const& getVkSet() const noexcept {
-        return mVkSet;
-    }
-
-    // Note that the only case where you'd set it more than once is with external images/samplers.
-    void setVkSet(VkDescriptorSet vkset) noexcept { mVkSet = vkset; }
-
    void setOffsets(backend::DescriptorSetOffsetArray&& offsets) noexcept {
        mOffsets = std::move(offsets);
    }
@@ -178,11 +163,11 @@ public:
    void acquire(fvkmemory::resource_ptr<VulkanTexture> texture);
    void acquire(fvkmemory::resource_ptr<VulkanBufferObject> buffer);

+    VkDescriptorSet const vkSet;
    fvkutils::UniformBufferBitmask const dynamicUboMask;
    uint8_t const uniqueDynamicUboCount;

 private:
-    VkDescriptorSet mVkSet = VK_NULL_HANDLE;
    backend::DescriptorSetOffsetArray mOffsets;
    std::vector<fvkmemory::resource_ptr<fvkmemory::Resource>> mResources;
    OnRecycle mOnRecycleFn;
@@ -18,18 +18,24 @@
 #define TNT_FILAMENT_BACKEND_VULKANPIPELINECACHE_H

 #include "VulkanCommands.h"
+#include "VulkanMemory.h"

 #include <backend/DriverEnums.h>
 #include <backend/TargetBufferInfo.h>

+#include "backend/Program.h"
+
 #include <bluevk/BlueVK.h>

 #include <utils/bitset.h>
 #include <utils/compiler.h>
 #include <utils/Hash.h>

+#include <list>
 #include <tsl/robin_map.h>
 #include <type_traits>
+#include <vector>
+#include <unordered_map>

 namespace filament::backend {

@@ -14,11 +14,8 @@
 * limitations under the License.
 */

-#include "VulkanSamplerCache.h"
-
-#include "VulkanConstants.h"
+#include "vulkan/VulkanSamplerCache.h"
 #include "vulkan/utils/Conversion.h"
-#include "vulkan/vulkan_core.h"

 #include <utils/Panic.h>

@@ -29,48 +26,41 @@ namespace filament::backend {
 VulkanSamplerCache::VulkanSamplerCache(VkDevice device)
    : mDevice(device) {}

-VkSampler VulkanSamplerCache::getSampler(Params params) noexcept {
+VkSampler VulkanSamplerCache::getSampler(SamplerParams params) noexcept {
    auto iter = mCache.find(params);
    if (UTILS_LIKELY(iter != mCache.end())) {
        return iter->second;
    }
-    VkSamplerYcbcrConversionInfo ycbcrConversion = {
-        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
-        .conversion = params.conversion,
-    };
-
-    auto const& samplerParams = params.sampler;
-    VkSamplerCreateInfo samplerInfo{
+    VkSamplerCreateInfo samplerInfo {
        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
-        .pNext = params.conversion != VK_NULL_HANDLE ? &ycbcrConversion : VK_NULL_HANDLE,
-        .magFilter = fvkutils::getFilter(samplerParams.filterMag),
-        .minFilter = fvkutils::getFilter(samplerParams.filterMin),
-        .mipmapMode = fvkutils::getMipmapMode(samplerParams.filterMin),
-        .addressModeU = fvkutils::getWrapMode(samplerParams.wrapS),
-        .addressModeV = fvkutils::getWrapMode(samplerParams.wrapT),
-        .addressModeW = fvkutils::getWrapMode(samplerParams.wrapR),
-        .anisotropyEnable = samplerParams.anisotropyLog2 == 0 ? VK_FALSE : VK_TRUE,
-        .maxAnisotropy = (float) (1u << samplerParams.anisotropyLog2),
-        .compareEnable = fvkutils::getCompareEnable(samplerParams.compareMode),
-        .compareOp = fvkutils::getCompareOp(samplerParams.compareFunc),
+        .magFilter = fvkutils::getFilter(params.filterMag),
+        .minFilter = fvkutils::getFilter(params.filterMin),
+        .mipmapMode = fvkutils::getMipmapMode(params.filterMin),
+        .addressModeU = fvkutils::getWrapMode(params.wrapS),
+        .addressModeV = fvkutils::getWrapMode(params.wrapT),
+        .addressModeW = fvkutils::getWrapMode(params.wrapR),
+        .anisotropyEnable = params.anisotropyLog2 == 0 ? VK_FALSE : VK_TRUE,
+        .maxAnisotropy = (float)(1u << params.anisotropyLog2),
+        .compareEnable = fvkutils::getCompareEnable(params.compareMode),
+        .compareOp = fvkutils::getCompareOp(params.compareFunc),
        .minLod = 0.0f,
-        .maxLod = fvkutils::getMaxLod(samplerParams.filterMin),
+        .maxLod = fvkutils::getMaxLod(params.filterMin),
        .borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
-        .unnormalizedCoordinates = VK_FALSE,
+        .unnormalizedCoordinates = VK_FALSE
    };
    VkSampler sampler;
    VkResult result = vkCreateSampler(mDevice, &samplerInfo, VKALLOC, &sampler);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to create sampler."
                                                       << " error=" << static_cast<int32_t>(result);
-    mCache.insert({ params, sampler });
+    mCache.insert({params, sampler});
    return sampler;
 }

 void VulkanSamplerCache::terminate() noexcept {
-    for (auto pair: mCache) {
+    for (auto pair : mCache) {
        vkDestroySampler(mDevice, pair.second, VKALLOC);
    }
    mCache.clear();
 }

-}// namespace filament::backend
+} // namespace filament::backend
@@ -17,11 +17,8 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANSAMPLERCACHE_H
 #define TNT_FILAMENT_BACKEND_VULKANSAMPLERCACHE_H

-#include <backend/DriverEnums.h>
+#include "VulkanContext.h"

-#include <utils/Hash.h>
-
-#include <bluevk/BlueVK.h>
 #include <tsl/robin_map.h>

 namespace filament::backend {
@@ -29,28 +26,12 @@ namespace filament::backend {
 // Simple manager for VkSampler objects.
 class VulkanSamplerCache {
 public:
-    struct Params {
-        SamplerParams sampler = {};
-        uint32_t padding = 0;
-        VkSamplerYcbcrConversion conversion = VK_NULL_HANDLE;
-    };
-
-    static_assert(sizeof(Params) == 16);
-
    explicit VulkanSamplerCache(VkDevice device);
-    VkSampler getSampler(Params params) noexcept;
+    VkSampler getSampler(SamplerParams params) noexcept;
    void terminate() noexcept;
 private:
    VkDevice mDevice;
-
-    struct SamplerEqualTo {
-        bool operator()(Params lhs, Params rhs) const noexcept {
-            SamplerParams::EqualTo equal;
-            return equal(lhs.sampler, rhs.sampler) && lhs.conversion == rhs.conversion;
-        }
-    };
-    using SamplerHashFn = utils::hash::MurmurHashFn<Params>;
-    tsl::robin_map<Params, VkSampler, SamplerHashFn, SamplerEqualTo> mCache;
+    tsl::robin_map<SamplerParams, VkSampler, SamplerParams::Hasher, SamplerParams::EqualTo> mCache;
 };

 } // namespace filament::backend
@@ -32,7 +32,6 @@ VulkanSwapChain::VulkanSwapChain(VulkanPlatform* platform, VulkanContext const&
        VulkanCommands* commands, VulkanStagePool& stagePool, void* nativeWindow, uint64_t flags,
        VkExtent2D extent)
    : mPlatform(platform),
-      mContext(context),
      mResourceManager(resourceManager),
      mCommands(commands),
      mAllocator(allocator),
@@ -78,16 +77,16 @@ void VulkanSwapChain::update() {
    }
    for (auto const color: bundle.colors) {
        auto colorTexture = fvkmemory::resource_ptr<VulkanTexture>::construct(mResourceManager,
-                mContext, device, mAllocator, mResourceManager, mCommands, color, VK_NULL_HANDLE,
-                bundle.colorFormat, VK_NULL_HANDLE /*ycrcb */, 1, bundle.extent.width,
-                bundle.extent.height, bundle.layerCount, colorUsage, mStagePool);
+                device, mAllocator, mResourceManager, mCommands, color, VK_NULL_HANDLE,
+                bundle.colorFormat, 1, bundle.extent.width, bundle.extent.height, bundle.layerCount, colorUsage,
+                mStagePool);
        mColors.push_back(colorTexture);
    }

-    mDepth = fvkmemory::resource_ptr<VulkanTexture>::construct(mResourceManager, mContext, device,
-            mAllocator, mResourceManager, mCommands, bundle.depth, VK_NULL_HANDLE,
-            bundle.depthFormat, VK_NULL_HANDLE /*ycrcb */, 1, bundle.extent.width,
-            bundle.extent.height, bundle.layerCount, depthUsage, mStagePool);
+    mDepth = fvkmemory::resource_ptr<VulkanTexture>::construct(mResourceManager, device,
+        mAllocator, mResourceManager, mCommands, bundle.depth, VK_NULL_HANDLE,
+        bundle.depthFormat, 1, bundle.extent.width, bundle.extent.height, bundle.layerCount, depthUsage,
+        mStagePool);

    mExtent = bundle.extent;
    mLayerCount = bundle.layerCount;
@@ -108,6 +107,11 @@ void VulkanSwapChain::present() {

    mCommands->flush();

+    // call the image ready wait function
+    if (mExplicitImageReadyWait != nullptr) {
+        mExplicitImageReadyWait(swapChain);
+    }
+
    // We only present if it is not headless. No-op for headless.
    if (!mHeadless) {
        VkSemaphore const finishedDrawing = mCommands->acquireFinishedSignal();
@@ -141,6 +145,7 @@ void VulkanSwapChain::acquire(bool& resized) {
    VulkanPlatform::ImageSyncData imageSyncData;
    VkResult const result = mPlatform->acquire(swapChain, &imageSyncData);
    mCurrentSwapIndex = imageSyncData.imageIndex;
+    mExplicitImageReadyWait = imageSyncData.explicitImageReadyWait;
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR)
            << "Cannot acquire in swapchain. error=" << static_cast<int32_t>(result);
    if (imageSyncData.imageReadySemaphore != VK_NULL_HANDLE) {
@@ -19,7 +19,6 @@

 #include "DriverBase.h"

-#include "VulkanConstants.h"
 #include "VulkanContext.h"
 #include "VulkanTexture.h"
 #include "vulkan/memory/Resource.h"
@@ -29,6 +28,7 @@
 #include <bluevk/BlueVK.h>
 #include <utils/FixedCapacityVector.h>

+#include <memory>

 using namespace bluevk;

@@ -49,9 +49,7 @@ struct VulkanSwapChain : public HwSwapChain, fvkmemory::Resource {

    void present();

-    // Acquire a new image from the swapchain. If the image is not available it would wait until it
-    // is.
-    void acquire(bool& resized);
+    void acquire(bool& reized);

    fvkmemory::resource_ptr<VulkanTexture> getCurrentColor() const noexcept {
        uint32_t const imageIndex = mCurrentSwapIndex;
@@ -85,7 +83,6 @@ private:
    void update();

    VulkanPlatform* mPlatform;
-    VulkanContext const& mContext;
    fvkmemory::ResourceManager* mResourceManager;
    VulkanCommands* mCommands;
    VmaAllocator mAllocator;
@@ -101,6 +98,7 @@ private:
    VkExtent2D mExtent;
    uint32_t mLayerCount;
    uint32_t mCurrentSwapIndex;
+    std::function<void(Platform::SwapChain* handle)> mExplicitImageReadyWait = nullptr;
    bool mAcquired;
    bool mIsFirstRenderPass;
 };
@@ -15,7 +15,6 @@
 */

 #include "VulkanCommands.h"
-#include "VulkanContext.h"
 #include "VulkanMemory.h"
 #include "VulkanTexture.h"
 #include "vulkan/memory/ResourcePointer.h"
@@ -55,6 +54,7 @@ VkComponentMapping composeSwizzle(VkComponentMapping const& prev, VkComponentMap
        VK_COMPONENT_SWIZZLE_B,
        VK_COMPONENT_SWIZZLE_A,
    };
+
    auto const compose = [](VkComponentMapping const& prev,
                                 VkComponentMapping const& next) -> VkComponentMapping {
        VkComponentSwizzle vals[4] = { next.r, next.g, next.b, next.a };
@@ -151,152 +151,35 @@ uint8_t getLayerCountFromDepth(uint32_t const depth) {
    return getLayerCount(getSamplerTypeFromDepth(depth), depth);
 }

-VkImageUsageFlags getUsage(VulkanContext const& context, uint8_t samples,
-        VkPhysicalDevice physicalDevice, VkFormat vkFormat, TextureUsage tusage) {
-    VkImageUsageFlags usage = {};
-    if (any(tusage & TextureUsage::BLIT_SRC)) {
-        usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-    }
-    if (any(tusage & TextureUsage::BLIT_DST)) {
-        usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-    }
-
-    // Determine if we can use the transient usage flag combined with lazily allocated memory.
-    const bool useTransientAttachment =
-            // Lazily allocated memory is available.
-            context.isLazilyAllocatedMemorySupported() &&
-            // Usage consists of attachment flags only.
-            none(tusage & ~TextureUsage::ALL_ATTACHMENTS) &&
-            // Usage contains at least one attachment flag.
-            any(tusage & TextureUsage::ALL_ATTACHMENTS) &&
-            // Depth resolve cannot use transient attachment because it uses a custom shader.
-            // TODO: see VulkanDriver::isDepthStencilResolveSupported() to know when to remove this
-            // restriction.
-            // Note that the custom shader does not resolve stencil. We do need to move to vk 1.2
-            // and above to be able to support stencil resolve (along with depth).
-            !(any(tusage & TextureUsage::DEPTH_ATTACHMENT) && samples > 1);
-
-    const VkImageUsageFlags transientFlag =
-       useTransientAttachment ? VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT : 0U;
-
-    if (any(tusage & TextureUsage::SAMPLEABLE)) {
-
-#if FVK_ENABLED(FVK_DEBUG_TEXTURE)
-        if (physicalDevice != VK_NULL_HANDLE) {
-            // Validate that the format is actually sampleable.
-            VkFormatProperties props;
-            vkGetPhysicalDeviceFormatProperties(physicalDevice, vkFormat, &props);
-            if (!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
-                FVK_LOGW << "Texture usage is SAMPLEABLE but format " << mState->mVkFormat << " is not "
-                        "sampleable with optimal tiling." << utils::io::endl;
-            }
-        }
-#endif
-
-        usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
-    }
-    if (any(tusage & TextureUsage::COLOR_ATTACHMENT)) {
-        usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | transientFlag;
-        if (any(tusage & TextureUsage::SUBPASS_INPUT)) {
-            usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
-        }
-    }
-    if (any(tusage & TextureUsage::STENCIL_ATTACHMENT)) {
-        usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | transientFlag;
-    }
-    if (any(tusage & TextureUsage::UPLOADABLE)) {
-        usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-    }
-    if (any(tusage & TextureUsage::DEPTH_ATTACHMENT)) {
-        usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | transientFlag;
-
-        // Depth resolves uses a custom shader and therefore needs to be sampleable.
-        if (samples > 1) {
-            usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
-        }
-    }
-    return usage;
-}
-
 } // anonymous namespace

-VulkanTextureState::VulkanTextureState(VulkanStagePool& stagePool, VulkanCommands* commands,
-        VmaAllocator allocator, VkDevice device, VkImage image, VkDeviceMemory deviceMemory,
-        VkFormat format, VkImageViewType viewType, uint8_t levels, uint8_t layerCount,
-        VkSamplerYcbcrConversion ycbcrConversion, bool isExternalFormat, VkImageUsageFlags usage,
+VulkanTextureState::VulkanTextureState(VkDevice device, VmaAllocator allocator,
+        VulkanCommands* commands, VulkanStagePool& stagePool, VkFormat format,
+        VkImageViewType viewType, uint8_t levels, uint8_t layerCount, VulkanLayout defaultLayout,
        bool isProtected)
-    : mStagePool(stagePool),
-      mCommands(commands),
-      mAllocator(allocator),
-      mDevice(device),
-      mTextureImage(image),
-      mTextureImageMemory(deviceMemory),
-      mVkFormat(format),
+    : mVkFormat(format),
      mViewType(viewType),
-      mFullViewRange{ fvkutils::getImageAspect(format), 0, levels, 0, layerCount },
-      mYcbcr{ ycbcrConversion, isExternalFormat },
-      mDefaultLayout(getDefaultLayoutImpl(usage)),
-      mUsage(usage),
-      mIsProtected(isProtected) {}
+      mFullViewRange{fvkutils::getImageAspect(format), 0, levels, 0, layerCount},
+      mDefaultLayout(defaultLayout),
+      mIsProtected(isProtected),
+      mStagePool(stagePool),
+      mDevice(device),
+      mAllocator(allocator),
+      mCommands(commands),
+      mIsTransientAttachment(false) {}

-VulkanTextureState::~VulkanTextureState() {
-    if (mTextureImageMemory != VK_NULL_HANDLE) {
-        vkDestroyImage(mDevice, mTextureImage, VKALLOC);
-        vkFreeMemory(mDevice, mTextureImageMemory, VKALLOC);
-    }
-    clearCachedImageViews();
-}
-
-void VulkanTextureState::clearCachedImageViews() noexcept {
-    for (auto entry: mCachedImageViews) {
-        vkDestroyImageView(mDevice, entry.second, VKALLOC);
-    }
-    mCachedImageViews.clear();
-}
-
-VkImageView VulkanTextureState::getImageView(VkImageSubresourceRange range, VkImageViewType viewType,
-        VkComponentMapping swizzle) {
-    ImageViewKey const key{ range, viewType, swizzle };
-    if (auto iter = mCachedImageViews.find(key); iter != mCachedImageViews.end()) {
-        return iter->second;
-    }
-
-    VkSamplerYcbcrConversionInfo conversionInfo = {
-        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
-        .conversion = mYcbcr.conversion,
-    };
-
-    VkImageViewCreateInfo viewInfo = {
-        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-        .pNext = mYcbcr.conversion != VK_NULL_HANDLE ? &conversionInfo : nullptr,
-        .flags = 0,
-        .image = mTextureImage,
-        .viewType = viewType,
-        .format = mYcbcr.isExternalFormat ? VK_FORMAT_UNDEFINED : mVkFormat,
-        .components = swizzle,
-        .subresourceRange = range,
-    };
-    VkImageView imageView;
-    vkCreateImageView(mDevice, &viewInfo, VKALLOC, &imageView);
-    mCachedImageViews.emplace(key, imageView);
-    return imageView;
-}
-
-// Constructor for internally passed VkImage - including swapchain images and external images.
-VulkanTexture::VulkanTexture(VulkanContext const& context, VkDevice device, VmaAllocator allocator,
+// Constructor for internally passed VkImage
+VulkanTexture::VulkanTexture(VkDevice device, VmaAllocator allocator,
        fvkmemory::ResourceManager* resourceManager, VulkanCommands* commands, VkImage image,
-        VkDeviceMemory memory, VkFormat format, VkSamplerYcbcrConversion conversion,
-        uint8_t samples, uint32_t width, uint32_t height, uint32_t depth, TextureUsage tusage,
-        VulkanStagePool& stagePool)
-    : HwTexture(getSamplerTypeFromDepth(depth), 1, samples, width, height, depth,
-              TextureFormat::UNUSED, tusage),
-      mState(fvkmemory::resource_ptr<VulkanTextureState>::construct(resourceManager, stagePool,
-              commands, allocator, device, image, memory, format,
-              fvkutils::getViewType(SamplerType::SAMPLER_2D),
-              /*mipLevels=*/1, getLayerCountFromDepth(depth), conversion,
-              /*isExternalFormat=*/false,
-              getUsage(context, samples, VK_NULL_HANDLE, format, tusage),
-              any(usage & TextureUsage::PROTECTED))) {
+        VkDeviceMemory memory, VkFormat format, uint8_t samples, uint32_t width,
+        uint32_t height, uint32_t depth, TextureUsage tusage, VulkanStagePool& stagePool)
+    : HwTexture(getSamplerTypeFromDepth(depth), 1, samples, width, height, depth, TextureFormat::UNUSED,
+              tusage),
+      mState(fvkmemory::resource_ptr<VulkanTextureState>::construct(resourceManager, device,
+              allocator, commands, stagePool, format, fvkutils::getViewType(SamplerType::SAMPLER_2D),
+              /*mipLevels=*/1, getLayerCountFromDepth(depth), getDefaultLayoutImpl(tusage), any(usage & TextureUsage::PROTECTED))) {
+    mState->mTextureImage = image;
+    mState->mTextureImageMemory = memory;
    mPrimaryViewRange = mState->mFullViewRange;
 }

@@ -306,19 +189,21 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        fvkmemory::ResourceManager* resourceManager, VulkanCommands* commands, SamplerType target,
        uint8_t levels, TextureFormat tformat, uint8_t samples, uint32_t w, uint32_t h,
        uint32_t depth, TextureUsage tusage, VulkanStagePool& stagePool)
-     : HwTexture(target, levels, samples, w, h, depth, tformat, tusage) {
+    : HwTexture(target, levels, samples, w, h, depth, tformat, tusage),
+      mState(fvkmemory::resource_ptr<VulkanTextureState>::construct(resourceManager, device,
+              allocator, commands, stagePool, fvkutils::getVkFormat(tformat),
+              fvkutils::getViewType(target), levels, getLayerCount(target, depth),
+              VulkanLayout::UNDEFINED, any(usage & TextureUsage::PROTECTED))) {
    // Create an appropriately-sized device-only VkImage, but do not fill it yet.
-    VkFormat const vkFormat = fvkutils::getVkFormat(tformat);
-    bool const isProtected = any(tusage & TextureUsage::PROTECTED);
    VkImageCreateInfo imageInfo{
        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
        .imageType = target == SamplerType::SAMPLER_3D ? VK_IMAGE_TYPE_3D : VK_IMAGE_TYPE_2D,
-        .format = vkFormat,
+        .format = mState->mVkFormat,
        .extent = {w, h, depth},
        .mipLevels = levels,
        .arrayLayers = 1,
        .tiling = VK_IMAGE_TILING_OPTIMAL,
-        .usage = getUsage(context, samples, physicalDevice, vkFormat, tusage),
+        .usage = 0,
    };
    if (target == SamplerType::SAMPLER_3D && any(tusage & TextureUsage::ALL_ATTACHMENTS)) {
        if (context.isImageView2DOn3DImageSupported()) {
@@ -348,17 +233,79 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        imageInfo.arrayLayers = depth * 6;
        imageInfo.extent.depth = 1;
    }
-    if (isProtected) {
+    if (any(usage & TextureUsage::PROTECTED)) {
        imageInfo.flags |= VK_IMAGE_CREATE_PROTECTED_BIT;
    }

+    if (any(usage & TextureUsage::BLIT_SRC)) {
+        imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    }
+    if (any(usage & TextureUsage::BLIT_DST)) {
+        imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    }
+
+    // Determine if we can use the transient usage flag combined with lazily allocated memory.
+    const bool useTransientAttachment =
+            // Lazily allocated memory is available.
+            context.isLazilyAllocatedMemorySupported() &&
+            // Usage consists of attachment flags only.
+            none(tusage & ~TextureUsage::ALL_ATTACHMENTS) &&
+            // Usage contains at least one attachment flag.
+            any(tusage & TextureUsage::ALL_ATTACHMENTS) &&
+            // Depth resolve cannot use transient attachment because it uses a custom shader.
+            // TODO: see VulkanDriver::isDepthStencilResolveSupported() to know when to remove this
+            // restriction.
+            // Note that the custom shader does not resolve stencil. We do need to move to vk 1.2
+            // and above to be able to support stencil resolve (along with depth).
+            !(any(usage & TextureUsage::DEPTH_ATTACHMENT) && samples > 1);
+
+    mState->mIsTransientAttachment = useTransientAttachment;
+
+    const VkImageUsageFlags transientFlag =
+       useTransientAttachment ? VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT : 0U;
+
+    if (any(usage & TextureUsage::SAMPLEABLE)) {
+
+#if FVK_ENABLED(FVK_DEBUG_TEXTURE)
+        // Validate that the format is actually sampleable.
+        VkFormatProperties props;
+        vkGetPhysicalDeviceFormatProperties(physicalDevice, mState->mVkFormat, &props);
+        if (!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
+            FVK_LOGW << "Texture usage is SAMPLEABLE but format " << mState->mVkFormat << " is not "
+                    "sampleable with optimal tiling." << utils::io::endl;
+        }
+#endif
+
+        imageInfo.usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+    }
+    if (any(usage & TextureUsage::COLOR_ATTACHMENT)) {
+        imageInfo.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | transientFlag;
+        if (any(usage & TextureUsage::SUBPASS_INPUT)) {
+            imageInfo.usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+        }
+    }
+    if (any(usage & TextureUsage::STENCIL_ATTACHMENT)) {
+        imageInfo.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | transientFlag;
+    }
+    if (any(usage & TextureUsage::UPLOADABLE)) {
+        imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    }
+    if (any(usage & TextureUsage::DEPTH_ATTACHMENT)) {
+        imageInfo.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | transientFlag;
+
+        // Depth resolves uses a custom shader and therefore needs to be sampleable.
+        if (samples > 1) {
+            imageInfo.usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+        }
+    }
+
    // Constrain the sample count according to the sample count masks in VkPhysicalDeviceProperties.
    // Note that VulkanRenderTarget holds a single MSAA count, so we play it safe if this is used as
    // any kind of attachment (color or depth).
-    auto const& limits = context.getPhysicalDeviceLimits();
+    const auto& limits = context.getPhysicalDeviceLimits();
    if (imageInfo.usage & VK_IMAGE_USAGE_SAMPLED_BIT) {
        samples = fvkutils::reduceSampleCount(samples,
-                fvkutils::isVkDepthFormat(vkFormat)
+                fvkutils::isVkDepthFormat(mState->mVkFormat)
                        ? limits.sampledImageDepthSampleCounts
                        : limits.sampledImageColorSampleCounts);
    }
@@ -372,36 +319,33 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
    this->samples = samples;
    imageInfo.samples = (VkSampleCountFlagBits) samples;

-    VkImage textureImage;
-    VkResult result = vkCreateImage(device, &imageInfo, VKALLOC, &textureImage);
+    VkResult result = vkCreateImage(mState->mDevice, &imageInfo, VKALLOC, &mState->mTextureImage);
    if (result != VK_SUCCESS || FVK_ENABLED(FVK_DEBUG_TEXTURE)) {
        FVK_LOGD << "vkCreateImage: "
-            << "image = " << textureImage << ", "
+            << "image = " << mState->mTextureImage << ", "
            << "result = " << result << ", "
-            << "handle = " << utils::io::hex << textureImage << utils::io::dec << ", "
+            << "handle = " << utils::io::hex << mState->mTextureImage << utils::io::dec << ", "
            << "extent = " << w << "x" << h << "x"<< depth << ", "
            << "mipLevels = " << int(levels) << ", "
-            << "TextureUsage = " << static_cast<int>(tusage) << ", "
+            << "TextureUsage = " << static_cast<int>(usage) << ", "
            << "usage = " << imageInfo.usage << ", "
            << "samples = " << imageInfo.samples << ", "
            << "type = " << imageInfo.imageType << ", "
            << "flags = " << imageInfo.flags << ", "
            << "target = " << static_cast<int>(target) <<", "
-            << "format = " << vkFormat << utils::io::endl;
+            << "format = " << mState->mVkFormat << utils::io::endl;
    }
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to create image."
                                                       << " error=" << static_cast<int32_t>(result);

    // Allocate memory for the VkImage and bind it.
-    VkMemoryRequirements memReqs;
-    vkGetImageMemoryRequirements(device, textureImage, &memReqs);
+    VkMemoryRequirements memReqs = {};
+    vkGetImageMemoryRequirements(mState->mDevice, mState->mTextureImage, &memReqs);

-    bool const useTransientAttachment = imageInfo.usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
-
-    VkFlags const requiredMemoryFlags =
+    const VkFlags requiredMemoryFlags =
        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
        (useTransientAttachment ? VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT : 0U) |
-        (isProtected ? VK_MEMORY_PROPERTY_PROTECTED_BIT : 0U);
+        (mState->mIsProtected ? VK_MEMORY_PROPERTY_PROTECTED_BIT : 0U);
    uint32_t memoryTypeIndex
            = context.selectMemoryType(memReqs.memoryTypeBits, requiredMemoryFlags);

@@ -413,22 +357,21 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        .allocationSize = memReqs.size,
        .memoryTypeIndex = memoryTypeIndex,
    };
-    VkDeviceMemory textureImageMemory;
-    result = vkAllocateMemory(device, &allocInfo, nullptr, &textureImageMemory);
+    result = vkAllocateMemory(mState->mDevice, &allocInfo, nullptr, &mState->mTextureImageMemory);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to allocate image memory."
                                                       << " error=" << static_cast<int32_t>(result);
-    result = vkBindImageMemory(device, textureImage, textureImageMemory, 0);
+    result = vkBindImageMemory(mState->mDevice, mState->mTextureImage, mState->mTextureImageMemory,
+            0);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to bind image."
                                                       << " error=" << static_cast<int32_t>(result);

-    mState = fvkmemory::resource_ptr<VulkanTextureState>::construct(resourceManager, stagePool,
-            commands, allocator, device, textureImage, textureImageMemory, vkFormat,
-            fvkutils::getViewType(target), levels, getLayerCount(target, depth),
-            VK_NULL_HANDLE /* ycbcrConversion */, false /*isExternalFormat*/, imageInfo.usage,
-            isProtected);
-
    // Spec out the "primary" VkImageView that shaders use to sample from the image.
    mPrimaryViewRange = mState->mFullViewRange;
+
+    // Go ahead and create the primary image view.
+    getImageView(mPrimaryViewRange, mState->mViewType, mSwizzle);
+
+    mState->mDefaultLayout = getDefaultLayoutImpl(imageInfo.usage);
 }

 // Constructor for creating a texture view
@@ -437,8 +380,8 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        fvkmemory::resource_ptr<VulkanTexture> src, uint8_t baseLevel,
        uint8_t levelCount)
    : HwTexture(src->target, src->levels, src->samples, src->width, src->height, src->depth,
-            src->format, src->usage),
-      mState(src->mState) {
+            src->format, src->usage) {
+    mState = src->mState;
    mPrimaryViewRange = src->mPrimaryViewRange;
    mPrimaryViewRange.baseMipLevel = src->mPrimaryViewRange.baseMipLevel + baseLevel;
    mPrimaryViewRange.levelCount = levelCount;
@@ -449,10 +392,21 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        VulkanContext const& context, VmaAllocator allocator, VulkanCommands* commands,
        fvkmemory::resource_ptr<VulkanTexture> src, VkComponentMapping swizzle)
    : HwTexture(src->target, src->levels, src->samples, src->width, src->height, src->depth,
-              src->format, src->usage),
-      mState(src->mState),
-      mPrimaryViewRange(src->mPrimaryViewRange),
-      mSwizzle(composeSwizzle(src->mSwizzle, swizzle)) {}
+              src->format, src->usage) {
+    mState = src->mState;
+    mPrimaryViewRange = src->mPrimaryViewRange;
+    mSwizzle = composeSwizzle(src->mSwizzle, swizzle);
+}
+
+VulkanTextureState::~VulkanTextureState() {
+    if (mTextureImageMemory != VK_NULL_HANDLE) {
+        vkDestroyImage(mDevice, mTextureImage, VKALLOC);
+        vkFreeMemory(mDevice, mTextureImageMemory, VKALLOC);
+    }
+    for (auto entry: mCachedImageViews) {
+        vkDestroyImageView(mDevice, entry.second, VKALLOC);
+    }
+}

 void VulkanTexture::updateImage(const PixelBufferDescriptor& data, uint32_t width, uint32_t height,
        uint32_t depth, uint32_t xoffset, uint32_t yoffset, uint32_t zoffset, uint32_t miplevel) {
@@ -559,20 +513,20 @@ void VulkanTexture::updateImageWithBlit(const PixelBufferDescriptor& hostData, u
    commands.acquire(fvkmemory::resource_ptr<VulkanTexture>::cast(this));

    // TODO: support blit-based format conversion for 3D images and cubemaps.
-    constexpr int layer = 0;
+    const int layer = 0;

-    VkOffset3D const rect[2] { {0, 0, 0}, {int32_t(width), int32_t(height), 1} };
+    const VkOffset3D rect[2] { {0, 0, 0}, {int32_t(width), int32_t(height), 1} };

-    VkImageAspectFlags const aspect = getImageAspect();
+    const VkImageAspectFlags aspect = getImageAspect();

-    VkImageBlit const blitRegions[1] = {{
+    const VkImageBlit blitRegions[1] = {{
        .srcSubresource = { aspect, 0, 0, 1 },
        .srcOffsets = { rect[0], rect[1] },
        .dstSubresource = { aspect, uint32_t(miplevel), layer, 1 },
        .dstOffsets = { rect[0], rect[1] }
    }};

-    VkImageSubresourceRange const range = { aspect, miplevel, 1, layer, 1 };
+    const VkImageSubresourceRange range = { aspect, miplevel, 1, layer, 1 };

    VulkanLayout const newLayout = VulkanLayout::TRANSFER_DST;
    VulkanLayout const oldLayout = getLayout(layer, miplevel);
@@ -588,21 +542,41 @@ VulkanLayout VulkanTexture::getDefaultLayout() const {
    return mState->mDefaultLayout;
 }

-VkImageView VulkanTexture::getAttachmentView(VkImageSubresourceRange const& range, VkImageViewType type) {
-    assert_invariant(mState->mYcbcr.conversion == VK_NULL_HANDLE &&
-                     "We are not yet supporting external image as attachments.");
-    if (type == VK_IMAGE_VIEW_TYPE_2D) {
-        VkImageSubresourceRange copy = range;
-        copy.levelCount = 1;
-        copy.layerCount = 1;
-        return mState->getImageView(copy, type, {});
-    } else {
-        return mState->getImageView(range, type, {});
-    }
+VkImageView VulkanTexture::getAttachmentView(VkImageSubresourceRange range) {
+    range.levelCount = 1;
+    range.layerCount = 1;
+    return getImageView(range, VK_IMAGE_VIEW_TYPE_2D, {});
 }

-VkImageView VulkanTexture::getView(VkImageSubresourceRange const& range) {
-    return mState->getImageView(range, mState->mViewType, mSwizzle);
+VkImageView VulkanTexture::getMultiviewAttachmentView(VkImageSubresourceRange range) {
+    return getImageView(range, VK_IMAGE_VIEW_TYPE_2D_ARRAY, {});
+}
+
+VkImageView VulkanTexture::getViewForType(VkImageSubresourceRange const& range, VkImageViewType type) {
+    return getImageView(range, type, mSwizzle);
+}
+
+VkImageView VulkanTexture::getImageView(VkImageSubresourceRange range, VkImageViewType viewType,
+        VkComponentMapping swizzle) {
+    VulkanTextureState::ImageViewKey const key{ range, viewType, swizzle };
+    auto iter = mState->mCachedImageViews.find(key);
+    if (iter != mState->mCachedImageViews.end()) {
+        return iter->second;
+    }
+    VkImageViewCreateInfo viewInfo = {
+        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .image = mState->mTextureImage,
+        .viewType = viewType,
+        .format = mState->mVkFormat,
+        .components = swizzle,
+        .subresourceRange = range,
+    };
+    VkImageView imageView;
+    vkCreateImageView(mState->mDevice, &viewInfo, VKALLOC, &imageView);
+    mState->mCachedImageViews.emplace(key, imageView);
+    return imageView;
 }

 VkImageAspectFlags VulkanTexture::getImageAspect() const {
@@ -764,21 +738,6 @@ void VulkanTexture::setLayout(VkImageSubresourceRange const& range, VulkanLayout
    }
 }

-void VulkanTexture::setYcbcrConversion(VkSamplerYcbcrConversion conversion, bool isExternalFormat) {
-    // Note that this comparison is valid because we only ever create VkSamplerYcbcrConversion from
-    // a cache.  So for each set of parameters, there is exactly one conversion (similar to
-    // samplers).
-    VulkanTextureState::Ycbcr ycbcr = {
-        .conversion = conversion,
-        .isExternalFormat = isExternalFormat,
-    };
-
-    if (mState->mYcbcr != ycbcr) {
-        mState->mYcbcr = ycbcr;
-        mState->clearCachedImageViews();
-    }
-}
-
 VulkanLayout VulkanTexture::getLayout(uint32_t layer, uint32_t level) const {
    assert_invariant(level <= 0xffff && layer <= 0xffff);
    const uint32_t key = (layer << 16) | level;
@@ -19,10 +19,7 @@

 #include "DriverBase.h"

-#include "VulkanCommands.h"
-#include "VulkanConstants.h"
-#include "VulkanMemory.h"
-#include "VulkanStagePool.h"
+#include "VulkanBuffer.h"
 #include "vulkan/memory/Resource.h"
 #include "vulkan/memory/ResourcePointer.h"
 #include "vulkan/utils/Image.h"
@@ -34,14 +31,10 @@

 namespace filament::backend {

-struct VulkanTexture;
-
 struct VulkanTextureState : public fvkmemory::Resource {
-    VulkanTextureState(VulkanStagePool& stagePool, VulkanCommands* commands, VmaAllocator allocator,
-            VkDevice device, VkImage image, VkDeviceMemory deviceMemory, VkFormat format,
-            VkImageViewType viewType, uint8_t levels, uint8_t layerCount,
-            VkSamplerYcbcrConversion ycbcrConversion, bool isExternalFormat,
-            VkImageUsageFlags usage, bool isProtected);
+    VulkanTextureState(VkDevice device, VmaAllocator allocator, VulkanCommands* commands,
+            VulkanStagePool& stagePool, VkFormat format, VkImageViewType viewType, uint8_t levels,
+            uint8_t layerCount, VulkanLayout defaultLayout, bool isProtected);

    ~VulkanTextureState();

@@ -64,50 +57,29 @@ struct VulkanTextureState : public fvkmemory::Resource {
    // No implicit padding allowed due to it being a hash key.
    static_assert(sizeof(ImageViewKey) == 40);

-    VkImageView getImageView(VkImageSubresourceRange range, VkImageViewType viewType,
-            VkComponentMapping swizzle);
-private:
-    void clearCachedImageViews() noexcept;
-    VulkanStagePool& mStagePool;
-    VulkanCommands* const mCommands;
-    VmaAllocator const mAllocator;
-    VkDevice const mDevice;
+    using ImageViewHash = utils::hash::MurmurHashFn<ImageViewKey>;

    // The texture with the sidecar owns the sidecar.
    fvkmemory::resource_ptr<VulkanTexture> mSidecarMSAA;
+    VkDeviceMemory mTextureImageMemory = VK_NULL_HANDLE;

-    VkImage const mTextureImage;
-    VkDeviceMemory const mTextureImageMemory;
    VkFormat const mVkFormat;
    VkImageViewType const mViewType;
    VkImageSubresourceRange const mFullViewRange;
+    VkImage mTextureImage = VK_NULL_HANDLE;
+    VulkanLayout mDefaultLayout;

-    // Note that this parameter is not constant due to the fact that AHB can force a change in the
-    // conversion matrix per-frame.
-    struct Ycbcr {
-        VkSamplerYcbcrConversion conversion;
-        bool isExternalFormat;
-
-        bool operator==(Ycbcr const& other) const {
-            return conversion == other.conversion && isExternalFormat == other.isExternalFormat;
-        }
-
-        bool operator!=(Ycbcr const& other) const {
-            return !((*this) == other);
-        }
-
-    } mYcbcr;
-
-    VulkanLayout const mDefaultLayout;
-    VkImageUsageFlags const mUsage;
-    bool const mIsProtected;
+    bool mIsProtected = false;

    // Track the image layout of each subresource using a sparse range map.
    utils::RangeMap<uint32_t, VulkanLayout> mSubresourceLayouts;
-    using ImageViewHash = utils::hash::MurmurHashFn<ImageViewKey>;
-    std::unordered_map<ImageViewKey, VkImageView, ImageViewHash> mCachedImageViews;

-    friend struct VulkanTexture;
+    std::unordered_map<ImageViewKey, VkImageView, ImageViewHash> mCachedImageViews;
+    VulkanStagePool& mStagePool;
+    VkDevice mDevice;
+    VmaAllocator mAllocator;
+    VulkanCommands* mCommands;
+    bool mIsTransientAttachment;
 };

 struct VulkanTexture : public HwTexture, fvkmemory::Resource {
@@ -119,10 +91,10 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {
            VulkanStagePool& stagePool);

    // Specialized constructor for internally created textures (e.g. from a swap chain)
-    VulkanTexture(VulkanContext const& context, VkDevice device, VmaAllocator allocator,
+    // The texture will never destroy the given VkImage, but it does manages its subresources.
+    VulkanTexture(VkDevice device, VmaAllocator allocator,
            fvkmemory::ResourceManager* resourceManager, VulkanCommands* commands, VkImage image,
-            VkDeviceMemory memory, VkFormat format, VkSamplerYcbcrConversion conversion,
-            uint8_t samples, uint32_t width, uint32_t height, uint32_t depth,
+            VkDeviceMemory memory, VkFormat format, uint8_t samples, uint32_t width, uint32_t height, uint32_t depth,
            TextureUsage tusage, VulkanStagePool& stagePool);

    // Constructor for creating a texture view for wrt specific mip range
@@ -141,6 +113,11 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {
    void updateImage(const PixelBufferDescriptor& data, uint32_t width, uint32_t height,
            uint32_t depth, uint32_t xoffset, uint32_t yoffset, uint32_t zoffset, uint32_t miplevel);

+    // Returns the primary image view, which is used for shader sampling.
+    VkImageView getPrimaryImageView() {
+        return getImageView(mPrimaryViewRange, mState->mViewType, mSwizzle);
+    }
+
    VkImageViewType getViewType() const {
        return mState->mViewType;
    }
@@ -155,11 +132,20 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {
    // time of the call.
    VulkanLayout getDefaultLayout() const;

-    // Gets or creates a cached VkImageView for a subresource that can be used as a render
-    // target attachment.  Unlike the primary image view, this always the identity swizzle.
-    VkImageView getAttachmentView(VkImageSubresourceRange const& range, VkImageViewType type);
+    // Gets or creates a cached VkImageView for a single subresource that can be used as a render
+    // target attachment.  Unlike the primary image view, this always has type VK_IMAGE_VIEW_TYPE_2D
+    // and the identity swizzle.
+    VkImageView getAttachmentView(VkImageSubresourceRange range);

-    VkImageView getView(VkImageSubresourceRange const& range);
+    // Gets or creates a cached VkImageView for a single subresource that can be used as a render
+    // target attachment when rendering with multiview.
+    VkImageView getMultiviewAttachmentView(VkImageSubresourceRange range);
+
+    // This is a workaround for the first few frames where we're waiting for the texture to actually
+    // be uploaded.  In that case, we bind the sampler to an empty texture, but the corresponding
+    // imageView needs to be of the right type. Hence, we provide an option to indicate the
+    // view type. Swizzle option does not matter in this case.
+    VkImageView getViewForType(VkImageSubresourceRange const& range, VkImageViewType type);

    VkFormat getVkFormat() const {
        return mState->mVkFormat;
@@ -179,7 +165,7 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {
    }

    bool isTransientAttachment() const {
-        return mState->mUsage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
+        return mState->mIsTransientAttachment;
    }

    bool getIsProtected() const {
@@ -206,11 +192,6 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {
    // manually (outside of calls to transitionLayout).
    void setLayout(VkImageSubresourceRange const& range, VulkanLayout newLayout);

-    // This is used in the case of external images and external samplers. AHB might update the
-    // conversion per-frame. This implies that we need to invalidate the view cache when that
-    // happens.
-    void setYcbcrConversion(VkSamplerYcbcrConversion conversion, bool isExternal);
-
 #if FVK_ENABLED(FVK_DEBUG_TEXTURE)
    void print() const;
 #endif
@@ -1,84 +0,0 @@
-/*
- * 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 "VulkanYcbcrConversionCache.h"
-
-#include "vulkan/VulkanConstants.h"
-#include "vulkan/utils/Conversion.h"
-
-#include <utils/Panic.h>
-
-#if defined(__ANDROID__)
-#include <vulkan/vulkan_android.h>  // for VkExternalFormatANDROID
-#endif
-
-using namespace bluevk;
-
-namespace filament::backend {
-
-VulkanYcbcrConversionCache::VulkanYcbcrConversionCache(VkDevice device)
-    : mDevice(device) {}
-
-VkSamplerYcbcrConversion VulkanYcbcrConversionCache::getConversion(
-        VulkanYcbcrConversionCache::Params params) noexcept {
-    auto iter = mCache.find(params);
-    if (UTILS_LIKELY(iter != mCache.end())) {
-        return iter->second;
-    }
-
-    auto const& chroma = params.conversion;
-    TextureSwizzle const swizzleArray[] = { chroma.r, chroma.g, chroma.b, chroma.a };
-    VkSamplerYcbcrConversionCreateInfo conversionInfo = {
-        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
-        .format = fvkutils::getVkFormat(params.format),
-        .ycbcrModel = fvkutils::getYcbcrModelConversion(chroma.ycbcrModel),
-        .ycbcrRange = fvkutils::getYcbcrRange(chroma.ycbcrRange),
-        .components = fvkutils::getSwizzleMap(swizzleArray),
-        .xChromaOffset = fvkutils::getChromaLocation(chroma.xChromaOffset),
-        .yChromaOffset = fvkutils::getChromaLocation(chroma.yChromaOffset),
-        .chromaFilter = fvkutils::getFilter(chroma.chromaFilter),
-    };
-
-    // We could put this in the platform class, but that seems like a bit of an overkill
-#if defined(__ANDROID__)
-    VkExternalFormatANDROID externalFormat = {
-        .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
-        .externalFormat = params.externalFormat,
-    };
-    if (params.externalFormat) {
-        conversionInfo.pNext = &externalFormat;
-        conversionInfo.format = VK_FORMAT_UNDEFINED;
-    }
-#endif
-
-    VkSamplerYcbcrConversion conversion;
-    VkResult result =
-            vkCreateSamplerYcbcrConversion(mDevice, &conversionInfo, nullptr, &conversion);
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to create Ycbcr Conversion."
-                                                       << " error=" << static_cast<int32_t>(result);
-
-    mCache.insert({ params, conversion });
-    return conversion;
-}
-
-void VulkanYcbcrConversionCache::terminate() noexcept {
-    for (auto& [param, conv]: mCache) {
-        vkDestroySamplerYcbcrConversion(mDevice, conv, VKALLOC);
-    }
-    mCache.clear();
-}
-
-} // namespace filament::backend
@@ -1,60 +0,0 @@
-/*
- * 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_VULKANYCBCRCONVERSIONCACHE_H
-#define TNT_FILAMENT_BACKEND_VULKANYCBCRCONVERSIONCACHE_H
-
-#include <backend/DriverEnums.h>
-
-#include <utils/Hash.h>
-
-#include <bluevk/BlueVK.h>
-#include <tsl/robin_map.h>
-
-namespace filament::backend {
-
-// Simple manager for VkSamplerYcbcrConversion objects.
-class VulkanYcbcrConversionCache {
-public:
-    struct Params {
-        SamplerYcbcrConversion conversion = {};
-        TextureFormat format = {};
-        uint16_t padding = 0;
-        uint64_t externalFormat = 0;
-    };
-    static_assert(sizeof(Params) == 16);
-
-    explicit VulkanYcbcrConversionCache(VkDevice device);
-    VkSamplerYcbcrConversion getConversion(Params params) noexcept;
-    void terminate() noexcept;
-
-private:
-    VkDevice mDevice;
-
-    struct ConversionEqualTo {
-        bool operator()(Params lhs, Params rhs) const noexcept {
-            SamplerYcbcrConversion::EqualTo equal;
-            return equal(lhs.conversion, rhs.conversion) &&
-                   lhs.externalFormat == rhs.externalFormat;
-        }
-    };
-    using ConversionHashFn = utils::hash::MurmurHashFn<Params>;
-    tsl::robin_map<Params, VkSamplerYcbcrConversion, ConversionHashFn, ConversionEqualTo> mCache;
-};
-
-}// namespace filament::backend
-
-#endif// TNT_FILAMENT_BACKEND_VULKANYCBCRCONVERSIONCACHE_H
@@ -132,10 +132,6 @@ public:
        return id() == other.id() && type() == other.type();
    }

-    inline bool operator!=(resource_ptr<D> const& other) const {
-        return !((*this) == other);
-    }
-
    inline explicit operator bool() const {
        return bool(mRef);
    }
@@ -211,7 +211,6 @@ ExtensionSet getDeviceExtensions(VkPhysicalDevice device) {
        VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME,
        VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME,
        VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME,
-        VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME,
 #endif
        // MoltenVk is the only non-conformant implementation we're interested in.
 #if defined(__APPLE__)
@@ -327,9 +326,7 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
 }

 VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
-        VkPhysicalDeviceFeatures2 const& features,
-        VkPhysicalDeviceVulkan11Features const& vk11Features,
-        uint32_t graphicsQueueFamilyIndex,
+        VkPhysicalDeviceFeatures2 const& features, uint32_t graphicsQueueFamilyIndex,
        uint32_t protectedGraphicsQueueFamilyIndex, ExtensionSet const& deviceExtensions,
        bool requestImageView2DOn3DImage) {
    VkDevice device;
@@ -362,28 +359,14 @@ VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,

    // We could simply enable all supported features, but since that may have performance
    // consequences let's just enable the features we need.
-    VkPhysicalDeviceFeatures enabledFeatures = {
+    VkPhysicalDeviceFeatures enabledFeatures{
        .depthClamp = features.features.depthClamp,
        .samplerAnisotropy = features.features.samplerAnisotropy,
        .textureCompressionETC2 = features.features.textureCompressionETC2,
        .textureCompressionBC = features.features.textureCompressionBC,
        .shaderClipDistance = features.features.shaderClipDistance,
    };
-
-    VkPhysicalDeviceFeatures2 enabledFeatures2 = {
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
-        .features = enabledFeatures,
-    };
-    chainStruct(&deviceCreateInfo, &enabledFeatures2);
-
-    VkPhysicalDeviceVulkan11Features enabledVk11Features = {
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
-        .multiview = vk11Features.multiview,
-#if defined(__ANDROID__)
-        .samplerYcbcrConversion = vk11Features.samplerYcbcrConversion,
-#endif
-    };
-    chainStruct(&deviceCreateInfo, &enabledVk11Features);
+    deviceCreateInfo.pEnabledFeatures = &enabledFeatures;

    deviceCreateInfo.enabledExtensionCount = (uint32_t) requestExtensions.size();
    deviceCreateInfo.ppEnabledExtensionNames = requestExtensions.data();
@@ -400,7 +383,7 @@ VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,

    VkPhysicalDeviceMultiviewFeaturesKHR multiview = {
        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR,
-        .multiview = vk11Features.multiview,
+        .multiview = VK_TRUE,
        .multiviewGeometryShader = VK_FALSE,
        .multiviewTessellationShader = VK_FALSE,
    };
@@ -751,7 +734,6 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
    };
    chainStruct(&context.mPhysicalDeviceFeatures, &queryProtectedMemoryFeatures);
-    chainStruct(&context.mPhysicalDeviceFeatures, &context.mPhysicalDeviceVk11Features);
    chainStruct(&context.mPhysicalDeviceProperties, &protectedMemoryProperties);

    // Initialize the following fields: physicalDeviceProperties, memoryProperties,
@@ -813,10 +795,10 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
    }

    if (mImpl->mDevice == VK_NULL_HANDLE) {
-        mImpl->mDevice = createLogicalDevice(mImpl->mPhysicalDevice,
-                context.mPhysicalDeviceFeatures, context.mPhysicalDeviceVk11Features,
-                mImpl->mGraphicsQueueFamilyIndex, mImpl->mProtectedGraphicsQueueFamilyIndex,
-                deviceExts, requestPortabilitySubsetImageView2DOn3DImage);
+        mImpl->mDevice =
+                createLogicalDevice(mImpl->mPhysicalDevice, context.mPhysicalDeviceFeatures,
+                        mImpl->mGraphicsQueueFamilyIndex, mImpl->mProtectedGraphicsQueueFamilyIndex,
+                        deviceExts, requestPortabilitySubsetImageView2DOn3DImage);
    }

    assert_invariant(mImpl->mDevice != VK_NULL_HANDLE);
@@ -844,10 +826,12 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
    if (!mImpl->mSharedContext) {
        context.mDebugUtilsSupported = setContains(instExts, VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
        context.mDebugMarkersSupported = setContains(deviceExts, VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
+        context.mMultiviewEnabled = setContains(deviceExts, VK_KHR_MULTIVIEW_EXTENSION_NAME);
    } else {
        VulkanSharedContext const* scontext = (VulkanSharedContext const*) sharedContext;
        context.mDebugUtilsSupported = scontext->debugUtilsSupported;
        context.mDebugMarkersSupported = scontext->debugMarkersSupported;
+        context.mMultiviewEnabled = scontext->multiviewSupported;
    }

    // Check the availability of lazily allocated memory
@@ -993,6 +977,30 @@ VkQueue VulkanPlatform::getProtectedGraphicsQueue() const noexcept {
    return mImpl->mProtectedGraphicsQueue;
 }

+VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadata(
+        ExternalImageHandleRef externalImage) {
+    return getExternalImageMetadataImpl(externalImage, mImpl->mDevice);
+}
+
+VulkanPlatform::ImageData VulkanPlatform::createExternalImageData(
+        ExternalImageHandleRef externalImage, const ExternalImageMetadata& metadata,
+        uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
+    return createExternalImageDataImpl(externalImage, mImpl->mDevice, metadata, memoryTypeIndex,
+            usage);
+}
+
+VkSampler VulkanPlatform::createExternalSampler(SamplerYcbcrConversion chroma,
+        SamplerParams sampler, uint32_t internalFormat) {
+    return createExternalSamplerImpl(mImpl->mDevice, chroma, sampler, internalFormat);
+}
+
+VkImageView VulkanPlatform::createExternalImageView(SamplerYcbcrConversion chroma,
+        uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
+        VkImageViewType viewType, VkComponentMapping swizzle) {
+    return createExternalImageViewImpl(mImpl->mDevice, chroma, internalFormat, image, range,
+            viewType, swizzle);
+}
+
 ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() const {
    return getSwapchainInstanceExtensionsImpl();
 }
@@ -15,14 +15,14 @@
 */
 #include <backend/platforms/VulkanPlatformAndroid.h>

-#include "vulkan/VulkanConstants.h"
-#include "vulkan/VulkanContext.h"
-#include "vulkan/vulkan_core.h"
-
 #include <backend/DriverEnums.h>
 #include <private/backend/BackendUtilsAndroid.h>

+#include "vulkan/VulkanConstants.h"
+
 #include <utils/Panic.h>
+#include "vulkan/utils/Image.h"
+#include "vulkan/utils/Conversion.h"

 #include <bluevk/BlueVK.h>

@@ -57,7 +57,7 @@ VkFormat transformVkFormat(VkFormat format, bool sRGB) {
 }

 bool isProtectedFromUsage(uint64_t usage) {
-    return usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
+    return (usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT) ? true : false;
 }

 std::pair<VkFormat, VkImageUsageFlags> getVKFormatAndUsage(const AHardwareBuffer_Desc& desc,
@@ -120,9 +120,7 @@ std::pair<VkFormat, VkImageUsageFlags> getVKFormatAndUsage(const AHardwareBuffer
    usage = 0;
    if (desc.usage & AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE) {
        usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
-
-        // We shouldn't be using external samplers as input attachments
-        // usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+        usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
    }
    if (desc.usage & AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER) {
        if (isDepthFormat) {
@@ -138,38 +136,87 @@ std::pair<VkFormat, VkImageUsageFlags> getVKFormatAndUsage(const AHardwareBuffer
    return { format, usage };
 }

-std::pair<TextureFormat, TextureUsage> getFilamentFormatAndUsage(const AHardwareBuffer_Desc& desc,
-        bool sRGB) {
-    auto const format = mapToFilamentFormat(desc.format, sRGB);
-    return {
-        format,
-        mapToFilamentUsage(desc.usage, format),
-    };
-}
+VulkanPlatform::ImageData allocateExternalImage(AHardwareBuffer* buffer, VkDevice device,
+        VulkanPlatform::ExternalImageMetadata const& metadata, uint32_t memoryTypeIndex,
+        VkImageUsageFlags usage) {
+    VulkanPlatform::ImageData data;

+    // if external format we need to specifiy it in the allocation
+    const bool useExternalFormat = metadata.format == VK_FORMAT_UNDEFINED;
+
+    const VkExternalFormatANDROID externalFormat = {
+        .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
+        .pNext = nullptr,
+        // pass down the format (external means we don't have it VK defined)
+        .externalFormat = metadata.externalFormat,
+    };
+    const VkExternalMemoryImageCreateInfo externalCreateInfo = {
+        .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+        .pNext = useExternalFormat ? &externalFormat : nullptr,
+        .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+    };
+
+    VkImageCreateInfo imageInfo{ .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+    imageInfo.pNext = &externalCreateInfo;
+    imageInfo.format = metadata.format;
+    imageInfo.imageType = VK_IMAGE_TYPE_2D;
+    imageInfo.extent = {
+        metadata.width,
+        metadata.height,
+        1u,
+    };
+    imageInfo.mipLevels = 1;
+    imageInfo.arrayLayers = metadata.layers;
+    imageInfo.samples = metadata.samples;
+    imageInfo.usage = usage;
+
+    VkResult result = vkCreateImage(device, &imageInfo, VKALLOC, &data.first);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+            << "vkCreateImage failed with error=" << static_cast<int32_t>(result);
+
+    // Allocate the memory
+    VkImportAndroidHardwareBufferInfoANDROID androidHardwareBufferInfo = {
+        .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
+        .pNext = nullptr,
+        .buffer = buffer,
+    };
+    VkMemoryDedicatedAllocateInfo memoryDedicatedAllocateInfo = {
+        .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
+        .pNext = &androidHardwareBufferInfo,
+        .image = data.first,
+        .buffer = VK_NULL_HANDLE,
+    };
+    VkMemoryAllocateInfo allocInfo = {
+        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+        .pNext = &memoryDedicatedAllocateInfo,
+        .allocationSize = metadata.allocationSize,
+        .memoryTypeIndex = memoryTypeIndex,
+    };
+    result = vkAllocateMemory(device, &allocInfo, VKALLOC, &data.second);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+            << "vkAllocateMemory failed with error=" << static_cast<int32_t>(result);
+
+    return data;
+}

 }// namespace

-VulkanPlatformAndroid::ExternalImageVulkanAndroid::~ExternalImageVulkanAndroid() {
-    if (__builtin_available(android 26, *)) {
-        if (aHardwareBuffer) {
-            AHardwareBuffer_release(aHardwareBuffer);
-        }
-    }
-}
+VulkanPlatformAndroid::ExternalImageVulkanAndroid::~ExternalImageVulkanAndroid() = default;

 Platform::ExternalImageHandle VulkanPlatformAndroid::createExternalImage(
        AHardwareBuffer const* buffer, bool sRGB) noexcept {
    if (__builtin_available(android 26, *)) {
-        auto bufferImpl = const_cast<AHardwareBuffer*>(buffer);
-        AHardwareBuffer_acquire(bufferImpl);
-
        AHardwareBuffer_Desc hardwareBufferDescription = {};
        AHardwareBuffer_describe(buffer, &hardwareBufferDescription);

        auto* const p = new (std::nothrow) ExternalImageVulkanAndroid;
        p->aHardwareBuffer = const_cast<AHardwareBuffer*>(buffer);
        p->sRGB = sRGB;
+        p->height = hardwareBufferDescription.height;
+        p->width = hardwareBufferDescription.width;
+        TextureFormat textureFormat = mapToFilamentFormat(hardwareBufferDescription.format, sRGB);
+        p->format = textureFormat;
+        p->usage = mapToFilamentUsage(hardwareBufferDescription.usage, textureFormat);
        return Platform::ExternalImageHandle{ p };
    }

@@ -178,20 +225,23 @@ Platform::ExternalImageHandle VulkanPlatformAndroid::createExternalImage(

 VulkanPlatformAndroid::ExternalImageDescAndroid VulkanPlatformAndroid::getExternalImageDesc(
        ExternalImageHandleRef externalImage) const noexcept {
-    auto metadata = extractExternalImageMetadata(externalImage);
+    auto const* fvkExternalImage =
+            static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());
+
    return {
-        .width = metadata.width,
-        .height = metadata.height,
-        .format = metadata.filamentFormat,
-        .usage = metadata.filamentUsage,
+        .width = fvkExternalImage->width,
+        .height = fvkExternalImage->height,
+        .format = fvkExternalImage->format,
+        .usage = fvkExternalImage->usage,
    };
 }

-VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::extractExternalImageMetadata(
-        ExternalImageHandleRef image) const {
-    auto const* fvkExternalImage = static_cast<ExternalImageVulkanAndroid const*>(image.get());
+VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::getExternalImageMetadata(
+        ExternalImageHandleRef externalImage) {
+    auto const* fvkExternalImage =
+            static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());

-    ExternalImageMetadata metadata = {};
+    ExternalImageMetadata metadata;
    AHardwareBuffer* buffer = fvkExternalImage->aHardwareBuffer;
    if (__builtin_available(android 26, *)) {
        AHardwareBuffer_Desc bufferDesc;
@@ -199,30 +249,16 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::extractExternalImag
        metadata.width = bufferDesc.width;
        metadata.height = bufferDesc.height;
        metadata.layers = bufferDesc.layers;
+        metadata.isProtected = isProtectedFromUsage(bufferDesc.usage);
        std::tie(metadata.format, metadata.usage) =
                getVKFormatAndUsage(bufferDesc, fvkExternalImage->sRGB);
-        std::tie(metadata.filamentFormat, metadata.filamentUsage) =
-                getFilamentFormatAndUsage(bufferDesc, fvkExternalImage->sRGB);
-
-        if (isProtectedFromUsage(bufferDesc.usage)) {
-            metadata.filamentUsage |= TextureUsage::PROTECTED;
-        }
-
-        // TODO: The following seems unnecessary. we should be able to discern directly from the
-        // bufferDesc.
-        if (any(metadata.filamentUsage & TextureUsage::BLIT_SRC)) {
-            metadata.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-        }
-
-        if (any(metadata.filamentUsage & (TextureUsage::BLIT_DST | TextureUsage::UPLOADABLE))) {
-            metadata.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-        }
    }
-    metadata.samples = VK_SAMPLE_COUNT_1_BIT;

+    metadata.samples = VK_SAMPLE_COUNT_1_BIT;

    VkAndroidHardwareBufferFormatPropertiesANDROID formatInfo = {
        .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
+        .pNext = nullptr,
    };
    VkAndroidHardwareBufferPropertiesANDROID properties = {
        .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
@@ -232,116 +268,141 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::extractExternalImag
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
            << "vkGetAndroidHardwareBufferProperties failed with error="
            << static_cast<int32_t>(result);
+
    VkFormat bufferPropertiesFormat = transformVkFormat(formatInfo.format, fvkExternalImage->sRGB);
    FILAMENT_CHECK_POSTCONDITION(metadata.format == bufferPropertiesFormat)
            << "mismatched image format( " << metadata.format << ") and queried format("
            << bufferPropertiesFormat << ") for external image (AHB)";
    metadata.externalFormat = formatInfo.externalFormat;
-
-    // Choose either externalFormat > 0 or metadata.format and prefer the latter.
-    if (metadata.externalFormat > 0 &&  metadata.format != VK_FORMAT_UNDEFINED) {
-        // See VUID-VkImageCreateInfo-pNext-09457
-        metadata.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
-        metadata.externalFormat = 0;
-    }
-
    metadata.allocationSize = properties.allocationSize;
    metadata.memoryTypeBits = properties.memoryTypeBits;
-
-    metadata.ycbcrConversionComponents = formatInfo.samplerYcbcrConversionComponents;
-    metadata.ycbcrModel = formatInfo.suggestedYcbcrModel;
-    metadata.ycbcrRange = formatInfo.suggestedYcbcrRange;
-    metadata.xChromaOffset = formatInfo.suggestedXChromaOffset;
-    metadata.yChromaOffset = formatInfo.suggestedYChromaOffset;
-
    return metadata;
 }

-VulkanPlatformAndroid::ImageData VulkanPlatformAndroid::createVkImageFromExternal(
-        ExternalImageHandleRef externalImage) const {
-    auto const& metadata = extractExternalImageMetadata(externalImage);
-
+VulkanPlatformAndroid::ImageData VulkanPlatformAndroid::createExternalImageData(
+        ExternalImageHandleRef externalImage, const ExternalImageMetadata& metadata,
+        uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
    auto const* fvkExternalImage =
            static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());
-    AHardwareBuffer* buffer = fvkExternalImage->aHardwareBuffer;
+    ImageData data = allocateExternalImage(fvkExternalImage->aHardwareBuffer, getDevice(), metadata,
+            memoryTypeIndex, usage);
+    VkResult result = vkBindImageMemory(getDevice(), data.first, data.second, 0);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+        << "vkBindImageMemory error=" << static_cast<int32_t>(result);
+    return data;
+}

-    // if external format we need to specifiy it in the allocation
-    bool const useExternalFormat = metadata.format == VK_FORMAT_UNDEFINED;
-
-    VkExternalFormatANDROID const externalFormat = {
+VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device, SamplerYcbcrConversion chroma,
+            uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
+            VkImageViewType viewType, VkComponentMapping swizzle){
+        VkExternalFormatANDROID externalFormat = {
        .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
        .pNext = nullptr,
-        .externalFormat = metadata.externalFormat,
-    };
-    VkExternalMemoryImageCreateInfo const externalCreateInfo = {
-        .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
-        .pNext = useExternalFormat ? &externalFormat : nullptr,
-        .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+        .externalFormat = internalFormat,
    };

-    VkImageCreateInfo const imageInfo{
-        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
-        .pNext = &externalCreateInfo,
-        .flags = useExternalFormat ? VK_IMAGE_CREATE_ALIAS_BIT : 0u,
-        .imageType = VK_IMAGE_TYPE_2D,
-        .format = metadata.format,
-        .extent = {
-            metadata.width,
-            metadata.height,
-            1u,
-        },
-        .mipLevels = 1,
-        .arrayLayers = metadata.layers,
-        .samples = metadata.samples,
-        .usage = metadata.usage,
+    TextureSwizzle const swizzleArray[] = {chroma.r, chroma.g, chroma.b, chroma.a};
+    VkSamplerYcbcrConversionCreateInfo conversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+        .pNext = &externalFormat,
+        .format = VK_FORMAT_UNDEFINED,
+        .ycbcrModel = fvkutils::getYcbcrModelConversion(chroma.ycbcrModel),
+        .ycbcrRange = fvkutils::getYcbcrRange(chroma.ycbcrRange),
+        .components = fvkutils::getSwizzleMap(swizzleArray),
+        .xChromaOffset = fvkutils::getChromaLocation(chroma.xChromaOffset),
+        .yChromaOffset = fvkutils::getChromaLocation(chroma.yChromaOffset),
+        .chromaFilter = fvkutils::getFilter(chroma.chromaFilter),
    };
-
-    VkDevice const device = getDevice();
-
-    VkImage image;
-    VkResult result = vkCreateImage(device, &imageInfo, VKALLOC, &image);
+    VkSamplerYcbcrConversion conversion = VK_NULL_HANDLE;
+    VkResult result = vkCreateSamplerYcbcrConversion(device, &conversionInfo,
+                                                     nullptr, &conversion);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkCreateImage failed with error=" << static_cast<int32_t>(result);
+        << "Unable to create Ycbcr Conversion."
+        << " error=" << static_cast<int32_t>(result);

-    // Allocate the memory
-    VkImportAndroidHardwareBufferInfoANDROID const androidHardwareBufferInfo = {
-        .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
-        .buffer = buffer,
+    VkSamplerYcbcrConversionInfo samplerYcbcrConversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
+        .pNext = nullptr,
+        .conversion = conversion,
    };
-    VkMemoryDedicatedAllocateInfo const memoryDedicatedAllocateInfo = {
-        .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
-        .pNext = &androidHardwareBufferInfo,
+
+    VkImageViewCreateInfo viewInfo = {
+        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+        .pNext = &samplerYcbcrConversionInfo,
+        .flags = 0,
        .image = image,
-        .buffer = VK_NULL_HANDLE,
+        .viewType = viewType,
+        .format = VK_FORMAT_UNDEFINED,
+        .components = swizzle,
+        .subresourceRange = range,
+    };
+    VkImageView imageView;
+    result = vkCreateImageView(device, &viewInfo, VKALLOC, &imageView);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+        << "Unable to create VkImageView."
+        << " error=" << static_cast<int32_t>(result);
+
+    return imageView;
+}
+
+VkSampler VulkanPlatform::createExternalSamplerImpl(
+        VkDevice device, SamplerYcbcrConversion chroma, SamplerParams params,
+        uint32_t internalFormat) {
+    VkExternalFormatANDROID externalFormat = {
+        .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
+        .pNext = nullptr,
+        .externalFormat = internalFormat,
    };

-    VkPhysicalDeviceMemoryProperties memoryProperties;
-    vkGetPhysicalDeviceMemoryProperties(getPhysicalDevice(), &memoryProperties);
-
-
-    VkMemoryPropertyFlags const requiredMemoryFlags =
-            any(metadata.filamentUsage & TextureUsage::UPLOADABLE)
-                    ? VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
-                    : VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
-
-    uint32_t const memoryTypeIndex = VulkanContext::selectMemoryType(memoryProperties,
-            metadata.memoryTypeBits, requiredMemoryFlags);
-
-    VkMemoryAllocateInfo const allocInfo = {
-        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
-        .pNext = &memoryDedicatedAllocateInfo,
-        .allocationSize = metadata.allocationSize,
-        .memoryTypeIndex = memoryTypeIndex,
+    TextureSwizzle const swizzleArray[] = {chroma.r, chroma.g, chroma.b, chroma.a};
+    VkSamplerYcbcrConversionCreateInfo conversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+        .pNext = &externalFormat,
+        .format = VK_FORMAT_UNDEFINED,
+        .ycbcrModel = fvkutils::getYcbcrModelConversion(chroma.ycbcrModel),
+        .ycbcrRange = fvkutils::getYcbcrRange(chroma.ycbcrRange),
+        .components = fvkutils::getSwizzleMap(swizzleArray),
+        .xChromaOffset = fvkutils::getChromaLocation(chroma.xChromaOffset),
+        .yChromaOffset = fvkutils::getChromaLocation(chroma.yChromaOffset),
+        .chromaFilter = fvkutils::getFilter(chroma.chromaFilter),
    };
-    VkDeviceMemory memory;
-    result = vkAllocateMemory(device, &allocInfo, VKALLOC, &memory);
+    VkSamplerYcbcrConversion conversion = VK_NULL_HANDLE;
+    VkResult result = vkCreateSamplerYcbcrConversion(device, &conversionInfo,
+                                                     nullptr, &conversion);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkAllocateMemory failed with error=" << static_cast<int32_t>(result);
+        << "Unable to create Ycbcr Conversion."
+        << " error=" << static_cast<int32_t>(result);

-    result = vkBindImageMemory(getDevice(), image, memory, 0);
+    VkSamplerYcbcrConversionInfo samplerYcbcrConversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
+        .pNext = nullptr,
+        .conversion = conversion,
+    };
+
+    VkSamplerCreateInfo samplerInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+        .pNext = &samplerYcbcrConversionInfo,
+        .magFilter = fvkutils::getFilter(params.filterMag),
+        .minFilter = fvkutils::getFilter(params.filterMin),
+        .mipmapMode = fvkutils::getMipmapMode(params.filterMin),
+        .addressModeU = fvkutils::getWrapMode(params.wrapS),
+        .addressModeV = fvkutils::getWrapMode(params.wrapT),
+        .addressModeW = fvkutils::getWrapMode(params.wrapR),
+        .anisotropyEnable = params.anisotropyLog2 == 0 ? VK_FALSE : VK_TRUE,
+        .maxAnisotropy = (float)(1u << params.anisotropyLog2),
+        .compareEnable = fvkutils::getCompareEnable(params.compareMode),
+        .compareOp = fvkutils::getCompareOp(params.compareFunc),
+        .minLod = 0.0f,
+        .maxLod = fvkutils::getMaxLod(params.filterMin),
+        .borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
+        .unnormalizedCoordinates = VK_FALSE,
+    };
+    VkSampler sampler;
+    result = vkCreateSampler(device, &samplerInfo, VKALLOC, &sampler);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkBindImageMemory error=" << static_cast<int32_t>(result);
-    return { image, memory };
+        << "Unable to create sampler."
+        << " error=" << static_cast<int32_t>(result);
+    return sampler;
 }

 VulkanPlatform::ExtensionSet VulkanPlatformAndroid::getSwapchainInstanceExtensions() const {
@@ -369,9 +430,20 @@ VulkanPlatform::SurfaceBundle VulkanPlatformAndroid::createVkSurfaceKHR(void* na
 // Deprecated platform dependent helper methods
 VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl() { return {}; }

+VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device) {
+    return ExternalImageMetadata{};
+}
+
+VulkanPlatform::ImageData VulkanPlatform::createExternalImageDataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device,
+        const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
+    return ImageData{};
+}
+
 VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
        VkInstance instance, uint64_t flags) noexcept {
    return SurfaceBundle{};
 }

-} // namespace filament::backend
+}// namespace filament::backend
@@ -63,6 +63,30 @@ VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl(
    return ret;
 }

+VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device) {
+    return {};
+}
+
+VulkanPlatform::ImageData VulkanPlatform::createExternalImageDataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device,
+        const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
+    return {};
+}
+
+VkSampler VulkanPlatform::createExternalSamplerImpl(VkDevice device,
+    SamplerYcbcrConversion chroma,
+    SamplerParams sampler,
+    uint32_t internalFormat) {
+    return VK_NULL_HANDLE;
+}
+
+VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device,
+        SamplerYcbcrConversion chroma, uint32_t internalFormat, VkImage image,
+        VkImageSubresourceRange range, VkImageViewType viewType, VkComponentMapping swizzle) {
+    return VK_NULL_HANDLE;
+}
+
 VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
        VkInstance instance, uint64_t flags) noexcept {
    VkSurfaceKHR surface;
@@ -84,6 +84,30 @@ using namespace bluevk;

 namespace filament::backend {

+VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device) {
+    return {};
+}
+
+VulkanPlatform::ImageData VulkanPlatform::createExternalImageDataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device,
+        const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
+    return {};
+}
+
+VkSampler VulkanPlatform::createExternalSamplerImpl(VkDevice device,
+    SamplerYcbcrConversion chroma,
+    SamplerParams sampler,
+    uint32_t internalFormat) {
+    return VK_NULL_HANDLE;
+}
+
+VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device,
+        SamplerYcbcrConversion chroma, uint32_t internalFormat, VkImage image,
+        VkImageSubresourceRange range, VkImageViewType viewType, VkComponentMapping swizzle) {
+    return VK_NULL_HANDLE;
+}
+
 VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl() {
    VulkanPlatform::ExtensionSet const ret = {
 #if defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
@@ -18,12 +18,12 @@
 #define TNT_FILAMENT_BACKEND_VULKANSWAPCHAIN_IMPL_H

 #include "vulkan/VulkanContext.h"
-#include "vulkan/VulkanConstants.h"

 #include <backend/platforms/VulkanPlatform.h>

 #include <bluevk/BlueVK.h>

+#include <tuple>
 #include <unordered_map>

 using namespace bluevk;
@@ -668,111 +668,4 @@ VkShaderStageFlags getShaderStageFlags(ShaderStageFlags stageFlags) {
    return flags;
 }

-VkSamplerYcbcrModelConversion getYcbcrModelConversion(
-    SamplerYcbcrModelConversion model) {
-    switch (model) {
-    case SamplerYcbcrModelConversion::RGB_IDENTITY:
-        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
-    case SamplerYcbcrModelConversion::YCBCR_IDENTITY:
-        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY;
-    case SamplerYcbcrModelConversion::YCBCR_709:
-        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709;
-    case SamplerYcbcrModelConversion::YCBCR_601:
-        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601;
-    case SamplerYcbcrModelConversion::YCBCR_2020:
-        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020;
-    default:
-        assert_invariant(false &&
-            "Unknown data type, conversion is not supported.");
-    }
-}
-
-VkSamplerYcbcrRange getYcbcrRange(SamplerYcbcrRange range) {
-    switch (range) {
-    case SamplerYcbcrRange::ITU_FULL:
-        return VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
-    case SamplerYcbcrRange::ITU_NARROW:
-        return VK_SAMPLER_YCBCR_RANGE_ITU_NARROW;
-    default:
-        assert_invariant(false &&
-            "Unknown data type, conversion is not supported.");
-    }
-}
-
-VkChromaLocation getChromaLocation(ChromaLocation loc) {
-    switch (loc) {
-    case ChromaLocation::COSITED_EVEN:
-        return VK_CHROMA_LOCATION_COSITED_EVEN;
-    case ChromaLocation::MIDPOINT:
-        return VK_CHROMA_LOCATION_MIDPOINT;
-    default:
-        assert_invariant(false &&
-            "Unknown data type, conversion is not supported.");
-    }
-}
-
-SamplerYcbcrModelConversion getYcbcrModelConversionFilament(VkSamplerYcbcrModelConversion model) {
-    switch (model) {
-        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
-            return SamplerYcbcrModelConversion::RGB_IDENTITY;
-        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
-            return SamplerYcbcrModelConversion::YCBCR_IDENTITY;
-        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709:
-            return SamplerYcbcrModelConversion::YCBCR_709;
-        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601:
-            return SamplerYcbcrModelConversion::YCBCR_601;
-        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020:
-            return SamplerYcbcrModelConversion::YCBCR_2020;
-        default:
-            assert_invariant(false && "Unknown data type, conversion is not supported.");
-            return {};
-    }
-}
-
-SamplerYcbcrRange getYcbcrRangeFilament(VkSamplerYcbcrRange range) {
-    switch (range) {
-        case VK_SAMPLER_YCBCR_RANGE_ITU_FULL:
-            return SamplerYcbcrRange::ITU_FULL;
-        case VK_SAMPLER_YCBCR_RANGE_ITU_NARROW:
-            return SamplerYcbcrRange::ITU_NARROW;
-        default:
-            assert_invariant(false && "Unknown data type, conversion is not supported.");
-            return {};
-    }
-}
-
-ChromaLocation getChromaLocationFilament(VkChromaLocation loc) {
-    switch (loc) {
-        case VK_CHROMA_LOCATION_COSITED_EVEN:
-            return ChromaLocation::COSITED_EVEN;
-        case VK_CHROMA_LOCATION_MIDPOINT:
-            return ChromaLocation::MIDPOINT;
-        default:
-            assert_invariant(false && "Unknown data type, conversion is not supported.");
-            return {};
-    }
-}
-
-TextureSwizzle getSwizzleFilament(VkComponentSwizzle c, uint8_t rgbaIndex) {
-    switch (c) {
-        case VK_COMPONENT_SWIZZLE_ZERO:
-            return TextureSwizzle::SUBSTITUTE_ZERO;
-        case VK_COMPONENT_SWIZZLE_ONE:
-            return TextureSwizzle::SUBSTITUTE_ONE;
-        case VK_COMPONENT_SWIZZLE_IDENTITY:
-            return (TextureSwizzle) (((uint8_t) TextureSwizzle::CHANNEL_0) + rgbaIndex);
-        case VK_COMPONENT_SWIZZLE_R:
-            return TextureSwizzle::CHANNEL_0;
-        case VK_COMPONENT_SWIZZLE_G:
-            return TextureSwizzle::CHANNEL_1;
-        case VK_COMPONENT_SWIZZLE_B:
-            return TextureSwizzle::CHANNEL_2;
-        case VK_COMPONENT_SWIZZLE_A:
-            return TextureSwizzle::CHANNEL_3;
-        default:
-            assert_invariant(false && "Unknown data type, conversion is not supported.");
-            return {};
-    }
-}
-
 } // namespace filament::backend::fvkutils
@@ -69,12 +69,6 @@ VkSamplerYcbcrModelConversion getYcbcrModelConversion(SamplerYcbcrModelConversio
 VkSamplerYcbcrRange getYcbcrRange(SamplerYcbcrRange range);
 VkChromaLocation getChromaLocation(ChromaLocation loc);

-// Ycbcr related functions
-SamplerYcbcrModelConversion getYcbcrModelConversionFilament(VkSamplerYcbcrModelConversion model);
-SamplerYcbcrRange getYcbcrRangeFilament(VkSamplerYcbcrRange range);
-ChromaLocation getChromaLocationFilament(VkChromaLocation loc);
-TextureSwizzle getSwizzleFilament(VkComponentSwizzle c, uint8_t rgbaIndex);
-
 inline VkImageViewType getViewType(SamplerType target) {
    switch (target) {
        case SamplerType::SAMPLER_CUBEMAP:
@@ -348,10 +348,6 @@ using SamplerBitmask = utils::bitset64;
 // general.
 using InputAttachmentBitmask = utils::bitset64;

-constexpr uint8_t MAX_DESCRIPTOR_SET_BITMASK_BITS =
-        std::max(std::max(sizeof(UniformBufferBitmask), sizeof(SamplerBitmask)),
-                sizeof(InputAttachmentBitmask)) * 8;
-
 template<typename Bitmask>
 static constexpr uint8_t getVertexStageShift() noexcept {
    // We assume the bottom half of bits are for vertex stages.
@@ -193,6 +193,49 @@ uint8_t reduceSampleCount(uint8_t sampleCount, VkSampleCountFlags mask) {
    return mostSignificantBit((sampleCount - 1) & mask);
 }

+VkSamplerYcbcrModelConversion getYcbcrModelConversion(
+    SamplerYcbcrModelConversion model) {
+    switch (model) {
+    case SamplerYcbcrModelConversion::RGB_IDENTITY:
+        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
+    case SamplerYcbcrModelConversion::YCBCR_IDENTITY:
+        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY;
+    case SamplerYcbcrModelConversion::YCBCR_709:
+        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709;
+    case SamplerYcbcrModelConversion::YCBCR_601:
+        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601;
+    case SamplerYcbcrModelConversion::YCBCR_2020:
+        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020;
+    default:
+        assert_invariant(false &&
+            "Unknown data type, conversion is not supported.");
+    }
+}
+
+VkSamplerYcbcrRange getYcbcrRange(SamplerYcbcrRange range) {
+    switch (range) {
+    case SamplerYcbcrRange::ITU_FULL:
+        return VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
+    case SamplerYcbcrRange::ITU_NARROW:
+        return VK_SAMPLER_YCBCR_RANGE_ITU_NARROW;
+    default:
+        assert_invariant(false &&
+            "Unknown data type, conversion is not supported.");
+    }
+}
+
+VkChromaLocation getChromaLocation(ChromaLocation loc) {
+    switch (loc) {
+    case ChromaLocation::COSITED_EVEN:
+        return VK_CHROMA_LOCATION_COSITED_EVEN;
+    case ChromaLocation::MIDPOINT:
+        return VK_CHROMA_LOCATION_MIDPOINT;
+    default:
+        assert_invariant(false &&
+            "Unknown data type, conversion is not supported.");
+    }
+}
+
 } // namespace filament::backend::fvkutils

 bool operator<(const VkImageSubresourceRange& a, const VkImageSubresourceRange& b) {
@@ -35,7 +35,6 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <memory>
 #include <sstream>
 #include <string_view>
 #include <utility>
@@ -117,6 +116,7 @@ void printLimits(wgpu::Limits const& limits) {
    printLimit("maxBufferSize", limits.maxBufferSize);
    printLimit("maxVertexAttributes", limits.maxVertexAttributes);
    printLimit("maxVertexBufferArrayStride", limits.maxVertexBufferArrayStride);
+    printLimit("maxInterStageShaderComponents", limits.maxInterStageShaderComponents);
    printLimit("maxInterStageShaderVariables", limits.maxInterStageShaderVariables);
    printLimit("maxColorAttachments", limits.maxColorAttachments);
    printLimit("maxColorAttachmentBytesPerSample", limits.maxColorAttachmentBytesPerSample);
@@ -158,6 +158,8 @@ void printAdapterDetails(wgpu::Adapter const& adapter) {
        FWGPU_LOGI << "  vendor ID: " << adapterInfo.vendorID << utils::io::endl;
        FWGPU_LOGI << "  subgroup min size: " << adapterInfo.subgroupMinSize << utils::io::endl;
        FWGPU_LOGI << "  subgroup max size: " << adapterInfo.subgroupMaxSize << utils::io::endl;
+        FWGPU_LOGI << "  compatibility mode: " << bool(adapterInfo.compatibilityMode)
+                   << utils::io::endl;
        FWGPU_LOGI << "  power preference: " << powerPreferenceStream.str() << utils::io::endl;
    }
    wgpu::SupportedFeatures supportedFeatures{};
@@ -173,17 +175,55 @@ void printAdapterDetails(wgpu::Adapter const& adapter) {
                    FWGPU_LOGI << "  " << nameStream.str().data() << utils::io::endl;
                });
    }
-    wgpu::Limits supportedLimits{};
+    wgpu::SupportedLimits supportedLimits{};
    if (!adapter.GetLimits(&supportedLimits)) {
        FWGPU_LOGW << "Failed to get WebGPU adapter supported limits" << utils::io::endl;
    } else {
        FWGPU_LOGI << "WebGPU adapter supported limits:" << utils::io::endl;
-        printLimits(supportedLimits);
+        printLimits(supportedLimits.limits);
    }
 }
 #endif

-
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+void printSurfaceCapabilitiesDetails(wgpu::SurfaceCapabilities const& capabilities) {
+    std::stringstream usages_stream{};
+    usages_stream << capabilities.usages;
+    FWGPU_LOGI << "WebGPU surface capabilities:" << utils::io::endl;
+    FWGPU_LOGI << "  surface usages: " << usages_stream.str().data() << utils::io::endl;
+    FWGPU_LOGI << "  surface formats (" << capabilities.formatCount << "):" << utils::io::endl;
+    if (capabilities.formatCount > 0 && capabilities.formats != nullptr) {
+        std::for_each(capabilities.formats, capabilities.formats + capabilities.formatCount,
+                [](wgpu::TextureFormat const format) {
+                    std::stringstream format_stream{};
+                    format_stream << format;
+                    FWGPU_LOGI << "    " << format_stream.str().data() << utils::io::endl;
+                });
+    }
+    FWGPU_LOGI << "  surface present modes (" << capabilities.presentModeCount
+               << "):" << utils::io::endl;
+    if (capabilities.presentModeCount > 0 && capabilities.presentModes != nullptr) {
+        std::for_each(capabilities.presentModes,
+                capabilities.presentModes + capabilities.presentModeCount,
+                [](wgpu::PresentMode const presentMode) {
+                    std::stringstream present_mode_stream{};
+                    present_mode_stream << presentMode;
+                    FWGPU_LOGI << "    " << present_mode_stream.str().data() << utils::io::endl;
+                });
+    }
+    FWGPU_LOGI << "  surface alpha modes (" << capabilities.alphaModeCount
+               << "):" << utils::io::endl;
+    if (capabilities.alphaModeCount > 0 && capabilities.alphaModes != nullptr) {
+        std::for_each(capabilities.alphaModes,
+                capabilities.alphaModes + capabilities.alphaModeCount,
+                [](wgpu::CompositeAlphaMode const alphaMode) {
+                    std::stringstream alpha_mode_stream{};
+                    alpha_mode_stream << alphaMode;
+                    FWGPU_LOGI << "    " << alpha_mode_stream.str().data() << utils::io::endl;
+                });
+    }
+}
+#endif

 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
 void printDeviceDetails(wgpu::Device const& device) {
@@ -200,31 +240,24 @@ void printDeviceDetails(wgpu::Device const& device) {
                    FWGPU_LOGI << "  " << nameStream.str().data() << utils::io::endl;
                });
    }
-    wgpu::Limits supportedLimits{};
+    wgpu::SupportedLimits supportedLimits{};
    if (!device.GetLimits(&supportedLimits)) {
        FWGPU_LOGW << "Failed to get WebGPU supported device limits" << utils::io::endl;
    } else {
        FWGPU_LOGI << "WebGPU device supported limits:" << utils::io::endl;
-        printLimits(supportedLimits);
+        printLimits(supportedLimits.limits);
    }
 }
 #endif

 }// namespace

-Driver* WebGPUDriver::create(WebGPUPlatform& platform, const Platform::DriverConfig& driverConfig) noexcept {
-    constexpr size_t defaultSize = FILAMENT_WEBGPU_HANDLE_ARENA_SIZE_IN_MB * 1024U * 1024U;
-    Platform::DriverConfig validConfig {driverConfig};
-    validConfig.handleArenaSize = std::max(driverConfig.handleArenaSize, defaultSize);
-    return new WebGPUDriver(platform, validConfig);
+Driver* WebGPUDriver::create(WebGPUPlatform& platform) noexcept {
+    return new WebGPUDriver(platform);
 }

-WebGPUDriver::WebGPUDriver(WebGPUPlatform& platform, const Platform::DriverConfig& driverConfig) noexcept
-    : mPlatform(platform),
-      mHandleAllocator("Handles",
-              driverConfig.handleArenaSize,
-              driverConfig.disableHandleUseAfterFreeCheck,
-              driverConfig.disableHeapHandleTags) {
+WebGPUDriver::WebGPUDriver(WebGPUPlatform& platform) noexcept
+    : mPlatform(platform) {
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
    printInstanceDetails(mPlatform.getInstance());
 #endif
@@ -309,13 +342,6 @@ void WebGPUDriver::destroyRenderTarget(Handle<HwRenderTarget> rth) {
 }

 void WebGPUDriver::destroySwapChain(Handle<HwSwapChain> sch) {
-    mSwapChain = nullptr;
-    // TODO:  use webgpu handle allocator from
-    //        https://github.com/google/filament/pull/8566
-//    if (sch) {
-//        HwSwapChain* hwSwapChain = handleCast<HwSwapChain*>(sch);
-//        destruct(sch, hwSwapChain);
-//    }
 }

 void WebGPUDriver::destroyStream(Handle<HwStream> sh) {
@@ -331,9 +357,6 @@ void WebGPUDriver::destroyDescriptorSet(Handle<HwDescriptorSet> tqh) {
 }

 Handle<HwSwapChain> WebGPUDriver::createSwapChainS() noexcept {
-    // TODO:  use webgpu handle allocator from.
-    //        https://github.com/google/filament/pull/8566
-    // return allocAndConstructHandle<HwSwapChain>();
    return Handle<HwSwapChain>((Handle<HwSwapChain>::HandleId) mNextFakeHandle++);
 }

@@ -362,7 +385,7 @@ Handle<HwTimerQuery> WebGPUDriver::createTimerQueryS() noexcept {
 }

 Handle<HwIndexBuffer> WebGPUDriver::createIndexBufferS() noexcept {
-    return allocHandle<HwIndexBuffer>();
+    return Handle<HwIndexBuffer>((Handle<HwIndexBuffer>::HandleId) mNextFakeHandle++);
 }

 Handle<HwTexture> WebGPUDriver::createTextureViewS() noexcept {
@@ -419,21 +442,25 @@ Handle<HwTexture> WebGPUDriver::createTextureExternalImagePlaneS() noexcept {
 }

 void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow, uint64_t flags) {
-    // TODO:  use webgpu handle allocator from.
-    //        https://github.com/google/filament/pull/8566
-    // HwSwapChain* hwSwapChain = handleCast<HwSwapChain*>(sch);
-    mSwapChain = nullptr;
-    wgpu::Surface surface = mPlatform.createSurface(nativeWindow, flags);
-    mAdapter = mPlatform.requestAdapter(surface);
+    mSurface= mPlatform.createSurface(nativeWindow, flags);
+    mAdapter = mPlatform.requestAdapter(mSurface);
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
    printAdapterDetails(mAdapter);
+    wgpu::SurfaceCapabilities surfaceCapabilities{};
+    if (!mSurface.GetCapabilities(mAdapter, &surfaceCapabilities)) {
+        FWGPU_LOGW << "Failed to get WebGPU surface capabilities" << utils::io::endl;
+    } else {
+        printSurfaceCapabilitiesDetails(surfaceCapabilities);
+    }
 #endif
    mDevice = mPlatform.requestDevice(mAdapter);
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
    printDeviceDetails(mDevice);
 #endif
    mQueue = mDevice.GetQueue();
-    mSwapChain = std::make_unique<WebGPUSwapChain>(std::move(surface), mAdapter, mDevice, flags);
+    // TODO configure the surface (maybe before or after creating the swapchain?
+    //                             how do we get the surface extent?)
+    // TODO actually create the swapchain
    FWGPU_LOGW << "WebGPU support is still essentially a no-op at this point in development (only "
                  "background components have been instantiated/selected, such as surface/screen, "
                  "graphics device/GPU, etc.), thus nothing is being drawn to the screen."
@@ -446,9 +473,6 @@ void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
                  "rebuilding Filament with that flag, e.g. ./build.sh -x "
               << FWGPU_PRINT_SYSTEM << " ..." << utils::io::endl;
 #endif
-    // TODO:  use webgpu handle allocator from.
-    //        https://github.com/google/filament/pull/8566
-    // hwSwapChain->swapChain = mSwapChain.get();
 }

 void WebGPUDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch, uint32_t width,
@@ -17,13 +17,11 @@
 #ifndef TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H
 #define TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H

-#include "webgpu/WebGPUSwapChain.h"
 #include <backend/platforms/WebGPUPlatform.h>

 #include "DriverBase.h"
 #include "private/backend/Dispatcher.h"
 #include "private/backend/Driver.h"
-#include "private/backend/HandleAllocator.h"
 #include <backend/DriverEnums.h>

 #include <utils/compiler.h>
@@ -31,11 +29,6 @@
 #include <webgpu/webgpu_cpp.h>

 #include <cstdint>
-#include <memory>
-
-#ifndef FILAMENT_WEBGPU_HANDLE_ARENA_SIZE_IN_MB
-#    define FILAMENT_WEBGPU_HANDLE_ARENA_SIZE_IN_MB 8
-#endif

 namespace filament::backend {

@@ -47,26 +40,26 @@ public:
    ~WebGPUDriver() noexcept override;

    [[nodiscard]] Dispatcher getDispatcher() const noexcept final;
-    [[nodiscard]] static Driver* create(WebGPUPlatform& platform, const Platform::DriverConfig& driverConfig) noexcept;
+    [[nodiscard]] static Driver* create(WebGPUPlatform& platform) noexcept;

 private:
-    explicit WebGPUDriver(WebGPUPlatform& platform, const Platform::DriverConfig& driverConfig) noexcept;
+    explicit WebGPUDriver(WebGPUPlatform& platform) noexcept;
    [[nodiscard]] ShaderModel getShaderModel() const noexcept final;
    [[nodiscard]] ShaderLanguage getShaderLanguage() const noexcept final;

    // the platform (e.g. OS) specific aspects of the WebGPU backend are strictly only
    // handled in the WebGPUPlatform
    WebGPUPlatform& mPlatform;
+    wgpu::Surface mSurface = nullptr;
    wgpu::Adapter mAdapter = nullptr;
    wgpu::Device mDevice = nullptr;
    wgpu::Queue mQueue = nullptr;
-    // TODO consider moving to handle allocator when ready
-    std::unique_ptr<WebGPUSwapChain> mSwapChain = nullptr;
    uint64_t mNextFakeHandle = 1;

    /*
     * Driver interface
     */
+
    template<typename T>
    friend class ConcreteDispatcher;

@@ -81,20 +74,8 @@ private:
    UTILS_ALWAYS_INLINE inline void methodName##R(RetType, paramsDecl);

 #include "private/backend/DriverAPI.inc"
-
-    /*
-     * Memory management
-     */
-
-    HandleAllocatorWGPU mHandleAllocator;
-
-    template<typename D>
-    Handle<D> allocHandle() {
-        return mHandleAllocator.allocate<D>();
-    }
-
 };

 }// namespace filament::backend

-#endif // TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H
+#endif// TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H
@@ -1,249 +0,0 @@
-/*
- * 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 "webgpu/WebGPUSwapChain.h"
-
-#include "webgpu/WebGPUConstants.h"
-
-#include "backend/DriverEnums.h"
-
-#include <utils/Panic.h>
-#include <utils/ostream.h>
-
-#include <dawn/webgpu_cpp_print.h>
-#include <webgpu/webgpu_cpp.h>
-
-#include <algorithm>
-#include <cstdint>
-#include <sstream>
-
-namespace {
-
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-void printSurfaceCapabilitiesDetails(wgpu::SurfaceCapabilities const& capabilities) {
-    std::stringstream usagesStream{};
-    usagesStream << capabilities.usages;
-    FWGPU_LOGI << "WebGPU surface capabilities:" << utils::io::endl;
-    FWGPU_LOGI << "  surface usages: " << usagesStream.str().data() << utils::io::endl;
-    FWGPU_LOGI << "  surface formats (" << capabilities.formatCount << "):" << utils::io::endl;
-    if (capabilities.formatCount > 0 && capabilities.formats != nullptr) {
-        std::for_each(capabilities.formats, capabilities.formats + capabilities.formatCount,
-                [](wgpu::TextureFormat const format) {
-                    std::stringstream formatStream{};
-                    formatStream << format;
-                    FWGPU_LOGI << "    " << formatStream.str().data() << utils::io::endl;
-                });
-    }
-    FWGPU_LOGI << "  surface present modes (" << capabilities.presentModeCount
-               << "):" << utils::io::endl;
-    if (capabilities.presentModeCount > 0 && capabilities.presentModes != nullptr) {
-        std::for_each(capabilities.presentModes,
-                capabilities.presentModes + capabilities.presentModeCount,
-                [](wgpu::PresentMode const presentMode) {
-                    std::stringstream presentModeStream{};
-                    presentModeStream << presentMode;
-                    FWGPU_LOGI << "    " << presentModeStream.str().data() << utils::io::endl;
-                });
-    }
-    FWGPU_LOGI << "  surface alpha modes (" << capabilities.alphaModeCount
-               << "):" << utils::io::endl;
-    if (capabilities.alphaModeCount > 0 && capabilities.alphaModes != nullptr) {
-        std::for_each(capabilities.alphaModes,
-                capabilities.alphaModes + capabilities.alphaModeCount,
-                [](wgpu::CompositeAlphaMode const alphaMode) {
-                    std::stringstream alphaModeStream{};
-                    alphaModeStream << alphaMode;
-                    FWGPU_LOGI << "    " << alphaModeStream.str().data() << utils::io::endl;
-                });
-    }
-}
-#endif
-
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-void printSurfaceConfiguration(wgpu::SurfaceConfiguration const& config) {
-    std::stringstream formatStream{};
-    formatStream << config.format;
-    std::stringstream usageStream{};
-    usageStream << config.usage;
-    std::stringstream alphaModeStream{};
-    alphaModeStream << config.alphaMode;
-    std::stringstream presentModeStream{};
-    presentModeStream << config.presentMode;
-    FWGPU_LOGI << "WebGPU surface configuration:" << utils::io::endl;
-    FWGPU_LOGI << "  surface format: " << formatStream.str() << utils::io::endl;
-    FWGPU_LOGI << "  surface usage: " << usageStream.str() << utils::io::endl;
-    FWGPU_LOGI << "  surface view formats (" << config.viewFormatCount << "):" << utils::io::endl;
-    if (config.viewFormatCount > 0 && config.viewFormats != nullptr) {
-        std::for_each(config.viewFormats, config.viewFormats + config.viewFormatCount,
-                [](wgpu::TextureFormat const viewFormat) {
-                    std::stringstream viewFormatStream{};
-                    viewFormatStream << viewFormat;
-                    FWGPU_LOGI << "    " << viewFormatStream.str().data() << utils::io::endl;
-                });
-    }
-    FWGPU_LOGI << "  surface alpha mode: " << alphaModeStream.str() << utils::io::endl;
-    FWGPU_LOGI << "  surface width: " << config.width << utils::io::endl;
-    FWGPU_LOGI << "  surface height: " << config.height << utils::io::endl;
-    FWGPU_LOGI << "  surface present mode: " << presentModeStream.str() << utils::io::endl;
-}
-#endif
-
-wgpu::TextureFormat selectColorFormat(size_t availableFormatsCount,
-        wgpu::TextureFormat const* availableFormats, bool useSRGBColorSpace) {
-    const std::array expectedColorFormats =
-            useSRGBColorSpace ?
-                              std::array{
-                                  wgpu::TextureFormat::RGBA8UnormSrgb,
-                                  wgpu::TextureFormat::BGRA8UnormSrgb }
-                              : std::array{
-                                    wgpu::TextureFormat::RGBA8Unorm,
-                                    wgpu::TextureFormat::BGRA8Unorm };
-    auto const firstFoundColorFormat = std::find_first_of(expectedColorFormats.begin(),
-            expectedColorFormats.end(), availableFormats, availableFormats + availableFormatsCount);
-    FILAMENT_CHECK_POSTCONDITION(firstFoundColorFormat != expectedColorFormats.end())
-            << "Cannot find a suitable WebGPU swapchain "
-            << (useSRGBColorSpace ? "sRGB" : "non-standard (e.g. linear) RGB") << " color format";
-    return *firstFoundColorFormat;
-}
-
-wgpu::PresentMode selectPresentMode(size_t availablePresentModesCount,
-        wgpu::PresentMode const* availablePresentModes) {
-    // Verify that our chosen present mode is supported. In practice all devices support the FIFO
-    // mode, but we check for it anyway for completeness.  (and to avoid validation warnings)
-    const wgpu::PresentMode desiredPresentMode = wgpu::PresentMode::Fifo;
-    FILAMENT_CHECK_POSTCONDITION(
-            std::any_of(availablePresentModes, availablePresentModes + availablePresentModesCount,
-                    [](const wgpu::PresentMode availablePresentMode) {
-                        return availablePresentMode == desiredPresentMode;
-                    }))
-            << "Cannot find a suitable WebGPU swapchain present mode";
-    return desiredPresentMode;
-}
-
-wgpu::CompositeAlphaMode selectAlphaMode(size_t availableAlphaModesCount,
-        wgpu::CompositeAlphaMode const* availableAlphaModes) {
-    bool autoAvailable = false;
-    bool inheritAvailable = false;
-    bool opaqueAvailable = false;
-    bool premultipliedAvailable = false;
-    bool unpremultipliedAvailable = false;
-    std::for_each(availableAlphaModes, availableAlphaModes + availableAlphaModesCount,
-            [&](const wgpu::CompositeAlphaMode alphMode) {
-                switch (alphMode) {
-                    // in practice, the surface capabilities would not list Auto,
-                    // but for completeness and defensive programming we can leverage it
-                    // if it explicitly comes back as available/supported
-                    case wgpu::CompositeAlphaMode::Auto:
-                        autoAvailable = true;
-                        break;
-                    case wgpu::CompositeAlphaMode::Opaque:
-                        opaqueAvailable = true;
-                        break;
-                    case wgpu::CompositeAlphaMode::Premultiplied:
-                        premultipliedAvailable = true;
-                        break;
-                    case wgpu::CompositeAlphaMode::Unpremultiplied:
-                        unpremultipliedAvailable = true;
-                        break;
-                    case wgpu::CompositeAlphaMode::Inherit:
-                        inheritAvailable = true;
-                        break;
-                }
-            });
-    if (autoAvailable || inheritAvailable || opaqueAvailable) {
-        return wgpu::CompositeAlphaMode::Auto;
-    } else if (premultipliedAvailable) {
-        // In practice, we do not expect this to possibly happen, as opaque should be supported,
-        // which we select first. However, if the underlying system actually does not support
-        // opaque we allow it to be tested, but warn that this may not likely work as they expect
-        // (untested territory).
-        // We prefer premultiplied to unpremuliplied until that assumption should be adjusted.
-        FWGPU_LOGW << "Auto, Inherit, & Opaque composite alpha modes not supported. Filament has "
-                      "historically used these. Premultiplied alpha composite mode for "
-                      "transparency is being selected as a fallback, but may not work as expected."
-                   << utils::io::endl;
-        return wgpu::CompositeAlphaMode::Premultiplied;
-    } else {
-        FILAMENT_CHECK_POSTCONDITION(unpremultipliedAvailable)
-                << "No available composite alpha modes? Unknown/unhandled composite alpha mode?";
-        // Again, we don't expect this in practice, but allow if for the same reason as premultiplied.
-        // We prefer premultiplied to unpremuliplied until that assumption should be adjusted.
-        FWGPU_LOGW << "Auto, Inherit, & Opaque composite alpha modes not supported. Filament has "
-                      "historically used these. Unpremultiplied alpha composite mode for "
-                      "transparency is being selected as a fallback "
-                      "(premulitipled is not available either), but may not work as expected."
-                   << utils::io::endl;
-        return wgpu::CompositeAlphaMode::Unpremultiplied;
-    }
-}
-
-void initConfig(wgpu::SurfaceConfiguration& config, wgpu::Device& device,
-        wgpu::SurfaceCapabilities const& capabilities, bool useSRGBColorSpace) {
-    config.device = device;
-    config.usage = wgpu::TextureUsage::RenderAttachment;
-    config.format =
-            selectColorFormat(capabilities.formatCount, capabilities.formats, useSRGBColorSpace);
-    config.presentMode =
-            selectPresentMode(capabilities.presentModeCount, capabilities.presentModes);
-    config.alphaMode = selectAlphaMode(capabilities.alphaModeCount, capabilities.alphaModes);
-}
-
-}// namespace
-
-namespace filament::backend {
-
-WebGPUSwapChain::WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Adapter& adapter,
-        wgpu::Device& device, uint64_t flags)
-    : mSurface(surface) {
-    wgpu::SurfaceCapabilities capabilities = {};
-    if (!mSurface.GetCapabilities(adapter, &capabilities)) {
-        FWGPU_LOGW << "Failed to get WebGPU surface capabilities" << utils::io::endl;
-    } else {
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-        printSurfaceCapabilitiesDetails(capabilities);
-#endif
-    }
-    const bool useSRGBColorSpace = (flags & SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0;
-    initConfig(mConfig, device, capabilities, useSRGBColorSpace);
-}
-
-WebGPUSwapChain::~WebGPUSwapChain() {
-    if (mConfigured) {
-        mSurface.Unconfigure();
-        mConfigured = false;
-    }
-}
-
-void WebGPUSwapChain::GetCurrentTexture(uint32_t width, uint32_t height, wgpu::SurfaceTexture* texture) {
-    if (width < 1 || height < 1) {
-        PANIC_LOG("WebGPUSwapChain::GetCurrentTexture: Invalid width and/or height requested.");
-        return;
-    }
-    if (mConfig.width != width || mConfig.height != height || !mConfigured) {
-        mConfig.width = width;
-        mConfig.height = height;
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-        printSurfaceConfiguration(mConfig);
-#endif
-        mSurface.Configure(&mConfig);
-        mConfigured = true;
-        return;
-    }
-
-    mSurface.GetCurrentTexture(texture);
-}
-
-}// namespace filament::backend
@@ -1,44 +0,0 @@
-/*
- * 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_WEBGPUSWAPCHAIN_H
-#define TNT_FILAMENT_BACKEND_WEBGPUSWAPCHAIN_H
-
-#include <webgpu/webgpu_cpp.h>
-
-#include <backend/Platform.h>
-
-#include <cstdint>
-
-namespace filament::backend {
-
-class WebGPUSwapChain : public Platform::SwapChain {
-public:
-    WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Adapter& adapter, wgpu::Device& device,
-            uint64_t flags);
-    ~WebGPUSwapChain();
-
-    void GetCurrentTexture(uint32_t width, uint32_t height, wgpu::SurfaceTexture*);
-
-private:
-    wgpu::Surface mSurface = {};
-    wgpu::SurfaceConfiguration mConfig = {};
-    bool mConfigured = false;
-};
-
-} // namespace filament::backend
-
-#endif //TNT_FILAMENT_BACKEND_WEBGPUSWAPCHAIN_H
@@ -144,13 +144,13 @@ wgpu::Device WebGPUPlatform::requestDevice(wgpu::Adapter const& adapter) {
 }

 Driver* WebGPUPlatform::createDriver(void* sharedContext,
-        const Platform::DriverConfig& driverConfig) noexcept {
+        const Platform::DriverConfig& /*driverConfig*/) noexcept {
    if (sharedContext) {
        FWGPU_LOGW << "sharedContext is ignored/unused in the WebGPU backend. A non-null "
                      "sharedContext was provided, but it will be ignored."
                   << utils::io::endl;
    }
-    return WebGPUDriver::create(*this, driverConfig);
+    return WebGPUDriver::create(*this);
 }

 WebGPUPlatform::WebGPUPlatform()
@@ -22,8 +22,6 @@

 #include <cstdint>

-#include <Windows.h>
-
 /**
 * Windows OS specific implementation aspects of the WebGPU backend
 */
@@ -43,12 +41,12 @@ wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags
    wgpu::SurfaceSourceWindowsHWND surfaceSourceWin{};
    surfaceSourceWin.hinstance = GetModuleHandle(nullptr);
    surfaceSourceWin.hwnd = nativeWindow;
-    const wgpu::SurfaceDescriptor surfaceDescriptor{
+    wgpu::SurfaceDescriptor surfaceDescriptor{
        .nextInChain = &surfaceSourceWin,
        .label = "windows_surface"
    };
    wgpu::Surface surface = mInstance.CreateSurface(&surfaceDescriptor);
-    FILAMENT_CHECK_POSTCONDITION(surface.Get() != nullptr) << "Unable to create Windows-backed surface.";
+    FILAMENT_CHECK_POSTCONDITION(surface != nullptr) << "Unable to create Windows-backed surface.";
    return surface;
 }

@@ -23,44 +23,30 @@ namespace test {

 using namespace filament::backend;

-Shader::Shader(DriverApi& api, Cleanup& cleanup, ShaderConfig config) : mCleanup(cleanup) {
-    utils::FixedCapacityVector<DescriptorSetLayoutBinding> kLayouts(config.uniforms.size());
-    for (unsigned char i = 0; i < config.uniforms.size(); ++i) {
-        kLayouts[i] = {
-                config.uniforms[i].type.value_or(DescriptorType::UNIFORM_BUFFER),
-                ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, i };
-    }
+Shader::Shader(DriverApi& api, Cleanup& cleanup, ShaderConfig config) {
+    utils::FixedCapacityVector<DescriptorSetLayoutBinding> kLayouts(config.uniformNames.size());
+    for (unsigned char i = 0; i < config.uniformNames.size(); ++i) {
+        kLayouts[i] =
+                { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, i };
+    };

-    // This assumes that the uniforms will all be in a single descriptor set at index 1.
-    // If there are shaders with uniforms in other sets then ShaderConfig will need to be expanded
-    // to accommodate that.
-    size_t kDescriptorSetIndex = 1;
    filamat::DescriptorSets descriptors;
-    descriptors[kDescriptorSetIndex] = filamat::DescriptorSetInfo(config.uniforms.size());
-    for (unsigned char i = 0; i < config.uniforms.size(); ++i) {
-        descriptors[kDescriptorSetIndex][i] = {
-                config.uniforms[i].name, kLayouts[i], config.uniforms[i].samplerInfo };
+    for (unsigned char i = 0; i < config.uniformNames.size(); ++i) {
+        descriptors[i + 1] = {{ config.uniformNames[i], kLayouts[i], {}}};
    }
    ShaderGenerator shaderGen(
            std::move(config.vertexShader), std::move(config.fragmentShader), BackendTest::sBackend,
            BackendTest::sIsMobilePlatform, std::move(descriptors));
    Program prog = shaderGen.getProgram(api);
-
-    Program::DescriptorBindingsInfo bindingsInfo(config.uniforms.size());
-    for (unsigned char i = 0; i < config.uniforms.size(); ++i) {
-        bindingsInfo[i] = {
-                config.uniforms[i].name,
-                config.uniforms[i].type.value_or(DescriptorType::UNIFORM_BUFFER), i };
+    for (unsigned char i = 0; i < config.uniformNames.size(); ++i) {
+        prog.descriptorBindings(1, {{ config.uniformNames[i], DescriptorType::UNIFORM_BUFFER, i }});
    }
-    prog.descriptorBindings(1, bindingsInfo);
    mProgram = cleanup.add(api.createProgram(std::move(prog)));

    mDescriptorSetLayout = cleanup.add(
            api.createDescriptorSetLayout(DescriptorSetLayout{ kLayouts }));
-}

-filament::backend::DescriptorSetHandle Shader::createDescriptorSet(DriverApi& api) const {
-    return mCleanup.add(api.createDescriptorSet(mDescriptorSetLayout));
+    mDescriptorSet = cleanup.add(api.createDescriptorSet(mDescriptorSetLayout));
 }

 filament::backend::ProgramHandle Shader::getProgram() const {
@@ -71,4 +57,8 @@ filament::backend::DescriptorSetLayoutHandle Shader::getDescriptorSetLayout() co
    return mDescriptorSetLayout;
 }

+filament::backend::DescriptorSetHandle Shader::getDescriptorSet() const {
+    return mDescriptorSet;
+}
+
 } // namespace test
@@ -18,22 +18,14 @@
 #define TNT_SHADER_H

 #include "Lifetimes.h"
-#include "private/filament/SamplerInterfaceBlock.h"

 namespace test {

-struct UniformConfig {
-    utils::CString name;
-    // If not specified this will be DescriptorType::UNIFORM_BUFFER
-    std::optional<filament::backend::DescriptorType> type;
-    std::optional<filament::SamplerInterfaceBlock::SamplerInfo> samplerInfo;
-};
-
 // All describing a shader that should be created.
 struct ShaderConfig {
    std::string vertexShader;
    std::string fragmentShader;
-    std::vector<UniformConfig> uniforms;
+    std::vector<utils::CString> uniformNames;
 };

 // All values describing a uniform.
@@ -43,7 +35,6 @@ struct ResolvedUniformBindingConfig {
    uint32_t byteOffset;
    filament::backend::descriptor_set_t set;
    filament::backend::descriptor_binding_t binding;
-    std::optional<filament::backend::DescriptorSetHandle> descriptorSet;
 };

 // An equivalent to ResolvedUniformBindingConfig with all fields optional.
@@ -55,7 +46,6 @@ struct UniformBindingConfig {
    std::optional<uint32_t> byteOffset;
    std::optional<filament::backend::descriptor_set_t> set;
    std::optional<filament::backend::descriptor_binding_t> binding;
-    std::optional<filament::backend::DescriptorSetHandle> descriptorSet;

    template<typename UniformType>
    ResolvedUniformBindingConfig resolve();
@@ -89,14 +79,12 @@ public:

    filament::backend::ProgramHandle getProgram() const;
    filament::backend::DescriptorSetLayoutHandle getDescriptorSetLayout() const;
-
-    filament::backend::DescriptorSetHandle createDescriptorSet(
-            filament::backend::DriverApi& api) const;
+    filament::backend::DescriptorSetHandle getDescriptorSet() const;

 protected:
-    Cleanup& mCleanup;
    filament::backend::ProgramHandle mProgram;
    filament::backend::DescriptorSetLayoutHandle mDescriptorSetLayout;
+    filament::backend::DescriptorSetHandle mDescriptorSet;
 };

 template<typename UniformType>
@@ -107,8 +95,7 @@ ResolvedUniformBindingConfig UniformBindingConfig::resolve() {
            .bufferSize = bufferSize.value_or(resolvedDataSize),
            .byteOffset = byteOffset.value_or(0),
            .set = set.value_or(1),
-            .binding = binding.value_or(0),
-            .descriptorSet = descriptorSet
+            .binding = binding.value_or(0)
    };
 }

@@ -133,16 +120,9 @@ void Shader::bindUniform(filament::backend::DriverApi& api,
        UniformBindingConfig config) const {
    auto resolvedConfig = config.resolve<UniformType>();

-    filament::backend::DescriptorSetHandle descriptorSet;
-    if (resolvedConfig.descriptorSet.has_value()) {
-        descriptorSet = *resolvedConfig.descriptorSet;
-    } else {
-        descriptorSet = createDescriptorSet(api);
-    }
-
-    api.updateDescriptorSetBuffer(descriptorSet, resolvedConfig.binding, hwBuffer, 0,
+    api.updateDescriptorSetBuffer(getDescriptorSet(), resolvedConfig.binding, hwBuffer, 0,
            resolvedConfig.bufferSize);
-    api.bindDescriptorSet(descriptorSet, resolvedConfig.set, {});
+    api.bindDescriptorSet(getDescriptorSet(), resolvedConfig.set, {});
 }

 template<typename UniformType>
@@ -1,253 +0,0 @@
-/*
- * Copyright (C) 2021 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 "SharedShaders.h"
-
-#include "Shader.h"
-#include "absl/strings/str_format.h"
-#include "gtest/gtest.h"
-
-namespace test {
-
-using namespace filament::backend;
-
-namespace {
-
-// A shader stored in pieces so that uniform declarations can be injected.
-struct ShaderText {
-    std::string mPrefix;
-    std::string mBody;
-
-    std::string withUniform(const std::string& uniformText) const {
-        return absl::StrFormat("%s\n%s\n%s", mPrefix.c_str(), uniformText.c_str(), mBody.c_str());
-    }
-};
-
-std::optional<ShaderText> GetGlslVertexShader(VertexShaderType type) {
-    switch (type) {
-        case VertexShaderType::Noop: {
-            return ShaderText{
-                    R"(
-#version 450 core
-layout(location = 0) in vec4 mesh_position;
-)", R"(
-void main() {
-    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
-#if defined(TARGET_VULKAN_ENVIRONMENT)
-    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
-    gl_Position.y = -gl_Position.y;
-#endif
-})" };
-        }
-        case VertexShaderType::Simple: {
-            return ShaderText{
-                    R"(
-#version 450 core
-layout(location = 0) in vec4 mesh_position;
-)", R"(
-void main() {
-    gl_Position = vec4(
-            mesh_position.xy * (params.scaleMinusOne.xy + 1.0) + params.offset.xy,
-            params.scaleMinusOne.z + 1.0,
-            1.0);
-#if defined(TARGET_VULKAN_ENVIRONMENT)
-    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
-    gl_Position.y = -gl_Position.y;
-#endif
-})" };
-        }
-        case VertexShaderType::Textured: {
-            return ShaderText{
-                    R"(
-#version 450 core
-layout(location = 0) in vec4 mesh_position;
-layout(location = 0) out vec2 uv;
-)", R"(
-void main() {
-    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
-    uv = (mesh_position.xy * 0.5 + 0.5);
-#if defined(TARGET_VULKAN_ENVIRONMENT)
-    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
-    gl_Position.y = -gl_Position.y;
-#endif
-})" };
-        }
-        default:
-            return std::nullopt;
-    }
-}
-
-std::optional<ShaderText> GetGlslFragmentShader(FragmentShaderType type) {
-    switch (type) {
-        case FragmentShaderType::White: {
-            return ShaderText{
-                    R"(
-#version 450 core
-precision mediump int; precision highp float;
-layout(location = 0) out vec4 fragColor;
-)", R"(
-void main() {
-    fragColor = vec4(1.0, 1.0, 1.0, 1.0);
-})" };
-        }
-        case FragmentShaderType::SolidColored: {
-            return ShaderText{
-                    R"(
-#version 450 core
-precision mediump int; precision highp float;
-layout(location = 0) out vec4 fragColor;
-)", R"(
-void main() {
-    fragColor = params.color;
-})" };
-        }
-        case FragmentShaderType::Textured: {
-            return ShaderText{
-                    R"(
-#version 450 core
-precision mediump int; precision highp float;
-layout(location = 0) out vec4 fragColor;
-layout(location = 0) in vec2 uv;
-)", R"(
-void main() {
-    fragColor = texture(test_tex, uv);
-})" };
-        }
-        default:
-            return std::nullopt;
-    }
-}
-
-std::optional<std::string> GetGlslUniform(ShaderUniformType type) {
-    switch (type) {
-        case ShaderUniformType::None: {
-            return "";
-        }
-        case ShaderUniformType::Simple: {
-            return R"(
-layout(binding = 0, set = 1) uniform Params {
-    highp vec4 color;
-    // Use scaleMinusOne instead of scale so that a 0 initialized value is a good default
-    highp vec4 scaleMinusOne;
-    highp vec4 offset;
-} params;
-)";
-        }
-        case ShaderUniformType::SimpleWithPadding: {
-            return R"(
-layout(binding = 0, set = 1) uniform Params {
-    highp vec4 padding[4];  // offset of 64 bytes
-
-    highp vec4 color;
-    // Use scaleMinusOne instead of scale so that a 0 initialized value is a good default
-    highp vec4 scaleMinusOne;
-    highp vec4 offset;
-} params;
-)";
-        }
-        case ShaderUniformType::Sampler: {
-            return R"(
-layout(location = 0, set = 1) uniform sampler2D test_tex;
-)";
-        }
-        default:
-            return std::nullopt;
-    }
-}
-
-std::vector<UniformConfig> GetUniformConfig(ShaderUniformType type) {
-    switch (type) {
-        case ShaderUniformType::None: {
-            return {};
-        }
-        case ShaderUniformType::Simple: {
-            return {{ "Params" }};
-        }
-        case ShaderUniformType::SimpleWithPadding: {
-            return {{ "Params" }};
-        }
-        case ShaderUniformType::Sampler: {
-            filament::SamplerInterfaceBlock::SamplerInfo samplerInfo{
-                    "backend_test", "test_tex", 0,
-                    SamplerType::SAMPLER_2D, SamplerFormat::FLOAT, Precision::HIGH, false };
-            return {{
-                            "test_tex", DescriptorType::SAMPLER, samplerInfo
-                    }};
-        }
-        default:
-            abort();
-    }
-}
-
-ShaderLanguage getShaderLanguage(const Backend& backend) {
-    switch (backend) {
-        case Backend::METAL:
-            return ShaderLanguage::MSL;
-        case Backend::WEBGPU:
-            return ShaderLanguage::WGSL;
-        case Backend::VULKAN:
-        case Backend::NOOP:
-        case Backend::OPENGL:
-        default: {
-            return ShaderLanguage::GLSL;
-        }
-    }
-}
-
-} // namespace
-
-Shader SharedShaders::makeShader(filament::backend::DriverApi& api, Cleanup& cleanup,
-        ShaderRequest request) {
-    std::optional<ShaderText> vertex;
-    std::optional<ShaderText> fragment;
-    std::optional<std::string> uniform;
-    if (getShaderLanguage(BackendTest::sBackend) != ShaderLanguage::GLSL) {
-        // TODO: If any shaders need backend/shader language specific shaders rather than transpiled
-        // versions of the GLSL shader, check environment.
-    }
-    vertex = GetGlslVertexShader(request.mVertexType);
-    fragment = GetGlslFragmentShader(request.mFragmentType);
-    uniform = GetGlslUniform(request.mUniformType);
-    if (vertex.has_value() && fragment.has_value() && uniform.has_value()) {
-        return Shader(
-                api, cleanup, ShaderConfig{
-                        vertex->withUniform(*uniform), fragment->withUniform(*uniform),
-                        GetUniformConfig(request.mUniformType)}
-        );
-    }
-    abort();
-}
-
-std::string SharedShaders::getVertexShaderText(VertexShaderType vertex, ShaderUniformType uniform) {
-    std::optional<ShaderText> vertexText = GetGlslVertexShader(vertex);
-    std::optional<std::string> uniformText = GetGlslUniform(uniform);
-    if (!vertexText.has_value() || !uniformText.has_value()) {
-        abort();
-    }
-    return vertexText->withUniform(*uniformText);
-}
-
-std::string SharedShaders::getFragmentShaderText(FragmentShaderType fragment,
-        ShaderUniformType uniform) {
-    std::optional<ShaderText> fragmentText = GetGlslFragmentShader(fragment);
-    std::optional<std::string> uniformText = GetGlslUniform(uniform);
-    if (!fragmentText.has_value() || !uniformText.has_value()) {
-        abort();
-    }
-    return fragmentText->withUniform(*uniformText);
-}
-
-} // namespace test
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2021 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_SHAREDSHADERS_H
-#define TNT_SHAREDSHADERS_H
-
-#include "Shader.h"
-#include "SharedShadersConstants.h"
-#include "Lifetimes.h"
-#include "PlatformRunner.h"
-
-namespace test {
-
-enum class ShaderLanguage : uint8_t {
-    GLSL,
-    MSL,
-    WGSL
-};
-
-struct ShaderRequest {
-    VertexShaderType mVertexType;
-    FragmentShaderType mFragmentType;
-    ShaderUniformType mUniformType;
-};
-
-class SharedShaders {
-public:
-    static Shader makeShader(filament::backend::DriverApi& api, Cleanup& cleanup,
-            ShaderRequest request);
-    static std::string getVertexShaderText(VertexShaderType vertex, ShaderUniformType uniform);
-    static std::string getFragmentShaderText(FragmentShaderType fragment,
-            ShaderUniformType uniform);
-};
-
-} // namespace test
-
-#endif //TNT_SHAREDSHADERS_H
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2021 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_SHAREDSHADERSCONSTANTS_H
-#define TNT_SHAREDSHADERSCONSTANTS_H
-
-#include "math/mathfwd.h"
-
-enum class ShaderUniformType : uint8_t {
-    None,
-    Simple,
-    SimpleWithPadding,
-    Sampler,
-};
-
-struct SimpleMaterialParams {
-    filament::math::float4 color;
-    // 1.0 will be added to this value before use.
-    // The XY values are used to scale position inputs and the Z value is used to set the output
-    // position's Z value.
-    filament::math::float4 scaleMinusOne;
-    // Offset will be applied after scale
-    filament::math::float4 offset;
-};
-
-struct SimpleWithPaddingMaterialParams {
-    // The associated uniform structure in the shader will have 64 bytes of padding at the beginning
-    // So users of this struct will need to add 64 bytes to its size and offset all uniform writes.
-    filament::math::float4 color;
-    // 1.0 will be added to this value before use.
-    // The XY values are used to scale position inputs and the Z value is used to set the output
-    // position's Z value.
-    filament::math::float4 scaleMinusOne;
-    // Offset will be applied after scale
-    filament::math::float4 offset;
-};
-
-enum class VertexShaderType : uint8_t {
-    Noop,
-    Simple,
-    Textured
-};
-
-enum class FragmentShaderType : uint8_t {
-    White,
-    SolidColored,
-    Textured
-};
-
-#endif //TNT_SHAREDSHADERSCONSTANTS_H
@@ -19,7 +19,6 @@
 #include "ImageExpectations.h"
 #include "Lifetimes.h"
 #include "Shader.h"
-#include "SharedShaders.h"
 #include "TrianglePrimitive.h"

 #include <utils/Hash.h>
@@ -41,14 +40,48 @@ using namespace filament::backend;
 using namespace filament::math;
 using namespace utils;

+struct MaterialParams {
+    float4 color;
+    float4 scale;
+};
+
 class BlitTest : public BackendTest {
 public:
    BlitTest() : mCleanup(getDriverApi()) {}

 protected:
+    Shader createShader();
+
    Cleanup mCleanup;
 };

+static const char* const triangleVs = R"(#version 450 core
+layout(location = 0) in vec4 mesh_position;
+layout(binding = 0, set = 1) uniform Params { highp vec4 color; highp vec4 scale; } params;
+void main() {
+    gl_Position = vec4((mesh_position.xy + 0.5) * params.scale.xy, params.scale.z, 1.0);
+#if defined(TARGET_VULKAN_ENVIRONMENT)
+    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
+    gl_Position.y = -gl_Position.y;
+#endif
+})";
+
+static const char* const triangleFs = R"(#version 450 core
+precision mediump int; precision highp float;
+layout(location = 0) out vec4 fragColor;
+layout(binding = 0, set = 1) uniform Params { highp vec4 color; highp vec4 scale; } params;
+void main() {
+    fragColor = params.color;
+})";
+
+Shader BlitTest::createShader() {
+    return Shader(getDriverApi(), mCleanup, ShaderConfig{
+            .vertexShader = triangleVs,
+            .fragmentShader = triangleFs,
+            .uniformNames = { "Params" },
+    });
+}
+
 static uint32_t toUintColor(float4 color) {
    color = saturate(color);
    uint32_t r = color.r * 255.0f;
@@ -280,11 +313,7 @@ TEST_F(BlitTest, ColorResolve) {
    constexpr auto kColorTexFormat = TextureFormat::RGBA8;
    constexpr int kSampleCount = 4;

-    Shader shader = SharedShaders::makeShader(api, mCleanup, ShaderRequest{
-            .mVertexType = VertexShaderType::Simple,
-            .mFragmentType = FragmentShaderType::SolidColored,
-            .mUniformType = ShaderUniformType::Simple,
-    });
+    Shader shader = createShader();

    // Create a VertexBuffer, IndexBuffer, and RenderPrimitive.
    TrianglePrimitive const triangle(api);
@@ -327,15 +356,14 @@ TEST_F(BlitTest, ColorResolve) {
    state.rasterState.depthFunc = RasterState::DepthFunc::A;
    state.rasterState.culling = CullingMode::NONE;

-    auto ubuffer = mCleanup.add(api.createBufferObject(sizeof(SimpleMaterialParams),
+    auto ubuffer = mCleanup.add(api.createBufferObject(sizeof(MaterialParams),
            BufferObjectBinding::UNIFORM, BufferUsage::STATIC));
    // Draw red triangle into srcRenderTarget.
-    shader.uploadUniform(api, ubuffer, SimpleMaterialParams{
-        .color = float4(1, 0, 0, 1),
-        .scaleMinusOne = float4(0, 0, -0.5, 0),
-        .offset = float4(0.5, 0.5, 0, 0),
+    shader.uploadUniform(api, ubuffer, MaterialParams{
+            .color = float4(1, 0, 0, 1),
+            .scale = float4(1, 1, 0.5, 0),
    });
-    shader.bindUniform<SimpleMaterialParams>(api, ubuffer);
+    shader.bindUniform<MaterialParams>(api, ubuffer);

    // FIXME: on Metal this triangle is not drawn. Can't understand why.
    {
@@ -18,18 +18,72 @@

 #include "Lifetimes.h"
 #include "Shader.h"
-#include "SharedShaders.h"
+#include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"

+namespace {
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Shaders
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+std::string vertex (R"(#version 450 core
+
+layout(location = 0) in vec4 mesh_position;
+
+layout(location = 0) out uvec4 indices;
+
+layout(binding = 0, set = 1) uniform Params {
+    highp vec4 padding[4];  // offset of 64 bytes
+
+    highp vec4 color;
+    highp vec4 offset;
+} params;
+
+void main() {
+    gl_Position = vec4(mesh_position.xy + params.offset.xy, 0.0, 1.0);
+#if defined(TARGET_VULKAN_ENVIRONMENT)
+    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
+    gl_Position.y = -gl_Position.y;
+#endif
+}
+)");
+
+std::string fragment (R"(#version 450 core
+
+layout(location = 0) out vec4 fragColor;
+
+layout(binding = 0, set = 1) uniform Params {
+    highp vec4 padding[4];  // offset of 64 bytes
+
+    highp vec4 color;
+    highp vec4 offset;
+} params;
+
+void main() {
+    fragColor = vec4(params.color.rgb, 1.0f);
+}
+
+)");
+
+}
+
 namespace test {

 using namespace filament;
 using namespace filament::backend;

+// In the shader, these MaterialParams are offset by 64 bytes into the uniform buffer to test buffer
+// updates with offset.
+struct MaterialParams {
+    math::float4 color;
+    math::float4 offset;
+};
+static_assert(sizeof(MaterialParams) == 8 * sizeof(float));
 // Uniform config for writing MaterialParams to the shader uniform with 64 bytes of padding.
 const UniformBindingConfig kBindingConfig = {
-        .dataSize = sizeof(SimpleMaterialParams),
-        .bufferSize = sizeof(SimpleMaterialParams) + 64,
+        .dataSize = sizeof(MaterialParams),
+        .bufferSize = sizeof(MaterialParams) + 64,
        .byteOffset = 64
 };

@@ -39,10 +93,8 @@ public:

 protected:
    Shader createShader() {
-        return SharedShaders::makeShader(getDriverApi(), mCleanup, ShaderRequest{
-                .mVertexType = VertexShaderType::Simple,
-                .mFragmentType = FragmentShaderType::SolidColored,
-                .mUniformType = ShaderUniformType::SimpleWithPadding
+        return Shader(getDriverApi(), mCleanup, ShaderConfig{
+           vertex, fragment, {"Params"}
        });
    }

@@ -77,7 +129,7 @@ TEST_F(BufferUpdatesTest, VertexBufferUpdate) {
        RenderPassParams params = {};
        fullViewport(params);
        params.flags.clear = TargetBufferFlags::COLOR;
-        params.clearColor = { 0.f, 1.f, 0.f, 1.f };
+        params.clearColor = {0.f, 1.f, 0.f, 1.f};
        params.flags.discardStart = TargetBufferFlags::ALL;
        params.flags.discardEnd = TargetBufferFlags::NONE;

@@ -92,18 +144,17 @@ TEST_F(BufferUpdatesTest, VertexBufferUpdate) {
        // Create a uniform buffer.
        // We use STATIC here, even though the buffer is updated, to force the Metal backend to use
        // a GPU buffer, which is more interesting to test.
-        auto ubuffer = cleanup.add(api.createBufferObject(sizeof(SimpleMaterialParams) + 64,
+        auto ubuffer = cleanup.add(api.createBufferObject(sizeof(MaterialParams) + 64,
                BufferObjectBinding::UNIFORM, BufferUsage::STATIC));

-        shader.bindUniform<SimpleMaterialParams>(api, ubuffer, kBindingConfig);
+        shader.bindUniform<MaterialParams>(api, ubuffer, kBindingConfig);

        api.startCapture(0);

        // Upload the uniform, but with an offset to accommodate the padding in the shader's
        // uniform definition.
-        shader.uploadUniform(api, ubuffer, kBindingConfig, SimpleMaterialParams{
+        shader.uploadUniform(api, ubuffer, kBindingConfig, MaterialParams{
                .color = { 1.0f, 1.0f, 1.0f, 1.0f },
-                .scaleMinusOne = { 0.0, 0.0, 0.0, 0.0 },
                .offset = { 0.0f, 0.0f, 0.0f, 0.0f }
        });

@@ -114,21 +165,19 @@ TEST_F(BufferUpdatesTest, VertexBufferUpdate) {
        size_t triangleIndex = 0;
        for (float i = -1.0f; i < 1.0f; i += 0.2f) {
            const float low = i, high = i + 0.2;
-            const filament::math::float2 v[3]{{ low,  low },
-                                              { high, low },
-                                              { low,  high }};
+            const filament::math::float2 v[3] {{low, low}, {high, low}, {low, high}};
            triangle.updateVertices(v);

            if (updateIndices) {
                if (triangleIndex % 2 == 0) {
                    // Upload each index separately, to test offsets.
-                    const TrianglePrimitive::index_type i[3]{ 0, 1, 2 };
+                    const TrianglePrimitive::index_type i[3] {0, 1, 2};
                    triangle.updateIndices(i + 0, 1, 0);
                    triangle.updateIndices(i + 1, 1, 1);
                    triangle.updateIndices(i + 2, 1, 2);
                } else {
                    // This effectively hides this triangle.
-                    const TrianglePrimitive::index_type i[3]{ 0, 0, 0 };
+                    const TrianglePrimitive::index_type i[3] {0, 0, 0};
                    triangle.updateIndices(i);
                }
            }
@@ -171,29 +220,28 @@ TEST_F(BufferUpdatesTest, BufferObjectUpdateWithOffset) {
    // Create a uniform buffer.
    // We use STATIC here, even though the buffer is updated, to force the Metal backend to use a
    // GPU buffer, which is more interesting to test.
-    auto ubuffer = cleanup.add(api.createBufferObject(sizeof(SimpleMaterialParams) + 64,
+    auto ubuffer = cleanup.add(api.createBufferObject(sizeof(MaterialParams) + 64,
            BufferObjectBinding::UNIFORM, BufferUsage::STATIC));

-    shader.bindUniform<SimpleMaterialParams>(api, ubuffer, kBindingConfig);
+    shader.bindUniform<MaterialParams>(api, ubuffer, kBindingConfig);

    // Create a render target.
    auto colorTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
            TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT));
    auto renderTarget = cleanup.add(api.createRenderTarget(
-            TargetBufferFlags::COLOR0, 512, 512, 1, 0, {{ colorTexture }}, {}, {}));
+            TargetBufferFlags::COLOR0, 512, 512, 1, 0, {{colorTexture}}, {}, {}));

    // Upload uniforms for the first triangle.
    // Upload the uniform, but with an offset to accommodate the padding in the shader's
    // uniform definition.
-    shader.uploadUniform(api, ubuffer, kBindingConfig, SimpleMaterialParams{
+    shader.uploadUniform(api, ubuffer, kBindingConfig, MaterialParams{
            .color = { 1.0f, 0.0f, 0.5f, 1.0f },
-            .scaleMinusOne = { 0.0f, 0.0f, 0.0f, 0.0f },
            .offset = { 0.0f, 0.0f, 0.0f, 0.0f }
    });

    RenderPassParams params = {};
    params.flags.clear = TargetBufferFlags::COLOR;
-    params.clearColor = { 0.f, 0.f, 1.f, 1.f };
+    params.clearColor = {0.f, 0.f, 1.f, 1.f};
    params.flags.discardStart = TargetBufferFlags::ALL;
    params.flags.discardEnd = TargetBufferFlags::NONE;
    params.viewport.height = 512;
@@ -202,18 +250,18 @@ TEST_F(BufferUpdatesTest, BufferObjectUpdateWithOffset) {
            renderTarget, swapChain, shader.getProgram(), params);

    // Upload uniforms for the second triangle. To test partial buffer updates, we'll only update
-    // color.b, color.a, scaleMinusOne, offset.x, and offset.y.
-    const UniformBindingConfig partialBindingConfig = {
-            .dataSize = sizeof(float) * 8,
-            .bufferSize = sizeof(SimpleMaterialParams) + 64,
-            .byteOffset = 64 + offsetof(SimpleMaterialParams, color.b)
-    };
-    shader.uploadUniform(api, ubuffer, partialBindingConfig,
-            std::array<float, 8>{
-                    1.0f, 1.0f, // color.b, color.a
-                    0.0f, 0.0f, 0.0f, 0.0f, // scale
-                    0.5f, 0.5f // offset.x, offset.y
-            });
+    // color.b, color.a, offset.x, and offset.y.
+    shader.uploadUniform(api, ubuffer, UniformBindingConfig{
+                    .dataSize = sizeof(std::array<float, 4>),
+                    .bufferSize = kBindingConfig.bufferSize,
+                    .byteOffset = *kBindingConfig.byteOffset + offsetof(MaterialParams, color.b),
+            },
+            std::array<float, 4>{
+                    // color.b, color.a
+                    1.0f, 1.0f,
+                    // offset.x, offset.y
+                    0.5f, 0.5f }
+    );

    params.flags.clear = TargetBufferFlags::NONE;
    params.flags.discardStart = TargetBufferFlags::NONE;
@@ -17,7 +17,7 @@
 #include "BackendTest.h"

 #include "Lifetimes.h"
-#include "Shader.h"
+#include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"

 #include <backend/DriverEnums.h>
@@ -96,6 +96,16 @@ struct MaterialParams {
    float unused;
 };

+static void uploadUniforms(DriverApi& dapi, Handle<HwBufferObject> ubh, MaterialParams params) {
+    MaterialParams* tmp = new MaterialParams(params);
+    auto cb = [](void* buffer, size_t size, void* user) {
+        MaterialParams* sp = (MaterialParams*) buffer;
+        delete sp;
+    };
+    BufferDescriptor bd(tmp, sizeof(MaterialParams), cb);
+    dapi.updateBufferObject(ubh, std::move(bd), 0);
+}
+
 static void dumpScreenshot(DriverApi& dapi, Handle<HwRenderTarget> rt) {
    const size_t size = kTexWidth * kTexHeight * 4;
    void* buffer = calloc(1, size);
@@ -130,13 +140,38 @@ TEST_F(BackendTest, FeedbackLoops) {
        api.makeCurrent(swapChain, swapChain);

        // Create a program.
-        filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
+        ProgramHandle program;
+        {
+            filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
                SamplerType::SAMPLER_2D, SamplerFormat::FLOAT, Precision::HIGH, false };
-        Shader shader = Shader(api, cleanup, ShaderConfig {
-            .vertexShader = fullscreenVs,
-            .fragmentShader = fullscreenFs,
-            .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}, {"Params"}}
-        });
+            filamat::DescriptorSets descriptors;
+            descriptors[1] = {
+                { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
+                        samplerInfo },
+                { "Params", { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::FRAGMENT, 1 }, {} }
+            };
+            ShaderGenerator shaderGen(fullscreenVs, fullscreenFs, sBackend, sIsMobilePlatform,
+                    std::move(descriptors));
+            Program prog = shaderGen.getProgram(api);
+            prog.descriptorBindings(1, {
+                    { "test_tex", DescriptorType::SAMPLER, 0 },
+                    { "Params", DescriptorType::UNIFORM_BUFFER, 1 }
+            });
+            program = cleanup.add(api.createProgram(std::move(prog)));
+        }
+
+        DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
+                {{
+                         DescriptorType::SAMPLER,
+                         ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
+                         DescriptorFlags::NONE, 0
+                 },
+                 {
+                         DescriptorType::UNIFORM_BUFFER,
+                         ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 1,
+                         DescriptorFlags::NONE, 0
+                 }}}));
+

        TrianglePrimitive const triangle(getDriverApi());

@@ -183,8 +218,8 @@ TEST_F(BackendTest, FeedbackLoops) {
            state.rasterState.colorWrite = true;
            state.rasterState.depthWrite = false;
            state.rasterState.depthFunc = RasterState::DepthFunc::A;
-            state.program = shader.getProgram();
-            state.pipelineLayout.setLayout[1] = { shader.getDescriptorSetLayout() };
+            state.program = program;
+            state.pipelineLayout.setLayout[1] = { descriptorSetLayout };

            api.makeCurrent(swapChain, swapChain);
            api.beginFrame(0, 0, 0);
@@ -198,24 +233,20 @@ TEST_F(BackendTest, FeedbackLoops) {
                params.viewport.width = kTexWidth >> targetLevel;
                params.viewport.height = kTexHeight >> targetLevel;

-                auto descriptorSet = shader.createDescriptorSet(api);
                auto textureView = passCleanup.add(api.createTextureView(texture, sourceLevel, 1));
+                DescriptorSetHandle descriptorSet = passCleanup.add(api.createDescriptorSet(descriptorSetLayout));
                api.updateDescriptorSetTexture(descriptorSet, 0, textureView, {
                        .filterMag = SamplerMagFilter::LINEAR,
                        .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
                });
+                api.updateDescriptorSetBuffer(descriptorSet, 1, ubuffer, 0, sizeof(MaterialParams));
+                api.bindDescriptorSet(descriptorSet, 1, {});

-                UniformBindingConfig uniformBinding{
-                    .binding = 1,
-                    .descriptorSet = descriptorSet
-                };
-                shader.bindUniform<MaterialParams>(api, ubuffer, uniformBinding);
-                shader.uploadUniform(api, ubuffer, uniformBinding, MaterialParams{
+                uploadUniforms(getDriverApi(), ubuffer, {
                    .fbWidth = float(params.viewport.width),
                    .fbHeight = float(params.viewport.height),
                    .sourceLevel = float(sourceLevel),
                });
-
                api.beginRenderPass(renderTargets[targetLevel], params);
                api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
                api.endRenderPass();
@@ -231,24 +262,20 @@ TEST_F(BackendTest, FeedbackLoops) {
                params.viewport.width = kTexWidth >> targetLevel;
                params.viewport.height = kTexHeight >> targetLevel;

-                auto descriptorSet = shader.createDescriptorSet(api);
                auto textureView = passCleanup.add(api.createTextureView(texture, sourceLevel, 1));
+                DescriptorSetHandle descriptorSet = passCleanup.add(api.createDescriptorSet(descriptorSetLayout));
                api.updateDescriptorSetTexture(descriptorSet, 0, textureView, {
                        .filterMag = SamplerMagFilter::LINEAR,
                        .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
                });
+                api.updateDescriptorSetBuffer(descriptorSet, 1, ubuffer, 0, sizeof(MaterialParams));
+                api.bindDescriptorSet(descriptorSet, 1, {});

-                UniformBindingConfig uniformBinding{
-                        .binding = 1,
-                        .descriptorSet = descriptorSet
-                };
-                shader.bindUniform<MaterialParams>(api, ubuffer, uniformBinding);
-                shader.uploadUniform(api, ubuffer, uniformBinding, MaterialParams{
-                        .fbWidth = float(params.viewport.width),
-                        .fbHeight = float(params.viewport.height),
-                        .sourceLevel = float(sourceLevel),
+                uploadUniforms(getDriverApi(), ubuffer, {
+                    .fbWidth = float(params.viewport.width),
+                    .fbHeight = float(params.viewport.height),
+                    .sourceLevel = float(sourceLevel),
                });
-
                api.beginRenderPass(renderTargets[targetLevel], params);
                api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
                api.endRenderPass();
@@ -18,14 +18,16 @@

 #include "BackendTestUtils.h"
 #include "Lifetimes.h"
-#include "Shader.h"
-#include "SharedShaders.h"
+#include "ShaderGenerator.h"
+#include "TrianglePrimitive.h"

 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>

 #include "private/filament/SamplerInterfaceBlock.h"

+#include <math/half.h>
+
 #include <vector>

 #include <stddef.h>
@@ -40,6 +42,19 @@ namespace {
 // Shaders
 ////////////////////////////////////////////////////////////////////////////////////////////////////

+std::string vertex (R"(#version 450 core
+
+layout(location = 0) in vec4 mesh_position;
+
+void main() {
+    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
+#if defined(TARGET_VULKAN_ENVIRONMENT)
+    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
+    gl_Position.y *= -1.0f;
+#endif
+}
+)");
+
 std::string fragmentTemplate (R"(#version 450 core

 layout(location = 0) out vec4 fragColor;
@@ -104,15 +119,6 @@ namespace test {

 template<typename componentType> inline componentType getMaxValue();

-class LoadImageTest : public BackendTest {
-public:
-    LoadImageTest() {
-        mVertexShader = SharedShaders::getVertexShaderText(VertexShaderType::Noop,
-                ShaderUniformType::None);
-    }
-
-    std::string mVertexShader;
-};


 inline std::string stringReplace(const std::string& find, const std::string& replace,
@@ -210,7 +216,7 @@ static SamplerFormat getSamplerFormat(TextureFormat textureFormat) {
    }
 }

-TEST_F(LoadImageTest, UpdateImage2D) {
+TEST_F(BackendTest, UpdateImage2D) {

    // All of these test cases should result in the same rendered image, and thus the same hash.
    static const uint32_t expectedHash = 3644679986;
@@ -300,14 +306,28 @@ TEST_F(LoadImageTest, UpdateImage2D) {
        // Create a program.
        filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
            SamplerType::SAMPLER_2D, getSamplerFormat(t.textureFormat), Precision::HIGH, false };
+        filamat::DescriptorSets descriptors;
+        descriptors[1] = { { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
+                samplerInfo } };

        std::string const fragment = stringReplace("{samplerType}",
                getSamplerTypeName(t.textureFormat), fragmentTemplate);
-        Shader shader(api, cleanup, ShaderConfig{
-           .vertexShader = mVertexShader,
-           .fragmentShader= fragment,
-           .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}}
-        });
+        ShaderGenerator shaderGen(
+                vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
+
+        Program prog = shaderGen.getProgram(api);
+        prog.descriptorBindings(1, {{"test_tex", DescriptorType::SAMPLER, 0}});
+
+        ProgramHandle const program = cleanup.add(api.createProgram(std::move(prog)));
+
+        DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
+                {{
+                         DescriptorType::SAMPLER,
+                         ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
+                         DescriptorFlags::NONE, 0
+                 }}}));
+
+        DescriptorSetHandle descriptorSet = cleanup.add(api.createDescriptorSet(descriptorSetLayout));

        // Create a Texture.
        auto usage = TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE;
@@ -329,15 +349,14 @@ TEST_F(LoadImageTest, UpdateImage2D) {
                    checkerboardPixelBuffer(t.pixelFormat, t.pixelType, 512, t.bufferPadding));
        }

-        DescriptorSetHandle  descriptorSet = shader.createDescriptorSet(api);
        api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
                .filterMag = SamplerMagFilter::NEAREST,
                .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });

        api.bindDescriptorSet(descriptorSet, 1, {});

-        renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
-                defaultRenderTarget, swapChain, shader.getProgram());
+        renderTriangle({{ DescriptorSetLayoutHandle{}, descriptorSetLayout }},
+                defaultRenderTarget, swapChain, program);

        readPixelsAndAssertHash(t.name, 512, 512, defaultRenderTarget, expectedHash);

@@ -351,9 +370,8 @@ TEST_F(LoadImageTest, UpdateImage2D) {
    flushAndWait();
 }

-TEST_F(LoadImageTest, UpdateImageSRGB) {
+TEST_F(BackendTest, UpdateImageSRGB) {
    auto& api = getDriverApi();
-    Cleanup cleanup(api);
    api.startCapture();

    PixelDataFormat const pixelFormat = PixelDataFormat::RGBA;
@@ -361,23 +379,36 @@ TEST_F(LoadImageTest, UpdateImageSRGB) {
    TextureFormat const textureFormat = TextureFormat::SRGB8_A8;

    // Create a platform-specific SwapChain and make it current.
-    auto swapChain = cleanup.add(createSwapChain());
+    auto swapChain = createSwapChain();
    api.makeCurrent(swapChain, swapChain);
-    auto defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
+    auto defaultRenderTarget = api.createDefaultRenderTarget(0);

    // Create a program.
    filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
        SamplerType::SAMPLER_2D, getSamplerFormat(textureFormat), Precision::HIGH, false };
+    filamat::DescriptorSets descriptors;
+    descriptors[1] = { { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
+            samplerInfo } };
+
    std::string const fragment = stringReplace("{samplerType}",
            getSamplerTypeName(textureFormat), fragmentTemplate);
-    Shader shader(api, cleanup, ShaderConfig{
-        .vertexShader = mVertexShader, .fragmentShader = fragment, .uniforms = {{
-            "text_tex", DescriptorType::SAMPLER, samplerInfo
-    }}});
+    ShaderGenerator shaderGen(
+            vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
+    Program prog = shaderGen.getProgram(api);
+    prog.descriptorBindings(1, {{"test_tex", DescriptorType::SAMPLER, 0}});
+    ProgramHandle const program = api.createProgram(std::move(prog));
+    DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
+            {{
+                     DescriptorType::SAMPLER,
+                     ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
+                     DescriptorFlags::NONE, 0
+             }}});
+
+    DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);

    // Create a texture.
-    Handle<HwTexture> const texture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
-            textureFormat, 1, 512, 512, 1, TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE));
+    Handle<HwTexture> const texture = api.createTexture(SamplerType::SAMPLER_2D, 1,
+            textureFormat, 1, 512, 512, 1, TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE);

    // Create image data.
    size_t components; int bpp;
@@ -405,7 +436,6 @@ TEST_F(LoadImageTest, UpdateImageSRGB) {
    api.beginFrame(0, 0, 0);

    // Update samplers.
-    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
            .filterMag = SamplerMagFilter::LINEAR,
            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
@@ -413,8 +443,8 @@ TEST_F(LoadImageTest, UpdateImageSRGB) {

    api.bindDescriptorSet(descriptorSet, 1, {});

-    renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
-            defaultRenderTarget, swapChain, shader.getProgram());
+    renderTriangle({{ DescriptorSetLayoutHandle{}, descriptorSetLayout }},
+            defaultRenderTarget, swapChain, program);

    static const uint32_t expectedHash = 359858623;
    readPixelsAndAssertHash("UpdateImageSRGB", 512, 512, defaultRenderTarget, expectedHash);
@@ -423,14 +453,21 @@ TEST_F(LoadImageTest, UpdateImageSRGB) {
    api.commit(swapChain);
    api.endFrame(0);

+    api.destroyDescriptorSet(descriptorSet);
+    api.destroyDescriptorSetLayout(descriptorSetLayout);
+    api.destroyProgram(program);
+    api.destroySwapChain(swapChain);
+    api.destroyRenderTarget(defaultRenderTarget);
+
    // This ensures all driver commands have finished before exiting the test.
    api.finish();
    api.stopCapture();
+
+    flushAndWait();
 }

-TEST_F(LoadImageTest, UpdateImageMipLevel) {
+TEST_F(BackendTest, UpdateImageMipLevel) {
    auto& api = getDriverApi();
-    Cleanup cleanup(api);
    api.startCapture();

    PixelDataFormat pixelFormat = PixelDataFormat::RGBA;
@@ -438,27 +475,38 @@ TEST_F(LoadImageTest, UpdateImageMipLevel) {
    TextureFormat textureFormat = TextureFormat::RGBA32F;

    // Create a platform-specific SwapChain and make it current.
-    auto swapChain = cleanup.add(createSwapChain());
+    auto swapChain = createSwapChain();
    api.makeCurrent(swapChain, swapChain);
-    auto defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
+    auto defaultRenderTarget = api.createDefaultRenderTarget(0);

    // Create a program.
    filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
        SamplerType::SAMPLER_2D, getSamplerFormat(textureFormat), Precision::HIGH, false };
+    filamat::DescriptorSets descriptors;
+    descriptors[1] = { { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
+            samplerInfo } };
    std::string const fragment = stringReplace("{samplerType}",
            getSamplerTypeName(textureFormat), fragmentUpdateImageMip);
-    Shader shader(api, cleanup, ShaderConfig {
-        .vertexShader = mVertexShader,
-        .fragmentShader = fragment,
-        .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}}
-    });
+    ShaderGenerator shaderGen(
+            vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
+    Program prog = shaderGen.getProgram(api);
+    prog.descriptorBindings(1, {{"test_tex", DescriptorType::SAMPLER, 0}});
+    ProgramHandle const program = api.createProgram(std::move(prog));
+    DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
+            {{
+                     DescriptorType::SAMPLER,
+                     ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
+                     DescriptorFlags::NONE, 0
+             }}});
+
+    DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);

    // Create a texture with 3 mip levels.
    // Base level: 1024
    // Level 1:     512     <-- upload data and sample from this level
    // Level 2:     256
-    Handle<HwTexture> texture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 3,
-            textureFormat, 1, 1024, 1024, 1, TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE));
+    Handle<HwTexture> texture = api.createTexture(SamplerType::SAMPLER_2D, 3,
+            textureFormat, 1, 1024, 1024, 1, TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE);

    // Create image data.
    PixelBufferDescriptor descriptor = checkerboardPixelBuffer(pixelFormat, pixelType, 512);
@@ -467,7 +515,6 @@ TEST_F(LoadImageTest, UpdateImageMipLevel) {
    api.beginFrame(0, 0, 0);

    // Update samplers.
-    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
            .filterMag = SamplerMagFilter::LINEAR,
            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
@@ -475,8 +522,8 @@ TEST_F(LoadImageTest, UpdateImageMipLevel) {

    api.bindDescriptorSet(descriptorSet, 1, {});

-    renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
-            defaultRenderTarget, swapChain, shader.getProgram());
+    renderTriangle({{ DescriptorSetLayoutHandle{}, descriptorSetLayout }},
+            defaultRenderTarget, swapChain, program);

    static const uint32_t expectedHash = 3644679986;
    readPixelsAndAssertHash("UpdateImageMipLevel", 512, 512, defaultRenderTarget, expectedHash);
@@ -485,14 +532,21 @@ TEST_F(LoadImageTest, UpdateImageMipLevel) {
    api.commit(swapChain);
    api.endFrame(0);

+    api.destroyDescriptorSet(descriptorSet);
+    api.destroyDescriptorSetLayout(descriptorSetLayout);
+    api.destroyProgram(program);
+    api.destroySwapChain(swapChain);
+    api.destroyRenderTarget(defaultRenderTarget);
+
    // This ensures all driver commands have finished before exiting the test.
    api.finish();
    api.stopCapture();
+
+    flushAndWait();
 }

-TEST_F(LoadImageTest, UpdateImage3D) {
+TEST_F(BackendTest, UpdateImage3D) {
    auto& api = getDriverApi();
-    Cleanup cleanup(api);
    api.startCapture();

    PixelDataFormat pixelFormat = PixelDataFormat::RGBA;
@@ -502,24 +556,35 @@ TEST_F(LoadImageTest, UpdateImage3D) {
    TextureUsage usage = TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE;

    // Create a platform-specific SwapChain and make it current.
-    auto swapChain = cleanup.add(createSwapChain());
+    auto swapChain = createSwapChain();
    api.makeCurrent(swapChain, swapChain);
-    auto defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
+    auto defaultRenderTarget = api.createDefaultRenderTarget(0);

    // Create a program.
    filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
        SamplerType::SAMPLER_2D_ARRAY, getSamplerFormat(textureFormat), Precision::HIGH, false };
+    filamat::DescriptorSets descriptors;
+    descriptors[1] = { { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
+            samplerInfo } };
    std::string fragment = stringReplace("{samplerType}",
            getSamplerTypeName(samplerType), fragmentUpdateImage3DTemplate);
-    Shader shader(api, cleanup, ShaderConfig {
-        .vertexShader = mVertexShader,
-        .fragmentShader = fragment,
-        .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}}
-    });
+    ShaderGenerator shaderGen(
+            vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
+    Program prog = shaderGen.getProgram(api);
+    prog.descriptorBindings(1, {{ "test_tex", DescriptorType::SAMPLER, 0 }});
+    ProgramHandle const program = api.createProgram(std::move(prog));
+    DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
+            {{
+                     DescriptorType::SAMPLER,
+                     ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
+                     DescriptorFlags::NONE, 0
+             }}});
+
+    DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);

    // Create a texture.
-    Handle<HwTexture> texture = cleanup.add(api.createTexture(samplerType, 1,
-            textureFormat, 1, 512, 512, 4, usage));
+    Handle<HwTexture> texture = api.createTexture(samplerType, 1,
+            textureFormat, 1, 512, 512, 4, usage);

    // Create image data for all 4 layers.
    size_t components; int bpp;
@@ -541,7 +606,6 @@ TEST_F(LoadImageTest, UpdateImage3D) {
    api.beginFrame(0, 0, 0);

    // Update samplers.
-    DescriptorSetHandle  descriptorSet = shader.createDescriptorSet(api);
    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
            .filterMag = SamplerMagFilter::LINEAR,
            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
@@ -549,8 +613,8 @@ TEST_F(LoadImageTest, UpdateImage3D) {

    api.bindDescriptorSet(descriptorSet, 1, {});

-    renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
-            defaultRenderTarget, swapChain, shader.getProgram());
+    renderTriangle({{ DescriptorSetLayoutHandle{}, descriptorSetLayout }},
+            defaultRenderTarget, swapChain, program);

    static const uint32_t expectedHash = 3644679986;
    readPixelsAndAssertHash("UpdateImage3D", 512, 512, defaultRenderTarget, expectedHash);
@@ -559,9 +623,17 @@ TEST_F(LoadImageTest, UpdateImage3D) {
    api.commit(swapChain);
    api.endFrame(0);

+    api.destroyDescriptorSet(descriptorSet);
+    api.destroyDescriptorSetLayout(descriptorSetLayout);
+    api.destroyProgram(program);
+    api.destroySwapChain(swapChain);
+    api.destroyRenderTarget(defaultRenderTarget);
+
    // This ensures all driver commands have finished before exiting the test.
    api.finish();
    api.stopCapture();
+
+    flushAndWait();
 }

 } // namespace test
@@ -17,8 +17,7 @@
 #include "BackendTest.h"

 #include "Lifetimes.h"
-#include "Shader.h"
-#include "SharedShaders.h"
+#include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"

 namespace {
@@ -27,6 +26,21 @@ namespace {
 // Shaders
 ////////////////////////////////////////////////////////////////////////////////////////////////////

+std::string vertex (R"(#version 450 core
+
+layout(location = 0) in vec4 mesh_position;
+
+layout(location = 0) out uvec4 indices;
+
+void main() {
+    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
+#if defined(TARGET_VULKAN_ENVIRONMENT)
+    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
+    gl_Position.y = -gl_Position.y;
+#endif
+}
+)");
+
 std::string fragment (R"(#version 450 core

 layout(location = 0) out vec4 fragColor;
@@ -57,12 +71,10 @@ TEST_F(BackendTest, MRT) {
        auto swapChain = cleanup.add(createSwapChain());
        api.makeCurrent(swapChain, swapChain);

-        Shader shader(api, cleanup, ShaderConfig{
-                .vertexShader = SharedShaders::getVertexShaderText(VertexShaderType::Noop,
-                        ShaderUniformType::None),
-                .fragmentShader = fragment,
-                .uniforms = {}
-        });
+        // Create a program.
+        ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);
+        Program p = shaderGen.getProgram(api);
+        auto program = cleanup.add(api.createProgram(std::move(p)));

        TrianglePrimitive triangle(api);

@@ -110,7 +122,7 @@ TEST_F(BackendTest, MRT) {
        params.flags.discardEnd = TargetBufferFlags::NONE;

        PipelineState state;
-        state.program = shader.getProgram();
+        state.program = program;
        state.rasterState.colorWrite = true;
        state.rasterState.depthWrite = false;
        state.rasterState.depthFunc = RasterState::DepthFunc::A;
@@ -19,8 +19,7 @@

 #include "BackendTestUtils.h"
 #include "Lifetimes.h"
-#include "Shader.h"
-#include "SharedShaders.h"
+#include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"

 #include <backend/DriverEnums.h>
@@ -35,7 +34,18 @@ namespace {
 // Shaders
 ////////////////////////////////////////////////////////////////////////////////////////////////////

-std::string fragmentTexturedLod (R"(#version 450 core
+std::string vertex (R"(#version 450 core
+
+layout(location = 0) in vec4 mesh_position;
+layout(location = 0) out vec2 uv;
+
+void main() {
+    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
+    uv = (mesh_position.xy * 0.5 + 0.5);
+}
+)");
+
+std::string fragment (R"(#version 450 core

 layout(location = 0) out vec4 fragColor;
 layout(location = 0) in vec2 uv;
@@ -47,6 +57,18 @@ void main() {
 }
 )");

+std::string whiteFragment (R"(#version 450 core
+
+layout(location = 0) out vec4 fragColor;
+layout(location = 0) in vec2 uv;
+
+layout(location = 0, set = 1) uniform sampler2D backend_test_sib_tex;
+
+void main() {
+    fragColor = vec4(1.0);
+}
+)");
+
 }

 namespace test {
@@ -66,25 +88,39 @@ TEST_F(BackendTest, TextureViewLod) {
        auto swapChain = cleanup.add(createSwapChain());
        api.makeCurrent(swapChain, swapChain);

-        Shader whiteShader = SharedShaders::makeShader(api, cleanup, ShaderRequest {
-            .mVertexType = VertexShaderType::Textured,
-            .mFragmentType = FragmentShaderType::White,
-            .mUniformType = ShaderUniformType::Sampler
-        });
+        // Create a program that draws only white.
+        Handle<HwProgram> whiteProgram;
+        {
+            ShaderGenerator shaderGen(vertex, whiteFragment, sBackend, sIsMobilePlatform);
+            Program p = shaderGen.getProgram(api);
+            p.descriptorBindings(0, {{"backend_test_sib_tex", DescriptorType::SAMPLER, 0}});
+            whiteProgram = cleanup.add(api.createProgram(std::move(p)));
+        }

        // Create a program that samples a texture.
-        std::string vertexShader = SharedShaders::getVertexShaderText(
-                VertexShaderType::Textured, ShaderUniformType::Sampler);
-        filament::SamplerInterfaceBlock::SamplerInfo samplerInfo {
-            "backend_test", "sib_tex", 0,
-            SamplerType::SAMPLER_2D, SamplerFormat::FLOAT, Precision::HIGH, false };
-        Shader texturedShader(api, cleanup, ShaderConfig {
-           .vertexShader = vertexShader,
-           .fragmentShader = fragmentTexturedLod,
-           .uniforms = {{
-               "backend_test_sib_tex", DescriptorType::SAMPLER, samplerInfo
-           }}
-        });
+        Handle<HwProgram> textureProgram;
+        {
+            filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "backend_test", "sib_tex", 0,
+                SamplerType::SAMPLER_2D, SamplerFormat::FLOAT, Precision::HIGH, false };
+            filamat::DescriptorSets descriptors;
+            descriptors[1] = { { "backend_test_sib_tex",
+                    { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 }, samplerInfo } };
+            ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
+            Program p = shaderGen.getProgram(api);
+            p.descriptorBindings(0, {{"backend_test_sib_tex", DescriptorType::SAMPLER, 0}});
+            textureProgram = cleanup.add(api.createProgram(std::move(p)));
+        }
+
+        DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
+                {{
+                         DescriptorType::SAMPLER,
+                         ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
+                         DescriptorFlags::NONE, 0
+                 }}}));
+
+        DescriptorSetHandle descriptorSet[2];
+        descriptorSet[0] = cleanup.add(api.createDescriptorSet(descriptorSetLayout));
+        descriptorSet[1] = cleanup.add(api.createDescriptorSet(descriptorSetLayout));

        // Create a texture that has 4 mip levels. Each level is a different color.
        // Level 0: 128x128 (red)
@@ -93,10 +129,9 @@ TEST_F(BackendTest, TextureViewLod) {
        // Level 3:   16x16 (yellow)
        const size_t kTextureSize = 128;
        const size_t kMipLevels = 4;
-        Handle<HwTexture> texture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D,
-                kMipLevels, TextureFormat::RGBA8, 1, kTextureSize, kTextureSize, 1,
-                TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT
-                | TextureUsage::UPLOADABLE));
+        Handle<HwTexture> texture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, kMipLevels,
+                TextureFormat::RGBA8, 1, kTextureSize, kTextureSize, 1,
+                TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT | TextureUsage::UPLOADABLE));

        // Create image data.
        auto pixelFormat = PixelDataFormat::RGBA;
@@ -144,7 +179,7 @@ TEST_F(BackendTest, TextureViewLod) {
            params.flags.discardStart = TargetBufferFlags::NONE;
            params.flags.discardEnd = TargetBufferFlags::NONE;
            PipelineState ps = {};
-            ps.program = whiteShader.getProgram();
+            ps.program = whiteProgram;
            ps.rasterState.colorWrite = true;
            ps.rasterState.depthWrite = false;
            api.beginRenderPass(renderTarget, params);
@@ -152,8 +187,7 @@ TEST_F(BackendTest, TextureViewLod) {
            api.endRenderPass();
        }

-        backend::Handle<HwRenderTarget> defaultRenderTarget =
-                cleanup.add(api.createDefaultRenderTarget(0));
+        backend::Handle<HwRenderTarget> defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));

        RenderPassParams params = {};
        fullViewport(params);
@@ -163,19 +197,18 @@ TEST_F(BackendTest, TextureViewLod) {
        params.flags.discardEnd = TargetBufferFlags::NONE;

        PipelineState state;
-        state.program = texturedShader.getProgram();
-        state.pipelineLayout.setLayout = { texturedShader.getDescriptorSetLayout() };
+        state.program = textureProgram;
+        state.pipelineLayout.setLayout = { descriptorSetLayout };
        state.rasterState.colorWrite = true;
        state.rasterState.depthWrite = false;
        state.rasterState.depthFunc = SamplerCompareFunc::A;
        state.rasterState.culling = CullingMode::NONE;

-        DescriptorSetHandle descriptorSet13 = texturedShader.createDescriptorSet(api);
-        api.updateDescriptorSetTexture(descriptorSet13, 0, texture13, {
+        api.updateDescriptorSetTexture(descriptorSet[0], 0, texture13, {
                .filterMag = SamplerMagFilter::NEAREST,
                .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });

-        api.bindDescriptorSet(descriptorSet13, 0, {});
+        api.bindDescriptorSet(descriptorSet[0], 0, {});

        // Render a triangle to the screen, sampling from mip level 1.
        // Because the min level is 1, the result color should be the white triangle drawn in the
@@ -188,12 +221,11 @@ TEST_F(BackendTest, TextureViewLod) {
        // Adjust the base mip to 2.
        auto texture22 = cleanup.add(api.createTextureView(texture, 2, 2));

-        DescriptorSetHandle descriptorSet22 = texturedShader.createDescriptorSet(api);
-        api.updateDescriptorSetTexture(descriptorSet22, 0, texture22, {
+        api.updateDescriptorSetTexture(descriptorSet[1], 0, texture22, {
                .filterMag = SamplerMagFilter::NEAREST,
                .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });

-        api.bindDescriptorSet(descriptorSet22, 0, {});
+        api.bindDescriptorSet(descriptorSet[1], 0, {});

        // Render a second, smaller, triangle, again sampling from mip level 1.
        // This triangle should be yellow striped.
@@ -17,8 +17,7 @@
 #include "BackendTest.h"

 #include "Lifetimes.h"
-#include "Shader.h"
-#include "SharedShaders.h"
+#include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"

 namespace {
@@ -27,7 +26,7 @@ namespace {
 // Shaders
 ////////////////////////////////////////////////////////////////////////////////////////////////////

-std::string vertex(R"(#version 450 core
+std::string vertex (R"(#version 450 core

 layout(location = 0) in vec4 mesh_position;

@@ -47,6 +46,16 @@ void main() {
 }
 )");

+std::string fragment (R"(#version 450 core
+
+layout(location = 0) out vec4 fragColor;
+
+void main() {
+    fragColor = vec4(1.0);
+}
+
+)");
+
 }

 namespace test {
@@ -69,11 +78,9 @@ TEST_F(BackendTest, MissingRequiredAttributes) {
        api.makeCurrent(swapChain, swapChain);

        // Create a program.
-        Shader shader(api, cleanup, ShaderConfig{
-                .vertexShader = vertex,
-                .fragmentShader = SharedShaders::getFragmentShaderText(FragmentShaderType::White,
-                        ShaderUniformType::None),
-        });
+        ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);
+        Program p = shaderGen.getProgram(api);
+        auto program = cleanup.add(api.createProgram(std::move(p)));

        auto defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));

@@ -82,12 +89,12 @@ TEST_F(BackendTest, MissingRequiredAttributes) {
        RenderPassParams params = {};
        fullViewport(params);
        params.flags.clear = TargetBufferFlags::COLOR;
-        params.clearColor = { 0.f, 1.f, 0.f, 1.f };
+        params.clearColor = {0.f, 1.f, 0.f, 1.f};
        params.flags.discardStart = TargetBufferFlags::ALL;
        params.flags.discardEnd = TargetBufferFlags::NONE;

        PipelineState state;
-        state.program = shader.getProgram();
+        state.program = program;
        state.rasterState.colorWrite = true;
        state.rasterState.depthWrite = false;
        state.rasterState.depthFunc = RasterState::DepthFunc::A;
@@ -18,8 +18,7 @@

 #include "BackendTestUtils.h"
 #include "Lifetimes.h"
-#include "Shader.h"
-#include "SharedShaders.h"
+#include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"

 #include <utils/Hash.h>
@@ -31,7 +30,6 @@ using namespace filament;
 using namespace filament::backend;

 #ifndef FILAMENT_IOS
-
 #include <imageio/ImageEncoder.h>
 #include <image/ColorTransform.h>

@@ -44,7 +42,20 @@ namespace {
 // Shaders
 ////////////////////////////////////////////////////////////////////////////////////////////////////

-std::string fragmentFloat(R"(#version 450 core
+std::string vertex (R"(#version 450 core
+
+layout(location = 0) in vec4 mesh_position;
+
+void main() {
+    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
+#if defined(TARGET_VULKAN_ENVIRONMENT)
+    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
+    gl_Position.y = -gl_Position.y;
+#endif
+}
+)");
+
+std::string fragmentFloat (R"(#version 450 core

 layout(location = 0) out vec4 fragColor;

@@ -54,7 +65,7 @@ void main() {

 )");

-std::string fragmentUint(R"(#version 450 core
+std::string fragmentUint (R"(#version 450 core

 layout(location = 0) out uvec4 fragColor;

@@ -97,7 +108,7 @@ TEST_F(ReadPixelsTest, ReadPixels) {
        size_t samples = 1;

        // The size of the actual render target, taking mip level into account;
-        size_t getRenderTargetSize() const {
+        size_t getRenderTargetSize () const {
            return std::max(size_t(1), renderTargetBaseSize >> mipLevel);
        }

@@ -127,11 +138,11 @@ TEST_F(ReadPixelsTest, ReadPixels) {
        }

        void exportScreenshot(void* pixelData) const {
-#ifndef FILAMENT_IOS
+            #ifndef FILAMENT_IOS
            const size_t width = readRect.width, height = readRect.height;
            LinearImage image(width, height, 4);
            if (format == PixelDataFormat::RGBA && type == PixelDataType::UBYTE) {
-                image = toLinearWithAlpha<uint8_t>(width, height, width * 4, (uint8_t*)pixelData);
+                image = toLinearWithAlpha<uint8_t>(width, height, width * 4, (uint8_t*) pixelData);
            }
            if (format == PixelDataFormat::RGBA && type == PixelDataType::FLOAT) {
                memcpy(image.getPixelRef(), pixelData, width * height * sizeof(math::float4));
@@ -140,13 +151,13 @@ TEST_F(ReadPixelsTest, ReadPixels) {
            std::ofstream outputStream(png.c_str(), std::ios::binary | std::ios::trunc);
            ImageEncoder::encode(outputStream, ImageEncoder::Format::PNG, image, "",
                    png.c_str());
-#endif
+            #endif
        }

        void exportRawBytes(void* pixelData) const {
            std::string out = std::string(testName) + ".raw";
            std::ofstream outputStream(out.c_str(), std::ios::binary | std::ios::trunc);
-            outputStream.write((char*)pixelData, getBufferSizeBytes());
+            outputStream.write((char*) pixelData, getBufferSizeBytes());
            outputStream.close();
        }

@@ -229,20 +240,22 @@ TEST_F(ReadPixelsTest, ReadPixels) {
    DriverApi& api = getDriverApi();
    Cleanup cleanup(api);

-    std::string vertexShader = SharedShaders::getVertexShaderText(VertexShaderType::Noop,
-            ShaderUniformType::None);
-    Shader floatShader(api, cleanup, ShaderConfig{
-            .vertexShader = vertexShader,
-            .fragmentShader = fragmentFloat,
-            .uniforms = {}
-    });
-    Shader uintShader(api, cleanup, ShaderConfig{
-            .vertexShader = vertexShader,
-            .fragmentShader = fragmentUint,
-            .uniforms = {}
-    });
+    // Create programs.
+    Handle<HwProgram> programFloat, programUint;
+    {
+        ShaderGenerator shaderGen(vertex, fragmentFloat, sBackend, sIsMobilePlatform);
+        Program p = shaderGen.getProgram(api);
+        programFloat = cleanup.add(api.createProgram(std::move(p)));
+    }
+    {
+        ShaderGenerator shaderGen(vertex, fragmentUint, sBackend, sIsMobilePlatform);
+        Program p = shaderGen.getProgram(api);
+        programUint = cleanup.add(api.createProgram(std::move(p)));
+    }

-    for (const auto& t: testCases) {
+
+    for (const auto& t : testCases)
+    {
        // Create a platform-specific SwapChain and make it current.
        Handle<HwSwapChain> swapChain;
        if (t.useDefaultRT) {
@@ -279,7 +292,7 @@ TEST_F(ReadPixelsTest, ReadPixels) {
        RenderPassParams params = {};
        fullViewport(params);
        params.flags.clear = TargetBufferFlags::COLOR;
-        params.clearColor = { 0.f, 0.f, 1.f, 1.f };
+        params.clearColor = {0.f, 0.f, 1.f, 1.f};
        params.flags.discardStart = TargetBufferFlags::ALL;
        params.flags.discardEnd = TargetBufferFlags::NONE;
        params.viewport.height = t.getRenderTargetSize();
@@ -292,9 +305,9 @@ TEST_F(ReadPixelsTest, ReadPixels) {
        api.beginRenderPass(renderTarget, params);

        PipelineState state;
-        state.program = floatShader.getProgram();
+        state.program = programFloat;
        if (isUnsignedIntFormat(t.textureFormat)) {
-            state.program = uintShader.getProgram();
+            state.program = programUint;
        }
        state.rasterState.colorWrite = true;
        state.rasterState.depthWrite = false;
@@ -312,7 +325,7 @@ TEST_F(ReadPixelsTest, ReadPixels) {
            Handle<HwRenderTarget> mipLevelOneRT = localCleanup.add(api.createRenderTarget(
                    TargetBufferFlags::COLOR, renderTargetBaseSize, renderTargetBaseSize, 1, 0,
                    {{ texture }}, {}, {}));
-            p.clearColor = { 1.f, 0.f, 0.f, 1.f };
+            p.clearColor = {1.f, 0.f, 0.f, 1.f};
            api.beginRenderPass(mipLevelOneRT, p);
            api.endRenderPass();
        }
@@ -322,28 +335,28 @@ TEST_F(ReadPixelsTest, ReadPixels) {

        PixelBufferDescriptor descriptor(buffer, t.getBufferSizeBytes(), t.format, t.type,
                t.alignment, t.left, t.top, t.getPixelBufferStride(), [](void* buffer, size_t size,
-                        void* user) {
-                    const auto* test = (const TestCase*)user;
+                    void* user) {
+                    const auto* test = (const TestCase*) user;
                    assert_invariant(test);

                    test->exportScreenshot(buffer);
                    //test->exportRawBytes(buffer);

                    // Hash the contents of the buffer and check that they match.
-                    uint32_t hash = utils::hash::murmur3((const uint32_t*)buffer, size / 4, 0);
+                    uint32_t hash = utils::hash::murmur3((const uint32_t*) buffer, size / 4, 0);

                    ASSERT_EQ(test->hash, hash) << test->testName <<
-                                                " failed: hashes do not match." << std::endl;
+                        " failed: hashes do not match." << std::endl;

                    free(buffer);
-                }, (void*)&t);
+                }, (void*) &t);

        api.readPixels(renderTarget, t.readRect.x, t.readRect.y, t.readRect.width,
                t.readRect.height, std::move(descriptor));

        // Now render red over what was just rendered. This ensures that readPixels captures the
        // state of rendering between render passes.
-        params.clearColor = { 1.f, 0.f, 0.f, 1.f };
+        params.clearColor = {1.f, 0.f, 0.f, 1.f};
        api.beginRenderPass(renderTarget, params);
        api.endRenderPass();

@@ -363,27 +376,25 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
    Cleanup cleanup(api);

    // Create a platform-specific SwapChain and make it current.
-    auto swapChain = cleanup.add(
-            api.createSwapChainHeadless(renderTargetSize, renderTargetSize, 0));
+    auto swapChain = cleanup.add(api.createSwapChainHeadless(renderTargetSize, renderTargetSize, 0));
    api.makeCurrent(swapChain, swapChain);

-    Shader shader = SharedShaders::makeShader(api, cleanup, ShaderRequest{
-            .mVertexType = VertexShaderType::Noop,
-            .mFragmentType = FragmentShaderType::White,
-            .mUniformType = ShaderUniformType::None
-    });
+    // Create a program.
+    ShaderGenerator shaderGen(vertex, fragmentFloat, sBackend, sIsMobilePlatform);
+    Program p = shaderGen.getProgram(api);
+    auto program = cleanup.add(api.createProgram(std::move(p)));

    // Create a Texture and RenderTarget to render into.
    auto usage = TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE;
    Handle<HwTexture> texture = cleanup.add(api.createTexture(
-            SamplerType::SAMPLER_2D,            // target
-            1,                                  // levels
-            TextureFormat::RGBA8,               // format
-            1,                                  // samples
-            renderTargetSize,                   // width
-            renderTargetSize,                   // height
-            1,                                  // depth
-            usage));                             // usage
+                SamplerType::SAMPLER_2D,            // target
+                1,                                  // levels
+                TextureFormat::RGBA8,               // format
+                1,                                  // samples
+                renderTargetSize,                   // width
+                renderTargetSize,                   // height
+                1,                                  // depth
+                usage));                             // usage

    Handle<HwRenderTarget> renderTarget = cleanup.add(api.createRenderTarget(
            TargetBufferFlags::COLOR,
@@ -400,7 +411,7 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
    RenderPassParams params = {};
    fullViewport(params);
    params.flags.clear = TargetBufferFlags::COLOR;
-    params.clearColor = { 0.f, 0.f, 1.f, 1.f };
+    params.clearColor = {0.f, 0.f, 1.f, 1.f};
    params.flags.discardStart = TargetBufferFlags::ALL;
    params.flags.discardEnd = TargetBufferFlags::NONE;
    params.viewport.height = renderTargetSize;
@@ -409,7 +420,7 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
    void* buffer = calloc(1, renderTargetSize * renderTargetSize * 4);

    PipelineState state;
-    state.program = shader.getProgram();
+    state.program = program;
    state.rasterState.colorWrite = true;
    state.rasterState.depthWrite = false;
    state.rasterState.depthFunc = RasterState::DepthFunc::A;
@@ -433,12 +444,11 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
        PixelBufferDescriptor descriptor(buffer, renderTargetSize * renderTargetSize * 4,
                PixelDataFormat::RGBA, PixelDataType::UBYTE, 1, 0, 0, renderTargetSize,
                [](void* buffer, size_t size, void* user) {
-                    ReadPixelsTest* test = (ReadPixelsTest*)user;
+                    ReadPixelsTest* test = (ReadPixelsTest*) user;
                    test->readPixelsFinished = true;
                }, this);

-        api.readPixels(renderTarget, 0, 0, renderTargetSize, renderTargetSize,
-                std::move(descriptor));
+        api.readPixels(renderTarget, 0, 0, renderTargetSize, renderTargetSize, std::move(descriptor));
        api.commit(swapChain);
        api.endFrame(0);

@@ -17,8 +17,7 @@
 #include "BackendTest.h"

 #include "Lifetimes.h"
-#include "Shader.h"
-#include "SharedShaders.h"
+#include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"

 #include <backend/DriverEnums.h>
@@ -29,19 +28,42 @@
 #include <stddef.h>
 #include <stdint.h>

+namespace {
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Shaders
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+std::string vertex (R"(#version 450 core
+
+layout(location = 0) in vec4 mesh_position;
+layout(location = 0) out vec2 uv;
+
+void main() {
+    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
+    uv = (mesh_position.xy * 0.5 + 0.5);
+}
+)");
+
+std::string fragment (R"(#version 450 core
+
+layout(location = 0) out vec4 fragColor;
+layout(location = 0) in vec2 uv;
+
+layout(location = 0, set = 1) uniform sampler2D test_tex;
+
+void main() {
+    fragColor = texture(test_tex, uv);
+}
+)");
+
+}
+
 namespace test {

 using namespace filament;
 using namespace filament::backend;

-Shader createShader(DriverApi& api, Cleanup& cleanup, Backend backend) {
-    return SharedShaders::makeShader(api, cleanup, ShaderRequest{
-            .mVertexType = VertexShaderType::Textured,
-            .mFragmentType = FragmentShaderType::Textured,
-            .mUniformType = ShaderUniformType::Sampler
-    });
-}
-
 // Rendering an external image without setting any data should not crash.
 TEST_F(BackendTest, RenderExternalImageWithoutSet) {
    auto& api = getDriverApi();
@@ -51,41 +73,57 @@ TEST_F(BackendTest, RenderExternalImageWithoutSet) {

    auto swapChain = cleanup.add(createSwapChain());

-    Shader shader = createShader(api, cleanup, sBackend);
+    filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
+        SamplerType::SAMPLER_EXTERNAL, SamplerFormat::FLOAT, Precision::HIGH, false };
+    filamat::DescriptorSets descriptors;
+    descriptors[1] = { { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
+            samplerInfo } };
+    ShaderGenerator shaderGen(
+            vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));

-    backend::Handle<HwRenderTarget> defaultRenderTarget = cleanup.add(
-            api.createDefaultRenderTarget(0));
+    // Create a program that samples a texture.
+    Program p = shaderGen.getProgram(api);
+    p.descriptorBindings(1, {{"test_tex", DescriptorType::SAMPLER, 0}});
+    backend::Handle<HwProgram> program = cleanup.add(api.createProgram(std::move(p)));
+    DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
+            {{
+                     DescriptorType::SAMPLER,
+                     ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
+                     DescriptorFlags::NONE, 0
+             }}}));
+
+    DescriptorSetHandle descriptorSet = cleanup.add(api.createDescriptorSet(descriptorSetLayout));
+
+    backend::Handle<HwRenderTarget> defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));

    // Create a texture that will be backed by an external image.
    auto usage = TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE;
    const NativeView& view = getNativeView();
    backend::Handle<HwTexture> texture = cleanup.add(api.createTexture(
-            SamplerType::SAMPLER_EXTERNAL,      // target
-            1,                                  // levels
-            TextureFormat::RGBA8,               // format
-            1,                                  // samples
-            view.width,                         // width
-            view.height,                        // height
-            1,                                  // depth
-            usage));                             // usage
+                SamplerType::SAMPLER_EXTERNAL,      // target
+                1,                                  // levels
+                TextureFormat::RGBA8,               // format
+                1,                                  // samples
+                view.width,                         // width
+                view.height,                        // height
+                1,                                  // depth
+                usage));                             // usage

    RenderPassParams params = {};
    fullViewport(params);
    params.flags.clear = TargetBufferFlags::COLOR;
-    params.clearColor = { 0.f, 1.f, 0.f, 1.f };
+    params.clearColor = {0.f, 1.f, 0.f, 1.f};
    params.flags.discardStart = TargetBufferFlags::ALL;
    params.flags.discardEnd = TargetBufferFlags::NONE;

    PipelineState state;
-    state.program = shader.getProgram();
-    state.pipelineLayout.setLayout[1] = { shader.getDescriptorSetLayout() };
+    state.program = program;
+    state.pipelineLayout.setLayout[1] = { descriptorSetLayout };
    state.rasterState.colorWrite = true;
    state.rasterState.depthWrite = false;
    state.rasterState.depthFunc = RasterState::DepthFunc::A;
    state.rasterState.culling = CullingMode::NONE;

-    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
-
    api.startCapture(0);
    api.makeCurrent(swapChain, swapChain);
    api.beginFrame(0, 0, 0);
@@ -117,11 +155,29 @@ TEST_F(BackendTest, RenderExternalImage) {

    auto swapChain = cleanup.add(createSwapChain());

-    Shader shader = createShader(api, cleanup, sBackend);
-    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
+    filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
+        SamplerType::SAMPLER_EXTERNAL, SamplerFormat::FLOAT, Precision::HIGH, false };
+    filamat::DescriptorSets descriptors;
+    descriptors[1] = { { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
+            samplerInfo } };
+    ShaderGenerator shaderGen(
+            vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));

-    backend::Handle<HwRenderTarget> defaultRenderTarget = cleanup.add(
-            api.createDefaultRenderTarget(0));
+    // Create a program that samples a texture.
+    Program p = shaderGen.getProgram(api);
+    p.descriptorBindings(1, {{"test_tex", DescriptorType::SAMPLER, 0}});
+    auto program = cleanup.add(api.createProgram(std::move(p)));
+
+    DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
+            {{
+                     DescriptorType::SAMPLER,
+                     ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
+                     DescriptorFlags::NONE, 0
+             }}}));
+
+    DescriptorSetHandle descriptorSet = cleanup.add(api.createDescriptorSet(descriptorSetLayout));
+
+    backend::Handle<HwRenderTarget> defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));

    // require users to create two Filament textures and have two material parameters
    // add a "plane" parameter to setExternalImage
@@ -142,12 +198,10 @@ TEST_F(BackendTest, RenderExternalImage) {
    values[1] = values[0];
    values[2] = values[0];
    values[3] = values[0];
-    CFDictionaryRef options = CFDictionaryCreate(kCFAllocatorDefault, (const void**)keys,
-            (const void**)values, 4, nullptr, nullptr);
+    CFDictionaryRef options = CFDictionaryCreate(kCFAllocatorDefault, (const void**) keys, (const void**) values, 4, nullptr, nullptr);
    CVPixelBufferRef pixBuffer = nullptr;
    CVReturn status =
-            CVPixelBufferCreate(kCFAllocatorDefault, 1024, 1024, kCVPixelFormatType_32BGRA, options,
-                    &pixBuffer);
+            CVPixelBufferCreate(kCFAllocatorDefault, 1024, 1024, kCVPixelFormatType_32BGRA, options, &pixBuffer);
    assert(status == kCVReturnSuccess);

    // Fill image with checker-pattern.
@@ -156,7 +210,7 @@ TEST_F(BackendTest, RenderExternalImage) {
    const uint32_t black = 0xFF000000;
    CVReturn lockStatus = CVPixelBufferLockBaseAddress(pixBuffer, 0);
    assert(lockStatus == kCVReturnSuccess);
-    uint32_t* pix = (uint32_t*)CVPixelBufferGetBaseAddressOfPlane(pixBuffer, 0);
+    uint32_t* pix = (uint32_t*) CVPixelBufferGetBaseAddressOfPlane(pixBuffer, 0);
    assert(pix);
    for (size_t r = 0; r < 1024; r++) {
        for (size_t c = 0; c < 1024; c++) {
@@ -176,13 +230,13 @@ TEST_F(BackendTest, RenderExternalImage) {
    RenderPassParams params = {};
    fullViewport(params);
    params.flags.clear = TargetBufferFlags::COLOR;
-    params.clearColor = { 0.f, 1.f, 0.f, 1.f };
+    params.clearColor = {0.f, 1.f, 0.f, 1.f};
    params.flags.discardStart = TargetBufferFlags::ALL;
    params.flags.discardEnd = TargetBufferFlags::NONE;

    PipelineState state;
-    state.program = shader.getProgram();
-    state.pipelineLayout.setLayout[1] = { shader.getDescriptorSetLayout() };
+    state.program = program;
+    state.pipelineLayout.setLayout[1] = { descriptorSetLayout };
    state.rasterState.colorWrite = true;
    state.rasterState.depthWrite = false;
    state.rasterState.depthFunc = RasterState::DepthFunc::A;
@@ -193,6 +247,7 @@ TEST_F(BackendTest, RenderExternalImage) {
    api.beginFrame(0, 0, 0);

    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {});
+
    api.bindDescriptorSet(descriptorSet, 1, {});

    // Render a triangle.
@@ -17,8 +17,7 @@
 #include "BackendTest.h"

 #include "Lifetimes.h"
-#include "Shader.h"
-#include "SharedShaders.h"
+#include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"

 #include <utils/Hash.h>
@@ -28,6 +27,23 @@ namespace test {
 using namespace filament;
 using namespace filament::backend;

+static const char* const triangleVs = R"(#version 450 core
+layout(location = 0) in vec4 mesh_position;
+void main() {
+    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
+#if defined(TARGET_VULKAN_ENVIRONMENT)
+    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
+    gl_Position.y = -gl_Position.y;
+#endif
+})";
+
+static const char* const triangleFs = R"(#version 450 core
+precision mediump int; precision highp float;
+layout(location = 0) out vec4 fragColor;
+void main() {
+    fragColor = vec4(1.0f);
+})";
+
 TEST_F(BackendTest, ScissorViewportRegion) {
    auto& api = getDriverApi();

@@ -69,11 +85,10 @@ TEST_F(BackendTest, ScissorViewportRegion) {
        auto swapChain = cleanup.add(api.createSwapChainHeadless(256, 256, 0));
        api.makeCurrent(swapChain, swapChain);

-        Shader shader = SharedShaders::makeShader(api, cleanup, ShaderRequest{
-            .mVertexType = VertexShaderType::Noop,
-            .mFragmentType = FragmentShaderType::White,
-            .mUniformType = ShaderUniformType::None,
-        });
+        // Create a program.
+        ShaderGenerator shaderGen(triangleVs, triangleFs, sBackend, sIsMobilePlatform);
+        Program p = shaderGen.getProgram(api);
+        ProgramHandle program = cleanup.add(api.createProgram(std::move(p)));

        // Create source color and depth textures.
        Handle<HwTexture> srcTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, kNumLevels,
@@ -118,7 +133,7 @@ TEST_F(BackendTest, ScissorViewportRegion) {
        params.flags.discardEnd = TargetBufferFlags::NONE;

        PipelineState ps = {};
-        ps.program = shader.getProgram();
+        ps.program = program;
        ps.rasterState.colorWrite = true;
        ps.rasterState.depthWrite = false;

@@ -160,11 +175,10 @@ TEST_F(BackendTest, ScissorViewportEdgeCases) {
        auto swapChain = cleanup.add(api.createSwapChainHeadless(256, 256, 0));
        api.makeCurrent(swapChain, swapChain);

-        Shader shader = SharedShaders::makeShader(api, cleanup, ShaderRequest{
-                .mVertexType = VertexShaderType::Noop,
-                .mFragmentType = FragmentShaderType::White,
-                .mUniformType = ShaderUniformType::None,
-        });
+        // Create a program.
+        ShaderGenerator shaderGen(triangleVs, triangleFs, sBackend, sIsMobilePlatform);
+        Program p = shaderGen.getProgram(api);
+        ProgramHandle program = cleanup.add(api.createProgram(std::move(p)));

        // Create a source color textures.
        Handle<HwTexture> srcTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
@@ -206,7 +220,7 @@ TEST_F(BackendTest, ScissorViewportEdgeCases) {
        params.flags.discardEnd = TargetBufferFlags::NONE;

        PipelineState ps = {};
-        ps.program = shader.getProgram();
+        ps.program = program;
        ps.rasterState.colorWrite = true;
        ps.rasterState.depthWrite = false;

@@ -17,13 +17,43 @@
 #include "BackendTest.h"

 #include "Lifetimes.h"
-#include "Shader.h"
-#include "SharedShaders.h"
+#include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"

 using namespace filament;
 using namespace filament::backend;

+namespace {
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Shaders
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+std::string vertex (R"(#version 450 core
+
+layout(location = 0) in vec4 mesh_position;
+
+void main() {
+    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
+#if defined(TARGET_VULKAN_ENVIRONMENT)
+    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
+    gl_Position.y = -gl_Position.y;
+#endif
+}
+)");
+
+std::string fragment (R"(#version 450 core
+
+layout(location = 0) out vec4 fragColor;
+
+void main() {
+    fragColor = vec4(1.0);
+}
+
+)");
+
+}
+
 namespace test {

 // 1. Clear the stencil buffer to all zeroes.
@@ -34,7 +64,7 @@ namespace test {
 class BasicStencilBufferTest : public BackendTest {
 public:

-    Handle <HwSwapChain> mSwapChain;
+    Handle<HwSwapChain> mSwapChain;
    ProgramHandle mProgram;
    Cleanup mCleanup;

@@ -47,23 +77,21 @@ public:
        mSwapChain = mCleanup.add(createSwapChain());
        api.makeCurrent(mSwapChain, mSwapChain);

-        Shader shader = SharedShaders::makeShader(api, mCleanup, ShaderRequest{
-                .mVertexType = VertexShaderType::Noop,
-                .mFragmentType = FragmentShaderType::White,
-                .mUniformType = ShaderUniformType::None
-        });
-        mProgram = shader.getProgram();
+        // Create a program.
+        ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);
+        Program p = shaderGen.getProgram(api);
+        mProgram = mCleanup.add(api.createProgram(std::move(p)));
    }

-    void RunTest(Handle <HwRenderTarget> renderTarget) {
+    void RunTest(Handle<HwRenderTarget> renderTarget) {
        auto& api = getDriverApi();

        // We'll be using a triangle as geometry.
        TrianglePrimitive smallTriangle(api);
        static filament::math::float2 vertices[3] = {
                { -0.5, -0.5 },
-                { 0.5,  -0.5 },
-                { -0.5, 0.5 }
+                {  0.5, -0.5 },
+                { -0.5,  0.5 }
        };
        smallTriangle.updateVertices(vertices);
        TrianglePrimitive triangle(api);
@@ -72,7 +100,7 @@ public:
        // Render a small triangle only to the stencil buffer, increasing the stencil buffer to 1.
        RenderPassParams params = {};
        params.flags.clear = TargetBufferFlags::COLOR0 | TargetBufferFlags::STENCIL;
-        params.viewport = { 0, 0, 512, 512 };
+        params.viewport = {0, 0, 512, 512};
        params.clearColor = math::float4(0.0f, 0.0f, 1.0f, 1.0f);
        params.clearStencil = 0u;
        params.flags.discardStart = TargetBufferFlags::ALL;
@@ -125,7 +153,7 @@ TEST_F(BasicStencilBufferTest, StencilBuffer) {
            TextureFormat::STENCIL8, 1, 512, 512, 1, TextureUsage::STENCIL_ATTACHMENT));
    auto renderTarget = cleanup.add(api.createRenderTarget(
            TargetBufferFlags::COLOR0 | TargetBufferFlags::STENCIL, 512, 512, 1, 0,
-            {{ colorTexture }}, {}, {{ stencilTexture }}));
+            {{colorTexture}}, {}, {{stencilTexture}}));

    RunTest(renderTarget);

@@ -143,11 +171,10 @@ TEST_F(BasicStencilBufferTest, DepthAndStencilBuffer) {
    auto colorTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
            TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT));
    auto depthStencilTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
-            TextureFormat::DEPTH24_STENCIL8, 1, 512, 512, 1,
-            TextureUsage::STENCIL_ATTACHMENT | TextureUsage::DEPTH_ATTACHMENT));
+            TextureFormat::DEPTH24_STENCIL8, 1, 512, 512, 1, TextureUsage::STENCIL_ATTACHMENT | TextureUsage::DEPTH_ATTACHMENT));
    auto renderTarget = cleanup.add(api.createRenderTarget(
            TargetBufferFlags::COLOR0 | TargetBufferFlags::STENCIL, 512, 512, 1, 0,
-            {{ colorTexture }}, { depthStencilTexture }, {{ depthStencilTexture }}));
+            {{colorTexture}}, {depthStencilTexture}, {{depthStencilTexture}}));

    RunTest(renderTarget);

@@ -167,17 +194,15 @@ TEST_F(BasicStencilBufferTest, StencilBufferMSAA) {
    // Pass 1: Render a triangle into (an auto-created) MSAA color buffer using the stencil test.
    //         Performs an auto-resolve on the color.
    auto colorTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
-            TextureFormat::RGBA8, 1, 512, 512, 1,
-            TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE));
+            TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE));
    auto depthStencilTextureMSAA = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
-            TextureFormat::DEPTH24_STENCIL8, 4, 512, 512, 1,
-            TextureUsage::STENCIL_ATTACHMENT | TextureUsage::DEPTH_ATTACHMENT));
+            TextureFormat::DEPTH24_STENCIL8, 4, 512, 512, 1, TextureUsage::STENCIL_ATTACHMENT | TextureUsage::DEPTH_ATTACHMENT));
    auto renderTarget0 = cleanup.add(api.createRenderTarget(
            TargetBufferFlags::DEPTH_AND_STENCIL, 512, 512, 4, 0,
-            {{}}, { depthStencilTextureMSAA }, { depthStencilTextureMSAA }));
+            {{}}, {depthStencilTextureMSAA}, {depthStencilTextureMSAA}));
    auto renderTarget1 = cleanup.add(api.createRenderTarget(
            TargetBufferFlags::COLOR0 | TargetBufferFlags::DEPTH_AND_STENCIL, 512, 512, 4, 0,
-            {{ colorTexture }}, { depthStencilTextureMSAA }, { depthStencilTextureMSAA }));
+            {{colorTexture}}, {depthStencilTextureMSAA}, {depthStencilTextureMSAA}));

    api.startCapture(0);

@@ -185,8 +210,8 @@ TEST_F(BasicStencilBufferTest, StencilBufferMSAA) {
    TrianglePrimitive smallTriangle(api);
    static filament::math::float2 vertices[3] = {
            { -0.5, -0.5 },
-            { 0.5,  -0.5 },
-            { -0.5, 0.5 }
+            {  0.5, -0.5 },
+            { -0.5,  0.5 }
    };
    smallTriangle.updateVertices(vertices);
    TrianglePrimitive triangle(api);
@@ -195,7 +220,7 @@ TEST_F(BasicStencilBufferTest, StencilBufferMSAA) {
    // Render a small triangle only to the stencil buffer, increasing the stencil buffer to 1.
    RenderPassParams params = {};
    params.flags.clear = TargetBufferFlags::STENCIL;
-    params.viewport = { 0, 0, 512, 512 };
+    params.viewport = {0, 0, 512, 512};
    params.clearStencil = 0u;
    params.flags.discardStart = TargetBufferFlags::ALL;
    params.flags.discardEnd = TargetBufferFlags::NONE;
@@ -317,15 +317,6 @@ public:
         */
        size_t metalUploadBufferSizeBytes = 512 * 1024;

-        /**
-         * The action to take if a Drawable cannot be acquired.
-         *
-         * Each frame rendered requires a CAMetalDrawable texture, which is
-         * presented on-screen at the completion of each frame. These are
-         * limited and provided round-robin style by the system.
-         */
-        bool metalDisablePanicOnDrawableFailure = false;
-
        /**
         * Set to `true` to forcibly disable parallel shader compilation in the backend.
         * Currently only honored by the GL and Metal backends.
@@ -138,7 +138,6 @@ Engine* FEngine::create(Builder const& builder) {
                .forceGLES2Context = instance->getConfig().forceGLES2Context,
                .stereoscopicType = instance->getConfig().stereoscopicType,
                .assertNativeWindowIsValid = instance->features.backend.opengl.assert_native_window_is_valid,
-                .metalDisablePanicOnDrawableFailure = instance->getConfig().metalDisablePanicOnDrawableFailure,
        };
        instance->mDriver = platform->createDriver(sharedContext, driverConfig);

@@ -734,7 +733,6 @@ int FEngine::loop() {
            .forceGLES2Context = mConfig.forceGLES2Context,
            .stereoscopicType =  mConfig.stereoscopicType,
            .assertNativeWindowIsValid = features.backend.opengl.assert_native_window_is_valid,
-            .metalDisablePanicOnDrawableFailure = mConfig.metalDisablePanicOnDrawableFailure,
    };
    mDriver = mPlatform->createDriver(mSharedGLContext, driverConfig);

@@ -793,17 +791,6 @@ int FEngine::loop() {
        }
    }

-#if FILAMENT_ENABLE_MATDBG
-    if(debug.server) {
-        delete debug.server;
-    } 
-#endif
-#if FILAMENT_ENABLE_FGVIEWER 
-    if(debug.fgviewerServer) {
-        delete debug.fgviewerServer;
-    }
-#endif
-
    // terminate() is a synchronous API
    getDriverApi().terminate();
    return 0;
@@ -1364,7 +1364,6 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
            xvp.left = xvp.bottom = 0;
            svp = xvp;
        }
-
        if (scaled) {
            mightNeedFinalBlit = false;
            auto viewport = DEBUG_DYNAMIC_SCALING ? xvp : vp;
@@ -1386,59 +1385,34 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
                        SamplerMagFilter::NEAREST, SamplerMinFilter::NEAREST);
    }

-    if (UTILS_UNLIKELY((input == postProcessInput && viewRenderTarget == mRenderTargetHandle) &&
-            view.isStencilBufferEnabled())) {
-        // FIXME: I think this check is incomplete, if we're rendering into a custom rendertarget
-        //        we need to check that it (not the swapchain) has a stencil buffer.
-        assert_invariant(mSwapChain);
-        FILAMENT_CHECK_PRECONDITION(mSwapChain->hasStencilBuffer())
-                << "View has stencil buffer enabled, but SwapChain does not have "
-                   "SwapChain::CONFIG_HAS_STENCIL_BUFFER flag set.";
-    }
-
-    /*
-     * Here we're ready to present the output of the framegraph, which is held in `input`.
-     * The presentation itself happens by forwarding `input` to the render target, which can
-     * either be the SwapChain's or the View's custom render target. This is done below with
-     * `forwardResource()`.
-     *
-     * There are however a few situations where `input` cannot be forwarded in this manner, and
-     * an intermediate buffer is needed instead.
-     *
-     * 1. Blending is needed (blendModeTranslucent)
-     * 2. Dimensions don't match, e.g.: because we have guard bands (xvp != svp)
-     * 3. MRT is needed (colorGradingConfig.asSubpass)
-     * 4. Frame history is needed (hasScreenSpaceRefraction)
-     * 5. Refraction is used because how clear flags work (ssReflectionsOptions.enabled)
-     * 6. `input` and the render target are not compatible:
-     *      - MSAA doesn't match. Note: auto-resolve could work if the SwapChain was configured
-     *        this way.
-     *
-     * One complication is that post-processing passes handle some of these issues automatically:
-     * - each post-processing pass will create an intermediate buffer, which takes care of
-     *      - MSAA (because of auto-resolve)
-     *      - MRT is needed
-     *      - Frame history is needed
-     *      - Refraction
-     * - the upscaling pass takes care of all the above plus blending and dimensions mismatch.
-     *
-     * TODO: we could make this work with custom render targets because we can access the texture
-     *       for those and it could behave just like a regular resource. This would lift
-     *       some (but not all) of those limitations. For instance we could use MRTs.
-     */
+    // We need to do special processing when rendering directly into the swap-chain, that is when
+    // the viewRenderTarget is the default render target (mRenderTarget) and we're rendering into
+    // it.
+    // * This is because the default render target is not multi-sampled, so we need an
+    //   intermediate buffer when MSAA is enabled.
+    // * We also need an extra buffer for blending the result to the framebuffer if the view
+    //   is translucent AND we've not already done it as part of upscaling.
+    // * And we can't use the default rendertarget if MRT is required (e.g. with color grading
+    //   as a subpass)
+    // * And we also can't use the default rendertarget if frame history is needed (e.g. with
+    //   screen-space reflections)
+    // * And we also can't use the default rendertarget with refractions, which need to reuse
+    //   the rendertarget due to how the clear flags work.
+    // * We also need an extra blit if we haven't yet handled "xvp"
+    //   TODO: in that specific scenario it would be better to just not use xvp
+    // The intermediate buffer is accomplished with a "fake" opaqueBlit (i.e. blit) operation.

+    const bool outputIsSwapChain =
+            (input == postProcessInput) && (viewRenderTarget == mRenderTargetHandle);
    if (mightNeedFinalBlit) {
-        assert_invariant(!scaled);
-        // Determine if our `input` is in fact the output of the color pass, in which case
-        // many of the caveat above apply.
-        bool const inputIsColorPass = (input == postProcessInput);
        if (blendModeTranslucent ||
            xvp != svp ||
-            (inputIsColorPass &&
+            (outputIsSwapChain &&
                    (msaaSampleCount > 1 ||
                    colorGradingConfig.asSubpass ||
                    hasScreenSpaceRefraction ||
                    ssReflectionsOptions.enabled))) {
+            assert_invariant(!scaled);
            input = ppm.blit(fg, blendModeTranslucent, input, xvp, {
                            .width = vp.width, .height = vp.height,
                            .format = colorGradingConfig.ldrFormat },
@@ -1446,6 +1420,13 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
        }
    }

+    if (UTILS_UNLIKELY(outputIsSwapChain && view.isStencilBufferEnabled())) {
+        assert_invariant(mSwapChain);
+        FILAMENT_CHECK_PRECONDITION(mSwapChain->hasStencilBuffer())
+                << "View has stencil buffer enabled, but SwapChain does not have "
+                   "SwapChain::CONFIG_HAS_STENCIL_BUFFER flag set.";
+    }
+
    if (UTILS_UNLIKELY(engine.debug.shadowmap.display_shadow_texture)) {
        auto shadowmap = blackboard.get<FrameGraphTexture>("shadowmap");
        input = ppm.debugDisplayShadowTexture(fg, input, shadowmap,
@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
  spec.name = "Filament"
-  spec.version = "1.59.0"
+  spec.version = "1.58.2"
  spec.license = { :type => "Apache 2.0", :file => "LICENSE" }
  spec.homepage = "https://google.github.io/filament"
  spec.authors = "Google LLC."
  spec.summary = "Filament is a real-time physically based rendering engine for Android, iOS, Windows, Linux, macOS, and WASM/WebGL."
  spec.platform = :ios, "11.0"
-  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.59.0/filament-v1.59.0-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.58.2/filament-v1.58.2-ios.tgz" }

  # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
  spec.pod_target_xcconfig = {
@@ -518,12 +518,25 @@ void GLSLPostProcessor::spirvToMsl(const SpirvBlob* spirv, std::string* outMsl,
    }
 }

-void GLSLPostProcessor::rebindImageSamplerForWGSL(std::vector<uint32_t> &spirv) {
+void GLSLPostProcessor::rebindImageSamplerForWGSL(std::vector<uint32_t>& spirv) {
    constexpr size_t HEADER_SIZE = 5;
    size_t const dataSize = spirv.size();
-    uint32_t *data = spirv.data();
+    uint32_t* data = spirv.data();

-    std::set<uint32_t> samplerTargetIDs;
+    struct Descriptor {
+        uint32_t binding = 0xFFFFFFFF;
+        bool fixed = false;
+    };
+
+    std::unordered_map<uint32_t, Descriptor> descriptors;
+    auto getDesc = [&](uint32_t var) -> Descriptor& {
+        using itertype = std::unordered_map<uint32_t, Descriptor>::iterator;
+        itertype itr;
+        if (itr = descriptors.find(var); itr == descriptors.end()) {
+            itr = descriptors.insert({var, {}}).first;
+        }
+        return itr->second;
+    };

    auto pass = [&](uint32_t targetOp, std::function<void(uint32_t)> f) {
        for (uint32_t cursor = HEADER_SIZE, cursorEnd = dataSize; cursor < cursorEnd;) {
@@ -531,40 +544,68 @@ void GLSLPostProcessor::rebindImageSamplerForWGSL(std::vector<uint32_t> &spirv)
            uint32_t const wordCount = firstWord >> 16;
            uint32_t const op = firstWord & 0x0000FFFF;
            if (targetOp == op) {
-                f(cursor + 1);
+                f(cursor+1);
            }
            cursor += wordCount;
        }
    };

-    //Parse through debug name info to determine which bindings are samplers and which are not.
-    // This is possible because the sampler splitting pass outputs sampler and texture pairs of the form:
-    // `uniform sampler2D var_x` => `uniform sampler var_sampler` and `uniform texture2D var_texture`;
-    // TODO: This works, but may limit what optimizations can be done and has the potential to collide with user
-    // variable names. Ideally, trace usage to determine binding type.
-    pass(spv::Op::OpName, [&](uint32_t pos) {
-        auto target = data[pos];
-        char *name = (char *) &data[pos + 1];
-        std::string_view view(name);
-        if (view.find("_sampler") != std::string_view::npos) {
-            samplerTargetIDs.insert(target);
-        }
+    uint32_t samplerTypeId = 0;
+
+    // First we find the ID used to identify the sampler type and the image type.
+    pass(spv::Op::OpTypeSampler, [&](uint32_t pos) {
+        samplerTypeId = data[pos];
    });

-    // Write out the offset bindings
+    // Next we identify all the descriptors and record their set id and binding.
    pass(spv::Op::OpDecorate, [&](uint32_t pos) {
        uint32_t const type = data[pos + 1];
        if (type == spv::Decoration::DecorationBinding) {
            uint32_t const targetVar = data[pos];
-            if (samplerTargetIDs.find(targetVar) != samplerTargetIDs.end()) {
-                data[pos + 2] = data[pos + 2] * 2 + 1;
-            } else {
-                data[pos + 2] = data[pos + 2] * 2;
+            uint32_t const binding = data[pos + 2];
+            auto& desc = getDesc(targetVar);
+            desc.binding = binding;
+            // Note these decorations do not need to be written to the output.
+        } else if (type == spv::Decoration::DecorationDescriptorSet) {
+            uint32_t const targetVar = data[pos];
+            uint32_t const set = data[pos + 2];
+            auto& desc = getDesc(targetVar);
+        }
+    });
+
+    // Offset samplers by 2n+1, and everything else by 2n
+    pass(spv::Op::OpLoad, [&](uint32_t pos) {
+        uint32_t const retType = data[pos];
+        uint32_t const targetVar = data[pos + 2];
+        auto& desc = getDesc(targetVar);
+        if (retType == samplerTypeId) {
+            if (!desc.fixed) {
+                //desc.binding = (desc.binding * 2) +1;
+                desc.binding = (desc.binding ) +100;
+
+                desc.fixed = true;
+            }
+        }
+        else {
+            if (!desc.fixed) {
+                //desc.binding *=2;
+               // desc.fixed = true;
            }
        }
    });
+
+    // Write out the offsetted bindings
+    pass(spv::Op::OpDecorate, [&](uint32_t pos) {
+        uint32_t const type = data[pos + 1];
+        if (type == spv::Decoration::DecorationBinding) {
+            uint32_t const targetVar = data[pos];
+            auto const &desc = getDesc(targetVar);
+            data[pos + 2] = desc.binding;
+        }
+    });
 }

+
 bool GLSLPostProcessor::spirvToWgsl(SpirvBlob *spirv, std::string *outWsl) {
 #if FILAMENT_SUPPORTS_WEBGPU
    //We need to run some opt-passes at all times to transpile to WGSL
@@ -582,25 +623,8 @@ bool GLSLPostProcessor::spirvToWgsl(SpirvBlob *spirv, std::string *outWsl) {
    tint::Program tintRead = tint::spirv::reader::Read(*spirv, readerOpts);

    if (tintRead.Diagnostics().ContainsErrors()) {
-        //We know errors can potentially crop up, and want the ability to ignore them if needed for sample bringup
-#ifndef FILAMENT_WEBGPU_IGNORE_TNT_READ_ERRORS
-        slog.e << "Tint Reader Error: " << tintRead.Diagnostics().Str() << io::endl;
-        spv_context context = spvContextCreate(SPV_ENV_VULKAN_1_1_SPIRV_1_4);
-        spv_text text = nullptr;
-        spv_diagnostic diagnostic = nullptr;
-        spv_result_t result = spvBinaryToText(
-            context,
-            spirv->data(),
-            spirv->size(),
-            SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | SPV_BINARY_TO_TEXT_OPTION_COLOR,
-            &text,
-            &diagnostic);
-        slog.e << "Beginning SpirV-output dump with ret " << result << "\n\n" << text->str << "\n\nEndSPIRV\n" <<
-                io::endl;
-        spvTextDestroy(text);
        slog.e << "Tint Reader Error: " << tintRead.Diagnostics().Str() << io::endl;
        return false;
-#endif
    }

    tint::Result<tint::wgsl::writer::Output> wgslOut = tint::wgsl::writer::Generate(tintRead,writerOpts);
@@ -608,7 +632,7 @@ bool GLSLPostProcessor::spirvToWgsl(SpirvBlob *spirv, std::string *outWsl) {
    tint::SuccessType tintSuccess;

    if (wgslOut != tintSuccess) {
-        slog.e << "Tint writer error: " << wgslOut.Failure().reason << io::endl;
+        slog.e << "Tint writer error: " << wgslOut.Failure().reason.Str() << io::endl;
        return false;
    }
    *outWsl = wgslOut->wgsl;
@@ -1020,9 +1044,6 @@ void GLSLPostProcessor::fixupClipDistance(
 // - triggers a segfault with AMD OpenGL drivers on macOS
 // - triggers a crash on some Adreno drivers (b/291140208, b/289401984, b/289393290)
 // However Metal requires this pass in order to correctly generate half-precision MSL
-// CreateMergeReturnPass() also creates issues with Tint conversion related to the
-// bitwise "<<" Operator used in shaders/src/surface_light_directional.fs against
-// a signed integer.
 //
 // CreateSimplificationPass() creates a lot of problems:
 // - Adreno GPU show artifacts after running simplification passes (Vulkan)
@@ -1033,11 +1054,6 @@ void GLSLPostProcessor::fixupClipDistance(
 // However, the simplification passes below are necessary when targeting Metal, otherwise the
 // result is mismatched half / float assignments in MSL.

-// CreateInlineExhaustivePass() expects CreateMergeReturnPass() to be run beforehand
-// (Throwing many warnings if this is not the case), but we don't consistently do so for the above
-// reasons. While running it alone may have some value, we will disable it for the new WebGPU backend
-// while minimizing other changes.
-

 void GLSLPostProcessor::registerPerformancePasses(Optimizer& optimizer, Config const& config) {
    auto RegisterPass = [&](spvtools::Optimizer::PassToken&& pass,
@@ -1051,6 +1067,7 @@ void GLSLPostProcessor::registerPerformancePasses(Optimizer& optimizer, Config c
    RegisterPass(CreateWrapOpKillPass());
    RegisterPass(CreateDeadBranchElimPass());
    RegisterPass(CreateMergeReturnPass(), MaterialBuilder::TargetApi::METAL);
+    //TODO Do not run inline pass without merge return pass until we sort out issues
    RegisterPass(CreateInlineExhaustivePass(), MaterialBuilder::TargetApi::ALL & ~MaterialBuilder::TargetApi::WEBGPU);
    RegisterPass(CreateAggressiveDCEPass());
    RegisterPass(CreatePrivateToLocalPass());
@@ -1095,7 +1112,7 @@ void GLSLPostProcessor::registerSizePasses(Optimizer& optimizer, Config const& c

    RegisterPass(CreateWrapOpKillPass());
    RegisterPass(CreateDeadBranchElimPass());
-    //  Disable for WebGPU, see comment above registerPerformancePasses()
+    //TODO Do not run inline pass without merge return pass until we sort out issues
    RegisterPass(CreateInlineExhaustivePass(), MaterialBuilder::TargetApi::ALL & ~MaterialBuilder::TargetApi::WEBGPU);
    RegisterPass(CreateEliminateDeadFunctionsPass());
    RegisterPass(CreatePrivateToLocalPass());
@@ -17,8 +17,6 @@
 #ifndef TNT_UTILS_STATICSTRING_H
 #define TNT_UTILS_STATICSTRING_H

-#include <utils/compiler.h>
-
 #include <type_traits>
 #include <string_view>

@@ -1,109 +0,0 @@
-# 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.
-
-import os
-import glob
-import yaml
-import hashlib
-import concurrent.futures
-import re
-
-from utils import execute, ArgParseImpl
-
-def get_line(file_name, offset):
-  with open(f'{file_name}', 'rb') as file:
-    bytes = file.read()[0:offset]
-    f_str = bytes.decode('utf-8')
-    return len(f_str.split('\n'))
-  return -1
-
-def get_func_name(msg):
-  pattern = r"\'(.+)\'"
-  res = re.findall(pattern, msg)
-  if len(res) > 0:
-    return res[0].replace("'", '')
-  return msg
-
-def run_tidy(files):
-  files_str = ' '.join(files)
-  hid = hashlib.md5(files_str.encode('utf-8')).hexdigest()
-  _, _ = execute(f'clang-tidy --export-fixes=/tmp/{hid}.yaml --quiet --checks=-*,bugprone-exception-escape {files_str}')
-  results = []
-  with open(f'/tmp/{hid}.yaml', 'r') as file:
-    data = yaml.safe_load(file)
-    for d in data['Diagnostics']:
-      if d['DiagnosticName'] != 'bugprone-exception-escape':
-        continue
-      msg = d['DiagnosticMessage']
-      fpath = msg['FilePath']
-      offset = msg['FileOffset']
-      line_num = get_line(fpath, offset)
-      results.append((msg['FilePath'].replace(f'{os.getcwd()}/', ''), line_num, get_func_name(msg['Message'])))
-  return results
-
-def exception_escape_test():
-  files = glob.glob('filament/**/*.mm', recursive=True) + \
-      glob.glob('filament/**/*.cpp', recursive=True) + \
-      glob.glob('filament/**/*.h', recursive=True)
-
-  num_workers = 5  # Number of threads to spawn
-  part_len = len(files) // num_workers
-  workloads = []
-  for i in range(num_workers):
-    next = min(len(files), part_len)
-    workloads.append(files[0:next])
-    files = files[next:]
-
-  all_results = []
-  with concurrent.futures.ThreadPoolExecutor(max_workers=num_workers) as executor:
-    future_to_worker_id = {executor.submit(run_tidy, workloads[i]): i for i in range(num_workers)}
-
-    for future in concurrent.futures.as_completed(future_to_worker_id):
-      worker_id = future_to_worker_id[future]
-      try:
-        all_results.extend(future.result())
-      except Exception as exc:
-          print(f"Main: Worker {worker_id} generated an exception: {exc}")
-  test_name = 'code-correctness::exception-escape'
-  failure_str_lines = []
-  if len(all_results) > 0:
-    failure_str_lines.append(f'Number of failures: {len(all_results)}')
-    for fname, line_num, msg in all_results:
-      failure_str_lines.append(f'{fname}({line_num}): {msg}()')
-  return (len(all_results) == 0, failure_str_lines)
-
-TESTS = [
-  (exception_escape_test,
-   'exception-escape',
-   '\'an exception may be thrown in a function which should not throw exceptions\'')
-]
-
-if __name__ == "__main__":
-  has_failures = False
-  for test_func, test_name, test_desc in TESTS:
-    result, res_strs = test_func()
-    ss = ' ' * 4
-    if result:
-      print(f'[{test_name}] PASSED')
-    else:
-      has_failures = True
-      print(f'[{test_name}] FAILED')
-      print(f'{ss}Description: \'{test_desc}\'')
-      for s in res_strs:
-        print(f'{ss}{s}')
-  if has_failures:
-    # TODO: Enable this when we've fixed all the exception-escape errors
-    #exit(1)    
-    pass
-
@@ -1,68 +0,0 @@
-# Copyright (C) 2024 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.
-
-import subprocess
-import os
-import argparse
-import sys
-
-def execute(cmd,
-            cwd=None,
-            capture_output=True,
-            stdin=None,
-            env=None,
-            raise_errors=False):
-  in_env = os.environ
-  in_env.update(env if env else {})
-  home = os.environ['HOME']
-  if f'{home}/bin' not in in_env['PATH']:
-    in_env['PATH'] = in_env['PATH'] + f':{home}/bin'
-
-  stdout = subprocess.PIPE if capture_output else sys.stdout
-  stderr = subprocess.PIPE if capture_output else sys.stdout
-  output = ''
-  err_output = ''
-  return_code = -1
-  kwargs = {
-      'cwd': cwd,
-      'env': in_env,
-      'stdout': stdout,
-      'stderr': stderr,
-      'stdin': stdin,
-      'universal_newlines': True
-  }
-  if capture_output:
-    process = subprocess.Popen(cmd.split(' '), **kwargs)
-    output, err_output = process.communicate()
-    return_code = process.returncode
-  else:
-    return_code = subprocess.call(cmd.split(' '), **kwargs)
-
-  if return_code:
-    # Error
-    if raise_errors:
-      raise subprocess.CalledProcessError(return_code, cmd)
-  if output:
-    if type(output) != str:
-      try:
-        output = output.decode('utf-8').strip()
-      except UnicodeDecodeError as e:
-        print('cannot decode ', output, file=sys.stderr)
-  return return_code, (output if return_code == 0 else err_output)
-
-class ArgParseImpl(argparse.ArgumentParser):
-  def error(self, message):
-    sys.stderr.write('error: %s\n' % message)
-    self.print_help()
-    sys.exit(1)
@@ -1,28 +0,0 @@
-# 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.
-
-#!/usr/bin/bash
-
-CODE_CORRECTNESS_TEST_DIR="$(pwd)/test/code-correctness"
-
-# Check if the clang-tidy command exists and is executable
-if ! command -v clang-tidy > /dev/null 2>&1; then
-  # If command -v fails (returns a non-zero exit status), clang-tidy is not found
-  echo "Error: clang-tidy command not found." >&2
-  echo "Please install clang-tidy or ensure it is in your system's PATH." >&2
-  exit 1 # Exit the script with an error code (conventionally non-zero for failure)
-fi
-
-set -e && set -x && \
-    python3 ${CODE_CORRECTNESS_TEST_DIR}/src/run.py
@@ -1,17 +0,0 @@
-# Bzlmod lockfile
-MODULE.bazel.lock
-# Ignore all bazel-* symlinks.
-/bazel-*
-# Ignore Bazel verbose explanations
--verbose_explanations
-# Ignore CMake usual build directory
-build
-# Ignore Vim files
-*.swp
-# Ignore QtCreator Project file
-CMakeLists.txt.user
-# Ignore VS Code files
-.vscode/*
-# Ignore generated python artifacts
-*.pyc
-copts/__pycache__/
@@ -0,0 +1,374 @@
+# Copyright 2018 The Chromium Authors
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# Flags specified here must not impact ABI. Code compiled with and without these
+# opts will be linked together, and in some cases headers compiled with and
+# without these options will be part of the same program.
+
+import("//build/config/c++/c++.gni")
+import("//build/config/nacl/config.gni")
+import("//build/config/sanitizers/sanitizers.gni")
+import("//build/toolchain/toolchain.gni")
+import("//build_overrides/build.gni")
+import("//third_party/abseil-cpp/absl.gni")
+
+config("absl_component_build") {
+  defines = [ "ABSL_CONSUME_DLL" ]
+}
+
+assert(!is_nacl || is_nacl_saigo,
+       "base must not be built in most nacl toolchains")
+
+component("absl") {
+  public_deps = [ ":absl_component_deps" ]
+  if (is_component_build) {
+    public_configs = [ ":absl_component_build" ]
+
+    if (is_win && is_clang) {
+      if (current_cpu == "x64") {
+        if (is_debug) {
+          sources = [ "symbols_x64_dbg.def" ]
+        } else {
+          if (is_asan) {
+            sources = [ "symbols_x64_rel_asan.def" ]
+          } else {
+            sources = [ "symbols_x64_rel.def" ]
+          }
+        }
+      }
+      if (current_cpu == "x86") {
+        if (is_debug) {
+          sources = [ "symbols_x86_dbg.def" ]
+        } else {
+          sources = [ "symbols_x86_rel.def" ]
+        }
+      }
+      if (current_cpu == "arm64") {
+        if (is_debug) {
+          sources = [ "symbols_arm64_dbg.def" ]
+        } else {
+          sources = [ "symbols_arm64_rel.def" ]
+        }
+      }
+    }
+  }
+}
+
+group("absl_component_deps") {
+  public_deps = [
+    "//third_party/abseil-cpp/absl/algorithm:container",
+    "//third_party/abseil-cpp/absl/base",
+    "//third_party/abseil-cpp/absl/base:config",
+    "//third_party/abseil-cpp/absl/base:core_headers",
+    "//third_party/abseil-cpp/absl/base:no_destructor",
+    "//third_party/abseil-cpp/absl/base:nullability",
+    "//third_party/abseil-cpp/absl/base:prefetch",
+    "//third_party/abseil-cpp/absl/cleanup",
+    "//third_party/abseil-cpp/absl/container:btree",
+    "//third_party/abseil-cpp/absl/container:fixed_array",
+    "//third_party/abseil-cpp/absl/container:flat_hash_map",
+    "//third_party/abseil-cpp/absl/container:flat_hash_set",
+    "//third_party/abseil-cpp/absl/container:inlined_vector",
+    "//third_party/abseil-cpp/absl/container:node_hash_map",
+    "//third_party/abseil-cpp/absl/container:node_hash_set",
+    "//third_party/abseil-cpp/absl/debugging:failure_signal_handler",
+    "//third_party/abseil-cpp/absl/debugging:stacktrace",
+    "//third_party/abseil-cpp/absl/debugging:symbolize",
+    "//third_party/abseil-cpp/absl/functional:any_invocable",
+    "//third_party/abseil-cpp/absl/functional:bind_front",
+    "//third_party/abseil-cpp/absl/functional:function_ref",
+    "//third_party/abseil-cpp/absl/functional:overload",
+    "//third_party/abseil-cpp/absl/hash",
+    "//third_party/abseil-cpp/absl/log:absl_check",
+    "//third_party/abseil-cpp/absl/log:absl_log",
+    "//third_party/abseil-cpp/absl/log:die_if_null",
+    "//third_party/abseil-cpp/absl/memory",
+    "//third_party/abseil-cpp/absl/meta:type_traits",
+    "//third_party/abseil-cpp/absl/numeric:bits",
+    "//third_party/abseil-cpp/absl/numeric:int128",
+    "//third_party/abseil-cpp/absl/random",
+    "//third_party/abseil-cpp/absl/random:distributions",
+    "//third_party/abseil-cpp/absl/status",
+    "//third_party/abseil-cpp/absl/status:statusor",
+    "//third_party/abseil-cpp/absl/strings",
+    "//third_party/abseil-cpp/absl/strings:cord",
+    "//third_party/abseil-cpp/absl/strings:has_ostream_operator",
+    "//third_party/abseil-cpp/absl/strings:str_format",
+    "//third_party/abseil-cpp/absl/strings:string_view",
+    "//third_party/abseil-cpp/absl/synchronization",
+    "//third_party/abseil-cpp/absl/time",
+    "//third_party/abseil-cpp/absl/types:optional",
+    "//third_party/abseil-cpp/absl/types:span",
+    "//third_party/abseil-cpp/absl/types:variant",
+    "//third_party/abseil-cpp/absl/utility",
+  ]
+
+  if (is_component_build) {
+    public_deps += [ ":absl_full_deps" ]
+  }
+
+  # The following dependencies currently don't build with NaCl.
+  # TODO(https://crbug.com/1114625): Fix build errors and remove this section.
+  if (is_nacl) {
+    public_deps -=
+        [ "//third_party/abseil-cpp/absl/debugging:failure_signal_handler" ]
+  }
+
+  visibility = [ ":absl" ]
+}
+
+# Some third-party libraries use additional parts of absl that are banned in
+# Chrome (e.g. flags generates static initializers that are undesirable in
+# non-test binaries). These third-party libraries can depend on `absl_full`
+# instead of `absl` to use those banned subsets of Abseil as well.
+source_set("absl_full") {
+  public_deps = [ ":absl" ]
+
+  # In component builds, `absl` itself depends on `absl_full_deps` directly so
+  # that all of absl is built as a single shared library. This is to prevent
+  # globals from being duplicated between both `absl` and `absl_full` (e.g.
+  # inline variables), and the subtle breakage that could cause.
+  #
+  # Deps violations will still be enforced by the non-component build.
+  if (!is_component_build) {
+    public_deps += [ ":absl_full_deps" ]
+  }
+
+  if (build_with_chromium) {
+    visibility = [
+      "//third_party/fuzztest:*",
+
+      # GoogleTest doesn't actually need absl_full, but this makes gn check
+      # happier.
+      "//third_party/googletest:*",
+    ]
+  }
+}
+
+group("absl_full_deps") {
+  public_deps = [
+    # Banned because each flag registration generates a static initializer, and
+    # the flag registration mechanism is problematic in component builds.
+    "//third_party/abseil-cpp/absl/flags:config",
+    "//third_party/abseil-cpp/absl/flags:flag",
+    "//third_party/abseil-cpp/absl/flags:parse",
+    "//third_party/abseil-cpp/absl/flags:reflection",
+    "//third_party/abseil-cpp/absl/flags:usage",
+
+    # Banned because the LOG and CHECK macros conflict with Chrome's version of
+    # those macros.
+    "//third_party/abseil-cpp/absl/log",
+    "//third_party/abseil-cpp/absl/log:check",
+
+    # TODO(danilchap): Investigate if these targets need to be banned in 3rd party library code.
+    "//third_party/abseil-cpp/absl/log:globals",
+    "//third_party/abseil-cpp/absl/log:initialize",
+    "//third_party/abseil-cpp/absl/random:bit_gen_ref",
+  ]
+
+  visibility = [
+    ":absl_component_deps",
+    ":absl_full",
+  ]
+
+  public_configs = [ "//third_party/abseil-cpp/absl/flags:absl_flags_config" ]
+}
+
+config("absl_include_config") {
+  include_dirs = [ "." ]
+}
+
+config("absl_define_config") {
+  defines = [ "ABSL_ALLOCATOR_NOTHROW=1" ]
+
+  if (is_win && !use_custom_libcxx) {
+    defines += [
+      # See crbug.com/1101367: Acknowledge extended alignment when using
+      # MSVC's standard library.
+      "_ENABLE_EXTENDED_ALIGNED_STORAGE",
+    ]
+  }
+}
+
+config("absl_default_cflags_cc") {
+  cflags_cc = []
+  if (is_clang) {
+    cflags_cc += [
+      # TODO(crbug.com/588506): Explicitly enable conversion warnings.
+      "-Wbool-conversion",
+      "-Wconstant-conversion",
+      "-Wenum-conversion",
+      "-Wint-conversion",
+      "-Wliteral-conversion",
+      "-Wnon-literal-null-conversion",
+      "-Wnull-conversion",
+      "-Wobjc-literal-conversion",
+      "-Wstring-conversion",
+    ]
+    if (!is_nacl) {
+      cflags_cc += [ "-Wbitfield-enum-conversion" ]
+    }
+  }
+}
+
+config("absl_public_cflags_cc") {
+  # Non-chromium users of abseil have more lax style guides and use additional features in
+  # abseil, Remove a few extra warnings for that use case.
+  if (!build_with_chromium && is_clang) {
+    cflags = [
+      # Allow the use of enable_if()
+      "-Wno-gcc-compat",
+      "-Wno-unreachable-code-break",
+    ]
+  }
+}
+
+config("absl_test_cflags_cc") {
+  cflags_cc = []
+  if (is_clang || !is_win) {
+    cflags_cc += [
+      "-Wno-conversion-null",
+      "-Wno-missing-declarations",
+      "-Wno-unused-function",
+      "-Wno-unused-parameter",
+      "-Wno-unused-private-field",
+    ]
+  }
+  if (is_win) {
+    cflags_cc += [
+      "/wd4101",  # unreferenced local variable
+    ]
+  }
+}
+
+config("absl_test_config") {
+  cflags_cc = []
+  if (is_win && !is_clang) {
+    cflags_cc += [ "/wd4996" ]
+  }
+  if (is_clang) {
+    cflags_cc += [
+      "-Wno-deprecated-declarations",
+      "-Wno-implicit-const-int-float-conversion",
+      "-Wno-unused-private-field",
+      "-Wno-unused-function",
+    ]
+  }
+}
+
+if (absl_build_tests) {
+  import("//testing/test.gni")
+
+  if (!is_component_build) {
+    test("absl_tests") {
+      testonly = true
+      deps = [
+        "absl/algorithm:algorithm_test",
+        "absl/algorithm:container_test",
+        "absl/base:config_test",
+        "absl/base:no_destructor_test",
+        "absl/base:nullability_test",
+        "absl/base:prefetch_test",
+        "absl/cleanup:cleanup_test",
+
+        # TODO(mbonadei): Fix issue with EXPECT_DEATH and uncomment.
+        # "absl/container:btree_test",
+        "absl/container:common_policy_traits_test",
+        "absl/container:fixed_array_test",
+        "absl/container:flat_hash_map_test",
+        "absl/container:flat_hash_set_test",
+        "absl/container:hash_function_defaults_test",
+        "absl/container:inlined_vector_test",
+        "absl/container:node_slot_policy_test",
+        "absl/container:raw_hash_set_allocator_test",
+        "absl/container:raw_hash_set_test",
+        "absl/container:sample_element_size_test",
+        "absl/crc:crc32c_test",
+        "absl/crc:crc_cord_state_test",
+        "absl/crc:crc_memcpy_test",
+        "absl/crc:non_temporal_memcpy_test",
+        "absl/debugging:demangle_rust_test",
+        "absl/debugging:stacktrace_test",
+        "absl/flags:flag_test",
+        "absl/functional:any_invocable_test",
+        "absl/functional:function_ref_test",
+        "absl/functional:overload_test",
+        "absl/hash:hash_instantiated_test",
+        "absl/hash:hash_test",
+        "absl/hash:low_level_hash_test",
+        "absl/log:absl_check_test",
+        "absl/log:absl_log_basic_test",
+        "absl/log:die_if_null_test",
+        "absl/log:flags_test",
+        "absl/log:globals_test",
+        "absl/log:log_entry_test",
+        "absl/log:log_format_test",
+        "absl/log:log_macro_hygiene_test",
+        "absl/log:log_modifier_methods_test",
+        "absl/log:log_sink_test",
+        "absl/log:log_streamer_test",
+        "absl/log:scoped_mock_log_test",
+        "absl/log:stripping_test",
+        "absl/log:vlog_is_on_test",
+        "absl/log/internal:fnmatch_test",
+        "absl/log/internal:stderr_log_sink_test",
+        "absl/memory:memory_test",
+        "absl/meta:type_traits_test",
+        "absl/numeric:int128_test",
+        "absl/profiling:exponential_biased_test",
+        "absl/profiling:periodic_sampler_test",
+        "absl/status:status_matchers_test",
+        "absl/status:status_test",
+        "absl/status:statusor_test",
+        "absl/strings:ascii_test",
+        "absl/strings:char_formatting_test",
+        "absl/strings:charset_test",
+        "absl/strings:cord_buffer_test",
+        "absl/strings:cord_data_edge_test",
+        "absl/strings:cord_rep_btree_navigator_test",
+        "absl/strings:cord_rep_btree_reader_test",
+        "absl/strings:cord_rep_btree_test",
+        "absl/strings:cord_rep_crc_test",
+        "absl/strings:cordz_functions_test",
+        "absl/strings:cordz_info_statistics_test",
+        "absl/strings:cordz_info_test",
+        "absl/strings:cordz_test",
+        "absl/strings:cordz_update_scope_test",
+        "absl/strings:cordz_update_tracker_test",
+        "absl/strings:damerau_levenshtein_distance_test",
+        "absl/strings:has_absl_stringify_test",
+        "absl/strings:has_ostream_operator_test",
+        "absl/strings:match_test",
+        "absl/strings:str_format_arg_test",
+        "absl/strings:str_format_bind_test",
+        "absl/strings:str_format_checker_test",
+        "absl/strings:str_format_convert_test",
+        "absl/strings:str_format_extension_test",
+        "absl/strings:str_format_output_test",
+        "absl/strings:str_format_parser_test",
+        "absl/strings:str_format_test",
+        "absl/strings:str_replace_test",
+        "absl/strings:string_view_test",
+        "absl/synchronization:kernel_timeout_internal_test",
+        "absl/synchronization:waiter_test",
+        "absl/time:time_test",
+        "absl/types:optional_test",
+        "absl/types:span_test",
+        "absl/types:variant_test",
+        "absl/utility:if_constexpr_test",
+        "//third_party/googletest:gtest_main",
+      ]
+    }
+  }
+
+  test("absl_hardening_tests") {
+    testonly = true
+    sources = [ "absl_hardening_test.cc" ]
+    deps = [
+      ":absl",
+      "//base/test:run_all_unittests",
+      "//third_party/googletest:gtest",
+    ]
+  }
+}
@@ -15,7 +15,6 @@ set(ABSL_INTERNAL_DLL_FILES
  "base/internal/cycleclock.h"
  "base/internal/cycleclock_config.h"
  "base/internal/direct_mmap.h"
-  "base/internal/dynamic_annotations.h"
  "base/internal/endian.h"
  "base/internal/errno_saver.h"
  "base/internal/fast_type_id.h"
@@ -28,8 +27,6 @@ set(ABSL_INTERNAL_DLL_FILES
  "base/internal/low_level_scheduling.h"
  "base/internal/nullability_impl.h"
  "base/internal/per_thread_tls.h"
-  "base/internal/poison.cc"
-  "base/internal/poison.h"
  "base/prefetch.h"
  "base/internal/pretty_function.h"
  "base/internal/raw_logging.cc"
@@ -49,8 +46,6 @@ set(ABSL_INTERNAL_DLL_FILES
  "base/internal/thread_identity.h"
  "base/internal/throw_delegate.cc"
  "base/internal/throw_delegate.h"
-  "base/internal/tracing.cc"
-  "base/internal/tracing.h"
  "base/internal/tsan_mutex_interface.h"
  "base/internal/unaligned_access.h"
  "base/internal/unscaledcycleclock.cc"
@@ -126,9 +121,6 @@ set(ABSL_INTERNAL_DLL_FILES
  "debugging/symbolize.h"
  "debugging/internal/address_is_readable.cc"
  "debugging/internal/address_is_readable.h"
-  "debugging/internal/bounded_utf8_length_sequence.h"
-  "debugging/internal/decode_rust_punycode.cc"
-  "debugging/internal/decode_rust_punycode.h"
  "debugging/internal/demangle.cc"
  "debugging/internal/demangle.h"
  "debugging/internal/demangle_rust.cc"
@@ -141,8 +133,6 @@ set(ABSL_INTERNAL_DLL_FILES
  "debugging/internal/stack_consumption.h"
  "debugging/internal/stacktrace_config.h"
  "debugging/internal/symbolize.h"
-  "debugging/internal/utf8_for_code_point.cc"
-  "debugging/internal/utf8_for_code_point.h"
  "debugging/internal/vdso_support.cc"
  "debugging/internal/vdso_support.h"
  "functional/any_invocable.h"
@@ -193,8 +183,6 @@ set(ABSL_INTERNAL_DLL_FILES
  "log/internal/proto.cc"
  "log/internal/strip.h"
  "log/internal/structured.h"
-  "log/internal/structured_proto.cc"
-  "log/internal/structured_proto.h"
  "log/internal/vlog_config.cc"
  "log/internal/vlog_config.h"
  "log/internal/voidify.h"
@@ -325,6 +313,7 @@ set(ABSL_INTERNAL_DLL_FILES
  "strings/internal/string_constant.h"
  "strings/internal/stringify_sink.h"
  "strings/internal/stringify_sink.cc"
+  "strings/internal/has_absl_stringify.h"
  "strings/has_absl_stringify.h"
  "strings/has_ostream_operator.h"
  "strings/match.cc"
@@ -450,47 +439,9 @@ set(ABSL_INTERNAL_DLL_FILES
  "debugging/leak_check.cc"
 )

-if(NOT MSVC)
-  list(APPEND ABSL_INTERNAL_DLL_FILES
-    "flags/commandlineflag.cc"
-    "flags/commandlineflag.h"
-    "flags/config.h"
-    "flags/declare.h"
-    "flags/flag.h"
-    "flags/internal/commandlineflag.cc"
-    "flags/internal/commandlineflag.h"
-    "flags/internal/flag.cc"
-    "flags/internal/flag.h"
-    "flags/internal/parse.h"
-    "flags/internal/path_util.h"
-    "flags/internal/private_handle_accessor.cc"
-    "flags/internal/private_handle_accessor.h"
-    "flags/internal/program_name.cc"
-    "flags/internal/program_name.h"
-    "flags/internal/registry.h"
-    "flags/internal/sequence_lock.h"
-    "flags/internal/usage.cc"
-    "flags/internal/usage.h"
-    "flags/marshalling.cc"
-    "flags/marshalling.h"
-    "flags/parse.cc"
-    "flags/parse.h"
-    "flags/reflection.cc"
-    "flags/reflection.h"
-    "flags/usage.cc"
-    "flags/usage.h"
-    "flags/usage_config.cc"
-    "flags/usage_config.h"
-    "log/flags.cc"
-    "log/flags.h"
-    "log/internal/flags.h"
-  )
-endif()
-
 set(ABSL_INTERNAL_DLL_TARGETS
  "absl_check"
  "absl_log"
-  "absl_vlog_is_on"
  "algorithm"
  "algorithm_container"
  "any"
@@ -556,7 +507,6 @@ set(ABSL_INTERNAL_DLL_TARGETS
  "log_internal_check_op"
  "log_internal_conditions"
  "log_internal_config"
-  "log_internal_fnmatch"
  "log_internal_format"
  "log_internal_globals"
  "log_internal_log_impl"
@@ -636,7 +586,6 @@ set(ABSL_INTERNAL_DLL_TARGETS
  "strerror"
  "strings"
  "strings_internal"
-  "string_view"
  "symbolize"
  "synchronization"
  "thread_pool"
@@ -647,30 +596,8 @@ set(ABSL_INTERNAL_DLL_TARGETS
  "type_traits"
  "utility"
  "variant"
-  "vlog_config_internal"
-  "vlog_is_on"
 )

-if(NOT MSVC)
-  list(APPEND ABSL_INTERNAL_DLL_TARGETS
-    "flags"
-    "flags_commandlineflag"
-    "flags_commandlineflag_internal"
-    "flags_config"
-    "flags_internal"
-    "flags_marshalling"
-    "flags_parse"
-    "flags_path_util"
-    "flags_private_handle_accessor"
-    "flags_program_name"
-    "flags_reflection"
-    "flags_usage"
-    "flags_usage_internal"
-    "log_internal_flags"
-    "log_flags"
-  )
-endif()
-
 set(ABSL_INTERNAL_TEST_DLL_FILES
  "hash/hash_testing.h"
  "log/scoped_mock_log.cc"
@@ -747,7 +674,12 @@ function(absl_internal_dll_contains)

  STRING(REGEX REPLACE "^absl::" "" _target ${ABSL_INTERNAL_DLL_TARGET})

-  if (_target IN_LIST ABSL_INTERNAL_DLL_TARGETS)
+  list(FIND
+    ABSL_INTERNAL_DLL_TARGETS
+    "${_target}"
+    _index)
+
+  if (${_index} GREATER -1)
    set(${ABSL_INTERNAL_DLL_OUTPUT} 1 PARENT_SCOPE)
  else()
    set(${ABSL_INTERNAL_DLL_OUTPUT} 0 PARENT_SCOPE)
@@ -764,7 +696,12 @@ function(absl_internal_test_dll_contains)

  STRING(REGEX REPLACE "^absl::" "" _target ${ABSL_INTERNAL_TEST_DLL_TARGET})

-  if (_target IN_LIST ABSL_INTERNAL_TEST_DLL_TARGETS)
+  list(FIND
+    ABSL_INTERNAL_TEST_DLL_TARGETS
+    "${_target}"
+    _index)
+
+  if (${_index} GREATER -1)
    set(${ABSL_INTERNAL_TEST_DLL_OUTPUT} 1 PARENT_SCOPE)
  else()
    set(${ABSL_INTERNAL_TEST_DLL_OUTPUT} 0 PARENT_SCOPE)
@@ -816,12 +753,7 @@ function(absl_make_dll)
  else()
    set(_dll "abseil_dll")
    set(_dll_files ${ABSL_INTERNAL_DLL_FILES})
-    set(_dll_libs
-      Threads::Threads
-      # TODO(#1495): Use $<LINK_LIBRARY:FRAMEWORK,CoreFoundation> once our
-      # minimum CMake version >= 3.24
-      $<$<PLATFORM_ID:Darwin>:-Wl,-framework,CoreFoundation>
-    )
+    set(_dll_libs "")
    set(_dll_compile_definitions "")
    set(_dll_includes "")
    set(_dll_consume "ABSL_CONSUME_DLL")
@@ -838,12 +770,8 @@ function(absl_make_dll)
    PRIVATE
      ${_dll_libs}
      ${ABSL_DEFAULT_LINKOPTS}
-      $<$<BOOL:${ANDROID}>:-llog>
-  )
-  set_target_properties(${_dll} PROPERTIES
-    LINKER_LANGUAGE "CXX"
-    SOVERSION ${ABSL_SOVERSION}
  )
+  set_property(TARGET ${_dll} PROPERTY LINKER_LANGUAGE "CXX")
  target_include_directories(
    ${_dll}
    PUBLIC
@@ -186,16 +186,16 @@ function(absl_cc_library)
        endif()
      endif()
    endforeach()
+    set(skip_next_cflag OFF)
    foreach(cflag ${ABSL_CC_LIB_COPTS})
-      # Strip out the CMake-specific `SHELL:` prefix, which is used to construct
-      # a group of space-separated options.
-      # https://cmake.org/cmake/help/v3.30/command/target_compile_options.html#option-de-duplication
-      string(REGEX REPLACE "^SHELL:" "" cflag "${cflag}")
-      if(${cflag} MATCHES "^-Xarch_")
+      if(skip_next_cflag)
+        set(skip_next_cflag OFF)
+      elseif(${cflag} MATCHES "^-Xarch_")
        # An -Xarch_ flag implies that its successor only applies to the
-        # specified platform. Such option groups are each specified in a single
-        # `SHELL:`-prefixed string in the COPTS list, which we simply ignore.
-      elseif(${cflag} MATCHES "^(-Wno-|/wd)")
+        # specified platform. Filter both of them out before the successor
+        # reaches the "^-m" filter.
+        set(skip_next_cflag ON)
+      elseif(${cflag} MATCHES "^(-Wno|/wd)")
        # These flags are needed to suppress warnings that might fire in our headers.
        set(PC_CFLAGS "${PC_CFLAGS} ${cflag}")
      elseif(${cflag} MATCHES "^(-W|/w[1234eo])")
@@ -258,13 +258,6 @@ Cflags: -I\${includedir}${PC_CFLAGS}\n")
    elseif(_build_type STREQUAL "static" OR _build_type STREQUAL "shared")
      add_library(${_NAME} "")
      target_sources(${_NAME} PRIVATE ${ABSL_CC_LIB_SRCS} ${ABSL_CC_LIB_HDRS})
-      if(APPLE)
-        set_target_properties(${_NAME} PROPERTIES
-          INSTALL_RPATH "@loader_path")
-      elseif(UNIX)
-        set_target_properties(${_NAME} PROPERTIES
-          INSTALL_RPATH "$ORIGIN")
-      endif()
      target_link_libraries(${_NAME}
      PUBLIC ${ABSL_CC_LIB_DEPS}
      PRIVATE
@@ -313,7 +306,7 @@ Cflags: -I\${includedir}${PC_CFLAGS}\n")
    if(ABSL_ENABLE_INSTALL)
      set_target_properties(${_NAME} PROPERTIES
        OUTPUT_NAME "absl_${_NAME}"
-        SOVERSION "${ABSL_SOVERSION}"
+        SOVERSION 0
      )
    endif()
  else()
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.10)

 project(googletest-external NONE)

@@ -39,7 +39,7 @@ section of your executable or of your library.<br>
 Here is a short CMakeLists.txt example of an application project using Abseil.

 ```cmake
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.10)
 project(my_app_project)

 # Pick the C++ standard to compile with.
@@ -62,7 +62,7 @@ will control Abseil library targets) is set to at least that minimum. For
 example:

 ```cmake
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.10)
 project(my_lib_project)

 # Leave C++ standard up to the root application, so set it only if this is the
@@ -15,7 +15,7 @@

 # A simple CMakeLists.txt for testing cmake installation

-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.10)
 project(absl_cmake_testing CXX)

 add_executable(simple simple.cc)
@@ -22,8 +22,7 @@ set -euox pipefail
 absl_dir=/abseil-cpp
 absl_build_dir=/buildfs
 googletest_builddir=/googletest_builddir
-googletest_archive="googletest-${ABSL_GOOGLETEST_VERSION}.tar.gz"
-project_dir="${absl_dir}/CMake/install_test_project"
+project_dir="${absl_dir}"/CMake/install_test_project
 project_build_dir=/buildfs/project-build

 build_shared_libs="OFF"
@@ -34,9 +33,9 @@ fi
 # Build and install GoogleTest
 mkdir "${googletest_builddir}"
 pushd "${googletest_builddir}"
-curl -L "${ABSL_GOOGLETEST_DOWNLOAD_URL}" --output "${googletest_archive}"
-tar -xz -f "${googletest_archive}"
-pushd "googletest-${ABSL_GOOGLETEST_VERSION}"
+curl -L "${ABSL_GOOGLETEST_DOWNLOAD_URL}" --output "${ABSL_GOOGLETEST_COMMIT}".zip
+unzip "${ABSL_GOOGLETEST_COMMIT}".zip
+pushd "googletest-${ABSL_GOOGLETEST_COMMIT}"
 mkdir build
 pushd build
 cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS="${build_shared_libs}" ..
@@ -15,16 +15,50 @@
 #

 # https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md
-# As of 2024-07-01, CMake 3.16 is the minimum supported version.
-cmake_minimum_required(VERSION 3.16)
+# As of 2022-09-06, CMake 3.10 is the minimum supported version.
+cmake_minimum_required(VERSION 3.10)
+
+# Compiler id for Apple Clang is now AppleClang.
+if (POLICY CMP0025)
+  cmake_policy(SET CMP0025 NEW)
+endif (POLICY CMP0025)
+
+# if command can use IN_LIST
+if (POLICY CMP0057)
+  cmake_policy(SET CMP0057 NEW)
+endif (POLICY CMP0057)
+
+# Project version variables are the empty string if version is unspecified
+if (POLICY CMP0048)
+  cmake_policy(SET CMP0048 NEW)
+endif (POLICY CMP0048)
+
+# Honor the GTest_ROOT variable if specified
+if (POLICY CMP0074)
+  cmake_policy(SET CMP0074 NEW)
+endif (POLICY CMP0074)
+
+# option() honor variables
+if (POLICY CMP0077)
+  cmake_policy(SET CMP0077 NEW)
+endif (POLICY CMP0077)
+
+# Allow the user to specify the MSVC runtime
+if (POLICY CMP0091)
+  cmake_policy(SET CMP0091 NEW)
+endif (POLICY CMP0091)
+
+# try_compile() honors the CMAKE_CXX_STANDARD value
+if (POLICY CMP0067)
+  cmake_policy(SET CMP0067 NEW)
+endif (POLICY CMP0067)

 # Allow the user to specify the CMAKE_MSVC_DEBUG_INFORMATION_FORMAT
 if (POLICY CMP0141)
  cmake_policy(SET CMP0141 NEW)
 endif (POLICY CMP0141)

-project(absl LANGUAGES CXX VERSION 20250127)
-set(ABSL_SOVERSION "2501.0.0")
+project(absl LANGUAGES CXX)
 include(CTest)

 # Output directory is correct by default for most build setups. However, when
@@ -41,13 +75,12 @@ else()
  option(ABSL_ENABLE_INSTALL "Enable install rule" ON)
 endif()

-set(CMAKE_INSTALL_RPATH "$ORIGIN")
-set(CMAKE_INSTALL_RPATH_USE_LINK_PATH ON)
-set(CMAKE_BUILD_RPATH_USE_ORIGIN ON)
-
 option(ABSL_PROPAGATE_CXX_STD
  "Use CMake C++ standard meta features (e.g. cxx_std_14) that propagate to targets that link to Abseil"
-  ON)
+  OFF)  # TODO: Default to ON for CMake 3.8 and greater.
+if(NOT ABSL_PROPAGATE_CXX_STD)
+  message(WARNING "A future Abseil release will default ABSL_PROPAGATE_CXX_STD to ON for CMake 3.8 and up. We recommend enabling this option to ensure your project still builds correctly.")
+endif()

 option(ABSL_USE_SYSTEM_INCLUDES
  "Silence warnings in Abseil headers by marking them as SYSTEM includes"
@@ -58,15 +91,6 @@ list(APPEND CMAKE_MODULE_PATH
  ${CMAKE_CURRENT_LIST_DIR}/absl/copts
 )

-option(ABSL_MSVC_STATIC_RUNTIME
-  "Link static runtime libraries"
-  OFF)
-if(ABSL_MSVC_STATIC_RUNTIME)
-  set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-else()
-  set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
-endif()
-
 include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
 include(AbseilDll)
@@ -125,14 +149,6 @@ set(ABSL_LOCAL_GOOGLETEST_DIR "/usr/src/googletest" CACHE PATH
  "If ABSL_USE_GOOGLETEST_HEAD is OFF and ABSL_GOOGLETEST_URL is not set, specifies the directory of a local GoogleTest checkout."
  )

-option(ABSL_BUILD_MONOLITHIC_SHARED_LIBS
-  "Build Abseil as a single shared library (always enabled for Windows)"
-  OFF
-)
-if(NOT BUILD_SHARED_LIBS AND ABSL_BUILD_MONOLITHIC_SHARED_LIBS)
-  message(WARNING "Not building a shared library because BUILD_SHARED_LIBS is not set. Ignoring ABSL_BUILD_MONOLITHIC_SHARED_LIBS.")
-endif()
-
 if((BUILD_TESTING AND ABSL_BUILD_TESTING) OR ABSL_BUILD_TEST_HELPERS)
  if (ABSL_USE_EXTERNAL_GOOGLETEST)
    if (ABSL_FIND_GOOGLETEST)
@@ -170,7 +186,17 @@ endif()
 add_subdirectory(absl)

 if(ABSL_ENABLE_INSTALL)
-  
+  # absl:lts-remove-begin(system installation is supported for LTS releases)
+  # We don't support system-wide installation
+  list(APPEND SYSTEM_INSTALL_DIRS "/usr/local" "/usr" "/opt/" "/opt/local" "c:/Program Files/${PROJECT_NAME}")
+  if(NOT DEFINED CMAKE_INSTALL_PREFIX OR CMAKE_INSTALL_PREFIX IN_LIST SYSTEM_INSTALL_DIRS)
+    message(WARNING "\
+  The default and system-level install directories are unsupported except in LTS \
+  releases of Abseil.  Please set CMAKE_INSTALL_PREFIX to install Abseil in your \
+  source or build tree directly.\
+    ")
+  endif()
+  # absl:lts-remove-end

  # install as a subdirectory only
  install(EXPORT ${PROJECT_NAME}Targets
@@ -201,13 +227,11 @@ if(ABSL_ENABLE_INSTALL)
    )
  endif()  # absl_VERSION

-  # Install the headers except for "options.h" which is installed separately.
  install(DIRECTORY absl
    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
    FILES_MATCHING
      PATTERN "*.inc"
      PATTERN "*.h"
-      PATTERN "options.h" EXCLUDE
      PATTERN "copts" EXCLUDE
      PATTERN "testdata" EXCLUDE
    )
@@ -247,21 +271,7 @@ if(ABSL_ENABLE_INSTALL)
    ABSL_INTERNAL_OPTIONS_H_PINNED
    "${ABSL_INTERNAL_OPTIONS_H_CONTENTS}")

-  # If the file already exists, check if it matches the new contents.
-  # This avoids writing the file if it is already up-to-date when the CMake
-  # generation is triggered and triggering unnecessary rebuilds.
-  set(ABSL_INTERNAL_OPTIONS_H_PINNED_NEEDS_UPDATE TRUE)
-  if (EXISTS "${CMAKE_BINARY_DIR}/options-pinned.h")
-    file(READ "${CMAKE_BINARY_DIR}/options-pinned.h" ABSL_INTERNAL_OPTIONS_PINNED_H_CONTENTS)
-    if ("${ABSL_INTERNAL_OPTIONS_H_PINNED}" STREQUAL "${ABSL_INTERNAL_OPTIONS_PINNED_H_CONTENTS}")
-      set(ABSL_INTERNAL_OPTIONS_H_PINNED_NEEDS_UPDATE FALSE)
-    endif()
-  endif()
-
-  # If the file needs an update, generate it.
-  if (ABSL_INTERNAL_OPTIONS_H_PINNED_NEEDS_UPDATE)
-    file(GENERATE OUTPUT "${CMAKE_BINARY_DIR}/options-pinned.h" CONTENT "${ABSL_INTERNAL_OPTIONS_H_PINNED}")
-  endif()
+  file(WRITE "${CMAKE_BINARY_DIR}/options-pinned.h" "${ABSL_INTERNAL_OPTIONS_H_PINNED}")

  install(FILES "${CMAKE_BINARY_DIR}/options-pinned.h"
         DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/absl/base
@@ -0,0 +1,6 @@
+monorail: {
+  component: "Internals>Core"
+}
+buganizer_public: {
+  component_id: 1456128
+}
@@ -16,31 +16,27 @@

 module(
    name = "abseil-cpp",
-    version = "20250127.1",
+    version = "head",
    compatibility_level = 1,
 )

-cc_configure = use_extension("@rules_cc//cc:extensions.bzl",
-                             "cc_configure_extension",
-                             dev_dependency = True)
+cc_configure = use_extension("@bazel_tools//tools/cpp:cc_configure.bzl", "cc_configure_extension")
 use_repo(cc_configure, "local_config_cc")

 # Only direct dependencies need to be listed below.
 # Please keep the versions in sync with the versions in the WORKSPACE file.

-bazel_dep(name = "rules_cc", version = "0.0.17")
-bazel_dep(name = "bazel_skylib", version = "1.7.1")
-bazel_dep(name = "platforms", version = "0.0.10")
+bazel_dep(name = "bazel_skylib",
+          version = "1.5.0")

-bazel_dep(
-    name = "google_benchmark",
-    version = "1.8.5",
-    dev_dependency = True,
-)
+bazel_dep(name = "google_benchmark",
+          version = "1.8.3",
+          repo_name = "com_github_google_benchmark",
+          dev_dependency = True)

-# Note: Googletest is NOT a dev_dependency. Some Abseil test utilities
-# intended to be used by Abseil users depend on GoogleTest.
-bazel_dep(
-    name = "googletest",
-    version = "1.15.2",
-)
+bazel_dep(name = "googletest",
+          version = "1.14.0.bcr.1",
+          repo_name = "com_google_googletest")
+
+bazel_dep(name = "platforms",
+          version = "0.0.8")
@@ -0,0 +1,5 @@
+danilchap@chromium.org
+mbonadei@chromium.org
+
+# For .def files updates:
+hans@chromium.org
@@ -0,0 +1,43 @@
+Name: Abseil
+Short Name: absl
+URL: https://github.com/abseil/abseil-cpp
+License: Apache 2.0
+License File: LICENSE
+Version: N/A
+Revision: eba8db7baf6c326870f28e58977075b7b2fb243d
+Security Critical: yes
+Shipped: yes
+
+Description:
+This directory contains the source code of Abseil for C++. This can be used by
+Chromium, subject to the guidance at
+https://chromium.googlesource.com/chromium/src/+/main/styleguide/c++/c++-features.md;
+it can be used without restriction by Chromium's dependencies, except that
+objects compiled into Chromium itself cannot use anything relying on
+absl::base_internal::FastTypeId (see https://crbug.com/1096380).
+
+How to update Abseil:
+
+1. From your source root run third_party/abseil-cpp/roll_abseil.py to download the code from the Abseil git repository and apply chromium specific patches.
+
+2. Update BUILD.gn files to match changes in BUILD.bazel
+
+If there is a new test, add dependcy on it from absl_tests in the
+third_party/abseil-cpp/BUILD.gn target
+
+3. From your source root run third_party/abseil-cpp/generate_def_files.py to
+   regenerate Windows symbol definition files.
+
+4. If abseil adds new features, update styleguide/c++/c++-features.md and add headers for that feature into exclude list in root DEPS
+
+Local Modifications:
+
+* absl/copts.bzl has been translated to //third_party/absl-cpp/BUILD.gn. Both
+  files contain lists of compiler flags in order to reduce duplication.
+
+* All the BUILD.bazel files have been translated to BUILD.gn files.
+
+* Patches from //third_party/abseil-cpp/patches have been applied.
+
+* Increment this number to silence presubmits about modifying files in
+  third_party when regenerating absl .def files: 2
@@ -14,63 +14,46 @@
 # limitations under the License.
 #

-workspace(name = "abseil-cpp")
+workspace(name = "com_google_absl")

 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

 # GoogleTest/GoogleMock framework. Used by most unit-tests.
 http_archive(
-    name = "googletest",
-    sha256 = "7b42b4d6ed48810c5362c265a17faebe90dc2373c885e5216439d37927f02926",
-    strip_prefix = "googletest-1.15.2",
-    # Keep this URL in sync with the version in ci/cmake_common.sh and
-    # ci/windows_msvc_cmake.bat.
-    urls = ["https://github.com/google/googletest/releases/download/v1.15.2/googletest-1.15.2.tar.gz"],
-    # Now that Abseil is using the canonical names from the Bazel Central Registry, map
-    # GoogleTest's old names to the new canonical names.
-    repo_mapping = {
-        "@com_google_absl": "@",
-        "@com_googlesource_code_re2": "@re2",
-    },
+  name = "com_google_googletest",
+  sha256 = "8ad598c73ad796e0d8280b082cebd82a630d73e73cd3c70057938a6501bba5d7",
+  strip_prefix = "googletest-1.14.0",
+  # Keep this URL in sync with ABSL_GOOGLETEST_COMMIT in ci/cmake_common.sh and
+  # ci/windows_msvc_cmake.bat.
+  urls = ["https://github.com/google/googletest/archive/refs/tags/v1.14.0.tar.gz"],
 )

 # RE2 (the regular expression library used by GoogleTest)
 http_archive(
-    name = "re2",
-    sha256 = "eb2df807c781601c14a260a507a5bb4509be1ee626024cb45acbd57cb9d4032b",
-    strip_prefix = "re2-2024-07-02",
-    urls = ["https://github.com/google/re2/releases/download/2024-07-02/re2-2024-07-02.tar.gz"],
+    name = "com_googlesource_code_re2",
+    sha256 = "828341ad08524618a626167bd320b0c2acc97bd1c28eff693a9ea33a7ed2a85f",
+    strip_prefix = "re2-2023-11-01",
+    urls = ["https://github.com/google/re2/releases/download/2023-11-01/re2-2023-11-01.zip"],
 )

 # Google benchmark.
 http_archive(
-    name = "google_benchmark",
-    sha256 = "d26789a2b46d8808a48a4556ee58ccc7c497fcd4c0af9b90197674a81e04798a",
-    strip_prefix = "benchmark-1.8.5",
-    urls = ["https://github.com/google/benchmark/archive/refs/tags/v1.8.5.tar.gz"],
+    name = "com_github_google_benchmark",
+    sha256 = "6bc180a57d23d4d9515519f92b0c83d61b05b5bab188961f36ac7b06b0d9e9ce",
+    strip_prefix = "benchmark-1.8.3",
+    urls = ["https://github.com/google/benchmark/archive/refs/tags/v1.8.3.tar.gz"],
 )

 # Bazel Skylib.
 http_archive(
-    name = "bazel_skylib",
-    sha256 = "bc283cdfcd526a52c3201279cda4bc298652efa898b10b4db0837dc51652756f",
-    urls = ["https://github.com/bazelbuild/bazel-skylib/releases/download/1.7.1/bazel-skylib-1.7.1.tar.gz"],
-)
-
-# C++ rules for Bazel
-http_archive(
-    name = "rules_cc",
-    urls = ["https://github.com/bazelbuild/rules_cc/releases/download/0.1.0/rules_cc-0.1.0.tar.gz"],
-    sha256 = "4b12149a041ddfb8306a8fd0e904e39d673552ce82e4296e96fac9cbf0780e59",
-    strip_prefix = "rules_cc-0.1.0",
+  name = "bazel_skylib",
+  sha256 = "cd55a062e763b9349921f0f5db8c3933288dc8ba4f76dd9416aac68acee3cb94",
+  urls = ["https://github.com/bazelbuild/bazel-skylib/releases/download/1.5.0/bazel-skylib-1.5.0.tar.gz"],
 )

 # Bazel platform rules.
 http_archive(
    name = "platforms",
-    urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/platforms/releases/download/0.0.10/platforms-0.0.10.tar.gz",
-        "https://github.com/bazelbuild/platforms/releases/download/0.0.10/platforms-0.0.10.tar.gz",
-    ],
-    sha256 = "218efe8ee736d26a3572663b374a253c012b716d8af0c07e842e82f238a0a7ee",
+    sha256 = "8150406605389ececb6da07cbcb509d5637a3ab9a24bc69b1101531367d89d74",
+    urls = ["https://github.com/bazelbuild/platforms/releases/download/0.0.8/platforms-0.0.8.tar.gz"],
 )
@@ -0,0 +1,128 @@
+# Copyright 2020 The Chromium Authors
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# This file contains the definition of the template absl_source_set which
+# should be the only type of target needed in abseil's BUILD.gn files.
+# This template will correctly set "configs" and "public_configs" in order
+# to correctly compile abseil in Chromium.
+#
+# Usage:
+# Most of the times its usage will be similar to the example below but all
+# the arguments avilable in source_set are also available for absl_source_set.
+#
+#  absl_source_set("foo") {
+#    sources = [ "foo.cc" ]
+#    public = [ "foo.h" ]
+#    deps = [ ":bar" ]
+#  }
+
+import("//build_overrides/build.gni")
+
+declare_args() {
+  absl_build_tests = build_with_chromium
+}
+
+template("absl_source_set") {
+  source_set(target_name) {
+    if (defined(invoker.testonly) && invoker.testonly && !absl_build_tests) {
+      not_needed(invoker, "*")
+    } else {
+      forward_variables_from(invoker, "*")
+      configs -= [ "//build/config/compiler:chromium_code" ]
+      configs += [
+        "//build/config/compiler:no_chromium_code",
+        "//build/config/compiler:prevent_unsafe_narrowing",
+        "//third_party/abseil-cpp:absl_default_cflags_cc",
+        "//third_party/abseil-cpp:absl_define_config",
+      ]
+
+      if (is_component_build) {
+        defines = [ "ABSL_BUILD_DLL" ]
+        if (!is_win && current_os != "aix") {
+          configs -= [ "//build/config/gcc:symbol_visibility_hidden" ]
+          configs += [ "//build/config/gcc:symbol_visibility_default" ]
+        }
+      }
+
+      if (!defined(public_configs)) {
+        public_configs = []
+      }
+      public_configs += [
+        "//third_party/abseil-cpp:absl_include_config",
+        "//third_party/abseil-cpp:absl_public_cflags_cc",
+      ]
+
+      if (!defined(visibility)) {
+        # Within Chromium builds, restrict direct visibility of Abseil sources, so
+        # users must depend on //third_party/abseil-cpp:absl. This prevents use of
+        # banned targets like absl/types:any. A few targets require exceptions.
+        # TODO(crbug.com/1096380): Consider replacing build_with_chromium with
+        # is_component_build for a narrower, more accurate condition.
+        if (build_with_chromium) {
+          visibility = [
+            # Abseil itself.
+            "//third_party/abseil-cpp/*",
+
+            # GTest.  It unconditionally #includes any.h if pretty-print support
+            # for absl types is enabled.
+            "//third_party/googletest/*",
+
+            # WebRTC binary to run PSNR and SSIM video quality analysis. It
+            # statically links absl and it is used by "browser_tests" when
+            # is_component_build=false but it cannot depend on the absl
+            # component because it uses absl/flags.
+            "//third_party/webrtc/rtc_tools:frame_analyzer",
+
+            # WebRTC binaries used by //:chromium_builder_asan. They both
+            # statically link absl (because they depend on absl/flags) and are
+            # used by Chromium only when is_component_build=false.
+            "//third_party/webrtc/rtc_tools:rtp_generator",
+            "//third_party/webrtc/rtc_tools:video_replay",
+
+            # Not used by Chromium directly.
+            "//chromecast/internal/*",
+            "//libassistant/*",
+
+            # Not built into Chrome.
+            "//components/optimization_guide/internal/*",
+          ]
+        } else {
+          visibility = [ "*" ]
+        }
+      }
+    }
+  }
+}
+
+template("absl_test") {
+  source_set(target_name) {
+    if (!absl_build_tests) {
+      not_needed(invoker, "*")
+    } else {
+      forward_variables_from(invoker, "*")
+      testonly = true
+      configs -= [ "//build/config/compiler:chromium_code" ]
+      configs += [
+        "//build/config/compiler:no_chromium_code",
+        "//third_party/abseil-cpp:absl_default_cflags_cc",
+        "//third_party/abseil-cpp:absl_define_config",
+        "//third_party/abseil-cpp:absl_test_config",
+      ]
+
+      if (!defined(public_configs)) {
+        public_configs = []
+      }
+      public_configs += [
+        "//third_party/abseil-cpp:absl_include_config",
+        "//third_party/abseil-cpp:absl_public_cflags_cc",
+      ]
+
+      visibility = [ "//third_party/abseil-cpp/:*" ]
+      deps += [
+        "//third_party/googletest:gmock",
+        "//third_party/googletest:gtest",
+      ]
+    }
+  }
+}
@@ -28,6 +28,14 @@ config_setting(
    visibility = [":__subpackages__"],
 )

+config_setting(
+    name = "gcc_compiler",
+    flag_values = {
+        "@bazel_tools//tools/cpp:compiler": "gcc",
+    },
+    visibility = [":__subpackages__"],
+)
+
 config_setting(
    name = "mingw_unspecified_compiler",
    flag_values = {
@@ -45,10 +53,91 @@ config_setting(
 )

 config_setting(
-    name = "fuchsia",
+    name = "msvc_compiler",
+    flag_values = {
+        "@bazel_tools//tools/cpp:compiler": "msvc-cl",
+    },
+    visibility = [":__subpackages__"],
+)
+
+config_setting(
+    name = "clang-cl_compiler",
+    flag_values = {
+        "@bazel_tools//tools/cpp:compiler": "clang-cl",
+    },
+    visibility = [":__subpackages__"],
+)
+
+config_setting(
+    name = "osx",
    constraint_values = [
-        "@platforms//os:fuchsia",
+        "@platforms//os:osx",
    ],
+)
+
+config_setting(
+    name = "ios",
+    constraint_values = [
+        "@platforms//os:ios",
+    ],
+)
+
+config_setting(
+    name = "ppc",
+    values = {
+        "cpu": "ppc",
+    },
+    visibility = [":__subpackages__"],
+)
+
+config_setting(
+    name = "cpu_wasm",
+    values = {
+        "cpu": "wasm",
+    },
+    visibility = [":__subpackages__"],
+)
+
+config_setting(
+    name = "cpu_wasm32",
+    values = {
+        "cpu": "wasm32",
+    },
+    visibility = [":__subpackages__"],
+)
+
+config_setting(
+    name = "platforms_wasm32",
+    constraint_values = [
+        "@platforms//cpu:wasm32",
+    ],
+    visibility = [":__subpackages__"],
+)
+
+config_setting(
+    name = "platforms_wasm64",
+    constraint_values = [
+        "@platforms//cpu:wasm64",
+    ],
+    visibility = [":__subpackages__"],
+)
+
+selects.config_setting_group(
+    name = "wasm",
+    match_any = [
+        ":cpu_wasm",
+        ":cpu_wasm32",
+        ":platforms_wasm32",
+        ":platforms_wasm64",
+    ],
+    visibility = [":__subpackages__"],
+)
+
+config_setting(
+    name = "fuchsia",
+    values = {
+        "cpu": "fuchsia",
+    },
    visibility = [":__subpackages__"],
 )

@@ -36,9 +36,9 @@ add_subdirectory(time)
 add_subdirectory(types)
 add_subdirectory(utility)

-if (ABSL_BUILD_DLL)
+if (${ABSL_BUILD_DLL})
  absl_make_dll()
-  if ((BUILD_TESTING AND ABSL_BUILD_TESTING) OR ABSL_BUILD_TEST_HELPERS)
+  if (${ABSL_BUILD_TEST_HELPERS})
    absl_make_dll(TEST ON)
  endif()
 endif()
@@ -51,8 +51,8 @@ cc_test(
    deps = [
        ":algorithm",
        "//absl/base:config",
-        "@googletest//:gtest",
-        "@googletest//:gtest_main",
+        "@com_google_googletest//:gtest",
+        "@com_google_googletest//:gtest_main",
    ],
 )

@@ -65,7 +65,6 @@ cc_library(
    linkopts = ABSL_DEFAULT_LINKOPTS,
    deps = [
        ":algorithm",
-        "//absl/base:config",
        "//absl/base:core_headers",
        "//absl/base:nullability",
        "//absl/meta:type_traits",
@@ -80,11 +79,10 @@ cc_test(
    deps = [
        ":container",
        "//absl/base",
-        "//absl/base:config",
        "//absl/base:core_headers",
        "//absl/memory",
        "//absl/types:span",
-        "@googletest//:gtest",
-        "@googletest//:gtest_main",
+        "@com_google_googletest//:gtest",
+        "@com_google_googletest//:gtest_main",
    ],
 )
@@ -0,0 +1,39 @@
+# Copyright 2018 The Chromium Authors
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//third_party/abseil-cpp/absl.gni")
+
+absl_source_set("algorithm") {
+  public = [ "algorithm.h" ]
+  deps = [ "//third_party/abseil-cpp/absl/base:config" ]
+}
+
+absl_source_set("container") {
+  public = [ "container.h" ]
+  deps = [
+    ":algorithm",
+    "//third_party/abseil-cpp/absl/base:nullability",
+    "//third_party/abseil-cpp/absl/base:core_headers",
+    "//third_party/abseil-cpp/absl/meta:type_traits",
+  ]
+}
+
+absl_test("algorithm_test") {
+  sources = [ "algorithm_test.cc" ]
+  deps = [
+    ":algorithm",
+    "//third_party/abseil-cpp/absl/base:config",
+  ]
+}
+
+absl_test("container_test") {
+  sources = [ "container_test.cc" ]
+  deps = [
+    ":container",
+    "//third_party/abseil-cpp/absl/base",
+    "//third_party/abseil-cpp/absl/base:core_headers",
+    "//third_party/abseil-cpp/absl/memory",
+    "//third_party/abseil-cpp/absl/types:span",
+  ]
+}
@@ -48,7 +48,6 @@ absl_cc_library(
    ${ABSL_DEFAULT_COPTS}
  DEPS
    absl::algorithm
-    absl::config
    absl::core_headers
    absl::meta
    absl::nullability
@@ -65,7 +64,6 @@ absl_cc_test(
  DEPS
    absl::algorithm_container
    absl::base
-    absl::config
    absl::core_headers
    absl::memory
    absl::span
@@ -53,8 +53,8 @@ using std::rotate;
 // n = (`last` - `first`) comparisons. A linear search over short containers
 // may be faster than a binary search, even when the container is sorted.
 template <typename InputIterator, typename EqualityComparable>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool linear_search(
-    InputIterator first, InputIterator last, const EqualityComparable& value) {
+bool linear_search(InputIterator first, InputIterator last,
+                   const EqualityComparable& value) {
  return std::find(first, last, value) != last;
 }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
bridgewaterrobbie	25c76d1396	Stash old version of rebind logic to still be able to play with it.	2025-03-31 17:12:39 -04:00
bridgewaterrobbie	f0ea0fa345	Avoid running the inline pass without merge return on WebGPU	2025-03-31 16:57:43 -04:00
bridgewaterrobbie	60280d91da	Split and rebind combined image samplers for WebGPU API target	2025-03-31 16:50:22 -04:00
bridgewaterrobbie	b0256e5375	Allow non uniform derivitives	2025-03-31 16:41:49 -04:00
bridgewaterrobbie	4d17c917a0	Hack a workaround for OpConstantLoad issue in Tint to work with most spec constants	2025-03-31 16:41:49 -04:00
bridgewaterrobbie	ba7a9924b9	Workaround Tint issues with texelFetchOffset in dofMedian.mat	2025-03-31 16:41:49 -04:00
bridgewaterrobbie	ad9a23ca60	Update SPIR-V tools to commit ada1771a9f7a125573aa94fe551fdc44b45769bd to pull in splitter pass	2025-03-31 16:41:07 -04:00