Include webgpu matc arg in android builds when appropriate.

Add Command, RenderPass encoders and other pieces of webgpu
Use HandleAllocator for webgpu to implement createVertexBufferInfoS
2025-04-07 14:36:37 -04:00 · 2025-04-04 13:14:35 -04:00 · 2025-04-04 13:12:57 -04:00
142 changed files with 2386 additions and 245597 deletions
--- a/.github/workflows/presubmit.yml
+++ b/.github/workflows/presubmit.yml
@@ -19,8 +19,6 @@ jobs:

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

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

    steps:
      - uses: actions/checkout@v4.1.6
-        with:
-          fetch-depth: 0
      - name: Run build script
        run: |
          cd build/ios && printf "y" | ./build.sh presubmit
@@ -108,21 +102,9 @@ jobs:
        uses: actions/setup-python@v5
        with:
          python-version: '3.x'
-      - 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
+      - name: Install python prereqs
+        run: pip install mako setuptools pyyaml
+      - name: Run script
        run: |
          bash test/renderdiff/test.sh
      - uses: actions/upload-artifact@v4
@@ -140,31 +122,3 @@ jobs:
        run: source ./build/linux/ci-common.sh && ./build.sh -W debug test_filamat filament
      - name: Run test
        run: ./out/cmake-debug/libs/filamat/test_filamat --gtest_filter=MaterialCompiler.Wgsl*
-
-  code-correcteness:
-    name: code-correctness
-    runs-on: 'macos-14-xlarge'
-    steps:
-      - uses: actions/checkout@v4.1.6
-        with:
-          fetch-depth: 0
-      - name: Set up Homebrew
-        id: set-up-homebrew
-        uses: Homebrew/actions/setup-homebrew@master
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.x'
-      - name: Install prerequisites
-        run: |
-          pip install pyyaml
-          brew install llvm
-          sudo ln -s "$(brew --prefix llvm)/bin/clang-tidy" "/usr/local/bin/clang-tidy"
-      - name: Run build script
-        # We need to build before clang-tidy can run analysis
-        run: |
-          # This will build for all three desktop backends on mac
-          ./build.sh -p desktop debug gltf_viewer
-      - name: Run test
-        run: |
-          bash test/code-correctness/test.sh
--- a/.gitignore
+++ b/.gitignore
@@ -18,18 +18,3 @@ 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/
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -801,7 +801,6 @@ 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)
--- a/NEW_RELEASE_NOTES.md
+++ b/NEW_RELEASE_NOTES.md
@@ -7,3 +7,5 @@ for next branch cut* header.
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).

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

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

@@ -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.3'
+pod 'Filament', '~> 1.59.0'
 ```

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

-## v1.59.4
-
-
-## v1.59.3
-
-
-## v1.59.2
-
- Fix build/compile errors when upgrading to MacOS 15.4
-
 ## v1.59.1


--- a/android/buildSrc/src/main/groovy/FilamentPlugin.groovy
+++ b/android/buildSrc/src/main/groovy/FilamentPlugin.groovy
@@ -142,13 +142,16 @@ 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']
+
+                if (!include_webgpu) {
+                    matcArgs += ['-a', 'webgpu']
                }

+
                def mat_no_opt = providers
                        .gradleProperty("com.google.android.filament.matnopt")
                        .forUseAtConfigurationTime().present
--- a/android/filamat-android/CMakeLists.txt
+++ b/android/filamat-android/CMakeLists.txt
@@ -26,10 +26,6 @@ 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)
@@ -44,7 +40,6 @@ set_target_properties(shaders PROPERTIES IMPORTED_LOCATION

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

 include_directories(${FILAMENT_DIR}/include)
@@ -60,7 +55,6 @@ target_link_libraries(filamat-jni
        filabridge
        shaders
        utils
-        perfetto
        log
        smol-v
        $<$<STREQUAL:${FILAMENT_SUPPORTS_WEBGPU},ON>:tint>
--- a/android/filament-android/CMakeLists.txt
+++ b/android/filament-android/CMakeLists.txt
@@ -21,10 +21,6 @@ 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)
@@ -127,7 +123,6 @@ target_link_libraries(filament-jni
    PRIVATE android
    PRIVATE jnigraphics
    PRIVATE utils
-    PRIVATE perfetto

    # libgeometry is PUBLIC because gltfio uses it.
    PUBLIC geometry
@@ -146,7 +141,6 @@ 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:
--- a/android/gltfio-android/CMakeLists.txt
+++ b/android/gltfio-android/CMakeLists.txt
@@ -35,10 +35,6 @@ 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)
@@ -125,7 +121,6 @@ set(GLTFIO_INCLUDE_DIRS
        ../../third_party/meshoptimizer/src
        ../../third_party/robin-map
        ../../third_party/stb
-        ../../third_party/perfetto
        ../../libs/utils/include
        ../../libs/ktxreader/include
 )
@@ -134,7 +129,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 perfetto uberzlib log stb ktxreader basis_transcoder zstd uberarchive)
+target_link_libraries(gltfio-jni filament-jni utils 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)
--- a/android/gradle.properties
+++ b/android/gradle.properties
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.59.3
+VERSION_NAME=1.59.0

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

--- a/filament/backend/CMakeLists.txt
+++ b/filament/backend/CMakeLists.txt
@@ -177,6 +177,29 @@ endif()
 if (FILAMENT_SUPPORTS_VULKAN)
    list(APPEND SRCS
            include/backend/platforms/VulkanPlatform.h
+            src/vulkan/VulkanDescriptorSetCache.cpp
+            src/vulkan/VulkanDescriptorSetCache.h
+            src/vulkan/VulkanDescriptorSetLayoutCache.cpp
+            src/vulkan/VulkanDescriptorSetLayoutCache.h
+            src/vulkan/VulkanPipelineLayoutCache.cpp
+            src/vulkan/VulkanPipelineLayoutCache.h
+            src/vulkan/memory/ResourceManager.cpp
+            src/vulkan/memory/ResourceManager.h
+            src/vulkan/memory/ResourcePointer.h
+            src/vulkan/memory/Resource.cpp
+            src/vulkan/memory/Resource.h
+            src/vulkan/platform/VulkanPlatform.cpp
+            src/vulkan/platform/VulkanPlatformSwapChainImpl.cpp
+            src/vulkan/platform/VulkanPlatformSwapChainImpl.h
+            src/vulkan/utils/Conversion.cpp
+            src/vulkan/utils/Conversion.h
+            src/vulkan/utils/Definitions.h
+            src/vulkan/utils/Helper.h
+            src/vulkan/utils/Image.h
+            src/vulkan/utils/Image.cpp
+            src/vulkan/utils/Spirv.h
+            src/vulkan/utils/Spirv.cpp
+            src/vulkan/utils/StaticVector.h
            src/vulkan/VulkanAsyncHandles.h
            src/vulkan/VulkanBlitter.cpp
            src/vulkan/VulkanBlitter.h
@@ -187,10 +210,6 @@ 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
@@ -198,43 +217,24 @@ if (FILAMENT_SUPPORTS_VULKAN)
            src/vulkan/VulkanFboCache.h
            src/vulkan/VulkanHandles.cpp
            src/vulkan/VulkanHandles.h
-            src/vulkan/VulkanMemory.cpp
            src/vulkan/VulkanMemory.h
+            src/vulkan/VulkanMemory.cpp
            src/vulkan/VulkanPipelineCache.cpp
            src/vulkan/VulkanPipelineCache.h
-            src/vulkan/VulkanPipelineLayoutCache.cpp
-            src/vulkan/VulkanPipelineLayoutCache.h
            src/vulkan/VulkanQueryManager.cpp
            src/vulkan/VulkanQueryManager.h
-            src/vulkan/VulkanReadPixels.cpp
-            src/vulkan/VulkanReadPixels.h
            src/vulkan/VulkanSamplerCache.cpp
            src/vulkan/VulkanSamplerCache.h
            src/vulkan/VulkanStagePool.cpp
            src/vulkan/VulkanStagePool.h
            src/vulkan/VulkanSwapChain.cpp
            src/vulkan/VulkanSwapChain.h
+            src/vulkan/VulkanReadPixels.cpp
+            src/vulkan/VulkanReadPixels.h
            src/vulkan/VulkanTexture.cpp
            src/vulkan/VulkanTexture.h
            src/vulkan/VulkanYcbcrConversionCache.cpp
            src/vulkan/VulkanYcbcrConversionCache.h
-            src/vulkan/memory/Resource.cpp
-            src/vulkan/memory/Resource.h
-            src/vulkan/memory/ResourceManager.cpp
-            src/vulkan/memory/ResourceManager.h
-            src/vulkan/memory/ResourcePointer.h
-            src/vulkan/platform/VulkanPlatform.cpp
-            src/vulkan/platform/VulkanPlatformSwapChainImpl.cpp
-            src/vulkan/platform/VulkanPlatformSwapChainImpl.h
-            src/vulkan/utils/Conversion.cpp
-            src/vulkan/utils/Conversion.h
-            src/vulkan/utils/Definitions.h
-            src/vulkan/utils/Helper.h
-            src/vulkan/utils/Image.cpp
-            src/vulkan/utils/Image.h
-            src/vulkan/utils/Spirv.cpp
-            src/vulkan/utils/Spirv.h
-            src/vulkan/utils/StaticVector.h
    )
    if (LINUX OR WIN32)
        list(APPEND SRCS src/vulkan/platform/VulkanPlatformLinuxWindows.cpp)
@@ -255,11 +255,10 @@ 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
+            src/webgpu/WebGPUHandles.cpp
+            src/webgpu/WebGPUHandles.h
    )
    if (WIN32)
        list(APPEND SRCS src/webgpu/platform/WebGPUPlatformWindows.cpp)
@@ -508,10 +507,7 @@ 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
@@ -535,9 +531,6 @@ 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
--- a/filament/backend/include/backend/BufferObjectStreamDescriptor.h
+++ b/filament/backend/include/backend/BufferObjectStreamDescriptor.h
@@ -55,9 +55,4 @@ 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
--- a/filament/backend/include/backend/platforms/VulkanPlatform.h
+++ b/filament/backend/include/backend/platforms/VulkanPlatform.h
@@ -104,6 +104,10 @@ public:

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

    VulkanPlatform();
--- a/filament/backend/include/backend/platforms/WebGPUPlatform.h
+++ b/filament/backend/include/backend/platforms/WebGPUPlatform.h
@@ -38,12 +38,6 @@ 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
--- a/filament/backend/src/CommandStream.cpp
+++ b/filament/backend/src/CommandStream.cpp
@@ -84,7 +84,7 @@ void CommandStream::execute(void* buffer) {

    Profiler profiler;

-    if constexpr (SYSTRACE_TAG) {
+    if (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 constexpr (SYSTRACE_TAG) {
+    if (SYSTRACE_TAG) {
        if (UTILS_UNLIKELY(mUsePerformanceCounter)) {
            // we want to remove all this when tracing is completely disabled
            profiler.stop();
--- a/filament/backend/src/opengl/OpenGLProgram.cpp
+++ b/filament/backend/src/opengl/OpenGLProgram.cpp
@@ -85,7 +85,6 @@ OpenGLProgram::~OpenGLProgram() noexcept {
        delete lazyInitializationData;

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

    delete [] mUniformsRecords;
--- a/filament/backend/src/opengl/ShaderCompilerService.cpp
+++ b/filament/backend/src/opengl/ShaderCompilerService.cpp
--- a/filament/backend/src/opengl/ShaderCompilerService.h
+++ b/filament/backend/src/opengl/ShaderCompilerService.h
@@ -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 <array>
+#include <atomic>
+#include <condition_variable>
+#include <deque>
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <tuple>
+#include <thread>
 #include <utility>
 #include <vector>

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

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

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

    explicit ShaderCompilerService(OpenGLDriver& driver);

@@ -84,7 +82,6 @@ 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
@@ -93,12 +90,6 @@ 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);
@@ -106,7 +97,7 @@ public:
 private:
    struct Job {
        template<typename FUNC>
-        Job(FUNC&& fn) : fn(std::forward<FUNC>(fn)) {} // NOLINT(*-explicit-constructor)
+        Job(FUNC&& fn) : fn(std::forward<FUNC>(fn)) {}
        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) {
@@ -135,49 +126,39 @@ private:
    using ContainerType = std::tuple<CompilerPriorityQueue, program_token_t, Job>;
    std::vector<ContainerType> mRunAtNextTickOps;

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

-    void runAtNextTick(CompilerPriorityQueue priority, program_token_t const& token,
-            Job job) noexcept;
+    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 executeTickOps() noexcept;
-    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;
+    bool cancelTickOp(program_token_t token) noexcept;
+    // order of insertion is important
 };

 } // namespace filament::backend
--- a/filament/backend/src/ostream.cpp
+++ b/filament/backend/src/ostream.cpp
@@ -15,7 +15,6 @@
 */

 #include <backend/BufferDescriptor.h>
-#include <backend/BufferObjectStreamDescriptor.h>
 #include <backend/DescriptorSetOffsetArray.h>
 #include <backend/DriverEnums.h>
 #include <backend/PipelineState.h>
@@ -438,10 +437,6 @@ 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
--- a/filament/backend/src/vulkan/VulkanConstants.h
+++ b/filament/backend/src/vulkan/VulkanConstants.h
@@ -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_CALL()
-    #define FVK_PROFILE_MARKER(marker)  SYSTRACE_CALL()
+    #define FVK_SYSTRACE_SCOPE()        SYSTRACE_NAME(__func__)
+    #define FVK_PROFILE_MARKER(marker)  FVK_SYSTRACE_SCOPE()

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

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

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

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

--- a/filament/backend/src/vulkan/VulkanDescriptorSetCache.cpp
+++ b/filament/backend/src/vulkan/VulkanDescriptorSetCache.cpp
@@ -282,25 +282,18 @@ void VulkanDescriptorSetCache::commit(VulkanCommandBuffer* commands,
    fvkutils::DescriptorSetMask curMask = setMask;

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

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

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

@@ -336,7 +329,7 @@ void VulkanDescriptorSetCache::updateBuffer(fvkmemory::resource_ptr<VulkanDescri
    }
    VkWriteDescriptorSet const descriptorWrite = {
        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-        .dstSet = set->getVkSet(),
+        .dstSet = set->vkSet,
        .dstBinding = binding,
        .descriptorCount = 1,
        .descriptorType = type,
@@ -349,6 +342,10 @@ 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,
+        .imageLayout = fvkutils::getVkLayout(texture->getDefaultLayout()),
+    };
    VkImageSubresourceRange range = texture->getPrimaryViewRange();
    VkImageViewType const expectedType = texture->getViewType();
    if (any(texture->usage & TextureUsage::DEPTH_ATTACHMENT) &&
@@ -358,16 +355,12 @@ void VulkanDescriptorSetCache::updateSampler(fvkmemory::resource_ptr<VulkanDescr
        range.levelCount = 1;
        range.layerCount = 1;
    }
-    VkDescriptorImageInfo info{
-        .sampler = sampler,
-        .imageView = texture->getView(range),
-        .imageLayout = fvkutils::getVkLayout(texture->getDefaultLayout()),
-    };
+    info.imageView = texture->getView(range);

    VkWriteDescriptorSet const descriptorWrite = {
        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
        .pNext = nullptr,
-        .dstSet = set->getVkSet(),
+        .dstSet = set->vkSet,
        .dstBinding = binding,
        .descriptorCount = 1,
        .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
@@ -385,10 +378,10 @@ void VulkanDescriptorSetCache::updateInputAttachment(

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

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

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

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

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

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

 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;
--- a/filament/backend/src/vulkan/VulkanDescriptorSetLayoutCache.cpp
+++ b/filament/backend/src/vulkan/VulkanDescriptorSetLayoutCache.cpp
@@ -18,8 +18,6 @@

 #include "VulkanHandles.h"

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

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

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

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

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

--- a/filament/backend/src/vulkan/VulkanDescriptorSetLayoutCache.h
+++ b/filament/backend/src/vulkan/VulkanDescriptorSetLayoutCache.h
@@ -26,11 +26,12 @@
 #include <backend/TargetBufferInfo.h>

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

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

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

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

    void terminate() noexcept;

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

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

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

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

 } // namespace filament::backend
--- a/filament/backend/src/vulkan/VulkanDriver.cpp
+++ b/filament/backend/src/vulkan/VulkanDriver.cpp
@@ -327,7 +327,7 @@ void VulkanDriver::terminate() {

    mStagePool.terminate();
    mPipelineCache.terminate();
-    mFramebufferCache.terminate();
+    mFramebufferCache.reset();
    mSamplerCache.terminate();
    mDescriptorSetLayoutCache.terminate();
    mDescriptorSetCache.terminate();
@@ -1523,7 +1523,7 @@ void VulkanDriver::makeCurrent(Handle<HwSwapChain> drawSch, Handle<HwSwapChain>
    swapChain->acquire(resized);

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

    if (UTILS_LIKELY(mDefaultRenderTarget)) {
--- a/filament/backend/src/vulkan/VulkanFboCache.cpp
+++ b/filament/backend/src/vulkan/VulkanFboCache.cpp
@@ -340,21 +340,15 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey const& config) noexcept
    return renderPass;
 }

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

--- a/filament/backend/src/vulkan/VulkanFboCache.h
+++ b/filament/backend/src/vulkan/VulkanFboCache.h
@@ -106,11 +106,8 @@ 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 terminate() noexcept;
+    void reset() noexcept;

 private:
    VkDevice mDevice;
--- a/filament/backend/src/vulkan/VulkanHandles.cpp
+++ b/filament/backend/src/vulkan/VulkanHandles.cpp
@@ -30,7 +30,6 @@

 #include <backend/platforms/VulkanPlatform.h>

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

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

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

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

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

    VulkanDescriptorSetLayout(DescriptorSetLayout const& layout);

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

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

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

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

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

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

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

 private:
-    VkDescriptorSet mVkSet = VK_NULL_HANDLE;
    backend::DescriptorSetOffsetArray mOffsets;
    std::vector<fvkmemory::resource_ptr<fvkmemory::Resource>> mResources;
    OnRecycle mOnRecycleFn;
--- a/filament/backend/src/vulkan/VulkanPipelineCache.cpp
+++ b/filament/backend/src/vulkan/VulkanPipelineCache.cpp
@@ -35,12 +35,7 @@ using namespace bluevk;
 namespace filament::backend {

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

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

 void VulkanPipelineCache::gc() noexcept {
--- a/filament/backend/src/vulkan/VulkanPipelineCache.h
+++ b/filament/backend/src/vulkan/VulkanPipelineCache.h
@@ -198,10 +198,6 @@ 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 = {};

--- a/filament/backend/src/vulkan/VulkanSamplerCache.cpp
+++ b/filament/backend/src/vulkan/VulkanSamplerCache.cpp
@@ -33,15 +33,8 @@ VkSampler VulkanSamplerCache::getSampler(Params params) noexcept {
    if (UTILS_LIKELY(iter != mCache.end())) {
        return iter->second;
    }
-    VkSamplerYcbcrConversionInfo ycbcrConversion = {
-        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
-        .conversion = params.conversion,
-    };
-
    auto const& samplerParams = params.sampler;
-    VkSamplerCreateInfo samplerInfo{
-        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
-        .pNext = params.conversion != VK_NULL_HANDLE ? &ycbcrConversion : VK_NULL_HANDLE,
+    VkSamplerCreateInfo samplerInfo{ .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
        .magFilter = fvkutils::getFilter(samplerParams.filterMag),
        .minFilter = fvkutils::getFilter(samplerParams.filterMin),
        .mipmapMode = fvkutils::getMipmapMode(samplerParams.filterMin),
@@ -55,8 +48,7 @@ VkSampler VulkanSamplerCache::getSampler(Params params) noexcept {
        .minLod = 0.0f,
        .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."
--- a/filament/backend/src/vulkan/VulkanSwapChain.cpp
+++ b/filament/backend/src/vulkan/VulkanSwapChain.cpp
@@ -108,6 +108,11 @@ void VulkanSwapChain::present() {

    mCommands->flush();

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

    void present();

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

    fvkmemory::resource_ptr<VulkanTexture> getCurrentColor() const noexcept {
        uint32_t const imageIndex = mCurrentSwapIndex;
@@ -101,6 +99,7 @@ private:
    VkExtent2D mExtent;
    uint32_t mLayerCount;
    uint32_t mCurrentSwapIndex;
+    std::function<void(Platform::SwapChain* handle)> mExplicitImageReadyWait = nullptr;
    bool mAcquired;
    bool mIsFirstRenderPass;
 };
--- a/filament/backend/src/vulkan/VulkanYcbcrConversionCache.cpp
+++ b/filament/backend/src/vulkan/VulkanYcbcrConversionCache.cpp
@@ -43,7 +43,7 @@ VkSamplerYcbcrConversion VulkanYcbcrConversionCache::getConversion(
    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),
+        .format = VK_FORMAT_UNDEFINED,
        .ycbcrModel = fvkutils::getYcbcrModelConversion(chroma.ycbcrModel),
        .ycbcrRange = fvkutils::getYcbcrRange(chroma.ycbcrRange),
        .components = fvkutils::getSwizzleMap(swizzleArray),
@@ -52,7 +52,6 @@ VkSamplerYcbcrConversion VulkanYcbcrConversionCache::getConversion(
        .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,
@@ -60,7 +59,6 @@ VkSamplerYcbcrConversion VulkanYcbcrConversionCache::getConversion(
    };
    if (params.externalFormat) {
        conversionInfo.pNext = &externalFormat;
-        conversionInfo.format = VK_FORMAT_UNDEFINED;
    }
 #endif

--- a/filament/backend/src/vulkan/VulkanYcbcrConversionCache.h
+++ b/filament/backend/src/vulkan/VulkanYcbcrConversionCache.h
@@ -31,8 +31,7 @@ class VulkanYcbcrConversionCache {
 public:
    struct Params {
        SamplerYcbcrConversion conversion = {};
-        TextureFormat format = {};
-        uint16_t padding = 0;
+        uint32_t padding = 0;
        uint64_t externalFormat = 0;
    };
    static_assert(sizeof(Params) == 16);
--- a/filament/backend/src/vulkan/platform/VulkanPlatform.cpp
+++ b/filament/backend/src/vulkan/platform/VulkanPlatform.cpp
@@ -211,7 +211,6 @@ ExtensionSet getDeviceExtensions(VkPhysicalDevice device) {
        VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME,
        VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME,
        VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME,
-        VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME,
 #endif
        // MoltenVk is the only non-conformant implementation we're interested in.
 #if defined(__APPLE__)
@@ -327,9 +326,7 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
 }

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

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

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

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

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

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

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

    // Check the availability of lazily allocated memory
--- a/filament/backend/src/vulkan/platform/VulkanPlatformApple.mm
+++ b/filament/backend/src/vulkan/platform/VulkanPlatformApple.mm
@@ -24,12 +24,28 @@
 #include <bluevk/BlueVK.h>

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

 using namespace bluevk;
@@ -38,7 +54,11 @@ 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;
 }
@@ -70,20 +90,36 @@ VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device,
 VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
        VkInstance instance, uint64_t flags) noexcept {
    VkSurfaceKHR surface;
-    NSView* nsview = (__bridge NSView*) nativeWindow;
-    FILAMENT_CHECK_POSTCONDITION(nsview) << "Unable to obtain Metal-backed NSView.";
+    #if defined(__APPLE__)
+        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(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,
+    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,
            (VkSurfaceKHR*) &surface);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkCreateMacOSSurfaceMVK. error=" << static_cast<int32_t>(result);
-    return std::make_tuple(surface, VkExtent2D{});
+            << "vkCreateIOSSurfaceMVK failed. error=" << static_cast<int32_t>(result);
+#endif
+        return std::make_tuple(surface, VkExtent2D{});
 }

 } // namespace filament::backend
--- a/filament/backend/src/vulkan/utils/Conversion.cpp
+++ b/filament/backend/src/vulkan/utils/Conversion.cpp
@@ -668,111 +668,4 @@ VkShaderStageFlags getShaderStageFlags(ShaderStageFlags stageFlags) {
    return flags;
 }

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

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

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

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

 bool operator<(const VkImageSubresourceRange& a, const VkImageSubresourceRange& b) {
--- a/filament/backend/src/webgpu/WGPUProgram.cpp
+++ b/filament/backend/src/webgpu/WGPUProgram.cpp
@@ -1,150 +0,0 @@
-/*
- * Copyright (C) 2025 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "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
--- a/filament/backend/src/webgpu/WebGPUDriver.cpp
+++ b/filament/backend/src/webgpu/WebGPUDriver.cpp
@@ -16,13 +16,13 @@

 #include "webgpu/WebGPUDriver.h"

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

 #include "CommandStreamDispatcher.h"
 #include "DriverBase.h"
 #include "private/backend/Dispatcher.h"
+
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>

@@ -228,14 +228,6 @@ 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
 }

@@ -270,6 +262,9 @@ void WebGPUDriver::tick(int) {

 void WebGPUDriver::beginFrame(int64_t monotonic_clock_ns,
        int64_t refreshIntervalNs, uint32_t frameId) {
+    wgpu::CommandEncoderDescriptor commandEncoderDescriptor{};
+    commandEncoderDescriptor.nextInChain = nullptr;
+    mCommandEncoder = mDevice.CreateCommandEncoder(&commandEncoderDescriptor);
 }

 void WebGPUDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
@@ -286,6 +281,12 @@ void WebGPUDriver::setPresentationTime(int64_t monotonic_clock_ns) {
 }

 void WebGPUDriver::endFrame(uint32_t frameId) {
+    // FWGPU_LOGW << __FUNCTION__<< "\n";
+    mQueue.Submit(1, &mCommandBuffer);
+    mCommandEncoder = nullptr;
+    mCommandBuffer = nullptr;
+    mTextureView = nullptr;
+    mSwapChain->Present();
 }

 void WebGPUDriver::flush(int) {
@@ -295,27 +296,15 @@ 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) {
@@ -325,19 +314,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;
+    // TODO:  use webgpu handle allocator from
+    //        https://github.com/google/filament/pull/8566
+//    if (sch) {
+//        HwSwapChain* hwSwapChain = handleCast<HwSwapChain*>(sch);
+//        destruct(sch, hwSwapChain);
+//    }
 }

 void WebGPUDriver::destroyStream(Handle<HwStream> sh) {
@@ -347,16 +336,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 allocHandle<WebGPUSwapChain>();
+    // TODO:  use webgpu handle allocator from.
+    //        https://github.com/google/filament/pull/8566
+    // return allocAndConstructHandle<HwSwapChain>();
+    return Handle<HwSwapChain>((Handle<HwSwapChain>::HandleId) mNextFakeHandle++);
 }

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

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

 Handle<HwFence> WebGPUDriver::createFenceS() noexcept {
@@ -388,7 +377,7 @@ Handle<HwIndexBuffer> WebGPUDriver::createIndexBufferS() noexcept {
 }

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

 Handle<HwBufferObject> WebGPUDriver::createBufferObjectS() noexcept {
@@ -408,7 +397,7 @@ Handle<HwDescriptorSet> WebGPUDriver::createDescriptorSetS() noexcept {
 }

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

 Handle<HwVertexBufferInfo> WebGPUDriver::createVertexBufferInfoS() noexcept {
@@ -416,7 +405,7 @@ Handle<HwVertexBufferInfo> WebGPUDriver::createVertexBufferInfoS() noexcept {
 }

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

 Handle<HwRenderTarget> WebGPUDriver::createDefaultRenderTargetS() noexcept {
@@ -424,7 +413,8 @@ Handle<HwRenderTarget> WebGPUDriver::createDefaultRenderTargetS() noexcept {
 }

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

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

 void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow, uint64_t flags) {
-    mNativeWindow = nativeWindow;
+    // TODO:  use webgpu handle allocator from.
+    //        https://github.com/google/filament/pull/8566
+    // HwSwapChain* hwSwapChain = handleCast<HwSwapChain*>(sch);
    assert_invariant(!mSwapChain);
    wgpu::Surface surface = mPlatform.createSurface(nativeWindow, flags);
-
+    mAdapter = mPlatform.requestAdapter(surface);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printAdapterDetails(mAdapter);
+#endif
+    mDevice = mPlatform.requestDevice(mAdapter);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printDeviceDetails(mDevice);
+#endif
    mQueue = mDevice.GetQueue();
-    wgpu::Extent2D surfaceSize = mPlatform.getSurfaceExtent(mNativeWindow);
-    mSwapChain = constructHandle<WebGPUSwapChain>(sch, std::move(surface), surfaceSize, mAdapter,
-            mDevice, flags);
-    assert_invariant(mSwapChain);
+    mSwapChain = std::make_unique<WebGPUSwapChain>(std::move(surface), mAdapter, mDevice, flags);
+    // TODO configure the surface (maybe before or after creating the swapchain?
+    //                             how do we get the surface extent?)
+    // TODO actually create the swapchain
+    // auto onQueueWorkDone = [](wgpu::QueueWorkDoneStatus status, void* /* pUserData */) {
+        // FWGPU_LOGW << "Queued work finished with status: " << status << std::endl;
+    // };
+    // mQueue.OnSubmittedWorkDone(wgpu::CallbackMode::WaitAnyOnly, [](wgpu::QueueWorkDoneStatus status, void* pUserdata) {
+    //     FWGPU_LOGW << "Queued work finished with status:\n";
+    // }, nullptr /* pUserData */);
+    void* userDataPtr = nullptr;
+    mQueue.OnSubmittedWorkDone(
+        wgpu::CallbackMode::AllowProcessEvents,
+        [](wgpu::QueueWorkDoneStatus status, void* pUserData) {
+            FWGPU_LOGW << "Queued work finished with status: " << static_cast<int>(status) << "\n";
+            if (pUserData == nullptr) {
+                // Expected case
+            } else {
+                FWGPU_LOGW << "Unexpected non-null pUserData received.\n";
+            }
+        },
+        userDataPtr /* pUserData */
+    );
    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."
@@ -461,6 +479,9 @@ void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
                  "rebuilding Filament with that flag, e.g. ./build.sh -x "
               << FWGPU_PRINT_SYSTEM << " ..." << utils::io::endl;
 #endif
+    // TODO:  use webgpu handle allocator from.
+    //        https://github.com/google/filament/pull/8566
+    // hwSwapChain->swapChain = mSwapChain.get();
 }

 void WebGPUDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch, uint32_t width,
@@ -483,7 +504,13 @@ void WebGPUDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
        TextureUsage usage) {}

 void WebGPUDriver::createTextureViewR(Handle<HwTexture> th, Handle<HwTexture> srch,
-        uint8_t baseLevel, uint8_t levelCount) {}
+        uint8_t baseLevel, uint8_t levelCount) {
+    // FWGPU_LOGW << __FUNCTION__<< "\n";
+    WGPUTexture const* src = handleCast<WGPUTexture>(srch);
+    (void) src;
+    // textures.insert(
+    //         constructHandle<WGPUTexture>(th, src, baseLevel, levelCount));
+}

 void WebGPUDriver::createTextureViewSwizzleR(Handle<HwTexture> th, Handle<HwTexture> srch,
        backend::TextureSwizzle r, backend::TextureSwizzle g, backend::TextureSwizzle b,
@@ -508,9 +535,7 @@ 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) {
-    constructHandle<WGPUProgram>(ph, mDevice, program);
-}
+void WebGPUDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {}

 void WebGPUDriver::createDefaultRenderTargetR(Handle<HwRenderTarget> rth, int) {
    assert_invariant(!mDefaultRenderTarget);
@@ -527,9 +552,7 @@ void WebGPUDriver::createFenceR(Handle<HwFence> fh, int) {}
 void WebGPUDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {}

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

 void WebGPUDriver::createDescriptorSetR(Handle<HwDescriptorSet> dsh,
        Handle<HwDescriptorSetLayout> dslh) {}
@@ -681,8 +704,9 @@ void WebGPUDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh, uint32_t in
        Handle<HwBufferObject> boh) {
    auto* vertexBuffer = handleCast<WGPUVertexBuffer>(vbh);
    auto* bufferObject = handleCast<WGPUBufferObject>(boh);
-    assert_invariant(index < vertexBuffer->buffers.size());
+    assert_invariant(index < vertexBuffer->mBuffers.size());
    vertexBuffer->setBuffer(bufferObject, index);
+
 }

 void WebGPUDriver::update3DImage(Handle<HwTexture> th,
@@ -715,71 +739,48 @@ 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},
-    };
+    // FWGPU_LOGW << __FUNCTION__<< "\n";
+    mTextureView = mSwapChain->GetNextSurfaceTextureView(params.viewport.width, params.viewport.height);
+    wgpu::RenderPassColorAttachment renderPassColorAttachment = {};
+    renderPassColorAttachment.view = mTextureView;
+    renderPassColorAttachment.resolveTarget = nullptr;
+    renderPassColorAttachment.loadOp = wgpu::LoadOp::Clear;
+    renderPassColorAttachment.storeOp = wgpu::StoreOp::Store;
+    renderPassColorAttachment.clearValue = wgpu::Color{1, 0 , 0 , 1};
+    renderPassColorAttachment.depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;

-    wgpu::RenderPassDescriptor renderPassDescriptor = {
-        .colorAttachmentCount = 1,
-        .colorAttachments = &renderPassColorAttachment,
-        .depthStencilAttachment = nullptr,
-        .timestampWrites = nullptr,
-    };
+    wgpu::RenderPassDescriptor renderPassDescriptor = {};
+    renderPassDescriptor.nextInChain = nullptr;
+    renderPassDescriptor.colorAttachmentCount = 1;
+    renderPassDescriptor.colorAttachments = &renderPassColorAttachment;
+    renderPassDescriptor.depthStencilAttachment = nullptr;
+    renderPassDescriptor.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);
+    mRenderPassEncoder.SetViewport((float)params.viewport.left, (float)params.viewport.bottom,
+            (float) params.viewport.width, (float) params.viewport.height, params.depthRange.near, params.depthRange.far);
+            // (float) 1024/*params.viewport.width*/, (float) 640/*params.viewport.height*/, params.depthRange.near, params.depthRange.far);
 }

 void WebGPUDriver::endRenderPass(int) {
+    // FWGPU_LOGW << __FUNCTION__<< "\n";
    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();
+    wgpu::CommandBufferDescriptor commandBufferDescriptor = {};
+    commandBufferDescriptor.nextInChain = nullptr;
+    mCommandBuffer = mCommandEncoder.Finish(&commandBufferDescriptor);
+
+    // mQueue.Submit(1, &mCommandBuffer);
+    // mCommandBuffer = nullptr;
 }

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

-void WebGPUDriver::readBufferSubData(Handle<HwBufferObject> boh,
+void WebGPUDriver::readBufferSubData(backend::BufferObjectHandle boh,
        uint32_t offset, uint32_t size, backend::BufferDescriptor&& p) {
    scheduleDestroy(std::move(p));
 }
@@ -836,6 +837,8 @@ void WebGPUDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
 }

 void WebGPUDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
+    // mRenderPassEncoder.DrawIndexed(indexCount, instanceCount, indexOffset, 0, 0);
+
 }

 void WebGPUDriver::draw(PipelineState pipelineState, Handle<HwRenderPrimitive> rph,
@@ -859,22 +862,22 @@ void WebGPUDriver::resetState(int) {
 }

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

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

 void WebGPUDriver::bindDescriptorSet(
-        Handle<HwDescriptorSet> dsh,
+        backend::DescriptorSetHandle dsh,
        backend::descriptor_set_t set,
        backend::DescriptorSetOffsetArray&& offsets) {
 }
--- a/filament/backend/src/webgpu/WebGPUDriver.h
+++ b/filament/backend/src/webgpu/WebGPUDriver.h
@@ -17,7 +17,7 @@
 #ifndef TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H
 #define TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H

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

 #include "DriverBase.h"
@@ -30,6 +30,8 @@

 #include <webgpu/webgpu_cpp.h>

+#include "WebGPUHandles.h"
+
 #include <cstdint>
 #include <memory>

@@ -39,8 +41,6 @@

 namespace filament::backend {

-class WebGPUSwapChain;
-
 /**
 * WebGPU backend (driver) implementation
 */
@@ -62,8 +62,8 @@ private:
    wgpu::Adapter mAdapter = nullptr;
    wgpu::Device mDevice = nullptr;
    wgpu::Queue mQueue = nullptr;
-    void* mNativeWindow = nullptr;
-    WebGPUSwapChain* mSwapChain = nullptr;
+    // TODO consider moving to handle allocator when ready
+    std::unique_ptr<WebGPUSwapChain> mSwapChain = nullptr;
    uint64_t mNextFakeHandle = 1;
    wgpu::CommandEncoder mCommandEncoder = nullptr;
    wgpu::TextureView mTextureView = nullptr;
@@ -103,17 +103,11 @@ private:
    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
--- a/filament/backend/src/webgpu/WebGPUHandles.cpp
+++ b/filament/backend/src/webgpu/WebGPUHandles.cpp
@@ -1,152 +1,19 @@
-/*
-* 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.
- */
+//
+// Created by Idris Idris Shah on 3/21/25.
+//

 #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.
+WGPUVertexBuffer::WGPUVertexBuffer(uint32_t vextexCount, uint32_t bufferCount,
+        Handle<WGPUVertexBufferInfo> vbih)
+    : HwVertexBuffer(vextexCount),
+      vbih(vbih),
+      mBuffers(MAX_VERTEX_BUFFER_COUNT) {}
 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() {}
+      mBindingType(bindingType) {}
 }// namespace filament::backend
--- a/filament/backend/src/webgpu/WebGPUHandles.h
+++ b/filament/backend/src/webgpu/WebGPUHandles.h
@@ -1,19 +1,6 @@
-/*
-* 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.
- */
-
+//
+// Created by Idris Idris Shah on 3/21/25.
+//

 #ifndef TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H
 #define TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H
@@ -22,29 +9,13 @@

 #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)
@@ -54,46 +25,28 @@ struct WGPUVertexBufferInfo : public HwVertexBufferInfo {
 };

 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);
+    WGPUVertexBuffer(uint32_t vextexCount, uint32_t bufferCount, Handle<WGPUVertexBufferInfo> vbih);
+    void setBuffer(WGPUBufferObject* bufferObject, uint32_t index);

    Handle<WGPUVertexBufferInfo> vbih;
-    utils::FixedCapacityVector<wgpu::Buffer> buffers;
+    utils::FixedCapacityVector<wgpu::Buffer> mBuffers;
 };

 struct WGPUIndexBuffer : public HwIndexBuffer {
-    WGPUIndexBuffer(wgpu::Device const &device, uint8_t elementSize,
-                    uint32_t indexCount);
+    WGPUIndexBuffer(BufferUsage usage, 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;
+    wgpu::Buffer mBuffer;
+    const BufferObjectBinding mBindingType;
 };
-class WebGPUDescriptorSetLayout : public HwDescriptorSetLayout {
+
+class WGPUTexture : public HwTexture {
 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;

@@ -103,22 +56,11 @@ struct WGPUTexture : public HwTexture {
    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 WGPURenderTarget : public HwRenderTarget {
+public:
    class Attachment {
    public:
-        friend struct WGPURenderTarget;
+        friend class WGPURenderTarget;

        Attachment() = default;
        Attachment(WGPUTexture* gpuTexture, uint8_t level = 0, uint16_t layer = 0)
--- a/filament/backend/src/webgpu/WebGPUSwapChain.cpp
+++ b/filament/backend/src/webgpu/WebGPUSwapChain.cpp
@@ -190,13 +190,10 @@ wgpu::CompositeAlphaMode selectAlphaMode(size_t availableAlphaModesCount,
    }
 }

-void initConfig(wgpu::SurfaceConfiguration& config, wgpu::Device const& device,
-        wgpu::SurfaceCapabilities const& capabilities, wgpu::Extent2D const& surfaceSize,
-        bool useSRGBColorSpace) {
+void initConfig(wgpu::SurfaceConfiguration& config, wgpu::Device& device,
+        wgpu::SurfaceCapabilities const& capabilities, 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 =
@@ -208,8 +205,8 @@ void initConfig(wgpu::SurfaceConfiguration& config, wgpu::Device const& device,

 namespace filament::backend {

-WebGPUSwapChain::WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Extent2D const& surfaceSize,
-        wgpu::Adapter& adapter, wgpu::Device& device, uint64_t flags)
+WebGPUSwapChain::WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Adapter& adapter,
+        wgpu::Device& device, uint64_t flags)
    : mSurface(surface) {
    wgpu::SurfaceCapabilities capabilities = {};
    if (!mSurface.GetCapabilities(adapter, &capabilities)) {
@@ -220,55 +217,59 @@ WebGPUSwapChain::WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Extent2D const&
 #endif
    }
    const bool useSRGBColorSpace = (flags & SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0;
-    initConfig(mConfig, device, capabilities, surfaceSize, useSRGBColorSpace);
-    mSurface.Configure(&mConfig);
+    initConfig(mConfig, device, capabilities, useSRGBColorSpace);
 }

 WebGPUSwapChain::~WebGPUSwapChain() {
-    mSurface.Unconfigure();
+    if (mConfigured) {
+        mSurface.Unconfigure();
+        mConfigured = false;
+    }
 }

-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;
+void WebGPUSwapChain::GetCurrentTexture(uint32_t width, uint32_t height, wgpu::SurfaceTexture* texture) {
+    if (width < 1 || height < 1) {
+        PANIC_LOG("WebGPUSwapChain::GetCurrentTexture: Invalid width and/or height requested.");
+        return;
+    }
+    if (mConfig.width != width || mConfig.height != height || !mConfigured) {
+        mConfig.width = width;
+        mConfig.height = height;
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
        printSurfaceConfiguration(mConfig);
 #endif
-        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);
+        mConfigured = true;
+        return;
    }
+
+    mSurface.GetCurrentTexture(texture);
 }

-wgpu::TextureView WebGPUSwapChain::getCurrentSurfaceTextureView(
-        wgpu::Extent2D const& currentSurfaceSize) {
-    setExtent(currentSurfaceSize);
+wgpu::TextureView WebGPUSwapChain::GetNextSurfaceTextureView(uint32_t width, uint32_t height) {
    wgpu::SurfaceTexture surfaceTexture;
-    mSurface.GetCurrentTexture(&surfaceTexture);
-    if (surfaceTexture.status != wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal) {
+    GetCurrentTexture(width, height, &surfaceTexture);
+    if (surfaceTexture.status != wgpu::SurfaceGetCurrentTextureStatus::Success) {
        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);
+    wgpu::TextureViewDescriptor textureViewDescriptor;
+    textureViewDescriptor.nextInChain = nullptr;
+    textureViewDescriptor.label = "Surface texture view";
+    textureViewDescriptor.format = surfaceTexture.texture.GetFormat();
+    textureViewDescriptor.dimension = wgpu::TextureViewDimension::e2D;
+    textureViewDescriptor.baseMipLevel = 0;
+    textureViewDescriptor.mipLevelCount = 1;
+    textureViewDescriptor.baseArrayLayer = 0;
+    textureViewDescriptor.arrayLayerCount = 1;
+    textureViewDescriptor.aspect = wgpu::TextureAspect::All;
+    wgpu::TextureView textureView = surfaceTexture.texture.CreateView(&textureViewDescriptor);
+
+    return textureView;
 }

-void WebGPUSwapChain::present() {
+void WebGPUSwapChain::Present() {
    assert_invariant(mSurface);
    mSurface.Present();
 }
--- a/filament/backend/src/webgpu/WebGPUSwapChain.h
+++ b/filament/backend/src/webgpu/WebGPUSwapChain.h
@@ -19,28 +19,26 @@

 #include <webgpu/webgpu_cpp.h>

-#include "DriverBase.h"
 #include <backend/Platform.h>

 #include <cstdint>

 namespace filament::backend {

-class WebGPUSwapChain final : public Platform::SwapChain, HwSwapChain {
+class WebGPUSwapChain : public Platform::SwapChain {
 public:
-    WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Extent2D const& surfaceSize,
-            wgpu::Adapter& adapter, wgpu::Device& device, uint64_t flags);
+    WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Adapter& adapter, wgpu::Device& device,
+            uint64_t flags);
    ~WebGPUSwapChain();

-    wgpu::TextureView getCurrentSurfaceTextureView(wgpu::Extent2D const&);
-
-    void present();
+    void GetCurrentTexture(uint32_t width, uint32_t height, wgpu::SurfaceTexture*);
+    wgpu::TextureView GetNextSurfaceTextureView(uint32_t width, uint32_t height);
+    void Present();

 private:
-    void setExtent(wgpu::Extent2D const&);
-
    wgpu::Surface mSurface = {};
    wgpu::SurfaceConfiguration mConfig = {};
+    bool mConfigured = false;
 };

 } // namespace filament::backend
--- a/filament/backend/src/webgpu/platform/WebGPUPlatformAndroid.cpp
+++ b/filament/backend/src/webgpu/platform/WebGPUPlatformAndroid.cpp
@@ -18,7 +18,6 @@

 #include <utils/Panic.h>

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

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

 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;
--- a/filament/backend/src/webgpu/platform/WebGPUPlatformApple.mm
+++ b/filament/backend/src/webgpu/platform/WebGPUPlatformApple.mm
@@ -24,8 +24,21 @@
 #include <cstdint>

 // Platform specific includes and defines
-#include <Cocoa/Cocoa.h>
-#import <QuartzCore/CAMetalLayer.h>
+#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

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

 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;
-    // Both IOS and MacOS expects CAMetalLayer.
-    CAMetalLayer* metalLayer = (__bridge CAMetalLayer*) nativeWindow;
+#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];
    wgpu::SurfaceSourceMetalLayer surfaceSourceMetalLayer{};
    surfaceSourceMetalLayer.layer = (__bridge void*) metalLayer;
    wgpu::SurfaceDescriptor surfaceDescriptor = {
@@ -54,6 +62,19 @@ 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;
 }

--- a/filament/backend/src/webgpu/platform/WebGPUPlatformLinux.cpp
+++ b/filament/backend/src/webgpu/platform/WebGPUPlatformLinux.cpp
@@ -79,74 +79,6 @@

 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)
--- a/filament/backend/src/webgpu/platform/WebGPUPlatformWindows.cpp
+++ b/filament/backend/src/webgpu/platform/WebGPUPlatformWindows.cpp
@@ -30,16 +30,6 @@

 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
--- a/filament/backend/test/BackendTest.cpp
+++ b/filament/backend/test/BackendTest.cpp
@@ -43,29 +43,24 @@ using namespace image;
 namespace test {

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

-void BackendTest::init(Backend backend, OperatingSystem operatingSystem, bool isMobilePlatform) {
+void BackendTest::init(Backend backend, 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;
 }
@@ -159,16 +154,49 @@ void BackendTest::renderTriangle(
    api.endRenderPass();
 }

-bool BackendTest::matchesEnvironment(Backend backend) {
-    return sBackend == backend;
-}
+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(OperatingSystem operatingSystem) {
-    return sOperatingSystem == operatingSystem;
-}
+    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, Backend backend) {
-    return matchesEnvironment(operatingSystem) && matchesEnvironment(backend);
+    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));
 }

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

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

 #include "PlatformRunner.h"
-#include "ImageExpectations.h"

 namespace test {

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

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

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

 protected:
@@ -66,14 +64,13 @@ 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;
@@ -81,10 +78,6 @@ 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
--- a/filament/backend/test/ImageExpectations.cpp
+++ b/filament/backend/test/ImageExpectations.cpp
@@ -16,6 +16,7 @@

 #include "ImageExpectations.h"

+#include "gtest/gtest.h"
 #include "gmock/gmock.h"
 #include "absl/strings/str_format.h"
 #include "utils/Hash.h"
@@ -27,17 +28,14 @@
 #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 expectedHash)
-    : mWidth(width),
-      mHeight(height),
-      mExpectedPixelHash(expectedHash),
-      mFileName(std::move(fileName)) {}
+        uint32_t expectedPixelHash)
+        : mWidth(width), mHeight(height), mFileName(std::move(fileName)),
+          mExpectedPixelHash(expectedPixelHash) {}

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

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

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

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

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

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

 ImageExpectation::ImageExpectation(const char* fileName, int lineNumber,
@@ -97,22 +91,11 @@ 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();
-#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.
+        EXPECT_THAT(actualHash, testing::Eq(mParams.expectedHash()));
    }
 }

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

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

 void ImageExpectations::evaluate() {
    for (auto& expectation: mExpectations) {
-        expectation->evaluate();
+        expectation.evaluate();
    }
    mExpectations.clear();
 }
@@ -140,28 +122,32 @@ 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.actualFilePath();
+        std::string filePath = internal->params.generatedActualFilePath();
        std::ofstream pngStream(filePath, std::ios::binary | std::ios::trunc);
        image::ImageEncoder::encode(pngStream, image::ImageEncoder::Format::PNG, image, "",
                filePath);
-#endif
+        internal->bytesFilled = true;
    };
    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() {
@@ -183,30 +169,4 @@ bool RenderTargetDump::bytesFilled() const {
    return mInternal->bytesFilled;
 }

-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);
-}
+RenderTargetDump::Internal::Internal(const ScreenshotParams& params) : params(params) {}
--- a/filament/backend/test/ImageExpectations.h
+++ b/filament/backend/test/ImageExpectations.h
@@ -46,12 +46,11 @@ public:
    int height() const;
    uint32_t expectedHash() 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;
+    std::string outputDirectoryPath() const;
+    std::string generatedActualFileName() const;
+    std::string generatedActualFilePath() const;
+    std::string goldenFileName() const;
+    std::string goldenFilePath() const;

 private:
    int mWidth;
@@ -99,17 +98,6 @@ 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,
@@ -142,8 +130,7 @@ public:

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

 #endif //TNT_IMAGE_EXPECTATIONS_H
--- a/filament/backend/test/PlatformRunner.cpp
+++ b/filament/backend/test/PlatformRunner.cpp
@@ -1,60 +0,0 @@
-/*
- * 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
-
--- a/filament/backend/test/PlatformRunner.h
+++ b/filament/backend/test/PlatformRunner.h
@@ -19,7 +19,6 @@

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

 namespace test {

@@ -35,15 +34,6 @@ 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;
@@ -61,10 +51,9 @@ 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, OperatingSystem operatingSystem, bool isMobile, int& argc, char* argv[]);
+void initTests(Backend backend, bool isMobile, int& argc, char* argv[]);

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

-} // namespace test
+}

 #endif
--- a/filament/backend/test/Shader.cpp
+++ b/filament/backend/test/Shader.cpp
@@ -23,44 +23,30 @@ namespace test {

 using namespace filament::backend;

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

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

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

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

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

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

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

 namespace test {

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

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

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

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

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

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

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

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

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

 template<typename UniformType>
--- a/filament/backend/test/SharedShaders.cpp
+++ b/filament/backend/test/SharedShaders.cpp
@@ -1,253 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "SharedShaders.h"
-
-#include "Shader.h"
-#include "absl/strings/str_format.h"
-#include "gtest/gtest.h"
-
-namespace test {
-
-using namespace filament::backend;
-
-namespace {
-
-// A shader stored in pieces so that uniform declarations can be injected.
-struct ShaderText {
-    std::string mPrefix;
-    std::string mBody;
-
-    std::string withUniform(const std::string& uniformText) const {
-        return absl::StrFormat("%s\n%s\n%s", mPrefix.c_str(), uniformText.c_str(), mBody.c_str());
-    }
-};
-
-std::optional<ShaderText> GetGlslVertexShader(VertexShaderType type) {
-    switch (type) {
-        case VertexShaderType::Noop: {
-            return ShaderText{
-                    R"(
-#version 450 core
-layout(location = 0) in vec4 mesh_position;
-)", R"(
-void main() {
-    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
-#if defined(TARGET_VULKAN_ENVIRONMENT)
-    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
-    gl_Position.y = -gl_Position.y;
-#endif
-})" };
-        }
-        case VertexShaderType::Simple: {
-            return ShaderText{
-                    R"(
-#version 450 core
-layout(location = 0) in vec4 mesh_position;
-)", R"(
-void main() {
-    gl_Position = vec4(
-            mesh_position.xy * (params.scaleMinusOne.xy + 1.0) + params.offset.xy,
-            params.scaleMinusOne.z + 1.0,
-            1.0);
-#if defined(TARGET_VULKAN_ENVIRONMENT)
-    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
-    gl_Position.y = -gl_Position.y;
-#endif
-})" };
-        }
-        case VertexShaderType::Textured: {
-            return ShaderText{
-                    R"(
-#version 450 core
-layout(location = 0) in vec4 mesh_position;
-layout(location = 0) out vec2 uv;
-)", R"(
-void main() {
-    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
-    uv = (mesh_position.xy * 0.5 + 0.5);
-#if defined(TARGET_VULKAN_ENVIRONMENT)
-    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
-    gl_Position.y = -gl_Position.y;
-#endif
-})" };
-        }
-        default:
-            return std::nullopt;
-    }
-}
-
-std::optional<ShaderText> GetGlslFragmentShader(FragmentShaderType type) {
-    switch (type) {
-        case FragmentShaderType::White: {
-            return ShaderText{
-                    R"(
-#version 450 core
-precision mediump int; precision highp float;
-layout(location = 0) out vec4 fragColor;
-)", R"(
-void main() {
-    fragColor = vec4(1.0, 1.0, 1.0, 1.0);
-})" };
-        }
-        case FragmentShaderType::SolidColored: {
-            return ShaderText{
-                    R"(
-#version 450 core
-precision mediump int; precision highp float;
-layout(location = 0) out vec4 fragColor;
-)", R"(
-void main() {
-    fragColor = params.color;
-})" };
-        }
-        case FragmentShaderType::Textured: {
-            return ShaderText{
-                    R"(
-#version 450 core
-precision mediump int; precision highp float;
-layout(location = 0) out vec4 fragColor;
-layout(location = 0) in vec2 uv;
-)", R"(
-void main() {
-    fragColor = texture(test_tex, uv);
-})" };
-        }
-        default:
-            return std::nullopt;
-    }
-}
-
-std::optional<std::string> GetGlslUniform(ShaderUniformType type) {
-    switch (type) {
-        case ShaderUniformType::None: {
-            return "";
-        }
-        case ShaderUniformType::Simple: {
-            return R"(
-layout(binding = 0, set = 1) uniform Params {
-    highp vec4 color;
-    // Use scaleMinusOne instead of scale so that a 0 initialized value is a good default
-    highp vec4 scaleMinusOne;
-    highp vec4 offset;
-} params;
-)";
-        }
-        case ShaderUniformType::SimpleWithPadding: {
-            return R"(
-layout(binding = 0, set = 1) uniform Params {
-    highp vec4 padding[4];  // offset of 64 bytes
-
-    highp vec4 color;
-    // Use scaleMinusOne instead of scale so that a 0 initialized value is a good default
-    highp vec4 scaleMinusOne;
-    highp vec4 offset;
-} params;
-)";
-        }
-        case ShaderUniformType::Sampler: {
-            return R"(
-layout(location = 0, set = 1) uniform sampler2D test_tex;
-)";
-        }
-        default:
-            return std::nullopt;
-    }
-}
-
-std::vector<UniformConfig> GetUniformConfig(ShaderUniformType type) {
-    switch (type) {
-        case ShaderUniformType::None: {
-            return {};
-        }
-        case ShaderUniformType::Simple: {
-            return {{ "Params" }};
-        }
-        case ShaderUniformType::SimpleWithPadding: {
-            return {{ "Params" }};
-        }
-        case ShaderUniformType::Sampler: {
-            filament::SamplerInterfaceBlock::SamplerInfo samplerInfo{
-                    "backend_test", "test_tex", 0,
-                    SamplerType::SAMPLER_2D, SamplerFormat::FLOAT, Precision::HIGH, false };
-            return {{
-                            "test_tex", DescriptorType::SAMPLER, samplerInfo
-                    }};
-        }
-        default:
-            abort();
-    }
-}
-
-ShaderLanguage getShaderLanguage(const Backend& backend) {
-    switch (backend) {
-        case Backend::METAL:
-            return ShaderLanguage::MSL;
-        case Backend::WEBGPU:
-            return ShaderLanguage::WGSL;
-        case Backend::VULKAN:
-        case Backend::NOOP:
-        case Backend::OPENGL:
-        default: {
-            return ShaderLanguage::GLSL;
-        }
-    }
-}
-
-} // namespace
-
-Shader SharedShaders::makeShader(filament::backend::DriverApi& api, Cleanup& cleanup,
-        ShaderRequest request) {
-    std::optional<ShaderText> vertex;
-    std::optional<ShaderText> fragment;
-    std::optional<std::string> uniform;
-    if (getShaderLanguage(BackendTest::sBackend) != ShaderLanguage::GLSL) {
-        // TODO: If any shaders need backend/shader language specific shaders rather than transpiled
-        // versions of the GLSL shader, check environment.
-    }
-    vertex = GetGlslVertexShader(request.mVertexType);
-    fragment = GetGlslFragmentShader(request.mFragmentType);
-    uniform = GetGlslUniform(request.mUniformType);
-    if (vertex.has_value() && fragment.has_value() && uniform.has_value()) {
-        return Shader(
-                api, cleanup, ShaderConfig{
-                        vertex->withUniform(*uniform), fragment->withUniform(*uniform),
-                        GetUniformConfig(request.mUniformType)}
-        );
-    }
-    abort();
-}
-
-std::string SharedShaders::getVertexShaderText(VertexShaderType vertex, ShaderUniformType uniform) {
-    std::optional<ShaderText> vertexText = GetGlslVertexShader(vertex);
-    std::optional<std::string> uniformText = GetGlslUniform(uniform);
-    if (!vertexText.has_value() || !uniformText.has_value()) {
-        abort();
-    }
-    return vertexText->withUniform(*uniformText);
-}
-
-std::string SharedShaders::getFragmentShaderText(FragmentShaderType fragment,
-        ShaderUniformType uniform) {
-    std::optional<ShaderText> fragmentText = GetGlslFragmentShader(fragment);
-    std::optional<std::string> uniformText = GetGlslUniform(uniform);
-    if (!fragmentText.has_value() || !uniformText.has_value()) {
-        abort();
-    }
-    return fragmentText->withUniform(*uniformText);
-}
-
-} // namespace test
--- a/filament/backend/test/SharedShaders.h
+++ b/filament/backend/test/SharedShaders.h
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TNT_SHAREDSHADERS_H
-#define TNT_SHAREDSHADERS_H
-
-#include "Shader.h"
-#include "SharedShadersConstants.h"
-#include "Lifetimes.h"
-#include "PlatformRunner.h"
-
-namespace test {
-
-enum class ShaderLanguage : uint8_t {
-    GLSL,
-    MSL,
-    WGSL
-};
-
-struct ShaderRequest {
-    VertexShaderType mVertexType;
-    FragmentShaderType mFragmentType;
-    ShaderUniformType mUniformType;
-};
-
-class SharedShaders {
-public:
-    static Shader makeShader(filament::backend::DriverApi& api, Cleanup& cleanup,
-            ShaderRequest request);
-    static std::string getVertexShaderText(VertexShaderType vertex, ShaderUniformType uniform);
-    static std::string getFragmentShaderText(FragmentShaderType fragment,
-            ShaderUniformType uniform);
-};
-
-} // namespace test
-
-#endif //TNT_SHAREDSHADERS_H
--- a/filament/backend/test/SharedShadersConstants.h
+++ b/filament/backend/test/SharedShadersConstants.h
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TNT_SHAREDSHADERSCONSTANTS_H
-#define TNT_SHAREDSHADERSCONSTANTS_H
-
-#include "math/mathfwd.h"
-
-enum class ShaderUniformType : uint8_t {
-    None,
-    Simple,
-    SimpleWithPadding,
-    Sampler,
-};
-
-struct SimpleMaterialParams {
-    filament::math::float4 color;
-    // 1.0 will be added to this value before use.
-    // The XY values are used to scale position inputs and the Z value is used to set the output
-    // position's Z value.
-    filament::math::float4 scaleMinusOne;
-    // Offset will be applied after scale
-    filament::math::float4 offset;
-};
-
-struct SimpleWithPaddingMaterialParams {
-    // The associated uniform structure in the shader will have 64 bytes of padding at the beginning
-    // So users of this struct will need to add 64 bytes to its size and offset all uniform writes.
-    filament::math::float4 color;
-    // 1.0 will be added to this value before use.
-    // The XY values are used to scale position inputs and the Z value is used to set the output
-    // position's Z value.
-    filament::math::float4 scaleMinusOne;
-    // Offset will be applied after scale
-    filament::math::float4 offset;
-};
-
-enum class VertexShaderType : uint8_t {
-    Noop,
-    Simple,
-    Textured
-};
-
-enum class FragmentShaderType : uint8_t {
-    White,
-    SolidColored,
-    Textured
-};
-
-#endif //TNT_SHAREDSHADERSCONSTANTS_H
--- a/filament/backend/test/Skip.cpp
+++ b/filament/backend/test/Skip.cpp
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2025 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "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
--- a/filament/backend/test/Skip.h
+++ b/filament/backend/test/Skip.h
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2025 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TNT_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/filament/backend/test/expected_images/Blit2DTextureArray.png
+++ b/filament/backend/test/expected_images/Blit2DTextureArray.png
--- a/filament/backend/test/expected_images/BufferObjectUpdateWithOffset.png
+++ b/filament/backend/test/expected_images/BufferObjectUpdateWithOffset.png
--- a/filament/backend/test/expected_images/ColorMagnify.png
+++ b/filament/backend/test/expected_images/ColorMagnify.png
--- a/filament/backend/test/expected_images/ColorMinify.png
+++ b/filament/backend/test/expected_images/ColorMinify.png
--- a/filament/backend/test/expected_images/ColorResolve.png
+++ b/filament/backend/test/expected_images/ColorResolve.png
--- a/filament/backend/test/expected_images/DepthAndStencilBuffer.png
+++ b/filament/backend/test/expected_images/DepthAndStencilBuffer.png
--- a/filament/backend/test/expected_images/FeedbackLoops.png
+++ b/filament/backend/test/expected_images/FeedbackLoops.png
--- a/filament/backend/test/expected_images/RGB
+++ b/filament/backend/test/expected_images/RGB
--- a/filament/backend/test/expected_images/RGB
+++ b/filament/backend/test/expected_images/RGB
--- a/filament/backend/test/expected_images/RGB
+++ b/filament/backend/test/expected_images/RGB
--- a/filament/backend/test/expected_images/RGB
+++ b/filament/backend/test/expected_images/RGB
--- a/filament/backend/test/expected_images/RGB
+++ b/filament/backend/test/expected_images/RGB
--- a/filament/backend/test/expected_images/RGB
+++ b/filament/backend/test/expected_images/RGB
--- a/filament/backend/test/expected_images/RGBA
+++ b/filament/backend/test/expected_images/RGBA
--- a/filament/backend/test/expected_images/RGBA
+++ b/filament/backend/test/expected_images/RGBA
--- a/filament/backend/test/expected_images/RGBA
+++ b/filament/backend/test/expected_images/RGBA
--- a/filament/backend/test/expected_images/RGBA
+++ b/filament/backend/test/expected_images/RGBA
--- a/filament/backend/test/expected_images/RGBA
+++ b/filament/backend/test/expected_images/RGBA
--- a/filament/backend/test/expected_images/RGBA
+++ b/filament/backend/test/expected_images/RGBA
--- a/filament/backend/test/expected_images/RGBA
+++ b/filament/backend/test/expected_images/RGBA
--- a/filament/backend/test/expected_images/RGBA
+++ b/filament/backend/test/expected_images/RGBA
--- a/filament/backend/test/expected_images/RGB_INTEGER
+++ b/filament/backend/test/expected_images/RGB_INTEGER
--- a/filament/backend/test/expected_images/RGB_INTEGER
+++ b/filament/backend/test/expected_images/RGB_INTEGER
--- a/filament/backend/test/expected_images/RGB_INTEGER
+++ b/filament/backend/test/expected_images/RGB_INTEGER
--- a/filament/backend/test/expected_images/RenderExternalImage.png
+++ b/filament/backend/test/expected_images/RenderExternalImage.png
--- a/filament/backend/test/expected_images/ScissorViewportEdgeCases.png
+++ b/filament/backend/test/expected_images/ScissorViewportEdgeCases.png
--- a/filament/backend/test/expected_images/StencilBuffer.png
+++ b/filament/backend/test/expected_images/StencilBuffer.png
--- a/filament/backend/test/expected_images/StencilBufferAutoResolve.png
+++ b/filament/backend/test/expected_images/StencilBufferAutoResolve.png
--- a/filament/backend/test/expected_images/UpdateImage3D.png
+++ b/filament/backend/test/expected_images/UpdateImage3D.png
--- a/filament/backend/test/expected_images/UpdateImageMipLevel.png
+++ b/filament/backend/test/expected_images/UpdateImageMipLevel.png
--- a/filament/backend/test/expected_images/UpdateImageSRGB.png
+++ b/filament/backend/test/expected_images/UpdateImageSRGB.png
--- a/filament/backend/test/expected_images/scissor.png
+++ b/filament/backend/test/expected_images/scissor.png
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
bridgewaterrobbie	3041a7ccc0	Include webgpu matc arg in android builds when appropriate.	2025-04-07 14:36:37 -04:00
Syed Idris Shah	06f8d073da	Add Command, RenderPass encoders and other pieces of webgpu	2025-04-04 13:14:35 -04:00
Syed Idris Shah	e5b8f91859	Use HandleAllocator for webgpu to implement createVertexBufferInfoS	2025-04-04 13:12:57 -04:00