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

Co-authored-by: Bill Napier <napier@google.com>
Co-authored-by: Powei Feng <powei@google.com>

.github/workflows/android-continuous.yml

@@ -12,7 +12,7 @@ jobs:
     name: build-android
     # We intentially use a larger runner here to enable larger disk space
     # (standard linux runner will fail on disk space and faster build time).
-    runs-on: ubuntu-22.04-32core
+    runs-on: 'ubuntu-24.04-32core'
 
     steps:
       - uses: actions/checkout@v4.1.6

.github/workflows/linux-continuous.yml

@@ -10,7 +10,7 @@ on:
 jobs:
   build-linux:
     name: build-linux
-    runs-on: ubuntu-22.04-16core
+    runs-on: 'ubuntu-24.04-16core'
 
     steps:
       - uses: actions/checkout@v4.1.6

.github/workflows/presubmit.yml

@@ -40,7 +40,7 @@ jobs:
 
   build-android:
     name: build-android
-    runs-on: ubuntu-22.04-16core
+    runs-on: 'ubuntu-24.04-16core'
 
     steps:
       - uses: actions/checkout@v4.1.6
@@ -69,7 +69,7 @@ jobs:
 
   build-web:
     name: build-web
-    runs-on: ubuntu-22.04-16core
+    runs-on: 'ubuntu-24.04-16core'
 
     steps:
       - uses: actions/checkout@v4.1.6
@@ -79,7 +79,7 @@ jobs:
 
   validate-docs:
     name: validate-docs
-    runs-on: ubuntu-22.04-4core
+    runs-on: 'ubuntu-24.04-4core'
     steps:
       - uses: actions/checkout@v4.1.6
         with:
@@ -114,7 +114,7 @@ jobs:
 
   validate-wgsl-webgpu:
     name: validate-wgsl-webgpu
-    runs-on: ubuntu-22.04-8core
+    runs-on: 'ubuntu-24.04-8core'
 
     steps:
       - uses: actions/checkout@v4.1.6

.github/workflows/release.yml

@@ -70,7 +70,7 @@ jobs:
 
   build-web:
     name: build-web
-    runs-on: ubuntu-22.04-16core
+    runs-on: 'ubuntu-24.04-16core'
     if: github.event_name == 'release' || github.event.inputs.platform == 'web'
 
     steps:
@@ -103,7 +103,7 @@ jobs:
 
   build-android:
     name: build-android
-    runs-on: ubuntu-22.04-16core
+    runs-on: 'ubuntu-24.04-16core'
     if: github.event_name == 'release' || github.event.inputs.platform == 'android'
 
     steps:

.github/workflows/web-continuous.yml

@@ -10,7 +10,7 @@ on:
 jobs:
   build-web:
     name: build-web
-    runs-on: ubuntu-22.04-16core
+    runs-on: 'ubuntu-24.04-16core'
 
     steps:
       - uses: actions/checkout@v4.1.6

NEW_RELEASE_NOTES.md

@@ -7,6 +7,3 @@ for next branch cut* header.
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).
 
 ## Release notes for next branch cut
-
-- materials: five custom variables (varyings) are now available on the condition that the `color` attribute is not requested (b/404930099). [⚠️ **New Material Version**]
-

README.md

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

RELEASE_NOTES.md

@@ -7,6 +7,10 @@ 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.0
+
+- materials: five custom variables (varyings) are now available on the condition that the `color` attribute is not requested (b/404930099). [⚠️ **New Material Version**]
+
 ## v1.58.2
 
 - engine: Generate 1D instead of 3D LUTs for color grading whenever possible.

android/gradle.properties

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

filament/backend/CMakeLists.txt

@@ -494,7 +494,9 @@ if (APPLE OR LINUX)
         test/ShaderGenerator.cpp
         test/TrianglePrimitive.cpp
         test/Arguments.cpp
+        test/ImageExpectations.cpp
         test/Lifetimes.cpp
+        test/Shader.cpp
         test/test_FeedbackLoops.cpp
         test/test_Blit.cpp
         test/test_MissingRequiredAttributes.cpp
@@ -510,6 +512,7 @@ if (APPLE OR LINUX)
         test/test_Handles.cpp
     )
     set(BACKEND_TEST_LIBS
+        absl::str_format
         backend
         getopt
         gtest
@@ -525,7 +528,7 @@ if (APPLE AND NOT IOS)
     list(APPEND BACKEND_TEST_SRC
          test/test_RenderExternalImage.cpp)
     add_library(backend_test STATIC ${BACKEND_TEST_SRC})
-    target_link_libraries(backend_test PRIVATE ${BACKEND_TEST_LIBS})
+    target_link_libraries(backend_test PUBLIC ${BACKEND_TEST_LIBS})
 
     set(BACKEND_TEST_DEPS
             OSDependent

filament/backend/src/metal/MetalDriver.mm

@@ -1177,9 +1177,17 @@ size_t MetalDriver::getMaxUniformBufferSize() {
     return 256 * 1024 * 1024;   // TODO: return the actual size instead of hardcoding the minspec
 }
 
-size_t MetalDriver::getMaxTextureSize(SamplerType) {
-    // TODO: return the actual size instead of hardcoding the minspec
-    return 2048;
+size_t MetalDriver::getMaxTextureSize(SamplerType type) {
+    if (type == SamplerType::SAMPLER_3D) {
+        return 2048;
+    }
+    if (mContext->highestSupportedGpuFamily.apple >= 3 ||
+            mContext->highestSupportedGpuFamily.mac >= 2) {
+        return 16384;
+    } else if (mContext->highestSupportedGpuFamily.apple >= 2) {
+        return 8192;
+    }
+    return 4096;
 }
 
 size_t MetalDriver::getMaxArrayTextureLayers() {

filament/backend/src/noop/NoopDriver.cpp

@@ -241,7 +241,9 @@ size_t NoopDriver::getMaxUniformBufferSize() {
 }
 
 size_t NoopDriver::getMaxTextureSize(SamplerType target) {
-    return 4096u;
+    // NoopDriver is being actively used for other purposes.  This needs to be resolved before we
+    // can change it to 2048. b/406832484
+    return 16384u;
 }
 
 size_t NoopDriver::getMaxArrayTextureLayers() {

filament/backend/src/opengl/OpenGLContext.cpp

@@ -566,7 +566,11 @@ void OpenGLContext::initBugs(Bugs* bugs, Extensions const& exts,
         } else if (strstr(renderer, "AMD") ||
                    strstr(renderer, "ATI")) {
             // AMD/ATI GPU
-        } else if (strstr(vendor, "Mesa")) {
+        } else if (strstr(renderer, "Mozilla")) {
+            bugs->disable_invalidate_framebuffer = true;
+        }
+
+        if (strstr(vendor, "Mesa")) {
             // Seen on
             //  [Mesa],
             //  [llvmpipe (LLVM 17.0.6, 256 bits)],
@@ -574,8 +578,6 @@ void OpenGLContext::initBugs(Bugs* bugs, Extensions const& exts,
             //  [4.50]
             // not known which version are affected
             bugs->rebind_buffer_after_deletion = true;
-        } else if (strstr(renderer, "Mozilla")) {
-            bugs->disable_invalidate_framebuffer = true;
         }
     } else {
         // When running under ANGLE, it's a different set of workaround that we need.
@@ -587,6 +589,19 @@ void OpenGLContext::initBugs(Bugs* bugs, Extensions const& exts,
         }
     }
 
+    if (strstr(vendor, "Mozilla")) {
+        // Seen on
+        //  [Mozilla],
+        //  [GeForce GTX 980, or similar]
+        //    or [ANGLE (NVIDIA, NVIDIA GeForce GTX 980 Direct3D11 vs_5_0 ps_5_0), or similar]
+        //    or anything else,
+        //  [OpenGL ES 3.0 (WebGL 2.0)],
+        //  [OpenGL ES GLSL ES 3.00 (WebGL GLSL ES 3.00)]
+        // For Mozilla, the issue appears to be observed regardless of whether the renderer is
+        // ANGLE or not. (b/376125497)
+        bugs->rebind_buffer_after_deletion = true;
+    }
+
 #ifdef BACKEND_OPENGL_VERSION_GLES
 #   ifndef FILAMENT_IOS // FILAMENT_IOS is guaranteed to have ES3.x
     if (UTILS_UNLIKELY(major == 2)) {

filament/backend/src/opengl/OpenGLContext.h

@@ -320,8 +320,8 @@ public:
         // a glFinish. So we must delay the destruction until we know the GPU is finished.
         bool delay_fbo_destruction;
 
-        // Mesa sometimes clears the generic buffer binding when *another* buffer is destroyed,
-        // if that other buffer is bound on an *indexed* buffer binding.
+        // Mesa and Mozilla(web) sometimes clear the generic buffer binding when *another* buffer
+        // is destroyed, if that other buffer is bound on an *indexed* buffer binding.
         bool rebind_buffer_after_deletion;
 
         // Force feature level 0. Typically used for low end ES3 devices with significant driver

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -1134,24 +1134,28 @@ math::float2 VulkanDriver::getClipSpaceParams() {
 }
 
 uint8_t VulkanDriver::getMaxDrawBuffers() {
-    return MRT::MIN_SUPPORTED_RENDER_TARGET_COUNT; // TODO: query real value
+    return mContext.getPhysicalDeviceLimits().maxColorAttachments;
 }
 
 size_t VulkanDriver::getMaxUniformBufferSize() {
-    // TODO: return the actual size instead of hardcoded value
-    // TODO: devices that return less than 32768 should be rejected. This represents only 3%
-    //       of android devices.
-    return 32768;
+    return mContext.getPhysicalDeviceLimits().maxUniformBufferRange;
 }
 
-size_t VulkanDriver::getMaxTextureSize(SamplerType) {
-    // TODO: return the actual size instead of hardcoded value
-    return 4096;
+size_t VulkanDriver::getMaxTextureSize(SamplerType type) {
+    switch (type) {
+        case SamplerType::SAMPLER_2D:
+            return mContext.getPhysicalDeviceLimits().maxImageDimension2D;
+        case SamplerType::SAMPLER_3D:
+            return mContext.getPhysicalDeviceLimits().maxImageDimension3D;
+        case SamplerType::SAMPLER_CUBEMAP:
+            return mContext.getPhysicalDeviceLimits().maxImageDimensionCube;
+        default:
+            return mContext.getPhysicalDeviceLimits().maxImageDimension1D;
+    }
 }
 
 size_t VulkanDriver::getMaxArrayTextureLayers() {
-    // TODO: return the actual size instead of hardcoded value
-    return 256;
+    return mContext.getPhysicalDeviceLimits().maxImageArrayLayers;
 }
 
 void VulkanDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh, uint32_t index,

filament/backend/test/ImageExpectations.cpp

@@ -0,0 +1,172 @@
+/*
+ * 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 "ImageExpectations.h"
+
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+#include "absl/strings/str_format.h"
+#include "utils/Hash.h"
+#include <fstream>
+
+#include "backend/PixelBufferDescriptor.h"
+#include "private/backend/DriverApi.h"
+
+#ifndef FILAMENT_IOS
+
+#include <imageio/ImageEncoder.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) {}
+
+int ScreenshotParams::width() const {
+    return mWidth;
+}
+
+int ScreenshotParams::height() const {
+    return mHeight;
+}
+
+uint32_t ScreenshotParams::expectedHash() const {
+    return mExpectedPixelHash;
+}
+
+std::string ScreenshotParams::outputDirectoryPath() const {
+    return ".";
+}
+
+std::string ScreenshotParams::generatedActualFileName() const {
+    return absl::StrFormat("%s_actual.png", mFileName);
+}
+
+std::string ScreenshotParams::generatedActualFilePath() const {
+    return absl::StrFormat("%s/%s", outputDirectoryPath(), generatedActualFileName());
+}
+
+std::string ScreenshotParams::goldenFileName() const {
+    return absl::StrFormat("%s_golden.png", mFileName);
+}
+
+std::string ScreenshotParams::goldenFilePath() const {
+    return absl::StrFormat("%s/%s", outputDirectoryPath(), goldenFileName());
+}
+
+ImageExpectation::ImageExpectation(const char* fileName, int lineNumber,
+        filament::backend::DriverApi& api, ScreenshotParams params,
+        filament::backend::RenderTargetHandle renderTarget)
+        : mFileName(fileName), mLineNumber(lineNumber), mParams(std::move(params)),
+          mResult(api, renderTarget, mParams) {}
+
+void ImageExpectation::evaluate() {
+    // Ensure this is only evaluated once.
+    if (mEvaluated) {
+        return;
+    }
+    mEvaluated = true;
+
+    // Do the actual image comparison inside a scoped trace with the stored file and line.
+    {
+        testing::ScopedTrace trace(mFileName, mLineNumber, "");
+        compareImage();
+    }
+}
+
+void ImageExpectation::compareImage() const {
+    bool bytesFilled = mResult.bytesFilled();
+    EXPECT_THAT(bytesFilled, testing::IsTrue())
+                        << "Render target wasn't copied to the buffer for " << mFileName;
+    if (bytesFilled) {
+        uint32_t actualHash = mResult.hash();
+        EXPECT_THAT(actualHash, testing::Eq(mParams.expectedHash()));
+    }
+}
+
+ImageExpectations::ImageExpectations(filament::backend::DriverApi& api) : mApi(api) {}
+
+ImageExpectations::~ImageExpectations() {
+    // Guarantee that all expectations are evaluated when this leaves scope even if the caller
+    // forgot to manually evaluate them.
+    evaluate();
+}
+
+void ImageExpectations::addExpectation(const char* fileName, int lineNumber,
+        filament::backend::RenderTargetHandle renderTarget, ScreenshotParams params) {
+    mExpectations.emplace_back(fileName, lineNumber, mApi, std::move(params), renderTarget);
+}
+
+void ImageExpectations::evaluate() {
+    for (auto& expectation: mExpectations) {
+        expectation.evaluate();
+    }
+    mExpectations.clear();
+}
+
+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);
+        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::ofstream pngStream(filePath, std::ios::binary | std::ios::trunc);
+        image::ImageEncoder::encode(pngStream, image::ImageEncoder::Format::PNG, image, "",
+                filePath);
+        internal->bytesFilled = true;
+    };
+    filament::backend::PixelBufferDescriptor pb(mInternal->bytes.data(), size,
+            filament::backend::PixelDataFormat::RGBA, filament::backend::PixelDataType::UBYTE, cb,
+            (void*)mInternal.get());
+    api.readPixels(renderTarget, 0, 0, mInternal->params.width(), mInternal->params.height(),
+            std::move(pb));
+#endif
+}
+
+RenderTargetDump::~RenderTargetDump() {
+    // If the GPU callback hasn't been made yet then there's a callback elsewhere that has a copy of
+    // the internal pointer. But there's no guarantee that the callback will be ever made if the GPU
+    // pipeline wasn't run for some reason. So it is necessary to leak the memory.
+    // It would be possible to try to coordinate with the callback to have it clean up the memory,
+    // but if this condition happens there's already an issue with the test case so there's no need.
+    if (!bytesFilled()) {
+        mInternal.release();
+    }
+}
+
+uint32_t RenderTargetDump::hash() const {
+    return utils::hash::murmur3((uint32_t*)mInternal->bytes.data(), mInternal->bytes.size() / 4, 0);
+}
+
+bool RenderTargetDump::bytesFilled() const {
+    return mInternal->bytesFilled;
+}
+
+RenderTargetDump::Internal::Internal(const ScreenshotParams& params) : params(params) {}

filament/backend/test/ImageExpectations.h

@@ -0,0 +1,136 @@
+/*
+ * 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_IMAGE_EXPECTATIONS_H
+#define TNT_IMAGE_EXPECTATIONS_H
+
+#include <vector>
+
+#include "gtest/gtest.h"
+
+#include "backend/Handle.h"
+#include "backend/DriverApiForward.h"
+
+// Arguments are (RenderTargetHandle renderTarget, ImageExpectations& expectations,
+// ScreenshotParams screenshotParams)
+#define EXPECT_IMAGE(renderTarget, expectations, screenshotParams)  \
+do {                                                                \
+    expectations.addExpectation(                                    \
+        __FILE__,                                                   \
+        __LINE__,                                                   \
+        renderTarget,                                               \
+        screenshotParams);                                          \
+} while (0)
+
+/**
+ * Stores user-provided configuration values for an image expectation
+ */
+class ScreenshotParams {
+public:
+    ScreenshotParams(int width, int height, std::string fileName, uint32_t expectedPixelHash);
+
+    int width() const;
+    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;
+
+private:
+    int mWidth;
+    int mHeight;
+    uint32_t mExpectedPixelHash;
+    std::string mFileName;
+};
+
+/**
+ * When created adds a command to the GPU pipeline to copy the render target into a buffer and
+ * stores the result.
+ * If this object is destroyed before the GPU pipeline is flushed it will leak memory in order to
+ * avoid the GPU pipeline callback being a use-after-free.
+ */
+class RenderTargetDump {
+public:
+    RenderTargetDump(filament::backend::DriverApi& api,
+            filament::backend::RenderTargetHandle renderTarget, const ScreenshotParams& params);
+    RenderTargetDump(RenderTargetDump&& other) = default;
+    RenderTargetDump& operator=(RenderTargetDump&& other) = default;
+    ~RenderTargetDump();
+
+    /**
+     * Should only bue used if BytesFilled returns true.
+     * @return The hash of the stored bytes.
+     */
+    uint32_t hash() const;
+    /**
+     * Thread safe as this is backed by an atomic.
+     * Once this returns true it will never return false.
+     * @return Whether the bytes have actually been copied from the GPU to the buffer.
+     */
+    bool bytesFilled() const;
+
+private:
+    struct Internal {
+        explicit Internal(const ScreenshotParams& params);
+        ScreenshotParams params;
+        std::atomic<bool> bytesFilled = false;
+        std::vector<unsigned char> bytes;
+    };
+
+    // We need a memory location that won't be invalidated to pass to GPU callbacks as they can't
+    // be canceled during the destructor.
+    std::unique_ptr<Internal> mInternal;
+};
+
+class ImageExpectation {
+public:
+    ImageExpectation(const char* fileName, int lineNumber, filament::backend::DriverApi& api,
+            ScreenshotParams params, filament::backend::RenderTargetHandle renderTarget);
+
+    void evaluate();
+
+private:
+    void compareImage() const;
+
+    bool mEvaluated = false;
+    const char* mFileName;
+    int mLineNumber;
+    ScreenshotParams mParams;
+    RenderTargetDump mResult;
+};
+
+class ImageExpectations {
+public:
+    explicit ImageExpectations(filament::backend::DriverApi& api);
+    ~ImageExpectations();
+
+    /**
+     * Not meant to be called directly, use EXPECT_IMAGE to get the file name and line number
+     */
+    void addExpectation(const char* fileName, int lineNumber,
+            filament::backend::RenderTargetHandle renderTarget, ScreenshotParams params);
+
+    void evaluate();
+
+private:
+    filament::backend::DriverApi& mApi;
+    std::vector<ImageExpectation> mExpectations;
+};
+
+#endif //TNT_IMAGE_EXPECTATIONS_H

filament/backend/test/Shader.cpp

@@ -0,0 +1,64 @@
+/*
+ * 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 "Shader.h"
+
+#include "BackendTest.h"
+#include "ShaderGenerator.h"
+
+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 };
+    };
+
+    filamat::DescriptorSets descriptors;
+    for (unsigned char i = 0; i < config.uniformNames.size(); ++i) {
+        descriptors[i + 1] = {{ config.uniformNames[i], kLayouts[i], {}}};
+    }
+    ShaderGenerator shaderGen(
+            std::move(config.vertexShader), std::move(config.fragmentShader), BackendTest::sBackend,
+            BackendTest::sIsMobilePlatform, std::move(descriptors));
+    Program prog = shaderGen.getProgram(api);
+    for (unsigned char i = 0; i < config.uniformNames.size(); ++i) {
+        prog.descriptorBindings(1, {{ config.uniformNames[i], DescriptorType::UNIFORM_BUFFER, i }});
+    }
+    mProgram = cleanup.add(api.createProgram(std::move(prog)));
+
+    mDescriptorSetLayout = cleanup.add(
+            api.createDescriptorSetLayout(DescriptorSetLayout{ kLayouts }));
+
+    mDescriptorSet = cleanup.add(api.createDescriptorSet(mDescriptorSetLayout));
+}
+
+filament::backend::ProgramHandle Shader::getProgram() const {
+    return mProgram;
+}
+
+filament::backend::DescriptorSetLayoutHandle Shader::getDescriptorSetLayout() const {
+    return mDescriptorSetLayout;
+}
+
+filament::backend::DescriptorSetHandle Shader::getDescriptorSet() const {
+    return mDescriptorSet;
+}
+
+} // namespace test

filament/backend/test/Shader.h

@@ -0,0 +1,143 @@
+/*
+ * 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_SHADER_H
+#define TNT_SHADER_H
+
+#include "Lifetimes.h"
+
+namespace test {
+
+// All describing a shader that should be created.
+struct ShaderConfig {
+    std::string vertexShader;
+    std::string fragmentShader;
+    std::vector<utils::CString> uniformNames;
+};
+
+// All values describing a uniform.
+struct ResolvedUniformBindingConfig {
+    size_t dataSize;
+    size_t bufferSize;
+    uint32_t byteOffset;
+    filament::backend::descriptor_set_t set;
+    filament::backend::descriptor_binding_t binding;
+};
+
+// An equivalent to ResolvedUniformBindingConfig with all fields optional.
+// resolve can be called to create a ResolvedBindingConfig with default values
+// use in place of nullopt values.
+struct UniformBindingConfig {
+    std::optional<size_t> dataSize;
+    std::optional<size_t> bufferSize;
+    std::optional<uint32_t> byteOffset;
+    std::optional<filament::backend::descriptor_set_t> set;
+    std::optional<filament::backend::descriptor_binding_t> binding;
+
+    template<typename UniformType>
+    ResolvedUniformBindingConfig resolve();
+};
+
+class Shader {
+public:
+    // All graphics resources have their lifetime controlled by the Cleanup and not this object.
+    // Shader must not outlive either the DriverApi or the Cleanup.
+    Shader(filament::backend::DriverApi& api, Cleanup& cleanup, ShaderConfig config);
+
+    // Uploads a uniform with the default config.
+    template<typename UniformType>
+    void uploadUniform(filament::backend::DriverApi& api,
+            filament::backend::Handle<filament::backend::HwBufferObject> hwBuffer,
+            UniformType uniforms) const;
+    // Binds a uniform with the default config.
+    template<typename UniformType>
+    void bindUniform(filament::backend::DriverApi& api,
+            filament::backend::Handle<filament::backend::HwBufferObject> hwBuffer) const;
+    // Uploads a uniform, with UniformBindingConfig providing the arguments.
+    template<typename UniformType>
+    void uploadUniform(filament::backend::DriverApi& api,
+            filament::backend::Handle<filament::backend::HwBufferObject> hwBuffer,
+            UniformBindingConfig config, UniformType uniforms) const;
+    // Binds a uniform, with UniformBindingConfig providing the arguments.
+    template<typename UniformType>
+    void bindUniform(filament::backend::DriverApi& api,
+            filament::backend::Handle<filament::backend::HwBufferObject> hwBuffer,
+            UniformBindingConfig config) const;
+
+    filament::backend::ProgramHandle getProgram() const;
+    filament::backend::DescriptorSetLayoutHandle getDescriptorSetLayout() const;
+    filament::backend::DescriptorSetHandle getDescriptorSet() const;
+
+protected:
+    filament::backend::ProgramHandle mProgram;
+    filament::backend::DescriptorSetLayoutHandle mDescriptorSetLayout;
+    filament::backend::DescriptorSetHandle mDescriptorSet;
+};
+
+template<typename UniformType>
+ResolvedUniformBindingConfig UniformBindingConfig::resolve() {
+    auto resolvedDataSize = dataSize.value_or(sizeof(UniformType));
+    return ResolvedUniformBindingConfig{
+            .dataSize = resolvedDataSize,
+            .bufferSize = bufferSize.value_or(resolvedDataSize),
+            .byteOffset = byteOffset.value_or(0),
+            .set = set.value_or(1),
+            .binding = binding.value_or(0)
+    };
+}
+
+template<typename UniformType>
+void Shader::uploadUniform(filament::backend::DriverApi& api,
+        filament::backend::Handle<filament::backend::HwBufferObject> hwBuffer,
+        UniformBindingConfig config, UniformType uniforms) const {
+    auto resolvedConfig = config.resolve<UniformType>();
+
+    UniformType* tmp = new UniformType(uniforms);
+    auto cb = [](void* buffer, size_t size, void* user) {
+        UniformType* sp = (UniformType*)buffer;
+        delete sp;
+    };
+    filament::backend::BufferDescriptor bd(tmp, resolvedConfig.dataSize, cb);
+    api.updateBufferObject(hwBuffer, std::move(bd), resolvedConfig.byteOffset);
+}
+
+template<typename UniformType>
+void Shader::bindUniform(filament::backend::DriverApi& api,
+        filament::backend::Handle<filament::backend::HwBufferObject> hwBuffer,
+        UniformBindingConfig config) const {
+    auto resolvedConfig = config.resolve<UniformType>();
+
+    api.updateDescriptorSetBuffer(getDescriptorSet(), resolvedConfig.binding, hwBuffer, 0,
+            resolvedConfig.bufferSize);
+    api.bindDescriptorSet(getDescriptorSet(), resolvedConfig.set, {});
+}
+
+template<typename UniformType>
+void Shader::uploadUniform(filament::backend::DriverApi& api,
+        filament::backend::Handle<filament::backend::HwBufferObject> hwBuffer,
+        UniformType uniforms) const {
+    uploadUniform(api, hwBuffer, UniformBindingConfig{}, uniforms);
+}
+
+template<typename UniformType>
+void Shader::bindUniform(filament::backend::DriverApi& api,
+        filament::backend::Handle<filament::backend::HwBufferObject> hwBuffer) const {
+    bindUniform<UniformType>(api, hwBuffer, UniformBindingConfig{});
+}
+
+} // namespace test
+
+#endif //TNT_SHADER_H

filament/backend/test/test_Blit.cpp

@@ -16,8 +16,9 @@
 
 #include "BackendTest.h"
 
+#include "ImageExpectations.h"
 #include "Lifetimes.h"
-#include "ShaderGenerator.h"
+#include "Shader.h"
 #include "TrianglePrimitive.h"
 
 #include <utils/Hash.h>
@@ -26,8 +27,10 @@
 #include <fstream>
 
 #ifndef FILAMENT_IOS
+
 #include <imageio/ImageEncoder.h>
 #include <image/ColorTransform.h>
+
 #endif
 
 namespace test {
@@ -37,6 +40,21 @@ 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;
@@ -56,49 +74,12 @@ void main() {
     fragColor = params.color;
 })";
 
-struct MaterialParams {
-    float4 color;
-    float4 scale;
-};
-
-struct ScreenshotParams {
-    int width;
-    int height;
-    const char* filename;
-    uint32_t pixelHashResult;
-};
-
-#ifdef FILAMENT_IOS
-static void dumpScreenshot(DriverApi& dapi, Handle<HwRenderTarget> rt, ScreenshotParams* params) {}
-#else
-static void dumpScreenshot(DriverApi& dapi, Handle<HwRenderTarget> rt, ScreenshotParams* params) {
-    using namespace image;
-    const size_t size = params->width * params->height * 4;
-    void* buffer = calloc(1, size);
-    auto cb = [](void* buffer, size_t size, void* user) {
-        ScreenshotParams* params = (ScreenshotParams*) user;
-        int w = params->width, h = params->height;
-        const uint32_t* texels = (uint32_t*) buffer;
-        params->pixelHashResult = utils::hash::murmur3(texels, size / 4, 0);
-        LinearImage image(w, h, 4);
-        image = toLinearWithAlpha<uint8_t>(w, h, w * 4, (uint8_t*) buffer);
-        std::ofstream pngstrm(params->filename, std::ios::binary | std::ios::trunc);
-        ImageEncoder::encode(pngstrm, ImageEncoder::Format::PNG, image, "", params->filename);
-    };
-    PixelBufferDescriptor pb(buffer, size, PixelDataFormat::RGBA, PixelDataType::UBYTE, cb,
-            (void*) params);
-    dapi.readPixels(rt, 0, 0, params->width, params->height, std::move(pb));
-}
-#endif
-
-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);
+Shader BlitTest::createShader() {
+    return Shader(getDriverApi(), mCleanup, ShaderConfig{
+            .vertexShader = triangleVs,
+            .fragmentShader = triangleFs,
+            .uniformNames = { "Params" },
+    });
 }
 
 static uint32_t toUintColor(float4 color) {
@@ -116,7 +97,7 @@ static void createBitmap(DriverApi& dapi, Handle<HwTexture> texture, int baseWid
     const int width = baseWidth >> level;
     const int height = baseHeight >> level;
     const size_t size0 = height * width * 4;
-    uint8_t* buffer0 = (uint8_t*) calloc(size0, 1);
+    uint8_t* buffer0 = (uint8_t*)calloc(size0, 1);
     PixelBufferDescriptor pb(buffer0, size0, PixelDataFormat::RGBA, PixelDataType::UBYTE, cb);
 
     const float3 foreground = color;
@@ -140,7 +121,7 @@ static void createBitmap(DriverApi& dapi, Handle<HwTexture> texture, int baseWid
     // |   ........
     // low addresses
     // This is because OpenGL automatically flips image data when uploading into the texture.
-    uint32_t* texels = (uint32_t*) buffer0;
+    uint32_t* texels = (uint32_t*)buffer0;
     for (int row = 0; row < height; row++) {
         for (int col = 0; col < width; col++) {
             float2 uv = { (col - width / 2.0f) / width, (row - height / 2.0f) / height };
@@ -168,7 +149,7 @@ static void createFaces(DriverApi& dapi, Handle<HwTexture> texture, int baseWidt
     const int width = baseWidth >> level;
     const int height = baseHeight >> level;
     const size_t size0 = height * width * 4 * 6;
-    uint8_t* buffer0 = (uint8_t*) calloc(size0, 1);
+    uint8_t* buffer0 = (uint8_t*)calloc(size0, 1);
     PixelBufferDescriptor pb(buffer0, size0, PixelDataFormat::RGBA, PixelDataType::UBYTE, cb);
 
     const float3 foreground = color;
@@ -176,7 +157,7 @@ static void createFaces(DriverApi& dapi, Handle<HwTexture> texture, int baseWidt
     const float radius = 0.25f;
 
     // Draw a circle on a yellow background.
-    uint32_t* texels = (uint32_t*) buffer0;
+    uint32_t* texels = (uint32_t*)buffer0;
     for (int face = 0; face < 6; face++) {
         for (int row = 0; row < height; row++) {
             for (int col = 0; col < width; col++) {
@@ -194,10 +175,9 @@ static void createFaces(DriverApi& dapi, Handle<HwTexture> texture, int baseWidt
     dapi.update3DImage(texture, level, 0, 0, 0, width, height, 6, std::move(pb));
 }
 
-TEST_F(BackendTest, ColorMagnify) {
+TEST_F(BlitTest, ColorMagnify) {
     auto& api = getDriverApi();
-    Cleanup cleanup(getDriverApi());
-    cleanup.addPostCall([&]() { executeCommands(); });
+    mCleanup.addPostCall([&]() { executeCommands(); });
 
     constexpr int kSrcTexWidth = 256;
     constexpr int kSrcTexHeight = 256;
@@ -208,37 +188,40 @@ TEST_F(BackendTest, ColorMagnify) {
     constexpr int kNumLevels = 3;
 
     // Create a SwapChain and make it current. We don't really use it so the res doesn't matter.
-    auto swapChain = cleanup.add(api.createSwapChainHeadless(256, 256, 0));
+    auto swapChain = mCleanup.add(api.createSwapChainHeadless(256, 256, 0));
     api.makeCurrent(swapChain, swapChain);
 
     // Create a source texture.
-    Handle<HwTexture> const srcTexture = cleanup.add(api.createTexture(
-        SamplerType::SAMPLER_2D, kNumLevels, kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, 1,
-        TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE | TextureUsage::COLOR_ATTACHMENT));
+    Handle<HwTexture> const srcTexture = mCleanup.add(api.createTexture(
+            SamplerType::SAMPLER_2D, kNumLevels, kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, 1,
+            TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE | TextureUsage::COLOR_ATTACHMENT));
     const bool flipY = sBackend == Backend::OPENGL;
     createBitmap(api, srcTexture, kSrcTexWidth, kSrcTexHeight, 0, float3(0.5, 0, 0), flipY);
     createBitmap(api, srcTexture, kSrcTexWidth, kSrcTexHeight, 1, float3(0, 0, 0.5), flipY);
 
     // Create a destination texture.
-    Handle<HwTexture> const dstTexture = cleanup.add(api.createTexture(
-        SamplerType::SAMPLER_2D, kNumLevels, kDstTexFormat, 1, kDstTexWidth, kDstTexHeight, 1,
-        TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
+    Handle<HwTexture> const dstTexture = mCleanup.add(api.createTexture(
+            SamplerType::SAMPLER_2D, kNumLevels, kDstTexFormat, 1, kDstTexWidth, kDstTexHeight, 1,
+            TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
 
     // Create a RenderTarget for each texture's miplevel.
     Handle<HwRenderTarget> srcRenderTargets[kNumLevels];
     Handle<HwRenderTarget> dstRenderTargets[kNumLevels];
     for (uint8_t level = 0; level < kNumLevels; level++) {
-        srcRenderTargets[level] = cleanup.add(api.createRenderTarget( TargetBufferFlags::COLOR,
-                kSrcTexWidth >> level, kSrcTexHeight >> level, 1, 0, { srcTexture, level, 0 }, {}, {}));
-        dstRenderTargets[level] = cleanup.add(api.createRenderTarget( TargetBufferFlags::COLOR,
-                kDstTexWidth >> level, kDstTexHeight >> level, 1, 0, { dstTexture, level, 0 }, {}, {}));
+        srcRenderTargets[level] = mCleanup.add(api.createRenderTarget(TargetBufferFlags::COLOR,
+                kSrcTexWidth >> level, kSrcTexHeight >> level, 1, 0, { srcTexture, level, 0 }, {},
+                {}));
+        dstRenderTargets[level] = mCleanup.add(api.createRenderTarget(TargetBufferFlags::COLOR,
+                kDstTexWidth >> level, kDstTexHeight >> level, 1, 0, { dstTexture, level, 0 }, {},
+                {}));
     }
 
     // Do a "magnify" blit from level 1 of the source RT to the level 0 of the destination RT.
     const int srcLevel = 1;
     api.blitDEPRECATED(TargetBufferFlags::COLOR0, dstRenderTargets[0],
-            {0, 0, kDstTexWidth, kDstTexHeight}, srcRenderTargets[srcLevel],
-            {0, 0, kSrcTexWidth >> srcLevel, kSrcTexHeight >> srcLevel}, SamplerMagFilter::LINEAR);
+            { 0, 0, kDstTexWidth, kDstTexHeight }, srcRenderTargets[srcLevel],
+            { 0, 0, kSrcTexWidth >> srcLevel, kSrcTexHeight >> srcLevel },
+            SamplerMagFilter::LINEAR);
 
     // Push through an empty frame to allow the texture to upload and the blit to execute.
     {
@@ -246,29 +229,23 @@ TEST_F(BackendTest, ColorMagnify) {
         api.commit(swapChain);
     }
 
-    // Grab a screenshot.
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "ColorMagnify.png" };
     {
-        RenderFrame frame(api);
-        dumpScreenshot(api, dstRenderTargets[0], &params);
-        api.commit(swapChain);
+        ImageExpectations expectations(api);
+
+        {
+            RenderFrame frame(api);
+            EXPECT_IMAGE(dstRenderTargets[0], expectations,
+                    ScreenshotParams(kDstTexWidth, kDstTexHeight, "ColorMagnify", 0x410bdd31));
+            api.commit(swapChain);
+        }
+
+        flushAndWait();
     }
-
-    // Wait for the ReadPixels result to come back.
-    api.finish();
-    executeCommands();
-    getDriver().purge();
-
-    // Check if the image matches perfectly to our golden run.
-    const uint32_t expected = 0x410bdd31;
-    printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", params.pixelHashResult, expected);
-    EXPECT_TRUE(params.pixelHashResult == expected);
 }
 
-TEST_F(BackendTest, ColorMinify) {
+TEST_F(BlitTest, ColorMinify) {
     auto& api = getDriverApi();
-    Cleanup cleanup(getDriverApi());
-    cleanup.addPostCall([&]() { executeCommands(); });
+    mCleanup.addPostCall([&]() { executeCommands(); });
 
     constexpr int kSrcTexWidth = 1024;
     constexpr int kSrcTexHeight = 1024;
@@ -279,57 +256,55 @@ TEST_F(BackendTest, ColorMinify) {
     constexpr int kNumLevels = 3;
 
     // Create a SwapChain and make it current. We don't really use it so the res doesn't matter.
-    auto swapChain = cleanup.add(api.createSwapChainHeadless(256, 256, 0));
+    auto swapChain = mCleanup.add(api.createSwapChainHeadless(256, 256, 0));
     api.makeCurrent(swapChain, swapChain);
 
     // Create a source texture.
-    Handle<HwTexture> const srcTexture = cleanup.add(api.createTexture(
-        SamplerType::SAMPLER_2D, kNumLevels, kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, 1,
-        TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE | TextureUsage::COLOR_ATTACHMENT));
+    Handle<HwTexture> const srcTexture = mCleanup.add(api.createTexture(
+            SamplerType::SAMPLER_2D, kNumLevels, kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, 1,
+            TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE | TextureUsage::COLOR_ATTACHMENT));
     const bool flipY = sBackend == Backend::OPENGL;
     createBitmap(api, srcTexture, kSrcTexWidth, kSrcTexHeight, 0, float3(0.5, 0, 0), flipY);
     createBitmap(api, srcTexture, kSrcTexWidth, kSrcTexHeight, 1, float3(0, 0, 0.5), flipY);
 
     // Create a destination texture.
-    Handle<HwTexture> const dstTexture = cleanup.add(api.createTexture(
-        SamplerType::SAMPLER_2D, kNumLevels, kDstTexFormat, 1, kDstTexWidth, kDstTexHeight, 1,
-        TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
+    Handle<HwTexture> const dstTexture = mCleanup.add(api.createTexture(
+            SamplerType::SAMPLER_2D, kNumLevels, kDstTexFormat, 1, kDstTexWidth, kDstTexHeight, 1,
+            TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
 
     // Create a RenderTarget for each texture's miplevel.
     Handle<HwRenderTarget> srcRenderTargets[kNumLevels];
     Handle<HwRenderTarget> dstRenderTargets[kNumLevels];
     for (uint8_t level = 0; level < kNumLevels; level++) {
-        srcRenderTargets[level] = cleanup.add(api.createRenderTarget( TargetBufferFlags::COLOR,
-                kSrcTexWidth >> level, kSrcTexHeight >> level, 1, 0, { srcTexture, level, 0 }, {}, {}));
-        dstRenderTargets[level] = cleanup.add(api.createRenderTarget( TargetBufferFlags::COLOR,
-                kDstTexWidth >> level, kDstTexHeight >> level, 1, 0, { dstTexture, level, 0 }, {}, {}));
+        srcRenderTargets[level] = mCleanup.add(api.createRenderTarget(TargetBufferFlags::COLOR,
+                kSrcTexWidth >> level, kSrcTexHeight >> level, 1, 0, { srcTexture, level, 0 }, {},
+                {}));
+        dstRenderTargets[level] = mCleanup.add(api.createRenderTarget(TargetBufferFlags::COLOR,
+                kDstTexWidth >> level, kDstTexHeight >> level, 1, 0, { dstTexture, level, 0 }, {},
+                {}));
     }
 
     // Do a "minify" blit from level 1 of the source RT to the level 0 of the destination RT.
     const int srcLevel = 1;
 
     api.blitDEPRECATED(TargetBufferFlags::COLOR0,
-            dstRenderTargets[0], {0, 0, kDstTexWidth, kDstTexHeight},
-            srcRenderTargets[srcLevel], {0, 0, kSrcTexWidth >> srcLevel, kSrcTexHeight >> srcLevel},
+            dstRenderTargets[0], { 0, 0, kDstTexWidth, kDstTexHeight },
+            srcRenderTargets[srcLevel],
+            { 0, 0, kSrcTexWidth >> srcLevel, kSrcTexHeight >> srcLevel },
             SamplerMagFilter::LINEAR);
 
+    {
+        ImageExpectations expectations(api);
 
-    // Grab a screenshot.
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "ColorMinify.png" };
-    dumpScreenshot(api, dstRenderTargets[0], &params);
+        EXPECT_IMAGE(dstRenderTargets[0], expectations,
+                ScreenshotParams(kDstTexWidth, kDstTexHeight, "ColorMinify", 0xf3d9c53f));
 
-    // Wait for the ReadPixels result to come back.
-    flushAndWait();
-
-    // Check if the image matches perfectly to our golden run.
-    const uint32_t expected = 0xf3d9c53f;
-    printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", params.pixelHashResult, expected);
-    EXPECT_TRUE(params.pixelHashResult == expected);
+        flushAndWait();
+    }
 }
 
-TEST_F(BackendTest, ColorResolve) {
+TEST_F(BlitTest, ColorResolve) {
     auto& api = getDriverApi();
-    Cleanup cleanup(getDriverApi());
 
     constexpr int kSrcTexWidth = 256;
     constexpr int kSrcTexHeight = 256;
@@ -338,49 +313,29 @@ TEST_F(BackendTest, ColorResolve) {
     constexpr auto kColorTexFormat = TextureFormat::RGBA8;
     constexpr int kSampleCount = 4;
 
-    // Create a program.
-    ProgramHandle program;
-    {
-        filamat::DescriptorSets descriptors;
-        descriptors[1] = { { "Params",
-                { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0 },
-                {} } };
-        ShaderGenerator shaderGen(
-                triangleVs, triangleFs, sBackend, sIsMobilePlatform, std::move(descriptors));
-        Program prog = shaderGen.getProgram(api);
-        prog.descriptorBindings(1, {{ "Params", DescriptorType::UNIFORM_BUFFER, 0 }});
-        program = cleanup.add(api.createProgram(std::move(prog)));
-    }
-
-    DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
-            {{
-                     DescriptorType::UNIFORM_BUFFER,
-                     ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
-                     DescriptorFlags::NONE, 0
-             }}}));
-
-    DescriptorSetHandle descriptorSet = cleanup.add(api.createDescriptorSet(descriptorSetLayout));
+    Shader shader = createShader();
 
     // Create a VertexBuffer, IndexBuffer, and RenderPrimitive.
     TrianglePrimitive const triangle(api);
 
     // Create 4-sample texture.
-    Handle<HwTexture> const srcColorTexture = cleanup.add(api.createTexture(
-        SamplerType::SAMPLER_2D, 1, kColorTexFormat, kSampleCount, kSrcTexWidth, kSrcTexHeight, 1,
-        TextureUsage::COLOR_ATTACHMENT));
+    Handle<HwTexture> const srcColorTexture = mCleanup.add(api.createTexture(
+            SamplerType::SAMPLER_2D, 1, kColorTexFormat, kSampleCount, kSrcTexWidth, kSrcTexHeight,
+            1,
+            TextureUsage::COLOR_ATTACHMENT));
 
     // Create 1-sample texture.
-    Handle<HwTexture> const dstColorTexture = cleanup.add(api.createTexture(
-        SamplerType::SAMPLER_2D, 1, kColorTexFormat, 1, kDstTexWidth, kDstTexHeight, 1,
-        TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
+    Handle<HwTexture> const dstColorTexture = mCleanup.add(api.createTexture(
+            SamplerType::SAMPLER_2D, 1, kColorTexFormat, 1, kDstTexWidth, kDstTexHeight, 1,
+            TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
 
     // Create a 4-sample render target with the 4-sample texture.
-    Handle<HwRenderTarget> const srcRenderTarget = cleanup.add(api.createRenderTarget(
+    Handle<HwRenderTarget> const srcRenderTarget = mCleanup.add(api.createRenderTarget(
             TargetBufferFlags::COLOR, kSrcTexWidth, kSrcTexHeight, kSampleCount, 0,
             {{ srcColorTexture }}, {}, {}));
 
     // Create a 1-sample render target with the 1-sample texture.
-    Handle<HwRenderTarget> const dstRenderTarget = cleanup.add(api.createRenderTarget(
+    Handle<HwRenderTarget> const dstRenderTarget = mCleanup.add(api.createRenderTarget(
             TargetBufferFlags::COLOR, kDstTexWidth, kDstTexHeight, 1, 0,
             {{ dstColorTexture }}, {}, {}));
 
@@ -394,58 +349,52 @@ TEST_F(BackendTest, ColorResolve) {
     params.viewport.height = kSrcTexHeight;
 
     PipelineState state = {};
-    state.program = program;
-    state.pipelineLayout.setLayout[1] = { descriptorSetLayout };
+    state.program = shader.getProgram();
+    state.pipelineLayout.setLayout[1] = { shader.getDescriptorSetLayout() };
     state.rasterState.colorWrite = true;
     state.rasterState.depthWrite = false;
     state.rasterState.depthFunc = RasterState::DepthFunc::A;
     state.rasterState.culling = CullingMode::NONE;
 
-    auto ubuffer = cleanup.add(api.createBufferObject(sizeof(MaterialParams),
+    auto ubuffer = mCleanup.add(api.createBufferObject(sizeof(MaterialParams),
             BufferObjectBinding::UNIFORM, BufferUsage::STATIC));
     // Draw red triangle into srcRenderTarget.
-    uploadUniforms(api, ubuffer, {
-        .color = float4(1, 0, 0, 1),
-        .scale = float4(1, 1, 0.5, 0),
+    shader.uploadUniform(api, ubuffer, MaterialParams{
+            .color = float4(1, 0, 0, 1),
+            .scale = float4(1, 1, 0.5, 0),
     });
-
-    api.updateDescriptorSetBuffer(descriptorSet, 0, ubuffer, 0, sizeof(MaterialParams));
-    api.bindDescriptorSet(descriptorSet, 1, {});
+    shader.bindUniform<MaterialParams>(api, ubuffer);
 
     // FIXME: on Metal this triangle is not drawn. Can't understand why.
     {
         RenderFrame frame(api);
         api.beginRenderPass(srcRenderTarget, params);
-            api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
+        api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
         api.endRenderPass();
     }
 
     // Resolve the MSAA render target into the single-sample render target.
     api.blitDEPRECATED(TargetBufferFlags::COLOR,
-            dstRenderTarget, {0, 0, kDstTexWidth, kDstTexHeight},
-            srcRenderTarget, {0, 0, kSrcTexWidth, kSrcTexHeight},
+            dstRenderTarget, { 0, 0, kDstTexWidth, kDstTexHeight },
+            srcRenderTarget, { 0, 0, kSrcTexWidth, kSrcTexHeight },
             SamplerMagFilter::NEAREST);
 
-    // Grab a screenshot.
-    ScreenshotParams sparams{ kDstTexWidth, kDstTexHeight, "ColorResolve.png" };
-    dumpScreenshot(api, dstRenderTarget, &sparams);
+    {
+        ImageExpectations expectations(api);
 
-    // Wait for the ReadPixels result to come back.
-    flushAndWait();
+        EXPECT_IMAGE(dstRenderTarget, expectations,
+                ScreenshotParams(kDstTexWidth, kDstTexHeight, "ColorResolve", 0xebfac2ef));
 
-    // Check if the image matches perfectly to our golden run.
-    const uint32_t expected = 0xebfac2ef;
-    printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", sparams.pixelHashResult, expected);
-    EXPECT_TRUE(sparams.pixelHashResult == expected);
+        flushAndWait();
+    }
 }
 
-TEST_F(BackendTest, Blit2DTextureArray) {
+TEST_F(BlitTest, Blit2DTextureArray) {
     auto& api = getDriverApi();
-    Cleanup cleanup(getDriverApi());
-    cleanup.addPostCall([&]() { executeCommands(); });
+    mCleanup.addPostCall([&]() { executeCommands(); });
 
     api.startCapture(0);
-    cleanup.addPostCall([&]() { api.stopCapture(0); });
+    mCleanup.addPostCall([&]() { api.stopCapture(0); });
 
     constexpr int kSrcTexWidth = 256;
     constexpr int kSrcTexHeight = 256;
@@ -460,33 +409,40 @@ TEST_F(BackendTest, Blit2DTextureArray) {
     constexpr int kDstTexLayer = 0;
 
     // Create a SwapChain and make it current. We don't really use it so the res doesn't matter.
-    auto swapChain = cleanup.add(api.createSwapChainHeadless(256, 256, 0));
+    auto swapChain = mCleanup.add(api.createSwapChainHeadless(256, 256, 0));
     api.makeCurrent(swapChain, swapChain);
 
     // Create a source texture.
-    Handle<HwTexture> srcTexture = cleanup.add(api.createTexture(
-            SamplerType::SAMPLER_2D_ARRAY, kNumLevels, kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, kSrcTexDepth,
+    Handle<HwTexture> srcTexture = mCleanup.add(api.createTexture(
+            SamplerType::SAMPLER_2D_ARRAY, kNumLevels, kSrcTexFormat, 1, kSrcTexWidth,
+            kSrcTexHeight, kSrcTexDepth,
             TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE | TextureUsage::COLOR_ATTACHMENT));
     const bool flipY = sBackend == Backend::OPENGL;
-    createBitmap(api, srcTexture, kSrcTexWidth, kSrcTexHeight, 0, kSrcTexLayer, float3(0.5, 0, 0), flipY);
+    createBitmap(api, srcTexture, kSrcTexWidth, kSrcTexHeight, 0, kSrcTexLayer, float3(0.5, 0, 0),
+            flipY);
 
     // Create a destination texture.
-    Handle<HwTexture> dstTexture = cleanup.add(api.createTexture(
+    Handle<HwTexture> dstTexture = mCleanup.add(api.createTexture(
             SamplerType::SAMPLER_2D, kNumLevels, kDstTexFormat, 1, kDstTexWidth, kDstTexHeight, 1,
             TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
 
     // Create two RenderTargets.
     const int level = 0;
-    Handle<HwRenderTarget> srcRenderTarget = cleanup.add(api.createRenderTarget( TargetBufferFlags::COLOR,
-            kSrcTexWidth >> level, kSrcTexHeight >> level, 1, 0, { srcTexture, level, kSrcTexLayer }, {}, {}));
-    Handle<HwRenderTarget> dstRenderTarget = cleanup.add(api.createRenderTarget( TargetBufferFlags::COLOR,
-            kDstTexWidth >> level, kDstTexHeight >> level, 1, 0, { dstTexture, level, kDstTexLayer }, {}, {}));
+    Handle<HwRenderTarget> srcRenderTarget = mCleanup.add(
+            api.createRenderTarget(TargetBufferFlags::COLOR,
+                    kSrcTexWidth >> level, kSrcTexHeight >> level, 1, 0,
+                    { srcTexture, level, kSrcTexLayer }, {}, {}));
+    Handle<HwRenderTarget> dstRenderTarget = mCleanup.add(
+            api.createRenderTarget(TargetBufferFlags::COLOR,
+                    kDstTexWidth >> level, kDstTexHeight >> level, 1, 0,
+                    { dstTexture, level, kDstTexLayer }, {}, {}));
 
     // Do a blit from kSrcTexLayer of the source RT to kDstTexLayer of the destination RT.
     const int srcLevel = 0;
     api.blitDEPRECATED(TargetBufferFlags::COLOR0, dstRenderTarget,
-            {0, 0, kDstTexWidth, kDstTexHeight}, srcRenderTarget,
-            {0, 0, kSrcTexWidth >> srcLevel, kSrcTexHeight >> srcLevel}, SamplerMagFilter::LINEAR);
+            { 0, 0, kDstTexWidth, kDstTexHeight }, srcRenderTarget,
+            { 0, 0, kSrcTexWidth >> srcLevel, kSrcTexHeight >> srcLevel },
+            SamplerMagFilter::LINEAR);
 
     // Push through an empty frame to allow the texture to upload and the blit to execute.
     {
@@ -494,29 +450,24 @@ TEST_F(BackendTest, Blit2DTextureArray) {
         api.commit(swapChain);
     }
 
-    // Grab a screenshot.
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "Blit2DTextureArray.png" };
     {
-        RenderFrame frame(api);
-        dumpScreenshot(api, dstRenderTarget, &params);
-        api.commit(swapChain);
+        ImageExpectations expectations(api);
+
+        {
+            RenderFrame frame(api);
+            EXPECT_IMAGE(dstRenderTarget, expectations,
+                    ScreenshotParams(kDstTexWidth, kDstTexHeight, "Blit2DTextureArray",
+                            0x8de7d55b));
+            api.commit(swapChain);
+        }
+
+        flushAndWait();
     }
-
-    // Wait for the ReadPixels result to come back.
-    api.finish();
-    executeCommands();
-    getDriver().purge();
-
-    // Check if the image matches perfectly to our golden run.
-    const uint32_t expected = 0x8de7d55b;
-    printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", params.pixelHashResult, expected);
-    EXPECT_TRUE(params.pixelHashResult == expected);
 }
 
-TEST_F(BackendTest, BlitRegion) {
+TEST_F(BlitTest, BlitRegion) {
     auto& api = getDriverApi();
-    Cleanup cleanup(getDriverApi());
-    cleanup.addPostCall([&]() { executeCommands(); });
+    mCleanup.addPostCall([&]() { executeCommands(); });
 
     constexpr int kSrcTexWidth = 1024;
     constexpr int kSrcTexHeight = 1024;
@@ -529,47 +480,48 @@ TEST_F(BackendTest, BlitRegion) {
     constexpr int kDstLevel = 0;
 
     // Create a SwapChain and make it current. We don't really use it so the res doesn't matter.
-    auto swapChain = cleanup.add(api.createSwapChainHeadless(256, 256, 0));
+    auto swapChain = mCleanup.add(api.createSwapChainHeadless(256, 256, 0));
     api.makeCurrent(swapChain, swapChain);
 
     // Create a source texture.
-    Handle<HwTexture> srcTexture = cleanup.add(api.createTexture(
-        SamplerType::SAMPLER_2D, kNumLevels, kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, 1,
-        TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE | TextureUsage::COLOR_ATTACHMENT));
+    Handle<HwTexture> srcTexture = mCleanup.add(api.createTexture(
+            SamplerType::SAMPLER_2D, kNumLevels, kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, 1,
+            TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE | TextureUsage::COLOR_ATTACHMENT));
     const bool flipY = sBackend == Backend::OPENGL;
     createBitmap(api, srcTexture, kSrcTexWidth, kSrcTexHeight, 0, float3(0.5, 0, 0), flipY);
     createBitmap(api, srcTexture, kSrcTexWidth, kSrcTexHeight, 1, float3(0, 0, 0.5), flipY);
 
     // Create a destination texture.
-    Handle<HwTexture> dstTexture = cleanup.add(api.createTexture(
-        SamplerType::SAMPLER_2D, kNumLevels, kDstTexFormat, 1, kDstTexWidth, kDstTexHeight, 1,
-        TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
+    Handle<HwTexture> dstTexture = mCleanup.add(api.createTexture(
+            SamplerType::SAMPLER_2D, kNumLevels, kDstTexFormat, 1, kDstTexWidth, kDstTexHeight, 1,
+            TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
 
     // Blit one-quarter of src level 1 to dst level 0.
     Viewport srcRect = {
-        .left = 0,
-        .bottom = 0,
-        .width = (kSrcTexWidth >> kSrcLevel) / 2,
-        .height = (kSrcTexHeight >> kSrcLevel) / 2,
+            .left = 0,
+            .bottom = 0,
+            .width = (kSrcTexWidth >> kSrcLevel) / 2,
+            .height = (kSrcTexHeight >> kSrcLevel) / 2,
     };
     Viewport dstRect = {
-        .left = 10,
-        .bottom = 10,
-        .width = kDstTexWidth - 10,
-        .height = kDstTexHeight - 10,
+            .left = 10,
+            .bottom = 10,
+            .width = kDstTexWidth - 10,
+            .height = kDstTexHeight - 10,
     };
 
     // Create a RenderTarget for each texture's miplevel.
     // We purposely set the render target width and height to smaller than the texture, to check
     // that this case is handled correctly.
     Handle<HwRenderTarget> srcRenderTarget =
-            cleanup.add(api.createRenderTarget(TargetBufferFlags::COLOR, srcRect.width,
-                    srcRect.height, 1, 0, {srcTexture, kSrcLevel, 0}, {}, {}));
+            mCleanup.add(api.createRenderTarget(TargetBufferFlags::COLOR, srcRect.width,
+                    srcRect.height, 1, 0, { srcTexture, kSrcLevel, 0 }, {}, {}));
     Handle<HwRenderTarget> dstRenderTarget =
-            cleanup.add(api.createRenderTarget(TargetBufferFlags::COLOR, kDstTexWidth >> kDstLevel,
-                    kDstTexHeight >> kDstLevel, 1, 0, {dstTexture, kDstLevel, 0}, {}, {}));
+            mCleanup.add(api.createRenderTarget(TargetBufferFlags::COLOR, kDstTexWidth >> kDstLevel,
+                    kDstTexHeight >> kDstLevel, 1, 0, { dstTexture, kDstLevel, 0 }, {}, {}));
 
-    api.blitDEPRECATED(TargetBufferFlags::COLOR0, dstRenderTarget, dstRect, srcRenderTarget, srcRect,
+    api.blitDEPRECATED(TargetBufferFlags::COLOR0, dstRenderTarget, dstRect, srcRenderTarget,
+            srcRect,
             SamplerMagFilter::LINEAR);
 
     // Push through an empty frame to allow the texture to upload and the blit to execute.
@@ -578,33 +530,25 @@ TEST_F(BackendTest, BlitRegion) {
         api.commit(swapChain);
     }
 
-    // Grab a screenshot.
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "BlitRegion.png" };
     {
-        RenderFrame frame(api);
-        dumpScreenshot(api, dstRenderTarget, &params);
-        api.commit(swapChain);
+        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();
     }
-
-    // Wait for the ReadPixels result to come back.
-    api.finish();
-    executeCommands();
-    getDriver().purge();
-
-    // 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.
-    // Use the compare tool from ImageMagick to see visual differences:
-    // compare -verbose -metric mae BlitRegion_Metal.png BlitRegion_OpenGL.png difference.png
-    //
-    // const uint32_t expected = 0x74fa34ed;
-    // printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", params.pixelHashResult, expected);
-    // EXPECT_TRUE(params.pixelHashResult == expected);
 }
 
-TEST_F(BackendTest, BlitRegionToSwapChain) {
+TEST_F(BlitTest, BlitRegionToSwapChain) {
     auto& api = getDriverApi();
-    Cleanup cleanup(getDriverApi());
-    cleanup.addPostCall([&]() { executeCommands(); });
+    mCleanup.addPostCall([&]() { executeCommands(); });
 
     constexpr int kSrcTexWidth = 1024;
     constexpr int kSrcTexHeight = 1024;
@@ -614,15 +558,15 @@ TEST_F(BackendTest, BlitRegionToSwapChain) {
     constexpr int kNumLevels = 3;
 
     // Create a SwapChain and make it current.
-    auto swapChain = cleanup.add(createSwapChain());
+    auto swapChain = mCleanup.add(createSwapChain());
     api.makeCurrent(swapChain, swapChain);
 
-    Handle<HwRenderTarget> dstRenderTarget = cleanup.add(api.createDefaultRenderTarget());
+    Handle<HwRenderTarget> dstRenderTarget = mCleanup.add(api.createDefaultRenderTarget());
 
     // Create a source texture.
-    Handle<HwTexture> srcTexture = cleanup.add(api.createTexture(
-        SamplerType::SAMPLER_2D, kNumLevels, kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, 1,
-        TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE | TextureUsage::COLOR_ATTACHMENT));
+    Handle<HwTexture> srcTexture = mCleanup.add(api.createTexture(
+            SamplerType::SAMPLER_2D, kNumLevels, kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, 1,
+            TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE | TextureUsage::COLOR_ATTACHMENT));
     const bool flipY = sBackend == Backend::OPENGL;
     createBitmap(api, srcTexture, kSrcTexWidth, kSrcTexHeight, 0, float3(0.5, 0, 0), flipY);
     createBitmap(api, srcTexture, kSrcTexWidth, kSrcTexHeight, 1, float3(0, 0, 0.5), flipY);
@@ -630,42 +574,46 @@ TEST_F(BackendTest, BlitRegionToSwapChain) {
     // Create a RenderTarget for each texture's miplevel.
     Handle<HwRenderTarget> srcRenderTargets[kNumLevels];
     for (uint8_t level = 0; level < kNumLevels; level++) {
-        srcRenderTargets[level] = cleanup.add(api.createRenderTarget( TargetBufferFlags::COLOR,
-                kSrcTexWidth >> level, kSrcTexHeight >> level, 1, 0, { srcTexture, level, 0 }, {}, {}));
+        srcRenderTargets[level] = mCleanup.add(api.createRenderTarget(TargetBufferFlags::COLOR,
+                kSrcTexWidth >> level, kSrcTexHeight >> level, 1, 0, { srcTexture, level, 0 }, {},
+                {}));
     }
 
     // Blit one-quarter of src level 1 to dst level 0.
     const int srcLevel = 1;
     Viewport srcRect = {
-        .left = (kSrcTexWidth >> srcLevel) / 2,
-        .bottom = (kSrcTexHeight >> srcLevel) / 2,
-        .width = (kSrcTexWidth >> srcLevel) / 2,
-        .height = (kSrcTexHeight >> srcLevel) / 2,
+            .left = (kSrcTexWidth >> srcLevel) / 2,
+            .bottom = (kSrcTexHeight >> srcLevel) / 2,
+            .width = (kSrcTexWidth >> srcLevel) / 2,
+            .height = (kSrcTexHeight >> srcLevel) / 2,
     };
     Viewport dstRect = {
-        .left = 10,
-        .bottom = 10,
-        .width = kDstTexWidth - 10,
-        .height = kDstTexHeight - 10,
+            .left = 10,
+            .bottom = 10,
+            .width = kDstTexWidth - 10,
+            .height = kDstTexHeight - 10,
     };
 
     {
-        RenderFrame frame(api);
+        ImageExpectations expectations(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);
 
-        ScreenshotParams params { kDstTexWidth, kDstTexHeight, "BlitRegionToSwapChain.png" };
-        dumpScreenshot(api, dstRenderTarget, &params);
+                api.commit(swapChain);
+            }
 
-        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();
     }
-
-    // Wait for the ReadPixels result to come back.
-    api.finish();
-    executeCommands();
-    getDriver().purge();
 }
 
 } // namespace test

filament/backend/test/test_BufferUpdates.cpp

@@ -16,6 +16,8 @@
 
 #include "BackendTest.h"
 
+#include "Lifetimes.h"
+#include "Shader.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
 
@@ -78,8 +80,28 @@ struct MaterialParams {
     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,
+        .byteOffset = 64
+};
 
-TEST_F(BackendTest, VertexBufferUpdate) {
+class BufferUpdatesTest : public BackendTest {
+public:
+    BufferUpdatesTest() : mCleanup(getDriverApi()) {}
+
+protected:
+    Shader createShader() {
+        return Shader(getDriverApi(), mCleanup, ShaderConfig{
+           vertex, fragment, {"Params"}
+        });
+    }
+
+    Cleanup mCleanup;
+};
+
+TEST_F(BufferUpdatesTest, VertexBufferUpdate) {
     const bool largeBuffers = false;
 
     // If updateIndices is true, then even-numbered triangles will have their indices set to
@@ -90,31 +112,15 @@ TEST_F(BackendTest, VertexBufferUpdate) {
     // executeCommands().
     {
         auto& api = getDriverApi();
+        Cleanup cleanup(api);
 
         // Create a platform-specific SwapChain and make it current.
-        auto swapChain = createSwapChain();
+        auto swapChain = cleanup.add(createSwapChain());
         api.makeCurrent(swapChain, swapChain);
 
-        // Create a program.
-        filamat::DescriptorSets descriptors;
-        descriptors[1] = { { "Params",
-                { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::FRAGMENT, 0 }, {} } };
-        ShaderGenerator shaderGen(
-                vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
-        Program p = shaderGen.getProgram(api);
-        p.descriptorBindings(1, {{ "Params", DescriptorType::UNIFORM_BUFFER, 0 }});
-        auto program = api.createProgram(std::move(p));
+        Shader shader = createShader();
 
-        DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
-                {{
-                         DescriptorType::UNIFORM_BUFFER,
-                         ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
-                         DescriptorFlags::NONE, 0
-                 }}});
-
-        DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);
-
-        auto defaultRenderTarget = api.createDefaultRenderTarget(0);
+        auto defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
 
         // To test large buffers (which exercise a different code path) create an extra large
         // buffer. Only the first 3 vertices will be used.
@@ -128,38 +134,29 @@ TEST_F(BackendTest, VertexBufferUpdate) {
         params.flags.discardEnd = TargetBufferFlags::NONE;
 
         PipelineState state;
-        state.program = program;
-        state.pipelineLayout.setLayout[1] = { descriptorSetLayout };
+        state.program = shader.getProgram();
+        state.pipelineLayout.setLayout[1] = { shader.getDescriptorSetLayout() };
         state.rasterState.colorWrite = true;
         state.rasterState.depthWrite = false;
         state.rasterState.depthFunc = RasterState::DepthFunc::A;
         state.rasterState.culling = CullingMode::NONE;
 
         // 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 = api.createBufferObject(sizeof(MaterialParams) + 64,
-                BufferObjectBinding::UNIFORM, BufferUsage::STATIC);
+        // 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,
+                BufferObjectBinding::UNIFORM, BufferUsage::STATIC));
 
-        api.updateDescriptorSetBuffer(descriptorSet, 0, ubuffer, 0, sizeof(MaterialParams) + 64);
-        api.bindDescriptorSet(descriptorSet, 1, {});
+        shader.bindUniform<MaterialParams>(api, ubuffer, kBindingConfig);
 
         api.startCapture(0);
 
-        // Upload uniforms.
-        {
-            MaterialParams params {
-                    .color = { 1.0f, 1.0f, 1.0f, 1.0f },
-                    .offset = { 0.0f, 0.0f, 0.0f, 0.0f }
-            };
-            auto* tmp = new MaterialParams(params);
-            auto cb = [](void* buffer, size_t size, void* user) {
-                auto* sp = (MaterialParams*) buffer;
-                delete sp;
-            };
-            BufferDescriptor bd(tmp, sizeof(MaterialParams), cb);
-            api.updateBufferObject(ubuffer, std::move(bd), 64);
-        }
+        // Upload the uniform, but with an offset to accommodate the padding in the shader's
+        // uniform definition.
+        shader.uploadUniform(api, ubuffer, kBindingConfig, MaterialParams{
+                .color = { 1.0f, 1.0f, 1.0f, 1.0f },
+                .offset = { 0.0f, 0.0f, 0.0f, 0.0f }
+        });
 
         api.makeCurrent(swapChain, swapChain);
         api.beginFrame(0, 0, 0);
@@ -202,13 +199,6 @@ TEST_F(BackendTest, VertexBufferUpdate) {
         api.endFrame(0);
 
         api.stopCapture(0);
-
-        api.destroyProgram(program);
-        api.destroySwapChain(swapChain);
-        api.destroyDescriptorSet(descriptorSet);
-        api.destroyDescriptorSetLayout(descriptorSetLayout);
-        api.destroyBufferObject(ubuffer);
-        api.destroyRenderTarget(defaultRenderTarget);
     }
 
     executeCommands();
@@ -216,62 +206,38 @@ TEST_F(BackendTest, VertexBufferUpdate) {
 
 // This test renders two triangles in two separate draw calls. Between the draw calls, a uniform
 // buffer object is partially updated.
-TEST_F(BackendTest, BufferObjectUpdateWithOffset) {
+TEST_F(BufferUpdatesTest, BufferObjectUpdateWithOffset) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
 
     // Create a platform-specific SwapChain and make it current.
-    auto swapChain = createSwapChain();
+    auto swapChain = cleanup.add(createSwapChain());
     api.makeCurrent(swapChain, swapChain);
 
     // Create a program.
-    filamat::DescriptorSets descriptors;
-    descriptors[1] = { { "Params",
-            { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::FRAGMENT, 0 }, {} } };
-    ShaderGenerator shaderGen(
-            vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
-    Program p = shaderGen.getProgram(api);
-    p.descriptorBindings(1, {{ "Params", DescriptorType::UNIFORM_BUFFER, 0 }});
-    auto program = api.createProgram(std::move(p));
-
-    DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
-            {{
-                     DescriptorType::UNIFORM_BUFFER,
-                     ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
-                     DescriptorFlags::NONE, 0
-             }}});
-
-    DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);
-
+    Shader shader = createShader();
 
     // 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 = api.createBufferObject(sizeof(MaterialParams) + 64,
-            BufferObjectBinding::UNIFORM, BufferUsage::STATIC);
+    auto ubuffer = cleanup.add(api.createBufferObject(sizeof(MaterialParams) + 64,
+            BufferObjectBinding::UNIFORM, BufferUsage::STATIC));
 
-    api.updateDescriptorSetBuffer(descriptorSet, 0, ubuffer, 0, sizeof(MaterialParams) + 64);
-    api.bindDescriptorSet(descriptorSet, 1, {});
+    shader.bindUniform<MaterialParams>(api, ubuffer, kBindingConfig);
 
     // Create a render target.
-    auto colorTexture = api.createTexture(SamplerType::SAMPLER_2D, 1,
-            TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT);
-    auto renderTarget = api.createRenderTarget(
-            TargetBufferFlags::COLOR0, 512, 512, 1, 0, {{colorTexture}}, {}, {});
+    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}}, {}, {}));
 
     // Upload uniforms for the first triangle.
-    {
-        MaterialParams params {
+    // Upload the uniform, but with an offset to accommodate the padding in the shader's
+    // uniform definition.
+    shader.uploadUniform(api, ubuffer, kBindingConfig, MaterialParams{
             .color = { 1.0f, 0.0f, 0.5f, 1.0f },
             .offset = { 0.0f, 0.0f, 0.0f, 0.0f }
-        };
-        auto* tmp = new MaterialParams(params);
-        auto cb = [](void* buffer, size_t size, void* user) {
-            auto* sp = (MaterialParams*) buffer;
-            delete sp;
-        };
-        BufferDescriptor bd(tmp, sizeof(MaterialParams), cb);
-        api.updateBufferObject(ubuffer, std::move(bd), 64);
-    }
+    });
 
     RenderPassParams params = {};
     params.flags.clear = TargetBufferFlags::COLOR;
@@ -280,29 +246,27 @@ TEST_F(BackendTest, BufferObjectUpdateWithOffset) {
     params.flags.discardEnd = TargetBufferFlags::NONE;
     params.viewport.height = 512;
     params.viewport.width = 512;
-    renderTriangle({{ DescriptorSetLayoutHandle{}, descriptorSetLayout }},
-            renderTarget, swapChain, program, params);
+    renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
+            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.
-    {
-        MaterialParams params {
-                .color = { 1.0f, 0.0f, 1.0f, 1.0f },
-                .offset = { 0.5f, 0.5f, 0.0f, 0.0f }
-        };
-        auto* tmp = new MaterialParams(params);
-        auto cb = [](void* buffer, size_t size, void* user) {
-            auto* sp = (MaterialParams*) ((char*)buffer - offsetof(MaterialParams, color.b));
-            delete sp;
-        };
-        BufferDescriptor bd((char*)tmp + offsetof(MaterialParams, color.b), sizeof(float) * 4, cb);
-        api.updateBufferObject(ubuffer, std::move(bd), 64 + offsetof(MaterialParams, color.b));
-    }
+    shader.uploadUniform(api, ubuffer, UniformBindingConfig{
+                    .dataSize = sizeof(std::array<float, 4>),
+                    .bufferSize = kBindingConfig.bufferSize,
+                    .byteOffset = *kBindingConfig.byteOffset + offsetof(MaterialParams, color.b),
+            },
+            std::array<float, 4>{
+                    // color.b, color.a
+                    1.0f, 1.0f,
+                    // offset.x, offset.y
+                    0.5f, 0.5f }
+    );
 
     params.flags.clear = TargetBufferFlags::NONE;
     params.flags.discardStart = TargetBufferFlags::NONE;
-    renderTriangle({{ DescriptorSetLayoutHandle{}, descriptorSetLayout }},
-            renderTarget, swapChain, program, params);
+    renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
+            renderTarget, swapChain, shader.getProgram(), params);
 
     static const uint32_t expectedHash = 91322442;
     readPixelsAndAssertHash(
@@ -312,14 +276,6 @@ TEST_F(BackendTest, BufferObjectUpdateWithOffset) {
     api.commit(swapChain);
     api.endFrame(0);
 
-    api.destroyProgram(program);
-    api.destroySwapChain(swapChain);
-    api.destroyDescriptorSet(descriptorSet);
-    api.destroyDescriptorSetLayout(descriptorSetLayout);
-    api.destroyBufferObject(ubuffer);
-    api.destroyRenderTarget(renderTarget);
-    api.destroyTexture(colorTexture);
-
     // This ensures all driver commands have finished before exiting the test.
     api.finish();
 

filament/backend/test/test_Callbacks.cpp

@@ -16,6 +16,8 @@
 
 #include "BackendTest.h"
 
+#include "Lifetimes.h"
+
 using namespace filament;
 using namespace filament::backend;
 
@@ -23,13 +25,14 @@ namespace test {
 
 TEST_F(BackendTest, FrameScheduledCallback) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
 
     // Create a SwapChain.
     // In order for the frameScheduledCallback to be called, this must be a real SwapChain (not
     // headless) so we obtain a drawable.
-    auto swapChain = createSwapChain();
+    auto swapChain = cleanup.add(createSwapChain());
 
-    Handle<HwRenderTarget> renderTarget = api.createDefaultRenderTarget();
+    Handle<HwRenderTarget> renderTarget = cleanup.add(api.createDefaultRenderTarget());
 
     int callbackCountA = 0;
     api.setFrameScheduledCallback(swapChain, nullptr, [&callbackCountA](PresentCallable callable) {
@@ -79,9 +82,10 @@ TEST_F(BackendTest, FrameScheduledCallback) {
 
 TEST_F(BackendTest, FrameCompletedCallback) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
 
     // Create a SwapChain.
-    auto swapChain = api.createSwapChainHeadless(256, 256, 0);
+    auto swapChain = cleanup.add(api.createSwapChainHeadless(256, 256, 0));
 
     int callbackCountA = 0;
     api.setFrameCompletedCallback(swapChain, nullptr,

filament/backend/test/test_FeedbackLoops.cpp

@@ -16,6 +16,7 @@
 
 #include "BackendTest.h"
 
+#include "Lifetimes.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
 
@@ -129,12 +130,13 @@ static void dumpScreenshot(DriverApi& dapi, Handle<HwRenderTarget> rt) {
 // backend's readPixels does not work correctly with textures that have image data uploaded.
 TEST_F(BackendTest, FeedbackLoops) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
 
     // The test is executed within this block scope to force destructors to run before
     // executeCommands().
     {
         // Create a platform-specific SwapChain and make it current.
-        auto swapChain = createSwapChain();
+        auto swapChain = cleanup.add(createSwapChain());
         api.makeCurrent(swapChain, swapChain);
 
         // Create a program.
@@ -155,10 +157,10 @@ TEST_F(BackendTest, FeedbackLoops) {
                     { "test_tex", DescriptorType::SAMPLER, 0 },
                     { "Params", DescriptorType::UNIFORM_BUFFER, 1 }
             });
-            program = api.createProgram(std::move(prog));
+            program = cleanup.add(api.createProgram(std::move(prog)));
         }
 
-        DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
+        DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
                 {{
                          DescriptorType::SAMPLER,
                          ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
@@ -168,27 +170,27 @@ TEST_F(BackendTest, FeedbackLoops) {
                          DescriptorType::UNIFORM_BUFFER,
                          ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 1,
                          DescriptorFlags::NONE, 0
-                 }}});
+                 }}}));
 
 
         TrianglePrimitive const triangle(getDriverApi());
 
         // Create a texture.
         auto usage = TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE;
-        Handle<HwTexture> const texture = api.createTexture(
-            SamplerType::SAMPLER_2D, kNumLevels, kTexFormat, 1, kTexWidth, kTexHeight, 1, usage);
+        Handle<HwTexture> const texture = cleanup.add(api.createTexture(
+            SamplerType::SAMPLER_2D, kNumLevels, kTexFormat, 1, kTexWidth, kTexHeight, 1, usage));
 
         // Create ubo
-        auto ubuffer = api.createBufferObject(sizeof(MaterialParams),
-                BufferObjectBinding::UNIFORM, BufferUsage::STATIC);
+        auto ubuffer = cleanup.add(api.createBufferObject(sizeof(MaterialParams),
+                BufferObjectBinding::UNIFORM, BufferUsage::STATIC));
 
         // Create a RenderTarget for each miplevel.
         Handle<HwRenderTarget> renderTargets[kNumLevels];
         for (uint8_t level = 0; level < kNumLevels; level++) {
             slog.i << "Level " << int(level) << ": " <<
                     (kTexWidth >> level) << "x" << (kTexHeight >> level) << io::endl;
-            renderTargets[level] = api.createRenderTarget( TargetBufferFlags::COLOR,
-                    kTexWidth >> level, kTexHeight >> level, 1, 0, { texture, level, 0 }, {}, {});
+            renderTargets[level] = cleanup.add(api.createRenderTarget( TargetBufferFlags::COLOR,
+                    kTexWidth >> level, kTexHeight >> level, 1, 0, { texture, level, 0 }, {}, {}));
         }
 
         // Fill the base level of the texture with interesting colors.
@@ -226,12 +228,13 @@ TEST_F(BackendTest, FeedbackLoops) {
             params.flags.discardStart = TargetBufferFlags::ALL;
             state.rasterState.disableBlending();
             for (int targetLevel = 1; targetLevel < kNumLevels; targetLevel++) {
+                Cleanup passCleanup(api);
                 const uint32_t sourceLevel = targetLevel - 1;
                 params.viewport.width = kTexWidth >> targetLevel;
                 params.viewport.height = kTexHeight >> targetLevel;
 
-                auto textureView = api.createTextureView(texture, sourceLevel, 1);
-                DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);
+                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
@@ -247,8 +250,6 @@ TEST_F(BackendTest, FeedbackLoops) {
                 api.beginRenderPass(renderTargets[targetLevel], params);
                 api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
                 api.endRenderPass();
-                api.destroyTexture(textureView);
-                api.destroyDescriptorSet(descriptorSet);
             }
 
             // Upsample passes
@@ -256,12 +257,13 @@ TEST_F(BackendTest, FeedbackLoops) {
             state.rasterState.blendFunctionSrcRGB = BlendFunction::ONE;
             state.rasterState.blendFunctionDstRGB = BlendFunction::ONE;
             for (int targetLevel = kNumLevels - 2; targetLevel >= 0; targetLevel--) {
+                Cleanup passCleanup(api);
                 const uint32_t sourceLevel = targetLevel + 1;
                 params.viewport.width = kTexWidth >> targetLevel;
                 params.viewport.height = kTexHeight >> targetLevel;
 
-                auto textureView = api.createTextureView(texture, sourceLevel, 1);
-                DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);
+                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
@@ -277,8 +279,6 @@ TEST_F(BackendTest, FeedbackLoops) {
                 api.beginRenderPass(renderTargets[targetLevel], params);
                 api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
                 api.endRenderPass();
-                api.destroyTexture(textureView);
-                api.destroyDescriptorSet(descriptorSet);
             }
 
             // Read back the render target corresponding to the base level.
@@ -296,15 +296,6 @@ TEST_F(BackendTest, FeedbackLoops) {
             executeCommands();
             getDriver().purge();
         }
-
-        api.destroyDescriptorSetLayout(descriptorSetLayout);
-        api.destroyProgram(program);
-        api.destroySwapChain(swapChain);
-        api.destroyTexture(texture);
-        api.destroyBufferObject(ubuffer);
-        for (auto rt : renderTargets)  {
-            api.destroyRenderTarget(rt);
-        }
     }
 
     const uint32_t expected = 0x70695aa1;

filament/backend/test/test_LoadImage.cpp

@@ -16,9 +16,10 @@
 
 #include "BackendTest.h"
 
+#include "BackendTestUtils.h"
+#include "Lifetimes.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
-#include "BackendTestUtils.h"
 
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>
@@ -295,10 +296,12 @@ TEST_F(BackendTest, UpdateImage2D) {
     // The test is executed within this block scope to force destructors to run before
     // executeCommands().
     for (const auto& t : testCases) {
+        Cleanup cleanup(api);
+
         // 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,
@@ -315,21 +318,21 @@ TEST_F(BackendTest, UpdateImage2D) {
         Program prog = shaderGen.getProgram(api);
         prog.descriptorBindings(1, {{"test_tex", DescriptorType::SAMPLER, 0}});
 
-        ProgramHandle const program = api.createProgram(std::move(prog));
+        ProgramHandle const program = cleanup.add(api.createProgram(std::move(prog)));
 
-        DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
+        DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
                 {{
                          DescriptorType::SAMPLER,
                          ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
                          DescriptorFlags::NONE, 0
-                 }}});
+                 }}}));
 
-        DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);
+        DescriptorSetHandle descriptorSet = cleanup.add(api.createDescriptorSet(descriptorSetLayout));
 
         // Create a Texture.
         auto usage = TextureUsage::SAMPLEABLE | TextureUsage::UPLOADABLE;
-        Handle<HwTexture> const texture = api.createTexture(SamplerType::SAMPLER_2D, 1,
-                t.textureFormat, 1, 512, 512, 1u, usage);
+        Handle<HwTexture> const texture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
+                t.textureFormat, 1, 512, 512, 1u, usage));
 
         // Upload some pixel data.
         if (t.uploadSubregions) {
@@ -359,13 +362,6 @@ TEST_F(BackendTest, UpdateImage2D) {
 
         api.commit(swapChain);
         api.endFrame(0);
-
-        api.destroyDescriptorSet(descriptorSet);
-        api.destroyDescriptorSetLayout(descriptorSetLayout);
-        api.destroyProgram(program);
-        api.destroySwapChain(swapChain);
-        api.destroyRenderTarget(defaultRenderTarget);
-        api.destroyTexture(texture);
     }
 
     api.finish();

filament/backend/test/test_MRT.cpp

@@ -16,6 +16,7 @@
 
 #include "BackendTest.h"
 
+#include "Lifetimes.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
 
@@ -60,25 +61,28 @@ using namespace filament;
 using namespace filament::backend;
 
 TEST_F(BackendTest, MRT) {
+    DriverApi& api = getDriverApi();
+    Cleanup cleanup(api);
+
     // The test is executed within this block scope to force destructors to run before
     // executeCommands().
     {
         // Create a platform-specific SwapChain and make it current.
-        auto swapChain = createSwapChain();
-        getDriverApi().makeCurrent(swapChain, swapChain);
+        auto swapChain = cleanup.add(createSwapChain());
+        api.makeCurrent(swapChain, swapChain);
 
         // Create a program.
         ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);
-        Program p = shaderGen.getProgram(getDriverApi());
-        auto program = getDriverApi().createProgram(std::move(p));
+        Program p = shaderGen.getProgram(api);
+        auto program = cleanup.add(api.createProgram(std::move(p)));
 
-        TrianglePrimitive triangle(getDriverApi());
+        TrianglePrimitive triangle(api);
 
-        auto defaultRenderTarget = getDriverApi().createDefaultRenderTarget(0);
+        auto defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
 
         // Create two Textures.
         auto usage = TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE;
-        Handle<HwTexture> textureA = getDriverApi().createTexture(
+        Handle<HwTexture> textureA = cleanup.add(api.createTexture(
                     SamplerType::SAMPLER_2D,            // target
                     1,                                  // levels
                     TextureFormat::RGBA8,               // format
@@ -86,8 +90,8 @@ TEST_F(BackendTest, MRT) {
                     512,                                // width
                     512,                                // height
                     1,                                  // depth
-                    usage);                             // usage
-        Handle<HwTexture> textureB = getDriverApi().createTexture(
+                    usage));                             // usage
+        Handle<HwTexture> textureB = cleanup.add(api.createTexture(
                     SamplerType::SAMPLER_2D,            // target
                     1,                                  // levels
                     TextureFormat::RGBA8,               // format
@@ -95,10 +99,10 @@ TEST_F(BackendTest, MRT) {
                     512,                                // width
                     512,                                // height
                     1,                                  // depth
-                    usage);                             // usage
+                    usage));                             // usage
 
         // Create a RenderTarget with two attachments.
-        Handle<HwRenderTarget> renderTarget = getDriverApi().createRenderTarget(
+        Handle<HwRenderTarget> renderTarget = cleanup.add(api.createRenderTarget(
                 TargetBufferFlags::COLOR0 | TargetBufferFlags::COLOR1,
                 // The width and height must match the width and height of the respective mip
                 // level (at least for OpenGL).
@@ -108,7 +112,7 @@ TEST_F(BackendTest, MRT) {
                 0,                                         // layerCount
                 {{textureA },{textureB }},                 // color
                 {},                                        // depth
-                {});                                       // stencil
+                {}));                                       // stencil
 
         RenderPassParams params = {};
         fullViewport(params);
@@ -124,25 +128,21 @@ TEST_F(BackendTest, MRT) {
         state.rasterState.depthFunc = RasterState::DepthFunc::A;
         state.rasterState.culling = CullingMode::NONE;
 
-        getDriverApi().startCapture(0);
+        api.startCapture(0);
 
-        getDriverApi().makeCurrent(swapChain, swapChain);
-        getDriverApi().beginFrame(0, 0, 0);
+        api.makeCurrent(swapChain, swapChain);
+        api.beginFrame(0, 0, 0);
 
         // Draw a triangle.
-        getDriverApi().beginRenderPass(renderTarget, params);
-        getDriverApi().draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
-        getDriverApi().endRenderPass();
+        api.beginRenderPass(renderTarget, params);
+        api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
+        api.endRenderPass();
 
-        getDriverApi().flush();
-        getDriverApi().commit(swapChain);
-        getDriverApi().endFrame(0);
+        api.flush();
+        api.commit(swapChain);
+        api.endFrame(0);
 
-        getDriverApi().stopCapture(0);
-
-        getDriverApi().destroyProgram(program);
-        getDriverApi().destroySwapChain(swapChain);
-        getDriverApi().destroyRenderTarget(defaultRenderTarget);
+        api.stopCapture(0);
     }
 
     executeCommands();

filament/backend/test/test_MipLevels.cpp

@@ -17,9 +17,10 @@
 
 #include "BackendTest.h"
 
+#include "BackendTestUtils.h"
+#include "Lifetimes.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
-#include "BackendTestUtils.h"
 
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>
@@ -78,12 +79,13 @@ using namespace filament::backend;
 TEST_F(BackendTest, TextureViewLod) {
     auto& api = getDriverApi();
     api.startCapture(0);
+    Cleanup cleanup(api);
 
     // The test is executed within this block scope to force destructors to run before
     // executeCommands().
     {
         // Create a SwapChain and make it current.
-        auto swapChain = createSwapChain();
+        auto swapChain = cleanup.add(createSwapChain());
         api.makeCurrent(swapChain, swapChain);
 
         // Create a program that draws only white.
@@ -92,7 +94,7 @@ TEST_F(BackendTest, TextureViewLod) {
             ShaderGenerator shaderGen(vertex, whiteFragment, sBackend, sIsMobilePlatform);
             Program p = shaderGen.getProgram(api);
             p.descriptorBindings(0, {{"backend_test_sib_tex", DescriptorType::SAMPLER, 0}});
-            whiteProgram = api.createProgram(std::move(p));
+            whiteProgram = cleanup.add(api.createProgram(std::move(p)));
         }
 
         // Create a program that samples a texture.
@@ -106,19 +108,19 @@ TEST_F(BackendTest, TextureViewLod) {
             ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform, std::move(descriptors));
             Program p = shaderGen.getProgram(api);
             p.descriptorBindings(0, {{"backend_test_sib_tex", DescriptorType::SAMPLER, 0}});
-            textureProgram = api.createProgram(std::move(p));
+            textureProgram = cleanup.add(api.createProgram(std::move(p)));
         }
 
-        DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
+        DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
                 {{
                          DescriptorType::SAMPLER,
                          ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
                          DescriptorFlags::NONE, 0
-                 }}});
+                 }}}));
 
         DescriptorSetHandle descriptorSet[2];
-        descriptorSet[0] = api.createDescriptorSet(descriptorSetLayout);
-        descriptorSet[1] = api.createDescriptorSet(descriptorSetLayout);
+        descriptorSet[0] = cleanup.add(api.createDescriptorSet(descriptorSetLayout));
+        descriptorSet[1] = cleanup.add(api.createDescriptorSet(descriptorSetLayout));
 
         // Create a texture that has 4 mip levels. Each level is a different color.
         // Level 0: 128x128 (red)
@@ -127,9 +129,9 @@ TEST_F(BackendTest, TextureViewLod) {
         // Level 3:   16x16 (yellow)
         const size_t kTextureSize = 128;
         const size_t kMipLevels = 4;
-        Handle<HwTexture> texture = api.createTexture(SamplerType::SAMPLER_2D, kMipLevels,
+        Handle<HwTexture> texture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, kMipLevels,
                 TextureFormat::RGBA8, 1, kTextureSize, kTextureSize, 1,
-                TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT | TextureUsage::UPLOADABLE);
+                TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT | TextureUsage::UPLOADABLE));
 
         // Create image data.
         auto pixelFormat = PixelDataFormat::RGBA;
@@ -163,13 +165,13 @@ TEST_F(BackendTest, TextureViewLod) {
         // Level 1:   64x64 (green)             <-- base
         // Level 2:   32x32 (blue)              <--- white triangle rendered
         // Level 3:   16x16 (yellow)            <-- max
-        auto texture13 = api.createTextureView(texture, 1, 3);
+        auto texture13 = cleanup.add(api.createTextureView(texture, 1, 3));
 
         // Render a white triangle into level 2.
         // We specify mip level 2, because minMaxLevels has no effect when rendering into a texture.
-        Handle<HwRenderTarget> renderTarget = api.createRenderTarget(
+        Handle<HwRenderTarget> renderTarget = cleanup.add(api.createRenderTarget(
                 TargetBufferFlags::COLOR, 32, 32, 1, 0,
-                {texture, 2 /* level */, 0 /* layer */}, {}, {});
+                {texture, 2 /* level */, 0 /* layer */}, {}, {}));
         {
             RenderPassParams params = {};
             fullViewport(params);
@@ -185,7 +187,7 @@ TEST_F(BackendTest, TextureViewLod) {
             api.endRenderPass();
         }
 
-        backend::Handle<HwRenderTarget> defaultRenderTarget = api.createDefaultRenderTarget(0);
+        backend::Handle<HwRenderTarget> defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
 
         RenderPassParams params = {};
         fullViewport(params);
@@ -217,7 +219,7 @@ TEST_F(BackendTest, TextureViewLod) {
         api.endRenderPass();
 
         // Adjust the base mip to 2.
-        auto texture22 = api.createTextureView(texture, 2, 2);
+        auto texture22 = cleanup.add(api.createTextureView(texture, 2, 2));
 
         api.updateDescriptorSetTexture(descriptorSet[1], 0, texture22, {
                 .filterMag = SamplerMagFilter::NEAREST,
@@ -244,18 +246,6 @@ TEST_F(BackendTest, TextureViewLod) {
         api.endFrame(0);
 
         api.stopCapture(0);
-
-        // Cleanup.
-        api.destroySwapChain(swapChain);
-        api.destroyRenderTarget(renderTarget);
-        api.destroyDescriptorSet(descriptorSet[0]);
-        api.destroyDescriptorSet(descriptorSet[1]);
-        api.destroyDescriptorSetLayout(descriptorSetLayout);
-        api.destroyTexture(texture);
-        api.destroyTexture(texture13);
-        api.destroyTexture(texture22);
-        api.destroyProgram(whiteProgram);
-        api.destroyProgram(textureProgram);
     }
 
     api.finish();

filament/backend/test/test_MissingRequiredAttributes.cpp

@@ -16,6 +16,7 @@
 
 #include "BackendTest.h"
 
+#include "Lifetimes.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
 
@@ -70,18 +71,20 @@ TEST_F(BackendTest, MissingRequiredAttributes) {
     // The test is executed within this block scope to force destructors to run before
     // executeCommands().
     {
+        DriverApi& api = getDriverApi();
+        Cleanup cleanup(api);
         // Create a platform-specific SwapChain and make it current.
-        auto swapChain = createSwapChain();
-        getDriverApi().makeCurrent(swapChain, swapChain);
+        auto swapChain = cleanup.add(createSwapChain());
+        api.makeCurrent(swapChain, swapChain);
 
         // Create a program.
         ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);
-        Program p = shaderGen.getProgram(getDriverApi());
-        auto program = getDriverApi().createProgram(std::move(p));
+        Program p = shaderGen.getProgram(api);
+        auto program = cleanup.add(api.createProgram(std::move(p)));
 
-        auto defaultRenderTarget = getDriverApi().createDefaultRenderTarget(0);
+        auto defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
 
-        TrianglePrimitive triangle(getDriverApi());
+        TrianglePrimitive triangle(api);
 
         RenderPassParams params = {};
         fullViewport(params);
@@ -97,25 +100,21 @@ TEST_F(BackendTest, MissingRequiredAttributes) {
         state.rasterState.depthFunc = RasterState::DepthFunc::A;
         state.rasterState.culling = CullingMode::NONE;
 
-        getDriverApi().startCapture(0);
+        api.startCapture(0);
 
-        getDriverApi().makeCurrent(swapChain, swapChain);
-        getDriverApi().beginFrame(0, 0, 0);
+        api.makeCurrent(swapChain, swapChain);
+        api.beginFrame(0, 0, 0);
 
         // Render a triangle.
-        getDriverApi().beginRenderPass(defaultRenderTarget, params);
-        getDriverApi().draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
-        getDriverApi().endRenderPass();
+        api.beginRenderPass(defaultRenderTarget, params);
+        api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
+        api.endRenderPass();
 
-        getDriverApi().flush();
-        getDriverApi().commit(swapChain);
-        getDriverApi().endFrame(0);
+        api.flush();
+        api.commit(swapChain);
+        api.endFrame(0);
 
-        getDriverApi().stopCapture(0);
-
-        getDriverApi().destroyProgram(program);
-        getDriverApi().destroySwapChain(swapChain);
-        getDriverApi().destroyRenderTarget(defaultRenderTarget);
+        api.stopCapture(0);
     }
 
     executeCommands();

filament/backend/test/test_PushConstants.cpp

@@ -16,6 +16,7 @@
 
 #include "BackendTest.h"
 
+#include "Lifetimes.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
 
@@ -80,20 +81,21 @@ TEST_F(BackendTest, PushConstants) {
     auto& api = getDriverApi();
 
     api.startCapture(0);
+    Cleanup cleanup(api);
 
     // The test is executed within this block scope to force destructors to run before
     // executeCommands().
     {
         // Create a SwapChain and make it current.
-        auto swapChain = createSwapChain();
+        auto swapChain = cleanup.add(createSwapChain());
         api.makeCurrent(swapChain, swapChain);
 
         // Create a program.
         ShaderGenerator shaderGen(triangleVs, triangleFs, sBackend, sIsMobilePlatform);
         Program p = shaderGen.getProgram(api);
-        ProgramHandle program = api.createProgram(std::move(p));
+        ProgramHandle program = cleanup.add(api.createProgram(std::move(p)));
 
-        Handle<HwRenderTarget> renderTarget = api.createDefaultRenderTarget();
+        Handle<HwRenderTarget> renderTarget = cleanup.add(api.createDefaultRenderTarget());
 
         TrianglePrimitive triangle(api);
 
@@ -150,10 +152,6 @@ TEST_F(BackendTest, PushConstants) {
 
         api.commit(swapChain);
         api.endFrame(0);
-
-        // Cleanup.
-        api.destroySwapChain(swapChain);
-        api.destroyRenderTarget(renderTarget);
     }
 
     api.stopCapture(0);

filament/backend/test/test_ReadPixels.cpp

@@ -16,9 +16,10 @@
 
 #include "BackendTest.h"
 
+#include "BackendTestUtils.h"
+#include "Lifetimes.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
-#include "BackendTestUtils.h"
 
 #include <utils/Hash.h>
 
@@ -236,17 +237,20 @@ TEST_F(ReadPixelsTest, ReadPixels) {
 
     TestCase const testCases[] = { t0, t2, t3, t4, t5, t6, t7, t8 };
 
+    DriverApi& api = getDriverApi();
+    Cleanup cleanup(api);
+
     // Create programs.
     Handle<HwProgram> programFloat, programUint;
     {
         ShaderGenerator shaderGen(vertex, fragmentFloat, sBackend, sIsMobilePlatform);
-        Program p = shaderGen.getProgram(getDriverApi());
-        programFloat = getDriverApi().createProgram(std::move(p));
+        Program p = shaderGen.getProgram(api);
+        programFloat = cleanup.add(api.createProgram(std::move(p)));
     }
     {
         ShaderGenerator shaderGen(vertex, fragmentUint, sBackend, sIsMobilePlatform);
-        Program p = shaderGen.getProgram(getDriverApi());
-        programUint = getDriverApi().createProgram(std::move(p));
+        Program p = shaderGen.getProgram(api);
+        programUint = cleanup.add(api.createProgram(std::move(p)));
     }
 
 
@@ -255,35 +259,35 @@ TEST_F(ReadPixelsTest, ReadPixels) {
         // Create a platform-specific SwapChain and make it current.
         Handle<HwSwapChain> swapChain;
         if (t.useDefaultRT) {
-            swapChain = createSwapChain();
+            swapChain = cleanup.add(createSwapChain());
         } else {
-            swapChain = getDriverApi().createSwapChainHeadless(t.getRenderTargetSize(),
-                    t.getRenderTargetSize(), 0);
+            swapChain = cleanup.add(api.createSwapChainHeadless(t.getRenderTargetSize(),
+                    t.getRenderTargetSize(), 0));
         }
 
-        getDriverApi().makeCurrent(swapChain, swapChain);
+        api.makeCurrent(swapChain, swapChain);
 
         // Create a Texture and RenderTarget to render into.
         auto usage = TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE;
-        Handle<HwTexture> const texture = getDriverApi().createTexture(SamplerType::SAMPLER_2D,
+        Handle<HwTexture> const texture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D,
                 t.mipLevels, t.textureFormat, 1, renderTargetBaseSize, renderTargetBaseSize, 1,
-                usage);
+                usage));
 
         Handle<HwRenderTarget> renderTarget;
         if (t.useDefaultRT) {
             // The width and height must match the width and height of the respective mip
             // level (at least for OpenGL).
-            renderTarget = getDriverApi().createDefaultRenderTarget();
+            renderTarget = cleanup.add(api.createDefaultRenderTarget());
         } else {
             // The width and height must match the width and height of the respective mip
             // level (at least for OpenGL).
-            renderTarget = getDriverApi().createRenderTarget(
+            renderTarget = cleanup.add(api.createRenderTarget(
                     TargetBufferFlags::COLOR, t.getRenderTargetSize(),
                     t.getRenderTargetSize(), t.samples, 0, {{ texture, uint8_t(t.mipLevel) }}, {},
-                    {});
+                    {}));
         }
 
-        TrianglePrimitive const triangle(getDriverApi());
+        TrianglePrimitive const triangle(api);
 
         RenderPassParams params = {};
         fullViewport(params);
@@ -294,11 +298,11 @@ TEST_F(ReadPixelsTest, ReadPixels) {
         params.viewport.height = t.getRenderTargetSize();
         params.viewport.width = t.getRenderTargetSize();
 
-        getDriverApi().makeCurrent(swapChain, swapChain);
-        getDriverApi().beginFrame(0, 0, 0);
+        api.makeCurrent(swapChain, swapChain);
+        api.beginFrame(0, 0, 0);
 
         // Render a white triangle over blue.
-        getDriverApi().beginRenderPass(renderTarget, params);
+        api.beginRenderPass(renderTarget, params);
 
         PipelineState state;
         state.program = programFloat;
@@ -309,21 +313,21 @@ TEST_F(ReadPixelsTest, ReadPixels) {
         state.rasterState.depthWrite = false;
         state.rasterState.depthFunc = RasterState::DepthFunc::A;
         state.rasterState.culling = CullingMode::NONE;
-        getDriverApi().draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
+        api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
 
-        getDriverApi().endRenderPass();
+        api.endRenderPass();
 
         if (t.mipLevel > 0) {
+            Cleanup localCleanup(api);
             // Render red to the first mip level to check that the backend is actually reading the
             // correct mip.
             RenderPassParams p = params;
-            Handle<HwRenderTarget> mipLevelOneRT = getDriverApi().createRenderTarget(
+            Handle<HwRenderTarget> mipLevelOneRT = localCleanup.add(api.createRenderTarget(
                     TargetBufferFlags::COLOR, renderTargetBaseSize, renderTargetBaseSize, 1, 0,
-                    {{ texture }}, {}, {});
+                    {{ texture }}, {}, {}));
             p.clearColor = {1.f, 0.f, 0.f, 1.f};
-            getDriverApi().beginRenderPass(mipLevelOneRT, p);
-            getDriverApi().endRenderPass();
-            getDriverApi().destroyRenderTarget(mipLevelOneRT);
+            api.beginRenderPass(mipLevelOneRT, p);
+            api.endRenderPass();
         }
 
         // Read pixels.
@@ -347,26 +351,19 @@ TEST_F(ReadPixelsTest, ReadPixels) {
                     free(buffer);
                 }, (void*) &t);
 
-        getDriverApi().readPixels(renderTarget, t.readRect.x, t.readRect.y, t.readRect.width,
+        api.readPixels(renderTarget, t.readRect.x, t.readRect.y, t.readRect.width,
                 t.readRect.height, std::move(descriptor));
 
         // Now render red over what was just rendered. This ensures that readPixels captures the
         // state of rendering between render passes.
         params.clearColor = {1.f, 0.f, 0.f, 1.f};
-        getDriverApi().beginRenderPass(renderTarget, params);
-        getDriverApi().endRenderPass();
+        api.beginRenderPass(renderTarget, params);
+        api.endRenderPass();
 
-        getDriverApi().commit(swapChain);
-        getDriverApi().endFrame(0);
-
-        getDriverApi().destroySwapChain(swapChain);
-        getDriverApi().destroyRenderTarget(renderTarget);
-        getDriverApi().destroyTexture(texture);
+        api.commit(swapChain);
+        api.endFrame(0);
     }
 
-    getDriverApi().destroyProgram(programFloat);
-    getDriverApi().destroyProgram(programUint);
-
     // This ensures all driver commands have finished before exiting the test.
     flushAndWait();
 }
@@ -375,18 +372,21 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
     const size_t renderTargetSize = 2000;
     const int iterationCount = 100;
 
+    DriverApi& api = getDriverApi();
+    Cleanup cleanup(api);
+
     // Create a platform-specific SwapChain and make it current.
-    auto swapChain = getDriverApi().createSwapChainHeadless(renderTargetSize, renderTargetSize, 0);
-    getDriverApi().makeCurrent(swapChain, swapChain);
+    auto swapChain = cleanup.add(api.createSwapChainHeadless(renderTargetSize, renderTargetSize, 0));
+    api.makeCurrent(swapChain, swapChain);
 
     // Create a program.
     ShaderGenerator shaderGen(vertex, fragmentFloat, sBackend, sIsMobilePlatform);
-    Program p = shaderGen.getProgram(getDriverApi());
-    auto program = getDriverApi().createProgram(std::move(p));
+    Program p = shaderGen.getProgram(api);
+    auto program = cleanup.add(api.createProgram(std::move(p)));
 
     // Create a Texture and RenderTarget to render into.
     auto usage = TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE;
-    Handle<HwTexture> texture = getDriverApi().createTexture(
+    Handle<HwTexture> texture = cleanup.add(api.createTexture(
                 SamplerType::SAMPLER_2D,            // target
                 1,                                  // levels
                 TextureFormat::RGBA8,               // format
@@ -394,9 +394,9 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
                 renderTargetSize,                   // width
                 renderTargetSize,                   // height
                 1,                                  // depth
-                usage);                             // usage
+                usage));                             // usage
 
-    Handle<HwRenderTarget> renderTarget = getDriverApi().createRenderTarget(
+    Handle<HwRenderTarget> renderTarget = cleanup.add(api.createRenderTarget(
             TargetBufferFlags::COLOR,
             renderTargetSize,                          // width
             renderTargetSize,                          // height
@@ -404,9 +404,9 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
             0,                                         // layerCount
             {{ texture }},                             // color
             {},                                        // depth
-            {});                                       // stencil
+            {}));                                       // stencil
 
-    TrianglePrimitive triangle(getDriverApi());
+    TrianglePrimitive triangle(api);
 
     RenderPassParams params = {};
     fullViewport(params);
@@ -433,13 +433,13 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
             printf("Executing test %d / %d\n", iteration, iterationCount);
         }
 
-        getDriverApi().makeCurrent(swapChain, swapChain);
-        getDriverApi().beginFrame(0, 0, 0);
+        api.makeCurrent(swapChain, swapChain);
+        api.beginFrame(0, 0, 0);
 
         // Render some content, just so we don't read back uninitialized data.
-        getDriverApi().beginRenderPass(renderTarget, params);
-        getDriverApi().draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
-        getDriverApi().endRenderPass();
+        api.beginRenderPass(renderTarget, params);
+        api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
+        api.endRenderPass();
 
         PixelBufferDescriptor descriptor(buffer, renderTargetSize * renderTargetSize * 4,
                 PixelDataFormat::RGBA, PixelDataType::UBYTE, 1, 0, 0, renderTargetSize,
@@ -448,9 +448,9 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
                     test->readPixelsFinished = true;
                 }, this);
 
-        getDriverApi().readPixels(renderTarget, 0, 0, renderTargetSize, renderTargetSize, std::move(descriptor));
-        getDriverApi().commit(swapChain);
-        getDriverApi().endFrame(0);
+        api.readPixels(renderTarget, 0, 0, renderTargetSize, renderTargetSize, std::move(descriptor));
+        api.commit(swapChain);
+        api.endFrame(0);
 
         flushAndWait();
         getDriver().purge();
@@ -460,11 +460,7 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
 
     free(buffer);
 
-    getDriverApi().destroyProgram(program);
-    getDriverApi().destroySwapChain(swapChain);
-    getDriverApi().destroyRenderTarget(renderTarget);
-    getDriverApi().destroyTexture(texture);
-    getDriverApi().finish();
+    api.finish();
     executeCommands();
 }
 

filament/backend/test/test_RenderExternalImage.cpp

@@ -16,6 +16,7 @@
 
 #include "BackendTest.h"
 
+#include "Lifetimes.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
 
@@ -66,10 +67,11 @@ using namespace filament::backend;
 // Rendering an external image without setting any data should not crash.
 TEST_F(BackendTest, RenderExternalImageWithoutSet) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
 
     TrianglePrimitive triangle(api);
 
-    auto swapChain = createSwapChain();
+    auto swapChain = cleanup.add(createSwapChain());
 
     filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
         SamplerType::SAMPLER_EXTERNAL, SamplerFormat::FLOAT, Precision::HIGH, false };
@@ -82,22 +84,22 @@ TEST_F(BackendTest, RenderExternalImageWithoutSet) {
     // Create a program that samples a texture.
     Program p = shaderGen.getProgram(api);
     p.descriptorBindings(1, {{"test_tex", DescriptorType::SAMPLER, 0}});
-    backend::Handle<HwProgram> program = api.createProgram(std::move(p));
-    DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
+    backend::Handle<HwProgram> program = cleanup.add(api.createProgram(std::move(p)));
+    DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
             {{
                      DescriptorType::SAMPLER,
                      ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
                      DescriptorFlags::NONE, 0
-             }}});
+             }}}));
 
-    DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);
+    DescriptorSetHandle descriptorSet = cleanup.add(api.createDescriptorSet(descriptorSetLayout));
 
-    backend::Handle<HwRenderTarget> defaultRenderTarget = api.createDefaultRenderTarget(0);
+    backend::Handle<HwRenderTarget> defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
 
     // Create a texture that will be backed by an external image.
     auto usage = TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE;
     const NativeView& view = getNativeView();
-    backend::Handle<HwTexture> texture = api.createTexture(
+    backend::Handle<HwTexture> texture = cleanup.add(api.createTexture(
                 SamplerType::SAMPLER_EXTERNAL,      // target
                 1,                                  // levels
                 TextureFormat::RGBA8,               // format
@@ -105,7 +107,7 @@ TEST_F(BackendTest, RenderExternalImageWithoutSet) {
                 view.width,                         // width
                 view.height,                        // height
                 1,                                  // depth
-                usage);                             // usage
+                usage));                             // usage
 
     RenderPassParams params = {};
     fullViewport(params);
@@ -140,15 +142,6 @@ TEST_F(BackendTest, RenderExternalImageWithoutSet) {
 
     api.stopCapture(0);
 
-    // Delete our resources.
-    api.destroyDescriptorSet(descriptorSet);
-    api.destroyDescriptorSetLayout(descriptorSetLayout);
-    api.destroyTexture(texture);
-
-    // Destroy frame resources.
-    api.destroyProgram(program);
-    api.destroyRenderTarget(defaultRenderTarget);
-
     api.finish();
 
     executeCommands();
@@ -156,10 +149,11 @@ TEST_F(BackendTest, RenderExternalImageWithoutSet) {
 
 TEST_F(BackendTest, RenderExternalImage) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
 
     TrianglePrimitive triangle(api);
 
-    auto swapChain = createSwapChain();
+    auto swapChain = cleanup.add(createSwapChain());
 
     filament::SamplerInterfaceBlock::SamplerInfo samplerInfo { "test", "tex", 0,
         SamplerType::SAMPLER_EXTERNAL, SamplerFormat::FLOAT, Precision::HIGH, false };
@@ -172,18 +166,18 @@ TEST_F(BackendTest, RenderExternalImage) {
     // Create a program that samples a texture.
     Program p = shaderGen.getProgram(api);
     p.descriptorBindings(1, {{"test_tex", DescriptorType::SAMPLER, 0}});
-    auto program = api.createProgram(std::move(p));
+    auto program = cleanup.add(api.createProgram(std::move(p)));
 
-    DescriptorSetLayoutHandle descriptorSetLayout = api.createDescriptorSetLayout({
+    DescriptorSetLayoutHandle descriptorSetLayout = cleanup.add(api.createDescriptorSetLayout({
             {{
                      DescriptorType::SAMPLER,
                      ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, 0,
                      DescriptorFlags::NONE, 0
-             }}});
+             }}}));
 
-    DescriptorSetHandle descriptorSet = api.createDescriptorSet(descriptorSetLayout);
+    DescriptorSetHandle descriptorSet = cleanup.add(api.createDescriptorSet(descriptorSetLayout));
 
-    backend::Handle<HwRenderTarget> defaultRenderTarget = api.createDefaultRenderTarget(0);
+    backend::Handle<HwRenderTarget> defaultRenderTarget = cleanup.add(api.createDefaultRenderTarget(0));
 
     // require users to create two Filament textures and have two material parameters
     // add a "plane" parameter to setExternalImage
@@ -227,8 +221,8 @@ TEST_F(BackendTest, RenderExternalImage) {
 
     api.setupExternalImage(pixBuffer);
     backend::Handle<HwTexture> texture =
-            api.createTextureExternalImage(SamplerType::SAMPLER_EXTERNAL,
-                    TextureFormat::RGBA8, 1024, 1024, usage, pixBuffer);
+            cleanup.add(api.createTextureExternalImage(SamplerType::SAMPLER_EXTERNAL,
+                    TextureFormat::RGBA8, 1024, 1024, usage, pixBuffer));
 
     // We're now free to release the buffer.
     CVBufferRelease(pixBuffer);
@@ -269,15 +263,6 @@ TEST_F(BackendTest, RenderExternalImage) {
 
     api.stopCapture(0);
 
-    // Delete our resources.
-    api.destroyDescriptorSet(descriptorSet);
-    api.destroyDescriptorSetLayout(descriptorSetLayout);
-    api.destroyTexture(texture);
-
-    // Destroy frame resources.
-    api.destroyProgram(program);
-    api.destroyRenderTarget(defaultRenderTarget);
-
     api.finish();
 
     executeCommands();

filament/backend/test/test_Scissor.cpp

@@ -16,6 +16,7 @@
 
 #include "BackendTest.h"
 
+#include "Lifetimes.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
 
@@ -55,6 +56,7 @@ TEST_F(BackendTest, ScissorViewportRegion) {
     constexpr int kSrcRtHeight = 384;
 
     api.startCapture(0);
+    Cleanup cleanup(api);
 
     //    color texture (mip level 1) 512x512           depth texture (mip level 0) 512x512
     // +----------------------------------------+   +------------------------------------------+
@@ -80,21 +82,21 @@ TEST_F(BackendTest, ScissorViewportRegion) {
     // executeCommands().
     {
         // Create a SwapChain and make it current. We don't really use it so the res doesn't matter.
-        auto swapChain = api.createSwapChainHeadless(256, 256, 0);
+        auto swapChain = cleanup.add(api.createSwapChainHeadless(256, 256, 0));
         api.makeCurrent(swapChain, swapChain);
 
         // Create a program.
         ShaderGenerator shaderGen(triangleVs, triangleFs, sBackend, sIsMobilePlatform);
         Program p = shaderGen.getProgram(api);
-        ProgramHandle program = api.createProgram(std::move(p));
+        ProgramHandle program = cleanup.add(api.createProgram(std::move(p)));
 
         // Create source color and depth textures.
-        Handle<HwTexture> srcTexture = api.createTexture(SamplerType::SAMPLER_2D, kNumLevels,
+        Handle<HwTexture> srcTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, kNumLevels,
                 kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, 1,
-                TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT);
-        Handle<HwTexture> depthTexture = api.createTexture(SamplerType::SAMPLER_2D, 1,
+                TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
+        Handle<HwTexture> depthTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
                 TextureFormat::DEPTH16, 1, 512, 512, 1,
-                TextureUsage::DEPTH_ATTACHMENT);
+                TextureUsage::DEPTH_ATTACHMENT));
 
         // Render into the bottom-left quarter of the texture.
         Viewport srcRect = {
@@ -112,13 +114,13 @@ TEST_F(BackendTest, ScissorViewportRegion) {
 
         // We purposely set the render target width and height to smaller than the texture, to check
         // that this case is handled correctly.
-        Handle<HwRenderTarget> srcRenderTarget = api.createRenderTarget(
+        Handle<HwRenderTarget> srcRenderTarget = cleanup.add(api.createRenderTarget(
                 TargetBufferFlags::COLOR | TargetBufferFlags::DEPTH, kSrcRtHeight, kSrcRtHeight, 1, 0,
-                {srcTexture, kSrcLevel, 0}, {depthTexture, 0, 0}, {});
+                {srcTexture, kSrcLevel, 0}, {depthTexture, 0, 0}, {}));
 
-        Handle<HwRenderTarget> fullRenderTarget = api.createRenderTarget(TargetBufferFlags::COLOR,
+        Handle<HwRenderTarget> fullRenderTarget = cleanup.add(api.createRenderTarget(TargetBufferFlags::COLOR,
                 kSrcTexHeight >> kSrcLevel, kSrcTexWidth >> kSrcLevel, 1, 0,
-                {srcTexture, kSrcLevel, 0}, {}, {});
+                {srcTexture, kSrcLevel, 0}, {}, {}));
 
         TrianglePrimitive triangle(api);
 
@@ -150,11 +152,6 @@ TEST_F(BackendTest, ScissorViewportRegion) {
         api.endFrame(0);
 
         api.stopCapture(0);
-
-        // Cleanup.
-        api.destroyTexture(srcTexture);
-        api.destroySwapChain(swapChain);
-        api.destroyRenderTarget(srcRenderTarget);
     }
 
     // Wait for the ReadPixels result to come back.
@@ -169,23 +166,24 @@ TEST_F(BackendTest, ScissorViewportEdgeCases) {
     auto& api = getDriverApi();
 
     api.startCapture(0);
+    Cleanup cleanup(api);
 
     // The test is executed within this block scope to force destructors to run before
     // executeCommands().
     {
         // Create a SwapChain and make it current. We don't really use it so the res doesn't matter.
-        auto swapChain = api.createSwapChainHeadless(256, 256, 0);
+        auto swapChain = cleanup.add(api.createSwapChainHeadless(256, 256, 0));
         api.makeCurrent(swapChain, swapChain);
 
         // Create a program.
         ShaderGenerator shaderGen(triangleVs, triangleFs, sBackend, sIsMobilePlatform);
         Program p = shaderGen.getProgram(api);
-        ProgramHandle program = api.createProgram(std::move(p));
+        ProgramHandle program = cleanup.add(api.createProgram(std::move(p)));
 
         // Create a source color textures.
-        Handle<HwTexture> srcTexture = api.createTexture(SamplerType::SAMPLER_2D, 1,
+        Handle<HwTexture> srcTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
                 TextureFormat::RGBA8, 1, 512, 512, 1,
-                TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT);
+                TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
 
         // Render into the bottom-left quarter of the texture, checking 3 special cases.
         // 1. negative viewport left/bottom
@@ -207,9 +205,9 @@ TEST_F(BackendTest, ScissorViewportEdgeCases) {
         Viewport scissor = {0, 0, (uint32_t)std::numeric_limits<int32_t>::max(),
                 (uint32_t)std::numeric_limits<int32_t>::max()};
 
-        Handle<HwRenderTarget> renderTarget = api.createRenderTarget(
+        Handle<HwRenderTarget> renderTarget = cleanup.add(api.createRenderTarget(
                 TargetBufferFlags::COLOR, 512, 512, 1, 0,
-                {srcTexture, 0, 0}, {}, {});
+                {srcTexture, 0, 0}, {}, {}));
 
         TrianglePrimitive triangle(api);
 
@@ -249,11 +247,6 @@ TEST_F(BackendTest, ScissorViewportEdgeCases) {
         api.endFrame(0);
 
         api.stopCapture(0);
-
-        // Cleanup.
-        api.destroyTexture(srcTexture);
-        api.destroySwapChain(swapChain);
-        api.destroyRenderTarget(renderTarget);
     }
 
     // Wait for the ReadPixels result to come back.

filament/backend/test/test_StencilBuffer.cpp

@@ -16,6 +16,7 @@
 
 #include "BackendTest.h"
 
+#include "Lifetimes.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
 
@@ -63,20 +64,23 @@ namespace test {
 class BasicStencilBufferTest : public BackendTest {
 public:
 
-    Handle<HwSwapChain> swapChain;
-    ProgramHandle program;
+    Handle<HwSwapChain> mSwapChain;
+    ProgramHandle mProgram;
+    Cleanup mCleanup;
+
+    BasicStencilBufferTest() : mCleanup(getDriverApi()) {}
 
     void SetUp() override {
         auto& api = getDriverApi();
 
         // Create a platform-specific SwapChain and make it current.
-        swapChain = createSwapChain();
-        api.makeCurrent(swapChain, swapChain);
+        mSwapChain = mCleanup.add(createSwapChain());
+        api.makeCurrent(mSwapChain, mSwapChain);
 
         // Create a program.
         ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);
         Program p = shaderGen.getProgram(api);
-        program = api.createProgram(std::move(p));
+        mProgram = mCleanup.add(api.createProgram(std::move(p)));
     }
 
     void RunTest(Handle<HwRenderTarget> renderTarget) {
@@ -103,13 +107,13 @@ public:
         params.flags.discardEnd = TargetBufferFlags::NONE;
 
         PipelineState ps = {};
-        ps.program = program;
+        ps.program = mProgram;
         ps.rasterState.colorWrite = false;
         ps.rasterState.depthWrite = false;
         ps.stencilState.stencilWrite = true;
         ps.stencilState.front.stencilOpDepthStencilPass = StencilOperation::INCR;
 
-        api.makeCurrent(swapChain, swapChain);
+        api.makeCurrent(mSwapChain, mSwapChain);
         api.beginFrame(0, 0, 0);
 
         api.beginRenderPass(renderTarget, params);
@@ -129,29 +133,27 @@ public:
         api.draw(ps, triangle.getRenderPrimitive(), 0, 3, 1);
         api.endRenderPass();
 
-        api.commit(swapChain);
+        api.commit(mSwapChain);
         api.endFrame(0);
     }
 
     void TearDown() override {
-        auto& api = getDriverApi();
-        api.destroyProgram(program);
-        api.destroySwapChain(swapChain);
         flushAndWait();
     }
 };
 
 TEST_F(BasicStencilBufferTest, StencilBuffer) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
 
     // Create two textures: a color and a stencil, and an associated RenderTarget.
-    auto colorTexture = api.createTexture(SamplerType::SAMPLER_2D, 1,
-            TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT);
-    auto stencilTexture = api.createTexture(SamplerType::SAMPLER_2D, 1,
-            TextureFormat::STENCIL8, 1, 512, 512, 1, TextureUsage::STENCIL_ATTACHMENT);
-    auto renderTarget = getDriverApi().createRenderTarget(
+    auto colorTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
+            TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT));
+    auto stencilTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
+            TextureFormat::STENCIL8, 1, 512, 512, 1, TextureUsage::STENCIL_ATTACHMENT));
+    auto renderTarget = cleanup.add(api.createRenderTarget(
             TargetBufferFlags::COLOR0 | TargetBufferFlags::STENCIL, 512, 512, 1, 0,
-            {{colorTexture}}, {}, {{stencilTexture}});
+            {{colorTexture}}, {}, {{stencilTexture}}));
 
     RunTest(renderTarget);
 
@@ -159,23 +161,20 @@ TEST_F(BasicStencilBufferTest, StencilBuffer) {
 
     flushAndWait();
     getDriver().purge();
-
-    api.destroyTexture(colorTexture);
-    api.destroyTexture(stencilTexture);
-    api.destroyRenderTarget(renderTarget);
 }
 
 TEST_F(BasicStencilBufferTest, DepthAndStencilBuffer) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
 
     // Create two textures: a color and a stencil, and an associated RenderTarget.
-    auto colorTexture = api.createTexture(SamplerType::SAMPLER_2D, 1,
-            TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT);
-    auto depthStencilTexture = api.createTexture(SamplerType::SAMPLER_2D, 1,
-            TextureFormat::DEPTH24_STENCIL8, 1, 512, 512, 1, TextureUsage::STENCIL_ATTACHMENT | TextureUsage::DEPTH_ATTACHMENT);
-    auto renderTarget = getDriverApi().createRenderTarget(
+    auto colorTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
+            TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT));
+    auto depthStencilTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
+            TextureFormat::DEPTH24_STENCIL8, 1, 512, 512, 1, TextureUsage::STENCIL_ATTACHMENT | TextureUsage::DEPTH_ATTACHMENT));
+    auto renderTarget = cleanup.add(api.createRenderTarget(
             TargetBufferFlags::COLOR0 | TargetBufferFlags::STENCIL, 512, 512, 1, 0,
-            {{colorTexture}}, {depthStencilTexture}, {{depthStencilTexture}});
+            {{colorTexture}}, {depthStencilTexture}, {{depthStencilTexture}}));
 
     RunTest(renderTarget);
 
@@ -183,30 +182,27 @@ TEST_F(BasicStencilBufferTest, DepthAndStencilBuffer) {
 
     flushAndWait();
     getDriver().purge();
-
-    api.destroyTexture(colorTexture);
-    api.destroyTexture(depthStencilTexture);
-    api.destroyRenderTarget(renderTarget);
 }
 
 TEST_F(BasicStencilBufferTest, StencilBufferMSAA) {
     auto& api = getDriverApi();
+    Cleanup cleanup(api);
 
     // Create two textures: a single-sampled color and a MSAA stencil texture.
     // We also create two RenderTargets, one for each pass:
     // Pass 0: Render a triangle only into the MSAA stencil buffer.
     // Pass 1: Render a triangle into (an auto-created) MSAA color buffer using the stencil test.
     //         Performs an auto-resolve on the color.
-    auto colorTexture = api.createTexture(SamplerType::SAMPLER_2D, 1,
-            TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE);
-    auto depthStencilTextureMSAA = api.createTexture(SamplerType::SAMPLER_2D, 1,
-            TextureFormat::DEPTH24_STENCIL8, 4, 512, 512, 1, TextureUsage::STENCIL_ATTACHMENT | TextureUsage::DEPTH_ATTACHMENT);
-    auto renderTarget0 = getDriverApi().createRenderTarget(
+    auto colorTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
+            TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE));
+    auto depthStencilTextureMSAA = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
+            TextureFormat::DEPTH24_STENCIL8, 4, 512, 512, 1, TextureUsage::STENCIL_ATTACHMENT | TextureUsage::DEPTH_ATTACHMENT));
+    auto renderTarget0 = cleanup.add(api.createRenderTarget(
             TargetBufferFlags::DEPTH_AND_STENCIL, 512, 512, 4, 0,
-            {{}}, {depthStencilTextureMSAA}, {depthStencilTextureMSAA});
-    auto renderTarget1 = getDriverApi().createRenderTarget(
+            {{}}, {depthStencilTextureMSAA}, {depthStencilTextureMSAA}));
+    auto renderTarget1 = cleanup.add(api.createRenderTarget(
             TargetBufferFlags::COLOR0 | TargetBufferFlags::DEPTH_AND_STENCIL, 512, 512, 4, 0,
-            {{colorTexture}}, {depthStencilTextureMSAA}, {depthStencilTextureMSAA});
+            {{colorTexture}}, {depthStencilTextureMSAA}, {depthStencilTextureMSAA}));
 
     api.startCapture(0);
 
@@ -230,13 +226,13 @@ TEST_F(BasicStencilBufferTest, StencilBufferMSAA) {
     params.flags.discardEnd = TargetBufferFlags::NONE;
 
     PipelineState ps = {};
-    ps.program = program;
+    ps.program = mProgram;
     ps.rasterState.colorWrite = false;
     ps.rasterState.depthWrite = false;
     ps.stencilState.stencilWrite = true;
     ps.stencilState.front.stencilOpDepthStencilPass = StencilOperation::INCR;
 
-    api.makeCurrent(swapChain, swapChain);
+    api.makeCurrent(mSwapChain, mSwapChain);
     api.beginFrame(0, 0, 0);
 
     api.beginRenderPass(renderTarget0, params);
@@ -258,7 +254,7 @@ TEST_F(BasicStencilBufferTest, StencilBufferMSAA) {
     api.draw(ps, triangle.getRenderPrimitive(), 0, 3, 1);
     api.endRenderPass();
 
-    api.commit(swapChain);
+    api.commit(mSwapChain);
     api.stopCapture(0);
     api.endFrame(0);
 
@@ -266,11 +262,6 @@ TEST_F(BasicStencilBufferTest, StencilBufferMSAA) {
 
     flushAndWait();
     getDriver().purge();
-
-    api.destroyTexture(colorTexture);
-    api.destroyTexture(depthStencilTextureMSAA);
-    api.destroyRenderTarget(renderTarget0);
-    api.destroyRenderTarget(renderTarget1);
 }
 
 } // namespace test

filament/include/filament/BufferObject.h

@@ -25,6 +25,7 @@
 #include <backend/BufferDescriptor.h>
 
 #include <utils/compiler.h>
+#include <utils/StaticString.h>
 
 #include <stdint.h>
 #include <stddef.h>
@@ -90,9 +91,21 @@ public:
          * @param name A string to identify this BufferObject
          * @param len Length of name, should be less than or equal to 128
          * @return This Builder, for chaining calls.
+         * @deprecated Use name(utils::StaticString const&) instead.
          */
+        UTILS_DEPRECATED
         Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept;
 
+        /**
+         * Associate an optional name with this BufferObject for debugging purposes.
+         *
+         * name will show in error messages and should be kept as short as possible.
+         *
+         * @param name A string literal to identify this BufferObject
+         * @return This Builder, for chaining calls.
+         */
+        Builder& name(utils::StaticString const& name) noexcept;
+
         /**
          * Creates the BufferObject and returns a pointer to it. After creation, the buffer
          * object is uninitialized. Use BufferObject::setBuffer() to initialize it.

filament/include/filament/FilamentAPI.h

@@ -20,6 +20,7 @@
 #include <utils/compiler.h>
 #include <utils/PrivateImplementation.h>
 #include <utils/CString.h>
+#include <utils/StaticString.h>
 
 #include <stddef.h>
 
@@ -61,11 +62,17 @@ UTILS_PUBLIC void builderMakeName(utils::CString& outName, const char* name, siz
 template <typename Builder>
 class UTILS_PUBLIC BuilderNameMixin {
 public:
+    UTILS_DEPRECATED
     Builder& name(const char* name, size_t len) noexcept {
         builderMakeName(mName, name, len);
         return static_cast<Builder&>(*this);
     }
 
+    Builder& name(utils::StaticString const& name) noexcept {
+        builderMakeName(mName, name.data(), name.size());
+        return static_cast<Builder&>(*this);
+    }
+
     utils::CString const& getName() const noexcept { return mName; }
 
 private:

filament/include/filament/IndexBuffer.h

@@ -26,6 +26,7 @@
 #include <backend/BufferDescriptor.h>
 
 #include <utils/compiler.h>
+#include <utils/StaticString.h>
 
 #include <stdint.h>
 #include <stddef.h>
@@ -95,9 +96,21 @@ public:
          * @param name A string to identify this IndexBuffer
          * @param len Length of name, should be less than or equal to 128
          * @return This Builder, for chaining calls.
+         * @deprecated Use name(utils::StaticString const&) instead.
          */
+        UTILS_DEPRECATED
         Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept;
 
+        /**
+         * Associate an optional name with this IndexBuffer for debugging purposes.
+         *
+         * name will show in error messages and should be kept as short as possible.
+         *
+         * @param name A string literal to identify this IndexBuffer
+         * @return This Builder, for chaining calls.
+         */
+        Builder& name(utils::StaticString const& name) noexcept;
+
         /**
          * Creates the IndexBuffer object and returns a pointer to it. After creation, the index
          * buffer is uninitialized. Use IndexBuffer::setBuffer() to initialize the IndexBuffer.

filament/include/filament/InstanceBuffer.h

@@ -21,6 +21,7 @@
 #include <filament/Engine.h>
 
 #include <utils/compiler.h>
+#include <utils/StaticString.h>
 
 #include <math/mathfwd.h>
 
@@ -82,9 +83,21 @@ public:
          * @param name A string to identify this InstanceBuffer
          * @param len Length of name, should be less than or equal to 128
          * @return This Builder, for chaining calls.
+         * @deprecated Use name(utils::StaticString const&) instead.
          */
+        UTILS_DEPRECATED
         Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept;
 
+        /**
+         * Associate an optional name with this InstanceBuffer for debugging purposes.
+         *
+         * name will show in error messages and should be kept as short as possible.
+         *
+         * @param name A string literal to identify this InstanceBuffer
+         * @return This Builder, for chaining calls.
+         */
+        Builder& name(utils::StaticString const& name) noexcept;
+
         /**
          * Creates the InstanceBuffer object and returns a pointer to it.
          */

filament/include/filament/MorphTargetBuffer.h

@@ -22,6 +22,7 @@
 #include <filament/Engine.h>
 
 #include <utils/compiler.h>
+#include <utils/StaticString.h>
 
 #include <math/mathfwd.h>
 
@@ -75,9 +76,21 @@ public:
          * @param name A string to identify this MorphTargetBuffer
          * @param len Length of name, should be less than or equal to 128
          * @return This Builder, for chaining calls.
+         * @deprecated Use name(utils::StaticString const&) instead.
          */
+        UTILS_DEPRECATED
         Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept;
 
+        /**
+         * Associate an optional name with this MorphTargetBuffer for debugging purposes.
+         *
+         * name will show in error messages and should be kept as short as possible.
+         *
+         * @param name A string literal to identify this MorphTargetBuffer
+         * @return This Builder, for chaining calls.
+         */
+        Builder& name(utils::StaticString const& name) noexcept;
+
         /**
          * Creates the MorphTargetBuffer object and returns a pointer to it.
          *

filament/include/filament/SkinningBuffer.h

@@ -22,6 +22,7 @@
 #include <filament/RenderableManager.h>
 
 #include <utils/compiler.h>
+#include <utils/StaticString.h>
 
 #include <math/mathfwd.h>
 
@@ -81,9 +82,21 @@ public:
          * @param name A string to identify this SkinningBuffer
          * @param len Length of name, should be less than or equal to 128
          * @return This Builder, for chaining calls.
+         * @deprecated Use name(utils::StaticString const&) instead.
          */
+        UTILS_DEPRECATED
         Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept;
 
+        /**
+         * Associate an optional name with this SkinningBuffer for debugging purposes.
+         *
+         * name will show in error messages and should be kept as short as possible.
+         *
+         * @param name A string literal to identify this SkinningBuffer
+         * @return This Builder, for chaining calls.
+         */
+        Builder& name(utils::StaticString const& name) noexcept;
+
         /**
          * Creates the SkinningBuffer object and returns a pointer to it.
          *

filament/include/filament/Stream.h

@@ -23,6 +23,7 @@
 #include <backend/CallbackHandler.h>
 
 #include <utils/compiler.h>
+#include <utils/StaticString.h>
 
 #include <math/mat3.h>
 
@@ -150,9 +151,21 @@ public:
          * @param name A string to identify this Stream
          * @param len Length of name, should be less than or equal to 128
          * @return This Builder, for chaining calls.
+         * @deprecated Use name(utils::StaticString const&) instead.
          */
+        UTILS_DEPRECATED
         Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept;
 
+        /**
+         * Associate an optional name with this Stream for debugging purposes.
+         *
+         * name will show in error messages and should be kept as short as possible.
+         *
+         * @param name A string literal to identify this Stream
+         * @return This Builder, for chaining calls.
+         */
+        Builder& name(utils::StaticString const& name) noexcept;
+
         /**
          * Creates the Stream object and returns a pointer to it.
          *

filament/include/filament/Texture.h

@@ -26,6 +26,7 @@
 #include <backend/Platform.h>
 
 #include <utils/compiler.h>
+#include <utils/StaticString.h>
 
 #include <utility>
 
@@ -229,8 +230,20 @@ public:
          * @param name A string to identify this Texture
          * @param len Length of name, should be less than or equal to 128
          * @return This Builder, for chaining calls.
+         * @deprecated Use name(utils::StaticString const&) instead.
          */
-         Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept;
+        UTILS_DEPRECATED
+        Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept;
+
+        /**
+         * Associate an optional name with this Texture for debugging purposes.
+         *
+         * name will show in error messages and should be kept as short as possible.
+         *
+         * @param name A string literal to identify this Texture
+         * @return This Builder, for chaining calls.
+         */
+        Builder& name(utils::StaticString const& name) noexcept;
 
         /**
          * Creates an external texture. The content must be set using setExternalImage().

filament/include/filament/VertexBuffer.h

@@ -26,6 +26,7 @@
 #include <backend/DriverEnums.h>
 
 #include <utils/compiler.h>
+#include <utils/StaticString.h>
 
 #include <stddef.h>
 #include <stdint.h>
@@ -170,9 +171,21 @@ public:
          * @param name A string to identify this VertexBuffer
          * @param len Length of name, should be less than or equal to 128
          * @return This Builder, for chaining calls.
+         * @deprecated Use name(utils::StaticString const&) instead.
          */
+        UTILS_DEPRECATED
         Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept;
 
+        /**
+         * Associate an optional name with this VertexBuffer for debugging purposes.
+         *
+         * name will show in error messages and should be kept as short as possible.
+         *
+         * @param name A string literal to identify this VertexBuffer
+         * @return This Builder, for chaining calls.
+         */
+        Builder& name(utils::StaticString const& name) noexcept;
+
         /**
          * Creates the VertexBuffer object and returns a pointer to it.
          *

filament/src/PostProcessManager.cpp

@@ -2341,6 +2341,9 @@ void PostProcessManager::customResolvePrepareSubpass(DriverApi& driver, CustomRe
 }
 
 void PostProcessManager::customResolveSubpass(DriverApi& driver) noexcept {
+
+    bindPostProcessDescriptorSet(driver);
+
     FEngine const& engine = mEngine;
     Handle<HwRenderPrimitive> const& fullScreenRenderPrimitive = engine.getFullScreenRenderPrimitive();
     auto const& material = getPostProcessMaterial("customResolveAsSubpass");
@@ -3036,7 +3039,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleBilinear(FrameGraph&
 
 FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleSGSR1(FrameGraph& fg, bool sourceHasLuminance,
     DynamicResolutionOptions dsrOptions, FrameGraphId<FrameGraphTexture> const input,
-    filament::Viewport const&, FrameGraphTexture::Descriptor const& outDesc) noexcept {
+    filament::Viewport const& vp, FrameGraphTexture::Descriptor const& outDesc) noexcept {
 
     struct QuadBlitData {
         FrameGraphId<FrameGraphTexture> input;
@@ -3052,7 +3055,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleSGSR1(FrameGraph& fg,
                         .attachments = { .color = { data.output } },
                         .clearFlags = TargetBufferFlags::DEPTH });
             },
-            [this, sourceHasLuminance](FrameGraphResources const& resources,
+            [this, vp, sourceHasLuminance](FrameGraphResources const& resources,
                     auto const& data, DriverApi& driver) {
                 bindPostProcessDescriptorSet(driver);
 
@@ -3078,10 +3081,17 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleSGSR1(FrameGraph& fg,
                 });
 
                 mi->setParameter("viewport", float4{
+                        float(vp.left)   / inputDesc.width,
+                        float(vp.bottom) / inputDesc.height,
+                        float(vp.width)  / inputDesc.width,
+                        float(vp.height) / inputDesc.height
+                });
+
+                mi->setParameter("viewportInfo", float4{
                         1.0f / inputDesc.width,
                         1.0f / inputDesc.height,
                         float(inputDesc.width),
-                        float(inputDesc.height),
+                        float(inputDesc.height)
                 });
 
                 mi->commit(driver);

filament/src/details/BufferObject.cpp

@@ -21,6 +21,7 @@
 #include "FilamentAPI-impl.h"
 
 #include <utils/CString.h>
+#include <utils/StaticString.h>
 
 namespace filament {
 
@@ -51,6 +52,10 @@ BufferObject::Builder& BufferObject::Builder::name(const char* name, size_t cons
     return BuilderNameMixin::name(name, len);
 }
 
+BufferObject::Builder& BufferObject::Builder::name(utils::StaticString const& name) noexcept {
+    return BuilderNameMixin::name(name);
+}
+
 BufferObject* BufferObject::Builder::build(Engine& engine) {
     return downcast(engine).createBufferObject(*this);
 }

filament/src/details/IndexBuffer.cpp

@@ -21,6 +21,7 @@
 #include "FilamentAPI-impl.h"
 
 #include <utils/CString.h>
+#include <utils/StaticString.h>
 
 namespace filament {
 
@@ -51,6 +52,10 @@ IndexBuffer::Builder& IndexBuffer::Builder::name(const char* name, size_t const
     return BuilderNameMixin::name(name, len);
 }
 
+IndexBuffer::Builder& IndexBuffer::Builder::name(utils::StaticString const& name) noexcept {
+    return BuilderNameMixin::name(name);
+}
+
 IndexBuffer* IndexBuffer::Builder::build(Engine& engine) {
     return downcast(engine).createIndexBuffer(*this);
 }

filament/src/details/InstanceBuffer.cpp

@@ -21,6 +21,8 @@
 
 #include "FilamentAPI-impl.h"
 
+#include <utils/StaticString.h>
+
 #include <math/mat3.h>
 #include <math/vec3.h>
 
@@ -54,6 +56,10 @@ InstanceBuffer::Builder& InstanceBuffer::Builder::name(const char* name, size_t
     return BuilderNameMixin::name(name, len);
 }
 
+InstanceBuffer::Builder& InstanceBuffer::Builder::name(utils::StaticString const& name) noexcept {
+    return BuilderNameMixin::name(name);
+}
+
 InstanceBuffer* InstanceBuffer::Builder::build(Engine& engine) {
     FILAMENT_CHECK_PRECONDITION(mImpl->mInstanceCount >= 1) << "instanceCount must be >= 1.";
     FILAMENT_CHECK_PRECONDITION(mImpl->mInstanceCount <= engine.getMaxAutomaticInstances())

filament/src/details/MorphTargetBuffer.cpp

@@ -26,6 +26,7 @@
 #include <math/norm.h>
 
 #include <utils/CString.h>
+#include <utils/StaticString.h>
 
 namespace filament {
 
@@ -59,6 +60,10 @@ MorphTargetBuffer::Builder& MorphTargetBuffer::Builder::name(const char* name, s
     return BuilderNameMixin::name(name, len);
 }
 
+MorphTargetBuffer::Builder& MorphTargetBuffer::Builder::name(utils::StaticString const& name) noexcept {
+    return BuilderNameMixin::name(name);
+}
+
 MorphTargetBuffer* MorphTargetBuffer::Builder::build(Engine& engine) {
     return downcast(engine).createMorphTargetBuffer(*this);
 }

filament/src/details/SkinningBuffer.cpp

@@ -26,6 +26,7 @@
 #include <math/mat4.h>
 
 #include <utils/CString.h>
+#include <utils/StaticString.h>
 
 #include <string.h>
 #include <stddef.h>
@@ -64,6 +65,10 @@ SkinningBuffer::Builder& SkinningBuffer::Builder::name(const char* name, size_t
     return BuilderNameMixin::name(name, len);
 }
 
+SkinningBuffer::Builder& SkinningBuffer::Builder::name(utils::StaticString const& name) noexcept {
+    return BuilderNameMixin::name(name);
+}
+
 SkinningBuffer* SkinningBuffer::Builder::build(Engine& engine) {
     return downcast(engine).createSkinningBuffer(*this);
 }

filament/src/details/Stream.cpp

@@ -24,6 +24,7 @@
 #include <backend/PixelBufferDescriptor.h>
 
 #include <utils/CString.h>
+#include <utils/StaticString.h>
 #include <utils/Panic.h>
 #include <filament/Stream.h>
 
@@ -65,6 +66,10 @@ Stream::Builder& Stream::Builder::name(const char* name, size_t const len) noexc
     return BuilderNameMixin::name(name, len);
 }
 
+Stream::Builder& Stream::Builder::name(utils::StaticString const& name) noexcept {
+    return BuilderNameMixin::name(name);
+}
+
 Stream* Stream::Builder::build(Engine& engine) {
     return downcast(engine).createStream(*this);
 }

filament/src/details/Texture.cpp

@@ -41,6 +41,8 @@
 #include <utils/algorithm.h>
 #include <utils/BitmaskEnum.h>
 #include <utils/compiler.h>
+#include <utils/CString.h>
+#include <utils/StaticString.h>
 #include <utils/debug.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/Panic.h>
@@ -152,6 +154,10 @@ Texture::Builder& Texture::Builder::name(const char* name, size_t const len) noe
     return BuilderNameMixin::name(name, len);
 }
 
+Texture::Builder& Texture::Builder::name(StaticString const& name) noexcept {
+    return BuilderNameMixin::name(name);
+}
+
 Texture* Texture::Builder::build(Engine& engine) {
     if (mImpl->mTarget != SamplerType::SAMPLER_EXTERNAL) {
         FILAMENT_CHECK_PRECONDITION(Texture::isTextureFormatSupported(engine, mImpl->mFormat))

filament/src/details/VertexBuffer.cpp

@@ -30,6 +30,7 @@
 #include <utils/bitset.h>
 #include <utils/compiler.h>
 #include <utils/CString.h>
+#include <utils/StaticString.h>
 #include <utils/debug.h>
 #include <utils/Log.h>
 #include <utils/ostream.h>
@@ -152,6 +153,10 @@ VertexBuffer::Builder& VertexBuffer::Builder::name(const char* name, size_t cons
     return BuilderNameMixin::name(name, len);
 }
 
+VertexBuffer::Builder& VertexBuffer::Builder::name(utils::StaticString const& name) noexcept {
+    return BuilderNameMixin::name(name);
+}
+
 VertexBuffer* VertexBuffer::Builder::build(Engine& engine) {
     FILAMENT_CHECK_PRECONDITION(mImpl->mVertexCount > 0) << "vertexCount cannot be 0";
     FILAMENT_CHECK_PRECONDITION(mImpl->mBufferCount > 0) << "bufferCount cannot be 0";

filament/src/materials/sgsr/sgsr1.mat

@@ -10,6 +10,11 @@ material {
             type : float4,
             name : viewport,
             precision: high
+        },
+        {
+            type : float4,
+            name : viewportInfo,
+            precision: high
         }
     ],
     variables : [
@@ -22,8 +27,8 @@ material {
 
 vertex {
     void postProcessVertex(inout PostProcessVertexInputs postProcess) {
-        postProcess.normalizedUV = uvToRenderTargetUV(postProcess.normalizedUV);
-        postProcess.vertex.xy = postProcess.normalizedUV;
+        postProcess.vertex.xy = materialParams.viewport.xy + postProcess.normalizedUV * materialParams.viewport.zw;
+        postProcess.vertex.xy = uvToRenderTargetUV(postProcess.vertex.xy);
     }
 }
 
@@ -38,7 +43,7 @@ fragment {
     #define gather textureGather
 #else
     vec4 gather(const mediump sampler2D color, highp vec2 p, const int comp) {
-        highp ivec2 i = ivec2(p * materialParams.viewport.zw - 0.5);
+        highp ivec2 i = ivec2(p * materialParams.viewportInfo.zw - 0.5);
         vec4 d;
         d[0] = texelFetchOffset(color, i, 0, ivec2(0, 1))[comp];
         d[1] = texelFetchOffset(color, i, 0, ivec2(1, 1))[comp];
@@ -74,7 +79,7 @@ fragment {
 #include "sgsr1_shader_mobile.fs"
 
     void postProcess(inout PostProcessInputs postProcess) {
-        highp vec4 vp[1] = vec4[1]( materialParams.viewport );
+        highp vec4 vp[1] = vec4[1]( materialParams.viewportInfo );
         postProcess.color = sgsr(materialParams_color, variable_vertex.xy, vp);
     }
 }

ios/CocoaPods/Filament.podspec

@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
   spec.name = "Filament"
-  spec.version = "1.58.1"
+  spec.version = "1.58.2"
   spec.license = { :type => "Apache 2.0", :file => "LICENSE" }
   spec.homepage = "https://google.github.io/filament"
   spec.authors = "Google LLC."
   spec.summary = "Filament is a real-time physically based rendering engine for Android, iOS, Windows, Linux, macOS, and WASM/WebGL."
   spec.platform = :ios, "11.0"
-  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.58.1/filament-v1.58.1-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.58.2/filament-v1.58.2-ios.tgz" }
 
   # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
   spec.pod_target_xcconfig = {

libs/filabridge/include/filament/MaterialEnums.h

@@ -28,7 +28,7 @@
 namespace filament {
 
 // update this when a new version of filament wouldn't work with older materials
-static constexpr size_t MATERIAL_VERSION = 58;
+static constexpr size_t MATERIAL_VERSION = 59;
 
 /**
  * Supported shading models

libs/filamat/src/GLSLPostProcessor.cpp

@@ -517,6 +517,7 @@ void GLSLPostProcessor::spirvToMsl(const SpirvBlob* spirv, std::string* outMsl,
         MetalArgumentBuffer::destroy(&argBuffer);
     }
 }
+
 void GLSLPostProcessor::rebindImageSamplerForWGSL(std::vector<uint32_t>& spirv) {
     constexpr size_t HEADER_SIZE = 5;
     size_t const dataSize = spirv.size();
@@ -528,9 +529,6 @@ void GLSLPostProcessor::rebindImageSamplerForWGSL(std::vector<uint32_t>& spirv)
     };
 
     std::unordered_map<uint32_t, Descriptor> descriptors;
-    std::set<uint32_t> unidentifiedLoadTargets;
-    std::vector<uint32_t> bindingTargets;
-
     auto getDesc = [&](uint32_t var) -> Descriptor& {
         using itertype = std::unordered_map<uint32_t, Descriptor>::iterator;
         itertype itr;
@@ -553,42 +551,69 @@ void GLSLPostProcessor::rebindImageSamplerForWGSL(std::vector<uint32_t>& spirv)
     };
 
     uint32_t samplerTypeId = 0;
-    pass(spv::Op::OpName, [&](uint32_t pos) {
-        auto target = data[pos];
-        char* name = (char*)&data[pos+1];
-        std::string_view view(name);
-        if (view.find("_sampler") != std::string_view::npos) {
-            unidentifiedLoadTargets.insert(target);
-        }
-});
 
+    // First we find the ID used to identify the sampler type and the image type.
+    pass(spv::Op::OpTypeSampler, [&](uint32_t pos) {
+        samplerTypeId = data[pos];
+    });
+
+    // Next we identify all the descriptors and record their set id and binding.
+    pass(spv::Op::OpDecorate, [&](uint32_t pos) {
+        uint32_t const type = data[pos + 1];
+        if (type == spv::Decoration::DecorationBinding) {
+            uint32_t const targetVar = data[pos];
+            uint32_t const binding = data[pos + 2];
+            auto& desc = getDesc(targetVar);
+            desc.binding = binding;
+            // Note these decorations do not need to be written to the output.
+        } else if (type == spv::Decoration::DecorationDescriptorSet) {
+            uint32_t const targetVar = data[pos];
+            uint32_t const set = data[pos + 2];
+            auto& desc = getDesc(targetVar);
+        }
+    });
+
+    // Offset samplers by 2n+1, and everything else by 2n
+    pass(spv::Op::OpLoad, [&](uint32_t pos) {
+        uint32_t const retType = data[pos];
+        uint32_t const targetVar = data[pos + 2];
+        auto& desc = getDesc(targetVar);
+        if (retType == samplerTypeId) {
+            if (!desc.fixed) {
+                //desc.binding = (desc.binding * 2) +1;
+                desc.binding = (desc.binding ) +100;
+
+                desc.fixed = true;
+            }
+        }
+        else {
+            if (!desc.fixed) {
+                //desc.binding *=2;
+               // desc.fixed = true;
+            }
+        }
+    });
 
     // Write out the offsetted bindings
     pass(spv::Op::OpDecorate, [&](uint32_t pos) {
         uint32_t const type = data[pos + 1];
         if (type == spv::Decoration::DecorationBinding) {
             uint32_t const targetVar = data[pos];
-            if (unidentifiedLoadTargets.find(targetVar) != unidentifiedLoadTargets.end()) {
-                data[pos + 2] = data[pos + 2]*2 + 1;
-            }
-            else {
-                data[pos + 2] = data[pos + 2] *2;
-            }
+            auto const &desc = getDesc(targetVar);
+            data[pos + 2] = desc.binding;
         }
     });
 }
 
+
 bool GLSLPostProcessor::spirvToWgsl(SpirvBlob *spirv, std::string *outWsl) {
 #if FILAMENT_SUPPORTS_WEBGPU
     //We need to run some opt-passes at all times to transpile to WGSL
     auto optimizer = createEmptyOptimizer();
     optimizer->RegisterPass(CreateSplitCombinedImageSamplerPass());
-    //optimizer->RegisterPass(CreateResolveBindingConflictsPass());
-
     optimizeSpirv(optimizer, *spirv);
 
     //After splitting the image samplers, we need to remap the bindings to separate them.
-    //TODO: This has issues, so use CreateResolveBindingConflictsPass instead. Mapping is less predictable but short term
     rebindImageSamplerForWGSL(*spirv);
 
     //Allow non-uniform derivitives due to our nested shaders. See https://github.com/gpuweb/gpuweb/issues/3479
@@ -598,23 +623,8 @@ bool GLSLPostProcessor::spirvToWgsl(SpirvBlob *spirv, std::string *outWsl) {
     tint::Program tintRead = tint::spirv::reader::Read(*spirv, readerOpts);
 
     if (tintRead.Diagnostics().ContainsErrors()) {
-        //We know errors can potentially crop up, and want the ability to ignore them if needed for sample bringup
-#ifndef FILAMENT_WEBGPU_IGNORE_TNT_READ_ERRORS
         slog.e << "Tint Reader Error: " << tintRead.Diagnostics().Str() << io::endl;
-        spv_context context = spvContextCreate(SPV_ENV_VULKAN_1_1_SPIRV_1_4);
-        spv_text text = nullptr;
-        spv_diagnostic diagnostic = nullptr;
-        spv_result_t result = spvBinaryToText(
-            context,
-            spirv->data(),
-            spirv->size(),
-            SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | SPV_BINARY_TO_TEXT_OPTION_COLOR,
-            &text,
-            &diagnostic);
-        slog.e << "Beginning SpirV-output dump\n\n" << text->str << "\n\nEndSPIRV\n" << io::endl;
-        spvTextDestroy(text);
         return false;
-#endif
     }
 
     tint::Result<tint::wgsl::writer::Output> wgslOut = tint::wgsl::writer::Generate(tintRead,writerOpts);
@@ -1056,8 +1066,9 @@ void GLSLPostProcessor::registerPerformancePasses(Optimizer& optimizer, Config c
 
     RegisterPass(CreateWrapOpKillPass());
     RegisterPass(CreateDeadBranchElimPass());
-    RegisterPass(CreateMergeReturnPass(), MaterialBuilder::TargetApi::METAL | MaterialBuilder::TargetApi::WEBGPU);
-    RegisterPass(CreateInlineExhaustivePass());
+    RegisterPass(CreateMergeReturnPass(), MaterialBuilder::TargetApi::METAL);
+    //TODO Do not run inline pass without merge return pass until we sort out issues
+    RegisterPass(CreateInlineExhaustivePass(), MaterialBuilder::TargetApi::ALL & ~MaterialBuilder::TargetApi::WEBGPU);
     RegisterPass(CreateAggressiveDCEPass());
     RegisterPass(CreatePrivateToLocalPass());
     RegisterPass(CreateLocalSingleBlockLoadStoreElimPass());
@@ -1101,7 +1112,8 @@ void GLSLPostProcessor::registerSizePasses(Optimizer& optimizer, Config const& c
 
     RegisterPass(CreateWrapOpKillPass());
     RegisterPass(CreateDeadBranchElimPass());
-    RegisterPass(CreateInlineExhaustivePass());
+    //TODO Do not run inline pass without merge return pass until we sort out issues
+    RegisterPass(CreateInlineExhaustivePass(), MaterialBuilder::TargetApi::ALL & ~MaterialBuilder::TargetApi::WEBGPU);
     RegisterPass(CreateEliminateDeadFunctionsPass());
     RegisterPass(CreatePrivateToLocalPass());
     RegisterPass(CreateScalarReplacementPass(0));

libs/utils/CMakeLists.txt

@@ -37,6 +37,7 @@ set(DIST_HDRS
         ${PUBLIC_HDR_DIR}/${TARGET}/PrivateImplementation-impl.h
         ${PUBLIC_HDR_DIR}/${TARGET}/SingleInstanceComponentManager.h
         ${PUBLIC_HDR_DIR}/${TARGET}/Slice.h
+        ${PUBLIC_HDR_DIR}/${TARGET}/StaticString.h
         ${PUBLIC_HDR_DIR}/${TARGET}/StructureOfArrays.h
         ${PUBLIC_HDR_DIR}/${TARGET}/Systrace.h
         ${PUBLIC_HDR_DIR}/${TARGET}/sstream.h

libs/utils/include/utils/CString.h

@@ -22,6 +22,8 @@
 #include <utils/compiler.h>
 #include <utils/ostream.h>
 
+#include <string_view>
+
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -197,16 +199,13 @@ private:
     };
 
     int compare(const CString& rhs) const noexcept {
-        size_type const lhs_size = size();
-        size_type const rhs_size = rhs.size();
-        if (lhs_size < rhs_size) return -1;
-        if (lhs_size > rhs_size) return 1;
-        return strncmp(data(), rhs.data(), size());
+        auto const l = std::string_view{data(), size()};
+        auto const r = std::string_view{rhs.data(), rhs.size()};
+        return l.compare(r);
     }
 
     friend bool operator==(CString const& lhs, CString const& rhs) noexcept {
-        return (lhs.data() == rhs.data()) ||
-               ((lhs.size() == rhs.size()) && !strncmp(lhs.data(), rhs.data(), lhs.size()));
+        return lhs.compare(rhs) == 0;
     }
     friend bool operator!=(CString const& lhs, CString const& rhs) noexcept {
         return !(lhs == rhs);

libs/utils/include/utils/StaticString.h

@@ -0,0 +1,108 @@
+/*
+ * 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_UTILS_STATICSTRING_H
+#define TNT_UTILS_STATICSTRING_H
+
+#include <type_traits>
+#include <string_view>
+
+#include <stddef.h>
+
+namespace utils {
+
+/**
+ * @brief A lightweight string class that stores a pointer to a string literal and its size, without dynamic allocation.
+ *
+ * This class is designed to efficiently represent string literals. It does not allocate any memory
+ * and instead relies on the compiler to manage the memory of the string literals.
+ */
+class UTILS_PUBLIC StaticString {
+public:
+    using value_type = std::string_view::value_type;
+    using const_pointer = std::string_view::const_pointer;
+    using const_reference = std::string_view::const_reference;
+    using size_type = std::string_view::size_type;
+    using const_iterator = std::string_view::const_iterator;
+
+    // Constructor from string literal
+    template <size_t M>
+    constexpr StaticString(const char (&str)[M]) noexcept : mString(str, M - 1) {} // NOLINT(*-explicit-constructor)
+
+    constexpr StaticString() noexcept = default;
+
+    constexpr const_pointer c_str() const noexcept { return mString.data(); }
+    constexpr const_pointer data() const noexcept { return mString.data(); }
+    constexpr size_type size() const noexcept { return mString.size(); }
+    constexpr size_type length() const noexcept { return mString.size(); }
+    constexpr bool empty() const noexcept { return mString.empty(); }
+
+    constexpr const_iterator begin() const noexcept { return mString.begin(); }
+    constexpr const_iterator end() const noexcept { return mString.end(); }
+    constexpr const_iterator cbegin() const noexcept { return mString.begin(); }
+    constexpr const_iterator cend() const noexcept { return mString.end(); }
+
+    constexpr const_reference operator[](size_type const pos) const noexcept {
+        return mString[pos];
+    }
+
+    constexpr const_reference at(size_type pos) const {
+        return mString[pos];
+    }
+
+    constexpr const_reference front() const noexcept {
+        return mString.front();
+    }
+
+    constexpr const_reference back() const noexcept {
+        return mString.back();
+    }
+
+    constexpr int compare(const StaticString& rhs) const noexcept {
+        return mString.compare(rhs.mString);
+    }
+
+private:
+    std::string_view mString;
+
+    friend constexpr bool operator==(const StaticString& lhs, const StaticString& rhs) noexcept {
+        return lhs.mString == rhs.mString;
+    }
+
+    friend constexpr bool operator!=(const StaticString& lhs, const StaticString& rhs) noexcept {
+        return lhs.mString != rhs.mString;
+    }
+
+    friend constexpr bool operator<(const StaticString& lhs, const StaticString& rhs) noexcept {
+        return lhs.mString < rhs.mString;
+    }
+
+    friend constexpr bool operator>(const StaticString& lhs, const StaticString& rhs) noexcept {
+        return lhs.mString > rhs.mString;
+    }
+
+    friend constexpr bool operator<=(const StaticString& lhs, const StaticString& rhs) noexcept {
+        return lhs.mString <= rhs.mString;
+    }
+
+    friend constexpr bool operator>=(const StaticString& lhs, const StaticString& rhs) noexcept {
+        return lhs.mString >= rhs.mString;
+    }
+};
+
+} // namespace utils
+
+#endif // TNT_UTILS_STATICSTRING_H

shaders/src/surface_getters.fs

@@ -129,14 +129,14 @@ bool isDoubleSided() {
 /**
  * Returns the cascade index for this fragment (between 0 and CONFIG_MAX_SHADOW_CASCADES - 1).
  */
-uint getShadowCascade() {
+int getShadowCascade() {
     highp float z = mulMat4x4Float3(getViewFromWorldMatrix(), getWorldPosition()).z;
     ivec4 greaterZ = ivec4(greaterThan(frameUniforms.cascadeSplits, vec4(z)));
-    uint cascadeCount = frameUniforms.cascades & 0xF;
+    int cascadeCount = frameUniforms.cascades & 0xF;
     return clamp(greaterZ.x + greaterZ.y + greaterZ.z + greaterZ.w, 0, cascadeCount - 1);
 }
 
-highp vec4 getCascadeLightSpacePosition(uint cascade) {
+highp vec4 getCascadeLightSpacePosition(int cascade) {
     // For the first cascade, return the interpolated light space position.
     // This branch will be coherent (mostly) for neighboring fragments, and it's worth avoiding
     // the matrix multiply inside computeLightSpacePosition.

shaders/src/surface_light_directional.fs

@@ -52,12 +52,12 @@ void evaluateDirectionalLight(const MaterialInputs material,
     if (light.NoL > 0.0) {
         float ssContactShadowOcclusion = 0.0;
 
-        uint cascade = getShadowCascade();
+        int cascade = getShadowCascade();
         bool cascadeHasVisibleShadows = bool(frameUniforms.cascades & ((1 << cascade) << 8));
         bool hasDirectionalShadows = bool(frameUniforms.directionalShadows & 1);
         if (hasDirectionalShadows && cascadeHasVisibleShadows) {
             highp vec4 shadowPosition = getShadowPosition(cascade);
-            visibility = shadow(true, sampler0_shadowMap, int(cascade), shadowPosition, 0.0);
+            visibility = shadow(true, sampler0_shadowMap, cascade, shadowPosition, 0.0);
 #if defined(MATERIAL_HAS_SHADOW_STRENGTH)
             applyShadowStrength(visibility, material.shadowStrength);
 #endif

shaders/src/surface_shading_unlit.fs

@@ -41,7 +41,7 @@ vec4 evaluateMaterial(const MaterialInputs material) {
 #if defined(VARIANT_HAS_DIRECTIONAL_LIGHTING)
 #if defined(VARIANT_HAS_SHADOWING)
     float visibility = 1.0;
-    uint cascade = getShadowCascade();
+    int cascade = getShadowCascade();
     bool cascadeHasVisibleShadows = bool(frameUniforms.cascades & ((1 << cascade) << 8));
     bool hasDirectionalShadows = bool(frameUniforms.directionalShadows & 1);
     if (hasDirectionalShadows && cascadeHasVisibleShadows) {

shaders/src/surface_shadowing.fs

@@ -485,7 +485,7 @@ float ShadowSample_VSM(const bool ELVSM, const highp sampler2DArray shadowMap,
 
 // get texture coordinate for directional and spot shadow maps
 #if defined(VARIANT_HAS_DIRECTIONAL_LIGHTING)
-highp vec4 getShadowPosition(const uint cascade) {
+highp vec4 getShadowPosition(const int cascade) {
     return getCascadeLightSpacePosition(cascade);
 }
 #endif

third_party/libgtest/tnt/CMakeLists.txt

@@ -4,13 +4,15 @@ project(gtest)
 set(OUR_DIR ${CMAKE_CURRENT_SOURCE_DIR}/..)
 
 set(TARGET              gtest)
-set(SRC_DIR             ${OUR_DIR}/googletest/src)
-set(PUBLIC_HDR_DIR      ${OUR_DIR}/googletest/include)
-set(PRIVATE_HDR_DIR     ${OUR_DIR}/googletest)
+set(TEST_SRC_DIR        ${OUR_DIR}/googletest/src)
+set(MOCK_SRC_DIR        ${OUR_DIR}/googlemock/src)
+set(PUBLIC_HDR_DIRS     ${OUR_DIR}/googletest/include ${OUR_DIR}/googlemock/include)
+set(PRIVATE_HDR_DIRS    ${OUR_DIR}/googletest ${OUR_DIR}/googlemock)
 
 # sources dependencies
 set(SRCS
-    ${SRC_DIR}/gtest-all.cc
+    ${TEST_SRC_DIR}/gtest-all.cc
+    ${MOCK_SRC_DIR}/gmock-all.cc
 )
 
 if (MSVC)
@@ -21,8 +23,8 @@ if (MSVC)
 endif()
 
 include_directories(
-    ${PUBLIC_HDR_DIR}
-    ${PRIVATE_HDR_DIR})
+    ${PUBLIC_HDR_DIRS}
+    ${PRIVATE_HDR_DIRS})
 
 # we're building a library
 add_library(${TARGET} STATIC ${SRCS})
@@ -34,5 +36,5 @@ if (LINUX)
 endif()
 
 # specify where the public headers of this library are
-target_include_directories(${TARGET} PUBLIC ${PUBLIC_HDR_DIR})
+target_include_directories(${TARGET} PUBLIC ${PUBLIC_HDR_DIRS})
 set_target_properties(${TARGET} PROPERTIES FOLDER ThirdParty)

web/filament-js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "filament",
-  "version": "1.58.1",
+  "version": "1.58.2",
   "description": "Real-time physically based rendering engine",
   "main": "filament.js",
   "module": "filament.js",