Update Gitignore to ignore generated files.

- Re-enable renderdiff test.
- Cache the mesa directory so that we're not spending time pulling
  and compiling it.
- Move python prereqs into the script and use venv.

.github/workflows/presubmit.yml

@@ -19,6 +19,8 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4.1.6
+        with:
+          fetch-depth: 0
       - name: Run build script
         run: |
           WORKFLOW_OS=`echo \`uname\` | sed "s/Darwin/mac/" | tr [:upper:] [:lower:]`
@@ -44,6 +46,8 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4.1.6
+        with:
+          fetch-depth: 0
       - uses: actions/setup-java@v3
         with:
           distribution: 'temurin'
@@ -60,6 +64,8 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4.1.6
+        with:
+          fetch-depth: 0
       - name: Run build script
         run: |
           cd build/ios && printf "y" | ./build.sh presubmit
@@ -102,9 +108,21 @@ jobs:
         uses: actions/setup-python@v5
         with:
           python-version: '3.x'
-      - name: Install python prereqs
-        run: pip install mako setuptools pyyaml
-      - name: Run script
+      - name: Cache Mesa and deps
+        id: mesa-cache
+        uses: actions/cache@v4 # Use a specific version
+        with:
+          path: |
+            $HOME/Library/Caches/Homebrew
+            mesa
+          key: ${{ runner.os }}-mesa-deps-${{ vars.MESA_VERSION }}
+      - name: Get Mesa
+        id: mesa-prereq
+        env:
+          MESA_VERSION: ${{ vars.MESA_VERSION }}
+        run: |
+          bash test/utils/get_mesa.sh
+      - name: Run Test
         run: |
           bash test/renderdiff/test.sh
       - uses: actions/upload-artifact@v4
@@ -122,3 +140,31 @@ jobs:
         run: source ./build/linux/ci-common.sh && ./build.sh -W debug test_filamat filament
       - name: Run test
         run: ./out/cmake-debug/libs/filamat/test_filamat --gtest_filter=MaterialCompiler.Wgsl*
+
+  code-correcteness:
+    name: code-correctness
+    runs-on: 'macos-14-xlarge'
+    steps:
+      - uses: actions/checkout@v4.1.6
+        with:
+          fetch-depth: 0
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+      - name: Install prerequisites
+        run: |
+          pip install pyyaml
+          brew install llvm
+          sudo ln -s "$(brew --prefix llvm)/bin/clang-tidy" "/usr/local/bin/clang-tidy"
+      - name: Run build script
+        # We need to build before clang-tidy can run analysis
+        run: |
+          # This will build for all three desktop backends on mac
+          ./build.sh -p desktop debug gltf_viewer
+      - name: Run test
+        run: |
+          bash test/code-correctness/test.sh

.gitignore

@@ -18,3 +18,18 @@ test*.json
 results
 /compile_commands.json
 /.cache
+build/.cmake/
+build/CMakeCache.txt
+build/CMakeFiles/
+build/Makefile
+build/SPIRV-Tools*
+build/cmake_install.cmake
+build/compile_commands.json
+build/filament/
+build/include/
+build/libs/
+build/mac/ninja
+build/samples/
+build/shaders/
+build/third_party/
+build/tools/

CMakeLists.txt

@@ -334,6 +334,9 @@ if (MSVC)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_STANDARD} /W0 /Zc:__cplusplus")
 else()
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_STANDARD} -fstrict-aliasing -Wno-unknown-pragmas -Wno-unused-function -Wno-deprecated-declarations")
+    if (APPLE)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nullability-extension")
+    endif()
 endif()
 
 if (FILAMENT_USE_EXTERNAL_GLES3)
@@ -798,6 +801,7 @@ add_subdirectory(${EXTERNAL}/draco/tnt)
 add_subdirectory(${EXTERNAL}/jsmn/tnt)
 add_subdirectory(${EXTERNAL}/stb/tnt)
 add_subdirectory(${EXTERNAL}/getopt)
+add_subdirectory(${EXTERNAL}/perfetto/tnt)
 
 # Note that this has to be placed after mikktspace in order for combine_static_libs to work.
 add_subdirectory(${LIBRARIES}/geometry)

README.md

@@ -31,7 +31,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.59.1'
+    implementation 'com.google.android.filament:filament-android:1.59.3'
 }
 ```
 
@@ -51,7 +51,7 @@ Here are all the libraries available in the group `com.google.android.filament`:
 iOS projects can use CocoaPods to install the latest release:
 
 ```shell
-pod 'Filament', '~> 1.59.1'
+pod 'Filament', '~> 1.59.3'
 ```
 
 ## Documentation

RELEASE_NOTES.md

@@ -7,6 +7,16 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).
 
+## v1.59.4
+
+
+## v1.59.3
+
+
+## v1.59.2
+
+- Fix build/compile errors when upgrading to MacOS 15.4
+
 ## v1.59.1
 
 

android/buildSrc/src/main/groovy/FilamentPlugin.groovy

@@ -142,6 +142,12 @@ abstract class MaterialCompiler extends TaskWithBinary {
                 if (!exclude_vulkan) {
                     matcArgs += ['-a', 'vulkan']
                 }
+                def include_webgpu = providers
+                        .gradleProperty("com.google.android.filament.include-webgpu")
+                        .forUseAtConfigurationTime().present
+                if (include_webgpu) {
+                    matcArgs += ['-a', 'webgpu', '--variant-filter=skinning,stereo']
+                }
 
                 def mat_no_opt = providers
                         .gradleProperty("com.google.android.filament.matnopt")

android/filamat-android/CMakeLists.txt

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

android/filament-android/CMakeLists.txt

@@ -21,6 +21,10 @@ add_library(utils STATIC IMPORTED)
 set_target_properties(utils PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libutils.a)
 
+add_library(perfetto STATIC IMPORTED)
+set_target_properties(perfetto PROPERTIES IMPORTED_LOCATION
+        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libperfetto.a)
+
 add_library(ibl-lite STATIC IMPORTED)
 set_target_properties(ibl-lite PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libibl-lite.a)
@@ -123,6 +127,7 @@ target_link_libraries(filament-jni
     PRIVATE android
     PRIVATE jnigraphics
     PRIVATE utils
+    PRIVATE perfetto
 
     # libgeometry is PUBLIC because gltfio uses it.
     PUBLIC geometry
@@ -141,6 +146,7 @@ target_include_directories(filament-jni PRIVATE
         ${FILAMENT_DIR}/include
         ../../filament/backend/include
         ../../third_party/robin-map
+        ../../third_party/perfetto
         ../../libs/utils/include)
 
 # Force a relink when the version script is changed:

android/gltfio-android/CMakeLists.txt

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

android/gradle.properties

@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.59.1
+VERSION_NAME=1.59.3
 
 POM_DESCRIPTION=Real-time physically based rendering engine for Android.
 

filament/backend/CMakeLists.txt

@@ -194,8 +194,6 @@ if (FILAMENT_SUPPORTS_VULKAN)
             src/vulkan/VulkanDriver.cpp
             src/vulkan/VulkanDriver.h
             src/vulkan/VulkanDriverFactory.h
-            src/vulkan/VulkanExternalImageManager.cpp
-            src/vulkan/VulkanExternalImageManager.h
             src/vulkan/VulkanFboCache.cpp
             src/vulkan/VulkanFboCache.h
             src/vulkan/VulkanHandles.cpp
@@ -257,6 +255,11 @@ if (FILAMENT_SUPPORTS_WEBGPU)
             src/webgpu/WebGPUConstants.h
             src/webgpu/WebGPUDriver.cpp
             src/webgpu/WebGPUDriver.h
+            src/webgpu/WebGPUHandles.cpp
+            src/webgpu/WebGPUHandles.h
+            src/webgpu/WebGPUSwapChain.cpp
+            src/webgpu/WebGPUSwapChain.h
+            src/webgpu/WGPUProgram.cpp
     )
     if (WIN32)
         list(APPEND SRCS src/webgpu/platform/WebGPUPlatformWindows.cpp)
@@ -306,6 +309,11 @@ target_include_directories(${TARGET} PUBLIC ${PUBLIC_HDR_DIR})
 # add this subproject to the Filament folder
 set_target_properties(${TARGET} PROPERTIES FOLDER Filament)
 
+# we need to export the headers properly for backend.lib on windows
+if (WIN32 AND FILAMENT_SUPPORTS_WEBGPU)
+    target_compile_definitions(${TARGET} PRIVATE "WGPU_IMPLEMENTATION")
+endif()
+
 # ==================================================================================================
 # Expose a header-only target to minimize dependencies.
 # ==================================================================================================
@@ -500,7 +508,10 @@ if (APPLE OR LINUX)
         test/Arguments.cpp
         test/ImageExpectations.cpp
         test/Lifetimes.cpp
+        test/PlatformRunner.cpp
         test/Shader.cpp
+        test/SharedShaders.cpp
+        test/Skip.cpp
         test/test_FeedbackLoops.cpp
         test/test_Blit.cpp
         test/test_MissingRequiredAttributes.cpp
@@ -524,6 +535,9 @@ if (APPLE OR LINUX)
         filamat
         SPIRV
         spirv-cross-glsl)
+    # Create input/output directories for test result images.
+    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/images/actual_images)
+    file(COPY test/expected_images DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/images)
 endif()
 
 # TODO: Disabling IOS test due to breakage wrt glslang update

filament/backend/include/backend/BufferObjectStreamDescriptor.h

@@ -55,4 +55,9 @@ public:
 
 } // namespace filament::backend
 
+#if !defined(NDEBUG)
+utils::io::ostream& operator<<(utils::io::ostream& out,
+        const filament::backend::BufferObjectStreamDescriptor& b);
+#endif
+
 #endif // TNT_FILAMENT_BACKEND_BUFFEROBJECTSTREAMDESCRIPTOR_H

filament/backend/include/backend/platforms/VulkanPlatform.h

@@ -104,10 +104,6 @@ public:
 
         // Semaphore to be signaled once the image is available.
         VkSemaphore imageReadySemaphore = VK_NULL_HANDLE;
-
-        // A function called right before vkQueueSubmit. After this call, the image must be 
-        // available. This pointer can be null if imageReadySemaphore is not VK_NULL_HANDLE.
-        std::function<void(SwapChainPtr handle)> explicitImageReadyWait = nullptr;
     };
 
     VulkanPlatform();
@@ -298,16 +294,6 @@ public:
     VkQueue getProtectedGraphicsQueue() const noexcept;
 
     struct ExternalImageMetadata {
-        /**
-         * The Filament texture format.
-         */
-        TextureFormat filamentFormat;
-
-        /**
-         * The Filament texture usage.
-         */
-        TextureUsage filamentUsage;
-
         /**
          * The width of the external image
          */
@@ -318,6 +304,11 @@ public:
          */
         uint32_t height;
 
+        /**
+         * The layerCount of the external image
+         */
+        uint32_t layerCount;
+
         /**
          * The layer count of the external image
          */
@@ -333,6 +324,11 @@ public:
          */
         VkFormat format;
 
+        /**
+         * An external buffer can be protected. This tells you if it is.
+         */
+        bool isProtected;
+
         /**
          * The type of external format (opaque int) if used.
          */
@@ -352,44 +348,20 @@ public:
          * Heap information
          */
         uint32_t memoryTypeBits;
-
-        /**
-         * Ycbcr conversion components
-         */
-        VkComponentMapping ycbcrConversionComponents;
-
-        /**
-         * Ycbcr model
-         */
-        VkSamplerYcbcrModelConversion ycbcrModel;
-
-        /**
-         * Ycbcr range
-         */
-        VkSamplerYcbcrRange ycbcrRange;
-
-        /**
-         * Ycbcr x chroma offset
-         */
-        VkChromaLocation xChromaOffset;
-
-        /**
-         * Ycbcr y chroma offset
-         */
-        VkChromaLocation yChromaOffset;
     };
-
-
-    // Note that the image metadata might change per-frame, hence we need a method for extracting
-    // it.
-    virtual ExternalImageMetadata extractExternalImageMetadata(ExternalImageHandleRef image) const {
-        return {};
-    }
+    virtual ExternalImageMetadata getExternalImageMetadata(ExternalImageHandleRef externalImage);
 
     using ImageData = std::pair<VkImage, VkDeviceMemory>;
-    virtual ImageData createVkImageFromExternal(ExternalImageHandleRef image) const {
-        return { VK_NULL_HANDLE, VK_NULL_HANDLE };
-    }
+    virtual ImageData createExternalImageData(ExternalImageHandleRef externalImage,
+            const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex,
+            VkImageUsageFlags usage);
+
+    virtual VkSampler createExternalSampler(SamplerYcbcrConversion chroma,
+            SamplerParams sampler, uint32_t internalFormat);
+
+    virtual VkImageView createExternalImageView(SamplerYcbcrConversion chroma,
+            uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
+            VkImageViewType viewType, VkComponentMapping swizzle);
 
 protected:
     virtual ExtensionSet getSwapchainInstanceExtensions() const;
@@ -402,6 +374,20 @@ private:
     // Platform dependent helper methods
     static ExtensionSet getSwapchainInstanceExtensionsImpl();
 
+    static ExternalImageMetadata getExternalImageMetadataImpl(ExternalImageHandleRef externalImage,
+            VkDevice device);
+
+    static ImageData createExternalImageDataImpl(ExternalImageHandleRef externalImage,
+            VkDevice device, const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex,
+            VkImageUsageFlags usage);
+    static VkSampler createExternalSamplerImpl(VkDevice device,
+            SamplerYcbcrConversion chroma, SamplerParams sampler,
+            uint32_t internalFormat);
+    static VkImageView createExternalImageViewImpl(VkDevice device,
+            SamplerYcbcrConversion chroma, uint32_t internalFormat, VkImage image,
+            VkImageSubresourceRange range, VkImageViewType viewType,
+            VkComponentMapping swizzle);
+
     // Platform dependent helper methods
     static SurfaceBundle createVkSurfaceKHRImpl(void* nativeWindow, VkInstance instance,
             uint64_t flags) noexcept;

filament/backend/include/backend/platforms/VulkanPlatformAndroid.h

@@ -26,7 +26,7 @@ namespace filament::backend {
 
 class VulkanPlatformAndroid : public VulkanPlatform {
 public:
-    ExternalImageHandle UTILS_PUBLIC createExternalImage(AHardwareBuffer const* buffer,
+    Platform::ExternalImageHandle UTILS_PUBLIC createExternalImage(AHardwareBuffer const* buffer,
             bool sRGB) noexcept;
 
     struct UTILS_PUBLIC ExternalImageDescAndroid {
@@ -39,26 +39,31 @@ public:
     ExternalImageDescAndroid UTILS_PUBLIC getExternalImageDesc(
             ExternalImageHandleRef externalImage) const noexcept;
 
-    virtual ExternalImageMetadata extractExternalImageMetadata(
-            ExternalImageHandleRef image) const override;
-
-    virtual ImageData createVkImageFromExternal(ExternalImageHandleRef image) const override;
-
 protected:
-    virtual ExtensionSet getSwapchainInstanceExtensions() const override;
-
-    using SurfaceBundle = VulkanPlatform::SurfaceBundle;
-    virtual SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
-            uint64_t flags) const noexcept override;
-
-private:
     struct ExternalImageVulkanAndroid : public Platform::ExternalImage {
         AHardwareBuffer* aHardwareBuffer = nullptr;
         bool sRGB = false;
+        unsigned int width;  // Texture width
+        unsigned int height; // Texture height
+        TextureFormat format;// Texture format
+        TextureUsage usage;  // Texture usage flags
 
     protected:
         ~ExternalImageVulkanAndroid() override;
     };
+
+    virtual ExternalImageMetadata getExternalImageMetadata(ExternalImageHandleRef externalImage);
+
+    using ImageData = VulkanPlatform::ImageData;
+    virtual ImageData createExternalImageData(ExternalImageHandleRef externalImage,
+            const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex,
+            VkImageUsageFlags usage);
+
+    virtual ExtensionSet getSwapchainInstanceExtensions() const;
+
+    using SurfaceBundle = VulkanPlatform::SurfaceBundle;
+    virtual SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
+            uint64_t flags) const noexcept;
 };
 
 }// namespace filament::backend

filament/backend/include/backend/platforms/WebGPUPlatform.h

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

filament/backend/src/CommandStream.cpp

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

filament/backend/src/opengl/OpenGLProgram.cpp

@@ -85,6 +85,7 @@ OpenGLProgram::~OpenGLProgram() noexcept {
         delete lazyInitializationData;
 
         ShaderCompilerService::terminate(mToken);
+        assert_invariant(!mToken);
     }
 
     delete [] mUniformsRecords;

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 <atomic>
-#include <condition_variable>
-#include <deque>
+#include <array>
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <thread>
+#include <tuple>
 #include <utility>
 #include <vector>
 
+#include <stdint.h>
+
 namespace filament::backend {
 
 class OpenGLDriver;
@@ -57,6 +57,8 @@ class ShaderCompilerService {
 
 public:
     using program_token_t = std::shared_ptr<OpenGLProgramToken>;
+    using shaders_t = std::array<GLuint, Program::SHADER_TYPE_COUNT>;
+    using shaders_source_t = std::array<utils::CString, Program::SHADER_TYPE_COUNT>;
 
     explicit ShaderCompilerService(OpenGLDriver& driver);
 
@@ -82,6 +84,7 @@ public:
     void tick();
 
     // Destroys a valid token and all associated resources. Used to "cancel" a program compilation.
+    // This function is not called if `initialize(token)` is already invoked.
     static void terminate(program_token_t& token);
 
     // stores a user data pointer in the token
@@ -90,6 +93,12 @@ public:
     // retrieves the user data pointer stored in the token
     static void* getUserData(const program_token_t& token) noexcept;
 
+    // Issue one callback handle.
+    CallbackManager::Handle issueCallbackHandle() const noexcept;
+
+    // Return a callback handle to the callback manager.
+    void submitCallbackHandle(CallbackManager::Handle handle) noexcept;
+
     // call the callback when all active programs are ready
     void notifyWhenAllProgramsAreReady(
             CallbackHandler* handler, CallbackHandler::Callback callback, void* user);
@@ -97,7 +106,7 @@ public:
 private:
     struct Job {
         template<typename FUNC>
-        Job(FUNC&& fn) : fn(std::forward<FUNC>(fn)) {}
+        Job(FUNC&& fn) : fn(std::forward<FUNC>(fn)) {} // NOLINT(*-explicit-constructor)
         Job(std::function<bool(Job const& job)> fn,
                 CallbackHandler* handler, void* user, CallbackHandler::Callback callback)
                 : fn(std::move(fn)), handler(handler), user(user), callback(callback) {
@@ -126,39 +135,49 @@ private:
     using ContainerType = std::tuple<CompilerPriorityQueue, program_token_t, Job>;
     std::vector<ContainerType> mRunAtNextTickOps;
 
-    GLuint initialize(ShaderCompilerService::program_token_t& token) noexcept;
+    GLuint initialize(program_token_t& token);
+    void ensureTokenIsReady(program_token_t const& token);
 
-    static void getProgramFromCompilerPool(program_token_t& token) noexcept;
-
-    static void compileShaders(
-            OpenGLContext& context,
-            Program::ShaderSource shadersSource,
-            utils::FixedCapacityVector<Program::SpecializationConstant> const& specializationConstants,
-            bool multiview,
-            std::array<GLuint, Program::SHADER_TYPE_COUNT>& outShaders,
-            std::array<utils::CString, Program::SHADER_TYPE_COUNT>& outShaderSourceCode) noexcept;
-
-    static void process_GOOGLE_cpp_style_line_directive(OpenGLContext& context,
-            char* source, size_t len) noexcept;
-
-    static void process_OVR_multiview2(OpenGLContext& context, int32_t eyeCount,
-            char* source, size_t len) noexcept;
-
-    static std::string_view process_ARB_shading_language_packing(OpenGLContext& context) noexcept;
-
-    static std::array<std::string_view, 3> splitShaderSource(std::string_view source) noexcept;
-
-    static GLuint linkProgram(OpenGLContext& context,
-            std::array<GLuint, Program::SHADER_TYPE_COUNT> shaders,
-            utils::FixedCapacityVector<std::pair<utils::CString, uint8_t>> const& attributes) noexcept;
-
-    static bool checkProgramStatus(program_token_t const& token) noexcept;
-
-    void runAtNextTick(CompilerPriorityQueue priority,
-            const program_token_t& token, Job job) noexcept;
+    void runAtNextTick(CompilerPriorityQueue priority, program_token_t const& token,
+            Job job) noexcept;
     void executeTickOps() noexcept;
-    bool cancelTickOp(program_token_t token) noexcept;
-    // order of insertion is important
+    bool cancelTickOp(program_token_t const& token) noexcept;
+
+    // Compile shaders with the given `shaderSource`. `gl.shaders` is always populated with valid
+    // shader IDs after this method. But this doesn't necessarily mean the shaders are successfully
+    // compiled. Errors can be checked by calling `checkCompileStatus` later.
+    static void compileShaders(OpenGLContext& context, Program::ShaderSource shadersSource,
+            utils::FixedCapacityVector<Program::SpecializationConstant> const&
+                    specializationConstants,
+            bool multiview, program_token_t const& token) noexcept;
+
+    // Check if the shader compilation is completed. You may want to call this when the extension
+    // `KHR_parallel_shader_compile` is enabled.
+    static bool isCompileCompleted(program_token_t const& token) noexcept;
+
+    // Check compilation status of the shaders and log errors on failure.
+    static void checkCompileStatus(program_token_t const& token) noexcept;
+
+    // Create a program by linking the compiled shaders. `gl.program` is always populated with a
+    // valid program ID after this method. But this doesn't necessarily mean the program is
+    // successfully linked. Errors can be checked by calling `checkLinkStatusAndCleanupShaders`
+    // later.
+    static void linkProgram(OpenGLContext const& context, program_token_t const& token) noexcept;
+
+    // Check if the program link is completed. You may want to call this when the extension
+    // `KHR_parallel_shader_compile` is enabled.
+    static bool isLinkCompleted(program_token_t const& token) noexcept;
+
+    // Check link status of the program and log errors on failure. Return the result of the link.
+    // Also cleanup shaders regardless of the result.
+    static bool checkLinkStatusAndCleanupShaders(program_token_t const& token) noexcept;
+
+    // Try caching the program if we haven't done it yet. Cache it only when the program is valid.
+    static void tryCachingProgram(OpenGLBlobCache& cache, OpenGLPlatform& platform,
+            program_token_t const& token) noexcept;
+
+    // Cleanup GL resources.
+    static void cleanupProgramAndShaders(program_token_t const& token) noexcept;
 };
 
 } // namespace filament::backend

filament/backend/src/ostream.cpp

@@ -15,6 +15,7 @@
  */
 
 #include <backend/BufferDescriptor.h>
+#include <backend/BufferObjectStreamDescriptor.h>
 #include <backend/DescriptorSetOffsetArray.h>
 #include <backend/DriverEnums.h>
 #include <backend/PipelineState.h>
@@ -437,6 +438,10 @@ io::ostream& operator<<(io::ostream& out, BufferDescriptor const& b) {
     << ", user=" << b.getUser() << " }";
 }
 
+io::ostream& operator<<(io::ostream& out, const BufferObjectStreamDescriptor& b) {
+    return out << "BufferObjectStreamDescriptor{ streams(" << b.mStreams.size() << ")=... }";
+}
+
 io::ostream& operator<<(io::ostream& out, PixelBufferDescriptor const& b) {
     BufferDescriptor const& base = static_cast<BufferDescriptor const&>(b);
     return out << "PixelBufferDescriptor{ " << base

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_NAME(__func__)
-    #define FVK_PROFILE_MARKER(marker)  FVK_SYSTRACE_SCOPE()
+    #define FVK_SYSTRACE_SCOPE()        SYSTRACE_CALL()
+    #define FVK_PROFILE_MARKER(marker)  SYSTRACE_CALL()
 
 #else
     #define FVK_SYSTRACE_CONTEXT()

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -200,7 +200,9 @@ Dispatcher VulkanDriver::getDispatcher() const noexcept {
 VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& context,
         Platform::DriverConfig const& driverConfig) noexcept
     : mPlatform(platform),
-      mResourceManager(driverConfig.handleArenaSize, driverConfig.disableHandleUseAfterFreeCheck,
+      mResourceManager(
+              driverConfig.handleArenaSize,
+              driverConfig.disableHandleUseAfterFreeCheck,
               driverConfig.disableHeapHandleTags),
       mAllocator(createAllocator(mPlatform->getInstance(), mPlatform->getPhysicalDevice(),
               mPlatform->getDevice())),
@@ -219,8 +221,6 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
       mDescriptorSetLayoutCache(mPlatform->getDevice(), &mResourceManager),
       mDescriptorSetCache(mPlatform->getDevice(), &mResourceManager),
       mQueryManager(mPlatform->getDevice()),
-      mExternalImageManager(platform, &mSamplerCache, &mYcbcrConversionCache, &mDescriptorSetCache,
-              &mDescriptorSetLayoutCache),
       mIsSRGBSwapChainSupported(mPlatform->getCustomization().isSRGBSwapChainSupported),
       mStereoscopicType(driverConfig.stereoscopicType) {
 
@@ -313,7 +313,7 @@ void VulkanDriver::terminate() {
 
     mCurrentSwapChain = {};
     mDefaultRenderTarget = {};
-    mPipelineState = {};
+    mBoundPipeline = {};
 
     mQueryManager.terminate();
 
@@ -325,13 +325,9 @@ void VulkanDriver::terminate() {
 
     mCommands.terminate();
 
-    // Must come before samplerCache, ycbcrConversionCache, descriptorSetCache,
-    // descriptorSetLayoutCache
-    mExternalImageManager.terminate();
-
     mStagePool.terminate();
     mPipelineCache.terminate();
-    mFramebufferCache.reset();
+    mFramebufferCache.terminate();
     mSamplerCache.terminate();
     mDescriptorSetLayoutCache.terminate();
     mDescriptorSetCache.terminate();
@@ -385,10 +381,6 @@ void VulkanDriver::beginFrame(int64_t monotonic_clock_ns,
         int64_t refreshIntervalNs, uint32_t frameId) {
     FVK_PROFILE_MARKER(PROFILE_NAME_BEGINFRAME);
     // Do nothing.
-
-    if (mAppState.hasExternalSamplers()) {
-        mExternalImageManager.onBeginFrame();
-    }
 }
 
 void VulkanDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch, CallbackHandler* handler,
@@ -429,16 +421,12 @@ void VulkanDriver::updateDescriptorSetTexture(
     auto set = resource_ptr<VulkanDescriptorSet>::cast(&mResourceManager, dsh);
     auto texture = resource_ptr<VulkanTexture>::cast(&mResourceManager, th);
 
-    if (mExternalImageManager.isExternallySampledTexture(texture)) {
-        mExternalImageManager.bindExternallySampledTexture(set, binding, texture, params);
-        mAppState.hasBoundExternalImages = true;
-    } else {
-        VulkanSamplerCache::Params cacheParams = {
-            .sampler = params,
-        };
-        VkSampler const vksampler = mSamplerCache.getSampler(cacheParams);
-        mDescriptorSetCache.updateSampler(set, binding, texture, vksampler);
-    }
+    // TODO: YcbcrConversion?
+    VulkanSamplerCache::Params cacheParams = {
+        .sampler = params,
+    };
+    VkSampler const vksampler = mSamplerCache.getSampler(cacheParams);
+    mDescriptorSetCache.updateSampler(set, binding, texture, vksampler);
 }
 
 void VulkanDriver::flush(int) {
@@ -575,35 +563,41 @@ void VulkanDriver::createTextureExternalImage2R(Handle<HwTexture> th, backend::S
         backend::TextureFormat format, uint32_t width, uint32_t height, backend::TextureUsage usage,
         Platform::ExternalImageHandleRef externalImage) {
     FVK_SYSTRACE_SCOPE();
-    auto const& metadata = mPlatform->extractExternalImageMetadata(externalImage);
+    auto const& metadata = mPlatform->getExternalImageMetadata(externalImage);
+    if (metadata.isProtected) {
+        usage |= backend::TextureUsage::PROTECTED;
+    }
 
-    // In theory the following are reasonable expectations, but in practice it's hard for client's
-    // to match up the dimensions of the texture with that of the AHB.
-    // assert_invariant(width == metadata.width);
-    // assert_invariant(height == metadata.height);
-    // assert_invariant(format == metadata.filamentFormat);
-    // assert_invariant(fvkutils::getVkFormat(format) == metadata.format);
+    VkImageUsageFlags vkUsage = metadata.usage;
+    if (any(usage & TextureUsage::BLIT_SRC)) {
+        vkUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    }
+
+    if (any(usage & (TextureUsage::BLIT_DST | TextureUsage::UPLOADABLE))) {
+        vkUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    }
+
+    assert_invariant(width == metadata.width);
+    assert_invariant(height == metadata.height);
+    assert_invariant(fvkutils::getVkFormat(format) == metadata.format);
+
+    VkMemoryPropertyFlags const requiredMemoryFlags = any(usage & TextureUsage::UPLOADABLE)
+                                                              ? VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
+                                                              : VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+    uint32_t const memoryTypeIndex =
+            mContext.selectMemoryType(metadata.memoryTypeBits, requiredMemoryFlags);
+    FILAMENT_CHECK_POSTCONDITION(memoryTypeIndex != VK_MAX_MEMORY_TYPES)
+            << "failed to find a valid memory type for external image memory.";
 
     VkImage vkimg;
     VkDeviceMemory deviceMemory;
-    std::tie(vkimg, deviceMemory) = mPlatform->createVkImageFromExternal(externalImage);
-
-    VkSamplerYcbcrConversion conversion =
-            mExternalImageManager.getVkSamplerYcbcrConversion(metadata);
+    std::tie(vkimg, deviceMemory) =
+            mPlatform->createExternalImageData(externalImage, metadata, memoryTypeIndex, vkUsage);
 
     auto texture = resource_ptr<VulkanTexture>::make(&mResourceManager, th, mContext,
             mPlatform->getDevice(), mAllocator, &mResourceManager, &mCommands, vkimg, deviceMemory,
-            metadata.format, conversion, metadata.samples, metadata.width, metadata.height,
-            metadata.layers, usage, mStagePool);
-
-    if (conversion != VK_NULL_HANDLE) {
-        mExternalImageManager.addExternallySampledTexture(texture, externalImage);
-    }
-
-    // Unlike uploaded textures or swapchains, we need to explicit transition this
-    // texture into the read layout.
-    auto& commands = mCommands.get();
-    texture->transitionLayout(&commands, texture->getPrimaryViewRange(), VulkanLayout::READ_ONLY);
+            metadata.format, VK_NULL_HANDLE, metadata.samples, metadata.width, metadata.height,
+            metadata.layerCount, usage, mStagePool);
 
     texture.inc();
 }
@@ -636,8 +630,6 @@ void VulkanDriver::destroyTexture(Handle<HwTexture> th) {
     }
     auto texture = resource_ptr<VulkanTexture>::cast(&mResourceManager, th);
     texture.dec();
-
-    mExternalImageManager.removeExternallySampledTexture(texture);
 }
 
 void VulkanDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {
@@ -806,11 +798,6 @@ void VulkanDriver::createDescriptorSetR(Handle<HwDescriptorSet> dsh,
             fvkmemory::resource_ptr<VulkanDescriptorSetLayout>::cast(&mResourceManager, dslh);
     auto set = mDescriptorSetCache.createSet(dsh, layout);
     set.inc();
-
-    if (layout->hasExternalSamplers()) {
-        mAppState.hasExternalSamplerLayouts = true;
-        mExternalImageManager.addDescriptorSet(layout, set);
-    }
 }
 
 Handle<HwVertexBufferInfo> VulkanDriver::createVertexBufferInfoS() noexcept {
@@ -930,19 +917,11 @@ void VulkanDriver::destroyTimerQuery(Handle<HwTimerQuery> tqh) {
 void VulkanDriver::destroyDescriptorSetLayout(Handle<HwDescriptorSetLayout> dslh) {
     auto layout = resource_ptr<VulkanDescriptorSetLayout>::cast(&mResourceManager, dslh);
     layout.dec();
-
-    if (layout->hasExternalSamplers()) {
-        mExternalImageManager.removeDescriptorSetLayout(layout);
-    }
 }
 
 void VulkanDriver::destroyDescriptorSet(Handle<HwDescriptorSet> dsh) {
     auto set = resource_ptr<VulkanDescriptorSet>::cast(&mResourceManager, dsh);
     set.dec();
-
-    if (mAppState.hasExternalSamplers()) {
-        mExternalImageManager.removeDescriptorSet(set);
-    }
 }
 
 Handle<HwStream> VulkanDriver::createStreamNative(void* nativeStream) {
@@ -1503,6 +1482,7 @@ void VulkanDriver::endRenderPass(int) {
     // pipeline barrier between framebuffer writes and shader reads.
     rt->emitBarriersEndRenderPass(*mCurrentRenderPass.commandBuffer);
 
+    mRenderPassFboInfo = {};
     mCurrentRenderPass.renderTarget = {};
     mCurrentRenderPass.renderPass = VK_NULL_HANDLE;
 
@@ -1543,7 +1523,7 @@ void VulkanDriver::makeCurrent(Handle<HwSwapChain> drawSch, Handle<HwSwapChain>
     swapChain->acquire(resized);
 
     if (resized) {
-        mFramebufferCache.reset();
+        mFramebufferCache.resetFramebuffers();
     }
 
     if (UTILS_LIKELY(mDefaultRenderTarget)) {
@@ -1562,10 +1542,10 @@ void VulkanDriver::commit(Handle<HwSwapChain> sch) {
 
 void VulkanDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
         backend::PushConstantVariant value) {
-    assert_invariant(mPipelineState.program && "Expect a program when writing to push constants");
+    assert_invariant(mBoundPipeline.program && "Expect a program when writing to push constants");
     assert_invariant(mCurrentRenderPass.commandBuffer && "Should be called within a renderpass");
-    mPipelineState.program->writePushConstant(mCurrentRenderPass.commandBuffer->buffer(),
-            mPipelineState.pipelineLayout, stage, index, value);
+    mBoundPipeline.program->writePushConstant(mCurrentRenderPass.commandBuffer->buffer(),
+            mBoundPipeline.pipelineLayout, stage, index, value);
 }
 
 void VulkanDriver::insertEventMarker(char const* string) {
@@ -1744,27 +1724,6 @@ void VulkanDriver::blitDEPRECATED(TargetBufferFlags buffers,
 }
 
 void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {
-    // We need to determine whether to delay bindning until draw().
-    mPipelineState.bindInDraw.first = false;
-    if (mAppState.hasExternalSamplers()) {
-        auto& layouts = pipelineState.pipelineLayout.setLayout;
-        auto haveExternalSamplers = [&](auto hwHandle) {
-            if (!hwHandle) {
-                return false;
-            }
-            auto layout =
-                    resource_ptr<VulkanDescriptorSetLayout>::cast(&mResourceManager, hwHandle);
-            return layout->hasExternalSamplers();
-        };
-        if (std::any_of(layouts.begin(), layouts.end(), haveExternalSamplers)) {
-            mPipelineState.bindInDraw = { true, pipelineState };
-            return;
-        }
-    }
-    bindPipelineImpl(pipelineState);
-}
-
-void VulkanDriver::bindPipelineImpl(PipelineState const& pipelineState) {
     FVK_SYSTRACE_SCOPE();
     auto commands = mCurrentRenderPass.commandBuffer;
     auto vbi = resource_ptr<VulkanVertexBufferInfo>::cast(&mResourceManager,
@@ -1833,11 +1792,10 @@ void VulkanDriver::bindPipelineImpl(PipelineState const& pipelineState) {
 
     constexpr uint8_t descriptorSetMaskTable[4] = {0x1, 0x3, 0x7, 0xF};
 
-    mPipelineState = {
+    mBoundPipeline = {
         .program = program,
         .pipelineLayout = pipelineLayout,
         .descriptorSetMask = fvkutils::DescriptorSetMask(descriptorSetMaskTable[layoutCount]),
-        .bindInDraw = {false, {}},
     };
 
     mPipelineCache.bindLayout(pipelineLayout);
@@ -1884,24 +1842,14 @@ void VulkanDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
     FVK_SYSTRACE_SCOPE();
     VkCommandBuffer cmdbuffer = mCurrentRenderPass.commandBuffer->buffer();
 
-    if (mAppState.hasExternalSamplers()) {
-        auto const& [bindInDraw, pipelineSt] = mPipelineState.bindInDraw;
-        bool const hasUpdated =
-                mExternalImageManager.prepareBindSets(mDescriptorSetCache.getBoundSets());
-        if (bindInDraw || hasUpdated) {
-            bindPipelineImpl(pipelineSt);
-        }
-        mPipelineState.bindInDraw.first = false;
-    }
-
     mDescriptorSetCache.commit(mCurrentRenderPass.commandBuffer,
-            mPipelineState.pipelineLayout,
-            mPipelineState.descriptorSetMask);
+            mBoundPipeline.pipelineLayout,
+            mBoundPipeline.descriptorSetMask);
 
     // Finally, make the actual draw call. TODO: support subranges
-    uint32_t const firstIndex = indexOffset;
-    constexpr int32_t vertexOffset = 0;
-    constexpr uint32_t firstInstId = 0;
+    const uint32_t firstIndex = indexOffset;
+    const int32_t vertexOffset = 0;
+    const uint32_t firstInstId = 0;
 
     vkCmdDrawIndexed(cmdbuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstId);
 }

filament/backend/src/vulkan/VulkanDriver.h

@@ -30,7 +30,6 @@
 #include "VulkanYcbcrConversionCache.h"
 #include "vulkan/VulkanDescriptorSetCache.h"
 #include "vulkan/VulkanDescriptorSetLayoutCache.h"
-#include "vulkan/VulkanExternalImageManager.h"
 #include "vulkan/VulkanPipelineLayoutCache.h"
 #include "vulkan/memory/ResourceManager.h"
 #include "vulkan/memory/ResourcePointer.h"
@@ -120,7 +119,6 @@ private:
 
 private:
     void collectGarbage();
-    void bindPipelineImpl(PipelineState const& pipelineState);
 
     VulkanPlatform* mPlatform = nullptr;
     fvkmemory::ResourceManager mResourceManager;
@@ -145,29 +143,21 @@ private:
     VulkanDescriptorSetLayoutCache mDescriptorSetLayoutCache;
     VulkanDescriptorSetCache mDescriptorSetCache;
     VulkanQueryManager mQueryManager;
-    VulkanExternalImageManager mExternalImageManager;
 
     // This is necessary for us to write to push constants after binding a pipeline.
     struct {
-        // For push constant
         resource_ptr<VulkanProgram> program;
-        // For push commiting dynamic ubos in draw()
         VkPipelineLayout pipelineLayout;
         fvkutils::DescriptorSetMask descriptorSetMask;
+    } mBoundPipeline = {};
 
-        std::pair<bool, PipelineState> bindInDraw = {false, {}};
-    } mPipelineState = {};
-
+    // We need to store information about a render pass to enable better barriers at the end of a
+    // renderpass.
     struct {
-        // This tracks whether the app has seen external samplers bound to a the descriptor set.
-        // This will force bindPipeline to take a slow path.
-        bool hasExternalSamplerLayouts = false;
-        bool hasBoundExternalImages = false;
-
-        bool hasExternalSamplers() const noexcept {
-            return hasExternalSamplerLayouts && hasBoundExternalImages;
-        }
-    } mAppState;
+        using AttachmentArray =
+                fvkutils::StaticVector<VulkanAttachment, MAX_RENDERTARGET_ATTACHMENT_TEXTURES>;
+        AttachmentArray attachments;
+    } mRenderPassFboInfo = {};
 
     bool const mIsSRGBSwapChainSupported;
     backend::StereoscopicType const mStereoscopicType;

filament/backend/src/vulkan/VulkanExternalImageManager.cpp

@@ -1,280 +0,0 @@
-/*
- * Copyright (C) 2025 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "VulkanExternalImageManager.h"
-
-#include "VulkanDescriptorSetCache.h"
-#include "VulkanDescriptorSetLayoutCache.h"
-#include "VulkanSamplerCache.h"
-#include "VulkanYcbcrConversionCache.h"
-#include "vulkan/memory/ResourcePointer.h"
-#include "vulkan/utils/Conversion.h"
-
-#include <backend/platforms/VulkanPlatform.h>
-
-#include <algorithm>
-
-namespace filament::backend {
-
-namespace {
-
-template<typename T>
-void erasep(std::vector<T>& v, std::function<bool(T const&)> f) {
-    auto newEnd = std::remove_if(v.begin(), v.end(), f);
-    v.erase(newEnd, v.end());
-}
-
-} // anonymous
-
-VulkanExternalImageManager::VulkanExternalImageManager(VulkanPlatform* platform,
-        VulkanSamplerCache* samplerCache, VulkanYcbcrConversionCache* ycbcrConversionCache,
-        VulkanDescriptorSetCache* setCache, VulkanDescriptorSetLayoutCache* layoutCache)
-    : mPlatform(platform),
-      mSamplerCache(samplerCache),
-      mYcbcrConversionCache(ycbcrConversionCache),
-      mDescriptorSetCache(setCache),
-      mDescriptorSetLayoutCache(layoutCache) {
-}
-
-VulkanExternalImageManager::~VulkanExternalImageManager() = default;
-
-void VulkanExternalImageManager::terminate() {
-    mSetAndLayouts.clear();
-    mSetBindings.clear();
-    mImages.clear();
-}
-
-void VulkanExternalImageManager::onBeginFrame() {
-    std::for_each(mImages.begin(), mImages.end(), [](ImageData& image) {
-        image.hasBeenValidated = false;
-    });
-}
-
-bool VulkanExternalImageManager::prepareBindSets(SetArray const& sets) {
-    bool hasUpdated = false;
-    for (auto set: sets) {
-        if (!set) {
-            continue;
-        }
-        if (auto itr = std::find_if(mSetAndLayouts.begin(), mSetAndLayouts.end(),
-                    [&](auto const& setAndLayout) { return setAndLayout.first == set; });
-                itr != mSetAndLayouts.end()) {
-            hasUpdated = updateSetAndLayout(itr->first, itr->second) || hasUpdated;
-        }
-    }
-    return hasUpdated;
-}
-
-bool VulkanExternalImageManager::updateSetAndLayout(
-        fvkmemory::resource_ptr<VulkanDescriptorSet> set,
-        fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout) {
-    auto findImage = [&](fvkmemory::resource_ptr<VulkanTexture> texture) -> ImageData* {
-        auto itr = std::find_if(mImages.begin(), mImages.end(), [&](ImageData const& data) {
-            return data.ptr == texture;
-        });
-        assert_invariant(itr != mImages.end());
-        return &(*itr);
-    };
-
-    //std::vector<std::pair<uint8_t, ImageData*>> externalImages;
-    utils::FixedCapacityVector<std::pair<uint8_t, VkSampler>> samplerAndBindings;
-    samplerAndBindings.reserve(MAX_SAMPLER_COUNT);
-
-    bool hasImageUpdates = false;
-    for (auto& bindingInfo : mSetBindings) {
-        if (bindingInfo.set != set) {
-            continue;
-        }
-        auto imageData = findImage(bindingInfo.image);
-        hasImageUpdates = updateImage(imageData) || hasImageUpdates;
-
-        auto samplerParams = bindingInfo.samplerParams;
-        // according to spec, these must match chromaFilter
-        // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCreateInfo.html#VUID-VkSamplerCreateInfo-minFilter-01645
-        samplerParams.filterMag = SamplerMagFilter::NEAREST;
-        samplerParams.filterMin = SamplerMinFilter::NEAREST;
-
-        auto sampler = mSamplerCache->getSampler({
-            .sampler = samplerParams,
-            .conversion = imageData->conversion,
-        });
-        samplerAndBindings.push_back({ bindingInfo.binding, sampler });
-    }
-
-    // We need to sort by binding number
-    std::sort(samplerAndBindings.begin(), samplerAndBindings.end());
-
-    utils::FixedCapacityVector<VkSampler> outSamplers;
-    outSamplers.reserve(MAX_SAMPLER_COUNT);
-    std::for_each(samplerAndBindings.begin(), samplerAndBindings.end(),
-            [&](auto const& b) { outSamplers.push_back(b.second); });
-
-    VkDescriptorSetLayout const oldLayout = layout->getVkLayout();
-    VkDescriptorSetLayout const newLayout =
-            mDescriptorSetLayoutCache->getVkLayout(layout->bitmask, outSamplers);
-    bool const hasLayoutUpdate = oldLayout != newLayout;
-    layout->setVkLayout(newLayout);
-
-    assert_invariant(
-            (!hasImageUpdates && !hasLayoutUpdate) ||
-            (hasImageUpdates && hasLayoutUpdate));
-
-    if (!hasLayoutUpdate) {
-        return false;
-    }
-
-    auto foldBitsInHalf = [](auto bitset) {
-        constexpr size_t BITMASK_LOWER_BITS_LEN = sizeof(bitset) * 4;
-        decltype(bitset) outBitset;
-        bitset.forEachSetBit([&](size_t index) { outBitset.set(index % BITMASK_LOWER_BITS_LEN); });
-        return outBitset;
-    };
-    // We need to build a new descriptor set from the new layout
-    VkDescriptorSet oldSet = set->getVkSet();
-    VkDescriptorSet newSet = mDescriptorSetCache->getVkSet(layout);
-
-    using Bitmask = fvkutils::UniformBufferBitmask;
-    static_assert(sizeof(Bitmask) * 8 == fvkutils::MAX_DESCRIPTOR_SET_BITMASK_BITS);
-
-    auto const ubo = layout->bitmask.ubo | layout->bitmask.dynamicUbo;
-    auto const samplers = layout->bitmask.sampler & (~layout->bitmask.externalSampler);
-
-    // each bitmask denotes a binding index, and separated into two stages - vertex and buffer
-    // We fold the two stages into just the lower half of the bits to denote a combined set of
-    // bindings.
-    Bitmask const copyBindings = foldBitsInHalf(ubo | samplers);
-
-    // TODO: fix the size for better memory
-    std::vector<VkCopyDescriptorSet> copies;
-    copyBindings.forEachSetBit([&](size_t index) {
-        copies.push_back({
-            .sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET,
-            .srcSet = oldSet,
-            .srcBinding = (uint32_t) index,
-            .dstSet = newSet,
-            .dstBinding = (uint32_t) index,
-            .descriptorCount = 1,
-        });
-    });
-    vkUpdateDescriptorSets(mPlatform->getDevice(), 0, nullptr, copies.size(), copies.data());
-
-    set->setVkSet(newSet);
-
-    // We need to release the vkset, which is no longer used, back into the pool.
-    mDescriptorSetCache->manualRecyle(layout->count, oldLayout, oldSet);
-
-    // We need to update the external samplers in the set
-    for (auto& bindingInfo: mSetBindings) {
-        if (bindingInfo.set != set) {
-            continue;
-        }
-        mDescriptorSetCache->updateSampler(set, bindingInfo.binding, bindingInfo.image,
-                VK_NULL_HANDLE);
-    }
-    return true;
-}
-
-VkSamplerYcbcrConversion VulkanExternalImageManager::getVkSamplerYcbcrConversion(
-        VulkanPlatform::ExternalImageMetadata const& metadata) {
-    // This external image does not require external sampler (YUV conversion).
-    if (metadata.externalFormat == 0) {
-        return VK_NULL_HANDLE;
-    }
-    VulkanYcbcrConversionCache::Params ycbcrParams = {
-        .conversion = {
-            .ycbcrModel = fvkutils::getYcbcrModelConversionFilament(metadata.ycbcrModel),
-            .r = fvkutils::getSwizzleFilament(metadata.ycbcrConversionComponents.r, 0),
-            .g = fvkutils::getSwizzleFilament(metadata.ycbcrConversionComponents.g, 1),
-            .b = fvkutils::getSwizzleFilament(metadata.ycbcrConversionComponents.b, 2),
-            .a = fvkutils::getSwizzleFilament(metadata.ycbcrConversionComponents.a, 3),
-            .ycbcrRange = fvkutils::getYcbcrRangeFilament(metadata.ycbcrRange),
-            .xChromaOffset = fvkutils::getChromaLocationFilament(metadata.xChromaOffset),
-            .yChromaOffset = fvkutils::getChromaLocationFilament(metadata.yChromaOffset),
-
-            // Unclear where to get the chromaFilter, we just assume it's nearest.
-            .chromaFilter = SamplerMagFilter::NEAREST,
-        },
-        .format = metadata.filamentFormat,
-        .externalFormat = metadata.externalFormat,
-    };
-    return mYcbcrConversionCache->getConversion(ycbcrParams);
-}
-
-bool VulkanExternalImageManager::updateImage(ImageData* image) {
-    if (image->hasBeenValidated) {
-        return false;
-    }
-    image->hasBeenValidated = true;
-
-    auto metadata = mPlatform->extractExternalImageMetadata(image->platformHandle);
-    auto vkYcbcr = getVkSamplerYcbcrConversion(metadata);
-    if (vkYcbcr == image->conversion) {
-        return false;
-    }
-
-    image->ptr->setYcbcrConversion(vkYcbcr, metadata.externalFormat != 0);
-    image->conversion = vkYcbcr;
-    return true;
-}
-
-void VulkanExternalImageManager::addDescriptorSet(
-        fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout,
-        fvkmemory::resource_ptr<VulkanDescriptorSet> set) {
-    mSetAndLayouts.push_back({set, layout});
-}
-
-void VulkanExternalImageManager::removeDescriptorSet(
-        fvkmemory::resource_ptr<VulkanDescriptorSet> inSet) {
-    erasep<SetAndLayout>(mSetAndLayouts,
-            [&](auto const& setLayout) { return (setLayout.first == inSet); });
-    erasep<SetBindingInfo>(mSetBindings,
-            [&](auto const& bindingInfo) { return (bindingInfo.set == inSet); });
-}
-
-void VulkanExternalImageManager::removeDescriptorSetLayout(
-        fvkmemory::resource_ptr<VulkanDescriptorSetLayout> inLayout) {
-    erasep<SetAndLayout>(mSetAndLayouts,
-            [&](auto const& setLayout) { return (setLayout.second == inLayout); });
-}
-
-void VulkanExternalImageManager::bindExternallySampledTexture(
-        fvkmemory::resource_ptr<VulkanDescriptorSet> set, uint8_t bindingPoint,
-        fvkmemory::resource_ptr<VulkanTexture> image, SamplerParams samplerParams) {
-    // Should we do duplicate validation here?
-    mSetBindings.push_back({ bindingPoint, image, set, samplerParams });
-}
-
-void VulkanExternalImageManager::addExternallySampledTexture(
-        fvkmemory::resource_ptr<VulkanTexture> image,
-        Platform::ExternalImageHandleRef platformHandleRef) {
-    mImages.push_back({ image, platformHandleRef, false });
-}
-
-void VulkanExternalImageManager::removeExternallySampledTexture(
-        fvkmemory::resource_ptr<VulkanTexture> image) {
-    erasep<SetBindingInfo>(mSetBindings,
-            [&](auto const& bindingInfo) { return (bindingInfo.image == image); });
-    erasep<ImageData>(mImages, [&](auto const& imageData) { return imageData.ptr == image; });
-}
-
-bool VulkanExternalImageManager::isExternallySampledTexture(
-        fvkmemory::resource_ptr<VulkanTexture> image) const {
-    return std::find_if(mImages.begin(), mImages.end(),
-                   [&](auto const& imageData) { return imageData.ptr == image; }) != mImages.end();
-}
-
-
-} // namesapce filament::backend

filament/backend/src/vulkan/VulkanExternalImageManager.h

@@ -1,115 +0,0 @@
-/*
- * Copyright (C) 2025 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TNT_FILAMENT_BACKEND_CACHING_VULKANEXTERNALIMAGEMANAGER_H
-#define TNT_FILAMENT_BACKEND_CACHING_VULKANEXTERNALIMAGEMANAGER_H
-
-#include "VulkanHandles.h"
-
-#include <backend/DriverEnums.h>
-
-#include <array>
-#include <vector>
-
-namespace filament::backend {
-
-class VulkanYcbcrConversionCache;
-class VulkanSamplerCache;
-class VulkanDescriptorSetLayoutCache;
-class VulkanDescriptorSetCache;
-
-// Manages the logic of external images and their quirks wrt Vulikan.
-class VulkanExternalImageManager {
-public:
-
-    VulkanExternalImageManager(
-            VulkanPlatform* platform,
-            VulkanSamplerCache* samplerCache,
-            VulkanYcbcrConversionCache* ycbcrConversionCache,
-            VulkanDescriptorSetCache* setCache,
-            VulkanDescriptorSetLayoutCache* layoutCache);
-
-    ~VulkanExternalImageManager();
-
-    void terminate();
-
-    void onBeginFrame();
-
-    using SetArray = std::array<fvkmemory::resource_ptr<VulkanDescriptorSet>,
-            VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;
-
-    // This sets the currently bound layouts objects for the pipeline
-    bool prepareBindSets(SetArray const& layouts);
-
-    void addDescriptorSet(fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout,
-            fvkmemory::resource_ptr<VulkanDescriptorSet> set);
-
-    void removeDescriptorSetLayout(fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout);
-
-    void removeDescriptorSet(fvkmemory::resource_ptr<VulkanDescriptorSet> set);
-
-    void bindExternallySampledTexture(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
-            uint8_t bindingPoint, fvkmemory::resource_ptr<VulkanTexture> image,
-            SamplerParams samplerParams);
-
-    void addExternallySampledTexture(fvkmemory::resource_ptr<VulkanTexture> image,
-            Platform::ExternalImageHandleRef platformHandleRef);
-
-    void removeExternallySampledTexture(fvkmemory::resource_ptr<VulkanTexture> image);
-
-    bool isExternallySampledTexture(fvkmemory::resource_ptr<VulkanTexture> image) const;
-
-    VkSamplerYcbcrConversion getVkSamplerYcbcrConversion(
-            VulkanPlatform::ExternalImageMetadata const& metadata);
-
-private:
-
-    struct ImageData {
-        fvkmemory::resource_ptr<VulkanTexture> ptr;
-        Platform::ExternalImageHandle platformHandle;
-        bool hasBeenValidated = false; // indicates whether the image has been validated *this frame*
-        VkSamplerYcbcrConversion conversion = VK_NULL_HANDLE;
-    };
-
-    bool updateSetAndLayout(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
-            fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout);
-    bool updateImage(ImageData* imageData);
-
-    VulkanPlatform* mPlatform;
-    VulkanSamplerCache* mSamplerCache;
-    VulkanYcbcrConversionCache* mYcbcrConversionCache;
-    VulkanDescriptorSetCache* mDescriptorSetCache;
-    VulkanDescriptorSetLayoutCache* mDescriptorSetLayoutCache;
-
-    using SetAndLayout = std::pair<fvkmemory::resource_ptr<VulkanDescriptorSet>,
-            fvkmemory::resource_ptr<VulkanDescriptorSetLayout>>;
-
-    struct SetBindingInfo {
-        uint8_t binding = 0;
-        fvkmemory::resource_ptr<VulkanTexture> image;
-        fvkmemory::resource_ptr<VulkanDescriptorSet> set;
-        SamplerParams samplerParams;
-    };
-
-    // Use vectors instead of hash maps because we only expect small number of entries.
-    std::vector<SetAndLayout> mSetAndLayouts;
-    std::vector<SetBindingInfo> mSetBindings;
-    std::vector<ImageData> mImages;
-};
-
-} // filament::backend
-
-#endif // TNT_FILAMENT_BACKEND_CACHING_VULKANEXTERNALIMAGEMANAGER_H

filament/backend/src/vulkan/VulkanFboCache.cpp

@@ -340,15 +340,21 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey const& config) noexcept
     return renderPass;
 }
 
-void VulkanFboCache::reset() noexcept {
-    for (auto pair : mFramebufferCache) {
+void VulkanFboCache::resetFramebuffers() noexcept {
+    for (const auto& pair: mFramebufferCache) {
         mRenderPassRefCount[pair.first.renderPass]--;
         vkDestroyFramebuffer(mDevice, pair.second.handle, VKALLOC);
     }
     mFramebufferCache.clear();
-    for (auto pair : mRenderPassCache) {
+}
+
+void VulkanFboCache::terminate() noexcept {
+    resetFramebuffers();
+
+    for (const auto& pair: mRenderPassCache) {
         vkDestroyRenderPass(mDevice, pair.second.handle, VKALLOC);
     }
+    mRenderPassRefCount.clear();
     mRenderPassCache.clear();
 }
 

filament/backend/src/vulkan/VulkanFboCache.h

@@ -106,8 +106,11 @@ public:
     // Evicts old unused Vulkan objects. Call this once per frame.
     void gc() noexcept;
 
+    // Frees all Framebuffer objects. Call this every time a the swapchain is resized
+    void resetFramebuffers() noexcept;
+
     // Frees all Vulkan objects. Call this during shutdown before the device is destroyed.
-    void reset() noexcept;
+    void terminate() noexcept;
 
 private:
     VkDevice mDevice;

filament/backend/src/vulkan/VulkanPipelineCache.cpp

@@ -35,7 +35,12 @@ using namespace bluevk;
 namespace filament::backend {
 
 VulkanPipelineCache::VulkanPipelineCache(VkDevice device)
-        : mDevice(device) {}
+    : mDevice(device) {
+    VkPipelineCacheCreateInfo createInfo = {
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
+    };
+    bluevk::vkCreatePipelineCache(mDevice, &createInfo, VKALLOC, &mPipelineCache);
+}
 
 void VulkanPipelineCache::bindLayout(VkPipelineLayout layout) noexcept {
     mPipelineRequirements.layout = layout;
@@ -215,7 +220,7 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
     PipelineCacheEntry cacheEntry = {
         .lastUsed = mCurrentTime,
     };
-    VkResult error = vkCreateGraphicsPipelines(mDevice, VK_NULL_HANDLE, 1, &pipelineCreateInfo,
+    VkResult error = vkCreateGraphicsPipelines(mDevice, mPipelineCache, 1, &pipelineCreateInfo,
             VKALLOC, &cacheEntry.handle);
     assert_invariant(error == VK_SUCCESS);
     if (error != VK_SUCCESS) {
@@ -271,6 +276,8 @@ void VulkanPipelineCache::terminate() noexcept {
     }
     mPipelines.clear();
     mBoundPipeline = {};
+
+    vkDestroyPipelineCache(mDevice, mPipelineCache, VKALLOC);
 }
 
 void VulkanPipelineCache::gc() noexcept {

filament/backend/src/vulkan/VulkanPipelineCache.h

@@ -198,6 +198,10 @@ private:
     // Immutable state.
     VkDevice mDevice = VK_NULL_HANDLE;
 
+    // Vuklan Driver pipeline cache handle. In the cases a pipeline has been  evicted by the `gc`,
+    // recreating the same pipeline is cheaper, helping with frame stalling.
+    VkPipelineCache mPipelineCache = VK_NULL_HANDLE;
+
     // Current requirements for the pipeline layout, pipeline, and descriptor sets.
     PipelineKey mPipelineRequirements = {};
 

filament/backend/src/vulkan/VulkanSamplerCache.cpp

@@ -18,7 +18,6 @@
 
 #include "VulkanConstants.h"
 #include "vulkan/utils/Conversion.h"
-#include "vulkan/vulkan_core.h"
 
 #include <utils/Panic.h>
 

filament/backend/src/vulkan/VulkanSwapChain.cpp

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

filament/backend/src/vulkan/VulkanSwapChain.h

@@ -49,7 +49,9 @@ struct VulkanSwapChain : public HwSwapChain, fvkmemory::Resource {
 
     void present();
 
-    void acquire(bool& reized);
+    // Acquire a new image from the swapchain. If the image is not available it would wait until it
+    // is.
+    void acquire(bool& resized);
 
     fvkmemory::resource_ptr<VulkanTexture> getCurrentColor() const noexcept {
         uint32_t const imageIndex = mCurrentSwapIndex;
@@ -99,7 +101,6 @@ private:
     VkExtent2D mExtent;
     uint32_t mLayerCount;
     uint32_t mCurrentSwapIndex;
-    std::function<void(Platform::SwapChain* handle)> mExplicitImageReadyWait = nullptr;
     bool mAcquired;
     bool mIsFirstRenderPass;
 };

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

@@ -132,10 +132,6 @@ public:
         return id() == other.id() && type() == other.type();
     }
 
-    inline bool operator!=(resource_ptr<D> const& other) const {
-        return !((*this) == other);
-    }
-
     inline explicit operator bool() const {
         return bool(mRef);
     }

filament/backend/src/vulkan/platform/VulkanPlatform.cpp

@@ -993,6 +993,30 @@ VkQueue VulkanPlatform::getProtectedGraphicsQueue() const noexcept {
     return mImpl->mProtectedGraphicsQueue;
 }
 
+VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadata(
+        ExternalImageHandleRef externalImage) {
+    return getExternalImageMetadataImpl(externalImage, mImpl->mDevice);
+}
+
+VulkanPlatform::ImageData VulkanPlatform::createExternalImageData(
+        ExternalImageHandleRef externalImage, const ExternalImageMetadata& metadata,
+        uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
+    return createExternalImageDataImpl(externalImage, mImpl->mDevice, metadata, memoryTypeIndex,
+            usage);
+}
+
+VkSampler VulkanPlatform::createExternalSampler(SamplerYcbcrConversion chroma,
+        SamplerParams sampler, uint32_t internalFormat) {
+    return createExternalSamplerImpl(mImpl->mDevice, chroma, sampler, internalFormat);
+}
+
+VkImageView VulkanPlatform::createExternalImageView(SamplerYcbcrConversion chroma,
+        uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
+        VkImageViewType viewType, VkComponentMapping swizzle) {
+    return createExternalImageViewImpl(mImpl->mDevice, chroma, internalFormat, image, range,
+            viewType, swizzle);
+}
+
 ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() const {
     return getSwapchainInstanceExtensionsImpl();
 }

filament/backend/src/vulkan/platform/VulkanPlatformAndroid.cpp

@@ -15,14 +15,14 @@
  */
 #include <backend/platforms/VulkanPlatformAndroid.h>
 
-#include "vulkan/VulkanConstants.h"
-#include "vulkan/VulkanContext.h"
-#include "vulkan/vulkan_core.h"
-
 #include <backend/DriverEnums.h>
 #include <private/backend/BackendUtilsAndroid.h>
 
+#include "vulkan/VulkanConstants.h"
+
 #include <utils/Panic.h>
+#include "vulkan/utils/Image.h"
+#include "vulkan/utils/Conversion.h"
 
 #include <bluevk/BlueVK.h>
 
@@ -57,7 +57,7 @@ VkFormat transformVkFormat(VkFormat format, bool sRGB) {
 }
 
 bool isProtectedFromUsage(uint64_t usage) {
-    return usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
+    return (usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT) ? true : false;
 }
 
 std::pair<VkFormat, VkImageUsageFlags> getVKFormatAndUsage(const AHardwareBuffer_Desc& desc,
@@ -120,9 +120,7 @@ std::pair<VkFormat, VkImageUsageFlags> getVKFormatAndUsage(const AHardwareBuffer
     usage = 0;
     if (desc.usage & AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE) {
         usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
-
-        // We shouldn't be using external samplers as input attachments
-        // usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+        usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
     }
     if (desc.usage & AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER) {
         if (isDepthFormat) {
@@ -138,38 +136,87 @@ std::pair<VkFormat, VkImageUsageFlags> getVKFormatAndUsage(const AHardwareBuffer
     return { format, usage };
 }
 
-std::pair<TextureFormat, TextureUsage> getFilamentFormatAndUsage(const AHardwareBuffer_Desc& desc,
-        bool sRGB) {
-    auto const format = mapToFilamentFormat(desc.format, sRGB);
-    return {
-        format,
-        mapToFilamentUsage(desc.usage, format),
-    };
-}
+VulkanPlatform::ImageData allocateExternalImage(AHardwareBuffer* buffer, VkDevice device,
+        VulkanPlatform::ExternalImageMetadata const& metadata, uint32_t memoryTypeIndex,
+        VkImageUsageFlags usage) {
+    VulkanPlatform::ImageData data;
 
+    // if external format we need to specifiy it in the allocation
+    const bool useExternalFormat = metadata.format == VK_FORMAT_UNDEFINED;
+
+    const VkExternalFormatANDROID externalFormat = {
+        .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
+        .pNext = nullptr,
+        // pass down the format (external means we don't have it VK defined)
+        .externalFormat = metadata.externalFormat,
+    };
+    const VkExternalMemoryImageCreateInfo externalCreateInfo = {
+        .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+        .pNext = useExternalFormat ? &externalFormat : nullptr,
+        .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+    };
+
+    VkImageCreateInfo imageInfo{ .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+    imageInfo.pNext = &externalCreateInfo;
+    imageInfo.format = metadata.format;
+    imageInfo.imageType = VK_IMAGE_TYPE_2D;
+    imageInfo.extent = {
+        metadata.width,
+        metadata.height,
+        1u,
+    };
+    imageInfo.mipLevels = 1;
+    imageInfo.arrayLayers = metadata.layers;
+    imageInfo.samples = metadata.samples;
+    imageInfo.usage = usage;
+
+    VkResult result = vkCreateImage(device, &imageInfo, VKALLOC, &data.first);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+            << "vkCreateImage failed with error=" << static_cast<int32_t>(result);
+
+    // Allocate the memory
+    VkImportAndroidHardwareBufferInfoANDROID androidHardwareBufferInfo = {
+        .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
+        .pNext = nullptr,
+        .buffer = buffer,
+    };
+    VkMemoryDedicatedAllocateInfo memoryDedicatedAllocateInfo = {
+        .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
+        .pNext = &androidHardwareBufferInfo,
+        .image = data.first,
+        .buffer = VK_NULL_HANDLE,
+    };
+    VkMemoryAllocateInfo allocInfo = {
+        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+        .pNext = &memoryDedicatedAllocateInfo,
+        .allocationSize = metadata.allocationSize,
+        .memoryTypeIndex = memoryTypeIndex,
+    };
+    result = vkAllocateMemory(device, &allocInfo, VKALLOC, &data.second);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+            << "vkAllocateMemory failed with error=" << static_cast<int32_t>(result);
+
+    return data;
+}
 
 }// namespace
 
-VulkanPlatformAndroid::ExternalImageVulkanAndroid::~ExternalImageVulkanAndroid() {
-    if (__builtin_available(android 26, *)) {
-        if (aHardwareBuffer) {
-            AHardwareBuffer_release(aHardwareBuffer);
-        }
-    }
-}
+VulkanPlatformAndroid::ExternalImageVulkanAndroid::~ExternalImageVulkanAndroid() = default;
 
 Platform::ExternalImageHandle VulkanPlatformAndroid::createExternalImage(
         AHardwareBuffer const* buffer, bool sRGB) noexcept {
     if (__builtin_available(android 26, *)) {
-        auto bufferImpl = const_cast<AHardwareBuffer*>(buffer);
-        AHardwareBuffer_acquire(bufferImpl);
-
         AHardwareBuffer_Desc hardwareBufferDescription = {};
         AHardwareBuffer_describe(buffer, &hardwareBufferDescription);
 
         auto* const p = new (std::nothrow) ExternalImageVulkanAndroid;
         p->aHardwareBuffer = const_cast<AHardwareBuffer*>(buffer);
         p->sRGB = sRGB;
+        p->height = hardwareBufferDescription.height;
+        p->width = hardwareBufferDescription.width;
+        TextureFormat textureFormat = mapToFilamentFormat(hardwareBufferDescription.format, sRGB);
+        p->format = textureFormat;
+        p->usage = mapToFilamentUsage(hardwareBufferDescription.usage, textureFormat);
         return Platform::ExternalImageHandle{ p };
     }
 
@@ -178,20 +225,23 @@ Platform::ExternalImageHandle VulkanPlatformAndroid::createExternalImage(
 
 VulkanPlatformAndroid::ExternalImageDescAndroid VulkanPlatformAndroid::getExternalImageDesc(
         ExternalImageHandleRef externalImage) const noexcept {
-    auto metadata = extractExternalImageMetadata(externalImage);
+    auto const* fvkExternalImage =
+            static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());
+
     return {
-        .width = metadata.width,
-        .height = metadata.height,
-        .format = metadata.filamentFormat,
-        .usage = metadata.filamentUsage,
+        .width = fvkExternalImage->width,
+        .height = fvkExternalImage->height,
+        .format = fvkExternalImage->format,
+        .usage = fvkExternalImage->usage,
     };
 }
 
-VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::extractExternalImageMetadata(
-        ExternalImageHandleRef image) const {
-    auto const* fvkExternalImage = static_cast<ExternalImageVulkanAndroid const*>(image.get());
+VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::getExternalImageMetadata(
+        ExternalImageHandleRef externalImage) {
+    auto const* fvkExternalImage =
+            static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());
 
-    ExternalImageMetadata metadata = {};
+    ExternalImageMetadata metadata;
     AHardwareBuffer* buffer = fvkExternalImage->aHardwareBuffer;
     if (__builtin_available(android 26, *)) {
         AHardwareBuffer_Desc bufferDesc;
@@ -199,30 +249,16 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::extractExternalImag
         metadata.width = bufferDesc.width;
         metadata.height = bufferDesc.height;
         metadata.layers = bufferDesc.layers;
+        metadata.isProtected = isProtectedFromUsage(bufferDesc.usage);
         std::tie(metadata.format, metadata.usage) =
                 getVKFormatAndUsage(bufferDesc, fvkExternalImage->sRGB);
-        std::tie(metadata.filamentFormat, metadata.filamentUsage) =
-                getFilamentFormatAndUsage(bufferDesc, fvkExternalImage->sRGB);
-
-        if (isProtectedFromUsage(bufferDesc.usage)) {
-            metadata.filamentUsage |= TextureUsage::PROTECTED;
-        }
-
-        // TODO: The following seems unnecessary. we should be able to discern directly from the
-        // bufferDesc.
-        if (any(metadata.filamentUsage & TextureUsage::BLIT_SRC)) {
-            metadata.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-        }
-
-        if (any(metadata.filamentUsage & (TextureUsage::BLIT_DST | TextureUsage::UPLOADABLE))) {
-            metadata.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-        }
     }
-    metadata.samples = VK_SAMPLE_COUNT_1_BIT;
 
+    metadata.samples = VK_SAMPLE_COUNT_1_BIT;
 
     VkAndroidHardwareBufferFormatPropertiesANDROID formatInfo = {
         .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
+        .pNext = nullptr,
     };
     VkAndroidHardwareBufferPropertiesANDROID properties = {
         .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
@@ -232,116 +268,138 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::extractExternalImag
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
             << "vkGetAndroidHardwareBufferProperties failed with error="
             << static_cast<int32_t>(result);
+
     VkFormat bufferPropertiesFormat = transformVkFormat(formatInfo.format, fvkExternalImage->sRGB);
     FILAMENT_CHECK_POSTCONDITION(metadata.format == bufferPropertiesFormat)
             << "mismatched image format( " << metadata.format << ") and queried format("
             << bufferPropertiesFormat << ") for external image (AHB)";
     metadata.externalFormat = formatInfo.externalFormat;
-
-    // Choose either externalFormat > 0 or metadata.format and prefer the latter.
-    if (metadata.externalFormat > 0 &&  metadata.format != VK_FORMAT_UNDEFINED) {
-        // See VUID-VkImageCreateInfo-pNext-09457
-        metadata.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
-        metadata.externalFormat = 0;
-    }
-
     metadata.allocationSize = properties.allocationSize;
     metadata.memoryTypeBits = properties.memoryTypeBits;
-
-    metadata.ycbcrConversionComponents = formatInfo.samplerYcbcrConversionComponents;
-    metadata.ycbcrModel = formatInfo.suggestedYcbcrModel;
-    metadata.ycbcrRange = formatInfo.suggestedYcbcrRange;
-    metadata.xChromaOffset = formatInfo.suggestedXChromaOffset;
-    metadata.yChromaOffset = formatInfo.suggestedYChromaOffset;
-
     return metadata;
 }
 
-VulkanPlatformAndroid::ImageData VulkanPlatformAndroid::createVkImageFromExternal(
-        ExternalImageHandleRef externalImage) const {
-    auto const& metadata = extractExternalImageMetadata(externalImage);
-
+VulkanPlatformAndroid::ImageData VulkanPlatformAndroid::createExternalImageData(
+        ExternalImageHandleRef externalImage, const ExternalImageMetadata& metadata,
+        uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
     auto const* fvkExternalImage =
             static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());
-    AHardwareBuffer* buffer = fvkExternalImage->aHardwareBuffer;
+    ImageData data = allocateExternalImage(fvkExternalImage->aHardwareBuffer, getDevice(), metadata,
+            memoryTypeIndex, usage);
+    VkResult result = vkBindImageMemory(getDevice(), data.first, data.second, 0);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+        << "vkBindImageMemory error=" << static_cast<int32_t>(result);
+    return data;
+}
 
-    // if external format we need to specifiy it in the allocation
-    bool const useExternalFormat = metadata.format == VK_FORMAT_UNDEFINED;
-
-    VkExternalFormatANDROID const externalFormat = {
+VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device, SamplerYcbcrConversion chroma,
+            uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
+            VkImageViewType viewType, VkComponentMapping swizzle){
+    VkExternalFormatANDROID externalFormat = {
         .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
-        .pNext = nullptr,
-        .externalFormat = metadata.externalFormat,
-    };
-    VkExternalMemoryImageCreateInfo const externalCreateInfo = {
-        .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
-        .pNext = useExternalFormat ? &externalFormat : nullptr,
-        .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+        .externalFormat = internalFormat,
     };
 
-    VkImageCreateInfo const imageInfo{
-        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
-        .pNext = &externalCreateInfo,
-        .flags = useExternalFormat ? VK_IMAGE_CREATE_ALIAS_BIT : 0u,
-        .imageType = VK_IMAGE_TYPE_2D,
-        .format = metadata.format,
-        .extent = {
-            metadata.width,
-            metadata.height,
-            1u,
-        },
-        .mipLevels = 1,
-        .arrayLayers = metadata.layers,
-        .samples = metadata.samples,
-        .usage = metadata.usage,
+    TextureSwizzle const swizzleArray[] = {chroma.r, chroma.g, chroma.b, chroma.a};
+    VkSamplerYcbcrConversionCreateInfo conversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+        .pNext = &externalFormat,
+        .format = VK_FORMAT_UNDEFINED,
+        .ycbcrModel = fvkutils::getYcbcrModelConversion(chroma.ycbcrModel),
+        .ycbcrRange = fvkutils::getYcbcrRange(chroma.ycbcrRange),
+        .components = fvkutils::getSwizzleMap(swizzleArray),
+        .xChromaOffset = fvkutils::getChromaLocation(chroma.xChromaOffset),
+        .yChromaOffset = fvkutils::getChromaLocation(chroma.yChromaOffset),
+        .chromaFilter = fvkutils::getFilter(chroma.chromaFilter),
     };
-
-    VkDevice const device = getDevice();
-
-    VkImage image;
-    VkResult result = vkCreateImage(device, &imageInfo, VKALLOC, &image);
+    VkSamplerYcbcrConversion conversion = VK_NULL_HANDLE;
+    VkResult result = vkCreateSamplerYcbcrConversion(device, &conversionInfo,
+                                                     nullptr, &conversion);
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkCreateImage failed with error=" << static_cast<int32_t>(result);
+        << "Unable to create Ycbcr Conversion."
+        << " error=" << static_cast<int32_t>(result);
 
-    // Allocate the memory
-    VkImportAndroidHardwareBufferInfoANDROID const androidHardwareBufferInfo = {
-        .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
-        .buffer = buffer,
+    VkSamplerYcbcrConversionInfo samplerYcbcrConversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
+        .conversion = conversion,
     };
-    VkMemoryDedicatedAllocateInfo const memoryDedicatedAllocateInfo = {
-        .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
-        .pNext = &androidHardwareBufferInfo,
+
+    VkImageViewCreateInfo viewInfo = {
+        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+        .pNext = &samplerYcbcrConversionInfo,
+        .flags = 0,
         .image = image,
-        .buffer = VK_NULL_HANDLE,
+        .viewType = viewType,
+        .format = VK_FORMAT_UNDEFINED,
+        .components = swizzle,
+        .subresourceRange = range,
+    };
+    VkImageView imageView;
+    result = vkCreateImageView(device, &viewInfo, VKALLOC, &imageView);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+        << "Unable to create VkImageView."
+        << " error=" << static_cast<int32_t>(result);
+
+    return imageView;
+}
+
+VkSampler VulkanPlatform::createExternalSamplerImpl(
+        VkDevice device, SamplerYcbcrConversion chroma, SamplerParams params,
+        uint32_t internalFormat) {
+    VkExternalFormatANDROID externalFormat = {
+        .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
+        .externalFormat = internalFormat,
     };
 
-    VkPhysicalDeviceMemoryProperties memoryProperties;
-    vkGetPhysicalDeviceMemoryProperties(getPhysicalDevice(), &memoryProperties);
-
-
-    VkMemoryPropertyFlags const requiredMemoryFlags =
-            any(metadata.filamentUsage & TextureUsage::UPLOADABLE)
-                    ? VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
-                    : VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
-
-    uint32_t const memoryTypeIndex = VulkanContext::selectMemoryType(memoryProperties,
-            metadata.memoryTypeBits, requiredMemoryFlags);
-
-    VkMemoryAllocateInfo const allocInfo = {
-        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
-        .pNext = &memoryDedicatedAllocateInfo,
-        .allocationSize = metadata.allocationSize,
-        .memoryTypeIndex = memoryTypeIndex,
+    TextureSwizzle const swizzleArray[] = {chroma.r, chroma.g, chroma.b, chroma.a};
+    VkSamplerYcbcrConversionCreateInfo conversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+        .pNext = &externalFormat,
+        .format = VK_FORMAT_UNDEFINED,
+        .ycbcrModel = fvkutils::getYcbcrModelConversion(chroma.ycbcrModel),
+        .ycbcrRange = fvkutils::getYcbcrRange(chroma.ycbcrRange),
+        .components = fvkutils::getSwizzleMap(swizzleArray),
+        .xChromaOffset = fvkutils::getChromaLocation(chroma.xChromaOffset),
+        .yChromaOffset = fvkutils::getChromaLocation(chroma.yChromaOffset),
+        .chromaFilter = fvkutils::getFilter(chroma.chromaFilter),
     };
-    VkDeviceMemory memory;
-    result = vkAllocateMemory(device, &allocInfo, VKALLOC, &memory);
+    VkSamplerYcbcrConversion conversion = VK_NULL_HANDLE;
+    VkResult result = vkCreateSamplerYcbcrConversion(device, &conversionInfo,
+                                                     nullptr, &conversion);
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkAllocateMemory failed with error=" << static_cast<int32_t>(result);
+        << "Unable to create Ycbcr Conversion."
+        << " error=" << static_cast<int32_t>(result);
 
-    result = vkBindImageMemory(getDevice(), image, memory, 0);
+    VkSamplerYcbcrConversionInfo samplerYcbcrConversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
+        .pNext = nullptr,
+        .conversion = conversion,
+    };
+
+    VkSamplerCreateInfo samplerInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+        .pNext = &samplerYcbcrConversionInfo,
+        .magFilter = fvkutils::getFilter(params.filterMag),
+        .minFilter = fvkutils::getFilter(params.filterMin),
+        .mipmapMode = fvkutils::getMipmapMode(params.filterMin),
+        .addressModeU = fvkutils::getWrapMode(params.wrapS),
+        .addressModeV = fvkutils::getWrapMode(params.wrapT),
+        .addressModeW = fvkutils::getWrapMode(params.wrapR),
+        .anisotropyEnable = params.anisotropyLog2 == 0 ? VK_FALSE : VK_TRUE,
+        .maxAnisotropy = (float)(1u << params.anisotropyLog2),
+        .compareEnable = fvkutils::getCompareEnable(params.compareMode),
+        .compareOp = fvkutils::getCompareOp(params.compareFunc),
+        .minLod = 0.0f,
+        .maxLod = fvkutils::getMaxLod(params.filterMin),
+        .borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
+        .unnormalizedCoordinates = VK_FALSE,
+    };
+    VkSampler sampler;
+    result = vkCreateSampler(device, &samplerInfo, VKALLOC, &sampler);
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkBindImageMemory error=" << static_cast<int32_t>(result);
-    return { image, memory };
+        << "Unable to create sampler."
+        << " error=" << static_cast<int32_t>(result);
+    return sampler;
 }
 
 VulkanPlatform::ExtensionSet VulkanPlatformAndroid::getSwapchainInstanceExtensions() const {
@@ -369,9 +427,20 @@ VulkanPlatform::SurfaceBundle VulkanPlatformAndroid::createVkSurfaceKHR(void* na
 // Deprecated platform dependent helper methods
 VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl() { return {}; }
 
+VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device) {
+    return ExternalImageMetadata{};
+}
+
+VulkanPlatform::ImageData VulkanPlatform::createExternalImageDataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device,
+        const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
+    return ImageData{};
+}
+
 VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
         VkInstance instance, uint64_t flags) noexcept {
     return SurfaceBundle{};
 }
 
-} // namespace filament::backend
+}// namespace filament::backend

filament/backend/src/vulkan/platform/VulkanPlatformApple.mm

@@ -24,28 +24,12 @@
 #include <bluevk/BlueVK.h>
 
 // Platform specific includes and defines
-#if defined(__APPLE__)
-    #include <Cocoa/Cocoa.h>
-    #import <Metal/Metal.h>
-    #import <QuartzCore/CAMetalLayer.h>
+#include <Cocoa/Cocoa.h>
+#import <Metal/Metal.h>
+#import <QuartzCore/CAMetalLayer.h>
 
-    #ifndef VK_MVK_macos_surface
-         #error VK_MVK_macos_surface is not defined
-    #endif
-#elif defined(FILAMENT_IOS)
-    // Metal is not available when building for the iOS simulator on Desktop.
-    #define METAL_AVAILABLE __has_include(<QuartzCore/CAMetalLayer.h>)
-    #if METAL_AVAILABLE
-        #import <Metal/Metal.h>
-        #import <QuartzCore/CAMetalLayer.h>
-    #endif
-
-    #ifndef VK_MVK_ios_surface
-        #error VK_MVK_ios_surface is not defined
-    #endif
-    #define METALVIEW_TAG 255
-#else
-    #error Not a supported Apple + Vulkan platform
+#ifndef VK_MVK_macos_surface
+    #error VK_MVK_macos_surface is not defined
 #endif
 
 using namespace bluevk;
@@ -54,48 +38,52 @@ 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;
 }
 
+VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device) {
+    return {};
+}
+
+VulkanPlatform::ImageData VulkanPlatform::createExternalImageDataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device,
+        const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
+    return {};
+}
+
+VkSampler VulkanPlatform::createExternalSamplerImpl(VkDevice device,
+    SamplerYcbcrConversion chroma,
+    SamplerParams sampler,
+    uint32_t internalFormat) {
+    return VK_NULL_HANDLE;
+}
+
+VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device,
+        SamplerYcbcrConversion chroma, uint32_t internalFormat, VkImage image,
+        VkImageSubresourceRange range, VkImageViewType viewType, VkComponentMapping swizzle) {
+    return VK_NULL_HANDLE;
+}
+
 VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
         VkInstance instance, uint64_t flags) noexcept {
     VkSurfaceKHR surface;
-    #if defined(__APPLE__)
-        NSView* nsview = (__bridge NSView*) nativeWindow;
-        FILAMENT_CHECK_POSTCONDITION(nsview) << "Unable to obtain Metal-backed NSView.";
+    NSView* nsview = (__bridge NSView*) nativeWindow;
+    FILAMENT_CHECK_POSTCONDITION(nsview) << "Unable to obtain Metal-backed NSView.";
 
-        // Create the VkSurface.
-        FILAMENT_CHECK_POSTCONDITION(vkCreateMacOSSurfaceMVK)
-                << "Unable to load vkCreateMacOSSurfaceMVK.";
-        VkMacOSSurfaceCreateInfoMVK createInfo = {};
-        createInfo.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
-        createInfo.pView = (__bridge void*) nsview;
-        VkResult result = vkCreateMacOSSurfaceMVK((VkInstance) instance, &createInfo, VKALLOC,
-                (VkSurfaceKHR*) &surface);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-                << "vkCreateMacOSSurfaceMVK. error=" << static_cast<int32_t>(result);
-#elif defined(FILAMENT_IOS) && defined(METAL_AVAILABLE)
-    CAMetalLayer* metalLayer = (CAMetalLayer*) nativeWindow;
     // Create the VkSurface.
-    FILAMENT_CHECK_POSTCONDITION(vkCreateIOSSurfaceMVK)
-            << "Unable to load vkCreateIOSSurfaceMVK function.";
-    VkIOSSurfaceCreateInfoMVK createInfo = {};
-    createInfo.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
-    createInfo.pNext = NULL;
-    createInfo.flags = 0;
-    createInfo.pView = metalLayer;
-    VkResult result = vkCreateIOSSurfaceMVK((VkInstance) instance, &createInfo, VKALLOC,
+    FILAMENT_CHECK_POSTCONDITION(vkCreateMacOSSurfaceMVK)
+            << "Unable to load vkCreateMacOSSurfaceMVK.";
+    VkMacOSSurfaceCreateInfoMVK createInfo = {};
+    createInfo.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
+    createInfo.pView = (__bridge void*) nsview;
+    VkResult result = vkCreateMacOSSurfaceMVK((VkInstance) instance, &createInfo, VKALLOC,
             (VkSurfaceKHR*) &surface);
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkCreateIOSSurfaceMVK failed. error=" << static_cast<int32_t>(result);
-#endif
-        return std::make_tuple(surface, VkExtent2D{});
+            << "vkCreateMacOSSurfaceMVK. error=" << static_cast<int32_t>(result);
+    return std::make_tuple(surface, VkExtent2D{});
 }
 
 } // namespace filament::backend

filament/backend/src/vulkan/platform/VulkanPlatformLinuxWindows.cpp

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

filament/backend/src/webgpu/WGPUProgram.cpp

@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "WebGPUHandles.h"
+
+#include "WebGPUConstants.h"
+
+#include "DriverBase.h"
+#include <backend/DriverEnums.h>
+#include <backend/Program.h>
+
+#include <utils/Panic.h>
+#include <utils/ostream.h>
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <sstream>
+#include <string_view>
+#include <vector>
+
+namespace filament::backend {
+
+namespace {
+
+[[nodiscard]] constexpr std::string_view toString(ShaderStage stage) {
+    switch (stage) {
+        case ShaderStage::VERTEX:
+            return "vertex";
+        case ShaderStage::FRAGMENT:
+            return "fragment";
+        case ShaderStage::COMPUTE:
+            return "compute";
+    }
+}
+
+[[nodiscard]] wgpu::ShaderModule createShaderModule(wgpu::Device& device, const char* programName,
+        std::array<utils::FixedCapacityVector<uint8_t>, Program::SHADER_TYPE_COUNT> const&
+                shaderSource,
+        ShaderStage stage) {
+    utils::FixedCapacityVector<uint8_t> const& sourceBytes =
+            shaderSource[static_cast<size_t>(stage)];
+    if (sourceBytes.empty()) {
+        return nullptr;// nothing to compile, the shader was not provided
+    }
+    wgpu::ShaderModuleWGSLDescriptor wgslDescriptor{};
+    wgslDescriptor.code = wgpu::StringView(reinterpret_cast<const char*>(sourceBytes.data()));
+    std::stringstream labelStream;
+    labelStream << programName << " " << toString(stage) << " shader";
+    auto label = labelStream.str();
+    wgpu::ShaderModuleDescriptor descriptor{
+        .nextInChain = &wgslDescriptor,
+        .label = label.data()
+    };
+    wgpu::ShaderModule module = device.CreateShaderModule(&descriptor);
+    FILAMENT_CHECK_POSTCONDITION(module != nullptr) << "Failed to create " << descriptor.label;
+    module.GetCompilationInfo(wgpu::CallbackMode::AllowSpontaneous,
+            [&descriptor](auto const& status, wgpu::CompilationInfo const* info) {
+                switch (status) {
+                    case wgpu::CompilationInfoRequestStatus::CallbackCancelled:
+                        FWGPU_LOGW << "Shader compilation info callback cancelled for "
+                                   << descriptor.label << "?" << utils::io::endl;
+                        return;
+                    case wgpu::CompilationInfoRequestStatus::Success:
+                        break;
+                }
+                if (info != nullptr) {
+                    std::stringstream errorStream;
+                    int errorCount = 0;
+                    for (size_t msgIndex = 0; msgIndex < info->messageCount; msgIndex++) {
+                        wgpu::CompilationMessage const& message = info->messages[msgIndex];
+                        switch (message.type) {
+                            case wgpu::CompilationMessageType::Info:
+                                FWGPU_LOGI << descriptor.label << ": " << message.message
+                                           << " line#:" << message.lineNum
+                                           << " linePos:" << message.linePos
+                                           << " offset:" << message.offset
+                                           << " length:" << message.length << utils::io::endl;
+                                break;
+                            case wgpu::CompilationMessageType::Warning:
+                                FWGPU_LOGW << "Warning compiling " << descriptor.label << ": "
+                                           << message.message << " line#:" << message.lineNum
+                                           << " linePos:" << message.linePos
+                                           << " offset:" << message.offset
+                                           << " length:" << message.length << utils::io::endl;
+                                break;
+                            case wgpu::CompilationMessageType::Error:
+                                errorCount++;
+                                errorStream << "Error " << errorCount << " : "
+                                            << std::string_view(message.message)
+                                            << " line#:" << message.lineNum
+                                            << " linePos:" << message.linePos
+                                            << " offset:" << message.offset
+                                            << " length:" << message.length << "\n";
+                                break;
+                        }
+                    }
+                    FILAMENT_CHECK_POSTCONDITION(errorCount < 1)
+                            << errorCount << " error(s) compiling " << descriptor.label << ":\n"
+                            << errorStream.str();
+                }
+                FWGPU_LOGD << descriptor.label << " compiled successfully" << utils::io::endl;
+            });
+    return module;
+}
+
+std::vector<wgpu::ConstantEntry> convertConstants(
+        utils::FixedCapacityVector<filament::backend::Program::SpecializationConstant> const&
+                constantsInfo) {
+    std::vector<wgpu::ConstantEntry> constants(constantsInfo.size());
+    for (size_t i = 0; i < constantsInfo.size(); i++) {
+        filament::backend::Program::SpecializationConstant const& specConstant = constantsInfo[i];
+        wgpu::ConstantEntry& constantEntry = constants[i];
+        constantEntry.key = wgpu::StringView(std::to_string(specConstant.id));
+        if (auto* v = std::get_if<int32_t>(&specConstant.value)) {
+            constantEntry.value = static_cast<double>(*v);
+        } else if (auto* f = std::get_if<float>(&specConstant.value)) {
+            constantEntry.value = static_cast<double>(*f);
+        } else if (auto* b = std::get_if<bool>(&specConstant.value)) {
+            constantEntry.value = *b ? 0.0 : 1.0;
+        }
+    }
+    return constants;
+}
+
+}// namespace
+
+WGPUProgram::WGPUProgram(wgpu::Device& device, Program& program)
+    : HwProgram(program.getName()),
+      vertexShaderModule(createShaderModule(device, name.c_str_safe(), program.getShadersSource(),
+              ShaderStage::VERTEX)),
+      fragmentShaderModule(createShaderModule(device, name.c_str_safe(), program.getShadersSource(),
+              ShaderStage::FRAGMENT)),
+      computeShaderModule(createShaderModule(device, name.c_str_safe(), program.getShadersSource(),
+              ShaderStage::COMPUTE)),
+      constants(convertConstants(program.getSpecializationConstants())) {}
+
+}// namespace filament::backend

filament/backend/src/webgpu/WebGPUDriver.cpp

@@ -16,6 +16,7 @@
 
 #include "webgpu/WebGPUDriver.h"
 
+#include "WebGPUSwapChain.h"
 #include "webgpu/WebGPUConstants.h"
 #include <backend/platforms/WebGPUPlatform.h>
 
@@ -35,6 +36,7 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <sstream>
 #include <string_view>
 #include <utility>
@@ -116,7 +118,6 @@ void printLimits(wgpu::Limits const& limits) {
     printLimit("maxBufferSize", limits.maxBufferSize);
     printLimit("maxVertexAttributes", limits.maxVertexAttributes);
     printLimit("maxVertexBufferArrayStride", limits.maxVertexBufferArrayStride);
-    printLimit("maxInterStageShaderComponents", limits.maxInterStageShaderComponents);
     printLimit("maxInterStageShaderVariables", limits.maxInterStageShaderVariables);
     printLimit("maxColorAttachments", limits.maxColorAttachments);
     printLimit("maxColorAttachmentBytesPerSample", limits.maxColorAttachmentBytesPerSample);
@@ -158,8 +159,6 @@ void printAdapterDetails(wgpu::Adapter const& adapter) {
         FWGPU_LOGI << "  vendor ID: " << adapterInfo.vendorID << utils::io::endl;
         FWGPU_LOGI << "  subgroup min size: " << adapterInfo.subgroupMinSize << utils::io::endl;
         FWGPU_LOGI << "  subgroup max size: " << adapterInfo.subgroupMaxSize << utils::io::endl;
-        FWGPU_LOGI << "  compatibility mode: " << bool(adapterInfo.compatibilityMode)
-                   << utils::io::endl;
         FWGPU_LOGI << "  power preference: " << powerPreferenceStream.str() << utils::io::endl;
     }
     wgpu::SupportedFeatures supportedFeatures{};
@@ -175,55 +174,17 @@ void printAdapterDetails(wgpu::Adapter const& adapter) {
                     FWGPU_LOGI << "  " << nameStream.str().data() << utils::io::endl;
                 });
     }
-    wgpu::SupportedLimits supportedLimits{};
+    wgpu::Limits supportedLimits{};
     if (!adapter.GetLimits(&supportedLimits)) {
         FWGPU_LOGW << "Failed to get WebGPU adapter supported limits" << utils::io::endl;
     } else {
         FWGPU_LOGI << "WebGPU adapter supported limits:" << utils::io::endl;
-        printLimits(supportedLimits.limits);
+        printLimits(supportedLimits);
     }
 }
 #endif
 
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-void printSurfaceCapabilitiesDetails(wgpu::SurfaceCapabilities const& capabilities) {
-    std::stringstream usages_stream{};
-    usages_stream << capabilities.usages;
-    FWGPU_LOGI << "WebGPU surface capabilities:" << utils::io::endl;
-    FWGPU_LOGI << "  surface usages: " << usages_stream.str().data() << utils::io::endl;
-    FWGPU_LOGI << "  surface formats (" << capabilities.formatCount << "):" << utils::io::endl;
-    if (capabilities.formatCount > 0 && capabilities.formats != nullptr) {
-        std::for_each(capabilities.formats, capabilities.formats + capabilities.formatCount,
-                [](wgpu::TextureFormat const format) {
-                    std::stringstream format_stream{};
-                    format_stream << format;
-                    FWGPU_LOGI << "    " << format_stream.str().data() << utils::io::endl;
-                });
-    }
-    FWGPU_LOGI << "  surface present modes (" << capabilities.presentModeCount
-               << "):" << utils::io::endl;
-    if (capabilities.presentModeCount > 0 && capabilities.presentModes != nullptr) {
-        std::for_each(capabilities.presentModes,
-                capabilities.presentModes + capabilities.presentModeCount,
-                [](wgpu::PresentMode const presentMode) {
-                    std::stringstream present_mode_stream{};
-                    present_mode_stream << presentMode;
-                    FWGPU_LOGI << "    " << present_mode_stream.str().data() << utils::io::endl;
-                });
-    }
-    FWGPU_LOGI << "  surface alpha modes (" << capabilities.alphaModeCount
-               << "):" << utils::io::endl;
-    if (capabilities.alphaModeCount > 0 && capabilities.alphaModes != nullptr) {
-        std::for_each(capabilities.alphaModes,
-                capabilities.alphaModes + capabilities.alphaModeCount,
-                [](wgpu::CompositeAlphaMode const alphaMode) {
-                    std::stringstream alpha_mode_stream{};
-                    alpha_mode_stream << alphaMode;
-                    FWGPU_LOGI << "    " << alpha_mode_stream.str().data() << utils::io::endl;
-                });
-    }
-}
-#endif
+
 
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
 void printDeviceDetails(wgpu::Device const& device) {
@@ -240,12 +201,12 @@ void printDeviceDetails(wgpu::Device const& device) {
                     FWGPU_LOGI << "  " << nameStream.str().data() << utils::io::endl;
                 });
     }
-    wgpu::SupportedLimits supportedLimits{};
+    wgpu::Limits supportedLimits{};
     if (!device.GetLimits(&supportedLimits)) {
         FWGPU_LOGW << "Failed to get WebGPU supported device limits" << utils::io::endl;
     } else {
         FWGPU_LOGI << "WebGPU device supported limits:" << utils::io::endl;
-        printLimits(supportedLimits.limits);
+        printLimits(supportedLimits);
     }
 }
 #endif
@@ -267,6 +228,14 @@ WebGPUDriver::WebGPUDriver(WebGPUPlatform& platform, const Platform::DriverConfi
               driverConfig.disableHeapHandleTags) {
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
     printInstanceDetails(mPlatform.getInstance());
+#endif
+    mAdapter = mPlatform.requestAdapter(nullptr);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printAdapterDetails(mAdapter);
+#endif
+    mDevice = mPlatform.requestDevice(mAdapter);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printDeviceDetails(mDevice);
 #endif
 }
 
@@ -296,6 +265,7 @@ void WebGPUDriver::terminate() {
 }
 
 void WebGPUDriver::tick(int) {
+    mDevice.Tick();
 }
 
 void WebGPUDriver::beginFrame(int64_t monotonic_clock_ns,
@@ -325,15 +295,27 @@ void WebGPUDriver::finish(int) {
 }
 
 void WebGPUDriver::destroyRenderPrimitive(Handle<HwRenderPrimitive> rph) {
+   if (rph) {
+        destructHandle<WGPURenderPrimitive>(rph);
+    }
 }
 
 void WebGPUDriver::destroyVertexBufferInfo(Handle<HwVertexBufferInfo> vbih) {
+   if (vbih) {
+        destructHandle<WGPUVertexBufferInfo>(vbih);
+    }
 }
 
 void WebGPUDriver::destroyVertexBuffer(Handle<HwVertexBuffer> vbh) {
+    if (vbh) {
+        destructHandle<WGPUVertexBuffer>(vbh);
+    }
 }
 
 void WebGPUDriver::destroyIndexBuffer(Handle<HwIndexBuffer> ibh) {
+    if (ibh) {
+        destructHandle<WGPUIndexBuffer>(ibh);
+    }
 }
 
 void WebGPUDriver::destroyBufferObject(Handle<HwBufferObject> boh) {
@@ -343,12 +325,19 @@ void WebGPUDriver::destroyTexture(Handle<HwTexture> th) {
 }
 
 void WebGPUDriver::destroyProgram(Handle<HwProgram> ph) {
+    if (ph) {
+        destructHandle<WGPUProgram>(ph);
+    }
 }
 
 void WebGPUDriver::destroyRenderTarget(Handle<HwRenderTarget> rth) {
 }
 
 void WebGPUDriver::destroySwapChain(Handle<HwSwapChain> sch) {
+    if (sch) {
+        destructHandle<WebGPUSwapChain>(sch);
+    }
+    mSwapChain = nullptr;
 }
 
 void WebGPUDriver::destroyStream(Handle<HwStream> sh) {
@@ -358,13 +347,16 @@ void WebGPUDriver::destroyTimerQuery(Handle<HwTimerQuery> tqh) {
 }
 
 void WebGPUDriver::destroyDescriptorSetLayout(Handle<HwDescriptorSetLayout> tqh) {
+    if (tqh) {
+        destructHandle<WebGPUDescriptorSetLayout>(tqh);
+    }
 }
 
 void WebGPUDriver::destroyDescriptorSet(Handle<HwDescriptorSet> tqh) {
 }
 
 Handle<HwSwapChain> WebGPUDriver::createSwapChainS() noexcept {
-    return Handle<HwSwapChain>((Handle<HwSwapChain>::HandleId) mNextFakeHandle++);
+    return allocHandle<WebGPUSwapChain>();
 }
 
 Handle<HwSwapChain> WebGPUDriver::createSwapChainHeadlessS() noexcept {
@@ -372,7 +364,7 @@ Handle<HwSwapChain> WebGPUDriver::createSwapChainHeadlessS() noexcept {
 }
 
 Handle<HwTexture> WebGPUDriver::createTextureS() noexcept {
-    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUTexture>();
 }
 
 Handle<HwTexture> WebGPUDriver::importTextureS() noexcept {
@@ -380,7 +372,7 @@ Handle<HwTexture> WebGPUDriver::importTextureS() noexcept {
 }
 
 Handle<HwProgram> WebGPUDriver::createProgramS() noexcept {
-    return Handle<HwProgram>((Handle<HwProgram>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUProgram>();
 }
 
 Handle<HwFence> WebGPUDriver::createFenceS() noexcept {
@@ -400,15 +392,15 @@ Handle<HwTexture> WebGPUDriver::createTextureViewS() noexcept {
 }
 
 Handle<HwBufferObject> WebGPUDriver::createBufferObjectS() noexcept {
-    return Handle<HwBufferObject>((Handle<HwBufferObject>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUBufferObject>();
 }
 
 Handle<HwRenderTarget> WebGPUDriver::createRenderTargetS() noexcept {
-    return Handle<HwRenderTarget>((Handle<HwRenderTarget>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPURenderTarget>();
 }
 
 Handle<HwVertexBuffer> WebGPUDriver::createVertexBufferS() noexcept {
-    return Handle<HwVertexBuffer>((Handle<HwVertexBuffer>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUVertexBuffer>();
 }
 
 Handle<HwDescriptorSet> WebGPUDriver::createDescriptorSetS() noexcept {
@@ -416,11 +408,11 @@ Handle<HwDescriptorSet> WebGPUDriver::createDescriptorSetS() noexcept {
 }
 
 Handle<HwRenderPrimitive> WebGPUDriver::createRenderPrimitiveS() noexcept {
-    return Handle<HwRenderPrimitive>((Handle<HwRenderPrimitive>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPURenderPrimitive>();
 }
 
 Handle<HwVertexBufferInfo> WebGPUDriver::createVertexBufferInfoS() noexcept {
-    return Handle<HwVertexBufferInfo>((Handle<HwVertexBufferInfo>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPUVertexBufferInfo>();
 }
 
 Handle<HwTexture> WebGPUDriver::createTextureViewSwizzleS() noexcept {
@@ -428,12 +420,11 @@ Handle<HwTexture> WebGPUDriver::createTextureViewSwizzleS() noexcept {
 }
 
 Handle<HwRenderTarget> WebGPUDriver::createDefaultRenderTargetS() noexcept {
-    return Handle<HwRenderTarget>((Handle<HwRenderTarget>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPURenderTarget>();
 }
 
 Handle<HwDescriptorSetLayout> WebGPUDriver::createDescriptorSetLayoutS() noexcept {
-    return Handle<HwDescriptorSetLayout>(
-            (Handle<HwDescriptorSetLayout>::HandleId) mNextFakeHandle++);
+    return allocHandle<WebGPUDescriptorSetLayout>();
 }
 
 Handle<HwTexture> WebGPUDriver::createTextureExternalImageS() noexcept {
@@ -449,25 +440,15 @@ Handle<HwTexture> WebGPUDriver::createTextureExternalImagePlaneS() noexcept {
 }
 
 void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow, uint64_t flags) {
-    mSurface= mPlatform.createSurface(nativeWindow, flags);
-    mAdapter = mPlatform.requestAdapter(mSurface);
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-    printAdapterDetails(mAdapter);
-    wgpu::SurfaceCapabilities surfaceCapabilities{};
-    if (!mSurface.GetCapabilities(mAdapter, &surfaceCapabilities)) {
-        FWGPU_LOGW << "Failed to get WebGPU surface capabilities" << utils::io::endl;
-    } else {
-        printSurfaceCapabilitiesDetails(surfaceCapabilities);
-    }
-#endif
-    mDevice = mPlatform.requestDevice(mAdapter);
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-    printDeviceDetails(mDevice);
-#endif
+    mNativeWindow = nativeWindow;
+    assert_invariant(!mSwapChain);
+    wgpu::Surface surface = mPlatform.createSurface(nativeWindow, flags);
+
     mQueue = mDevice.GetQueue();
-    // TODO configure the surface (maybe before or after creating the swapchain?
-    //                             how do we get the surface extent?)
-    // TODO actually create the swapchain
+    wgpu::Extent2D surfaceSize = mPlatform.getSurfaceExtent(mNativeWindow);
+    mSwapChain = constructHandle<WebGPUSwapChain>(sch, std::move(surface), surfaceSize, mAdapter,
+            mDevice, flags);
+    assert_invariant(mSwapChain);
     FWGPU_LOGW << "WebGPU support is still essentially a no-op at this point in development (only "
                   "background components have been instantiated/selected, such as surface/screen, "
                   "graphics device/GPU, etc.), thus nothing is being drawn to the screen."
@@ -527,9 +508,15 @@ void WebGPUDriver::importTextureR(Handle<HwTexture> th, intptr_t id, SamplerType
 void WebGPUDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph, Handle<HwVertexBuffer> vbh,
         Handle<HwIndexBuffer> ibh, PrimitiveType pt) {}
 
-void WebGPUDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {}
+void WebGPUDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {
+    constructHandle<WGPUProgram>(ph, mDevice, program);
+}
 
-void WebGPUDriver::createDefaultRenderTargetR(Handle<HwRenderTarget> rth, int) {}
+void WebGPUDriver::createDefaultRenderTargetR(Handle<HwRenderTarget> rth, int) {
+    assert_invariant(!mDefaultRenderTarget);
+    mDefaultRenderTarget = constructHandle<WGPURenderTarget>(rth);
+    assert_invariant(mDefaultRenderTarget);
+}
 
 void WebGPUDriver::createRenderTargetR(Handle<HwRenderTarget> rth, TargetBufferFlags targets,
         uint32_t width, uint32_t height, uint8_t samples, uint8_t layerCount, MRT color,
@@ -540,7 +527,9 @@ void WebGPUDriver::createFenceR(Handle<HwFence> fh, int) {}
 void WebGPUDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {}
 
 void WebGPUDriver::createDescriptorSetLayoutR(Handle<HwDescriptorSetLayout> dslh,
-        backend::DescriptorSetLayout&& info) {}
+        backend::DescriptorSetLayout&& info) {
+    constructHandle<WebGPUDescriptorSetLayout>(dslh, std::move(info), mDevice);
+}
 
 void WebGPUDriver::createDescriptorSetR(Handle<HwDescriptorSet> dsh,
         Handle<HwDescriptorSetLayout> dslh) {}
@@ -690,6 +679,10 @@ void WebGPUDriver::resetBufferObject(Handle<HwBufferObject> boh) {
 
 void WebGPUDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh, uint32_t index,
         Handle<HwBufferObject> boh) {
+    auto* vertexBuffer = handleCast<WGPUVertexBuffer>(vbh);
+    auto* bufferObject = handleCast<WGPUBufferObject>(boh);
+    assert_invariant(index < vertexBuffer->buffers.size());
+    vertexBuffer->setBuffer(bufferObject, index);
 }
 
 void WebGPUDriver::update3DImage(Handle<HwTexture> th,
@@ -722,18 +715,71 @@ void WebGPUDriver::compilePrograms(CompilerPriorityQueue priority,
 }
 
 void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassParams& params) {
+    wgpu::CommandEncoderDescriptor commandEncoderDescriptor = {
+        .label = "command_encoder"
+    };
+    mCommandEncoder = mDevice.CreateCommandEncoder(&commandEncoderDescriptor);
+    assert_invariant(mCommandEncoder);
+    // TODO: Remove this code once WebGPU pipeline is implemented
+    static float red = 1.0f;
+    if (red - 0.01 > 0) {
+        red -= 0.01;
+    } else {
+        red = 1.0f;
+    }
+    assert_invariant(mTextureView);
+    wgpu::RenderPassColorAttachment renderPassColorAttachment = {
+        .view = mTextureView,
+        // TODO: remove this code once WebGPU Pipeline is implemented with render targets, pipeline and buffers.
+        .depthSlice = wgpu::kDepthSliceUndefined,
+        .loadOp = wgpu::LoadOp::Clear,
+        .storeOp = wgpu::StoreOp::Store,
+        .clearValue = wgpu::Color{red, 0 , 0 , 1},
+    };
+
+    wgpu::RenderPassDescriptor renderPassDescriptor = {
+        .colorAttachmentCount = 1,
+        .colorAttachments = &renderPassColorAttachment,
+        .depthStencilAttachment = nullptr,
+        .timestampWrites = nullptr,
+    };
+
+    mRenderPassEncoder = mCommandEncoder.BeginRenderPass(&renderPassDescriptor);
+    mRenderPassEncoder.SetViewport(params.viewport.left, params.viewport.bottom,
+            params.viewport.width, params.viewport.height, params.depthRange.near, params.depthRange.far);
 }
 
 void WebGPUDriver::endRenderPass(int) {
+    mRenderPassEncoder.End();
+    mRenderPassEncoder = nullptr;
+    wgpu::CommandBufferDescriptor commandBufferDescriptor {
+        .label = "command_buffer",
+    };
+    mCommandBuffer = mCommandEncoder.Finish(&commandBufferDescriptor);
+    assert_invariant(mCommandBuffer);
 }
 
 void WebGPUDriver::nextSubpass(int) {
 }
 
 void WebGPUDriver::makeCurrent(Handle<HwSwapChain> drawSch, Handle<HwSwapChain> readSch) {
+    ASSERT_PRECONDITION_NON_FATAL(drawSch == readSch,
+            "WebGPU driver does not support distinct draw/read swap chains.");
+    auto* swapChain = handleCast<WebGPUSwapChain>(drawSch);
+    mSwapChain = swapChain;
+    assert_invariant(mSwapChain);
+    wgpu::Extent2D surfaceSize = mPlatform.getSurfaceExtent(mNativeWindow);
+    mTextureView = mSwapChain->getCurrentSurfaceTextureView(surfaceSize);
+    assert_invariant(mTextureView);
 }
 
 void WebGPUDriver::commit(Handle<HwSwapChain> sch) {
+    mCommandEncoder = nullptr;
+    mQueue.Submit(1, &mCommandBuffer);
+    mCommandBuffer = nullptr;
+    mTextureView = nullptr;
+    assert_invariant(mSwapChain);
+    mSwapChain->present();
 }
 
 void WebGPUDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
@@ -761,7 +807,7 @@ void WebGPUDriver::readPixels(Handle<HwRenderTarget> src,
     scheduleDestroy(std::move(p));
 }
 
-void WebGPUDriver::readBufferSubData(backend::BufferObjectHandle boh,
+void WebGPUDriver::readBufferSubData(Handle<HwBufferObject> boh,
         uint32_t offset, uint32_t size, backend::BufferDescriptor&& p) {
     scheduleDestroy(std::move(p));
 }
@@ -813,22 +859,22 @@ void WebGPUDriver::resetState(int) {
 }
 
 void WebGPUDriver::updateDescriptorSetBuffer(
-        backend::DescriptorSetHandle dsh,
+        Handle<HwDescriptorSet> dsh,
         backend::descriptor_binding_t binding,
-        backend::BufferObjectHandle boh,
+        Handle<HwBufferObject> boh,
         uint32_t offset,
         uint32_t size) {
 }
 
 void WebGPUDriver::updateDescriptorSetTexture(
-        backend::DescriptorSetHandle dsh,
+        Handle<HwDescriptorSet> dsh,
         backend::descriptor_binding_t binding,
-        backend::TextureHandle th,
+        Handle<HwTexture> th,
         SamplerParams params) {
 }
 
 void WebGPUDriver::bindDescriptorSet(
-        backend::DescriptorSetHandle dsh,
+        Handle<HwDescriptorSet> dsh,
         backend::descriptor_set_t set,
         backend::DescriptorSetOffsetArray&& offsets) {
 }

filament/backend/src/webgpu/WebGPUDriver.h

@@ -17,6 +17,7 @@
 #ifndef TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H
 #define TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H
 
+#include "WebGPUHandles.h"
 #include <backend/platforms/WebGPUPlatform.h>
 
 #include "DriverBase.h"
@@ -30,6 +31,7 @@
 #include <webgpu/webgpu_cpp.h>
 
 #include <cstdint>
+#include <memory>
 
 #ifndef FILAMENT_WEBGPU_HANDLE_ARENA_SIZE_IN_MB
 #    define FILAMENT_WEBGPU_HANDLE_ARENA_SIZE_IN_MB 8
@@ -37,6 +39,8 @@
 
 namespace filament::backend {
 
+class WebGPUSwapChain;
+
 /**
  * WebGPU backend (driver) implementation
  */
@@ -55,16 +59,20 @@ private:
     // the platform (e.g. OS) specific aspects of the WebGPU backend are strictly only
     // handled in the WebGPUPlatform
     WebGPUPlatform& mPlatform;
-    wgpu::Surface mSurface = nullptr;
     wgpu::Adapter mAdapter = nullptr;
     wgpu::Device mDevice = nullptr;
     wgpu::Queue mQueue = nullptr;
+    void* mNativeWindow = nullptr;
+    WebGPUSwapChain* mSwapChain = nullptr;
     uint64_t mNextFakeHandle = 1;
-
+    wgpu::CommandEncoder mCommandEncoder = nullptr;
+    wgpu::TextureView mTextureView = nullptr;
+    wgpu::RenderPassEncoder mRenderPassEncoder = nullptr;
+    wgpu::CommandBuffer mCommandBuffer = nullptr;
+    WGPURenderTarget* mDefaultRenderTarget = nullptr;
     /*
      * Driver interface
      */
-
     template<typename T>
     friend class ConcreteDispatcher;
 
@@ -91,6 +99,21 @@ private:
         return mHandleAllocator.allocate<D>();
     }
 
+    template<typename D, typename B, typename ... ARGS>
+    D* constructHandle(Handle<B>& handle, ARGS&& ... args) noexcept {
+        return mHandleAllocator.construct<D>(handle, std::forward<ARGS>(args)...);
+    }
+
+    template<typename D, typename B>
+    D* handleCast(Handle<B> handle) noexcept {
+        return mHandleAllocator.handle_cast<D*>(handle);
+    }
+
+    template<typename D, typename B>
+    void destructHandle(Handle<B>& handle) noexcept {
+        auto* p = mHandleAllocator.handle_cast<D*>(handle);
+        return mHandleAllocator.deallocate(handle, p);
+    }
 };
 
 }// namespace filament::backend

filament/backend/src/webgpu/WebGPUHandles.cpp

@@ -0,0 +1,152 @@
+/*
+* Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "WebGPUHandles.h"
+
+#include <utility>
+
+namespace {
+
+wgpu::Buffer createIndexBuffer(wgpu::Device const& device, uint8_t elementSize, uint32_t indexCount) {
+    wgpu::BufferDescriptor descriptor{ .label = "index_buffer",
+        .usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Index,
+        .size = elementSize * indexCount,
+        .mappedAtCreation = false };
+    return device.CreateBuffer(&descriptor);
+}
+} // namespace
+
+namespace filament::backend {
+
+
+WGPUIndexBuffer::WGPUIndexBuffer(wgpu::Device const& device, uint8_t elementSize,
+        uint32_t indexCount)
+    : buffer(createIndexBuffer(device, elementSize, indexCount)) {}
+
+
+WGPUVertexBuffer::WGPUVertexBuffer(wgpu::Device const &device, uint32_t vextexCount, uint32_t bufferCount,
+                                   Handle<WGPUVertexBufferInfo> vbih)
+        : HwVertexBuffer(vextexCount),
+          vbih(vbih),
+          buffers(bufferCount) {
+    wgpu::BufferDescriptor descriptor {
+            .usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Vertex,
+            .size = vextexCount * bufferCount,
+            .mappedAtCreation = false };
+
+    for (uint32_t i = 0; i < bufferCount; ++i) {
+        descriptor.label = ("vertex_buffer_" + std::to_string(i)).c_str();
+        buffers[i] = device.CreateBuffer(&descriptor);
+    }
+}
+
+// TODO: Empty function is a place holder for verxtex buffer updates and should be
+// updated for that purpose.
+void WGPUVertexBuffer::setBuffer(WGPUBufferObject* bufferObject, uint32_t index) {}
+
+WGPUBufferObject::WGPUBufferObject(BufferObjectBinding bindingType, uint32_t byteCount)
+    : HwBufferObject(byteCount),
+      bufferObjectBinding(bindingType) {}
+
+wgpu::ShaderStage WebGPUDescriptorSetLayout::filamentStageToWGPUStage(ShaderStageFlags fFlags) {
+    wgpu::ShaderStage retStages = wgpu::ShaderStage::None;
+    if (any(ShaderStageFlags::VERTEX & fFlags)) {
+        retStages |= wgpu::ShaderStage::Vertex;
+    }
+    if (any(ShaderStageFlags::FRAGMENT & fFlags)) {
+        retStages |= wgpu::ShaderStage::Fragment;
+    }
+    if (any(ShaderStageFlags::COMPUTE & fFlags)) {
+        retStages |= wgpu::ShaderStage::Compute;
+    }
+    return retStages;
+}
+
+WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const& layout,
+        wgpu::Device const& device) {
+    assert_invariant(device);
+
+    // TODO: layoutDescriptor has a "Label". Ideally we can get info on what this layout is for
+    // debugging. For now, hack an incrementing value.
+    static int layoutNum = 0;
+
+    uint samplerCount =
+            std::count_if(layout.bindings.begin(), layout.bindings.end(), [](auto& fEntry) {
+                return fEntry.type == DescriptorType::SAMPLER ||
+                       fEntry.type == DescriptorType::SAMPLER_EXTERNAL;
+            });
+
+
+    std::vector<wgpu::BindGroupLayoutEntry> wEntries;
+    wEntries.reserve(layout.bindings.size() + samplerCount);
+
+    for (auto fEntry: layout.bindings) {
+        auto& wEntry = wEntries.emplace_back();
+        wEntry.visibility = filamentStageToWGPUStage(fEntry.stageFlags);
+        wEntry.binding = fEntry.binding * 2;
+
+        switch (fEntry.type) {
+            // TODO Metal treats these the same. Is this fine?
+            case DescriptorType::SAMPLER_EXTERNAL:
+            case DescriptorType::SAMPLER: {
+                // Sampler binding is 2n+1 due to split.
+                auto& samplerEntry = wEntries.emplace_back();
+                samplerEntry.binding = fEntry.binding * 2 + 1;
+                samplerEntry.visibility = wEntry.visibility;
+                // We are simply hoping that undefined and defaults suffices here.
+                samplerEntry.sampler.type = wgpu::SamplerBindingType::Undefined;
+                wEntry.texture.sampleType = wgpu::TextureSampleType::Undefined;
+                break;
+            }
+            case DescriptorType::UNIFORM_BUFFER: {
+                wEntry.buffer.hasDynamicOffset =
+                        any(fEntry.flags & DescriptorFlags::DYNAMIC_OFFSET);
+                wEntry.buffer.type = wgpu::BufferBindingType::Uniform;
+                // TODO: Ideally we fill minBindingSize
+                break;
+            }
+
+            case DescriptorType::INPUT_ATTACHMENT: {
+                // TODO: support INPUT_ATTACHMENT. Metal does not currently.
+                PANIC_POSTCONDITION("Input Attachment is not supported");
+                break;
+            }
+
+            case DescriptorType::SHADER_STORAGE_BUFFER: {
+                // TODO: Vulkan does not support this, can we?
+                PANIC_POSTCONDITION("Shader storage is not supported");
+                break;
+            }
+        }
+
+        // Currently flags are only used to specify dynamic offset.
+
+        // UNUSED
+        // fEntry.count
+    }
+
+    wgpu::BindGroupLayoutDescriptor layoutDescriptor{
+        // TODO: layoutDescriptor has a "Label". Ideally we can get info on what this layout is for
+        // debugging. For now, hack an incrementing value.
+        .label{ "layout_" + std::to_string(++layoutNum) },
+        .entryCount = wEntries.size(),
+        .entries = wEntries.data()
+    };
+    // TODO Do we need to defer this until we have more info on textures and samplers??
+    mLayout = device.CreateBindGroupLayout(&layoutDescriptor);
+}
+WebGPUDescriptorSetLayout::~WebGPUDescriptorSetLayout() {}
+}// namespace filament::backend

filament/backend/src/webgpu/WebGPUHandles.h

@@ -0,0 +1,167 @@
+/*
+* Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H
+#define TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H
+
+#include "DriverBase.h"
+
+#include <backend/DriverEnums.h>
+#include <backend/Handle.h>
+
+#include <utils/FixedCapacityVector.h>
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <cstdint>
+#include <vector>
+
+namespace filament::backend {
+
+class WGPUProgram final : public HwProgram {
+public:
+    WGPUProgram(wgpu::Device&, Program&);
+
+    wgpu::ShaderModule vertexShaderModule = nullptr;
+    wgpu::ShaderModule fragmentShaderModule = nullptr;
+    wgpu::ShaderModule computeShaderModule = nullptr;
+    std::vector<wgpu::ConstantEntry> constants;
+};
+
+struct WGPUBufferObject;
+// TODO: Currently WGPUVertexBufferInfo is not used by WebGPU for useful task.
+// Update the struct when used by WebGPU driver.
+struct WGPUVertexBufferInfo : public HwVertexBufferInfo {
+    WGPUVertexBufferInfo(uint8_t bufferCount, uint8_t attributeCount,
+            AttributeArray const& attributes)
+        : HwVertexBufferInfo(bufferCount, attributeCount),
+          attributes(attributes) {}
+    AttributeArray attributes;
+};
+
+struct WGPUVertexBuffer : public HwVertexBuffer {
+    WGPUVertexBuffer(wgpu::Device const &device, uint32_t vextexCount, uint32_t bufferCount,
+                     Handle<WGPUVertexBufferInfo> vbih);
+
+    void setBuffer(WGPUBufferObject *bufferObject, uint32_t index);
+
+    Handle<WGPUVertexBufferInfo> vbih;
+    utils::FixedCapacityVector<wgpu::Buffer> buffers;
+};
+
+struct WGPUIndexBuffer : public HwIndexBuffer {
+    WGPUIndexBuffer(wgpu::Device const &device, uint8_t elementSize,
+                    uint32_t indexCount);
+
+    wgpu::Buffer buffer;
+};
+
+// TODO: Currently WGPUVertexBufferInfo is not used by WebGPU for useful task.
+// Update the struct when used by WebGPU driver.
+struct WGPUBufferObject : HwBufferObject {
+    WGPUBufferObject(BufferObjectBinding bindingType, uint32_t byteCount);
+
+    wgpu::Buffer buffer;
+    const BufferObjectBinding bufferObjectBinding;
+};
+class WebGPUDescriptorSetLayout : public HwDescriptorSetLayout {
+public:
+    WebGPUDescriptorSetLayout(DescriptorSetLayout const& layout, wgpu::Device const& device);
+    ~WebGPUDescriptorSetLayout();
+
+private:
+    // TODO: If this is useful elsewhere, remove it from this class
+    // Convert Filament Shader Stage Flags bitmask to webgpu equivilant
+    static wgpu::ShaderStage filamentStageToWGPUStage(ShaderStageFlags fFlags);
+
+    wgpu::BindGroupLayout mLayout;
+};
+
+// TODO: Currently WGPUTexture is not used by WebGPU for useful task.
+// Update the struct when used by WebGPU driver.
+struct WGPUTexture : public HwTexture {
+    WGPUTexture(SamplerType target, uint8_t levels, TextureFormat format, uint8_t samples,
+            uint32_t width, uint32_t height, uint32_t depth, TextureUsage usage) noexcept;
+
+    // constructors for creating texture views
+    WGPUTexture(WGPUTexture const* src, uint8_t baseLevel, uint8_t levelCount) noexcept;
+
+    wgpu::Texture texture = nullptr;
+};
+
+struct WGPURenderPrimitive : public HwRenderPrimitive {
+    WGPURenderPrimitive();
+
+    void setBuffers(WGPUVertexBufferInfo const* const vbi,
+            WGPUVertexBuffer* vertexBuffer, WGPUIndexBuffer* indexBuffer);
+
+    WGPUVertexBuffer* vertexBuffer = nullptr;
+    WGPUIndexBuffer* indexBuffer = nullptr;
+};
+
+// TODO: Currently WGPURenderTarget is not used by WebGPU for useful task.
+// Update the struct when used by WebGPU driver.
+struct WGPURenderTarget : public HwRenderTarget {
+    class Attachment {
+    public:
+        friend struct WGPURenderTarget;
+
+        Attachment() = default;
+        Attachment(WGPUTexture* gpuTexture, uint8_t level = 0, uint16_t layer = 0)
+            : level(level),
+              layer(layer),
+              texture(gpuTexture->texture),
+              mWGPUTexture(gpuTexture) {}
+
+        uint8_t level = 0;
+        uint16_t layer = 0;
+
+    private:
+        wgpu::Texture texture = nullptr;
+        WGPUTexture* mWGPUTexture = nullptr;
+    };
+
+    WGPURenderTarget(uint32_t width, uint32_t height, uint8_t samples,
+            Attachment colorAttachments[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT]);
+    WGPURenderTarget()
+        : HwRenderTarget(0, 0),
+          defaultRenderTarget(true) {}
+
+    void setUpRenderPassAttachments(wgpu::RenderPassDescriptor* descriptor,
+            const RenderPassParams& params);
+
+    math::uint2 getAttachmentSize() noexcept;
+
+    bool isDefaultRenderTarget() const { return defaultRenderTarget; }
+    uint8_t getSamples() const { return samples; }
+
+    Attachment getDrawColorAttachment(size_t index);
+    Attachment getReadColorAttachment(size_t index);
+
+private:
+    static wgpu::LoadOp getLoadAction(const RenderPassParams& params, TargetBufferFlags buffer);
+    static wgpu::LoadOp getStoreAction(const RenderPassParams& params, TargetBufferFlags buffer);
+
+    bool defaultRenderTarget = false;
+    uint8_t samples = 1;
+
+    Attachment color[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT] = {};
+    math::uint2 attachmentSize = {};
+};
+
+}// namespace filament::backend
+#endif// TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H

filament/backend/src/webgpu/WebGPUSwapChain.cpp

@@ -0,0 +1,276 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "webgpu/WebGPUSwapChain.h"
+
+#include "webgpu/WebGPUConstants.h"
+
+#include "backend/DriverEnums.h"
+
+#include <utils/Panic.h>
+#include <utils/ostream.h>
+
+#include <dawn/webgpu_cpp_print.h>
+#include <webgpu/webgpu_cpp.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <sstream>
+
+namespace {
+
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+void printSurfaceCapabilitiesDetails(wgpu::SurfaceCapabilities const& capabilities) {
+    std::stringstream usagesStream{};
+    usagesStream << capabilities.usages;
+    FWGPU_LOGI << "WebGPU surface capabilities:" << utils::io::endl;
+    FWGPU_LOGI << "  surface usages: " << usagesStream.str().data() << utils::io::endl;
+    FWGPU_LOGI << "  surface formats (" << capabilities.formatCount << "):" << utils::io::endl;
+    if (capabilities.formatCount > 0 && capabilities.formats != nullptr) {
+        std::for_each(capabilities.formats, capabilities.formats + capabilities.formatCount,
+                [](wgpu::TextureFormat const format) {
+                    std::stringstream formatStream{};
+                    formatStream << format;
+                    FWGPU_LOGI << "    " << formatStream.str().data() << utils::io::endl;
+                });
+    }
+    FWGPU_LOGI << "  surface present modes (" << capabilities.presentModeCount
+               << "):" << utils::io::endl;
+    if (capabilities.presentModeCount > 0 && capabilities.presentModes != nullptr) {
+        std::for_each(capabilities.presentModes,
+                capabilities.presentModes + capabilities.presentModeCount,
+                [](wgpu::PresentMode const presentMode) {
+                    std::stringstream presentModeStream{};
+                    presentModeStream << presentMode;
+                    FWGPU_LOGI << "    " << presentModeStream.str().data() << utils::io::endl;
+                });
+    }
+    FWGPU_LOGI << "  surface alpha modes (" << capabilities.alphaModeCount
+               << "):" << utils::io::endl;
+    if (capabilities.alphaModeCount > 0 && capabilities.alphaModes != nullptr) {
+        std::for_each(capabilities.alphaModes,
+                capabilities.alphaModes + capabilities.alphaModeCount,
+                [](wgpu::CompositeAlphaMode const alphaMode) {
+                    std::stringstream alphaModeStream{};
+                    alphaModeStream << alphaMode;
+                    FWGPU_LOGI << "    " << alphaModeStream.str().data() << utils::io::endl;
+                });
+    }
+}
+#endif
+
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+void printSurfaceConfiguration(wgpu::SurfaceConfiguration const& config) {
+    std::stringstream formatStream{};
+    formatStream << config.format;
+    std::stringstream usageStream{};
+    usageStream << config.usage;
+    std::stringstream alphaModeStream{};
+    alphaModeStream << config.alphaMode;
+    std::stringstream presentModeStream{};
+    presentModeStream << config.presentMode;
+    FWGPU_LOGI << "WebGPU surface configuration:" << utils::io::endl;
+    FWGPU_LOGI << "  surface format: " << formatStream.str() << utils::io::endl;
+    FWGPU_LOGI << "  surface usage: " << usageStream.str() << utils::io::endl;
+    FWGPU_LOGI << "  surface view formats (" << config.viewFormatCount << "):" << utils::io::endl;
+    if (config.viewFormatCount > 0 && config.viewFormats != nullptr) {
+        std::for_each(config.viewFormats, config.viewFormats + config.viewFormatCount,
+                [](wgpu::TextureFormat const viewFormat) {
+                    std::stringstream viewFormatStream{};
+                    viewFormatStream << viewFormat;
+                    FWGPU_LOGI << "    " << viewFormatStream.str().data() << utils::io::endl;
+                });
+    }
+    FWGPU_LOGI << "  surface alpha mode: " << alphaModeStream.str() << utils::io::endl;
+    FWGPU_LOGI << "  surface width: " << config.width << utils::io::endl;
+    FWGPU_LOGI << "  surface height: " << config.height << utils::io::endl;
+    FWGPU_LOGI << "  surface present mode: " << presentModeStream.str() << utils::io::endl;
+}
+#endif
+
+wgpu::TextureFormat selectColorFormat(size_t availableFormatsCount,
+        wgpu::TextureFormat const* availableFormats, bool useSRGBColorSpace) {
+    const std::array expectedColorFormats =
+            useSRGBColorSpace ?
+                              std::array{
+                                  wgpu::TextureFormat::RGBA8UnormSrgb,
+                                  wgpu::TextureFormat::BGRA8UnormSrgb }
+                              : std::array{
+                                    wgpu::TextureFormat::RGBA8Unorm,
+                                    wgpu::TextureFormat::BGRA8Unorm };
+    auto const firstFoundColorFormat = std::find_first_of(expectedColorFormats.begin(),
+            expectedColorFormats.end(), availableFormats, availableFormats + availableFormatsCount);
+    FILAMENT_CHECK_POSTCONDITION(firstFoundColorFormat != expectedColorFormats.end())
+            << "Cannot find a suitable WebGPU swapchain "
+            << (useSRGBColorSpace ? "sRGB" : "non-standard (e.g. linear) RGB") << " color format";
+    return *firstFoundColorFormat;
+}
+
+wgpu::PresentMode selectPresentMode(size_t availablePresentModesCount,
+        wgpu::PresentMode const* availablePresentModes) {
+    // Verify that our chosen present mode is supported. In practice all devices support the FIFO
+    // mode, but we check for it anyway for completeness.  (and to avoid validation warnings)
+    const wgpu::PresentMode desiredPresentMode = wgpu::PresentMode::Fifo;
+    FILAMENT_CHECK_POSTCONDITION(
+            std::any_of(availablePresentModes, availablePresentModes + availablePresentModesCount,
+                    [](const wgpu::PresentMode availablePresentMode) {
+                        return availablePresentMode == desiredPresentMode;
+                    }))
+            << "Cannot find a suitable WebGPU swapchain present mode";
+    return desiredPresentMode;
+}
+
+wgpu::CompositeAlphaMode selectAlphaMode(size_t availableAlphaModesCount,
+        wgpu::CompositeAlphaMode const* availableAlphaModes) {
+    bool autoAvailable = false;
+    bool inheritAvailable = false;
+    bool opaqueAvailable = false;
+    bool premultipliedAvailable = false;
+    bool unpremultipliedAvailable = false;
+    std::for_each(availableAlphaModes, availableAlphaModes + availableAlphaModesCount,
+            [&](const wgpu::CompositeAlphaMode alphMode) {
+                switch (alphMode) {
+                    // in practice, the surface capabilities would not list Auto,
+                    // but for completeness and defensive programming we can leverage it
+                    // if it explicitly comes back as available/supported
+                    case wgpu::CompositeAlphaMode::Auto:
+                        autoAvailable = true;
+                        break;
+                    case wgpu::CompositeAlphaMode::Opaque:
+                        opaqueAvailable = true;
+                        break;
+                    case wgpu::CompositeAlphaMode::Premultiplied:
+                        premultipliedAvailable = true;
+                        break;
+                    case wgpu::CompositeAlphaMode::Unpremultiplied:
+                        unpremultipliedAvailable = true;
+                        break;
+                    case wgpu::CompositeAlphaMode::Inherit:
+                        inheritAvailable = true;
+                        break;
+                }
+            });
+    if (autoAvailable || inheritAvailable || opaqueAvailable) {
+        return wgpu::CompositeAlphaMode::Auto;
+    } else if (premultipliedAvailable) {
+        // In practice, we do not expect this to possibly happen, as opaque should be supported,
+        // which we select first. However, if the underlying system actually does not support
+        // opaque we allow it to be tested, but warn that this may not likely work as they expect
+        // (untested territory).
+        // We prefer premultiplied to unpremuliplied until that assumption should be adjusted.
+        FWGPU_LOGW << "Auto, Inherit, & Opaque composite alpha modes not supported. Filament has "
+                      "historically used these. Premultiplied alpha composite mode for "
+                      "transparency is being selected as a fallback, but may not work as expected."
+                   << utils::io::endl;
+        return wgpu::CompositeAlphaMode::Premultiplied;
+    } else {
+        FILAMENT_CHECK_POSTCONDITION(unpremultipliedAvailable)
+                << "No available composite alpha modes? Unknown/unhandled composite alpha mode?";
+        // Again, we don't expect this in practice, but allow if for the same reason as premultiplied.
+        // We prefer premultiplied to unpremuliplied until that assumption should be adjusted.
+        FWGPU_LOGW << "Auto, Inherit, & Opaque composite alpha modes not supported. Filament has "
+                      "historically used these. Unpremultiplied alpha composite mode for "
+                      "transparency is being selected as a fallback "
+                      "(premulitipled is not available either), but may not work as expected."
+                   << utils::io::endl;
+        return wgpu::CompositeAlphaMode::Unpremultiplied;
+    }
+}
+
+void initConfig(wgpu::SurfaceConfiguration& config, wgpu::Device const& device,
+        wgpu::SurfaceCapabilities const& capabilities, wgpu::Extent2D const& surfaceSize,
+        bool useSRGBColorSpace) {
+    config.device = device;
+    config.usage = wgpu::TextureUsage::RenderAttachment;
+    config.width = surfaceSize.width;
+    config.height = surfaceSize.height;
+    config.format =
+            selectColorFormat(capabilities.formatCount, capabilities.formats, useSRGBColorSpace);
+    config.presentMode =
+            selectPresentMode(capabilities.presentModeCount, capabilities.presentModes);
+    config.alphaMode = selectAlphaMode(capabilities.alphaModeCount, capabilities.alphaModes);
+}
+
+}// namespace
+
+namespace filament::backend {
+
+WebGPUSwapChain::WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Extent2D const& surfaceSize,
+        wgpu::Adapter& adapter, wgpu::Device& device, uint64_t flags)
+    : mSurface(surface) {
+    wgpu::SurfaceCapabilities capabilities = {};
+    if (!mSurface.GetCapabilities(adapter, &capabilities)) {
+        FWGPU_LOGW << "Failed to get WebGPU surface capabilities" << utils::io::endl;
+    } else {
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+        printSurfaceCapabilitiesDetails(capabilities);
+#endif
+    }
+    const bool useSRGBColorSpace = (flags & SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0;
+    initConfig(mConfig, device, capabilities, surfaceSize, useSRGBColorSpace);
+    mSurface.Configure(&mConfig);
+}
+
+WebGPUSwapChain::~WebGPUSwapChain() {
+    mSurface.Unconfigure();
+}
+
+void WebGPUSwapChain::setExtent(wgpu::Extent2D const& currentSurfaceSize) {
+    FILAMENT_CHECK_POSTCONDITION(currentSurfaceSize.width > 0 || currentSurfaceSize.height > 0)
+            << "WebGPUSwapChain::setExtent: Invalid width " << currentSurfaceSize.width
+            << " and/or height " << currentSurfaceSize.height << " requested.";
+    if (mConfig.width != currentSurfaceSize.width || mConfig.height != currentSurfaceSize.height) {
+        mConfig.width = currentSurfaceSize.width;
+        mConfig.height = currentSurfaceSize.height;
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+        printSurfaceConfiguration(mConfig);
+#endif
+        FWGPU_LOGD << "Resizing to width " << mConfig.width << " height " << mConfig.height
+                   << utils::io::endl;
+        // TODO we may need to ensure no surface texture is flight when we do this. some
+        //      synchronization may be necessary
+        mSurface.Configure(&mConfig);
+    }
+}
+
+wgpu::TextureView WebGPUSwapChain::getCurrentSurfaceTextureView(
+        wgpu::Extent2D const& currentSurfaceSize) {
+    setExtent(currentSurfaceSize);
+    wgpu::SurfaceTexture surfaceTexture;
+    mSurface.GetCurrentTexture(&surfaceTexture);
+    if (surfaceTexture.status != wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal) {
+        return nullptr;
+    }
+    // Create a view for this surface texture
+    // TODO: review these initiliazations as webgpu pipeline gets mature
+    wgpu::TextureViewDescriptor textureViewDescriptor = {
+        .label = "texture_view",
+        .format = surfaceTexture.texture.GetFormat(),
+        .dimension = wgpu::TextureViewDimension::e2D,
+        .baseMipLevel = 0,
+        .mipLevelCount = 1,
+        .baseArrayLayer = 0,
+        .arrayLayerCount = 1
+    };
+    return surfaceTexture.texture.CreateView(&textureViewDescriptor);
+}
+
+void WebGPUSwapChain::present() {
+    assert_invariant(mSurface);
+    mSurface.Present();
+}
+
+}// namespace filament::backend

filament/backend/src/webgpu/WebGPUSwapChain.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TNT_FILAMENT_BACKEND_WEBGPUSWAPCHAIN_H
+#define TNT_FILAMENT_BACKEND_WEBGPUSWAPCHAIN_H
+
+#include <webgpu/webgpu_cpp.h>
+
+#include "DriverBase.h"
+#include <backend/Platform.h>
+
+#include <cstdint>
+
+namespace filament::backend {
+
+class WebGPUSwapChain final : public Platform::SwapChain, HwSwapChain {
+public:
+    WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Extent2D const& surfaceSize,
+            wgpu::Adapter& adapter, wgpu::Device& device, uint64_t flags);
+    ~WebGPUSwapChain();
+
+    wgpu::TextureView getCurrentSurfaceTextureView(wgpu::Extent2D const&);
+
+    void present();
+
+private:
+    void setExtent(wgpu::Extent2D const&);
+
+    wgpu::Surface mSurface = {};
+    wgpu::SurfaceConfiguration mConfig = {};
+};
+
+} // namespace filament::backend
+
+#endif //TNT_FILAMENT_BACKEND_WEBGPUSWAPCHAIN_H

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

@@ -18,6 +18,7 @@
 
 #include <utils/Panic.h>
 
+#include <android/native_window.h>
 #include <webgpu/webgpu_cpp.h>
 
 #include <cstdint>
@@ -28,6 +29,14 @@
 
 namespace filament::backend {
 
+wgpu::Extent2D WebGPUPlatform::getSurfaceExtent(void* nativeWindow) const {
+    ANativeWindow* window = static_cast<ANativeWindow*>(nativeWindow);
+    return wgpu::Extent2D{
+        .width = static_cast<uint32_t>(ANativeWindow_getWidth(window)),
+        .height = static_cast<uint32_t>(ANativeWindow_getHeight(window))
+    };
+}
+
 wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags*/) {
     wgpu::SurfaceSourceAndroidNativeWindow surfaceSourceAndroidWindow{};
     surfaceSourceAndroidWindow.window = nativeWindow;

filament/backend/src/webgpu/platform/WebGPUPlatformApple.mm

@@ -24,21 +24,8 @@
 #include <cstdint>
 
 // Platform specific includes and defines
-#if defined(__APPLE__)
-    #include <Cocoa/Cocoa.h>
-    #import <QuartzCore/CAMetalLayer.h>
-#elif defined(FILAMENT_IOS)
-    // Metal is not available when building for the iOS simulator on Desktop.
-    #define METAL_AVAILABLE __has_include(<QuartzCore/CAMetalLayer.h>)
-    #if METAL_AVAILABLE
-        #import <Metal/Metal.h>
-        #import <QuartzCore/CAMetalLayer.h>
-    #endif
-    // is this needed?
-    #define METALVIEW_TAG 255
-#else
-    #error Not a supported Apple + WebGPU platform
-#endif
+#include <Cocoa/Cocoa.h>
+#import <QuartzCore/CAMetalLayer.h>
 
 /**
  * Apple (Mac OS and IOS) specific implementation aspects of the WebGPU backend
@@ -46,14 +33,19 @@
 
 namespace filament::backend {
 
+wgpu::Extent2D WebGPUPlatform::getSurfaceExtent(void* nativeWindow) const {
+    // Both IOS and MacOS expects CAMetalLayer.
+    CAMetalLayer* metalLayer = (__bridge CAMetalLayer*) nativeWindow;
+    return wgpu::Extent2D{
+        .width = static_cast<uint32_t>(metalLayer.drawableSize.width),
+        .height = static_cast<uint32_t>(metalLayer.drawableSize.height)
+    };
+}
+
 wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags*/) {
     wgpu::Surface surface = nullptr;
-#if defined(__APPLE__)
-    auto nsView = (__bridge NSView*) nativeWindow;
-    FILAMENT_CHECK_POSTCONDITION(nsView) << "Unable to obtain Metal-backed NSView.";
-    [nsView setWantsLayer:YES];
-    id metalLayer = [CAMetalLayer layer];
-    [nsView setLayer:metalLayer];
+    // Both IOS and MacOS expects CAMetalLayer.
+    CAMetalLayer* metalLayer = (__bridge CAMetalLayer*) nativeWindow;
     wgpu::SurfaceSourceMetalLayer surfaceSourceMetalLayer{};
     surfaceSourceMetalLayer.layer = (__bridge void*) metalLayer;
     wgpu::SurfaceDescriptor surfaceDescriptor = {
@@ -62,19 +54,6 @@ wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags
     };
     surface = mInstance.CreateSurface(&surfaceDescriptor);
     FILAMENT_CHECK_POSTCONDITION(surface != nullptr) << "Unable to create Metal-backed surface.";
-#elif defined(FILAMENT_IOS)
-    CAMetalLayer* metalLayer = (CAMetalLayer*) nativeWindow;
-    wgpu::SurfaceSourceMetalLayer surfaceSourceMetalLayer{};
-    surfaceSourceMetalLayer.layer = (__bridge void*) metalLayer;
-    wgpu::SurfaceDescriptor surfaceDescriptor = {
-        .nextInChain = &surfaceSourceMetalLayer,
-        .label = "metal_surface",
-    };
-    surface = mInstance.CreateSurface(&surfaceDescriptor);
-    FILAMENT_CHECK_POSTCONDITION(surface != nullptr) << "Unable to create Metal-backed surface.";
-#else
-    #error Not a supported Apple + WebGPU platform
-#endif
     return surface;
 }
 

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

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

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

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

filament/backend/test/BackendTest.cpp

@@ -43,24 +43,29 @@ using namespace image;
 namespace test {
 
 Backend BackendTest::sBackend = Backend::NOOP;
+OperatingSystem BackendTest::sOperatingSystem = OperatingSystem::OTHER;
 bool BackendTest::sIsMobilePlatform = false;
 
-void BackendTest::init(Backend backend, bool isMobilePlatform) {
+void BackendTest::init(Backend backend, OperatingSystem operatingSystem, bool isMobilePlatform) {
     sBackend = backend;
+    sOperatingSystem = operatingSystem;
     sIsMobilePlatform = isMobilePlatform;
 }
 
 BackendTest::BackendTest() : commandBufferQueue(CONFIG_MIN_COMMAND_BUFFERS_SIZE,
         CONFIG_COMMAND_BUFFERS_SIZE, /*mPaused=*/false) {
     initializeDriver();
+    mImageExpectations.emplace(getDriverApi());
 }
 
 BackendTest::~BackendTest() {
+    // Ensure all graphics commands and callbacks are finished.
+    flushAndWait();
+    mImageExpectations->evaluate();
     // Note: Don't terminate the driver for OpenGL, as it wipes away the context and removes the buffer from the screen.
     if (sBackend == Backend::OPENGL) {
         return;
     }
-    flushAndWait();
     driver->terminate();
     delete driver;
 }
@@ -154,49 +159,16 @@ void BackendTest::renderTriangle(
     api.endRenderPass();
 }
 
-void BackendTest::readPixelsAndAssertHash(const char* testName, size_t width, size_t height,
-        Handle<HwRenderTarget> rt, uint32_t expectedHash, bool exportScreenshot) {
-    void* buffer = calloc(1, width * height * 4);
+bool BackendTest::matchesEnvironment(Backend backend) {
+    return sBackend == backend;
+}
 
-    struct Capture {
-        uint32_t expectedHash;
-        char* name;
-        bool exportScreenshot;
-        size_t width, height;
-    };
-    auto* c = new Capture();
-    c->expectedHash = expectedHash;
-    c->name = strdup(testName);
-    c->exportScreenshot = exportScreenshot;
-    c->width = width;
-    c->height = height;
+bool BackendTest::matchesEnvironment(OperatingSystem operatingSystem) {
+    return sOperatingSystem == operatingSystem;
+}
 
-    PixelBufferDescriptor pbd(buffer, width * height * 4, PixelDataFormat::RGBA, PixelDataType::UBYTE,
-            1, 0, 0, width, [](void* buffer, size_t size, void* user) {
-                auto* c = (Capture*)user;
-
-                // Export a screenshot, if requested.
-                if (c->exportScreenshot) {
-#ifndef FILAMENT_IOS
-                    LinearImage image(c->width, c->height, 4);
-                    image = toLinearWithAlpha<uint8_t>(c->width, c->height, c->width * 4,
-                            (uint8_t*) buffer);
-                    const std::string png = std::string(c->name) + ".png";
-                    std::ofstream outputStream(png.c_str(), std::ios::binary | std::ios::trunc);
-                    ImageEncoder::encode(outputStream, ImageEncoder::Format::PNG, image, "",
-                            png);
-#endif
-                }
-
-                // Hash the contents of the buffer and check that they match.
-                uint32_t hash = utils::hash::murmur3((const uint32_t*) buffer, size / 4, 0);
-                ASSERT_EQ(hash, c->expectedHash) << c->name << " failed: hashes do not match." << std::endl;
-
-                free(buffer);
-                free(c->name);
-                free(c);
-            }, (void*)c);
-    getDriverApi().readPixels(rt, 0, 0, width, height, std::move(pbd));
+bool BackendTest::matchesEnvironment(OperatingSystem operatingSystem, Backend backend) {
+    return matchesEnvironment(operatingSystem) && matchesEnvironment(backend);
 }
 
 class Environment : public ::testing::Environment {
@@ -210,8 +182,8 @@ public:
     }
 };
 
-void initTests(Backend backend, bool isMobile, int& argc, char* argv[]) {
-    BackendTest::init(backend, isMobile);
+void initTests(Backend backend, OperatingSystem operatingSystem, bool isMobile, int& argc, char* argv[]) {
+    BackendTest::init(backend, operatingSystem, isMobile);
     ::testing::InitGoogleTest(&argc, argv);
     ::testing::AddGlobalTestEnvironment(new Environment);
 }

filament/backend/test/BackendTest.h

@@ -25,15 +25,17 @@
 #include "private/backend/DriverApi.h"
 
 #include "PlatformRunner.h"
+#include "ImageExpectations.h"
 
 namespace test {
 
 class BackendTest : public ::testing::Test {
 public:
 
-    static void init(Backend backend, bool isMobilePlatform);
+    static void init(Backend backend, OperatingSystem operatingSystem, bool isMobilePlatform);
 
     static Backend sBackend;
+    static OperatingSystem sOperatingSystem;
     static bool sIsMobilePlatform;
 
 protected:
@@ -64,13 +66,14 @@ protected:
             filament::backend::Handle<filament::backend::HwProgram> program,
             const filament::backend::RenderPassParams& params);
 
-    void readPixelsAndAssertHash(const char* testName, size_t width, size_t height,
-            filament::backend::Handle<filament::backend::HwRenderTarget> rt, uint32_t expectedHash,
-            bool exportScreenshot = false);
-
     filament::backend::DriverApi& getDriverApi() { return *commandStream; }
     filament::backend::Driver& getDriver() { return *driver; }
 
+    ImageExpectations& getExpectations() { return *mImageExpectations; }
+
+    static bool matchesEnvironment(Backend backend);
+    static bool matchesEnvironment(OperatingSystem operatingSystem);
+    static bool matchesEnvironment(OperatingSystem operatingSystem, Backend backend);
 private:
 
     filament::backend::Driver* driver = nullptr;
@@ -78,6 +81,10 @@ private:
     std::unique_ptr<filament::backend::DriverApi> commandStream;
 
     filament::backend::Handle<filament::backend::HwBufferObject> uniform;
+
+    // This isn't truly optional, it just needs to delay construction until after the driver has
+    // been initialized
+    std::optional<ImageExpectations> mImageExpectations;
 };
 
 } // namespace test

filament/backend/test/ImageExpectations.cpp

@@ -16,7 +16,6 @@
 
 #include "ImageExpectations.h"
 
-#include "gtest/gtest.h"
 #include "gmock/gmock.h"
 #include "absl/strings/str_format.h"
 #include "utils/Hash.h"
@@ -28,14 +27,17 @@
 #ifndef FILAMENT_IOS
 
 #include <imageio/ImageEncoder.h>
+#include <imageio/ImageDecoder.h>
 #include <image/ColorTransform.h>
 
 #endif
 
 ScreenshotParams::ScreenshotParams(int width, int height, std::string fileName,
-        uint32_t expectedPixelHash)
-        : mWidth(width), mHeight(height), mFileName(std::move(fileName)),
-          mExpectedPixelHash(expectedPixelHash) {}
+        uint32_t expectedHash)
+    : mWidth(width),
+      mHeight(height),
+      mExpectedPixelHash(expectedHash),
+      mFileName(std::move(fileName)) {}
 
 int ScreenshotParams::width() const {
     return mWidth;
@@ -49,24 +51,28 @@ uint32_t ScreenshotParams::expectedHash() const {
     return mExpectedPixelHash;
 }
 
-std::string ScreenshotParams::outputDirectoryPath() const {
-    return ".";
+std::string ScreenshotParams::actualDirectoryPath() {
+    return "images/actual_images";
 }
 
-std::string ScreenshotParams::generatedActualFileName() const {
+std::string ScreenshotParams::actualFileName() const {
     return absl::StrFormat("%s_actual.png", mFileName);
 }
 
-std::string ScreenshotParams::generatedActualFilePath() const {
-    return absl::StrFormat("%s/%s", outputDirectoryPath(), generatedActualFileName());
+std::string ScreenshotParams::actualFilePath() const {
+    return absl::StrFormat("%s/%s", actualDirectoryPath(), actualFileName());
 }
 
-std::string ScreenshotParams::goldenFileName() const {
-    return absl::StrFormat("%s_golden.png", mFileName);
+std::string ScreenshotParams::expectedDirectoryPath() {
+    return "images/expected_images";
 }
 
-std::string ScreenshotParams::goldenFilePath() const {
-    return absl::StrFormat("%s/%s", outputDirectoryPath(), goldenFileName());
+std::string ScreenshotParams::expectedFileName() const {
+    return absl::StrFormat("%s.png", mFileName);
+}
+
+std::string ScreenshotParams::expectedFilePath() const {
+    return absl::StrFormat("%s/%s", expectedDirectoryPath(), expectedFileName());
 }
 
 ImageExpectation::ImageExpectation(const char* fileName, int lineNumber,
@@ -91,11 +97,22 @@ void ImageExpectation::evaluate() {
 
 void ImageExpectation::compareImage() const {
     bool bytesFilled = mResult.bytesFilled();
+    // If this fails, it likely means that BackendTest::flushAndWait needs to be called before
+    // ImageExpectations is evaluated or destroyed.
     EXPECT_THAT(bytesFilled, testing::IsTrue())
                         << "Render target wasn't copied to the buffer for " << mFileName;
     if (bytesFilled) {
+        // Rather than directly compare the two images compare their hashes because comparing very
+        // large arrays generates way too much debug output to be useful.
         uint32_t actualHash = mResult.hash();
-        EXPECT_THAT(actualHash, testing::Eq(mParams.expectedHash()));
+#ifndef FILAMENT_IOS
+        LoadedPng loadedImage(mParams.expectedFilePath());
+        uint32_t loadedImageHash = loadedImage.hash();
+        EXPECT_THAT(actualHash, testing::Eq(loadedImageHash)) << mParams.expectedFileName();
+#endif
+        // For builds that can't load PNGs (currently iOS only) use the expected hash.
+        EXPECT_THAT(actualHash, testing::Eq(mParams.expectedHash())) << mParams.expectedFileName();
+        // TODO: Add better debug output, such as generating a diff image.
     }
 }
 
@@ -109,12 +126,13 @@ ImageExpectations::~ImageExpectations() {
 
 void ImageExpectations::addExpectation(const char* fileName, int lineNumber,
         filament::backend::RenderTargetHandle renderTarget, ScreenshotParams params) {
-    mExpectations.emplace_back(fileName, lineNumber, mApi, std::move(params), renderTarget);
+    mExpectations.emplace_back(std::make_unique<ImageExpectation>(fileName, lineNumber, mApi,
+            std::move(params), renderTarget));
 }
 
 void ImageExpectations::evaluate() {
     for (auto& expectation: mExpectations) {
-        expectation.evaluate();
+        expectation->evaluate();
     }
     mExpectations.clear();
 }
@@ -122,32 +140,28 @@ void ImageExpectations::evaluate() {
 RenderTargetDump::RenderTargetDump(filament::backend::DriverApi& api,
         filament::backend::RenderTargetHandle renderTarget, const ScreenshotParams& params)
         : mInternal(std::make_unique<RenderTargetDump::Internal>(params)) {
-#ifdef FILAMENT_IOS
-    bytesFilled_ = true;
-    bytes_.resize(size);
-    std::fill(bytes_.begin(), bytes_.end(), 0);
-#else
     const size_t size = mInternal->params.width() * mInternal->params.height() * 4;
     mInternal->bytes.resize(size);
 
     auto cb = [](void* buffer, size_t size, void* user) {
         auto* internal = static_cast<RenderTargetDump::Internal*>(user);
+        internal->bytesFilled = true;
+#ifndef FILAMENT_IOS
         image::LinearImage image(internal->params.width(), internal->params.width(), 4);
         image = image::toLinearWithAlpha<uint8_t>(internal->params.width(),
                 internal->params.height(),
                 internal->params.width() * 4, (uint8_t*)buffer);
-        std::string filePath = internal->params.generatedActualFilePath();
+        std::string filePath = internal->params.actualFilePath();
         std::ofstream pngStream(filePath, std::ios::binary | std::ios::trunc);
         image::ImageEncoder::encode(pngStream, image::ImageEncoder::Format::PNG, image, "",
                 filePath);
-        internal->bytesFilled = true;
+#endif
     };
     filament::backend::PixelBufferDescriptor pb(mInternal->bytes.data(), size,
             filament::backend::PixelDataFormat::RGBA, filament::backend::PixelDataType::UBYTE, cb,
             (void*)mInternal.get());
     api.readPixels(renderTarget, 0, 0, mInternal->params.width(), mInternal->params.height(),
             std::move(pb));
-#endif
 }
 
 RenderTargetDump::~RenderTargetDump() {
@@ -169,4 +183,30 @@ bool RenderTargetDump::bytesFilled() const {
     return mInternal->bytesFilled;
 }
 
-RenderTargetDump::Internal::Internal(const ScreenshotParams& params) : params(params) {}
+RenderTargetDump::Internal::Internal(const ScreenshotParams& params) : params(params) {}
+
+LoadedPng::LoadedPng(std::string filePath) : mFilePath(std::move(filePath)) {
+#ifndef FILAMENT_IOS
+    std::ifstream pngStream(mFilePath, std::ios::binary);
+    image::LinearImage loadedImage = image::ImageDecoder::decode(pngStream, filePath,
+            image::ImageDecoder::ColorSpace::LINEAR);
+    size_t valuesInImage = loadedImage.getWidth() * loadedImage.getHeight() *
+                          loadedImage.getChannels();
+    // The linear image is loaded with each component as [0.0, 1.0] but should be [0, 255], so
+    // convert them.
+    mBytes = std::vector<unsigned char>(valuesInImage);
+    for (int i = 0; i < valuesInImage; ++i) {
+        mBytes[i] = static_cast<uint8_t>(loadedImage.get<float>()[i] * 255.0f);
+    }
+#endif
+    // For platforms that don't support the image loading library, leave the loaded data blank.
+}
+
+uint32_t LoadedPng::hash() const {
+    EXPECT_THAT(mBytes, testing::Not(testing::IsEmpty()))
+            << "Failed to load expected test result: " << mFilePath;
+    if (mBytes.empty()) {
+        return 0;
+    }
+    return utils::hash::murmur3((uint32_t*)mBytes.data(), mBytes.size() / 4, 0);
+}

filament/backend/test/ImageExpectations.h

@@ -46,11 +46,12 @@ public:
     int height() const;
     uint32_t expectedHash() const;
 
-    std::string outputDirectoryPath() const;
-    std::string generatedActualFileName() const;
-    std::string generatedActualFilePath() const;
-    std::string goldenFileName() const;
-    std::string goldenFilePath() const;
+    static std::string actualDirectoryPath();
+    std::string actualFileName() const;
+    std::string actualFilePath() const;
+    static std::string expectedDirectoryPath();
+    std::string expectedFileName() const;
+    std::string expectedFilePath() const;
 
 private:
     int mWidth;
@@ -98,6 +99,17 @@ private:
     std::unique_ptr<Internal> mInternal;
 };
 
+class LoadedPng {
+public:
+    explicit LoadedPng(std::string filePath);
+
+    uint32_t hash() const;
+
+private:
+    std::string mFilePath;
+    std::vector<unsigned char> mBytes;
+};
+
 class ImageExpectation {
 public:
     ImageExpectation(const char* fileName, int lineNumber, filament::backend::DriverApi& api,
@@ -130,7 +142,8 @@ public:
 
 private:
     filament::backend::DriverApi& mApi;
-    std::vector<ImageExpectation> mExpectations;
+    // Store expectations in unique pointers because they are self referential.
+    std::vector<std::unique_ptr<ImageExpectation>> mExpectations;
 };
 
 #endif //TNT_IMAGE_EXPECTATIONS_H

filament/backend/test/PlatformRunner.cpp

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "PlatformRunner.h"
+
+namespace utils {
+
+template<>
+CString to_string<test::Backend>(test::Backend backend) noexcept {
+    switch (backend) {
+        case test::Backend::OPENGL: {
+            return "OpenGL";
+        }
+        case test::Backend::VULKAN: {
+            return "Vulkan";
+        }
+        case test::Backend::METAL: {
+            return "Metal";
+        }
+        case test::Backend::WEBGPU: {
+            return "WebGPU";
+        }
+        case test::Backend::NOOP:
+        default: {
+            return "No-op";
+        }
+    }
+}
+
+template<>
+CString to_string(test::OperatingSystem os) noexcept {
+    switch (os) {
+        case test::OperatingSystem::LINUX: {
+            return "Linux";
+        }
+        case test::OperatingSystem::APPLE: {
+            return "Apple";
+        }
+        case test::OperatingSystem::OTHER:
+        default: {
+            return "Other";
+        }
+    }
+}
+
+} // namespace utils
+

filament/backend/test/PlatformRunner.h

@@ -19,6 +19,7 @@
 
 #include <stdint.h>
 #include <stddef.h>
+#include "utils/CString.h"
 
 namespace test {
 
@@ -34,6 +35,15 @@ enum class Backend : uint8_t {
     NOOP = 5,
 };
 
+enum class OperatingSystem: uint8_t {
+    OTHER = 1,
+    // Also represents android phones.
+    LINUX = 2,
+    // Also represents iOS phones.
+    APPLE = 3,
+    // TODO: When tests support windows add it here.
+};
+
 struct NativeView {
     void* ptr = nullptr;
     size_t width = 0, height = 0;
@@ -51,9 +61,10 @@ NativeView getNativeView();
  * No tests will be run yet.
  *
  * @param backend The backend to run the tests on.
+ * @param operatingSystem The operating system the tests are being run on.
  * @param isMobile True if the platform is a mobile platform (iOS or Android).
  */
-void initTests(Backend backend, bool isMobile, int& argc, char* argv[]);
+void initTests(Backend backend, OperatingSystem operatingSystem, bool isMobile, int& argc, char* argv[]);
 
 /**
  * Test runners should call runTests when they are ready for tests to be run.
@@ -68,6 +79,6 @@ int runTests();
  */
 Backend parseArgumentsForBackend(int argc, char* argv[]);
 
-}
+} // namespace test
 
 #endif

filament/backend/test/Shader.cpp

@@ -23,30 +23,44 @@ namespace test {
 
 using namespace filament::backend;
 
-Shader::Shader(DriverApi& api, Cleanup& cleanup, ShaderConfig config) {
-    utils::FixedCapacityVector<DescriptorSetLayoutBinding> kLayouts(config.uniformNames.size());
-    for (unsigned char i = 0; i < config.uniformNames.size(); ++i) {
-        kLayouts[i] =
-                { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, i };
-    };
+Shader::Shader(DriverApi& api, Cleanup& cleanup, ShaderConfig config) : mCleanup(cleanup) {
+    utils::FixedCapacityVector<DescriptorSetLayoutBinding> kLayouts(config.uniforms.size());
+    for (unsigned char i = 0; i < config.uniforms.size(); ++i) {
+        kLayouts[i] = {
+                config.uniforms[i].type.value_or(DescriptorType::UNIFORM_BUFFER),
+                ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, i };
+    }
 
+    // This assumes that the uniforms will all be in a single descriptor set at index 1.
+    // If there are shaders with uniforms in other sets then ShaderConfig will need to be expanded
+    // to accommodate that.
+    size_t kDescriptorSetIndex = 1;
     filamat::DescriptorSets descriptors;
-    for (unsigned char i = 0; i < config.uniformNames.size(); ++i) {
-        descriptors[i + 1] = {{ config.uniformNames[i], kLayouts[i], {}}};
+    descriptors[kDescriptorSetIndex] = filamat::DescriptorSetInfo(config.uniforms.size());
+    for (unsigned char i = 0; i < config.uniforms.size(); ++i) {
+        descriptors[kDescriptorSetIndex][i] = {
+                config.uniforms[i].name, kLayouts[i], config.uniforms[i].samplerInfo };
     }
     ShaderGenerator shaderGen(
             std::move(config.vertexShader), std::move(config.fragmentShader), BackendTest::sBackend,
             BackendTest::sIsMobilePlatform, std::move(descriptors));
     Program prog = shaderGen.getProgram(api);
-    for (unsigned char i = 0; i < config.uniformNames.size(); ++i) {
-        prog.descriptorBindings(1, {{ config.uniformNames[i], DescriptorType::UNIFORM_BUFFER, i }});
+
+    Program::DescriptorBindingsInfo bindingsInfo(config.uniforms.size());
+    for (unsigned char i = 0; i < config.uniforms.size(); ++i) {
+        bindingsInfo[i] = {
+                config.uniforms[i].name,
+                config.uniforms[i].type.value_or(DescriptorType::UNIFORM_BUFFER), i };
     }
+    prog.descriptorBindings(1, bindingsInfo);
     mProgram = cleanup.add(api.createProgram(std::move(prog)));
 
     mDescriptorSetLayout = cleanup.add(
             api.createDescriptorSetLayout(DescriptorSetLayout{ kLayouts }));
+}
 
-    mDescriptorSet = cleanup.add(api.createDescriptorSet(mDescriptorSetLayout));
+filament::backend::DescriptorSetHandle Shader::createDescriptorSet(DriverApi& api) const {
+    return mCleanup.add(api.createDescriptorSet(mDescriptorSetLayout));
 }
 
 filament::backend::ProgramHandle Shader::getProgram() const {
@@ -57,8 +71,4 @@ filament::backend::DescriptorSetLayoutHandle Shader::getDescriptorSetLayout() co
     return mDescriptorSetLayout;
 }
 
-filament::backend::DescriptorSetHandle Shader::getDescriptorSet() const {
-    return mDescriptorSet;
-}
-
 } // namespace test

filament/backend/test/Shader.h

@@ -18,14 +18,22 @@
 #define TNT_SHADER_H
 
 #include "Lifetimes.h"
+#include "private/filament/SamplerInterfaceBlock.h"
 
 namespace test {
 
+struct UniformConfig {
+    utils::CString name;
+    // If not specified this will be DescriptorType::UNIFORM_BUFFER
+    std::optional<filament::backend::DescriptorType> type;
+    std::optional<filament::SamplerInterfaceBlock::SamplerInfo> samplerInfo;
+};
+
 // All describing a shader that should be created.
 struct ShaderConfig {
     std::string vertexShader;
     std::string fragmentShader;
-    std::vector<utils::CString> uniformNames;
+    std::vector<UniformConfig> uniforms;
 };
 
 // All values describing a uniform.
@@ -35,6 +43,7 @@ struct ResolvedUniformBindingConfig {
     uint32_t byteOffset;
     filament::backend::descriptor_set_t set;
     filament::backend::descriptor_binding_t binding;
+    std::optional<filament::backend::DescriptorSetHandle> descriptorSet;
 };
 
 // An equivalent to ResolvedUniformBindingConfig with all fields optional.
@@ -46,6 +55,7 @@ struct UniformBindingConfig {
     std::optional<uint32_t> byteOffset;
     std::optional<filament::backend::descriptor_set_t> set;
     std::optional<filament::backend::descriptor_binding_t> binding;
+    std::optional<filament::backend::DescriptorSetHandle> descriptorSet;
 
     template<typename UniformType>
     ResolvedUniformBindingConfig resolve();
@@ -79,12 +89,14 @@ public:
 
     filament::backend::ProgramHandle getProgram() const;
     filament::backend::DescriptorSetLayoutHandle getDescriptorSetLayout() const;
-    filament::backend::DescriptorSetHandle getDescriptorSet() const;
+
+    filament::backend::DescriptorSetHandle createDescriptorSet(
+            filament::backend::DriverApi& api) const;
 
 protected:
+    Cleanup& mCleanup;
     filament::backend::ProgramHandle mProgram;
     filament::backend::DescriptorSetLayoutHandle mDescriptorSetLayout;
-    filament::backend::DescriptorSetHandle mDescriptorSet;
 };
 
 template<typename UniformType>
@@ -95,7 +107,8 @@ ResolvedUniformBindingConfig UniformBindingConfig::resolve() {
             .bufferSize = bufferSize.value_or(resolvedDataSize),
             .byteOffset = byteOffset.value_or(0),
             .set = set.value_or(1),
-            .binding = binding.value_or(0)
+            .binding = binding.value_or(0),
+            .descriptorSet = descriptorSet
     };
 }
 
@@ -120,9 +133,16 @@ void Shader::bindUniform(filament::backend::DriverApi& api,
         UniformBindingConfig config) const {
     auto resolvedConfig = config.resolve<UniformType>();
 
-    api.updateDescriptorSetBuffer(getDescriptorSet(), resolvedConfig.binding, hwBuffer, 0,
+    filament::backend::DescriptorSetHandle descriptorSet;
+    if (resolvedConfig.descriptorSet.has_value()) {
+        descriptorSet = *resolvedConfig.descriptorSet;
+    } else {
+        descriptorSet = createDescriptorSet(api);
+    }
+
+    api.updateDescriptorSetBuffer(descriptorSet, resolvedConfig.binding, hwBuffer, 0,
             resolvedConfig.bufferSize);
-    api.bindDescriptorSet(getDescriptorSet(), resolvedConfig.set, {});
+    api.bindDescriptorSet(descriptorSet, resolvedConfig.set, {});
 }
 
 template<typename UniformType>

filament/backend/test/SharedShaders.cpp

@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SharedShaders.h"
+
+#include "Shader.h"
+#include "absl/strings/str_format.h"
+#include "gtest/gtest.h"
+
+namespace test {
+
+using namespace filament::backend;
+
+namespace {
+
+// A shader stored in pieces so that uniform declarations can be injected.
+struct ShaderText {
+    std::string mPrefix;
+    std::string mBody;
+
+    std::string withUniform(const std::string& uniformText) const {
+        return absl::StrFormat("%s\n%s\n%s", mPrefix.c_str(), uniformText.c_str(), mBody.c_str());
+    }
+};
+
+std::optional<ShaderText> GetGlslVertexShader(VertexShaderType type) {
+    switch (type) {
+        case VertexShaderType::Noop: {
+            return ShaderText{
+                    R"(
+#version 450 core
+layout(location = 0) in vec4 mesh_position;
+)", R"(
+void main() {
+    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
+#if defined(TARGET_VULKAN_ENVIRONMENT)
+    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
+    gl_Position.y = -gl_Position.y;
+#endif
+})" };
+        }
+        case VertexShaderType::Simple: {
+            return ShaderText{
+                    R"(
+#version 450 core
+layout(location = 0) in vec4 mesh_position;
+)", R"(
+void main() {
+    gl_Position = vec4(
+            mesh_position.xy * (params.scaleMinusOne.xy + 1.0) + params.offset.xy,
+            params.scaleMinusOne.z + 1.0,
+            1.0);
+#if defined(TARGET_VULKAN_ENVIRONMENT)
+    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
+    gl_Position.y = -gl_Position.y;
+#endif
+})" };
+        }
+        case VertexShaderType::Textured: {
+            return ShaderText{
+                    R"(
+#version 450 core
+layout(location = 0) in vec4 mesh_position;
+layout(location = 0) out vec2 uv;
+)", R"(
+void main() {
+    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
+    uv = (mesh_position.xy * 0.5 + 0.5);
+#if defined(TARGET_VULKAN_ENVIRONMENT)
+    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
+    gl_Position.y = -gl_Position.y;
+#endif
+})" };
+        }
+        default:
+            return std::nullopt;
+    }
+}
+
+std::optional<ShaderText> GetGlslFragmentShader(FragmentShaderType type) {
+    switch (type) {
+        case FragmentShaderType::White: {
+            return ShaderText{
+                    R"(
+#version 450 core
+precision mediump int; precision highp float;
+layout(location = 0) out vec4 fragColor;
+)", R"(
+void main() {
+    fragColor = vec4(1.0, 1.0, 1.0, 1.0);
+})" };
+        }
+        case FragmentShaderType::SolidColored: {
+            return ShaderText{
+                    R"(
+#version 450 core
+precision mediump int; precision highp float;
+layout(location = 0) out vec4 fragColor;
+)", R"(
+void main() {
+    fragColor = params.color;
+})" };
+        }
+        case FragmentShaderType::Textured: {
+            return ShaderText{
+                    R"(
+#version 450 core
+precision mediump int; precision highp float;
+layout(location = 0) out vec4 fragColor;
+layout(location = 0) in vec2 uv;
+)", R"(
+void main() {
+    fragColor = texture(test_tex, uv);
+})" };
+        }
+        default:
+            return std::nullopt;
+    }
+}
+
+std::optional<std::string> GetGlslUniform(ShaderUniformType type) {
+    switch (type) {
+        case ShaderUniformType::None: {
+            return "";
+        }
+        case ShaderUniformType::Simple: {
+            return R"(
+layout(binding = 0, set = 1) uniform Params {
+    highp vec4 color;
+    // Use scaleMinusOne instead of scale so that a 0 initialized value is a good default
+    highp vec4 scaleMinusOne;
+    highp vec4 offset;
+} params;
+)";
+        }
+        case ShaderUniformType::SimpleWithPadding: {
+            return R"(
+layout(binding = 0, set = 1) uniform Params {
+    highp vec4 padding[4];  // offset of 64 bytes
+
+    highp vec4 color;
+    // Use scaleMinusOne instead of scale so that a 0 initialized value is a good default
+    highp vec4 scaleMinusOne;
+    highp vec4 offset;
+} params;
+)";
+        }
+        case ShaderUniformType::Sampler: {
+            return R"(
+layout(location = 0, set = 1) uniform sampler2D test_tex;
+)";
+        }
+        default:
+            return std::nullopt;
+    }
+}
+
+std::vector<UniformConfig> GetUniformConfig(ShaderUniformType type) {
+    switch (type) {
+        case ShaderUniformType::None: {
+            return {};
+        }
+        case ShaderUniformType::Simple: {
+            return {{ "Params" }};
+        }
+        case ShaderUniformType::SimpleWithPadding: {
+            return {{ "Params" }};
+        }
+        case ShaderUniformType::Sampler: {
+            filament::SamplerInterfaceBlock::SamplerInfo samplerInfo{
+                    "backend_test", "test_tex", 0,
+                    SamplerType::SAMPLER_2D, SamplerFormat::FLOAT, Precision::HIGH, false };
+            return {{
+                            "test_tex", DescriptorType::SAMPLER, samplerInfo
+                    }};
+        }
+        default:
+            abort();
+    }
+}
+
+ShaderLanguage getShaderLanguage(const Backend& backend) {
+    switch (backend) {
+        case Backend::METAL:
+            return ShaderLanguage::MSL;
+        case Backend::WEBGPU:
+            return ShaderLanguage::WGSL;
+        case Backend::VULKAN:
+        case Backend::NOOP:
+        case Backend::OPENGL:
+        default: {
+            return ShaderLanguage::GLSL;
+        }
+    }
+}
+
+} // namespace
+
+Shader SharedShaders::makeShader(filament::backend::DriverApi& api, Cleanup& cleanup,
+        ShaderRequest request) {
+    std::optional<ShaderText> vertex;
+    std::optional<ShaderText> fragment;
+    std::optional<std::string> uniform;
+    if (getShaderLanguage(BackendTest::sBackend) != ShaderLanguage::GLSL) {
+        // TODO: If any shaders need backend/shader language specific shaders rather than transpiled
+        // versions of the GLSL shader, check environment.
+    }
+    vertex = GetGlslVertexShader(request.mVertexType);
+    fragment = GetGlslFragmentShader(request.mFragmentType);
+    uniform = GetGlslUniform(request.mUniformType);
+    if (vertex.has_value() && fragment.has_value() && uniform.has_value()) {
+        return Shader(
+                api, cleanup, ShaderConfig{
+                        vertex->withUniform(*uniform), fragment->withUniform(*uniform),
+                        GetUniformConfig(request.mUniformType)}
+        );
+    }
+    abort();
+}
+
+std::string SharedShaders::getVertexShaderText(VertexShaderType vertex, ShaderUniformType uniform) {
+    std::optional<ShaderText> vertexText = GetGlslVertexShader(vertex);
+    std::optional<std::string> uniformText = GetGlslUniform(uniform);
+    if (!vertexText.has_value() || !uniformText.has_value()) {
+        abort();
+    }
+    return vertexText->withUniform(*uniformText);
+}
+
+std::string SharedShaders::getFragmentShaderText(FragmentShaderType fragment,
+        ShaderUniformType uniform) {
+    std::optional<ShaderText> fragmentText = GetGlslFragmentShader(fragment);
+    std::optional<std::string> uniformText = GetGlslUniform(uniform);
+    if (!fragmentText.has_value() || !uniformText.has_value()) {
+        abort();
+    }
+    return fragmentText->withUniform(*uniformText);
+}
+
+} // namespace test

filament/backend/test/SharedShaders.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TNT_SHAREDSHADERS_H
+#define TNT_SHAREDSHADERS_H
+
+#include "Shader.h"
+#include "SharedShadersConstants.h"
+#include "Lifetimes.h"
+#include "PlatformRunner.h"
+
+namespace test {
+
+enum class ShaderLanguage : uint8_t {
+    GLSL,
+    MSL,
+    WGSL
+};
+
+struct ShaderRequest {
+    VertexShaderType mVertexType;
+    FragmentShaderType mFragmentType;
+    ShaderUniformType mUniformType;
+};
+
+class SharedShaders {
+public:
+    static Shader makeShader(filament::backend::DriverApi& api, Cleanup& cleanup,
+            ShaderRequest request);
+    static std::string getVertexShaderText(VertexShaderType vertex, ShaderUniformType uniform);
+    static std::string getFragmentShaderText(FragmentShaderType fragment,
+            ShaderUniformType uniform);
+};
+
+} // namespace test
+
+#endif //TNT_SHAREDSHADERS_H

filament/backend/test/SharedShadersConstants.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TNT_SHAREDSHADERSCONSTANTS_H
+#define TNT_SHAREDSHADERSCONSTANTS_H
+
+#include "math/mathfwd.h"
+
+enum class ShaderUniformType : uint8_t {
+    None,
+    Simple,
+    SimpleWithPadding,
+    Sampler,
+};
+
+struct SimpleMaterialParams {
+    filament::math::float4 color;
+    // 1.0 will be added to this value before use.
+    // The XY values are used to scale position inputs and the Z value is used to set the output
+    // position's Z value.
+    filament::math::float4 scaleMinusOne;
+    // Offset will be applied after scale
+    filament::math::float4 offset;
+};
+
+struct SimpleWithPaddingMaterialParams {
+    // The associated uniform structure in the shader will have 64 bytes of padding at the beginning
+    // So users of this struct will need to add 64 bytes to its size and offset all uniform writes.
+    filament::math::float4 color;
+    // 1.0 will be added to this value before use.
+    // The XY values are used to scale position inputs and the Z value is used to set the output
+    // position's Z value.
+    filament::math::float4 scaleMinusOne;
+    // Offset will be applied after scale
+    filament::math::float4 offset;
+};
+
+enum class VertexShaderType : uint8_t {
+    Noop,
+    Simple,
+    Textured
+};
+
+enum class FragmentShaderType : uint8_t {
+    White,
+    SolidColored,
+    Textured
+};
+
+#endif //TNT_SHAREDSHADERSCONSTANTS_H

filament/backend/test/Skip.cpp

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Skip.h"
+
+#include <sstream>
+
+namespace test {
+
+SkipEnvironment::SkipEnvironment(test::Backend backend) : backend(backend) {}
+SkipEnvironment::SkipEnvironment(test::OperatingSystem os) : os(os) {}
+SkipEnvironment::SkipEnvironment(test::OperatingSystem os, test::Backend backend)
+    : backend(backend),
+      os(os) {}
+
+bool SkipEnvironment::matches() {
+    bool backendMatches = !backend.has_value() || *backend == BackendTest::sBackend;
+    bool osMatches = !os.has_value() || *os == BackendTest::sOperatingSystem;
+    bool isMobileMatches = !isMobile.has_value() || *isMobile == BackendTest::sIsMobilePlatform;
+    return backendMatches && osMatches && isMobileMatches;
+}
+
+std::string SkipEnvironment::describe() {
+    std::stringstream result;
+    if (matches()) {
+        result << "environment matches because " << describe_actual_environment() << ".";
+    } else {
+        result << "environment does not match because " << describe_requirements() << " but "
+               << describe_actual_environment() << ".";
+    }
+    return result.str();
+}
+
+std::string SkipEnvironment::describe_actual_environment() {
+    bool resultWritten = false;
+    std::stringstream reality;
+    if (backend.has_value()) {
+        reality << "backend was " << utils::to_string(BackendTest::sBackend).c_str();
+        resultWritten = true;
+    }
+    if (os.has_value()) {
+        if (resultWritten) {
+            reality << ", and ";
+        }
+        reality << "operating system was "
+                << utils::to_string(BackendTest::sOperatingSystem).c_str();
+        resultWritten = true;
+    }
+    if (isMobile.has_value()) {
+        if (resultWritten) {
+            reality << ", and ";
+        }
+        reality << "device " << (BackendTest::sIsMobilePlatform ? "was" : "was not") << " mobile";
+        resultWritten = true;
+    }
+    return reality.str();
+}
+
+std::string SkipEnvironment::describe_requirements() {
+    bool resultWritten = false;
+    std::stringstream requirement;
+    if (backend.has_value()) {
+        requirement << "backend needs to be " << utils::to_string(*backend).c_str();
+        resultWritten = true;
+    }
+    if (os.has_value()) {
+        if (resultWritten) {
+            requirement << ", and ";
+        }
+        requirement << "operating system needs to be " << utils::to_string(*os).c_str();
+        resultWritten = true;
+    }
+    if (isMobile.has_value() && BackendTest::sIsMobilePlatform != isMobile) {
+        if (resultWritten) {
+            requirement << ", and ";
+        }
+        requirement << "device needs to " << (*isMobile ? "be" : "not be") << " mobile";
+        resultWritten = true;
+    }
+    return requirement.str();
+}
+
+} // namespace test

filament/backend/test/Skip.h

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

filament/backend/test/linux_runner.cpp

@@ -51,6 +51,6 @@ int main(int argc, char* argv[]) {
         return 1;
     }
 
-    test::initTests(backend, false, argc, argv);
+    test::initTests(backend, test::OperatingSystem::LINUX, false, argc, argv);
     return test::runTests();
 }

filament/backend/test/mac_runner.mm

@@ -98,7 +98,7 @@ test::NativeView getNativeView() {
 
 int main(int argc, char* argv[]) {
     auto backend = test::parseArgumentsForBackend(argc, argv);
-    test::initTests(backend, false, argc, argv);
+    test::initTests(backend, test::OperatingSystem::APPLE, false, argc, argv);
     AppDelegate* delegate = [AppDelegate new];
     delegate.backend = backend;
     NSApplication* app = [NSApplication sharedApplication];

filament/backend/test/test_Blit.cpp

@@ -19,6 +19,7 @@
 #include "ImageExpectations.h"
 #include "Lifetimes.h"
 #include "Shader.h"
+#include "SharedShaders.h"
 #include "TrianglePrimitive.h"
 
 #include <utils/Hash.h>
@@ -40,48 +41,14 @@ using namespace filament::backend;
 using namespace filament::math;
 using namespace utils;
 
-struct MaterialParams {
-    float4 color;
-    float4 scale;
-};
-
 class BlitTest : public BackendTest {
 public:
     BlitTest() : mCleanup(getDriverApi()) {}
 
 protected:
-    Shader createShader();
-
     Cleanup mCleanup;
 };
 
-static const char* const triangleVs = R"(#version 450 core
-layout(location = 0) in vec4 mesh_position;
-layout(binding = 0, set = 1) uniform Params { highp vec4 color; highp vec4 scale; } params;
-void main() {
-    gl_Position = vec4((mesh_position.xy + 0.5) * params.scale.xy, params.scale.z, 1.0);
-#if defined(TARGET_VULKAN_ENVIRONMENT)
-    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
-    gl_Position.y = -gl_Position.y;
-#endif
-})";
-
-static const char* const triangleFs = R"(#version 450 core
-precision mediump int; precision highp float;
-layout(location = 0) out vec4 fragColor;
-layout(binding = 0, set = 1) uniform Params { highp vec4 color; highp vec4 scale; } params;
-void main() {
-    fragColor = params.color;
-})";
-
-Shader BlitTest::createShader() {
-    return Shader(getDriverApi(), mCleanup, ShaderConfig{
-            .vertexShader = triangleVs,
-            .fragmentShader = triangleFs,
-            .uniformNames = { "Params" },
-    });
-}
-
 static uint32_t toUintColor(float4 color) {
     color = saturate(color);
     uint32_t r = color.r * 255.0f;
@@ -230,16 +197,10 @@ TEST_F(BlitTest, ColorMagnify) {
     }
 
     {
-        ImageExpectations expectations(api);
-
-        {
-            RenderFrame frame(api);
-            EXPECT_IMAGE(dstRenderTargets[0], expectations,
-                    ScreenshotParams(kDstTexWidth, kDstTexHeight, "ColorMagnify", 0x410bdd31));
-            api.commit(swapChain);
-        }
-
-        flushAndWait();
+        RenderFrame frame(api);
+        EXPECT_IMAGE(dstRenderTargets[0], getExpectations(),
+                ScreenshotParams(kDstTexWidth, kDstTexHeight, "ColorMagnify", 0x410bdd31));
+        api.commit(swapChain);
     }
 }
 
@@ -293,14 +254,8 @@ TEST_F(BlitTest, ColorMinify) {
             { 0, 0, kSrcTexWidth >> srcLevel, kSrcTexHeight >> srcLevel },
             SamplerMagFilter::LINEAR);
 
-    {
-        ImageExpectations expectations(api);
-
-        EXPECT_IMAGE(dstRenderTargets[0], expectations,
-                ScreenshotParams(kDstTexWidth, kDstTexHeight, "ColorMinify", 0xf3d9c53f));
-
-        flushAndWait();
-    }
+    EXPECT_IMAGE(dstRenderTargets[0], getExpectations(),
+            ScreenshotParams(kDstTexWidth, kDstTexHeight, "ColorMinify", 0xf3d9c53f));
 }
 
 TEST_F(BlitTest, ColorResolve) {
@@ -313,7 +268,11 @@ TEST_F(BlitTest, ColorResolve) {
     constexpr auto kColorTexFormat = TextureFormat::RGBA8;
     constexpr int kSampleCount = 4;
 
-    Shader shader = createShader();
+    Shader shader = SharedShaders::makeShader(api, mCleanup, ShaderRequest{
+            .mVertexType = VertexShaderType::Simple,
+            .mFragmentType = FragmentShaderType::SolidColored,
+            .mUniformType = ShaderUniformType::Simple,
+    });
 
     // Create a VertexBuffer, IndexBuffer, and RenderPrimitive.
     TrianglePrimitive const triangle(api);
@@ -356,14 +315,15 @@ TEST_F(BlitTest, ColorResolve) {
     state.rasterState.depthFunc = RasterState::DepthFunc::A;
     state.rasterState.culling = CullingMode::NONE;
 
-    auto ubuffer = mCleanup.add(api.createBufferObject(sizeof(MaterialParams),
+    auto ubuffer = mCleanup.add(api.createBufferObject(sizeof(SimpleMaterialParams),
             BufferObjectBinding::UNIFORM, BufferUsage::STATIC));
     // Draw red triangle into srcRenderTarget.
-    shader.uploadUniform(api, ubuffer, MaterialParams{
-            .color = float4(1, 0, 0, 1),
-            .scale = float4(1, 1, 0.5, 0),
+    shader.uploadUniform(api, ubuffer, SimpleMaterialParams{
+        .color = float4(1, 0, 0, 1),
+        .scaleMinusOne = float4(0, 0, -0.5, 0),
+        .offset = float4(0.5, 0.5, 0, 0),
     });
-    shader.bindUniform<MaterialParams>(api, ubuffer);
+    shader.bindUniform<SimpleMaterialParams>(api, ubuffer);
 
     // FIXME: on Metal this triangle is not drawn. Can't understand why.
     {
@@ -379,14 +339,8 @@ TEST_F(BlitTest, ColorResolve) {
             srcRenderTarget, { 0, 0, kSrcTexWidth, kSrcTexHeight },
             SamplerMagFilter::NEAREST);
 
-    {
-        ImageExpectations expectations(api);
-
-        EXPECT_IMAGE(dstRenderTarget, expectations,
-                ScreenshotParams(kDstTexWidth, kDstTexHeight, "ColorResolve", 0xebfac2ef));
-
-        flushAndWait();
-    }
+    EXPECT_IMAGE(dstRenderTarget, getExpectations(),
+            ScreenshotParams(kDstTexWidth, kDstTexHeight, "ColorResolve", 0xebfac2ef));
 }
 
 TEST_F(BlitTest, Blit2DTextureArray) {
@@ -451,17 +405,11 @@ TEST_F(BlitTest, Blit2DTextureArray) {
     }
 
     {
-        ImageExpectations expectations(api);
-
-        {
-            RenderFrame frame(api);
-            EXPECT_IMAGE(dstRenderTarget, expectations,
-                    ScreenshotParams(kDstTexWidth, kDstTexHeight, "Blit2DTextureArray",
-                            0x8de7d55b));
-            api.commit(swapChain);
-        }
-
-        flushAndWait();
+        RenderFrame frame(api);
+        EXPECT_IMAGE(dstRenderTarget, getExpectations(),
+                ScreenshotParams(kDstTexWidth, kDstTexHeight, "Blit2DTextureArray",
+                        0x8de7d55b));
+        api.commit(swapChain);
     }
 }
 
@@ -531,18 +479,12 @@ TEST_F(BlitTest, BlitRegion) {
     }
 
     {
-        ImageExpectations expectations(api);
-
-        {
-            RenderFrame frame(api);
-            // TODO: for some reason, this test has very, very slight (as in one pixel) differences
-            // between OpenGL and Metal. So disable golden checking for now.
-            // EXPECT_IMAGE(dstRenderTarget, expectations, ScreenshotParams(kDstTexWidth,
-            //         kDstTexHeight, "BlitRegion", 0x74fa34ed));
-            api.commit(swapChain);
-        }
-
-        flushAndWait();
+        RenderFrame frame(api);
+        // TODO: for some reason, this test has very, very slight (as in one pixel) differences
+        // between OpenGL and Metal. So disable golden checking for now.
+        // EXPECT_IMAGE(dstRenderTarget, expectations, ScreenshotParams(kDstTexWidth,
+        //         kDstTexHeight, "BlitRegion", 0x74fa34ed));
+        api.commit(swapChain);
     }
 }
 
@@ -595,25 +537,19 @@ TEST_F(BlitTest, BlitRegionToSwapChain) {
     };
 
     {
-        ImageExpectations expectations(api);
-        {
-            {
-                RenderFrame frame(api);
+        RenderFrame frame(api);
 
-                api.blitDEPRECATED(TargetBufferFlags::COLOR0, dstRenderTarget,
-                        dstRect, srcRenderTargets[srcLevel],
-                        srcRect, SamplerMagFilter::LINEAR);
+        api.blitDEPRECATED(TargetBufferFlags::COLOR0, dstRenderTarget,
+                dstRect, srcRenderTargets[srcLevel],
+                srcRect, SamplerMagFilter::LINEAR);
 
-                api.commit(swapChain);
-            }
-
-            // TODO: for some reason, this test has been disabled. It needs to be tested on all
-            // machines.
-            // EXPECT_IMAGE(dstRenderTarget, expectations,
-            //         ScreenshotParams(kDstTexWidth, kDstTexHeight, "BlitRegionToSwapChain", 0x0));
-        }
-        flushAndWait();
+        api.commit(swapChain);
     }
+
+    // TODO: for some reason, this test has been disabled. It needs to be tested on all
+    // machines.
+    // EXPECT_IMAGE(dstRenderTarget, expectations,
+    //         ScreenshotParams(kDstTexWidth, kDstTexHeight, "BlitRegionToSwapChain", 0x0));
 }
 
 } // namespace test

filament/backend/test/test_BufferUpdates.cpp

@@ -16,74 +16,21 @@
 
 #include "BackendTest.h"
 
+#include "ImageExpectations.h"
 #include "Lifetimes.h"
 #include "Shader.h"
-#include "ShaderGenerator.h"
+#include "SharedShaders.h"
 #include "TrianglePrimitive.h"
 
-namespace {
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Shaders
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-std::string vertex (R"(#version 450 core
-
-layout(location = 0) in vec4 mesh_position;
-
-layout(location = 0) out uvec4 indices;
-
-layout(binding = 0, set = 1) uniform Params {
-    highp vec4 padding[4];  // offset of 64 bytes
-
-    highp vec4 color;
-    highp vec4 offset;
-} params;
-
-void main() {
-    gl_Position = vec4(mesh_position.xy + params.offset.xy, 0.0, 1.0);
-#if defined(TARGET_VULKAN_ENVIRONMENT)
-    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
-    gl_Position.y = -gl_Position.y;
-#endif
-}
-)");
-
-std::string fragment (R"(#version 450 core
-
-layout(location = 0) out vec4 fragColor;
-
-layout(binding = 0, set = 1) uniform Params {
-    highp vec4 padding[4];  // offset of 64 bytes
-
-    highp vec4 color;
-    highp vec4 offset;
-} params;
-
-void main() {
-    fragColor = vec4(params.color.rgb, 1.0f);
-}
-
-)");
-
-}
-
 namespace test {
 
 using namespace filament;
 using namespace filament::backend;
 
-// In the shader, these MaterialParams are offset by 64 bytes into the uniform buffer to test buffer
-// updates with offset.
-struct MaterialParams {
-    math::float4 color;
-    math::float4 offset;
-};
-static_assert(sizeof(MaterialParams) == 8 * sizeof(float));
 // Uniform config for writing MaterialParams to the shader uniform with 64 bytes of padding.
 const UniformBindingConfig kBindingConfig = {
-        .dataSize = sizeof(MaterialParams),
-        .bufferSize = sizeof(MaterialParams) + 64,
+        .dataSize = sizeof(SimpleMaterialParams),
+        .bufferSize = sizeof(SimpleMaterialParams) + 64,
         .byteOffset = 64
 };
 
@@ -93,8 +40,10 @@ public:
 
 protected:
     Shader createShader() {
-        return Shader(getDriverApi(), mCleanup, ShaderConfig{
-           vertex, fragment, {"Params"}
+        return SharedShaders::makeShader(getDriverApi(), mCleanup, ShaderRequest{
+                .mVertexType = VertexShaderType::Simple,
+                .mFragmentType = FragmentShaderType::SolidColored,
+                .mUniformType = ShaderUniformType::SimpleWithPadding
         });
     }
 
@@ -129,7 +78,7 @@ TEST_F(BufferUpdatesTest, VertexBufferUpdate) {
         RenderPassParams params = {};
         fullViewport(params);
         params.flags.clear = TargetBufferFlags::COLOR;
-        params.clearColor = {0.f, 1.f, 0.f, 1.f};
+        params.clearColor = { 0.f, 1.f, 0.f, 1.f };
         params.flags.discardStart = TargetBufferFlags::ALL;
         params.flags.discardEnd = TargetBufferFlags::NONE;
 
@@ -144,17 +93,18 @@ TEST_F(BufferUpdatesTest, VertexBufferUpdate) {
         // Create a uniform buffer.
         // We use STATIC here, even though the buffer is updated, to force the Metal backend to use
         // a GPU buffer, which is more interesting to test.
-        auto ubuffer = cleanup.add(api.createBufferObject(sizeof(MaterialParams) + 64,
+        auto ubuffer = cleanup.add(api.createBufferObject(sizeof(SimpleMaterialParams) + 64,
                 BufferObjectBinding::UNIFORM, BufferUsage::STATIC));
 
-        shader.bindUniform<MaterialParams>(api, ubuffer, kBindingConfig);
+        shader.bindUniform<SimpleMaterialParams>(api, ubuffer, kBindingConfig);
 
         api.startCapture(0);
 
         // Upload the uniform, but with an offset to accommodate the padding in the shader's
         // uniform definition.
-        shader.uploadUniform(api, ubuffer, kBindingConfig, MaterialParams{
+        shader.uploadUniform(api, ubuffer, kBindingConfig, SimpleMaterialParams{
                 .color = { 1.0f, 1.0f, 1.0f, 1.0f },
+                .scaleMinusOne = { 0.0, 0.0, 0.0, 0.0 },
                 .offset = { 0.0f, 0.0f, 0.0f, 0.0f }
         });
 
@@ -165,19 +115,21 @@ TEST_F(BufferUpdatesTest, VertexBufferUpdate) {
         size_t triangleIndex = 0;
         for (float i = -1.0f; i < 1.0f; i += 0.2f) {
             const float low = i, high = i + 0.2;
-            const filament::math::float2 v[3] {{low, low}, {high, low}, {low, high}};
+            const filament::math::float2 v[3]{{ low,  low },
+                                              { high, low },
+                                              { low,  high }};
             triangle.updateVertices(v);
 
             if (updateIndices) {
                 if (triangleIndex % 2 == 0) {
                     // Upload each index separately, to test offsets.
-                    const TrianglePrimitive::index_type i[3] {0, 1, 2};
+                    const TrianglePrimitive::index_type i[3]{ 0, 1, 2 };
                     triangle.updateIndices(i + 0, 1, 0);
                     triangle.updateIndices(i + 1, 1, 1);
                     triangle.updateIndices(i + 2, 1, 2);
                 } else {
                     // This effectively hides this triangle.
-                    const TrianglePrimitive::index_type i[3] {0, 0, 0};
+                    const TrianglePrimitive::index_type i[3]{ 0, 0, 0 };
                     triangle.updateIndices(i);
                 }
             }
@@ -220,28 +172,29 @@ TEST_F(BufferUpdatesTest, BufferObjectUpdateWithOffset) {
     // Create a uniform buffer.
     // We use STATIC here, even though the buffer is updated, to force the Metal backend to use a
     // GPU buffer, which is more interesting to test.
-    auto ubuffer = cleanup.add(api.createBufferObject(sizeof(MaterialParams) + 64,
+    auto ubuffer = cleanup.add(api.createBufferObject(sizeof(SimpleMaterialParams) + 64,
             BufferObjectBinding::UNIFORM, BufferUsage::STATIC));
 
-    shader.bindUniform<MaterialParams>(api, ubuffer, kBindingConfig);
+    shader.bindUniform<SimpleMaterialParams>(api, ubuffer, kBindingConfig);
 
     // Create a render target.
     auto colorTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
             TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT));
     auto renderTarget = cleanup.add(api.createRenderTarget(
-            TargetBufferFlags::COLOR0, 512, 512, 1, 0, {{colorTexture}}, {}, {}));
+            TargetBufferFlags::COLOR0, 512, 512, 1, 0, {{ colorTexture }}, {}, {}));
 
     // Upload uniforms for the first triangle.
     // Upload the uniform, but with an offset to accommodate the padding in the shader's
     // uniform definition.
-    shader.uploadUniform(api, ubuffer, kBindingConfig, MaterialParams{
+    shader.uploadUniform(api, ubuffer, kBindingConfig, SimpleMaterialParams{
             .color = { 1.0f, 0.0f, 0.5f, 1.0f },
+            .scaleMinusOne = { 0.0f, 0.0f, 0.0f, 0.0f },
             .offset = { 0.0f, 0.0f, 0.0f, 0.0f }
     });
 
     RenderPassParams params = {};
     params.flags.clear = TargetBufferFlags::COLOR;
-    params.clearColor = {0.f, 0.f, 1.f, 1.f};
+    params.clearColor = { 0.f, 0.f, 1.f, 1.f };
     params.flags.discardStart = TargetBufferFlags::ALL;
     params.flags.discardEnd = TargetBufferFlags::NONE;
     params.viewport.height = 512;
@@ -250,27 +203,27 @@ TEST_F(BufferUpdatesTest, BufferObjectUpdateWithOffset) {
             renderTarget, swapChain, shader.getProgram(), params);
 
     // Upload uniforms for the second triangle. To test partial buffer updates, we'll only update
-    // color.b, color.a, offset.x, and offset.y.
-    shader.uploadUniform(api, ubuffer, UniformBindingConfig{
-                    .dataSize = sizeof(std::array<float, 4>),
-                    .bufferSize = kBindingConfig.bufferSize,
-                    .byteOffset = *kBindingConfig.byteOffset + offsetof(MaterialParams, color.b),
-            },
-            std::array<float, 4>{
-                    // color.b, color.a
-                    1.0f, 1.0f,
-                    // offset.x, offset.y
-                    0.5f, 0.5f }
-    );
+    // color.b, color.a, scaleMinusOne, offset.x, and offset.y.
+    const UniformBindingConfig partialBindingConfig = {
+            .dataSize = sizeof(float) * 8,
+            .bufferSize = sizeof(SimpleMaterialParams) + 64,
+            .byteOffset = 64 + offsetof(SimpleMaterialParams, color.b)
+    };
+    shader.uploadUniform(api, ubuffer, partialBindingConfig,
+            std::array<float, 8>{
+                    1.0f, 1.0f, // color.b, color.a
+                    0.0f, 0.0f, 0.0f, 0.0f, // scale
+                    0.5f, 0.5f // offset.x, offset.y
+            });
 
     params.flags.clear = TargetBufferFlags::NONE;
     params.flags.discardStart = TargetBufferFlags::NONE;
     renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
             renderTarget, swapChain, shader.getProgram(), params);
 
-    static const uint32_t expectedHash = 91322442;
-    readPixelsAndAssertHash(
-            "BufferObjectUpdateWithOffset", 512, 512, renderTarget, expectedHash, true);
+
+    EXPECT_IMAGE(renderTarget, getExpectations(),
+            ScreenshotParams(512, 512, "BufferObjectUpdateWithOffset", 91322442));
 
     api.flush();
     api.commit(swapChain);

filament/backend/test/test_Callbacks.cpp

@@ -17,6 +17,7 @@
 #include "BackendTest.h"
 
 #include "Lifetimes.h"
+#include "Skip.h"
 
 using namespace filament;
 using namespace filament::backend;
@@ -24,6 +25,8 @@ using namespace filament::backend;
 namespace test {
 
 TEST_F(BackendTest, FrameScheduledCallback) {
+    SKIP_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::OPENGL));
+
     auto& api = getDriverApi();
     Cleanup cleanup(api);
 
@@ -81,6 +84,8 @@ TEST_F(BackendTest, FrameScheduledCallback) {
 }
 
 TEST_F(BackendTest, FrameCompletedCallback) {
+    SKIP_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::OPENGL));
+
     auto& api = getDriverApi();
     Cleanup cleanup(api);
 

filament/backend/test/test_FeedbackLoops.cpp

@@ -17,7 +17,7 @@
 #include "BackendTest.h"
 
 #include "Lifetimes.h"
-#include "ShaderGenerator.h"
+#include "Shader.h"
 #include "TrianglePrimitive.h"
 
 #include <backend/DriverEnums.h>
@@ -71,8 +71,6 @@ void main() {
     fragColor = textureLod(test_tex, uv, params.sourceLevel);
 })";
 
-static uint32_t sPixelHashResult = 0;
-
 // Selecting a NPOT texture size seems to exacerbate the bug seen with Intel GPU's.
 // Note that Filament uses a higher precision format (R11F_G11F_B10F) but this does not seem
 // necessary to trigger the bug.
@@ -96,35 +94,6 @@ struct MaterialParams {
     float unused;
 };
 
-static void uploadUniforms(DriverApi& dapi, Handle<HwBufferObject> ubh, MaterialParams params) {
-    MaterialParams* tmp = new MaterialParams(params);
-    auto cb = [](void* buffer, size_t size, void* user) {
-        MaterialParams* sp = (MaterialParams*) buffer;
-        delete sp;
-    };
-    BufferDescriptor bd(tmp, sizeof(MaterialParams), cb);
-    dapi.updateBufferObject(ubh, std::move(bd), 0);
-}
-
-static void dumpScreenshot(DriverApi& dapi, Handle<HwRenderTarget> rt) {
-    const size_t size = kTexWidth * kTexHeight * 4;
-    void* buffer = calloc(1, size);
-    auto cb = [](void* buffer, size_t size, void* user) {
-        int w = kTexWidth, h = kTexHeight;
-        const uint32_t* texels = (uint32_t*) buffer;
-        sPixelHashResult = utils::hash::murmur3(texels, size / 4, 0);
-#ifndef FILAMENT_IOS
-        LinearImage image(w, h, 4);
-        image = toLinearWithAlpha<uint8_t>(w, h, w * 4, (uint8_t*) buffer);
-        std::ofstream pngstrm("feedback.png", std::ios::binary | std::ios::trunc);
-        ImageEncoder::encode(pngstrm, ImageEncoder::Format::PNG, image, "", "feedback.png");
-#endif
-        free(buffer);
-    };
-    PixelBufferDescriptor pb(buffer, size, PixelDataFormat::RGBA, PixelDataType::UBYTE, cb);
-    dapi.readPixels(rt, 0, 0, kTexWidth, kTexHeight, std::move(pb));
-}
-
 // TODO: This test needs work to get Metal and OpenGL to agree on results.
 // The problems are caused by both uploading and rendering into the same texture, since the OpenGL
 // backend's readPixels does not work correctly with textures that have image data uploaded.
@@ -140,38 +109,13 @@ TEST_F(BackendTest, FeedbackLoops) {
         api.makeCurrent(swapChain, swapChain);
 
         // Create a program.
-        ProgramHandle program;
-        {
-            filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
+        filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
                 SamplerType::SAMPLER_2D, SamplerFormat::FLOAT, Precision::HIGH, false };
-            filamat::DescriptorSets descriptors;
-            descriptors[1] = {
-                { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
-                        samplerInfo },
-                { "Params", { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::FRAGMENT, 1 }, {} }
-            };
-            ShaderGenerator shaderGen(fullscreenVs, fullscreenFs, sBackend, sIsMobilePlatform,
-                    std::move(descriptors));
-            Program prog = shaderGen.getProgram(api);
-            prog.descriptorBindings(1, {
-                    { "test_tex", DescriptorType::SAMPLER, 0 },
-                    { "Params", DescriptorType::UNIFORM_BUFFER, 1 }
-            });
-            program = cleanup.add(api.createProgram(std::move(prog)));
-        }
-
-        DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
-                {{
-                         DescriptorType::SAMPLER,
-                         ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
-                         DescriptorFlags::NONE, 0
-                 },
-                 {
-                         DescriptorType::UNIFORM_BUFFER,
-                         ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 1,
-                         DescriptorFlags::NONE, 0
-                 }}}));
-
+        Shader shader = Shader(api, cleanup, ShaderConfig {
+            .vertexShader = fullscreenVs,
+            .fragmentShader = fullscreenFs,
+            .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}, {"Params"}}
+        });
 
         TrianglePrimitive const triangle(getDriverApi());
 
@@ -218,8 +162,8 @@ TEST_F(BackendTest, FeedbackLoops) {
             state.rasterState.colorWrite = true;
             state.rasterState.depthWrite = false;
             state.rasterState.depthFunc = RasterState::DepthFunc::A;
-            state.program = program;
-            state.pipelineLayout.setLayout[1] = { descriptorSetLayout };
+            state.program = shader.getProgram();
+            state.pipelineLayout.setLayout[1] = { shader.getDescriptorSetLayout() };
 
             api.makeCurrent(swapChain, swapChain);
             api.beginFrame(0, 0, 0);
@@ -233,20 +177,24 @@ TEST_F(BackendTest, FeedbackLoops) {
                 params.viewport.width = kTexWidth >> targetLevel;
                 params.viewport.height = kTexHeight >> targetLevel;
 
+                auto descriptorSet = shader.createDescriptorSet(api);
                 auto textureView = passCleanup.add(api.createTextureView(texture, sourceLevel, 1));
-                DescriptorSetHandle descriptorSet = passCleanup.add(api.createDescriptorSet(descriptorSetLayout));
                 api.updateDescriptorSetTexture(descriptorSet, 0, textureView, {
                         .filterMag = SamplerMagFilter::LINEAR,
                         .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
                 });
-                api.updateDescriptorSetBuffer(descriptorSet, 1, ubuffer, 0, sizeof(MaterialParams));
-                api.bindDescriptorSet(descriptorSet, 1, {});
 
-                uploadUniforms(getDriverApi(), ubuffer, {
+                UniformBindingConfig uniformBinding{
+                    .binding = 1,
+                    .descriptorSet = descriptorSet
+                };
+                shader.bindUniform<MaterialParams>(api, ubuffer, uniformBinding);
+                shader.uploadUniform(api, ubuffer, uniformBinding, MaterialParams{
                     .fbWidth = float(params.viewport.width),
                     .fbHeight = float(params.viewport.height),
                     .sourceLevel = float(sourceLevel),
                 });
+
                 api.beginRenderPass(renderTargets[targetLevel], params);
                 api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
                 api.endRenderPass();
@@ -262,20 +210,24 @@ TEST_F(BackendTest, FeedbackLoops) {
                 params.viewport.width = kTexWidth >> targetLevel;
                 params.viewport.height = kTexHeight >> targetLevel;
 
+                auto descriptorSet = shader.createDescriptorSet(api);
                 auto textureView = passCleanup.add(api.createTextureView(texture, sourceLevel, 1));
-                DescriptorSetHandle descriptorSet = passCleanup.add(api.createDescriptorSet(descriptorSetLayout));
                 api.updateDescriptorSetTexture(descriptorSet, 0, textureView, {
                         .filterMag = SamplerMagFilter::LINEAR,
                         .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
                 });
-                api.updateDescriptorSetBuffer(descriptorSet, 1, ubuffer, 0, sizeof(MaterialParams));
-                api.bindDescriptorSet(descriptorSet, 1, {});
 
-                uploadUniforms(getDriverApi(), ubuffer, {
-                    .fbWidth = float(params.viewport.width),
-                    .fbHeight = float(params.viewport.height),
-                    .sourceLevel = float(sourceLevel),
+                UniformBindingConfig uniformBinding{
+                        .binding = 1,
+                        .descriptorSet = descriptorSet
+                };
+                shader.bindUniform<MaterialParams>(api, ubuffer, uniformBinding);
+                shader.uploadUniform(api, ubuffer, uniformBinding, MaterialParams{
+                        .fbWidth = float(params.viewport.width),
+                        .fbHeight = float(params.viewport.height),
+                        .sourceLevel = float(sourceLevel),
                 });
+
                 api.beginRenderPass(renderTargets[targetLevel], params);
                 api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
                 api.endRenderPass();
@@ -286,7 +238,8 @@ TEST_F(BackendTest, FeedbackLoops) {
             // NOTE: Calling glReadPixels on any miplevel other than the base level
             // seems to be un-reliable on some GPU's.
             if (frame == kNumFrames - 1) {
-                dumpScreenshot(api, renderTargets[0]);
+                EXPECT_IMAGE(renderTargets[0], getExpectations(),
+                        ScreenshotParams(kTexWidth, kTexHeight, "FeedbackLoops", 0x70695aa1));
             }
 
             api.flush();
@@ -297,10 +250,6 @@ TEST_F(BackendTest, FeedbackLoops) {
             getDriver().purge();
         }
     }
-
-    const uint32_t expected = 0x70695aa1;
-    printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", sPixelHashResult, expected);
-    EXPECT_TRUE(sPixelHashResult == expected);
 }
 
 } // namespace test

filament/backend/test/test_LoadImage.cpp

@@ -18,16 +18,14 @@
 
 #include "BackendTestUtils.h"
 #include "Lifetimes.h"
-#include "ShaderGenerator.h"
-#include "TrianglePrimitive.h"
+#include "Shader.h"
+#include "SharedShaders.h"
 
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>
 
 #include "private/filament/SamplerInterfaceBlock.h"
 
-#include <math/half.h>
-
 #include <vector>
 
 #include <stddef.h>
@@ -42,19 +40,6 @@ namespace {
 // Shaders
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-std::string vertex (R"(#version 450 core
-
-layout(location = 0) in vec4 mesh_position;
-
-void main() {
-    gl_Position = vec4(mesh_position.xy, 0.0, 1.0);
-#if defined(TARGET_VULKAN_ENVIRONMENT)
-    // In Vulkan, clip space is Y-down. In OpenGL and Metal, clip space is Y-up.
-    gl_Position.y *= -1.0f;
-#endif
-}
-)");
-
 std::string fragmentTemplate (R"(#version 450 core
 
 layout(location = 0) out vec4 fragColor;
@@ -119,6 +104,15 @@ namespace test {
 
 template<typename componentType> inline componentType getMaxValue();
 
+class LoadImageTest : public BackendTest {
+public:
+    LoadImageTest() {
+        mVertexShader = SharedShaders::getVertexShaderText(VertexShaderType::Noop,
+                ShaderUniformType::None);
+    }
+
+    std::string mVertexShader;
+};
 
 
 inline std::string stringReplace(const std::string& find, const std::string& replace,
@@ -216,7 +210,7 @@ static SamplerFormat getSamplerFormat(TextureFormat textureFormat) {
     }
 }
 
-TEST_F(BackendTest, UpdateImage2D) {
+TEST_F(LoadImageTest, UpdateImage2D) {
 
     // All of these test cases should result in the same rendered image, and thus the same hash.
     static const uint32_t expectedHash = 3644679986;
@@ -252,42 +246,42 @@ TEST_F(BackendTest, UpdateImage2D) {
     std::vector<TestCase> testCases;
 
     // Test basic upload.
-    testCases.emplace_back("RGBA, UBYTE -> RGBA8", PixelDataFormat::RGBA, PixelDataType::UBYTE, TextureFormat::RGBA8);
+    testCases.emplace_back("RGBA UBYTE to RGBA8", PixelDataFormat::RGBA, PixelDataType::UBYTE, TextureFormat::RGBA8);
 
     // Test format conversion.
     // TODO: Vulkan crashes with `Texture at colorAttachment[0] has usage (0x01) which doesn't specify MTLTextureUsageRenderTarget (0x04)'
-    testCases.emplace_back("RGBA, FLOAT -> RGBA16F", PixelDataFormat::RGBA, PixelDataType::FLOAT, TextureFormat::RGBA16F);
+    testCases.emplace_back("RGBA FLOAT to RGBA16F", PixelDataFormat::RGBA, PixelDataType::FLOAT, TextureFormat::RGBA16F);
 
     // Test texture formats not all backends support natively.
     // TODO: Vulkan crashes with "VK_FORMAT_R32G32B32_SFLOAT is not supported"
-    testCases.emplace_back("RGB, FLOAT -> RGB32F", PixelDataFormat::RGB, PixelDataType::FLOAT, TextureFormat::RGB32F);
-    testCases.emplace_back("RGB, FLOAT -> RGB16F", PixelDataFormat::RGB, PixelDataType::FLOAT, TextureFormat::RGB16F);
+    testCases.emplace_back("RGB FLOAT to RGB32F", PixelDataFormat::RGB, PixelDataType::FLOAT, TextureFormat::RGB32F);
+    testCases.emplace_back("RGB FLOAT to RGB16F", PixelDataFormat::RGB, PixelDataType::FLOAT, TextureFormat::RGB16F);
 
     // Test packed format uploads.
     // TODO: Vulkan crashes with "Texture at colorAttachment[0] has usage (0x01) which doesn't specify MTLTextureUsageRenderTarget (0x04)"
-    testCases.emplace_back("RGBA, UINT_2_10_10_10_REV -> RGB10_A2", PixelDataFormat::RGBA, PixelDataType::UINT_2_10_10_10_REV, TextureFormat::RGB10_A2);
-    testCases.emplace_back("RGB, UINT_10F_11F_11F_REV -> R11F_G11F_B10F", PixelDataFormat::RGB, PixelDataType::UINT_10F_11F_11F_REV, TextureFormat::R11F_G11F_B10F);
-    testCases.emplace_back("RGB, HALF -> R11F_G11F_B10F", PixelDataFormat::RGB, PixelDataType::HALF, TextureFormat::R11F_G11F_B10F);
+    testCases.emplace_back("RGBA UINT_2_10_10_10_REV to RGB10_A2", PixelDataFormat::RGBA, PixelDataType::UINT_2_10_10_10_REV, TextureFormat::RGB10_A2);
+    testCases.emplace_back("RGB UINT_10F_11F_11F_REV to R11F_G11F_B10F", PixelDataFormat::RGB, PixelDataType::UINT_10F_11F_11F_REV, TextureFormat::R11F_G11F_B10F);
+    testCases.emplace_back("RGB HALF to R11F_G11F_B10F", PixelDataFormat::RGB, PixelDataType::HALF, TextureFormat::R11F_G11F_B10F);
 
     // Test integer format uploads.
     // TODO: These cases fail on OpenGL and Vulkan.
     // TODO: These cases now also fail on Metal, but at some point previously worked.
-     testCases.emplace_back("RGB_INTEGER, UBYTE -> RGB8UI", PixelDataFormat::RGB_INTEGER, PixelDataType::UBYTE, TextureFormat::RGB8UI);
-     testCases.emplace_back("RGB_INTEGER, USHORT -> RGB16UI", PixelDataFormat::RGB_INTEGER, PixelDataType::USHORT, TextureFormat::RGB16UI);
-     testCases.emplace_back("RGB_INTEGER, INT -> RGB32I", PixelDataFormat::RGB_INTEGER, PixelDataType::INT, TextureFormat::RGB32I);
+     testCases.emplace_back("RGB_INTEGER UBYTE to RGB8UI", PixelDataFormat::RGB_INTEGER, PixelDataType::UBYTE, TextureFormat::RGB8UI);
+     testCases.emplace_back("RGB_INTEGER USHORT to RGB16UI", PixelDataFormat::RGB_INTEGER, PixelDataType::USHORT, TextureFormat::RGB16UI);
+     testCases.emplace_back("RGB_INTEGER INT to RGB32I", PixelDataFormat::RGB_INTEGER, PixelDataType::INT, TextureFormat::RGB32I);
 
     // Test uploads with buffer padding.
     // TODO: Vulkan crashes with "Assertion failed: (offset + size <= allocationSize)"
-    testCases.emplace_back("RGBA, UBYTE -> RGBA8 (with buffer padding)", PixelDataFormat::RGBA, PixelDataType::UBYTE, TextureFormat::RGBA8, 64u);
-    testCases.emplace_back("RGBA, FLOAT -> RGBA16F (with buffer padding)", PixelDataFormat::RGBA, PixelDataType::FLOAT, TextureFormat::RGBA16F, 64u);
-    testCases.emplace_back("RGB, FLOAT -> RGB32F (with buffer padding)", PixelDataFormat::RGB, PixelDataType::FLOAT, TextureFormat::RGB32F, 64u);
+    testCases.emplace_back("RGBA UBYTE to RGBA8 (with buffer padding)", PixelDataFormat::RGBA, PixelDataType::UBYTE, TextureFormat::RGBA8, 64u);
+    testCases.emplace_back("RGBA FLOAT to RGBA16F (with buffer padding)", PixelDataFormat::RGBA, PixelDataType::FLOAT, TextureFormat::RGBA16F, 64u);
+    testCases.emplace_back("RGB FLOAT to RGB32F (with buffer padding)", PixelDataFormat::RGB, PixelDataType::FLOAT, TextureFormat::RGB32F, 64u);
 
     // Upload subregions separately.
     // TODO: Vulkan crashes with "Offsets not yet supported"
-    testCases.emplace_back("RGBA, UBYTE -> RGBA8 (subregions)", PixelDataFormat::RGBA, PixelDataType::UBYTE, TextureFormat::RGBA8, 0u, true);
-    testCases.emplace_back("RGBA, FLOAT -> RGBA16F (subregions)", PixelDataFormat::RGBA, PixelDataType::FLOAT, TextureFormat::RGBA16F, 0u, true);
-    testCases.emplace_back("RGBA, UBYTE -> RGBA8 (subregions, buffer padding)", PixelDataFormat::RGBA, PixelDataType::UBYTE, TextureFormat::RGBA8, 64u, true);
-    testCases.emplace_back("RGB, FLOAT -> RGB32F (subregions, buffer padding)", PixelDataFormat::RGB, PixelDataType::FLOAT, TextureFormat::RGB32F, 64u, true);
+    testCases.emplace_back("RGBA UBYTE to RGBA8 (subregions)", PixelDataFormat::RGBA, PixelDataType::UBYTE, TextureFormat::RGBA8, 0u, true);
+    testCases.emplace_back("RGBA FLOAT to RGBA16F (subregions)", PixelDataFormat::RGBA, PixelDataType::FLOAT, TextureFormat::RGBA16F, 0u, true);
+    testCases.emplace_back("RGBA UBYTE to RGBA8 (subregions and buffer padding)", PixelDataFormat::RGBA, PixelDataType::UBYTE, TextureFormat::RGBA8, 64u, true);
+    testCases.emplace_back("RGB FLOAT to RGB32F (subregions and buffer padding)", PixelDataFormat::RGB, PixelDataType::FLOAT, TextureFormat::RGB32F, 64u, true);
 
     auto& api = getDriverApi();
 
@@ -306,28 +300,14 @@ TEST_F(BackendTest, UpdateImage2D) {
         // Create a program.
         filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
             SamplerType::SAMPLER_2D, getSamplerFormat(t.textureFormat), Precision::HIGH, false };
-        filamat::DescriptorSets descriptors;
-        descriptors[1] = { { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
-                samplerInfo } };
 
         std::string const fragment = stringReplace("{samplerType}",
                 getSamplerTypeName(t.textureFormat), fragmentTemplate);
-        ShaderGenerator shaderGen(
-                vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
-
-        Program prog = shaderGen.getProgram(api);
-        prog.descriptorBindings(1, {{"test_tex", DescriptorType::SAMPLER, 0}});
-
-        ProgramHandle const program = cleanup.add(api.createProgram(std::move(prog)));
-
-        DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
-                {{
-                         DescriptorType::SAMPLER,
-                         ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
-                         DescriptorFlags::NONE, 0
-                 }}}));
-
-        DescriptorSetHandle descriptorSet = cleanup.add(api.createDescriptorSet(descriptorSetLayout));
+        Shader shader(api, cleanup, ShaderConfig{
+           .vertexShader = mVertexShader,
+           .fragmentShader= fragment,
+           .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}}
+        });
 
         // Create a Texture.
         auto usage = TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE;
@@ -349,29 +329,29 @@ TEST_F(BackendTest, UpdateImage2D) {
                     checkerboardPixelBuffer(t.pixelFormat, t.pixelType, 512, t.bufferPadding));
         }
 
+        DescriptorSetHandle  descriptorSet = shader.createDescriptorSet(api);
         api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
                 .filterMag = SamplerMagFilter::NEAREST,
                 .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
 
         api.bindDescriptorSet(descriptorSet, 1, {});
 
-        renderTriangle({{ DescriptorSetLayoutHandle{}, descriptorSetLayout }},
-                defaultRenderTarget, swapChain, program);
+        renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
+                defaultRenderTarget, swapChain, shader.getProgram());
 
-        readPixelsAndAssertHash(t.name, 512, 512, defaultRenderTarget, expectedHash);
+        EXPECT_IMAGE(defaultRenderTarget, getExpectations(),
+                ScreenshotParams(512, 512, t.name, expectedHash));
 
         api.commit(swapChain);
         api.endFrame(0);
     }
 
-    api.finish();
     api.stopCapture();
-
-    flushAndWait();
 }
 
-TEST_F(BackendTest, UpdateImageSRGB) {
+TEST_F(LoadImageTest, UpdateImageSRGB) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
     api.startCapture();
 
     PixelDataFormat const pixelFormat = PixelDataFormat::RGBA;
@@ -379,36 +359,23 @@ TEST_F(BackendTest, UpdateImageSRGB) {
     TextureFormat const textureFormat = TextureFormat::SRGB8_A8;
 
     // Create a platform-specific SwapChain and make it current.
-    auto swapChain = createSwapChain();
+    auto swapChain = cleanup.add(createSwapChain());
     api.makeCurrent(swapChain, swapChain);
-    auto defaultRenderTarget = api.createDefaultRenderTarget(0);
+    auto defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
 
     // Create a program.
     filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
         SamplerType::SAMPLER_2D, getSamplerFormat(textureFormat), Precision::HIGH, false };
-    filamat::DescriptorSets descriptors;
-    descriptors[1] = { { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
-            samplerInfo } };
-
     std::string const fragment = stringReplace("{samplerType}",
             getSamplerTypeName(textureFormat), fragmentTemplate);
-    ShaderGenerator shaderGen(
-            vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
-    Program prog = shaderGen.getProgram(api);
-    prog.descriptorBindings(1, {{"test_tex", DescriptorType::SAMPLER, 0}});
-    ProgramHandle const program = api.createProgram(std::move(prog));
-    DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
-            {{
-                     DescriptorType::SAMPLER,
-                     ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
-                     DescriptorFlags::NONE, 0
-             }}});
-
-    DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);
+    Shader shader(api, cleanup, ShaderConfig{
+        .vertexShader = mVertexShader, .fragmentShader = fragment, .uniforms = {{
+            "test_tex", DescriptorType::SAMPLER, samplerInfo
+    }}});
 
     // Create a texture.
-    Handle<HwTexture> const texture = api.createTexture(SamplerType::SAMPLER_2D, 1,
-            textureFormat, 1, 512, 512, 1, TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE);
+    Handle<HwTexture> const texture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
+            textureFormat, 1, 512, 512, 1, TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE));
 
     // Create image data.
     size_t components; int bpp;
@@ -436,6 +403,7 @@ TEST_F(BackendTest, UpdateImageSRGB) {
     api.beginFrame(0, 0, 0);
 
     // Update samplers.
+    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
     api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
             .filterMag = SamplerMagFilter::LINEAR,
             .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
@@ -443,31 +411,21 @@ TEST_F(BackendTest, UpdateImageSRGB) {
 
     api.bindDescriptorSet(descriptorSet, 1, {});
 
-    renderTriangle({{ DescriptorSetLayoutHandle{}, descriptorSetLayout }},
-            defaultRenderTarget, swapChain, program);
+    renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
+            defaultRenderTarget, swapChain, shader.getProgram());
 
-    static const uint32_t expectedHash = 359858623;
-    readPixelsAndAssertHash("UpdateImageSRGB", 512, 512, defaultRenderTarget, expectedHash);
+    EXPECT_IMAGE(defaultRenderTarget, getExpectations(),
+            ScreenshotParams(512, 512, "UpdateImageSRGB", 359858623));
 
-    api.flush();
     api.commit(swapChain);
     api.endFrame(0);
 
-    api.destroyDescriptorSet(descriptorSet);
-    api.destroyDescriptorSetLayout(descriptorSetLayout);
-    api.destroyProgram(program);
-    api.destroySwapChain(swapChain);
-    api.destroyRenderTarget(defaultRenderTarget);
-
-    // This ensures all driver commands have finished before exiting the test.
-    api.finish();
     api.stopCapture();
-
-    flushAndWait();
 }
 
-TEST_F(BackendTest, UpdateImageMipLevel) {
+TEST_F(LoadImageTest, UpdateImageMipLevel) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
     api.startCapture();
 
     PixelDataFormat pixelFormat = PixelDataFormat::RGBA;
@@ -475,38 +433,27 @@ TEST_F(BackendTest, UpdateImageMipLevel) {
     TextureFormat textureFormat = TextureFormat::RGBA32F;
 
     // Create a platform-specific SwapChain and make it current.
-    auto swapChain = createSwapChain();
+    auto swapChain = cleanup.add(createSwapChain());
     api.makeCurrent(swapChain, swapChain);
-    auto defaultRenderTarget = api.createDefaultRenderTarget(0);
+    auto defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
 
     // Create a program.
     filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
         SamplerType::SAMPLER_2D, getSamplerFormat(textureFormat), Precision::HIGH, false };
-    filamat::DescriptorSets descriptors;
-    descriptors[1] = { { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
-            samplerInfo } };
     std::string const fragment = stringReplace("{samplerType}",
             getSamplerTypeName(textureFormat), fragmentUpdateImageMip);
-    ShaderGenerator shaderGen(
-            vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
-    Program prog = shaderGen.getProgram(api);
-    prog.descriptorBindings(1, {{"test_tex", DescriptorType::SAMPLER, 0}});
-    ProgramHandle const program = api.createProgram(std::move(prog));
-    DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
-            {{
-                     DescriptorType::SAMPLER,
-                     ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
-                     DescriptorFlags::NONE, 0
-             }}});
-
-    DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);
+    Shader shader(api, cleanup, ShaderConfig {
+        .vertexShader = mVertexShader,
+        .fragmentShader = fragment,
+        .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}}
+    });
 
     // Create a texture with 3 mip levels.
     // Base level: 1024
     // Level 1:     512     <-- upload data and sample from this level
     // Level 2:     256
-    Handle<HwTexture> texture = api.createTexture(SamplerType::SAMPLER_2D, 3,
-            textureFormat, 1, 1024, 1024, 1, TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE);
+    Handle<HwTexture> texture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 3,
+            textureFormat, 1, 1024, 1024, 1, TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE));
 
     // Create image data.
     PixelBufferDescriptor descriptor = checkerboardPixelBuffer(pixelFormat, pixelType, 512);
@@ -515,6 +462,7 @@ TEST_F(BackendTest, UpdateImageMipLevel) {
     api.beginFrame(0, 0, 0);
 
     // Update samplers.
+    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
     api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
             .filterMag = SamplerMagFilter::LINEAR,
             .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
@@ -522,31 +470,21 @@ TEST_F(BackendTest, UpdateImageMipLevel) {
 
     api.bindDescriptorSet(descriptorSet, 1, {});
 
-    renderTriangle({{ DescriptorSetLayoutHandle{}, descriptorSetLayout }},
-            defaultRenderTarget, swapChain, program);
+    renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
+            defaultRenderTarget, swapChain, shader.getProgram());
 
-    static const uint32_t expectedHash = 3644679986;
-    readPixelsAndAssertHash("UpdateImageMipLevel", 512, 512, defaultRenderTarget, expectedHash);
+    EXPECT_IMAGE(defaultRenderTarget, getExpectations(),
+            ScreenshotParams(512, 512, "UpdateImageMipLevel", 3644679986));
 
-    api.flush();
     api.commit(swapChain);
     api.endFrame(0);
 
-    api.destroyDescriptorSet(descriptorSet);
-    api.destroyDescriptorSetLayout(descriptorSetLayout);
-    api.destroyProgram(program);
-    api.destroySwapChain(swapChain);
-    api.destroyRenderTarget(defaultRenderTarget);
-
-    // This ensures all driver commands have finished before exiting the test.
-    api.finish();
     api.stopCapture();
-
-    flushAndWait();
 }
 
-TEST_F(BackendTest, UpdateImage3D) {
+TEST_F(LoadImageTest, UpdateImage3D) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
     api.startCapture();
 
     PixelDataFormat pixelFormat = PixelDataFormat::RGBA;
@@ -556,35 +494,24 @@ TEST_F(BackendTest, UpdateImage3D) {
     TextureUsage usage = TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE;
 
     // Create a platform-specific SwapChain and make it current.
-    auto swapChain = createSwapChain();
+    auto swapChain = cleanup.add(createSwapChain());
     api.makeCurrent(swapChain, swapChain);
-    auto defaultRenderTarget = api.createDefaultRenderTarget(0);
+    auto defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
 
     // Create a program.
     filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
         SamplerType::SAMPLER_2D_ARRAY, getSamplerFormat(textureFormat), Precision::HIGH, false };
-    filamat::DescriptorSets descriptors;
-    descriptors[1] = { { "test_tex", { DescriptorType::SAMPLER, ShaderStageFlags::FRAGMENT, 0 },
-            samplerInfo } };
     std::string fragment = stringReplace("{samplerType}",
             getSamplerTypeName(samplerType), fragmentUpdateImage3DTemplate);
-    ShaderGenerator shaderGen(
-            vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
-    Program prog = shaderGen.getProgram(api);
-    prog.descriptorBindings(1, {{ "test_tex", DescriptorType::SAMPLER, 0 }});
-    ProgramHandle const program = api.createProgram(std::move(prog));
-    DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
-            {{
-                     DescriptorType::SAMPLER,
-                     ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
-                     DescriptorFlags::NONE, 0
-             }}});
-
-    DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);
+    Shader shader(api, cleanup, ShaderConfig {
+        .vertexShader = mVertexShader,
+        .fragmentShader = fragment,
+        .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}}
+    });
 
     // Create a texture.
-    Handle<HwTexture> texture = api.createTexture(samplerType, 1,
-            textureFormat, 1, 512, 512, 4, usage);
+    Handle<HwTexture> texture = cleanup.add(api.createTexture(samplerType, 1,
+            textureFormat, 1, 512, 512, 4, usage));
 
     // Create image data for all 4 layers.
     size_t components; int bpp;
@@ -603,37 +530,25 @@ TEST_F(BackendTest, UpdateImage3D) {
 
     api.update3DImage(texture, 0, 0, 0, 0, 512, 512, 4, std::move(descriptor));
 
-    api.beginFrame(0, 0, 0);
+    {
+        RenderFrame frame(api);
 
-    // Update samplers.
-    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
-            .filterMag = SamplerMagFilter::LINEAR,
-            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
-    });
+        // Update samplers.
+        DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
+        api.updateDescriptorSetTexture(descriptorSet, 0, texture,
+                { .filterMag = SamplerMagFilter::LINEAR,
+                    .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST });
 
-    api.bindDescriptorSet(descriptorSet, 1, {});
+        api.bindDescriptorSet(descriptorSet, 1, {});
 
-    renderTriangle({{ DescriptorSetLayoutHandle{}, descriptorSetLayout }},
-            defaultRenderTarget, swapChain, program);
+        renderTriangle({ { DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() } },
+                defaultRenderTarget, swapChain, shader.getProgram());
 
-    static const uint32_t expectedHash = 3644679986;
-    readPixelsAndAssertHash("UpdateImage3D", 512, 512, defaultRenderTarget, expectedHash);
+        EXPECT_IMAGE(defaultRenderTarget, getExpectations(),
+                ScreenshotParams(512, 512, "UpdateImage3D", 3644679986));
+    }
 
-    api.flush();
-    api.commit(swapChain);
-    api.endFrame(0);
-
-    api.destroyDescriptorSet(descriptorSet);
-    api.destroyDescriptorSetLayout(descriptorSetLayout);
-    api.destroyProgram(program);
-    api.destroySwapChain(swapChain);
-    api.destroyRenderTarget(defaultRenderTarget);
-
-    // This ensures all driver commands have finished before exiting the test.
-    api.finish();
     api.stopCapture();
-
-    flushAndWait();
 }
 
 } // namespace test