Fix test

.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/DriverEnums.h

@@ -1139,6 +1139,7 @@ struct ExternalSamplerDatum {
 static_assert(sizeof(ExternalSamplerDatum) == 12);
 
 struct DescriptorSetLayout {
+    std::string label;
     utils::FixedCapacityVector<DescriptorSetLayoutBinding> bindings;
 
 //  TODO: uncomment when needed

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

@@ -523,7 +523,7 @@ void WebGPUDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {}
 
 void WebGPUDriver::createDescriptorSetLayoutR(Handle<HwDescriptorSetLayout> dslh,
         backend::DescriptorSetLayout&& info) {
-    constructHandle<WebGPUDescriptorSetLayout>(dslh, std::move(info), mDevice);
+    constructHandle<WebGPUDescriptorSetLayout>(dslh, std::move(info), &mDevice);
 }
 
 void WebGPUDriver::createDescriptorSetR(Handle<HwDescriptorSet> dsh,
@@ -802,7 +802,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 +854,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

@@ -62,27 +62,28 @@ WGPUBufferObject::WGPUBufferObject(BufferObjectBinding bindingType, uint32_t byt
       bufferObjectBinding(bindingType) {}
 
 wgpu::ShaderStage WebGPUDescriptorSetLayout::filamentStageToWGPUStage(ShaderStageFlags fFlags) {
-    wgpu::ShaderStage retStages = wgpu::ShaderStage::None;
+    wgpu::ShaderStage ret = wgpu::ShaderStage::None;
     if (any(ShaderStageFlags::VERTEX & fFlags)) {
-        retStages |= wgpu::ShaderStage::Vertex;
+        ret |= wgpu::ShaderStage::Vertex;
     }
     if (any(ShaderStageFlags::FRAGMENT & fFlags)) {
-        retStages |= wgpu::ShaderStage::Fragment;
+        ret |= wgpu::ShaderStage::Fragment;
     }
     if (any(ShaderStageFlags::COMPUTE & fFlags)) {
-        retStages |= wgpu::ShaderStage::Compute;
+        ret |= wgpu::ShaderStage::Compute;
     }
-    return retStages;
+    return ret;
 }
 
 WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const& layout,
-        wgpu::Device const& device) {
-    assert_invariant(device);
+        wgpu::Device const* device) {
+    assert_invariant(device->Get());
 
     // 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 ||
@@ -141,12 +142,12 @@ WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const&
     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) },
+        .label{ "layout_"+ layout.label + 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);
+    mLayout = device->CreateBindGroupLayout(&layoutDescriptor);
 }
 WebGPUDescriptorSetLayout::~WebGPUDescriptorSetLayout() {}
 }// namespace filament::backend

filament/backend/src/webgpu/WebGPUHandles.h

@@ -69,7 +69,7 @@ struct WGPUBufferObject : HwBufferObject {
 };
 class WebGPUDescriptorSetLayout : public HwDescriptorSetLayout {
 public:
-    WebGPUDescriptorSetLayout(DescriptorSetLayout const& layout, wgpu::Device const& device);
+    WebGPUDescriptorSetLayout(DescriptorSetLayout const& layout, wgpu::Device const* device);
     ~WebGPUDescriptorSetLayout();
 
 private:

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

@@ -56,7 +56,7 @@ Shader::Shader(DriverApi& api, Cleanup& cleanup, ShaderConfig config) : mCleanup
     mProgram = cleanup.add(api.createProgram(std::move(prog)));
 
     mDescriptorSetLayout = cleanup.add(
-            api.createDescriptorSetLayout(DescriptorSetLayout{ kLayouts }));
+            api.createDescriptorSetLayout(DescriptorSetLayout{ "kLayouts", kLayouts }));
 }
 
 filament::backend::DescriptorSetHandle Shader::createDescriptorSet(DriverApi& api) const {

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

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 = {

libs/filabridge/src/DescriptorSets.cpp

@@ -33,11 +33,11 @@ namespace filament::descriptor_sets {
 
 using namespace backend;
 
-static DescriptorSetLayout const postProcessDescriptorSetLayout{{
+static DescriptorSetLayout const postProcessDescriptorSetLayout{"postProcess", {
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FRAME_UNIFORMS },
 }};
 
-static DescriptorSetLayout const depthVariantDescriptorSetLayout{{
+static DescriptorSetLayout const depthVariantDescriptorSetLayout{"depthVariant",{
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FRAME_UNIFORMS },
 }};
 
@@ -46,14 +46,14 @@ static DescriptorSetLayout const depthVariantDescriptorSetLayout{{
 // dedicated SSR vertex shader), which uses perViewDescriptorSetLayout.
 // This means that PerViewBindingPoints::SHADOWS must be in the layout even though it's not used
 // by the SSR variant.
-static DescriptorSetLayout const ssrVariantDescriptorSetLayout{{
+static DescriptorSetLayout const ssrVariantDescriptorSetLayout{"ssrVariant", {
    { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FRAME_UNIFORMS },
    { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::SHADOWS        },
    { DescriptorType::SAMPLER,                                   ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::STRUCTURE      },
    { DescriptorType::SAMPLER,                                   ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::SSR            },
 }};
 
-static DescriptorSetLayout perViewDescriptorSetLayout = {{
+static DescriptorSetLayout perViewDescriptorSetLayout = {"perView", {
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FRAME_UNIFORMS },
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::SHADOWS        },
     { DescriptorType::UNIFORM_BUFFER,                            ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::LIGHTS         },
@@ -68,7 +68,7 @@ static DescriptorSetLayout perViewDescriptorSetLayout = {{
     { DescriptorType::SAMPLER,                                   ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FOG            },
 }};
 
-static DescriptorSetLayout perRenderableDescriptorSetLayout = {{
+static DescriptorSetLayout perRenderableDescriptorSetLayout = {"preRenderable",{
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerRenderableBindingPoints::OBJECT_UNIFORMS, DescriptorFlags::DYNAMIC_OFFSET },
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerRenderableBindingPoints::BONES_UNIFORMS,  DescriptorFlags::DYNAMIC_OFFSET },
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerRenderableBindingPoints::MORPHING_UNIFORMS         },

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",