Update Gitignore to ignore generated files.

renderdiff: fix breakage (#8648 )
- Re-enable renderdiff test. - Cache the mesa directory so that we're not spending time pulling and compiling it. - Move python prereqs into the script and use venv.
2025-04-22 14:23:31 -04:00 · 2025-04-22 18:23:05 +00:00 · 2025-04-22 12:56:03 -05:00 · 2025-04-22 17:31:40 +00:00 · 2025-04-22 09:31:29 -07:00 · 2025-04-22 09:31:29 -07:00
9474 changed files with 597426 additions and 2043924 deletions
@@ -19,6 +19,8 @@ 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:]`
@@ -44,6 +46,8 @@ jobs:

    steps:
      - uses: actions/checkout@v4.1.6
+        with:
+          fetch-depth: 0
      - uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
@@ -60,6 +64,8 @@ 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
@@ -102,9 +108,21 @@ jobs:
        uses: actions/setup-python@v5
        with:
          python-version: '3.x'
-      - name: Install python prereqs
-        run: pip install mako setuptools pyyaml
-      - name: Run script
+      - name: Cache Mesa and deps
+        id: mesa-cache
+        uses: actions/cache@v4 # Use a specific version
+        with:
+          path: |
+            $HOME/Library/Caches/Homebrew
+            mesa
+          key: ${{ runner.os }}-mesa-deps-${{ vars.MESA_VERSION }}
+      - name: Get Mesa
+        id: mesa-prereq
+        env:
+          MESA_VERSION: ${{ vars.MESA_VERSION }}
+        run: |
+          bash test/utils/get_mesa.sh
+      - name: Run Test
        run: |
          bash test/renderdiff/test.sh
      - uses: actions/upload-artifact@v4
@@ -122,3 +140,31 @@ 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
@@ -18,3 +18,18 @@ test*.json
 results
 /compile_commands.json
 /.cache
+build/.cmake/
+build/CMakeCache.txt
+build/CMakeFiles/
+build/Makefile
+build/SPIRV-Tools*
+build/cmake_install.cmake
+build/compile_commands.json
+build/filament/
+build/include/
+build/libs/
+build/mac/ninja
+build/samples/
+build/shaders/
+build/third_party/
+build/tools/
@@ -334,6 +334,9 @@ 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)
@@ -798,6 +801,7 @@ add_subdirectory(${EXTERNAL}/draco/tnt)
 add_subdirectory(${EXTERNAL}/jsmn/tnt)
 add_subdirectory(${EXTERNAL}/stb/tnt)
 add_subdirectory(${EXTERNAL}/getopt)
+add_subdirectory(${EXTERNAL}/perfetto/tnt)

 # Note that this has to be placed after mikktspace in order for combine_static_libs to work.
 add_subdirectory(${LIBRARIES}/geometry)
@@ -31,7 +31,7 @@ repositories {
 }

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

@@ -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.59.3'
 ```

 ## Documentation
@@ -7,6 +7,16 @@ 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.4
+
+
+## v1.59.3
+
+
+## v1.59.2
+
+- Fix build/compile errors when upgrading to MacOS 15.4
+
 ## v1.59.1


@@ -142,6 +142,12 @@ 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")
@@ -26,6 +26,10 @@ add_library(utils STATIC IMPORTED)
 set_target_properties(utils PROPERTIES IMPORTED_LOCATION
        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libutils.a)

+add_library(perfetto STATIC IMPORTED)
+set_target_properties(perfetto PROPERTIES IMPORTED_LOCATION
+        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libperfetto.a)
+
 add_library(filabridge STATIC IMPORTED)
 set_target_properties(filabridge PROPERTIES IMPORTED_LOCATION
        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libfilabridge.a)
@@ -40,6 +44,7 @@ set_target_properties(shaders PROPERTIES IMPORTED_LOCATION

 set(FILAMAT_INCLUDE_DIRS
        ../../libs/utils/include
+        ../../third_party/perfetto
        )

 include_directories(${FILAMENT_DIR}/include)
@@ -55,6 +60,7 @@ target_link_libraries(filamat-jni
        filabridge
        shaders
        utils
+        perfetto
        log
        smol-v
        $<$<STREQUAL:${FILAMENT_SUPPORTS_WEBGPU},ON>:tint>
@@ -21,6 +21,10 @@ add_library(utils STATIC IMPORTED)
 set_target_properties(utils PROPERTIES IMPORTED_LOCATION
        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libutils.a)

+add_library(perfetto STATIC IMPORTED)
+set_target_properties(perfetto PROPERTIES IMPORTED_LOCATION
+        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libperfetto.a)
+
 add_library(ibl-lite STATIC IMPORTED)
 set_target_properties(ibl-lite PROPERTIES IMPORTED_LOCATION
        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libibl-lite.a)
@@ -123,6 +127,7 @@ target_link_libraries(filament-jni
    PRIVATE android
    PRIVATE jnigraphics
    PRIVATE utils
+    PRIVATE perfetto

    # libgeometry is PUBLIC because gltfio uses it.
    PUBLIC geometry
@@ -141,6 +146,7 @@ target_include_directories(filament-jni PRIVATE
        ${FILAMENT_DIR}/include
        ../../filament/backend/include
        ../../third_party/robin-map
+        ../../third_party/perfetto
        ../../libs/utils/include)

 # Force a relink when the version script is changed:
@@ -35,6 +35,10 @@ add_library(utils STATIC IMPORTED)
 set_target_properties(utils PROPERTIES IMPORTED_LOCATION
        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libutils.a)

+add_library(perfetto STATIC IMPORTED)
+set_target_properties(perfetto PROPERTIES IMPORTED_LOCATION
+        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libperfetto.a)
+
 add_library(uberzlib STATIC IMPORTED)
 set_target_properties(uberzlib PROPERTIES IMPORTED_LOCATION
        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libuberzlib.a)
@@ -121,6 +125,7 @@ set(GLTFIO_INCLUDE_DIRS
        ../../third_party/meshoptimizer/src
        ../../third_party/robin-map
        ../../third_party/stb
+        ../../third_party/perfetto
        ../../libs/utils/include
        ../../libs/ktxreader/include
 )
@@ -129,7 +134,7 @@ add_library(gltfio-jni SHARED ${GLTFIO_SRCS})
 target_include_directories(gltfio-jni PRIVATE ${GLTFIO_INCLUDE_DIRS})
 set_target_properties(gltfio-jni PROPERTIES LINK_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/libgltfio-jni.symbols)
 set_target_properties(gltfio-jni PROPERTIES LINK_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/libgltfio-jni.map)
-target_link_libraries(gltfio-jni filament-jni utils uberzlib log stb ktxreader basis_transcoder zstd uberarchive)
+target_link_libraries(gltfio-jni filament-jni utils perfetto uberzlib log stb ktxreader basis_transcoder zstd uberarchive)
 target_link_libraries(gltfio-jni dracodec meshoptimizer)
 target_compile_definitions(gltfio-jni PUBLIC GLTFIO_DRACO_SUPPORTED=1)
 target_include_directories(gltfio-jni PRIVATE ${DRACO_DIR}/src)
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.59.0
+VERSION_NAME=1.59.3

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

@@ -177,29 +177,6 @@ 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
@@ -210,6 +187,10 @@ 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
@@ -217,22 +198,43 @@ if (FILAMENT_SUPPORTS_VULKAN)
            src/vulkan/VulkanFboCache.h
            src/vulkan/VulkanHandles.cpp
            src/vulkan/VulkanHandles.h
-            src/vulkan/VulkanMemory.h
            src/vulkan/VulkanMemory.cpp
+            src/vulkan/VulkanMemory.h
            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)
@@ -253,6 +255,11 @@ if (FILAMENT_SUPPORTS_WEBGPU)
            src/webgpu/WebGPUConstants.h
            src/webgpu/WebGPUDriver.cpp
            src/webgpu/WebGPUDriver.h
+            src/webgpu/WebGPUHandles.cpp
+            src/webgpu/WebGPUHandles.h
+            src/webgpu/WebGPUSwapChain.cpp
+            src/webgpu/WebGPUSwapChain.h
+            src/webgpu/WGPUProgram.cpp
    )
    if (WIN32)
        list(APPEND SRCS src/webgpu/platform/WebGPUPlatformWindows.cpp)
@@ -302,6 +309,11 @@ 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.
 # ==================================================================================================
@@ -496,7 +508,10 @@ if (APPLE OR LINUX)
        test/Arguments.cpp
        test/ImageExpectations.cpp
        test/Lifetimes.cpp
+        test/PlatformRunner.cpp
        test/Shader.cpp
+        test/SharedShaders.cpp
+        test/Skip.cpp
        test/test_FeedbackLoops.cpp
        test/test_Blit.cpp
        test/test_MissingRequiredAttributes.cpp
@@ -520,6 +535,9 @@ if (APPLE OR LINUX)
        filamat
        SPIRV
        spirv-cross-glsl)
+    # Create input/output directories for test result images.
+    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/images/actual_images)
+    file(COPY test/expected_images DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/images)
 endif()

 # TODO: Disabling IOS test due to breakage wrt glslang update
@@ -55,4 +55,9 @@ public:

 } // namespace filament::backend

+#if !defined(NDEBUG)
+utils::io::ostream& operator<<(utils::io::ostream& out,
+        const filament::backend::BufferObjectStreamDescriptor& b);
+#endif
+
 #endif // TNT_FILAMENT_BACKEND_BUFFEROBJECTSTREAMDESCRIPTOR_H
@@ -104,10 +104,6 @@ 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();
@@ -361,8 +357,7 @@ public:
            VkImageUsageFlags usage);

    virtual VkSampler createExternalSampler(SamplerYcbcrConversion chroma,
-            SamplerParams sampler,
-            uint32_t internalFormat);
+            SamplerParams sampler, uint32_t internalFormat);

    virtual VkImageView createExternalImageView(SamplerYcbcrConversion chroma,
            uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
@@ -38,6 +38,12 @@ public:

    [[nodiscard]] wgpu::Instance& getInstance() noexcept { return mInstance; }

+    // TODO consider that this functionality is not WebGPU-specific, and thus could be
+    //      placed in a generic place and even reused across backends. Alternatively,
+    //      a 3rd party library could be considered. However, this was a simple and
+    //      quick change and works for now.
+    // gets the size (height and width) of the surface/window
+    [[nodiscard]] wgpu::Extent2D getSurfaceExtent(void* nativeWindow) const;
    // either returns a valid surface or panics
    [[nodiscard]] wgpu::Surface createSurface(void* nativeWindow, uint64_t flags);
    // either returns a valid adapter or panics
@@ -84,7 +84,7 @@ void CommandStream::execute(void* buffer) {

    Profiler profiler;

-    if (SYSTRACE_TAG) {
+    if constexpr (SYSTRACE_TAG) {
        if (UTILS_UNLIKELY(mUsePerformanceCounter)) {
            // we want to remove all this when tracing is completely disabled
            profiler.resetEvents(Profiler::EV_CPU_CYCLES  | Profiler::EV_BPU_MISSES);
@@ -100,7 +100,7 @@ void CommandStream::execute(void* buffer) {
        }
    });

-    if (SYSTRACE_TAG) {
+    if constexpr (SYSTRACE_TAG) {
        if (UTILS_UNLIKELY(mUsePerformanceCounter)) {
            // we want to remove all this when tracing is completely disabled
            profiler.stop();
@@ -85,6 +85,7 @@ OpenGLProgram::~OpenGLProgram() noexcept {
        delete lazyInitializationData;

        ShaderCompilerService::terminate(mToken);
+        assert_invariant(!mToken);
    }

    delete [] mUniformsRecords;
@@ -24,23 +24,23 @@
 #include "OpenGLBlobCache.h"

 #include <backend/CallbackHandler.h>
+#include <backend/DriverEnums.h>
 #include <backend/Program.h>

 #include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
-#include <utils/Invocable.h>
 #include <utils/JobSystem.h>

-#include <atomic>
-#include <condition_variable>
-#include <deque>
+#include <array>
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <thread>
+#include <tuple>
 #include <utility>
 #include <vector>

+#include <stdint.h>
+
 namespace filament::backend {

 class OpenGLDriver;
@@ -57,6 +57,8 @@ class ShaderCompilerService {

 public:
    using program_token_t = std::shared_ptr<OpenGLProgramToken>;
+    using shaders_t = std::array<GLuint, Program::SHADER_TYPE_COUNT>;
+    using shaders_source_t = std::array<utils::CString, Program::SHADER_TYPE_COUNT>;

    explicit ShaderCompilerService(OpenGLDriver& driver);

@@ -82,6 +84,7 @@ public:
    void tick();

    // Destroys a valid token and all associated resources. Used to "cancel" a program compilation.
+    // This function is not called if `initialize(token)` is already invoked.
    static void terminate(program_token_t& token);

    // stores a user data pointer in the token
@@ -90,6 +93,12 @@ public:
    // retrieves the user data pointer stored in the token
    static void* getUserData(const program_token_t& token) noexcept;

+    // Issue one callback handle.
+    CallbackManager::Handle issueCallbackHandle() const noexcept;
+
+    // Return a callback handle to the callback manager.
+    void submitCallbackHandle(CallbackManager::Handle handle) noexcept;
+
    // call the callback when all active programs are ready
    void notifyWhenAllProgramsAreReady(
            CallbackHandler* handler, CallbackHandler::Callback callback, void* user);
@@ -97,7 +106,7 @@ public:
 private:
    struct Job {
        template<typename FUNC>
-        Job(FUNC&& fn) : fn(std::forward<FUNC>(fn)) {}
+        Job(FUNC&& fn) : fn(std::forward<FUNC>(fn)) {} // NOLINT(*-explicit-constructor)
        Job(std::function<bool(Job const& job)> fn,
                CallbackHandler* handler, void* user, CallbackHandler::Callback callback)
                : fn(std::move(fn)), handler(handler), user(user), callback(callback) {
@@ -126,39 +135,49 @@ private:
    using ContainerType = std::tuple<CompilerPriorityQueue, program_token_t, Job>;
    std::vector<ContainerType> mRunAtNextTickOps;

-    GLuint initialize(ShaderCompilerService::program_token_t& token) noexcept;
+    GLuint initialize(program_token_t& token);
+    void ensureTokenIsReady(program_token_t const& token);

-    static void getProgramFromCompilerPool(program_token_t& token) noexcept;
-
-    static void compileShaders(
-            OpenGLContext& context,
-            Program::ShaderSource shadersSource,
-            utils::FixedCapacityVector<Program::SpecializationConstant> const& specializationConstants,
-            bool multiview,
-            std::array<GLuint, Program::SHADER_TYPE_COUNT>& outShaders,
-            std::array<utils::CString, Program::SHADER_TYPE_COUNT>& outShaderSourceCode) noexcept;
-
-    static void process_GOOGLE_cpp_style_line_directive(OpenGLContext& context,
-            char* source, size_t len) noexcept;
-
-    static void process_OVR_multiview2(OpenGLContext& context, int32_t eyeCount,
-            char* source, size_t len) noexcept;
-
-    static std::string_view process_ARB_shading_language_packing(OpenGLContext& context) noexcept;
-
-    static std::array<std::string_view, 3> splitShaderSource(std::string_view source) noexcept;
-
-    static GLuint linkProgram(OpenGLContext& context,
-            std::array<GLuint, Program::SHADER_TYPE_COUNT> shaders,
-            utils::FixedCapacityVector<std::pair<utils::CString, uint8_t>> const& attributes) noexcept;
-
-    static bool checkProgramStatus(program_token_t const& token) noexcept;
-
-    void runAtNextTick(CompilerPriorityQueue priority,
-            const program_token_t& token, Job job) noexcept;
+    void runAtNextTick(CompilerPriorityQueue priority, program_token_t const& token,
+            Job job) noexcept;
    void executeTickOps() noexcept;
-    bool cancelTickOp(program_token_t token) noexcept;
-    // order of insertion is important
+    bool cancelTickOp(program_token_t const& token) noexcept;
+
+    // Compile shaders with the given `shaderSource`. `gl.shaders` is always populated with valid
+    // shader IDs after this method. But this doesn't necessarily mean the shaders are successfully
+    // compiled. Errors can be checked by calling `checkCompileStatus` later.
+    static void compileShaders(OpenGLContext& context, Program::ShaderSource shadersSource,
+            utils::FixedCapacityVector<Program::SpecializationConstant> const&
+                    specializationConstants,
+            bool multiview, program_token_t const& token) noexcept;
+
+    // Check if the shader compilation is completed. You may want to call this when the extension
+    // `KHR_parallel_shader_compile` is enabled.
+    static bool isCompileCompleted(program_token_t const& token) noexcept;
+
+    // Check compilation status of the shaders and log errors on failure.
+    static void checkCompileStatus(program_token_t const& token) noexcept;
+
+    // Create a program by linking the compiled shaders. `gl.program` is always populated with a
+    // valid program ID after this method. But this doesn't necessarily mean the program is
+    // successfully linked. Errors can be checked by calling `checkLinkStatusAndCleanupShaders`
+    // later.
+    static void linkProgram(OpenGLContext const& context, program_token_t const& token) noexcept;
+
+    // Check if the program link is completed. You may want to call this when the extension
+    // `KHR_parallel_shader_compile` is enabled.
+    static bool isLinkCompleted(program_token_t const& token) noexcept;
+
+    // Check link status of the program and log errors on failure. Return the result of the link.
+    // Also cleanup shaders regardless of the result.
+    static bool checkLinkStatusAndCleanupShaders(program_token_t const& token) noexcept;
+
+    // Try caching the program if we haven't done it yet. Cache it only when the program is valid.
+    static void tryCachingProgram(OpenGLBlobCache& cache, OpenGLPlatform& platform,
+            program_token_t const& token) noexcept;
+
+    // Cleanup GL resources.
+    static void cleanupProgramAndShaders(program_token_t const& token) noexcept;
 };

 } // namespace filament::backend
@@ -15,6 +15,7 @@
 */

 #include <backend/BufferDescriptor.h>
+#include <backend/BufferObjectStreamDescriptor.h>
 #include <backend/DescriptorSetOffsetArray.h>
 #include <backend/DriverEnums.h>
 #include <backend/PipelineState.h>
@@ -437,6 +438,10 @@ io::ostream& operator<<(io::ostream& out, BufferDescriptor const& b) {
    << ", user=" << b.getUser() << " }";
 }

+io::ostream& operator<<(io::ostream& out, const BufferObjectStreamDescriptor& b) {
+    return out << "BufferObjectStreamDescriptor{ streams(" << b.mStreams.size() << ")=... }";
+}
+
 io::ostream& operator<<(io::ostream& out, PixelBufferDescriptor const& b) {
    BufferDescriptor const& base = static_cast<BufferDescriptor const&>(b);
    return out << "PixelBufferDescriptor{ " << base
@@ -17,9 +17,6 @@
 #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,13 +24,6 @@

 namespace filament::backend {

-class VulkanBuffer;
-class VulkanFboCache;
-class VulkanPipelineCache;
-class VulkanSamplerCache;
-
-struct VulkanProgram;
-
 class VulkanBlitter {
 public:
    VulkanBlitter(VkPhysicalDevice physicalDevice, VulkanCommands* commands) noexcept;
@@ -152,12 +152,12 @@ static_assert(FVK_ENABLED(FVK_DEBUG_VALIDATION));
 #elif FVK_ENABLED(FVK_DEBUG_SYSTRACE)

    #include <utils/Systrace.h>
-    
+
    #define FVK_SYSTRACE_CONTEXT()      SYSTRACE_CONTEXT()
    #define FVK_SYSTRACE_START(marker)  SYSTRACE_NAME_BEGIN(marker)
    #define FVK_SYSTRACE_END()          SYSTRACE_NAME_END()
-    #define FVK_SYSTRACE_SCOPE()        SYSTRACE_NAME(__func__)
-    #define FVK_PROFILE_MARKER(marker)  FVK_SYSTRACE_SCOPE()
+    #define FVK_SYSTRACE_SCOPE()        SYSTRACE_CALL()
+    #define FVK_PROFILE_MARKER(marker)  SYSTRACE_CALL()

 #else
    #define FVK_SYSTRACE_CONTEXT()
@@ -56,9 +56,9 @@ VkImageView VulkanAttachment::getImageView() {
    assert_invariant(texture);
    VkImageSubresourceRange range = getSubresourceRange();
    if (range.layerCount > 1) {
-        return texture->getMultiviewAttachmentView(range);
+        return texture->getAttachmentView(range, VK_IMAGE_VIEW_TYPE_2D_ARRAY);
    }
-    return texture->getAttachmentView(range);
+    return texture->getAttachmentView(range, VK_IMAGE_VIEW_TYPE_2D);
 }

 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,7 +17,6 @@
 #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"

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

 #include <bluevk/BlueVK.h>

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

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

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

    inline bool isClipDistanceSupported() const noexcept {
@@ -145,6 +147,9 @@ 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,
    };
@@ -157,7 +162,6 @@ private:
    };
    bool mDebugMarkersSupported = false;
    bool mDebugUtilsSupported = false;
-    bool mMultiviewEnabled = false;
    bool mLazilyAllocatedMemorySupported = false;
    bool mProtectedMemorySupported = false;

@@ -260,7 +260,6 @@ 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
@@ -283,18 +282,25 @@ void VulkanDescriptorSetCache::commit(VulkanCommandBuffer* commands,
    fvkutils::DescriptorSetMask curMask = setMask;

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

-    setMask.forEachSetBit([&](size_t index) {
-        if (!updateSets[index] || updateSets[index] == lastBoundSets[index]) {
-            curMask.unset(index);
+    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;
        }
-    });
-
-    if (curMask.none() &&
-            (mLastBoundInfo.pipelineLayout == pipelineLayout && mLastBoundInfo.setMask == setMask &&
-                    mLastBoundInfo.boundSets == updateSets)) {
-        return;
+    } else {
+        setMask.forEachSetBit([&](size_t index) {
+            if (!updateSets[index]) {
+                curMask.unset(index);
+            }
+        });
    }

    curMask.forEachSetBit([&updateSets, commands, pipelineLayout](size_t index) {
@@ -302,7 +308,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->vkSet, set->uniqueDynamicUboCount, set->getOffsets()->data());
+                1, &set->getVkSet(), set->uniqueDynamicUboCount, set->getOffsets()->data());
        commands->acquire(set);
    });

@@ -330,8 +336,7 @@ void VulkanDescriptorSetCache::updateBuffer(fvkmemory::resource_ptr<VulkanDescri
    }
    VkWriteDescriptorSet const descriptorWrite = {
        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-        .pNext = nullptr,
-        .dstSet = set->vkSet,
+        .dstSet = set->getVkSet(),
        .dstBinding = binding,
        .descriptorCount = 1,
        .descriptorType = type,
@@ -344,26 +349,25 @@ 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 {
-    VkDescriptorImageInfo info{
-        .sampler = sampler,
-    };
-    VkImageSubresourceRange const range = texture->getPrimaryViewRange();
+    VkImageSubresourceRange 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 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);
+        // an attachment, then the range for this view has exactly one level and one layer.
+        range.levelCount = 1;
+        range.layerCount = 1;
    }
-    info.imageLayout = fvkutils::getVkLayout(texture->getDefaultLayout());
+    VkDescriptorImageInfo info{
+        .sampler = sampler,
+        .imageView = texture->getView(range),
+        .imageLayout = fvkutils::getVkLayout(texture->getDefaultLayout()),
+    };
+
    VkWriteDescriptorSet const descriptorWrite = {
        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
        .pNext = nullptr,
-        .dstSet = set->vkSet,
+        .dstSet = set->getVkSet(),
        .dstBinding = binding,
        .descriptorCount = 1,
        .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
@@ -381,10 +385,10 @@ void VulkanDescriptorSetCache::updateInputAttachment(

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

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

+void VulkanDescriptorSetCache::manualRecyle(VulkanDescriptorSetLayout::Count const& count,
+        VkDescriptorSetLayout vklayout, VkDescriptorSet vkSet) {
+    mDescriptorPool->recycle(count, vklayout, vkSet);
+}
+
+void VulkanDescriptorSetCache::gc() { mStashedSets = {}; }
+
 } // namespace filament::backend
@@ -41,6 +41,8 @@ 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();
@@ -68,14 +70,21 @@ public:
    fvkmemory::resource_ptr<VulkanDescriptorSet> createSet(Handle<HwDescriptorSet> handle,
            fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout);

-    void clearHistory();
+    // 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();

 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,6 +18,8 @@

 #include "VulkanHandles.h"

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

 namespace {
@@ -58,6 +60,56 @@ 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,
@@ -73,37 +125,44 @@ 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);
-    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);
+    layout->setVkLayout(getVkLayout(layout->bitmask));
    return layout;
 }

@@ -26,12 +26,11 @@
 #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 {
@@ -41,21 +40,34 @@ 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;

-    using BitmaskGroup = VulkanDescriptorSetLayout::Bitmask;
-    using BitmaskGroupHashFn = utils::hash::MurmurHashFn<BitmaskGroup>;
-    struct BitmaskGroupEqual {
-        bool operator()(BitmaskGroup const& k1, BitmaskGroup const& k2) const { return k1 == k2; }
+    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;
+        }
    };

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

 } // namespace filament::backend
@@ -25,10 +25,12 @@
 #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>
@@ -212,6 +214,7 @@ 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()),
@@ -324,7 +327,7 @@ void VulkanDriver::terminate() {

    mStagePool.terminate();
    mPipelineCache.terminate();
-    mFramebufferCache.reset();
+    mFramebufferCache.terminate();
    mSamplerCache.terminate();
    mDescriptorSetLayoutCache.terminate();
    mDescriptorSetCache.terminate();
@@ -363,7 +366,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.clearHistory();
+    mDescriptorSetCache.gc();
    mStagePool.gc();
    mFramebufferCache.gc();
    mPipelineCache.gc();
@@ -418,7 +421,11 @@ void VulkanDriver::updateDescriptorSetTexture(
    auto set = resource_ptr<VulkanDescriptorSet>::cast(&mResourceManager, dsh);
    auto texture = resource_ptr<VulkanTexture>::cast(&mResourceManager, th);

-    VkSampler const vksampler = mSamplerCache.getSampler(params);
+    // TODO: YcbcrConversion?
+    VulkanSamplerCache::Params cacheParams = {
+        .sampler = params,
+    };
+    VkSampler const vksampler = mSamplerCache.getSampler(cacheParams);
    mDescriptorSetCache.updateSampler(set, binding, texture, vksampler);
 }

@@ -556,7 +563,7 @@ 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();
-    const auto& metadata = mPlatform->getExternalImageMetadata(externalImage);
+    auto const& metadata = mPlatform->getExternalImageMetadata(externalImage);
    if (metadata.isProtected) {
        usage |= backend::TextureUsage::PROTECTED;
    }
@@ -566,7 +573,7 @@ void VulkanDriver::createTextureExternalImage2R(Handle<HwTexture> th, backend::S
        vkUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
    }

-    if (any(usage & (TextureUsage::BLIT_DST & TextureUsage::UPLOADABLE))) {
+    if (any(usage & (TextureUsage::BLIT_DST | TextureUsage::UPLOADABLE))) {
        vkUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
    }

@@ -582,13 +589,15 @@ void VulkanDriver::createTextureExternalImage2R(Handle<HwTexture> th, backend::S
    FILAMENT_CHECK_POSTCONDITION(memoryTypeIndex != VK_MAX_MEMORY_TYPES)
            << "failed to find a valid memory type for external image memory.";

-    const auto& data =
+    VkImage vkimg;
+    VkDeviceMemory deviceMemory;
+    std::tie(vkimg, deviceMemory) =
            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);
+    auto texture = resource_ptr<VulkanTexture>::make(&mResourceManager, th, mContext,
+            mPlatform->getDevice(), mAllocator, &mResourceManager, &mCommands, vkimg, deviceMemory,
+            metadata.format, VK_NULL_HANDLE, metadata.samples, metadata.width, metadata.height,
+            metadata.layerCount, usage, mStagePool);

    texture.inc();
 }
@@ -597,13 +606,14 @@ 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,
@@ -611,6 +621,7 @@ 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) {
@@ -1512,7 +1523,7 @@ void VulkanDriver::makeCurrent(Handle<HwSwapChain> drawSch, Handle<HwSwapChain>
    swapChain->acquire(resized);

    if (resized) {
-        mFramebufferCache.reset();
+        mFramebufferCache.resetFramebuffers();
    }

    if (UTILS_LIKELY(mDefaultRenderTarget)) {
@@ -27,6 +27,7 @@
 #include "VulkanSamplerCache.h"
 #include "VulkanStagePool.h"
 #include "VulkanQueryManager.h"
+#include "VulkanYcbcrConversionCache.h"
 #include "vulkan/VulkanDescriptorSetCache.h"
 #include "vulkan/VulkanDescriptorSetLayoutCache.h"
 #include "vulkan/VulkanPipelineLayoutCache.h"
@@ -135,6 +136,7 @@ private:
    VulkanPipelineCache mPipelineCache;
    VulkanStagePool mStagePool;
    VulkanFboCache mFramebufferCache;
+    VulkanYcbcrConversionCache mYcbcrConversionCache;
    VulkanSamplerCache mSamplerCache;
    VulkanBlitter mBlitter;
    VulkanReadPixels mReadPixels;
@@ -340,15 +340,21 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey const& config) noexcept
    return renderPass;
 }

-void VulkanFboCache::reset() noexcept {
-    for (auto pair : mFramebufferCache) {
+void VulkanFboCache::resetFramebuffers() noexcept {
+    for (const auto& pair: mFramebufferCache) {
        mRenderPassRefCount[pair.first.renderPass]--;
        vkDestroyFramebuffer(mDevice, pair.second.handle, VKALLOC);
    }
    mFramebufferCache.clear();
-    for (auto pair : mRenderPassCache) {
+}
+
+void VulkanFboCache::terminate() noexcept {
+    resetFramebuffers();
+
+    for (const auto& pair: mRenderPassCache) {
        vkDestroyRenderPass(mDevice, pair.second.handle, VKALLOC);
    }
+    mRenderPassRefCount.clear();
    mRenderPassCache.clear();
 }

@@ -106,8 +106,11 @@ public:
    // Evicts old unused Vulkan objects. Call this once per frame.
    void gc() noexcept;

+    // Frees all Framebuffer objects. Call this every time a the swapchain is resized
+    void resetFramebuffers() noexcept;
+
    // Frees all Vulkan objects. Call this during shutdown before the device is destroyed.
-    void reset() noexcept;
+    void terminate() noexcept;

 private:
    VkDevice mDevice;
@@ -30,6 +30,7 @@

 #include <backend/platforms/VulkanPlatform.h>

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

 using namespace bluevk;
@@ -89,8 +90,9 @@ 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,18 +66,21 @@ 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;
+                   inputAttachment == right.inputAttachment &&
+                   externalSampler == right.externalSampler;
        }
    };
-    static_assert(sizeof(Bitmask) == 32);
+    static_assert(sizeof(Bitmask) == 40);

    // This is a convenience struct to quickly check layout compatibility in terms of descriptor set
    // pools.
@@ -119,10 +122,16 @@ 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 getVkLayout() const { return mVkLayout; }
-    void setVkLayout(VkDescriptorSetLayout vklayout) { mVkLayout = vklayout; }
+    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; }

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

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

@@ -152,6 +160,13 @@ 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);
    }
@@ -163,11 +178,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;
@@ -35,7 +35,12 @@ using namespace bluevk;
 namespace filament::backend {

 VulkanPipelineCache::VulkanPipelineCache(VkDevice device)
-        : mDevice(device) {}
+    : mDevice(device) {
+    VkPipelineCacheCreateInfo createInfo = {
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
+    };
+    bluevk::vkCreatePipelineCache(mDevice, &createInfo, VKALLOC, &mPipelineCache);
+}

 void VulkanPipelineCache::bindLayout(VkPipelineLayout layout) noexcept {
    mPipelineRequirements.layout = layout;
@@ -215,7 +220,7 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
    PipelineCacheEntry cacheEntry = {
        .lastUsed = mCurrentTime,
    };
-    VkResult error = vkCreateGraphicsPipelines(mDevice, VK_NULL_HANDLE, 1, &pipelineCreateInfo,
+    VkResult error = vkCreateGraphicsPipelines(mDevice, mPipelineCache, 1, &pipelineCreateInfo,
            VKALLOC, &cacheEntry.handle);
    assert_invariant(error == VK_SUCCESS);
    if (error != VK_SUCCESS) {
@@ -271,6 +276,8 @@ void VulkanPipelineCache::terminate() noexcept {
    }
    mPipelines.clear();
    mBoundPipeline = {};
+
+    vkDestroyPipelineCache(mDevice, mPipelineCache, VKALLOC);
 }

 void VulkanPipelineCache::gc() noexcept {
@@ -18,24 +18,18 @@
 #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 {

@@ -204,6 +198,10 @@ private:
    // Immutable state.
    VkDevice mDevice = VK_NULL_HANDLE;

+    // Vuklan Driver pipeline cache handle. In the cases a pipeline has been  evicted by the `gc`,
+    // recreating the same pipeline is cheaper, helping with frame stalling.
+    VkPipelineCache mPipelineCache = VK_NULL_HANDLE;
+
    // Current requirements for the pipeline layout, pipeline, and descriptor sets.
    PipelineKey mPipelineRequirements = {};

@@ -14,7 +14,9 @@
 * limitations under the License.
 */

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

 #include <utils/Panic.h>
@@ -26,41 +28,48 @@ namespace filament::backend {
 VulkanSamplerCache::VulkanSamplerCache(VkDevice device)
    : mDevice(device) {}

-VkSampler VulkanSamplerCache::getSampler(SamplerParams params) noexcept {
+VkSampler VulkanSamplerCache::getSampler(Params params) noexcept {
    auto iter = mCache.find(params);
    if (UTILS_LIKELY(iter != mCache.end())) {
        return iter->second;
    }
-    VkSamplerCreateInfo samplerInfo {
+    VkSamplerYcbcrConversionInfo ycbcrConversion = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
+        .conversion = params.conversion,
+    };
+
+    auto const& samplerParams = params.sampler;
+    VkSamplerCreateInfo samplerInfo{
        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
-        .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),
+        .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),
        .minLod = 0.0f,
-        .maxLod = fvkutils::getMaxLod(params.filterMin),
+        .maxLod = fvkutils::getMaxLod(samplerParams.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,8 +17,11 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANSAMPLERCACHE_H
 #define TNT_FILAMENT_BACKEND_VULKANSAMPLERCACHE_H

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

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

 namespace filament::backend {
@@ -26,12 +29,28 @@ 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(SamplerParams params) noexcept;
+    VkSampler getSampler(Params params) noexcept;
    void terminate() noexcept;
 private:
    VkDevice mDevice;
-    tsl::robin_map<SamplerParams, VkSampler, SamplerParams::Hasher, SamplerParams::EqualTo> mCache;
+
+    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;
 };

 } // namespace filament::backend
@@ -32,6 +32,7 @@ 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),
@@ -77,16 +78,16 @@ void VulkanSwapChain::update() {
    }
    for (auto const color: bundle.colors) {
        auto colorTexture = fvkmemory::resource_ptr<VulkanTexture>::construct(mResourceManager,
-                device, mAllocator, mResourceManager, mCommands, color, VK_NULL_HANDLE,
-                bundle.colorFormat, 1, bundle.extent.width, bundle.extent.height, bundle.layerCount, colorUsage,
-                mStagePool);
+                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);
        mColors.push_back(colorTexture);
    }

-    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);
+    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);

    mExtent = bundle.extent;
    mLayerCount = bundle.layerCount;
@@ -107,11 +108,6 @@ 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();
@@ -145,7 +141,6 @@ 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,6 +19,7 @@

 #include "DriverBase.h"

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

-#include <memory>

 using namespace bluevk;

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

    void present();

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

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

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

 #include "VulkanCommands.h"
+#include "VulkanContext.h"
 #include "VulkanMemory.h"
 #include "VulkanTexture.h"
 #include "vulkan/memory/ResourcePointer.h"
@@ -54,7 +55,6 @@ 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,35 +151,152 @@ 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(VkDevice device, VmaAllocator allocator,
-        VulkanCommands* commands, VulkanStagePool& stagePool, VkFormat format,
-        VkImageViewType viewType, uint8_t levels, uint8_t layerCount, VulkanLayout defaultLayout,
+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,
        bool isProtected)
-    : mVkFormat(format),
-      mViewType(viewType),
-      mFullViewRange{fvkutils::getImageAspect(format), 0, levels, 0, layerCount},
-      mDefaultLayout(defaultLayout),
-      mIsProtected(isProtected),
-      mStagePool(stagePool),
-      mDevice(device),
-      mAllocator(allocator),
+    : mStagePool(stagePool),
      mCommands(commands),
-      mIsTransientAttachment(false) {}
+      mAllocator(allocator),
+      mDevice(device),
+      mTextureImage(image),
+      mTextureImageMemory(deviceMemory),
+      mVkFormat(format),
+      mViewType(viewType),
+      mFullViewRange{ fvkutils::getImageAspect(format), 0, levels, 0, layerCount },
+      mYcbcr{ ycbcrConversion, isExternalFormat },
+      mDefaultLayout(getDefaultLayoutImpl(usage)),
+      mUsage(usage),
+      mIsProtected(isProtected) {}

-// Constructor for internally passed VkImage
-VulkanTexture::VulkanTexture(VkDevice device, VmaAllocator allocator,
+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,
        fvkmemory::ResourceManager* resourceManager, VulkanCommands* commands, VkImage image,
-        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;
+        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))) {
    mPrimaryViewRange = mState->mFullViewRange;
 }

@@ -189,21 +306,19 @@ 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),
-      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))) {
+     : HwTexture(target, levels, samples, w, h, depth, tformat, tusage) {
    // 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 = mState->mVkFormat,
+        .format = vkFormat,
        .extent = {w, h, depth},
        .mipLevels = levels,
        .arrayLayers = 1,
        .tiling = VK_IMAGE_TILING_OPTIMAL,
-        .usage = 0,
+        .usage = getUsage(context, samples, physicalDevice, vkFormat, tusage),
    };
    if (target == SamplerType::SAMPLER_3D && any(tusage & TextureUsage::ALL_ATTACHMENTS)) {
        if (context.isImageView2DOn3DImageSupported()) {
@@ -233,79 +348,17 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        imageInfo.arrayLayers = depth * 6;
        imageInfo.extent.depth = 1;
    }
-    if (any(usage & TextureUsage::PROTECTED)) {
+    if (isProtected) {
        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).
-    const auto& limits = context.getPhysicalDeviceLimits();
+    auto const& limits = context.getPhysicalDeviceLimits();
    if (imageInfo.usage & VK_IMAGE_USAGE_SAMPLED_BIT) {
        samples = fvkutils::reduceSampleCount(samples,
-                fvkutils::isVkDepthFormat(mState->mVkFormat)
+                fvkutils::isVkDepthFormat(vkFormat)
                        ? limits.sampledImageDepthSampleCounts
                        : limits.sampledImageColorSampleCounts);
    }
@@ -319,33 +372,36 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
    this->samples = samples;
    imageInfo.samples = (VkSampleCountFlagBits) samples;

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

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

@@ -357,21 +413,22 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        .allocationSize = memReqs.size,
        .memoryTypeIndex = memoryTypeIndex,
    };
-    result = vkAllocateMemory(mState->mDevice, &allocInfo, nullptr, &mState->mTextureImageMemory);
+    VkDeviceMemory textureImageMemory;
+    result = vkAllocateMemory(device, &allocInfo, nullptr, &textureImageMemory);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to allocate image memory."
                                                       << " error=" << static_cast<int32_t>(result);
-    result = vkBindImageMemory(mState->mDevice, mState->mTextureImage, mState->mTextureImageMemory,
-            0);
+    result = vkBindImageMemory(device, textureImage, textureImageMemory, 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
@@ -380,8 +437,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;
@@ -392,21 +449,10 @@ 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);
-}
-
-VulkanTextureState::~VulkanTextureState() {
-    if (mTextureImageMemory != VK_NULL_HANDLE) {
-        vkDestroyImage(mDevice, mTextureImage, VKALLOC);
-        vkFreeMemory(mDevice, mTextureImageMemory, VKALLOC);
-    }
-    for (auto entry: mCachedImageViews) {
-        vkDestroyImageView(mDevice, entry.second, VKALLOC);
-    }
-}
+              src->format, src->usage),
+      mState(src->mState),
+      mPrimaryViewRange(src->mPrimaryViewRange),
+      mSwizzle(composeSwizzle(src->mSwizzle, swizzle)) {}

 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) {
@@ -513,20 +559,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.
-    const int layer = 0;
+    constexpr int layer = 0;

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

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

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

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

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

-VkImageView VulkanTexture::getAttachmentView(VkImageSubresourceRange range) {
-    range.levelCount = 1;
-    range.layerCount = 1;
-    return getImageView(range, VK_IMAGE_VIEW_TYPE_2D, {});
-}
-
-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;
+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, {});
    }
-    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;
+}
+
+VkImageView VulkanTexture::getView(VkImageSubresourceRange const& range) {
+    return mState->getImageView(range, mState->mViewType, mSwizzle);
 }

 VkImageAspectFlags VulkanTexture::getImageAspect() const {
@@ -738,6 +764,21 @@ 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,7 +19,10 @@

 #include "DriverBase.h"

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

 namespace filament::backend {

+struct VulkanTexture;
+
 struct VulkanTextureState : public fvkmemory::Resource {
-    VulkanTextureState(VkDevice device, VmaAllocator allocator, VulkanCommands* commands,
-            VulkanStagePool& stagePool, VkFormat format, VkImageViewType viewType, uint8_t levels,
-            uint8_t layerCount, VulkanLayout defaultLayout, bool isProtected);
+    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();

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

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

    // 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;

-    bool mIsProtected = false;
+    // 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;

    // 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;
-    VulkanStagePool& mStagePool;
-    VkDevice mDevice;
-    VmaAllocator mAllocator;
-    VulkanCommands* mCommands;
-    bool mIsTransientAttachment;
+
+    friend struct VulkanTexture;
 };

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

    // Specialized constructor for internally created textures (e.g. from a swap chain)
-    // The texture will never destroy the given VkImage, but it does manages its subresources.
-    VulkanTexture(VkDevice device, VmaAllocator allocator,
+    VulkanTexture(VulkanContext const& context, VkDevice device, VmaAllocator allocator,
            fvkmemory::ResourceManager* resourceManager, VulkanCommands* commands, VkImage image,
-            VkDeviceMemory memory, VkFormat format, uint8_t samples, uint32_t width, uint32_t height, uint32_t depth,
+            VkDeviceMemory memory, VkFormat format, VkSamplerYcbcrConversion conversion,
+            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
@@ -113,11 +141,6 @@ 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;
    }
@@ -132,20 +155,11 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {
    // time of the call.
    VulkanLayout getDefaultLayout() const;

-    // 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);
+    // 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 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);
+    VkImageView getView(VkImageSubresourceRange const& range);

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

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

    bool getIsProtected() const {
@@ -192,6 +206,11 @@ 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
@@ -0,0 +1,84 @@
+/*
+ * 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
@@ -0,0 +1,60 @@
+/*
+ * 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
@@ -211,6 +211,7 @@ 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__)
@@ -326,7 +327,9 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
 }

 VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
-        VkPhysicalDeviceFeatures2 const& features, uint32_t graphicsQueueFamilyIndex,
+        VkPhysicalDeviceFeatures2 const& features,
+        VkPhysicalDeviceVulkan11Features const& vk11Features,
+        uint32_t graphicsQueueFamilyIndex,
        uint32_t protectedGraphicsQueueFamilyIndex, ExtensionSet const& deviceExtensions,
        bool requestImageView2DOn3DImage) {
    VkDevice device;
@@ -359,14 +362,28 @@ 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,
    };
-    deviceCreateInfo.pEnabledFeatures = &enabledFeatures;
+
+    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.enabledExtensionCount = (uint32_t) requestExtensions.size();
    deviceCreateInfo.ppEnabledExtensionNames = requestExtensions.data();
@@ -383,7 +400,7 @@ VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,

    VkPhysicalDeviceMultiviewFeaturesKHR multiview = {
        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR,
-        .multiview = VK_TRUE,
+        .multiview = vk11Features.multiview,
        .multiviewGeometryShader = VK_FALSE,
        .multiviewTessellationShader = VK_FALSE,
    };
@@ -734,6 +751,7 @@ 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,
@@ -795,10 +813,10 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
    }

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

    assert_invariant(mImpl->mDevice != VK_NULL_HANDLE);
@@ -826,12 +844,10 @@ 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
@@ -295,9 +295,8 @@ VulkanPlatformAndroid::ImageData VulkanPlatformAndroid::createExternalImageData(
 VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device, SamplerYcbcrConversion chroma,
            uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
            VkImageViewType viewType, VkComponentMapping swizzle){
-        VkExternalFormatANDROID externalFormat = {
+    VkExternalFormatANDROID externalFormat = {
        .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
-        .pNext = nullptr,
        .externalFormat = internalFormat,
    };

@@ -322,7 +321,6 @@ VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device, Sampler

    VkSamplerYcbcrConversionInfo samplerYcbcrConversionInfo = {
        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
-        .pNext = nullptr,
        .conversion = conversion,
    };

@@ -350,7 +348,6 @@ VkSampler VulkanPlatform::createExternalSamplerImpl(
        uint32_t internalFormat) {
    VkExternalFormatANDROID externalFormat = {
        .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
-        .pNext = nullptr,
        .externalFormat = internalFormat,
    };

@@ -24,28 +24,12 @@
 #include <bluevk/BlueVK.h>

 // Platform specific includes and defines
-#if defined(__APPLE__)
-    #include <Cocoa/Cocoa.h>
-    #import <Metal/Metal.h>
-    #import <QuartzCore/CAMetalLayer.h>
+#include <Cocoa/Cocoa.h>
+#import <Metal/Metal.h>
+#import <QuartzCore/CAMetalLayer.h>

-    #ifndef VK_MVK_macos_surface
-         #error VK_MVK_macos_surface is not defined
-    #endif
-#elif defined(FILAMENT_IOS)
-    // Metal is not available when building for the iOS simulator on Desktop.
-    #define METAL_AVAILABLE __has_include(<QuartzCore/CAMetalLayer.h>)
-    #if METAL_AVAILABLE
-        #import <Metal/Metal.h>
-        #import <QuartzCore/CAMetalLayer.h>
-    #endif
-
-    #ifndef VK_MVK_ios_surface
-        #error VK_MVK_ios_surface is not defined
-    #endif
-    #define METALVIEW_TAG 255
-#else
-    #error Not a supported Apple + Vulkan platform
+#ifndef VK_MVK_macos_surface
+    #error VK_MVK_macos_surface is not defined
 #endif

 using namespace bluevk;
@@ -54,11 +38,7 @@ namespace filament::backend {

 VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl() {
    ExtensionSet const ret = {
-    #if defined(__APPLE__)
        VK_MVK_MACOS_SURFACE_EXTENSION_NAME,  // TODO: replace with VK_EXT_metal_surface
-    #elif defined(FILAMENT_IOS) && defined(METAL_AVAILABLE)
-        VK_MVK_IOS_SURFACE_EXTENSION_NAME,
-    #endif
    };
    return ret;
 }
@@ -90,36 +70,20 @@ VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device,
 VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
        VkInstance instance, uint64_t flags) noexcept {
    VkSurfaceKHR surface;
-    #if defined(__APPLE__)
-        NSView* nsview = (__bridge NSView*) nativeWindow;
-        FILAMENT_CHECK_POSTCONDITION(nsview) << "Unable to obtain Metal-backed NSView.";
+    NSView* nsview = (__bridge NSView*) nativeWindow;
+    FILAMENT_CHECK_POSTCONDITION(nsview) << "Unable to obtain Metal-backed NSView.";

-        // Create the VkSurface.
-        FILAMENT_CHECK_POSTCONDITION(vkCreateMacOSSurfaceMVK)
-                << "Unable to load vkCreateMacOSSurfaceMVK.";
-        VkMacOSSurfaceCreateInfoMVK createInfo = {};
-        createInfo.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
-        createInfo.pView = (__bridge void*) nsview;
-        VkResult result = vkCreateMacOSSurfaceMVK((VkInstance) instance, &createInfo, VKALLOC,
-                (VkSurfaceKHR*) &surface);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-                << "vkCreateMacOSSurfaceMVK. error=" << static_cast<int32_t>(result);
-#elif defined(FILAMENT_IOS) && defined(METAL_AVAILABLE)
-    CAMetalLayer* metalLayer = (CAMetalLayer*) nativeWindow;
    // Create the VkSurface.
-    FILAMENT_CHECK_POSTCONDITION(vkCreateIOSSurfaceMVK)
-            << "Unable to load vkCreateIOSSurfaceMVK function.";
-    VkIOSSurfaceCreateInfoMVK createInfo = {};
-    createInfo.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
-    createInfo.pNext = NULL;
-    createInfo.flags = 0;
-    createInfo.pView = metalLayer;
-    VkResult result = vkCreateIOSSurfaceMVK((VkInstance) instance, &createInfo, VKALLOC,
+    FILAMENT_CHECK_POSTCONDITION(vkCreateMacOSSurfaceMVK)
+            << "Unable to load vkCreateMacOSSurfaceMVK.";
+    VkMacOSSurfaceCreateInfoMVK createInfo = {};
+    createInfo.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
+    createInfo.pView = (__bridge void*) nsview;
+    VkResult result = vkCreateMacOSSurfaceMVK((VkInstance) instance, &createInfo, VKALLOC,
            (VkSurfaceKHR*) &surface);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkCreateIOSSurfaceMVK failed. error=" << static_cast<int32_t>(result);
-#endif
-        return std::make_tuple(surface, VkExtent2D{});
+            << "vkCreateMacOSSurfaceMVK. error=" << static_cast<int32_t>(result);
+    return std::make_tuple(surface, VkExtent2D{});
 }

 } // namespace filament::backend
@@ -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,4 +668,111 @@ 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,6 +69,12 @@ 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,6 +348,10 @@ 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,49 +193,6 @@ 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) {
@@ -0,0 +1,150 @@
+/*
+ * 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 "WebGPUHandles.h"
+
+#include "WebGPUConstants.h"
+
+#include "DriverBase.h"
+#include <backend/DriverEnums.h>
+#include <backend/Program.h>
+
+#include <utils/Panic.h>
+#include <utils/ostream.h>
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <sstream>
+#include <string_view>
+#include <vector>
+
+namespace filament::backend {
+
+namespace {
+
+[[nodiscard]] constexpr std::string_view toString(ShaderStage stage) {
+    switch (stage) {
+        case ShaderStage::VERTEX:
+            return "vertex";
+        case ShaderStage::FRAGMENT:
+            return "fragment";
+        case ShaderStage::COMPUTE:
+            return "compute";
+    }
+}
+
+[[nodiscard]] wgpu::ShaderModule createShaderModule(wgpu::Device& device, const char* programName,
+        std::array<utils::FixedCapacityVector<uint8_t>, Program::SHADER_TYPE_COUNT> const&
+                shaderSource,
+        ShaderStage stage) {
+    utils::FixedCapacityVector<uint8_t> const& sourceBytes =
+            shaderSource[static_cast<size_t>(stage)];
+    if (sourceBytes.empty()) {
+        return nullptr;// nothing to compile, the shader was not provided
+    }
+    wgpu::ShaderModuleWGSLDescriptor wgslDescriptor{};
+    wgslDescriptor.code = wgpu::StringView(reinterpret_cast<const char*>(sourceBytes.data()));
+    std::stringstream labelStream;
+    labelStream << programName << " " << toString(stage) << " shader";
+    auto label = labelStream.str();
+    wgpu::ShaderModuleDescriptor descriptor{
+        .nextInChain = &wgslDescriptor,
+        .label = label.data()
+    };
+    wgpu::ShaderModule module = device.CreateShaderModule(&descriptor);
+    FILAMENT_CHECK_POSTCONDITION(module != nullptr) << "Failed to create " << descriptor.label;
+    module.GetCompilationInfo(wgpu::CallbackMode::AllowSpontaneous,
+            [&descriptor](auto const& status, wgpu::CompilationInfo const* info) {
+                switch (status) {
+                    case wgpu::CompilationInfoRequestStatus::CallbackCancelled:
+                        FWGPU_LOGW << "Shader compilation info callback cancelled for "
+                                   << descriptor.label << "?" << utils::io::endl;
+                        return;
+                    case wgpu::CompilationInfoRequestStatus::Success:
+                        break;
+                }
+                if (info != nullptr) {
+                    std::stringstream errorStream;
+                    int errorCount = 0;
+                    for (size_t msgIndex = 0; msgIndex < info->messageCount; msgIndex++) {
+                        wgpu::CompilationMessage const& message = info->messages[msgIndex];
+                        switch (message.type) {
+                            case wgpu::CompilationMessageType::Info:
+                                FWGPU_LOGI << descriptor.label << ": " << message.message
+                                           << " line#:" << message.lineNum
+                                           << " linePos:" << message.linePos
+                                           << " offset:" << message.offset
+                                           << " length:" << message.length << utils::io::endl;
+                                break;
+                            case wgpu::CompilationMessageType::Warning:
+                                FWGPU_LOGW << "Warning compiling " << descriptor.label << ": "
+                                           << message.message << " line#:" << message.lineNum
+                                           << " linePos:" << message.linePos
+                                           << " offset:" << message.offset
+                                           << " length:" << message.length << utils::io::endl;
+                                break;
+                            case wgpu::CompilationMessageType::Error:
+                                errorCount++;
+                                errorStream << "Error " << errorCount << " : "
+                                            << std::string_view(message.message)
+                                            << " line#:" << message.lineNum
+                                            << " linePos:" << message.linePos
+                                            << " offset:" << message.offset
+                                            << " length:" << message.length << "\n";
+                                break;
+                        }
+                    }
+                    FILAMENT_CHECK_POSTCONDITION(errorCount < 1)
+                            << errorCount << " error(s) compiling " << descriptor.label << ":\n"
+                            << errorStream.str();
+                }
+                FWGPU_LOGD << descriptor.label << " compiled successfully" << utils::io::endl;
+            });
+    return module;
+}
+
+std::vector<wgpu::ConstantEntry> convertConstants(
+        utils::FixedCapacityVector<filament::backend::Program::SpecializationConstant> const&
+                constantsInfo) {
+    std::vector<wgpu::ConstantEntry> constants(constantsInfo.size());
+    for (size_t i = 0; i < constantsInfo.size(); i++) {
+        filament::backend::Program::SpecializationConstant const& specConstant = constantsInfo[i];
+        wgpu::ConstantEntry& constantEntry = constants[i];
+        constantEntry.key = wgpu::StringView(std::to_string(specConstant.id));
+        if (auto* v = std::get_if<int32_t>(&specConstant.value)) {
+            constantEntry.value = static_cast<double>(*v);
+        } else if (auto* f = std::get_if<float>(&specConstant.value)) {
+            constantEntry.value = static_cast<double>(*f);
+        } else if (auto* b = std::get_if<bool>(&specConstant.value)) {
+            constantEntry.value = *b ? 0.0 : 1.0;
+        }
+    }
+    return constants;
+}
+
+}// namespace
+
+WGPUProgram::WGPUProgram(wgpu::Device& device, Program& program)
+    : HwProgram(program.getName()),
+      vertexShaderModule(createShaderModule(device, name.c_str_safe(), program.getShadersSource(),
+              ShaderStage::VERTEX)),
+      fragmentShaderModule(createShaderModule(device, name.c_str_safe(), program.getShadersSource(),
+              ShaderStage::FRAGMENT)),
+      computeShaderModule(createShaderModule(device, name.c_str_safe(), program.getShadersSource(),
+              ShaderStage::COMPUTE)),
+      constants(convertConstants(program.getSpecializationConstants())) {}
+
+}// namespace filament::backend
@@ -16,6 +16,7 @@

 #include "webgpu/WebGPUDriver.h"

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

@@ -35,6 +36,7 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <sstream>
 #include <string_view>
 #include <utility>
@@ -116,7 +118,6 @@ 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,8 +159,6 @@ 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{};
@@ -175,55 +174,17 @@ void printAdapterDetails(wgpu::Adapter const& adapter) {
                    FWGPU_LOGI << "  " << nameStream.str().data() << utils::io::endl;
                });
    }
-    wgpu::SupportedLimits supportedLimits{};
+    wgpu::Limits 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.limits);
+        printLimits(supportedLimits);
    }
 }
 #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) {
@@ -240,12 +201,12 @@ void printDeviceDetails(wgpu::Device const& device) {
                    FWGPU_LOGI << "  " << nameStream.str().data() << utils::io::endl;
                });
    }
-    wgpu::SupportedLimits supportedLimits{};
+    wgpu::Limits 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.limits);
+        printLimits(supportedLimits);
    }
 }
 #endif
@@ -267,6 +228,14 @@ WebGPUDriver::WebGPUDriver(WebGPUPlatform& platform, const Platform::DriverConfi
              driverConfig.disableHeapHandleTags) {
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
    printInstanceDetails(mPlatform.getInstance());
+#endif
+    mAdapter = mPlatform.requestAdapter(nullptr);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printAdapterDetails(mAdapter);
+#endif
+    mDevice = mPlatform.requestDevice(mAdapter);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printDeviceDetails(mDevice);
 #endif
 }

@@ -296,6 +265,7 @@ void WebGPUDriver::terminate() {
 }

 void WebGPUDriver::tick(int) {
+    mDevice.Tick();
 }

 void WebGPUDriver::beginFrame(int64_t monotonic_clock_ns,
@@ -325,15 +295,27 @@ void WebGPUDriver::finish(int) {
 }

 void WebGPUDriver::destroyRenderPrimitive(Handle<HwRenderPrimitive> rph) {
+   if (rph) {
+        destructHandle<WGPURenderPrimitive>(rph);
+    }
 }

 void WebGPUDriver::destroyVertexBufferInfo(Handle<HwVertexBufferInfo> vbih) {
+   if (vbih) {
+        destructHandle<WGPUVertexBufferInfo>(vbih);
+    }
 }

 void WebGPUDriver::destroyVertexBuffer(Handle<HwVertexBuffer> vbh) {
+    if (vbh) {
+        destructHandle<WGPUVertexBuffer>(vbh);
+    }
 }

 void WebGPUDriver::destroyIndexBuffer(Handle<HwIndexBuffer> ibh) {
+    if (ibh) {
+        destructHandle<WGPUIndexBuffer>(ibh);
+    }
 }

 void WebGPUDriver::destroyBufferObject(Handle<HwBufferObject> boh) {
@@ -343,12 +325,19 @@ void WebGPUDriver::destroyTexture(Handle<HwTexture> th) {
 }

 void WebGPUDriver::destroyProgram(Handle<HwProgram> ph) {
+    if (ph) {
+        destructHandle<WGPUProgram>(ph);
+    }
 }

 void WebGPUDriver::destroyRenderTarget(Handle<HwRenderTarget> rth) {
 }

 void WebGPUDriver::destroySwapChain(Handle<HwSwapChain> sch) {
+    if (sch) {
+        destructHandle<WebGPUSwapChain>(sch);
+    }
+    mSwapChain = nullptr;
 }

 void WebGPUDriver::destroyStream(Handle<HwStream> sh) {
@@ -358,13 +347,16 @@ void WebGPUDriver::destroyTimerQuery(Handle<HwTimerQuery> tqh) {
 }

 void WebGPUDriver::destroyDescriptorSetLayout(Handle<HwDescriptorSetLayout> tqh) {
+    if (tqh) {
+        destructHandle<WebGPUDescriptorSetLayout>(tqh);
+    }
 }

 void WebGPUDriver::destroyDescriptorSet(Handle<HwDescriptorSet> tqh) {
 }

 Handle<HwSwapChain> WebGPUDriver::createSwapChainS() noexcept {
-    return Handle<HwSwapChain>((Handle<HwSwapChain>::HandleId) mNextFakeHandle++);
+    return allocHandle<WebGPUSwapChain>();
 }

 Handle<HwSwapChain> WebGPUDriver::createSwapChainHeadlessS() noexcept {
@@ -372,7 +364,7 @@ Handle<HwSwapChain> WebGPUDriver::createSwapChainHeadlessS() noexcept {
 }

 Handle<HwTexture> WebGPUDriver::createTextureS() noexcept {
-    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUTexture>();
 }

 Handle<HwTexture> WebGPUDriver::importTextureS() noexcept {
@@ -380,7 +372,7 @@ Handle<HwTexture> WebGPUDriver::importTextureS() noexcept {
 }

 Handle<HwProgram> WebGPUDriver::createProgramS() noexcept {
-    return Handle<HwProgram>((Handle<HwProgram>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUProgram>();
 }

 Handle<HwFence> WebGPUDriver::createFenceS() noexcept {
@@ -400,15 +392,15 @@ Handle<HwTexture> WebGPUDriver::createTextureViewS() noexcept {
 }

 Handle<HwBufferObject> WebGPUDriver::createBufferObjectS() noexcept {
-    return Handle<HwBufferObject>((Handle<HwBufferObject>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUBufferObject>();
 }

 Handle<HwRenderTarget> WebGPUDriver::createRenderTargetS() noexcept {
-    return Handle<HwRenderTarget>((Handle<HwRenderTarget>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPURenderTarget>();
 }

 Handle<HwVertexBuffer> WebGPUDriver::createVertexBufferS() noexcept {
-    return Handle<HwVertexBuffer>((Handle<HwVertexBuffer>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUVertexBuffer>();
 }

 Handle<HwDescriptorSet> WebGPUDriver::createDescriptorSetS() noexcept {
@@ -416,11 +408,11 @@ Handle<HwDescriptorSet> WebGPUDriver::createDescriptorSetS() noexcept {
 }

 Handle<HwRenderPrimitive> WebGPUDriver::createRenderPrimitiveS() noexcept {
-    return Handle<HwRenderPrimitive>((Handle<HwRenderPrimitive>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPURenderPrimitive>();
 }

 Handle<HwVertexBufferInfo> WebGPUDriver::createVertexBufferInfoS() noexcept {
-    return Handle<HwVertexBufferInfo>((Handle<HwVertexBufferInfo>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUVertexBufferInfo>();
 }

 Handle<HwTexture> WebGPUDriver::createTextureViewSwizzleS() noexcept {
@@ -428,12 +420,11 @@ Handle<HwTexture> WebGPUDriver::createTextureViewSwizzleS() noexcept {
 }

 Handle<HwRenderTarget> WebGPUDriver::createDefaultRenderTargetS() noexcept {
-    return Handle<HwRenderTarget>((Handle<HwRenderTarget>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPURenderTarget>();
 }

 Handle<HwDescriptorSetLayout> WebGPUDriver::createDescriptorSetLayoutS() noexcept {
-    return Handle<HwDescriptorSetLayout>(
-            (Handle<HwDescriptorSetLayout>::HandleId) mNextFakeHandle++);
+    return allocHandle<WebGPUDescriptorSetLayout>();
 }

 Handle<HwTexture> WebGPUDriver::createTextureExternalImageS() noexcept {
@@ -449,25 +440,15 @@ Handle<HwTexture> WebGPUDriver::createTextureExternalImagePlaneS() noexcept {
 }

 void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow, uint64_t flags) {
-    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
+    mNativeWindow = nativeWindow;
+    assert_invariant(!mSwapChain);
+    wgpu::Surface surface = mPlatform.createSurface(nativeWindow, flags);
+
    mQueue = mDevice.GetQueue();
-    // TODO configure the surface (maybe before or after creating the swapchain?
-    //                             how do we get the surface extent?)
-    // TODO actually create the swapchain
+    wgpu::Extent2D surfaceSize = mPlatform.getSurfaceExtent(mNativeWindow);
+    mSwapChain = constructHandle<WebGPUSwapChain>(sch, std::move(surface), surfaceSize, mAdapter,
+            mDevice, flags);
+    assert_invariant(mSwapChain);
    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."
@@ -527,9 +508,15 @@ void WebGPUDriver::importTextureR(Handle<HwTexture> th, intptr_t id, SamplerType
 void WebGPUDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph, Handle<HwVertexBuffer> vbh,
        Handle<HwIndexBuffer> ibh, PrimitiveType pt) {}

-void WebGPUDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {}
+void WebGPUDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {
+    constructHandle<WGPUProgram>(ph, mDevice, program);
+}

-void WebGPUDriver::createDefaultRenderTargetR(Handle<HwRenderTarget> rth, int) {}
+void WebGPUDriver::createDefaultRenderTargetR(Handle<HwRenderTarget> rth, int) {
+    assert_invariant(!mDefaultRenderTarget);
+    mDefaultRenderTarget = constructHandle<WGPURenderTarget>(rth);
+    assert_invariant(mDefaultRenderTarget);
+}

 void WebGPUDriver::createRenderTargetR(Handle<HwRenderTarget> rth, TargetBufferFlags targets,
        uint32_t width, uint32_t height, uint8_t samples, uint8_t layerCount, MRT color,
@@ -540,7 +527,9 @@ void WebGPUDriver::createFenceR(Handle<HwFence> fh, int) {}
 void WebGPUDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {}

 void WebGPUDriver::createDescriptorSetLayoutR(Handle<HwDescriptorSetLayout> dslh,
-        backend::DescriptorSetLayout&& info) {}
+        backend::DescriptorSetLayout&& info) {
+    constructHandle<WebGPUDescriptorSetLayout>(dslh, std::move(info), mDevice);
+}

 void WebGPUDriver::createDescriptorSetR(Handle<HwDescriptorSet> dsh,
        Handle<HwDescriptorSetLayout> dslh) {}
@@ -690,6 +679,10 @@ void WebGPUDriver::resetBufferObject(Handle<HwBufferObject> boh) {

 void WebGPUDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh, uint32_t index,
        Handle<HwBufferObject> boh) {
+    auto* vertexBuffer = handleCast<WGPUVertexBuffer>(vbh);
+    auto* bufferObject = handleCast<WGPUBufferObject>(boh);
+    assert_invariant(index < vertexBuffer->buffers.size());
+    vertexBuffer->setBuffer(bufferObject, index);
 }

 void WebGPUDriver::update3DImage(Handle<HwTexture> th,
@@ -722,18 +715,71 @@ void WebGPUDriver::compilePrograms(CompilerPriorityQueue priority,
 }

 void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassParams& params) {
+    wgpu::CommandEncoderDescriptor commandEncoderDescriptor = {
+        .label = "command_encoder"
+    };
+    mCommandEncoder = mDevice.CreateCommandEncoder(&commandEncoderDescriptor);
+    assert_invariant(mCommandEncoder);
+    // TODO: Remove this code once WebGPU pipeline is implemented
+    static float red = 1.0f;
+    if (red - 0.01 > 0) {
+        red -= 0.01;
+    } else {
+        red = 1.0f;
+    }
+    assert_invariant(mTextureView);
+    wgpu::RenderPassColorAttachment renderPassColorAttachment = {
+        .view = mTextureView,
+        // TODO: remove this code once WebGPU Pipeline is implemented with render targets, pipeline and buffers.
+        .depthSlice = wgpu::kDepthSliceUndefined,
+        .loadOp = wgpu::LoadOp::Clear,
+        .storeOp = wgpu::StoreOp::Store,
+        .clearValue = wgpu::Color{red, 0 , 0 , 1},
+    };
+
+    wgpu::RenderPassDescriptor renderPassDescriptor = {
+        .colorAttachmentCount = 1,
+        .colorAttachments = &renderPassColorAttachment,
+        .depthStencilAttachment = nullptr,
+        .timestampWrites = nullptr,
+    };
+
+    mRenderPassEncoder = mCommandEncoder.BeginRenderPass(&renderPassDescriptor);
+    mRenderPassEncoder.SetViewport(params.viewport.left, params.viewport.bottom,
+            params.viewport.width, params.viewport.height, params.depthRange.near, params.depthRange.far);
 }

 void WebGPUDriver::endRenderPass(int) {
+    mRenderPassEncoder.End();
+    mRenderPassEncoder = nullptr;
+    wgpu::CommandBufferDescriptor commandBufferDescriptor {
+        .label = "command_buffer",
+    };
+    mCommandBuffer = mCommandEncoder.Finish(&commandBufferDescriptor);
+    assert_invariant(mCommandBuffer);
 }

 void WebGPUDriver::nextSubpass(int) {
 }

 void WebGPUDriver::makeCurrent(Handle<HwSwapChain> drawSch, Handle<HwSwapChain> readSch) {
+    ASSERT_PRECONDITION_NON_FATAL(drawSch == readSch,
+            "WebGPU driver does not support distinct draw/read swap chains.");
+    auto* swapChain = handleCast<WebGPUSwapChain>(drawSch);
+    mSwapChain = swapChain;
+    assert_invariant(mSwapChain);
+    wgpu::Extent2D surfaceSize = mPlatform.getSurfaceExtent(mNativeWindow);
+    mTextureView = mSwapChain->getCurrentSurfaceTextureView(surfaceSize);
+    assert_invariant(mTextureView);
 }

 void WebGPUDriver::commit(Handle<HwSwapChain> sch) {
+    mCommandEncoder = nullptr;
+    mQueue.Submit(1, &mCommandBuffer);
+    mCommandBuffer = nullptr;
+    mTextureView = nullptr;
+    assert_invariant(mSwapChain);
+    mSwapChain->present();
 }

 void WebGPUDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
@@ -761,7 +807,7 @@ void WebGPUDriver::readPixels(Handle<HwRenderTarget> src,
    scheduleDestroy(std::move(p));
 }

-void WebGPUDriver::readBufferSubData(backend::BufferObjectHandle boh,
+void WebGPUDriver::readBufferSubData(Handle<HwBufferObject> boh,
        uint32_t offset, uint32_t size, backend::BufferDescriptor&& p) {
    scheduleDestroy(std::move(p));
 }
@@ -813,22 +859,22 @@ void WebGPUDriver::resetState(int) {
 }

 void WebGPUDriver::updateDescriptorSetBuffer(
-        backend::DescriptorSetHandle dsh,
+        Handle<HwDescriptorSet> dsh,
        backend::descriptor_binding_t binding,
-        backend::BufferObjectHandle boh,
+        Handle<HwBufferObject> boh,
        uint32_t offset,
        uint32_t size) {
 }

 void WebGPUDriver::updateDescriptorSetTexture(
-        backend::DescriptorSetHandle dsh,
+        Handle<HwDescriptorSet> dsh,
        backend::descriptor_binding_t binding,
-        backend::TextureHandle th,
+        Handle<HwTexture> th,
        SamplerParams params) {
 }

 void WebGPUDriver::bindDescriptorSet(
-        backend::DescriptorSetHandle dsh,
+        Handle<HwDescriptorSet> dsh,
        backend::descriptor_set_t set,
        backend::DescriptorSetOffsetArray&& offsets) {
 }
@@ -17,6 +17,7 @@
 #ifndef TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H
 #define TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H

+#include "WebGPUHandles.h"
 #include <backend/platforms/WebGPUPlatform.h>

 #include "DriverBase.h"
@@ -30,6 +31,7 @@
 #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
@@ -37,6 +39,8 @@

 namespace filament::backend {

+class WebGPUSwapChain;
+
 /**
 * WebGPU backend (driver) implementation
 */
@@ -55,16 +59,20 @@ private:
    // 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;
+    void* mNativeWindow = nullptr;
+    WebGPUSwapChain* mSwapChain = nullptr;
    uint64_t mNextFakeHandle = 1;
-
+    wgpu::CommandEncoder mCommandEncoder = nullptr;
+    wgpu::TextureView mTextureView = nullptr;
+    wgpu::RenderPassEncoder mRenderPassEncoder = nullptr;
+    wgpu::CommandBuffer mCommandBuffer = nullptr;
+    WGPURenderTarget* mDefaultRenderTarget = nullptr;
    /*
     * Driver interface
     */
-
    template<typename T>
    friend class ConcreteDispatcher;

@@ -91,6 +99,21 @@ private:
        return mHandleAllocator.allocate<D>();
    }

+    template<typename D, typename B, typename ... ARGS>
+    D* constructHandle(Handle<B>& handle, ARGS&& ... args) noexcept {
+        return mHandleAllocator.construct<D>(handle, std::forward<ARGS>(args)...);
+    }
+
+    template<typename D, typename B>
+    D* handleCast(Handle<B> handle) noexcept {
+        return mHandleAllocator.handle_cast<D*>(handle);
+    }
+
+    template<typename D, typename B>
+    void destructHandle(Handle<B>& handle) noexcept {
+        auto* p = mHandleAllocator.handle_cast<D*>(handle);
+        return mHandleAllocator.deallocate(handle, p);
+    }
 };

 }// namespace filament::backend
@@ -0,0 +1,152 @@
+/*
+* 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 "WebGPUHandles.h"
+
+#include <utility>
+
+namespace {
+
+wgpu::Buffer createIndexBuffer(wgpu::Device const& device, uint8_t elementSize, uint32_t indexCount) {
+    wgpu::BufferDescriptor descriptor{ .label = "index_buffer",
+        .usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Index,
+        .size = elementSize * indexCount,
+        .mappedAtCreation = false };
+    return device.CreateBuffer(&descriptor);
+}
+} // namespace
+
+namespace filament::backend {
+
+
+WGPUIndexBuffer::WGPUIndexBuffer(wgpu::Device const& device, uint8_t elementSize,
+        uint32_t indexCount)
+    : buffer(createIndexBuffer(device, elementSize, indexCount)) {}
+
+
+WGPUVertexBuffer::WGPUVertexBuffer(wgpu::Device const &device, uint32_t vextexCount, uint32_t bufferCount,
+                                   Handle<WGPUVertexBufferInfo> vbih)
+        : HwVertexBuffer(vextexCount),
+          vbih(vbih),
+          buffers(bufferCount) {
+    wgpu::BufferDescriptor descriptor {
+            .usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Vertex,
+            .size = vextexCount * bufferCount,
+            .mappedAtCreation = false };
+
+    for (uint32_t i = 0; i < bufferCount; ++i) {
+        descriptor.label = ("vertex_buffer_" + std::to_string(i)).c_str();
+        buffers[i] = device.CreateBuffer(&descriptor);
+    }
+}
+
+// TODO: Empty function is a place holder for verxtex buffer updates and should be
+// updated for that purpose.
+void WGPUVertexBuffer::setBuffer(WGPUBufferObject* bufferObject, uint32_t index) {}
+
+WGPUBufferObject::WGPUBufferObject(BufferObjectBinding bindingType, uint32_t byteCount)
+    : HwBufferObject(byteCount),
+      bufferObjectBinding(bindingType) {}
+
+wgpu::ShaderStage WebGPUDescriptorSetLayout::filamentStageToWGPUStage(ShaderStageFlags fFlags) {
+    wgpu::ShaderStage retStages = wgpu::ShaderStage::None;
+    if (any(ShaderStageFlags::VERTEX & fFlags)) {
+        retStages |= wgpu::ShaderStage::Vertex;
+    }
+    if (any(ShaderStageFlags::FRAGMENT & fFlags)) {
+        retStages |= wgpu::ShaderStage::Fragment;
+    }
+    if (any(ShaderStageFlags::COMPUTE & fFlags)) {
+        retStages |= wgpu::ShaderStage::Compute;
+    }
+    return retStages;
+}
+
+WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const& layout,
+        wgpu::Device const& device) {
+    assert_invariant(device);
+
+    // TODO: layoutDescriptor has a "Label". Ideally we can get info on what this layout is for
+    // debugging. For now, hack an incrementing value.
+    static int layoutNum = 0;
+
+    uint samplerCount =
+            std::count_if(layout.bindings.begin(), layout.bindings.end(), [](auto& fEntry) {
+                return fEntry.type == DescriptorType::SAMPLER ||
+                       fEntry.type == DescriptorType::SAMPLER_EXTERNAL;
+            });
+
+
+    std::vector<wgpu::BindGroupLayoutEntry> wEntries;
+    wEntries.reserve(layout.bindings.size() + samplerCount);
+
+    for (auto fEntry: layout.bindings) {
+        auto& wEntry = wEntries.emplace_back();
+        wEntry.visibility = filamentStageToWGPUStage(fEntry.stageFlags);
+        wEntry.binding = fEntry.binding * 2;
+
+        switch (fEntry.type) {
+            // TODO Metal treats these the same. Is this fine?
+            case DescriptorType::SAMPLER_EXTERNAL:
+            case DescriptorType::SAMPLER: {
+                // Sampler binding is 2n+1 due to split.
+                auto& samplerEntry = wEntries.emplace_back();
+                samplerEntry.binding = fEntry.binding * 2 + 1;
+                samplerEntry.visibility = wEntry.visibility;
+                // We are simply hoping that undefined and defaults suffices here.
+                samplerEntry.sampler.type = wgpu::SamplerBindingType::Undefined;
+                wEntry.texture.sampleType = wgpu::TextureSampleType::Undefined;
+                break;
+            }
+            case DescriptorType::UNIFORM_BUFFER: {
+                wEntry.buffer.hasDynamicOffset =
+                        any(fEntry.flags & DescriptorFlags::DYNAMIC_OFFSET);
+                wEntry.buffer.type = wgpu::BufferBindingType::Uniform;
+                // TODO: Ideally we fill minBindingSize
+                break;
+            }
+
+            case DescriptorType::INPUT_ATTACHMENT: {
+                // TODO: support INPUT_ATTACHMENT. Metal does not currently.
+                PANIC_POSTCONDITION("Input Attachment is not supported");
+                break;
+            }
+
+            case DescriptorType::SHADER_STORAGE_BUFFER: {
+                // TODO: Vulkan does not support this, can we?
+                PANIC_POSTCONDITION("Shader storage is not supported");
+                break;
+            }
+        }
+
+        // Currently flags are only used to specify dynamic offset.
+
+        // UNUSED
+        // fEntry.count
+    }
+
+    wgpu::BindGroupLayoutDescriptor layoutDescriptor{
+        // TODO: layoutDescriptor has a "Label". Ideally we can get info on what this layout is for
+        // debugging. For now, hack an incrementing value.
+        .label{ "layout_" + std::to_string(++layoutNum) },
+        .entryCount = wEntries.size(),
+        .entries = wEntries.data()
+    };
+    // TODO Do we need to defer this until we have more info on textures and samplers??
+    mLayout = device.CreateBindGroupLayout(&layoutDescriptor);
+}
+WebGPUDescriptorSetLayout::~WebGPUDescriptorSetLayout() {}
+}// namespace filament::backend
@@ -0,0 +1,167 @@
+/*
+* 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_WEBGPUHANDLES_H
+#define TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H
+
+#include "DriverBase.h"
+
+#include <backend/DriverEnums.h>
+#include <backend/Handle.h>
+
+#include <utils/FixedCapacityVector.h>
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <cstdint>
+#include <vector>
+
+namespace filament::backend {
+
+class WGPUProgram final : public HwProgram {
+public:
+    WGPUProgram(wgpu::Device&, Program&);
+
+    wgpu::ShaderModule vertexShaderModule = nullptr;
+    wgpu::ShaderModule fragmentShaderModule = nullptr;
+    wgpu::ShaderModule computeShaderModule = nullptr;
+    std::vector<wgpu::ConstantEntry> constants;
+};
+
+struct WGPUBufferObject;
+// TODO: Currently WGPUVertexBufferInfo is not used by WebGPU for useful task.
+// Update the struct when used by WebGPU driver.
+struct WGPUVertexBufferInfo : public HwVertexBufferInfo {
+    WGPUVertexBufferInfo(uint8_t bufferCount, uint8_t attributeCount,
+            AttributeArray const& attributes)
+        : HwVertexBufferInfo(bufferCount, attributeCount),
+          attributes(attributes) {}
+    AttributeArray attributes;
+};
+
+struct WGPUVertexBuffer : public HwVertexBuffer {
+    WGPUVertexBuffer(wgpu::Device const &device, uint32_t vextexCount, uint32_t bufferCount,
+                     Handle<WGPUVertexBufferInfo> vbih);
+
+    void setBuffer(WGPUBufferObject *bufferObject, uint32_t index);
+
+    Handle<WGPUVertexBufferInfo> vbih;
+    utils::FixedCapacityVector<wgpu::Buffer> buffers;
+};
+
+struct WGPUIndexBuffer : public HwIndexBuffer {
+    WGPUIndexBuffer(wgpu::Device const &device, uint8_t elementSize,
+                    uint32_t indexCount);
+
+    wgpu::Buffer buffer;
+};
+
+// TODO: Currently WGPUVertexBufferInfo is not used by WebGPU for useful task.
+// Update the struct when used by WebGPU driver.
+struct WGPUBufferObject : HwBufferObject {
+    WGPUBufferObject(BufferObjectBinding bindingType, uint32_t byteCount);
+
+    wgpu::Buffer buffer;
+    const BufferObjectBinding bufferObjectBinding;
+};
+class WebGPUDescriptorSetLayout : public HwDescriptorSetLayout {
+public:
+    WebGPUDescriptorSetLayout(DescriptorSetLayout const& layout, wgpu::Device const& device);
+    ~WebGPUDescriptorSetLayout();
+
+private:
+    // TODO: If this is useful elsewhere, remove it from this class
+    // Convert Filament Shader Stage Flags bitmask to webgpu equivilant
+    static wgpu::ShaderStage filamentStageToWGPUStage(ShaderStageFlags fFlags);
+
+    wgpu::BindGroupLayout mLayout;
+};
+
+// TODO: Currently WGPUTexture is not used by WebGPU for useful task.
+// Update the struct when used by WebGPU driver.
+struct WGPUTexture : public HwTexture {
+    WGPUTexture(SamplerType target, uint8_t levels, TextureFormat format, uint8_t samples,
+            uint32_t width, uint32_t height, uint32_t depth, TextureUsage usage) noexcept;
+
+    // constructors for creating texture views
+    WGPUTexture(WGPUTexture const* src, uint8_t baseLevel, uint8_t levelCount) noexcept;
+
+    wgpu::Texture texture = nullptr;
+};
+
+struct WGPURenderPrimitive : public HwRenderPrimitive {
+    WGPURenderPrimitive();
+
+    void setBuffers(WGPUVertexBufferInfo const* const vbi,
+            WGPUVertexBuffer* vertexBuffer, WGPUIndexBuffer* indexBuffer);
+
+    WGPUVertexBuffer* vertexBuffer = nullptr;
+    WGPUIndexBuffer* indexBuffer = nullptr;
+};
+
+// TODO: Currently WGPURenderTarget is not used by WebGPU for useful task.
+// Update the struct when used by WebGPU driver.
+struct WGPURenderTarget : public HwRenderTarget {
+    class Attachment {
+    public:
+        friend struct WGPURenderTarget;
+
+        Attachment() = default;
+        Attachment(WGPUTexture* gpuTexture, uint8_t level = 0, uint16_t layer = 0)
+            : level(level),
+              layer(layer),
+              texture(gpuTexture->texture),
+              mWGPUTexture(gpuTexture) {}
+
+        uint8_t level = 0;
+        uint16_t layer = 0;
+
+    private:
+        wgpu::Texture texture = nullptr;
+        WGPUTexture* mWGPUTexture = nullptr;
+    };
+
+    WGPURenderTarget(uint32_t width, uint32_t height, uint8_t samples,
+            Attachment colorAttachments[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT]);
+    WGPURenderTarget()
+        : HwRenderTarget(0, 0),
+          defaultRenderTarget(true) {}
+
+    void setUpRenderPassAttachments(wgpu::RenderPassDescriptor* descriptor,
+            const RenderPassParams& params);
+
+    math::uint2 getAttachmentSize() noexcept;
+
+    bool isDefaultRenderTarget() const { return defaultRenderTarget; }
+    uint8_t getSamples() const { return samples; }
+
+    Attachment getDrawColorAttachment(size_t index);
+    Attachment getReadColorAttachment(size_t index);
+
+private:
+    static wgpu::LoadOp getLoadAction(const RenderPassParams& params, TargetBufferFlags buffer);
+    static wgpu::LoadOp getStoreAction(const RenderPassParams& params, TargetBufferFlags buffer);
+
+    bool defaultRenderTarget = false;
+    uint8_t samples = 1;
+
+    Attachment color[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT] = {};
+    math::uint2 attachmentSize = {};
+};
+
+}// namespace filament::backend
+#endif// TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H
@@ -0,0 +1,276 @@
+/*
+ * 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 const& device,
+        wgpu::SurfaceCapabilities const& capabilities, wgpu::Extent2D const& surfaceSize,
+        bool useSRGBColorSpace) {
+    config.device = device;
+    config.usage = wgpu::TextureUsage::RenderAttachment;
+    config.width = surfaceSize.width;
+    config.height = surfaceSize.height;
+    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::Extent2D const& surfaceSize,
+        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, surfaceSize, useSRGBColorSpace);
+    mSurface.Configure(&mConfig);
+}
+
+WebGPUSwapChain::~WebGPUSwapChain() {
+    mSurface.Unconfigure();
+}
+
+void WebGPUSwapChain::setExtent(wgpu::Extent2D const& currentSurfaceSize) {
+    FILAMENT_CHECK_POSTCONDITION(currentSurfaceSize.width > 0 || currentSurfaceSize.height > 0)
+            << "WebGPUSwapChain::setExtent: Invalid width " << currentSurfaceSize.width
+            << " and/or height " << currentSurfaceSize.height << " requested.";
+    if (mConfig.width != currentSurfaceSize.width || mConfig.height != currentSurfaceSize.height) {
+        mConfig.width = currentSurfaceSize.width;
+        mConfig.height = currentSurfaceSize.height;
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+        printSurfaceConfiguration(mConfig);
+#endif
+        FWGPU_LOGD << "Resizing to width " << mConfig.width << " height " << mConfig.height
+                   << utils::io::endl;
+        // TODO we may need to ensure no surface texture is flight when we do this. some
+        //      synchronization may be necessary
+        mSurface.Configure(&mConfig);
+    }
+}
+
+wgpu::TextureView WebGPUSwapChain::getCurrentSurfaceTextureView(
+        wgpu::Extent2D const& currentSurfaceSize) {
+    setExtent(currentSurfaceSize);
+    wgpu::SurfaceTexture surfaceTexture;
+    mSurface.GetCurrentTexture(&surfaceTexture);
+    if (surfaceTexture.status != wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal) {
+        return nullptr;
+    }
+    // Create a view for this surface texture
+    // TODO: review these initiliazations as webgpu pipeline gets mature
+    wgpu::TextureViewDescriptor textureViewDescriptor = {
+        .label = "texture_view",
+        .format = surfaceTexture.texture.GetFormat(),
+        .dimension = wgpu::TextureViewDimension::e2D,
+        .baseMipLevel = 0,
+        .mipLevelCount = 1,
+        .baseArrayLayer = 0,
+        .arrayLayerCount = 1
+    };
+    return surfaceTexture.texture.CreateView(&textureViewDescriptor);
+}
+
+void WebGPUSwapChain::present() {
+    assert_invariant(mSurface);
+    mSurface.Present();
+}
+
+}// namespace filament::backend
@@ -0,0 +1,48 @@
+/*
+ * 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 "DriverBase.h"
+#include <backend/Platform.h>
+
+#include <cstdint>
+
+namespace filament::backend {
+
+class WebGPUSwapChain final : public Platform::SwapChain, HwSwapChain {
+public:
+    WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Extent2D const& surfaceSize,
+            wgpu::Adapter& adapter, wgpu::Device& device, uint64_t flags);
+    ~WebGPUSwapChain();
+
+    wgpu::TextureView getCurrentSurfaceTextureView(wgpu::Extent2D const&);
+
+    void present();
+
+private:
+    void setExtent(wgpu::Extent2D const&);
+
+    wgpu::Surface mSurface = {};
+    wgpu::SurfaceConfiguration mConfig = {};
+};
+
+} // namespace filament::backend
+
+#endif //TNT_FILAMENT_BACKEND_WEBGPUSWAPCHAIN_H
@@ -18,6 +18,7 @@

 #include <utils/Panic.h>

+#include <android/native_window.h>
 #include <webgpu/webgpu_cpp.h>

 #include <cstdint>
@@ -28,6 +29,14 @@

 namespace filament::backend {

+wgpu::Extent2D WebGPUPlatform::getSurfaceExtent(void* nativeWindow) const {
+    ANativeWindow* window = static_cast<ANativeWindow*>(nativeWindow);
+    return wgpu::Extent2D{
+        .width = static_cast<uint32_t>(ANativeWindow_getWidth(window)),
+        .height = static_cast<uint32_t>(ANativeWindow_getHeight(window))
+    };
+}
+
 wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags*/) {
    wgpu::SurfaceSourceAndroidNativeWindow surfaceSourceAndroidWindow{};
    surfaceSourceAndroidWindow.window = nativeWindow;
@@ -24,21 +24,8 @@
 #include <cstdint>

 // Platform specific includes and defines
-#if defined(__APPLE__)
-    #include <Cocoa/Cocoa.h>
-    #import <QuartzCore/CAMetalLayer.h>
-#elif defined(FILAMENT_IOS)
-    // Metal is not available when building for the iOS simulator on Desktop.
-    #define METAL_AVAILABLE __has_include(<QuartzCore/CAMetalLayer.h>)
-    #if METAL_AVAILABLE
-        #import <Metal/Metal.h>
-        #import <QuartzCore/CAMetalLayer.h>
-    #endif
-    // is this needed?
-    #define METALVIEW_TAG 255
-#else
-    #error Not a supported Apple + WebGPU platform
-#endif
+#include <Cocoa/Cocoa.h>
+#import <QuartzCore/CAMetalLayer.h>

 /**
 * Apple (Mac OS and IOS) specific implementation aspects of the WebGPU backend
@@ -46,14 +33,19 @@

 namespace filament::backend {

+wgpu::Extent2D WebGPUPlatform::getSurfaceExtent(void* nativeWindow) const {
+    // Both IOS and MacOS expects CAMetalLayer.
+    CAMetalLayer* metalLayer = (__bridge CAMetalLayer*) nativeWindow;
+    return wgpu::Extent2D{
+        .width = static_cast<uint32_t>(metalLayer.drawableSize.width),
+        .height = static_cast<uint32_t>(metalLayer.drawableSize.height)
+    };
+}
+
 wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags*/) {
    wgpu::Surface surface = nullptr;
-#if defined(__APPLE__)
-    auto nsView = (__bridge NSView*) nativeWindow;
-    FILAMENT_CHECK_POSTCONDITION(nsView) << "Unable to obtain Metal-backed NSView.";
-    [nsView setWantsLayer:YES];
-    id metalLayer = [CAMetalLayer layer];
-    [nsView setLayer:metalLayer];
+    // Both IOS and MacOS expects CAMetalLayer.
+    CAMetalLayer* metalLayer = (__bridge CAMetalLayer*) nativeWindow;
    wgpu::SurfaceSourceMetalLayer surfaceSourceMetalLayer{};
    surfaceSourceMetalLayer.layer = (__bridge void*) metalLayer;
    wgpu::SurfaceDescriptor surfaceDescriptor = {
@@ -62,19 +54,6 @@ wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags
    };
    surface = mInstance.CreateSurface(&surfaceDescriptor);
    FILAMENT_CHECK_POSTCONDITION(surface != nullptr) << "Unable to create Metal-backed surface.";
-#elif defined(FILAMENT_IOS)
-    CAMetalLayer* metalLayer = (CAMetalLayer*) nativeWindow;
-    wgpu::SurfaceSourceMetalLayer surfaceSourceMetalLayer{};
-    surfaceSourceMetalLayer.layer = (__bridge void*) metalLayer;
-    wgpu::SurfaceDescriptor surfaceDescriptor = {
-        .nextInChain = &surfaceSourceMetalLayer,
-        .label = "metal_surface",
-    };
-    surface = mInstance.CreateSurface(&surfaceDescriptor);
-    FILAMENT_CHECK_POSTCONDITION(surface != nullptr) << "Unable to create Metal-backed surface.";
-#else
-    #error Not a supported Apple + WebGPU platform
-#endif
    return surface;
 }

@@ -79,6 +79,74 @@

 namespace filament::backend {

+wgpu::Extent2D WebGPUPlatform::getSurfaceExtent(void* nativeWindow) const {
+    auto surfaceExtent = wgpu::Extent2D{};
+#if defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
+    wl* ptrval = reinterpret_cast<wl*>(nativeWindow);
+    surfaceExtent.width = ptrval->width;
+    surfaceExtent.height = ptrval->height;
+    FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+            << "Unable to get window size for Linux Wayland-backed surface.";
+#elif defined(LINUX_OR_FREEBSD) && defined(FILAMENT_SUPPORTS_X11)
+    if (g_x11.library == nullptr) {
+        g_x11.library = dlopen(LIBRARY_X11, RTLD_LOCAL | RTLD_NOW);
+        FILAMENT_CHECK_PRECONDITION(g_x11.library) << "Unable to open X11 library.";
+        #if defined(FILAMENT_SUPPORTS_XCB)
+            g_x11.xcbConnect = (XCB_CONNECT) dlsym(g_x11.library, "xcb_connect");
+            int screen = 0;
+            g_x11.connection = g_x11.xcbConnect(nullptr, &screen);
+        #endif
+        #if defined(FILAMENT_SUPPORTS_XLIB)
+            g_x11.openDisplay = (X11_OPEN_DISPLAY) dlsym(g_x11.library, "XOpenDisplay");
+            g_x11.display = g_x11.openDisplay(NULL);
+            FILAMENT_CHECK_PRECONDITION(g_x11.display) << "Unable to open X11 display.";
+        #endif
+    }
+    #if defined(FILAMENT_SUPPORTS_XCB) || defined(FILAMENT_SUPPORTS_XLIB)
+        bool useXcb = false;
+    #endif
+    #if defined(FILAMENT_SUPPORTS_XCB)
+        #if defined(FILAMENT_SUPPORTS_XLIB)
+            useXcb = (SWAP_CHAIN_CONFIG_ENABLE_XCB) != 0;
+        #else
+            useXcb = true;
+        #endif
+        if (useXcb) {
+            const xcb_setup_t* setup = xcb_get_setup(g_x11.connection);
+            xcb_screen_iterator_t screen_iter = xcb_setup_roots_iterator(setup);
+            xcb_screen_t* screen = screen_iter.data;
+            surfaceExtent.width = static_cast<uint32_t>(screen->width_in_pixels);
+            surfaceExtent.height = static_cast<uint32_t>(screen->height_in_pixels);
+            FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+                    << "Unable to get window surface size for Linux (or FreeBSD) "
+                       "XCB-backed surface.";
+        }
+    #endif
+    #if defined(FILAMENT_SUPPORTS_XLIB)
+        if (!useXcb) {
+            int screenNumber = DefaultScreen(g_x11.display);
+            Screen* screen = ScreenOfDisplay(g_x11.display, screenNumber);
+            surfaceExtent.width = static_cast<uint32_t>(WidthOfScreen(screen));
+            surfaceExtent.height = static_cast<uint32_t>(HeightOfScreen(screen));
+            FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+                    << "Unable to get window surface size for Linux (or FreeBSD) "
+                       "XLib-backed surface.";
+        }
+    #endif
+    FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+            << "Cannot get window surface size for X11 surface for Linux (or FreeBSD) OS "
+               "(not built with support for XCB or XLIB?)";
+#elif defined(__linux__)
+    FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+            << "Cannot get window surface size for Linux (or FreeBSD) OS "
+               "(not built with support for Wayland or X11?)";
+#else
+    FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+            << "Not a supported (Linux) OS + WebGPU platform";
+#endif
+    return surfaceExtent;
+}
+
 wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t flags) {
    wgpu::Surface surface = nullptr;
 #if defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
@@ -22,12 +22,24 @@

 #include <cstdint>

+#include <Windows.h>
+
 /**
 * Windows OS specific implementation aspects of the WebGPU backend
 */

 namespace filament::backend {

+wgpu::Extent2D WebGPUPlatform::getSurfaceExtent(void* nativeWindow) const {
+    HWND window = static_cast<HWND>(nativeWindow);
+    RECT windowRect;
+    GetWindowRect(window, &windowRect);
+    return wgpu::Extent2D{
+        .width = static_cast<uint32_t>(windowRect.right - windowRect.left),
+        .height = static_cast<uint32_t>(windowRect.bottom - windowRect.top)
+    };
+}
+
 wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags*/) {
    // TODO verify this is necessary for Dawn implementation as well:
    // On (at least) NVIDIA drivers, the Vulkan implementation (specifically the call to
@@ -41,12 +53,12 @@ wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags
    wgpu::SurfaceSourceWindowsHWND surfaceSourceWin{};
    surfaceSourceWin.hinstance = GetModuleHandle(nullptr);
    surfaceSourceWin.hwnd = nativeWindow;
-    wgpu::SurfaceDescriptor surfaceDescriptor{
+    const wgpu::SurfaceDescriptor surfaceDescriptor{
        .nextInChain = &surfaceSourceWin,
        .label = "windows_surface"
    };
    wgpu::Surface surface = mInstance.CreateSurface(&surfaceDescriptor);
-    FILAMENT_CHECK_POSTCONDITION(surface != nullptr) << "Unable to create Windows-backed surface.";
+    FILAMENT_CHECK_POSTCONDITION(surface.Get() != nullptr) << "Unable to create Windows-backed surface.";
    return surface;
 }

@@ -43,24 +43,29 @@ using namespace image;
 namespace test {

 Backend BackendTest::sBackend = Backend::NOOP;
+OperatingSystem BackendTest::sOperatingSystem = OperatingSystem::OTHER;
 bool BackendTest::sIsMobilePlatform = false;

-void BackendTest::init(Backend backend, bool isMobilePlatform) {
+void BackendTest::init(Backend backend, OperatingSystem operatingSystem, bool isMobilePlatform) {
    sBackend = backend;
+    sOperatingSystem = operatingSystem;
    sIsMobilePlatform = isMobilePlatform;
 }

 BackendTest::BackendTest() : commandBufferQueue(CONFIG_MIN_COMMAND_BUFFERS_SIZE,
        CONFIG_COMMAND_BUFFERS_SIZE, /*mPaused=*/false) {
    initializeDriver();
+    mImageExpectations.emplace(getDriverApi());
 }

 BackendTest::~BackendTest() {
+    // Ensure all graphics commands and callbacks are finished.
+    flushAndWait();
+    mImageExpectations->evaluate();
    // Note: Don't terminate the driver for OpenGL, as it wipes away the context and removes the buffer from the screen.
    if (sBackend == Backend::OPENGL) {
        return;
    }
-    flushAndWait();
    driver->terminate();
    delete driver;
 }
@@ -154,49 +159,16 @@ void BackendTest::renderTriangle(
    api.endRenderPass();
 }

-void BackendTest::readPixelsAndAssertHash(const char* testName, size_t width, size_t height,
-        Handle<HwRenderTarget> rt, uint32_t expectedHash, bool exportScreenshot) {
-    void* buffer = calloc(1, width * height * 4);
+bool BackendTest::matchesEnvironment(Backend backend) {
+    return sBackend == backend;
+}

-    struct Capture {
-        uint32_t expectedHash;
-        char* name;
-        bool exportScreenshot;
-        size_t width, height;
-    };
-    auto* c = new Capture();
-    c->expectedHash = expectedHash;
-    c->name = strdup(testName);
-    c->exportScreenshot = exportScreenshot;
-    c->width = width;
-    c->height = height;
+bool BackendTest::matchesEnvironment(OperatingSystem operatingSystem) {
+    return sOperatingSystem == operatingSystem;
+}

-    PixelBufferDescriptor pbd(buffer, width * height * 4, PixelDataFormat::RGBA, PixelDataType::UBYTE,
-            1, 0, 0, width, [](void* buffer, size_t size, void* user) {
-                auto* c = (Capture*)user;
-
-                // Export a screenshot, if requested.
-                if (c->exportScreenshot) {
-#ifndef FILAMENT_IOS
-                    LinearImage image(c->width, c->height, 4);
-                    image = toLinearWithAlpha<uint8_t>(c->width, c->height, c->width * 4,
-                            (uint8_t*) buffer);
-                    const std::string png = std::string(c->name) + ".png";
-                    std::ofstream outputStream(png.c_str(), std::ios::binary | std::ios::trunc);
-                    ImageEncoder::encode(outputStream, ImageEncoder::Format::PNG, image, "",
-                            png);
-#endif
-                }
-
-                // Hash the contents of the buffer and check that they match.
-                uint32_t hash = utils::hash::murmur3((const uint32_t*) buffer, size / 4, 0);
-                ASSERT_EQ(hash, c->expectedHash) << c->name << " failed: hashes do not match." << std::endl;
-
-                free(buffer);
-                free(c->name);
-                free(c);
-            }, (void*)c);
-    getDriverApi().readPixels(rt, 0, 0, width, height, std::move(pbd));
+bool BackendTest::matchesEnvironment(OperatingSystem operatingSystem, Backend backend) {
+    return matchesEnvironment(operatingSystem) && matchesEnvironment(backend);
 }

 class Environment : public ::testing::Environment {
@@ -210,8 +182,8 @@ public:
    }
 };

-void initTests(Backend backend, bool isMobile, int& argc, char* argv[]) {
-    BackendTest::init(backend, isMobile);
+void initTests(Backend backend, OperatingSystem operatingSystem, bool isMobile, int& argc, char* argv[]) {
+    BackendTest::init(backend, operatingSystem, isMobile);
    ::testing::InitGoogleTest(&argc, argv);
    ::testing::AddGlobalTestEnvironment(new Environment);
 }
@@ -25,15 +25,17 @@
 #include "private/backend/DriverApi.h"

 #include "PlatformRunner.h"
+#include "ImageExpectations.h"

 namespace test {

 class BackendTest : public ::testing::Test {
 public:

-    static void init(Backend backend, bool isMobilePlatform);
+    static void init(Backend backend, OperatingSystem operatingSystem, bool isMobilePlatform);

    static Backend sBackend;
+    static OperatingSystem sOperatingSystem;
    static bool sIsMobilePlatform;

 protected:
@@ -64,13 +66,14 @@ protected:
            filament::backend::Handle<filament::backend::HwProgram> program,
            const filament::backend::RenderPassParams& params);

-    void readPixelsAndAssertHash(const char* testName, size_t width, size_t height,
-            filament::backend::Handle<filament::backend::HwRenderTarget> rt, uint32_t expectedHash,
-            bool exportScreenshot = false);
-
    filament::backend::DriverApi& getDriverApi() { return *commandStream; }
    filament::backend::Driver& getDriver() { return *driver; }

+    ImageExpectations& getExpectations() { return *mImageExpectations; }
+
+    static bool matchesEnvironment(Backend backend);
+    static bool matchesEnvironment(OperatingSystem operatingSystem);
+    static bool matchesEnvironment(OperatingSystem operatingSystem, Backend backend);
 private:

    filament::backend::Driver* driver = nullptr;
@@ -78,6 +81,10 @@ private:
    std::unique_ptr<filament::backend::DriverApi> commandStream;

    filament::backend::Handle<filament::backend::HwBufferObject> uniform;
+
+    // This isn't truly optional, it just needs to delay construction until after the driver has
+    // been initialized
+    std::optional<ImageExpectations> mImageExpectations;
 };

 } // namespace test
@@ -16,7 +16,6 @@

 #include "ImageExpectations.h"

-#include "gtest/gtest.h"
 #include "gmock/gmock.h"
 #include "absl/strings/str_format.h"
 #include "utils/Hash.h"
@@ -28,14 +27,17 @@
 #ifndef FILAMENT_IOS

 #include <imageio/ImageEncoder.h>
+#include <imageio/ImageDecoder.h>
 #include <image/ColorTransform.h>

 #endif

 ScreenshotParams::ScreenshotParams(int width, int height, std::string fileName,
-        uint32_t expectedPixelHash)
-        : mWidth(width), mHeight(height), mFileName(std::move(fileName)),
-          mExpectedPixelHash(expectedPixelHash) {}
+        uint32_t expectedHash)
+    : mWidth(width),
+      mHeight(height),
+      mExpectedPixelHash(expectedHash),
+      mFileName(std::move(fileName)) {}

 int ScreenshotParams::width() const {
    return mWidth;
@@ -49,24 +51,28 @@ uint32_t ScreenshotParams::expectedHash() const {
    return mExpectedPixelHash;
 }

-std::string ScreenshotParams::outputDirectoryPath() const {
-    return ".";
+std::string ScreenshotParams::actualDirectoryPath() {
+    return "images/actual_images";
 }

-std::string ScreenshotParams::generatedActualFileName() const {
+std::string ScreenshotParams::actualFileName() const {
    return absl::StrFormat("%s_actual.png", mFileName);
 }

-std::string ScreenshotParams::generatedActualFilePath() const {
-    return absl::StrFormat("%s/%s", outputDirectoryPath(), generatedActualFileName());
+std::string ScreenshotParams::actualFilePath() const {
+    return absl::StrFormat("%s/%s", actualDirectoryPath(), actualFileName());
 }

-std::string ScreenshotParams::goldenFileName() const {
-    return absl::StrFormat("%s_golden.png", mFileName);
+std::string ScreenshotParams::expectedDirectoryPath() {
+    return "images/expected_images";
 }

-std::string ScreenshotParams::goldenFilePath() const {
-    return absl::StrFormat("%s/%s", outputDirectoryPath(), goldenFileName());
+std::string ScreenshotParams::expectedFileName() const {
+    return absl::StrFormat("%s.png", mFileName);
+}
+
+std::string ScreenshotParams::expectedFilePath() const {
+    return absl::StrFormat("%s/%s", expectedDirectoryPath(), expectedFileName());
 }

 ImageExpectation::ImageExpectation(const char* fileName, int lineNumber,
@@ -91,11 +97,22 @@ void ImageExpectation::evaluate() {

 void ImageExpectation::compareImage() const {
    bool bytesFilled = mResult.bytesFilled();
+    // If this fails, it likely means that BackendTest::flushAndWait needs to be called before
+    // ImageExpectations is evaluated or destroyed.
    EXPECT_THAT(bytesFilled, testing::IsTrue())
                        << "Render target wasn't copied to the buffer for " << mFileName;
    if (bytesFilled) {
+        // Rather than directly compare the two images compare their hashes because comparing very
+        // large arrays generates way too much debug output to be useful.
        uint32_t actualHash = mResult.hash();
-        EXPECT_THAT(actualHash, testing::Eq(mParams.expectedHash()));
+#ifndef FILAMENT_IOS
+        LoadedPng loadedImage(mParams.expectedFilePath());
+        uint32_t loadedImageHash = loadedImage.hash();
+        EXPECT_THAT(actualHash, testing::Eq(loadedImageHash)) << mParams.expectedFileName();
+#endif
+        // For builds that can't load PNGs (currently iOS only) use the expected hash.
+        EXPECT_THAT(actualHash, testing::Eq(mParams.expectedHash())) << mParams.expectedFileName();
+        // TODO: Add better debug output, such as generating a diff image.
    }
 }

@@ -109,12 +126,13 @@ ImageExpectations::~ImageExpectations() {

 void ImageExpectations::addExpectation(const char* fileName, int lineNumber,
        filament::backend::RenderTargetHandle renderTarget, ScreenshotParams params) {
-    mExpectations.emplace_back(fileName, lineNumber, mApi, std::move(params), renderTarget);
+    mExpectations.emplace_back(std::make_unique<ImageExpectation>(fileName, lineNumber, mApi,
+            std::move(params), renderTarget));
 }

 void ImageExpectations::evaluate() {
    for (auto& expectation: mExpectations) {
-        expectation.evaluate();
+        expectation->evaluate();
    }
    mExpectations.clear();
 }
@@ -122,32 +140,28 @@ void ImageExpectations::evaluate() {
 RenderTargetDump::RenderTargetDump(filament::backend::DriverApi& api,
        filament::backend::RenderTargetHandle renderTarget, const ScreenshotParams& params)
        : mInternal(std::make_unique<RenderTargetDump::Internal>(params)) {
-#ifdef FILAMENT_IOS
-    bytesFilled_ = true;
-    bytes_.resize(size);
-    std::fill(bytes_.begin(), bytes_.end(), 0);
-#else
    const size_t size = mInternal->params.width() * mInternal->params.height() * 4;
    mInternal->bytes.resize(size);

    auto cb = [](void* buffer, size_t size, void* user) {
        auto* internal = static_cast<RenderTargetDump::Internal*>(user);
+        internal->bytesFilled = true;
+#ifndef FILAMENT_IOS
        image::LinearImage image(internal->params.width(), internal->params.width(), 4);
        image = image::toLinearWithAlpha<uint8_t>(internal->params.width(),
                internal->params.height(),
                internal->params.width() * 4, (uint8_t*)buffer);
-        std::string filePath = internal->params.generatedActualFilePath();
+        std::string filePath = internal->params.actualFilePath();
        std::ofstream pngStream(filePath, std::ios::binary | std::ios::trunc);
        image::ImageEncoder::encode(pngStream, image::ImageEncoder::Format::PNG, image, "",
                filePath);
-        internal->bytesFilled = true;
+#endif
    };
    filament::backend::PixelBufferDescriptor pb(mInternal->bytes.data(), size,
            filament::backend::PixelDataFormat::RGBA, filament::backend::PixelDataType::UBYTE, cb,
            (void*)mInternal.get());
    api.readPixels(renderTarget, 0, 0, mInternal->params.width(), mInternal->params.height(),
            std::move(pb));
-#endif
 }

 RenderTargetDump::~RenderTargetDump() {
@@ -169,4 +183,30 @@ bool RenderTargetDump::bytesFilled() const {
    return mInternal->bytesFilled;
 }

-RenderTargetDump::Internal::Internal(const ScreenshotParams& params) : params(params) {}
+RenderTargetDump::Internal::Internal(const ScreenshotParams& params) : params(params) {}
+
+LoadedPng::LoadedPng(std::string filePath) : mFilePath(std::move(filePath)) {
+#ifndef FILAMENT_IOS
+    std::ifstream pngStream(mFilePath, std::ios::binary);
+    image::LinearImage loadedImage = image::ImageDecoder::decode(pngStream, filePath,
+            image::ImageDecoder::ColorSpace::LINEAR);
+    size_t valuesInImage = loadedImage.getWidth() * loadedImage.getHeight() *
+                          loadedImage.getChannels();
+    // The linear image is loaded with each component as [0.0, 1.0] but should be [0, 255], so
+    // convert them.
+    mBytes = std::vector<unsigned char>(valuesInImage);
+    for (int i = 0; i < valuesInImage; ++i) {
+        mBytes[i] = static_cast<uint8_t>(loadedImage.get<float>()[i] * 255.0f);
+    }
+#endif
+    // For platforms that don't support the image loading library, leave the loaded data blank.
+}
+
+uint32_t LoadedPng::hash() const {
+    EXPECT_THAT(mBytes, testing::Not(testing::IsEmpty()))
+            << "Failed to load expected test result: " << mFilePath;
+    if (mBytes.empty()) {
+        return 0;
+    }
+    return utils::hash::murmur3((uint32_t*)mBytes.data(), mBytes.size() / 4, 0);
+}
@@ -46,11 +46,12 @@ public:
    int height() const;
    uint32_t expectedHash() const;

-    std::string outputDirectoryPath() const;
-    std::string generatedActualFileName() const;
-    std::string generatedActualFilePath() const;
-    std::string goldenFileName() const;
-    std::string goldenFilePath() const;
+    static std::string actualDirectoryPath();
+    std::string actualFileName() const;
+    std::string actualFilePath() const;
+    static std::string expectedDirectoryPath();
+    std::string expectedFileName() const;
+    std::string expectedFilePath() const;

 private:
    int mWidth;
@@ -98,6 +99,17 @@ private:
    std::unique_ptr<Internal> mInternal;
 };

+class LoadedPng {
+public:
+    explicit LoadedPng(std::string filePath);
+
+    uint32_t hash() const;
+
+private:
+    std::string mFilePath;
+    std::vector<unsigned char> mBytes;
+};
+
 class ImageExpectation {
 public:
    ImageExpectation(const char* fileName, int lineNumber, filament::backend::DriverApi& api,
@@ -130,7 +142,8 @@ public:

 private:
    filament::backend::DriverApi& mApi;
-    std::vector<ImageExpectation> mExpectations;
+    // Store expectations in unique pointers because they are self referential.
+    std::vector<std::unique_ptr<ImageExpectation>> mExpectations;
 };

 #endif //TNT_IMAGE_EXPECTATIONS_H
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2019 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 "PlatformRunner.h"
+
+namespace utils {
+
+template<>
+CString to_string<test::Backend>(test::Backend backend) noexcept {
+    switch (backend) {
+        case test::Backend::OPENGL: {
+            return "OpenGL";
+        }
+        case test::Backend::VULKAN: {
+            return "Vulkan";
+        }
+        case test::Backend::METAL: {
+            return "Metal";
+        }
+        case test::Backend::WEBGPU: {
+            return "WebGPU";
+        }
+        case test::Backend::NOOP:
+        default: {
+            return "No-op";
+        }
+    }
+}
+
+template<>
+CString to_string(test::OperatingSystem os) noexcept {
+    switch (os) {
+        case test::OperatingSystem::LINUX: {
+            return "Linux";
+        }
+        case test::OperatingSystem::APPLE: {
+            return "Apple";
+        }
+        case test::OperatingSystem::OTHER:
+        default: {
+            return "Other";
+        }
+    }
+}
+
+} // namespace utils
+
@@ -19,6 +19,7 @@

 #include <stdint.h>
 #include <stddef.h>
+#include "utils/CString.h"

 namespace test {

@@ -34,6 +35,15 @@ enum class Backend : uint8_t {
    NOOP = 5,
 };

+enum class OperatingSystem: uint8_t {
+    OTHER = 1,
+    // Also represents android phones.
+    LINUX = 2,
+    // Also represents iOS phones.
+    APPLE = 3,
+    // TODO: When tests support windows add it here.
+};
+
 struct NativeView {
    void* ptr = nullptr;
    size_t width = 0, height = 0;
@@ -51,9 +61,10 @@ NativeView getNativeView();
 * No tests will be run yet.
 *
 * @param backend The backend to run the tests on.
+ * @param operatingSystem The operating system the tests are being run on.
 * @param isMobile True if the platform is a mobile platform (iOS or Android).
 */
-void initTests(Backend backend, bool isMobile, int& argc, char* argv[]);
+void initTests(Backend backend, OperatingSystem operatingSystem, bool isMobile, int& argc, char* argv[]);

 /**
 * Test runners should call runTests when they are ready for tests to be run.
@@ -68,6 +79,6 @@ int runTests();
 */
 Backend parseArgumentsForBackend(int argc, char* argv[]);

-}
+} // namespace test

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

 using namespace filament::backend;

-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 };
-    };
+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 };
+    }

+    // 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;
-    for (unsigned char i = 0; i < config.uniformNames.size(); ++i) {
-        descriptors[i + 1] = {{ config.uniformNames[i], kLayouts[i], {}}};
+    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 };
    }
    ShaderGenerator shaderGen(
            std::move(config.vertexShader), std::move(config.fragmentShader), BackendTest::sBackend,
            BackendTest::sIsMobilePlatform, std::move(descriptors));
    Program prog = shaderGen.getProgram(api);
-    for (unsigned char i = 0; i < config.uniformNames.size(); ++i) {
-        prog.descriptorBindings(1, {{ config.uniformNames[i], DescriptorType::UNIFORM_BUFFER, i }});
+
+    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 };
    }
+    prog.descriptorBindings(1, bindingsInfo);
    mProgram = cleanup.add(api.createProgram(std::move(prog)));

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

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

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

-filament::backend::DescriptorSetHandle Shader::getDescriptorSet() const {
-    return mDescriptorSet;
-}
-
 } // namespace test
@@ -18,14 +18,22 @@
 #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<utils::CString> uniformNames;
+    std::vector<UniformConfig> uniforms;
 };

 // All values describing a uniform.
@@ -35,6 +43,7 @@ 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.
@@ -46,6 +55,7 @@ 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();
@@ -79,12 +89,14 @@ public:

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

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

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

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

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

 template<typename UniformType>
@@ -0,0 +1,253 @@
+/*
+ * 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
@@ -0,0 +1,50 @@
+/*
+ * 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
@@ -0,0 +1,63 @@
+/*
+ * 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
@@ -0,0 +1,96 @@
+/*
+ * 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 "Skip.h"
+
+#include <sstream>
+
+namespace test {
+
+SkipEnvironment::SkipEnvironment(test::Backend backend) : backend(backend) {}
+SkipEnvironment::SkipEnvironment(test::OperatingSystem os) : os(os) {}
+SkipEnvironment::SkipEnvironment(test::OperatingSystem os, test::Backend backend)
+    : backend(backend),
+      os(os) {}
+
+bool SkipEnvironment::matches() {
+    bool backendMatches = !backend.has_value() || *backend == BackendTest::sBackend;
+    bool osMatches = !os.has_value() || *os == BackendTest::sOperatingSystem;
+    bool isMobileMatches = !isMobile.has_value() || *isMobile == BackendTest::sIsMobilePlatform;
+    return backendMatches && osMatches && isMobileMatches;
+}
+
+std::string SkipEnvironment::describe() {
+    std::stringstream result;
+    if (matches()) {
+        result << "environment matches because " << describe_actual_environment() << ".";
+    } else {
+        result << "environment does not match because " << describe_requirements() << " but "
+               << describe_actual_environment() << ".";
+    }
+    return result.str();
+}
+
+std::string SkipEnvironment::describe_actual_environment() {
+    bool resultWritten = false;
+    std::stringstream reality;
+    if (backend.has_value()) {
+        reality << "backend was " << utils::to_string(BackendTest::sBackend).c_str();
+        resultWritten = true;
+    }
+    if (os.has_value()) {
+        if (resultWritten) {
+            reality << ", and ";
+        }
+        reality << "operating system was "
+                << utils::to_string(BackendTest::sOperatingSystem).c_str();
+        resultWritten = true;
+    }
+    if (isMobile.has_value()) {
+        if (resultWritten) {
+            reality << ", and ";
+        }
+        reality << "device " << (BackendTest::sIsMobilePlatform ? "was" : "was not") << " mobile";
+        resultWritten = true;
+    }
+    return reality.str();
+}
+
+std::string SkipEnvironment::describe_requirements() {
+    bool resultWritten = false;
+    std::stringstream requirement;
+    if (backend.has_value()) {
+        requirement << "backend needs to be " << utils::to_string(*backend).c_str();
+        resultWritten = true;
+    }
+    if (os.has_value()) {
+        if (resultWritten) {
+            requirement << ", and ";
+        }
+        requirement << "operating system needs to be " << utils::to_string(*os).c_str();
+        resultWritten = true;
+    }
+    if (isMobile.has_value() && BackendTest::sIsMobilePlatform != isMobile) {
+        if (resultWritten) {
+            requirement << ", and ";
+        }
+        requirement << "device needs to " << (*isMobile ? "be" : "not be") << " mobile";
+        resultWritten = true;
+    }
+    return requirement.str();
+}
+
+} // namespace test
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TNT_SKIP_H
+#define TNT_SKIP_H
+
+#include <gtest/gtest.h>
+#include "BackendTest.h"
+
+// skipEnvironment must be a test::SkipEnvironment
+#define SKIP_IF(skipEnvironment)                                                                   \
+do {                                                                                               \
+    SkipEnvironment skip(skipEnvironment);                                                         \
+    if (skip.matches()) {                                                                          \
+        GTEST_SKIP() << "Skipping test as the " << skip.describe();                                \
+    }                                                                                              \
+} while (false)
+
+namespace test {
+
+struct SkipEnvironment {
+    SkipEnvironment(const SkipEnvironment&) = default;
+    explicit SkipEnvironment(test::Backend backend);
+    explicit SkipEnvironment(test::OperatingSystem os);
+    SkipEnvironment(test::OperatingSystem os, test::Backend backend);
+
+    std::optional<test::Backend> backend;
+    std::optional<test::OperatingSystem> os;
+    std::optional<bool> isMobile;
+
+    bool matches();
+    // Describes the current state of either matching or mismatching.
+    std::string describe();
+    // Describe all the non-null requirements.
+    std::string describe_requirements();
+    // Describes the environment's status for all the attributes that are non-null.
+    std::string describe_actual_environment();
+};
+
+} // namespace test
+
+#endif// TNT_SKIP_H
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
bridgewaterrobbie	9a74936103	Update Gitignore to ignore generated files.	2025-04-22 14:23:31 -04:00
Powei Feng	7967157fbb	renderdiff: fix breakage (#8648 ) - Re-enable renderdiff test. - Cache the mesa directory so that we're not spending time pulling and compiling it. - Move python prereqs into the script and use venv.	2025-04-22 18:23:05 +00:00
Andy Hovingh	597ced13e1	webgpu: initial shader compilation	2025-04-22 12:56:03 -05:00
Sungun Park	c3542b135e	Fix crash for ShaderCompilerService (#8626 ) This change fixes a crash that occurs in ShaderCompilerService under a certain condition described below. Functions are called in the order described below. 1. `ShaderCompilerService::initialize(...)` is called when a new gl program is created. There are cases whre the corresponding TickOp may be still alive at the end of this method. 2. `OpenGLProgram::~OpenGLProgram()` is called when the program is immediately destroyed without being used. This deletes gl.program. 3. `ShaderCompilerService::tick()` is called later, and it references the dangling gl object `gl.program` in the lambda function, and it crashes. This change also includes refactoring the class `ShaderCompilerService` to make code simpler and less error-prone. TEST = Tested on Desktop, Android, and Web by running sample apps BUGS = [394319326, 407090622]	2025-04-22 17:31:40 +00:00
Mathias Agopian	ca3ff7e08e	Use the Perfetto SDK instead of ATRACE Perfetto has significantly less overhead. The User facing API is mostly unchanged: Here are the differences: - SYSTRACE_ENABLE() does nothing on ANDROID, initializes systraces on darwin. - SYSTRACE_DISABLE() is removed. - A new "gltfio" tag is added. - SYSTRACE_TAG must be defined before including `utils/Systrace.h` - `utils/Systrace.h` should not be used from a public header - the new SYSTRACE_TAG_DISABLE disables systrace at compile time For android a data source MUST be created in the perfetto config: ``` data_sources { config { name: "track_event" track_event_config { enabled_categories: ["filament", "jobsystem", "gltfio"] disabled_categories: "*" } } } ``` This can for example be added to AGI's custom/advanced config. FIXES=[407572663]	2025-04-22 09:31:29 -07:00
Mathias Agopian	42c760a92f	add the Perfetto SDK to libutils for android NDK projects we also need to add it to the dependent libraries.	2025-04-22 09:31:29 -07:00
Mathias Agopian	327a537bcc	Add the Perfetto SDK to the build	2025-04-22 09:31:29 -07:00
Matthew Hoffman	cfc4f34c18	Use EXPECT_IMAGE in all backend tests. (#8628 )	2025-04-21 19:57:40 -05:00
Sungun Park	6dac384bd9	Release Filament 1.59.3	2025-04-21 22:05:28 +00:00
rafadevai	d666f8a0ba	VK: Create and use a VkPipelineCache (#8631 ) To minimize the cost to recreated old pipelines that has been evicted from VulkanPipelineCache, make the driver cache the pipeline objects.	2025-04-21 18:14:58 +00:00
Matthew Hoffman	d6ae3a57b5	Replace backend test expected hash with loading the image. (#8622 ) BUGS=[402474473]	2025-04-18 15:59:01 -05:00
Powei Feng	c2155f3f98	github: disable renderdiff (#8640 ) The test is broken. Disable while investigating.	2025-04-18 11:10:10 -07:00
bridgewaterrobbie	e2a3637413	webgpu: Avoid using handle 'using' redefines for consistency	2025-04-18 11:42:10 -04:00
bridgewaterrobbie	390df4e42c	Tweak constructor of WebGPUDescriptorSetLayout to take a ref rather than a pointer	2025-04-18 11:04:24 -04:00
Powei Feng	21dd1319df	Release Filament 1.59.2	2025-04-16 15:47:19 -07:00
bridgewaterrobbie	444ac8d6a6	Handle WebGPUDescriptorSetLayout creation	2025-04-15 18:51:26 -04:00
Syed Idris Shah	aac1e7dc4c	Move adapter and device creation to the begining	2025-04-15 18:51:26 -04:00
Matthew Hoffman	5b8a1e5e58	Add a macro for skipping tests based on backend/OS. (#8602 ) BUGS=[398198557]	2025-04-15 17:03:48 -05:00
Andy Hovingh	ad1b36d2b3	fix: DEBUG_COMMAND_STREAM could not be compiled as true due to lack of BufferObjectStreamDescriptor insertion operator	2025-04-14 16:50:53 -05:00
Sungun Park	315c2c273f	Cleanup shader compiler (#8613 ) There's no functional difference.	2025-04-14 18:27:52 +00:00
Juan Caldas	005d835dbe	wgpu: Add Vertex and Index Buffer (#8616 ) * implement vertex and index buffers	2025-04-14 10:36:14 -04:00
Jeremy Nelson	cade94ab2c	webgpu: surface window size for swapchain/surface	2025-04-11 17:30:08 -05:00
Max Rebuschatis	5cd2f5626c	Fix bug in FMaterialInstance::setParameterImpl() where mTextureParameters was not updated when a texture was reassigned if !texture->textureHandleCanMutate(). This could cause a crash in FMaterialInstance::commit() since the old texture binding was still in mTextureParameters but may have been destroyed.	2025-04-11 12:51:46 -07:00
Jeremy Nelson	94bbcbf1c3	wgpu: combine swapchain classes	2025-04-10 09:20:12 -05:00
Andy Hovingh	52c998d2b6	webgpu: use handle allocator with swapchain	2025-04-10 07:37:53 -05:00
rafadevai	527d831c15	VK: Reuse renderpasses after swapchain resize (#8601 ) When a swapchain is resized the FBO cache gets resets which includes the framebuffer and renderpass objects. This causes pipelines to be recreated instead of being reused from the previous frames, causing stalls. In the case of renderpasses there's no need to clear these objects, since the state of the renderpass is the same, only their refcount should be adjusted, fixing the issue mentioned above.	2025-04-10 07:08:20 +00:00
Syed Idris Shah	2790f2e64c	Cleanup the dead code from VulkanPlatformApple.mm __APPLE__ is defined for both macos and ios platform. #elif code will never be excuted.	2025-04-09 14:16:11 -04:00
Benjamin Doherty	757640e850	Release Filament 1.59.1	2025-04-09 10:20:51 -07:00
Ben Doherty	9d9abca33a	Validate textures have non-zero dimensions (#8607 )	2025-04-09 10:18:17 -07:00
Syed Idris Shah	bea7a7c73f	Implement basic webgpu driver backend to render a background color Add priliminay implementations of CommandBuffer, RenderColor Attachment, RenderPass encoders and web gpu queue. This is sufficient to render background color on a surface using webgpu api's.	2025-04-08 16:28:26 -04:00
Syed Idris Shah	dd62f98784	Treat native Window as CAMetalLayer Attach MetalLayer to Native View same as vulkan and metal backend. This change assumes native window is already a CAMetalLayer. This is no different for IOS and Mac.	2025-04-08 16:28:26 -04:00
Syed Idris Shah	395a3eda9b	Introduce basic HandleAllocator for webgpu Implement stub implementations for different handles. This is a place holder patch. These handles will be enhanced and used by webgpu driver for backend implementations.	2025-04-08 16:28:26 -04:00
Syed Idris Shah	9d18cc35e0	Fix webgpu android build after dawn update	2025-04-08 14:58:59 -04:00
Andy Hovingh	2e37ebe70c	webgpu: compile WGSL shaders into Android materials when needed	2025-04-08 13:13:21 -05:00
Matthew Hoffman	63ef412be1	Shared shader helpers for backend tests. (#8562 )	2025-04-08 12:45:59 -05:00
rafadevai	f0996296c1	VK: Remove explicitImageReadyWait callback (#8603 ) This function was created to make sure the swapchain image was available before submitting the work to the GPU. So the order of the process looked like \| Acquire \| Begin \| Record \| Wait \| Present \| End \| After this change the expectation is that when the swapchain acquires a new image it will also wait until is actually available from the platform. \| Acquire \| Begin \| Record \| Present \| End \| In the case the image is not available, the expectation is that the acquire will wait until it is and then start processing the frame.	2025-04-08 06:09:49 +00:00
Powei Feng	a60d570b3b	vk: preparing for Ycbcr conversion (#8596 ) - Move utils functions to the right files - Add conversion from vk formats to filament - Refactor how to enable multiview and external sampler in VulkanPlatform - Make VuklanDescriptorSet and VuklanDescriptorSetLayout more general to allow for mutability - Reorder vulkan files in CMakeLists.txt to be sorted in alphabetical order.	2025-04-08 05:50:37 +00:00
Powei Feng	3fdb9f311a	github: add code-correctness presubmit (#8595 )	2025-04-04 15:17:07 -07:00
Andy Hovingh	70f2cda9b6	remove unnecessary third party includes from dawn (Filament already brings them in)	2025-04-03 20:22:28 -04:00
Andy Hovingh	c3e4894d49	fix Mac OS 15.4 compile errors: minor changes to reflect webgpu and tint API changes	2025-04-03 20:22:28 -04:00
Andy Hovingh	a128d9143a	fix Mac OS 15.4 compile errors: ignore clang nullability-extension warnings/errors only for Macs	2025-04-03 20:22:28 -04:00
Andy Hovingh	2cf10999f4	fix Mac OS 15.4 compile errors: upgrade spirv-tools dependency to match dawn (6add4e478f8802d3bbd100120e5ffc6f725ec9fe)	2025-04-03 20:22:28 -04:00
Andy Hovingh	e0e44da185	fix Mac OS 15.4 compile errors: upgrade spirv-headers dependency to match dawn (8e82b7cfeca98baae9a01a53511483da7194f854)	2025-04-03 20:22:28 -04:00
Andy Hovingh	ce62e0ef06	fix Mac OS 15.4 compile errors: upgrade glslang dependency to match dawn (e57f993cff981c8c3ffd38967e030f04d13781a9)	2025-04-03 20:22:28 -04:00
Andy Hovingh	826b885d0e	fix Mac OS 15.4 compile errors: upgrade dawn dependency (chromium/7106 tag/version)	2025-04-03 20:22:28 -04:00
Andy Hovingh	5b9a24edf0	fix Mac OS 15.4 compile errors: upgrade abseil dependency (version Abseil LTS 20250127.1)	2025-04-03 20:22:28 -04:00
Andy Hovingh	b651f63e02	update release notes	2025-04-03 20:22:28 -04:00
Andy Hovingh	c48273df3c	fix Mac OS 15.4 compile errors: invoke printSurfaceConfiguration to avoid an unused error	2025-04-03 20:22:28 -04:00
Andy Hovingh	8397a15914	fix Mac OS 15.4 compile errors: upgrade libpng dependency (v1.6.47)	2025-04-03 20:22:28 -04:00
Andy Hovingh	d76567b4a8	fix Mac OS 15.4 compile errors: upgrade libz dependency (v1.3.1)	2025-04-03 20:22:28 -04:00
Konrad Piascik	ce62b169cb	Fix Windows webGPU build	2025-04-03 14:12:17 -04:00
Powei Feng	9244f8ee21	vk: add YcbcrConversion to VulkanTexture (#8588 ) - Refactor VulkanTextureState and VulkanTexture so that most state fields are consts. - Add a field for VkYcbcrConversion. - Clear the image view cache when YcbcrConversion changes - Make sure that getAttachmentView and getView are better defined and called.	2025-04-03 17:30:40 +00:00
bridgewaterrobbie	3c7a871e7e	Avoid running the inline pass without merge return on WebGPU	2025-04-02 17:52:27 -04:00
Jeremy Nelson	31d698e9ca	remove resize and refactor GetCurrentTexture remove resize and refactor GetCurrentTexture remove resize and refactor GetCurrentTexture	2025-04-02 15:35:50 -05:00
Andy Hovingh	769b0db858	webgpu: select color format, present mode, and composite alpha mode from surface capabilities	2025-04-02 15:35:50 -05:00
Jeremy Nelson	b40064b1ab	Changed class name to WebGPUSwapChain and comments for handle allocator	2025-04-02 15:35:50 -05:00
Jeremy Nelson	889a62d617	Create WebGPUSurface Class	2025-04-02 15:35:50 -05:00
Mathias Agopian	784b3ce565	Fix subpasses with custom render targets When Color grading is using the optimized subpass mode, it could fail if it was the last pass. This is because in that case it renders directly into the custom rendertarget which doesn't have MRTs (which is needed). The fix is to issue an extra blit. FIXES=[406343577]	2025-04-01 15:23:34 -07:00
Powei Feng	4f77547ab3	vk: add ycbcr conversion cache (#8557 ) Introduce a cache for Ycbcr conversion, which is needed for external textures on Android.	2025-04-01 22:12:59 +00:00
Nick Fisher	46c89499d0	Dispose debug.server/debug.fgViewerServer when Engine destroyed (#8563 )	2025-04-01 20:52:42 +00:00
Sungun Park	57c782685b	Add missing header (#8586 )	2025-04-01 11:11:19 -07:00
bridgewaterrobbieandPowei Feng	bc799c78f6	Update libs/filamat/src/GLSLPostProcessor.cpp per suggestion Co-authored-by: Powei Feng <powei@google.com>	2025-03-31 19:39:05 -04:00
bridgewaterrobbieandPowei Feng	86e688a2a3	Update libs/filamat/src/GLSLPostProcessor.cpp per suggestion Co-authored-by: Powei Feng <powei@google.com>	2025-03-31 19:39:05 -04:00
bridgewaterrobbie	3dead231d4	Output failing processed spir-v on failure to read with tint Also add a build option to ignore such issues if needed during bringup	2025-03-31 19:39:05 -04:00
bridgewaterrobbie	fd382ce219	Split and rebind combined image samplers for WebGPU API target	2025-03-31 19:39:05 -04:00
bridgewaterrobbie	46358572b7	Allow non uniform derivitives	2025-03-31 19:39:05 -04:00
bridgewaterrobbie	546b986107	Hack a workaround for OpConstantLoad issue in Tint to work with most spec constants	2025-03-31 19:39:05 -04:00
bridgewaterrobbie	5245141c46	Workaround Tint issues with texelFetchOffset in dofMedian.mat	2025-03-31 19:39:05 -04:00
bridgewaterrobbie	62b182fe04	Update SPIR-V tools to commit ada1771a9f7a125573aa94fe551fdc44b45769bd to pull in splitter pass	2025-03-31 19:39:05 -04:00