Create a helper for setting texture uniforms in backend tests.

BUGS=[407799122]

.github/workflows/presubmit.yml

@@ -112,12 +112,11 @@ jobs:
         run: pip install mako setuptools pyyaml
       - name: Run script
         run: |
-          echo "disabled test"
-#          bash test/renderdiff/test.sh
-#      - uses: actions/upload-artifact@v4
-#        with:
-#          name: presubmit-renderdiff-result
-#          path: ./out/renderdiff_tests
+          bash test/renderdiff/test.sh
+      - uses: actions/upload-artifact@v4
+        with:
+          name: presubmit-renderdiff-result
+          path: ./out/renderdiff_tests
 
   validate-wgsl-webgpu:
     name: validate-wgsl-webgpu

README.md

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

RELEASE_NOTES.md

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

android/gradle.properties

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

filament/backend/CMakeLists.txt

@@ -507,10 +507,8 @@ if (APPLE OR LINUX)
         test/Arguments.cpp
         test/ImageExpectations.cpp
         test/Lifetimes.cpp
-        test/PlatformRunner.cpp
         test/Shader.cpp
         test/SharedShaders.cpp
-        test/Skip.cpp
         test/test_FeedbackLoops.cpp
         test/test_Blit.cpp
         test/test_MissingRequiredAttributes.cpp
@@ -534,9 +532,6 @@ if (APPLE OR LINUX)
         filamat
         SPIRV
         spirv-cross-glsl)
-    # Create input/output directories for test result images.
-    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/images/actual_images)
-    file(COPY test/expected_images DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/images)
 endif()
 
 # TODO: Disabling IOS test due to breakage wrt glslang update

filament/backend/include/backend/BufferObjectStreamDescriptor.h

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

filament/backend/src/ostream.cpp

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

filament/backend/src/vulkan/VulkanPipelineCache.cpp

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

filament/backend/src/vulkan/VulkanPipelineCache.h

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

filament/backend/src/webgpu/WebGPUDriver.cpp

@@ -228,14 +228,6 @@ WebGPUDriver::WebGPUDriver(WebGPUPlatform& platform, const Platform::DriverConfi
               driverConfig.disableHeapHandleTags) {
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
     printInstanceDetails(mPlatform.getInstance());
-#endif
-    mAdapter = mPlatform.requestAdapter(nullptr);
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-    printAdapterDetails(mAdapter);
-#endif
-    mDevice = mPlatform.requestDevice(mAdapter);
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-    printDeviceDetails(mDevice);
 #endif
 }
 
@@ -344,9 +336,6 @@ void WebGPUDriver::destroyTimerQuery(Handle<HwTimerQuery> tqh) {
 }
 
 void WebGPUDriver::destroyDescriptorSetLayout(Handle<HwDescriptorSetLayout> tqh) {
-    if (tqh) {
-        destructHandle<WebGPUDescriptorSetLayout>(tqh);
-    }
 }
 
 void WebGPUDriver::destroyDescriptorSet(Handle<HwDescriptorSet> tqh) {
@@ -421,7 +410,8 @@ Handle<HwRenderTarget> WebGPUDriver::createDefaultRenderTargetS() noexcept {
 }
 
 Handle<HwDescriptorSetLayout> WebGPUDriver::createDescriptorSetLayoutS() noexcept {
-    return allocHandle<WebGPUDescriptorSetLayout>();
+    return Handle<HwDescriptorSetLayout>(
+            (Handle<HwDescriptorSetLayout>::HandleId) mNextFakeHandle++);
 }
 
 Handle<HwTexture> WebGPUDriver::createTextureExternalImageS() noexcept {
@@ -440,7 +430,14 @@ void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
     mNativeWindow = nativeWindow;
     assert_invariant(!mSwapChain);
     wgpu::Surface surface = mPlatform.createSurface(nativeWindow, flags);
-
+    mAdapter = mPlatform.requestAdapter(surface);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printAdapterDetails(mAdapter);
+#endif
+    mDevice = mPlatform.requestDevice(mAdapter);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printDeviceDetails(mDevice);
+#endif
     mQueue = mDevice.GetQueue();
     wgpu::Extent2D surfaceSize = mPlatform.getSurfaceExtent(mNativeWindow);
     mSwapChain = constructHandle<WebGPUSwapChain>(sch, std::move(surface), surfaceSize, mAdapter,
@@ -522,9 +519,7 @@ void WebGPUDriver::createFenceR(Handle<HwFence> fh, int) {}
 void WebGPUDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {}
 
 void WebGPUDriver::createDescriptorSetLayoutR(Handle<HwDescriptorSetLayout> dslh,
-        backend::DescriptorSetLayout&& info) {
-    constructHandle<WebGPUDescriptorSetLayout>(dslh, std::move(info), mDevice);
-}
+        backend::DescriptorSetLayout&& info) {}
 
 void WebGPUDriver::createDescriptorSetR(Handle<HwDescriptorSet> dsh,
         Handle<HwDescriptorSetLayout> dslh) {}
@@ -802,7 +797,7 @@ void WebGPUDriver::readPixels(Handle<HwRenderTarget> src,
     scheduleDestroy(std::move(p));
 }
 
-void WebGPUDriver::readBufferSubData(Handle<HwBufferObject> boh,
+void WebGPUDriver::readBufferSubData(backend::BufferObjectHandle boh,
         uint32_t offset, uint32_t size, backend::BufferDescriptor&& p) {
     scheduleDestroy(std::move(p));
 }
@@ -854,22 +849,22 @@ void WebGPUDriver::resetState(int) {
 }
 
 void WebGPUDriver::updateDescriptorSetBuffer(
-        Handle<HwDescriptorSet> dsh,
+        backend::DescriptorSetHandle dsh,
         backend::descriptor_binding_t binding,
-        Handle<HwBufferObject> boh,
+        backend::BufferObjectHandle boh,
         uint32_t offset,
         uint32_t size) {
 }
 
 void WebGPUDriver::updateDescriptorSetTexture(
-        Handle<HwDescriptorSet> dsh,
+        backend::DescriptorSetHandle dsh,
         backend::descriptor_binding_t binding,
-        Handle<HwTexture> th,
+        backend::TextureHandle th,
         SamplerParams params) {
 }
 
 void WebGPUDriver::bindDescriptorSet(
-        Handle<HwDescriptorSet> dsh,
+        backend::DescriptorSetHandle dsh,
         backend::descriptor_set_t set,
         backend::DescriptorSetOffsetArray&& offsets) {
 }

filament/backend/src/webgpu/WebGPUHandles.cpp

@@ -60,93 +60,4 @@ void WGPUVertexBuffer::setBuffer(WGPUBufferObject* bufferObject, uint32_t index)
 WGPUBufferObject::WGPUBufferObject(BufferObjectBinding bindingType, uint32_t byteCount)
     : HwBufferObject(byteCount),
       bufferObjectBinding(bindingType) {}
-
-wgpu::ShaderStage WebGPUDescriptorSetLayout::filamentStageToWGPUStage(ShaderStageFlags fFlags) {
-    wgpu::ShaderStage retStages = wgpu::ShaderStage::None;
-    if (any(ShaderStageFlags::VERTEX & fFlags)) {
-        retStages |= wgpu::ShaderStage::Vertex;
-    }
-    if (any(ShaderStageFlags::FRAGMENT & fFlags)) {
-        retStages |= wgpu::ShaderStage::Fragment;
-    }
-    if (any(ShaderStageFlags::COMPUTE & fFlags)) {
-        retStages |= wgpu::ShaderStage::Compute;
-    }
-    return retStages;
-}
-
-WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const& layout,
-        wgpu::Device const& device) {
-    assert_invariant(device);
-
-    // TODO: layoutDescriptor has a "Label". Ideally we can get info on what this layout is for
-    // debugging. For now, hack an incrementing value.
-    static int layoutNum = 0;
-
-    uint samplerCount =
-            std::count_if(layout.bindings.begin(), layout.bindings.end(), [](auto& fEntry) {
-                return fEntry.type == DescriptorType::SAMPLER ||
-                       fEntry.type == DescriptorType::SAMPLER_EXTERNAL;
-            });
-
-
-    std::vector<wgpu::BindGroupLayoutEntry> wEntries;
-    wEntries.reserve(layout.bindings.size() + samplerCount);
-
-    for (auto fEntry: layout.bindings) {
-        auto& wEntry = wEntries.emplace_back();
-        wEntry.visibility = filamentStageToWGPUStage(fEntry.stageFlags);
-        wEntry.binding = fEntry.binding * 2;
-
-        switch (fEntry.type) {
-            // TODO Metal treats these the same. Is this fine?
-            case DescriptorType::SAMPLER_EXTERNAL:
-            case DescriptorType::SAMPLER: {
-                // Sampler binding is 2n+1 due to split.
-                auto& samplerEntry = wEntries.emplace_back();
-                samplerEntry.binding = fEntry.binding * 2 + 1;
-                samplerEntry.visibility = wEntry.visibility;
-                // We are simply hoping that undefined and defaults suffices here.
-                samplerEntry.sampler.type = wgpu::SamplerBindingType::Undefined;
-                wEntry.texture.sampleType = wgpu::TextureSampleType::Undefined;
-                break;
-            }
-            case DescriptorType::UNIFORM_BUFFER: {
-                wEntry.buffer.hasDynamicOffset =
-                        any(fEntry.flags & DescriptorFlags::DYNAMIC_OFFSET);
-                wEntry.buffer.type = wgpu::BufferBindingType::Uniform;
-                // TODO: Ideally we fill minBindingSize
-                break;
-            }
-
-            case DescriptorType::INPUT_ATTACHMENT: {
-                // TODO: support INPUT_ATTACHMENT. Metal does not currently.
-                PANIC_POSTCONDITION("Input Attachment is not supported");
-                break;
-            }
-
-            case DescriptorType::SHADER_STORAGE_BUFFER: {
-                // TODO: Vulkan does not support this, can we?
-                PANIC_POSTCONDITION("Shader storage is not supported");
-                break;
-            }
-        }
-
-        // Currently flags are only used to specify dynamic offset.
-
-        // UNUSED
-        // fEntry.count
-    }
-
-    wgpu::BindGroupLayoutDescriptor layoutDescriptor{
-        // TODO: layoutDescriptor has a "Label". Ideally we can get info on what this layout is for
-        // debugging. For now, hack an incrementing value.
-        .label{ "layout_" + std::to_string(++layoutNum) },
-        .entryCount = wEntries.size(),
-        .entries = wEntries.data()
-    };
-    // TODO Do we need to defer this until we have more info on textures and samplers??
-    mLayout = device.CreateBindGroupLayout(&layoutDescriptor);
-}
-WebGPUDescriptorSetLayout::~WebGPUDescriptorSetLayout() {}
 }// namespace filament::backend

filament/backend/src/webgpu/WebGPUHandles.h

@@ -67,18 +67,6 @@ struct WGPUBufferObject : HwBufferObject {
     wgpu::Buffer buffer;
     const BufferObjectBinding bufferObjectBinding;
 };
-class WebGPUDescriptorSetLayout : public HwDescriptorSetLayout {
-public:
-    WebGPUDescriptorSetLayout(DescriptorSetLayout const& layout, wgpu::Device const& device);
-    ~WebGPUDescriptorSetLayout();
-
-private:
-    // TODO: If this is useful elsewhere, remove it from this class
-    // Convert Filament Shader Stage Flags bitmask to webgpu equivilant
-    static wgpu::ShaderStage filamentStageToWGPUStage(ShaderStageFlags fFlags);
-
-    wgpu::BindGroupLayout mLayout;
-};
 
 // TODO: Currently WGPUTexture is not used by WebGPU for useful task.
 // Update the struct when used by WebGPU driver.

filament/backend/test/BackendTest.cpp

@@ -43,12 +43,10 @@ using namespace image;
 namespace test {
 
 Backend BackendTest::sBackend = Backend::NOOP;
-OperatingSystem BackendTest::sOperatingSystem = OperatingSystem::OTHER;
 bool BackendTest::sIsMobilePlatform = false;
 
-void BackendTest::init(Backend backend, OperatingSystem operatingSystem, bool isMobilePlatform) {
+void BackendTest::init(Backend backend, bool isMobilePlatform) {
     sBackend = backend;
-    sOperatingSystem = operatingSystem;
     sIsMobilePlatform = isMobilePlatform;
 }
 
@@ -201,18 +199,6 @@ void BackendTest::readPixelsAndAssertHash(const char* testName, size_t width, si
     getDriverApi().readPixels(rt, 0, 0, width, height, std::move(pbd));
 }
 
-bool BackendTest::matchesEnvironment(Backend backend) {
-    return sBackend == backend;
-}
-
-bool BackendTest::matchesEnvironment(OperatingSystem operatingSystem) {
-    return sOperatingSystem == operatingSystem;
-}
-
-bool BackendTest::matchesEnvironment(OperatingSystem operatingSystem, Backend backend) {
-    return matchesEnvironment(operatingSystem) && matchesEnvironment(backend);
-}
-
 class Environment : public ::testing::Environment {
 public:
     virtual void SetUp() override {
@@ -224,8 +210,8 @@ public:
     }
 };
 
-void initTests(Backend backend, OperatingSystem operatingSystem, bool isMobile, int& argc, char* argv[]) {
-    BackendTest::init(backend, operatingSystem, isMobile);
+void initTests(Backend backend, bool isMobile, int& argc, char* argv[]) {
+    BackendTest::init(backend, isMobile);
     ::testing::InitGoogleTest(&argc, argv);
     ::testing::AddGlobalTestEnvironment(new Environment);
 }

filament/backend/test/BackendTest.h

@@ -31,10 +31,9 @@ namespace test {
 class BackendTest : public ::testing::Test {
 public:
 
-    static void init(Backend backend, OperatingSystem operatingSystem, bool isMobilePlatform);
+    static void init(Backend backend, bool isMobilePlatform);
 
     static Backend sBackend;
-    static OperatingSystem sOperatingSystem;
     static bool sIsMobilePlatform;
 
 protected:
@@ -72,10 +71,6 @@ protected:
     filament::backend::DriverApi& getDriverApi() { return *commandStream; }
     filament::backend::Driver& getDriver() { return *driver; }
 
-    static bool matchesEnvironment(Backend backend);
-    static bool matchesEnvironment(OperatingSystem operatingSystem);
-    static bool matchesEnvironment(OperatingSystem operatingSystem, Backend backend);
-
 private:
 
     filament::backend::Driver* driver = nullptr;

filament/backend/test/ImageExpectations.cpp

@@ -16,6 +16,7 @@
 
 #include "ImageExpectations.h"
 
+#include "gtest/gtest.h"
 #include "gmock/gmock.h"
 #include "absl/strings/str_format.h"
 #include "utils/Hash.h"
@@ -27,17 +28,14 @@
 #ifndef FILAMENT_IOS
 
 #include <imageio/ImageEncoder.h>
-#include <imageio/ImageDecoder.h>
 #include <image/ColorTransform.h>
 
 #endif
 
 ScreenshotParams::ScreenshotParams(int width, int height, std::string fileName,
-        uint32_t expectedHash)
-    : mWidth(width),
-      mHeight(height),
-      mExpectedPixelHash(expectedHash),
-      mFileName(std::move(fileName)) {}
+        uint32_t expectedPixelHash)
+        : mWidth(width), mHeight(height), mFileName(std::move(fileName)),
+          mExpectedPixelHash(expectedPixelHash) {}
 
 int ScreenshotParams::width() const {
     return mWidth;
@@ -51,28 +49,24 @@ uint32_t ScreenshotParams::expectedHash() const {
     return mExpectedPixelHash;
 }
 
-std::string ScreenshotParams::actualDirectoryPath() {
-    return "images/actual_images";
+std::string ScreenshotParams::outputDirectoryPath() const {
+    return ".";
 }
 
-std::string ScreenshotParams::actualFileName() const {
+std::string ScreenshotParams::generatedActualFileName() const {
     return absl::StrFormat("%s_actual.png", mFileName);
 }
 
-std::string ScreenshotParams::actualFilePath() const {
-    return absl::StrFormat("%s/%s", actualDirectoryPath(), actualFileName());
+std::string ScreenshotParams::generatedActualFilePath() const {
+    return absl::StrFormat("%s/%s", outputDirectoryPath(), generatedActualFileName());
 }
 
-std::string ScreenshotParams::expectedDirectoryPath() {
-    return "images/expected_images";
+std::string ScreenshotParams::goldenFileName() const {
+    return absl::StrFormat("%s_golden.png", mFileName);
 }
 
-std::string ScreenshotParams::expectedFileName() const {
-    return absl::StrFormat("%s.png", mFileName);
-}
-
-std::string ScreenshotParams::expectedFilePath() const {
-    return absl::StrFormat("%s/%s", expectedDirectoryPath(), expectedFileName());
+std::string ScreenshotParams::goldenFilePath() const {
+    return absl::StrFormat("%s/%s", outputDirectoryPath(), goldenFileName());
 }
 
 ImageExpectation::ImageExpectation(const char* fileName, int lineNumber,
@@ -100,14 +94,8 @@ void ImageExpectation::compareImage() const {
     EXPECT_THAT(bytesFilled, testing::IsTrue())
                         << "Render target wasn't copied to the buffer for " << mFileName;
     if (bytesFilled) {
-        LoadedPng loadedImage(mParams.expectedFilePath());
-        // Rather than directly compare the two images compare their hashes because comparing very
-        // large arrays generates way too much debug output to be useful.
         uint32_t actualHash = mResult.hash();
-        uint32_t loadedImageHash = loadedImage.hash();
-        EXPECT_THAT(actualHash, testing::Eq(loadedImageHash));
         EXPECT_THAT(actualHash, testing::Eq(mParams.expectedHash()));
-        // TODO: Add better debug output, such as generating a diff image.
     }
 }
 
@@ -148,7 +136,7 @@ RenderTargetDump::RenderTargetDump(filament::backend::DriverApi& api,
         image = image::toLinearWithAlpha<uint8_t>(internal->params.width(),
                 internal->params.height(),
                 internal->params.width() * 4, (uint8_t*)buffer);
-        std::string filePath = internal->params.actualFilePath();
+        std::string filePath = internal->params.generatedActualFilePath();
         std::ofstream pngStream(filePath, std::ios::binary | std::ios::trunc);
         image::ImageEncoder::encode(pngStream, image::ImageEncoder::Format::PNG, image, "",
                 filePath);
@@ -181,29 +169,4 @@ bool RenderTargetDump::bytesFilled() const {
     return mInternal->bytesFilled;
 }
 
-RenderTargetDump::Internal::Internal(const ScreenshotParams& params) : params(params) {}
-
-LoadedPng::LoadedPng(std::string filePath) {
-#ifndef FILAMENT_IOS
-    std::ifstream pngStream(filePath, std::ios::binary);
-    image::LinearImage loadedImage = image::ImageDecoder::decode(pngStream, filePath,
-            image::ImageDecoder::ColorSpace::LINEAR);
-    size_t valuesInImage = loadedImage.getWidth() * loadedImage.getHeight() *
-                          loadedImage.getChannels();
-    // The linear image is loaded with each component as [0.0, 1.0] but should be [0, 255], so
-    // convert them.
-    mBytes = std::vector<unsigned char>(valuesInImage);
-    for (int i = 0; i < valuesInImage; ++i) {
-        mBytes[i] = static_cast<uint8_t>(loadedImage.get<float>()[i] * 255.0f);
-    }
-#endif
-    // For platforms that don't support the image loading library, leave the loaded data blank.
-}
-
-uint32_t LoadedPng::hash() const {
-    EXPECT_THAT(mBytes, testing::Not(testing::IsEmpty()));
-    if (mBytes.empty()) {
-        return 0;
-    }
-    return utils::hash::murmur3((uint32_t*)mBytes.data(), mBytes.size() / 4, 0);
-}
+RenderTargetDump::Internal::Internal(const ScreenshotParams& params) : params(params) {}

filament/backend/test/ImageExpectations.h

@@ -46,12 +46,11 @@ public:
     int height() const;
     uint32_t expectedHash() const;
 
-    static std::string actualDirectoryPath();
-    std::string actualFileName() const;
-    std::string actualFilePath() const;
-    static std::string expectedDirectoryPath();
-    std::string expectedFileName() const;
-    std::string expectedFilePath() const;
+    std::string outputDirectoryPath() const;
+    std::string generatedActualFileName() const;
+    std::string generatedActualFilePath() const;
+    std::string goldenFileName() const;
+    std::string goldenFilePath() const;
 
 private:
     int mWidth;
@@ -99,16 +98,6 @@ private:
     std::unique_ptr<Internal> mInternal;
 };
 
-class LoadedPng {
-public:
-    explicit LoadedPng(std::string filePath);
-
-    uint32_t hash() const;
-
-private:
-    std::vector<unsigned char> mBytes;
-};
-
 class ImageExpectation {
 public:
     ImageExpectation(const char* fileName, int lineNumber, filament::backend::DriverApi& api,

filament/backend/test/PlatformRunner.cpp

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

filament/backend/test/PlatformRunner.h

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

filament/backend/test/Shader.cpp

@@ -23,6 +23,14 @@ namespace test {
 
 using namespace filament::backend;
 
+filament::backend::descriptor_binding_t TextureBindingConfig::getBinding() const {
+    return binding.value_or(0);
+}
+
+filament::backend::SamplerParams TextureBindingConfig::getParams() const {
+    return samplerParams.value_or(SamplerParams{});
+}
+
 Shader::Shader(DriverApi& api, Cleanup& cleanup, ShaderConfig config) : mCleanup(cleanup) {
     utils::FixedCapacityVector<DescriptorSetLayoutBinding> kLayouts(config.uniforms.size());
     for (unsigned char i = 0; i < config.uniforms.size(); ++i) {
@@ -57,6 +65,19 @@ Shader::Shader(DriverApi& api, Cleanup& cleanup, ShaderConfig config) : mCleanup
 
     mDescriptorSetLayout = cleanup.add(
             api.createDescriptorSetLayout(DescriptorSetLayout{ kLayouts }));
+
+    mDefaultDescriptorSet = createDescriptorSet(api);
+}
+
+void Shader::updateTextureUniform(filament::backend::DriverApi& api,
+        TextureBindingConfig config) const {
+    DescriptorSetHandle descriptorSet = config.descriptorSet.value_or(mDefaultDescriptorSet);
+    api.updateDescriptorSetTexture(descriptorSet, config.getBinding(), config.textureHandle,
+            config.getParams());
+
+    if (config.alsoBindToSet.has_value()) {
+        api.bindDescriptorSet(descriptorSet, *config.alsoBindToSet, {});
+    }
 }
 
 filament::backend::DescriptorSetHandle Shader::createDescriptorSet(DriverApi& api) const {

filament/backend/test/Shader.h

@@ -61,6 +61,18 @@ struct UniformBindingConfig {
     ResolvedUniformBindingConfig resolve();
 };
 
+struct TextureBindingConfig {
+    filament::backend::TextureHandle textureHandle;
+    std::optional<filament::backend::DescriptorSetHandle> descriptorSet;
+    std::optional<filament::backend::descriptor_binding_t> binding;
+    std::optional<filament::backend::SamplerParams> samplerParams;
+    // If present then the call to update the texture will also bind the descriptor set.
+    std::optional<filament::backend::descriptor_set_t> alsoBindToSet;
+
+    filament::backend::descriptor_binding_t getBinding() const;
+    filament::backend::SamplerParams getParams() const;
+};
+
 class Shader {
 public:
     // All graphics resources have their lifetime controlled by the Cleanup and not this object.
@@ -86,17 +98,20 @@ public:
     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;
+    void updateTextureUniform(filament::backend::DriverApi& api, TextureBindingConfig config) const;
 
     filament::backend::DescriptorSetHandle createDescriptorSet(
             filament::backend::DriverApi& api) const;
 
+    filament::backend::ProgramHandle getProgram() const;
+    filament::backend::DescriptorSetLayoutHandle getDescriptorSetLayout() const;
+
 protected:
     Cleanup& mCleanup;
     filament::backend::ProgramHandle mProgram;
     filament::backend::DescriptorSetLayoutHandle mDescriptorSetLayout;
+    // Used whenever the caller doesn't provide a descriptor set.
+    filament::backend::DescriptorSetHandle mDefaultDescriptorSet;
 };
 
 template<typename UniformType>
@@ -133,12 +148,8 @@ void Shader::bindUniform(filament::backend::DriverApi& api,
         UniformBindingConfig config) const {
     auto resolvedConfig = config.resolve<UniformType>();
 
-    filament::backend::DescriptorSetHandle descriptorSet;
-    if (resolvedConfig.descriptorSet.has_value()) {
-        descriptorSet = *resolvedConfig.descriptorSet;
-    } else {
-        descriptorSet = createDescriptorSet(api);
-    }
+    filament::backend::DescriptorSetHandle descriptorSet =
+            resolvedConfig.descriptorSet.value_or(mDefaultDescriptorSet);
 
     api.updateDescriptorSetBuffer(descriptorSet, resolvedConfig.binding, hwBuffer, 0,
             resolvedConfig.bufferSize);

filament/backend/test/Skip.cpp

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

filament/backend/test/Skip.h

@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2025 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TNT_SKIP_H
-#define TNT_SKIP_H
-
-#include <gtest/gtest.h>
-#include "BackendTest.h"
-
-// skipEnvironment must be a test::SkipEnvironment
-#define SKIP_IF(skipEnvironment)                                                                   \
-do {                                                                                               \
-    SkipEnvironment skip(skipEnvironment);                                                         \
-    if (skip.matches()) {                                                                          \
-        GTEST_SKIP() << "Skipping test as the " << skip.describe();                                \
-    }                                                                                              \
-} while (false)
-
-namespace test {
-
-struct SkipEnvironment {
-    SkipEnvironment(const SkipEnvironment&) = default;
-    explicit SkipEnvironment(test::Backend backend);
-    explicit SkipEnvironment(test::OperatingSystem os);
-    SkipEnvironment(test::OperatingSystem os, test::Backend backend);
-
-    std::optional<test::Backend> backend;
-    std::optional<test::OperatingSystem> os;
-    std::optional<bool> isMobile;
-
-    bool matches();
-    // Describes the current state of either matching or mismatching.
-    std::string describe();
-    // Describe all the non-null requirements.
-    std::string describe_requirements();
-    // Describes the environment's status for all the attributes that are non-null.
-    std::string describe_actual_environment();
-};
-
-} // namespace test
-
-#endif// TNT_SKIP_H

filament/backend/test/linux_runner.cpp

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

filament/backend/test/mac_runner.mm

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

filament/backend/test/test_Callbacks.cpp

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

filament/backend/test/test_FeedbackLoops.cpp

@@ -198,12 +198,14 @@ TEST_F(BackendTest, FeedbackLoops) {
                 params.viewport.width = kTexWidth >> targetLevel;
                 params.viewport.height = kTexHeight >> targetLevel;
 
+                // Each pass needs its own descriptor set.
                 auto descriptorSet = shader.createDescriptorSet(api);
                 auto textureView = passCleanup.add(api.createTextureView(texture, sourceLevel, 1));
-                api.updateDescriptorSetTexture(descriptorSet, 0, textureView, {
-                        .filterMag = SamplerMagFilter::LINEAR,
-                        .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
-                });
+                shader.updateTextureUniform(api,
+                        TextureBindingConfig{ .textureHandle = textureView,
+                            .descriptorSet = descriptorSet,
+                            .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::LINEAR,
+                                .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST } });
 
                 UniformBindingConfig uniformBinding{
                     .binding = 1,

filament/backend/test/test_LoadImage.cpp

@@ -329,12 +329,14 @@ TEST_F(LoadImageTest, UpdateImage2D) {
                     checkerboardPixelBuffer(t.pixelFormat, t.pixelType, 512, t.bufferPadding));
         }
 
+        // Each loop needs its own descriptor set.
         DescriptorSetHandle  descriptorSet = shader.createDescriptorSet(api);
-        api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
-                .filterMag = SamplerMagFilter::NEAREST,
-                .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
-
-        api.bindDescriptorSet(descriptorSet, 1, {});
+        shader.updateTextureUniform(api,
+                TextureBindingConfig{ .textureHandle = texture,
+                    .descriptorSet = descriptorSet,
+                    .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::NEAREST,
+                        .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST },
+                    .alsoBindToSet = 1 });
 
         renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
                 defaultRenderTarget, swapChain, shader.getProgram());
@@ -405,13 +407,11 @@ TEST_F(LoadImageTest, UpdateImageSRGB) {
     api.beginFrame(0, 0, 0);
 
     // Update samplers.
-    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
-    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
-            .filterMag = SamplerMagFilter::LINEAR,
-            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
-    });
-
-    api.bindDescriptorSet(descriptorSet, 1, {});
+    shader.updateTextureUniform(api,
+            TextureBindingConfig{ .textureHandle = texture,
+                    .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::LINEAR,
+                            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST },
+                    .alsoBindToSet = 1 });
 
     renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
             defaultRenderTarget, swapChain, shader.getProgram());
@@ -467,13 +467,11 @@ TEST_F(LoadImageTest, UpdateImageMipLevel) {
     api.beginFrame(0, 0, 0);
 
     // Update samplers.
-    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
-    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
-            .filterMag = SamplerMagFilter::LINEAR,
-            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
-    });
-
-    api.bindDescriptorSet(descriptorSet, 1, {});
+    shader.updateTextureUniform(api,
+            TextureBindingConfig{ .textureHandle = texture,
+                    .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::LINEAR,
+                            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST },
+                    .alsoBindToSet = 1 });
 
     renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
             defaultRenderTarget, swapChain, shader.getProgram());
@@ -541,13 +539,11 @@ TEST_F(LoadImageTest, UpdateImage3D) {
     api.beginFrame(0, 0, 0);
 
     // Update samplers.
-    DescriptorSetHandle  descriptorSet = shader.createDescriptorSet(api);
-    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
-            .filterMag = SamplerMagFilter::LINEAR,
-            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
-    });
-
-    api.bindDescriptorSet(descriptorSet, 1, {});
+    shader.updateTextureUniform(api,
+            TextureBindingConfig{ .textureHandle = texture,
+                .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::LINEAR,
+                    .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST },
+                .alsoBindToSet = 1 });
 
     renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
             defaultRenderTarget, swapChain, shader.getProgram());

filament/backend/test/test_MipLevels.cpp

@@ -171,11 +171,12 @@ TEST_F(BackendTest, TextureViewLod) {
         state.rasterState.culling = CullingMode::NONE;
 
         DescriptorSetHandle descriptorSet13 = texturedShader.createDescriptorSet(api);
-        api.updateDescriptorSetTexture(descriptorSet13, 0, texture13, {
-                .filterMag = SamplerMagFilter::NEAREST,
-                .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
-
-        api.bindDescriptorSet(descriptorSet13, 0, {});
+        texturedShader.updateTextureUniform(api,
+                TextureBindingConfig{ .textureHandle = texture13,
+                        .descriptorSet = descriptorSet13,
+                        .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::NEAREST,
+                                .filterMin = SamplerMinFilter::NEAREST },
+                        .alsoBindToSet = 0 });
 
         // Render a triangle to the screen, sampling from mip level 1.
         // Because the min level is 1, the result color should be the white triangle drawn in the
@@ -189,11 +190,12 @@ TEST_F(BackendTest, TextureViewLod) {
         auto texture22 = cleanup.add(api.createTextureView(texture, 2, 2));
 
         DescriptorSetHandle descriptorSet22 = texturedShader.createDescriptorSet(api);
-        api.updateDescriptorSetTexture(descriptorSet22, 0, texture22, {
-                .filterMag = SamplerMagFilter::NEAREST,
-                .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
-
-        api.bindDescriptorSet(descriptorSet22, 0, {});
+        texturedShader.updateTextureUniform(api,
+                TextureBindingConfig{ .textureHandle = texture22,
+                        .descriptorSet = descriptorSet22,
+                        .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::NEAREST,
+                                .filterMin = SamplerMinFilter::NEAREST },
+                        .alsoBindToSet = 0 });
 
         // Render a second, smaller, triangle, again sampling from mip level 1.
         // This triangle should be yellow striped.

filament/backend/test/test_PushConstants.cpp

@@ -18,7 +18,6 @@
 
 #include "Lifetimes.h"
 #include "ShaderGenerator.h"
-#include "Skip.h"
 #include "TrianglePrimitive.h"
 
 #include <utils/Hash.h>
@@ -79,8 +78,6 @@ void main() {
 })";
 
 TEST_F(BackendTest, PushConstants) {
-    SKIP_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::OPENGL));
-
     auto& api = getDriverApi();
 
     api.startCapture(0);

filament/backend/test/test_RenderExternalImage.cpp

@@ -84,14 +84,12 @@ TEST_F(BackendTest, RenderExternalImageWithoutSet) {
     state.rasterState.depthFunc = RasterState::DepthFunc::A;
     state.rasterState.culling = CullingMode::NONE;
 
-    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
-
     api.startCapture(0);
     api.makeCurrent(swapChain, swapChain);
     api.beginFrame(0, 0, 0);
 
-    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {});
-    api.bindDescriptorSet(descriptorSet, 1, {});
+    shader.updateTextureUniform(api,
+            TextureBindingConfig{ .textureHandle = texture, .alsoBindToSet = 1 });
 
     // Render a triangle.
     api.beginRenderPass(defaultRenderTarget, params);

ios/CocoaPods/Filament.podspec

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

web/filament-js/package.json

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