osmesa: Enable Mesa/OSMesa rendering for mac

This commit enables local running of the renderdiff tests and also for github workflows.
2025-03-18 17:01:22 -07:00
178 changed files with 937 additions and 9740 deletions
@@ -106,19 +106,16 @@ jobs:
        run: pip install mako setuptools pyyaml
      - name: Run script
        run: |
+          echo "$(brew --version)"
          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
-    runs-on: ubuntu-22.04-8core
+  validate-wgsl-pipeline:
+    name: validate-wgsl-pipeline
+    runs-on: ubuntu-22.04-4core

    steps:
      - uses: actions/checkout@v4.1.6
      - name: Run build script
-        run: source ./build/linux/ci-common.sh && ./build.sh -W debug test_filamat filament
+        run: source ./build/linux/ci-common.sh && ./build.sh -W debug test_filamat
      - name: Run test
        run: ./out/cmake-debug/libs/filamat/test_filamat --gtest_filter=MaterialCompiler.Wgsl*
@@ -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**]
-
@@ -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.0'
 }
 ```

@@ -51,7 +51,7 @@ Here are all the libraries available in the group `com.google.android.filament`:
 iOS projects can use CocoaPods to install the latest release:

 ```shell
-pod 'Filament', '~> 1.58.1'
+pod 'Filament', '~> 1.58.0'
 ```

 ## Documentation
@@ -7,10 +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.58.2
-
- engine: Generate 1D instead of 3D LUTs for color grading whenever possible.
-
 ## v1.58.1


@@ -46,8 +46,9 @@ import static com.google.android.filament.Asserts.assertFloat4In;
 *
 * <h1>Performance</h1>
 *
- * Creating a new ColorGrading object may be more expensive than other Filament objects as a LUT may
- * need to be generated. The generation of this LUT, if necessary, may happen on the CPU.
+ * Creating a new ColorGrading object may be more expensive than other Filament objects as a
+ * 3D LUT may need to be generated. The generation of a 3D LUT, if necessary, may happen on
+ * the CPU.
 *
 * <h1>Ordering</h1>
 *
@@ -159,10 +160,6 @@ public class ColorGrading {
         * quality level will use a 32x32x32 10 bit LUT, a high quality will use a 32x32x32 16 bit
         * LUT, and a ultra quality will use a 64x64x64 16 bit LUT.
         *
-         * This setting has no effect if generating a 1D LUT.
-         *
-         * This overrides the values set by format() and dimensions().
-         *
         * The default quality is {@link QualityLevel#MEDIUM}.
         *
         * @param qualityLevel The desired quality of the color grading process
@@ -178,8 +175,6 @@ public class ColorGrading {
         * When color grading is implemented using a 3D LUT, this sets the texture format of
         * of the LUT. This overrides the value set by quality().
         *
-         * This setting has no effect if generating a 1D LUT.
-         *
         * The default is INTEGER
         *
         * @param format The desired format of the 3D LUT.
@@ -195,8 +190,6 @@ public class ColorGrading {
         * When color grading is implemented using a 3D LUT, this sets the dimension of the LUT.
         * This overrides the value set by quality().
         *
-         * This setting has no effect if generating a 1D LUT.
-         *
         * The default is 32
         *
         * @param dim The desired dimension of the LUT. Between 16 and 64.
@@ -623,3 +616,4 @@ public class ColorGrading {

    private static native long nBuilderBuild(long nativeBuilder, long nativeEngine);
 }
+
@@ -31,6 +31,8 @@ package com.google.android.filament;
 *   <li>DisplayRangeToneMapper</li>
 * </ul>
 * </ul>
+ *
+ * You can create custom tone mapping operators by subclassing ToneMapper.
 */
 public class ToneMapper {
    private final long mNativeObject;
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.58.1
+VERSION_NAME=1.58.0

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

@@ -200,9 +200,8 @@ WEBGPU_ANDROID_GRADLE_OPTION=""
 EGL_ON_LINUX_OPTION="-DFILAMENT_SUPPORTS_EGL_ON_LINUX=OFF"

 MATDBG_OPTION="-DFILAMENT_ENABLE_MATDBG=OFF"
-MATDBG_GRADLE_OPTION=""
 FGVIEWER_OPTION="-DFILAMENT_ENABLE_FGVIEWER=OFF"
-FGVIEWER_GRADLE_OPTION=""
+MATDBG_GRADLE_OPTION=""

 MATOPT_OPTION=""
 MATOPT_GRADLE_OPTION=""
@@ -534,7 +533,6 @@ function build_android {
            ${VULKAN_ANDROID_GRADLE_OPTION} \
            ${WEBGPU_ANDROID_GRADLE_OPTION} \
            ${MATDBG_GRADLE_OPTION} \
-            ${FGVIEWER_GRADLE_OPTION} \
            ${MATOPT_GRADLE_OPTION} \
            :filament-android:assembleDebug \
            :gltfio-android:assembleDebug \
@@ -586,7 +584,6 @@ function build_android {
            ${VULKAN_ANDROID_GRADLE_OPTION} \
            ${WEBGPU_ANDROID_GRADLE_OPTION} \
            ${MATDBG_GRADLE_OPTION} \
-            ${FGVIEWER_GRADLE_OPTION} \
            ${MATOPT_GRADLE_OPTION} \
            :filament-android:assembleRelease \
            :gltfio-android:assembleRelease \
@@ -31,7 +31,7 @@ if [[ "$GITHUB_WORKFLOW" ]]; then
    sudo apt-get install mesa-common-dev libxi-dev libxxf86vm-dev

    # For dawn
-    sudo apt-get install libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libx11-xcb-dev
+    sudo apt-get install libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev

    sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang-${GITHUB_CLANG_VERSION} 100
    sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-${GITHUB_CLANG_VERSION} 100
@@ -13,7 +13,7 @@ This document is part of the [Filament project](https://github.com/google/filame
 ## Authors

 - [Romain Guy](https://github.com/romainguy), [@romainguy](https://twitter.com/romainguy)
- [Mathias Agopian](https://github.com/pixelflinger), [@pixelflinger](https://bsky.app/profile/pixelflinger.bsky.social)
+- [Mathias Agopian](https://github.com/pixelflinger), [@darthmoosious](https://twitter.com/darthmoosious)

 # Overview

@@ -78,27 +78,26 @@ in table [standardProperties].
        Property        |      Definition
 -----------------------:|:---------------------
 **baseColor**           | Diffuse albedo for non-metallic surfaces, and specular color for metallic surfaces
-**roughness**           | Perceived smoothness (1.0) or roughness (0.0) of a surface. Smooth surfaces exhibit sharp reflections
 **metallic**            | Whether a surface appears to be dielectric (0.0) or conductor (1.0). Often used as a binary value (0 or 1)
+**roughness**           | Perceived smoothness (1.0) or roughness (0.0) of a surface. Smooth surfaces exhibit sharp reflections
 **reflectance**         | Fresnel reflectance at normal incidence for dielectric surfaces. This directly controls the strength of the reflections
-**ambientOcclusion**    | Defines how much of the ambient light is accessible to a surface point. It is a per-pixel shadowing factor between 0.0 and 1.0
-**clearCoat**           | Strength of the clear coat layer
-**clearCoatRoughness**  | Perceived smoothness or roughness of the clear coat layer
-**clearCoatNormal**     | A detail normal used to perturb the clear coat layer using _bump mapping_ (_normal mapping_)
-**anisotropy**          | Amount of anisotropy in either the tangent or bitangent direction
-**anisotropyDirection** | Local surface direction in tangent space
-**thickness**           | Thickness of the solid volume of refractive objects
 **sheenColor**          | Strength of the sheen layer
 **sheenRoughness**      | Perceived smoothness or roughness of the sheen layer
-**emissive**            | Additional diffuse albedo to simulate emissive surfaces (such as neons, etc.) This property is mostly useful in an HDR pipeline with a bloom pass
+**clearCoat**           | Strength of the clear coat layer
+**clearCoatRoughness**  | Perceived smoothness or roughness of the clear coat layer
+**anisotropy**          | Amount of anisotropy in either the tangent or bitangent direction
+**anisotropyDirection** | Local surface direction in tangent space
+**ambientOcclusion**    | Defines how much of the ambient light is accessible to a surface point. It is a per-pixel shadowing factor between 0.0 and 1.0
 **normal**              | A detail normal used to perturb the surface using _bump mapping_ (_normal mapping_)
-**postLightingColor**   | Additional color that can be blended with the result of the lighting computations. See `postLightingBlending`
-**absorption**          | Absorption factor for refractive objects
-**transmission**        | Defines how much of the diffuse light of a dielectric is transmitted through the object, in other words this defines how transparent an object is
-**ior**                 | Index of refraction, either for refractive objects or as an alternative to reflectance
-**microThickness**      | Thickness of the thin layer of refractive objects
 **bentNormal**          | A normal pointing in the average unoccluded direction. Can be used to improve indirect lighting quality
-**shadowStrength**      | Strength factor between 0 and 1 for all shadows received by this material
+**clearCoatNormal**     | A detail normal used to perturb the clear coat layer using _bump mapping_ (_normal mapping_)
+**emissive**            | Additional diffuse albedo to simulate emissive surfaces (such as neons, etc.) This property is mostly useful in an HDR pipeline with a bloom pass
+**postLightingColor**   | Additional color that can be blended with the result of the lighting computations. See `postLightingBlending`
+**ior**                 | Index of refraction, either for refractive objects or as an alternative to reflectance
+**transmission**        | Defines how much of the diffuse light of a dielectric is transmitted through the object, in other words this defines how transparent an object is
+**absorption**          | Absorption factor for refractive objects
+**microThickness**      | Thickness of the thin layer of refractive objects
+**thickness**           | Thickness of the solid volume of refractive objects
 [Table [standardProperties]: Properties of the standard model]

 The type and range of each property is described in table [standardPropertiesTypes].
@@ -1273,9 +1272,6 @@ Description
      when selecting any shading model that is not `unlit`. See the shader sections of this document
      for more information on how to access these attributes from the shaders.

-!!! Note: Interaction with custom variables
-    When the `color` attribute is specified, only four custom variables are available instead of five.
-
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JSON
 material {
    parameters : [
@@ -1306,7 +1302,7 @@ Type
 :    array of `string`

 Value
-:     Up to 5 strings, each must be a valid GLSL identifier.
+:     Up to 4 strings, each must be a valid GLSL identifier.

 Description
 :     Defines custom interpolants (or variables) that are output by the material's vertex shader.
@@ -1322,10 +1318,6 @@ Description
      particular if `default` is specified the default precision is used is the fragment shader
      (`mediump`) and in the vertex shader (`highp`).

-!!! Warning: Interaction with required attributes
-    If the `color` attribute is specified in the `required` list, then only four variables can be used
-    instead of five.
-
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JSON
 material {
    name : Skybox,
@@ -177,12 +177,10 @@ endif()
 if (FILAMENT_SUPPORTS_VULKAN)
    list(APPEND SRCS
            include/backend/platforms/VulkanPlatform.h
-            src/vulkan/VulkanDescriptorSetCache.cpp
-            src/vulkan/VulkanDescriptorSetCache.h
-            src/vulkan/VulkanDescriptorSetLayoutCache.cpp
-            src/vulkan/VulkanDescriptorSetLayoutCache.h
-            src/vulkan/VulkanPipelineLayoutCache.cpp
-            src/vulkan/VulkanPipelineLayoutCache.h
+            src/vulkan/caching/VulkanDescriptorSetManager.cpp
+            src/vulkan/caching/VulkanDescriptorSetManager.h
+            src/vulkan/caching/VulkanPipelineLayoutCache.cpp
+            src/vulkan/caching/VulkanPipelineLayoutCache.h
            src/vulkan/memory/ResourceManager.cpp
            src/vulkan/memory/ResourceManager.h
            src/vulkan/memory/ResourcePointer.h
@@ -256,18 +256,16 @@ struct DescriptorSetLayoutBinding {
    DescriptorFlags flags = DescriptorFlags::NONE;
    uint16_t count = 0;

-    //  TODO: uncomment when needed.  Note that this class is used as hash key.  We need to ensure
-    //  no uninitialized padding bytes.
-    //    uint8_t externalSamplerDataIndex = EXTERNAL_SAMPLER_DATA_INDEX_UNUSED;
+    uint8_t externalSamplerDataIndex = EXTERNAL_SAMPLER_DATA_INDEX_UNUSED;

-    friend inline bool operator==(DescriptorSetLayoutBinding const& lhs,
+    friend inline bool operator==(
+            DescriptorSetLayoutBinding const& lhs,
            DescriptorSetLayoutBinding const& rhs) noexcept {
        return lhs.type == rhs.type &&
               lhs.flags == rhs.flags &&
               lhs.count == rhs.count &&
-               lhs.stageFlags == rhs.stageFlags;
-//               lhs.stageFlags == rhs.stageFlags &&
-//               lhs.externalSamplerDataIndex == rhs.externalSamplerDataIndex;
+               lhs.stageFlags == rhs.stageFlags &&
+               lhs.externalSamplerDataIndex == rhs.externalSamplerDataIndex;
    }
 };

@@ -1140,9 +1138,7 @@ static_assert(sizeof(ExternalSamplerDatum) == 12);

 struct DescriptorSetLayout {
    utils::FixedCapacityVector<DescriptorSetLayoutBinding> bindings;
-
-//  TODO: uncomment when needed
-//    utils::FixedCapacityVector<ExternalSamplerDatum> externalSamplerData;
+    utils::FixedCapacityVector<ExternalSamplerDatum> externalSamplerData;
 };

 //! blending equation function
@@ -33,7 +33,7 @@ public:
    PlatformCocoaGL();
    ~PlatformCocoaGL() noexcept override;

-    ExternalImageHandle UTILS_PUBLIC createExternalImage(void* cvPixelBuffer) noexcept;
+    ExternalImageHandle createExternalImage(void* cvPixelBuffer) noexcept;

 protected:
    // --------------------------------------------------------------------------------------------
@@ -32,7 +32,7 @@ public:
    PlatformCocoaTouchGL();
    ~PlatformCocoaTouchGL() noexcept override;

-    ExternalImageHandle UTILS_PUBLIC createExternalImage(void* cvPixelBuffer) noexcept;
+    ExternalImageHandle createExternalImage(void* cvPixelBuffer) noexcept;

    // --------------------------------------------------------------------------------------------
    // Platform Interface
@@ -50,7 +50,7 @@ public:
    /**
     * Creates an ExternalImage from a EGLImageKHR
     */
-    ExternalImageHandle UTILS_PUBLIC createExternalImage(EGLImageKHR eglImage) noexcept;
+    ExternalImageHandle createExternalImage(EGLImageKHR eglImage) noexcept;

 protected:
    // --------------------------------------------------------------------------------------------
@@ -23,7 +23,6 @@
 #include <backend/platforms/PlatformEGL.h>

 #include <utils/android/PerformanceHintManager.h>
-#include <utils/compiler.h>

 #include <chrono>

@@ -44,21 +43,8 @@ public:
    PlatformEGLAndroid() noexcept;
    ~PlatformEGLAndroid() noexcept override;

-    /**
-     * Creates an ExternalImage from a EGLImageKHR
-     */
-    ExternalImageHandle UTILS_PUBLIC createExternalImage(AHardwareBuffer const* buffer, bool sRGB) noexcept;
-
-    struct UTILS_PUBLIC ExternalImageDescAndroid {
-        uint32_t width;      // Texture width
-        uint32_t height;     // Texture height
-        TextureFormat format;// Texture format
-        TextureUsage usage;  // Texture usage flags
-    };
-
-    ExternalImageDescAndroid UTILS_PUBLIC getExternalImageDesc(ExternalImageHandle externalImage) noexcept;
-
 protected:
+
    // --------------------------------------------------------------------------------------------
    // Platform Interface

@@ -71,6 +57,11 @@ protected:
    Driver* createDriver(void* sharedContext,
            const Platform::DriverConfig& driverConfig) noexcept override;

+    /**
+     * Creates an ExternalImage from a EGLImageKHR
+     */
+    ExternalImageHandle createExternalImage(AHardwareBuffer const *buffer, bool sRGB) noexcept;
+
    // --------------------------------------------------------------------------------------------
    // OpenGLPlatform Interface

@@ -104,26 +95,15 @@ protected:
     */
    AcquiredImage transformAcquiredImage(AcquiredImage source) noexcept override;

-    OpenGLPlatform::ExternalTexture* createExternalImageTexture() noexcept override;
-    void destroyExternalImageTexture(ExternalTexture* texture) noexcept override;
+    bool setExternalImage(ExternalImageHandleRef externalImage, ExternalTexture* texture) noexcept override;

    struct ExternalImageEGLAndroid : public ExternalImageEGL {
        AHardwareBuffer* aHardwareBuffer = nullptr;
-        uint32_t width;      // Texture width
-        uint32_t height;     // Texture height
-        TextureFormat format;// Texture format
-        TextureUsage usage;  // Texture usage flags
        bool sRGB = false;
-
    protected:
        ~ExternalImageEGLAndroid() override;
    };

-    bool setExternalImage(ExternalImageHandleRef externalImage,
-            ExternalTexture* texture) noexcept override;
-    bool setImage(ExternalImageEGLAndroid const* eglExternalImage,
-            ExternalTexture* texture) noexcept;
-
 protected:
    bool makeCurrent(ContextType type,
            SwapChain* drawSwapChain,
@@ -368,16 +368,8 @@ public:
            uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
            VkImageViewType viewType, VkComponentMapping swizzle);

-protected:
-    virtual ExtensionSet getSwapchainInstanceExtensions() const;
-
-    using SurfaceBundle = std::tuple<VkSurfaceKHR, VkExtent2D>;
-    virtual SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
-            uint64_t flags) const noexcept;
-
 private:
-    // Platform dependent helper methods
-    static ExtensionSet getSwapchainInstanceExtensionsImpl();
+    static ExtensionSet getSwapchainInstanceExtensions();

    static ExternalImageMetadata getExternalImageMetadataImpl(ExternalImageHandleRef externalImage,
            VkDevice device);
@@ -394,7 +386,8 @@ private:
            VkComponentMapping swizzle);

    // Platform dependent helper methods
-    static SurfaceBundle createVkSurfaceKHRImpl(void* nativeWindow, VkInstance instance,
+    using SurfaceBundle = std::tuple<VkSurfaceKHR, VkExtent2D>;
+    static SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
            uint64_t flags) noexcept;

    friend struct VulkanPlatformPrivate;
@@ -17,55 +17,27 @@
 #ifndef TNT_FILAMENT_BACKEND_PLATFORMS_VULKAN_PLATFORM_ANDROID_H
 #define TNT_FILAMENT_BACKEND_PLATFORMS_VULKAN_PLATFORM_ANDROID_H

-#include <backend/DriverEnums.h>
-#include <backend/platforms/VulkanPlatform.h>
+#include <backend/Platform.h>

 #include <android/hardware_buffer.h>

-namespace filament::backend {
+namespace filament::backend::fvkandroid {

-class VulkanPlatformAndroid : public VulkanPlatform {
-public:
-    Platform::ExternalImageHandle UTILS_PUBLIC createExternalImage(AHardwareBuffer const* buffer,
-            bool sRGB) noexcept;
-
-    struct UTILS_PUBLIC ExternalImageDescAndroid {
-        uint32_t width;      // Texture width
-        uint32_t height;     // Texture height
-        TextureFormat format;// Texture format
-        TextureUsage usage;  // Texture usage flags
-    };
-
-    ExternalImageDescAndroid UTILS_PUBLIC getExternalImageDesc(
-            ExternalImageHandleRef externalImage) const noexcept;
+struct ExternalImageVulkanAndroid : public Platform::ExternalImage {
+    AHardwareBuffer* aHardwareBuffer = nullptr;
+    bool sRGB = false;
+    unsigned int width;   // Texture width
+    unsigned int height;  // Texture height
+    TextureFormat format; // Texture format
+    TextureUsage usage;   // Texture usage flags

 protected:
-    struct ExternalImageVulkanAndroid : public Platform::ExternalImage {
-        AHardwareBuffer* aHardwareBuffer = nullptr;
-        bool sRGB = false;
-        unsigned int width;  // Texture width
-        unsigned int height; // Texture height
-        TextureFormat format;// Texture format
-        TextureUsage usage;  // Texture usage flags
-
-    protected:
-        ~ExternalImageVulkanAndroid() override;
-    };
-
-    virtual ExternalImageMetadata getExternalImageMetadata(ExternalImageHandleRef externalImage);
-
-    using ImageData = VulkanPlatform::ImageData;
-    virtual ImageData createExternalImageData(ExternalImageHandleRef externalImage,
-            const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex,
-            VkImageUsageFlags usage);
-
-    virtual ExtensionSet getSwapchainInstanceExtensions() const;
-
-    using SurfaceBundle = VulkanPlatform::SurfaceBundle;
-    virtual SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
-            uint64_t flags) const noexcept;
+    ~ExternalImageVulkanAndroid() override;
 };

-}// namespace filament::backend
+Platform::ExternalImageHandle createExternalImage(AHardwareBuffer const* buffer,
+        bool sRGB) noexcept;

-#endif// TNT_FILAMENT_BACKEND_PLATFORMS_VULKAN_PLATFORM_ANDROID_H
+} // namespace filament::backend::fvkandroid
+
+#endif // TNT_FILAMENT_BACKEND_PLATFORMS_VULKAN_PLATFORM_ANDROID_H
@@ -19,11 +19,6 @@
 #include <utils/Systrace.h>
 #include <utils/debug.h>

-// We need to keep this up top for the linux (X11) name collisions.
-#if defined(FILAMENT_SUPPORTS_WEBGPU)
-    #include "backend/platforms/WebGPUPlatform.h"
-#endif
-
 #if defined(__ANDROID__)
    #include <sys/system_properties.h>
    #if defined(FILAMENT_SUPPORTS_OPENGL) && !defined(FILAMENT_USE_EXTERNAL_GLES3)
@@ -64,11 +59,7 @@
 #endif

 #if defined(FILAMENT_DRIVER_SUPPORTS_VULKAN)
-    #if defined(__ANDROID__)
-        #include "backend/platforms/VulkanPlatformAndroid.h"
-    #else
-        #include "backend/platforms/VulkanPlatform.h"
-    #endif
+    #include "backend/platforms/VulkanPlatform.h"
 #endif

 #if defined (FILAMENT_SUPPORTS_METAL)
@@ -78,6 +69,9 @@ filament::backend::Platform* createDefaultMetalPlatform();
 #endif

 #include "noop/PlatformNoop.h"
+#if defined(FILAMENT_SUPPORTS_WEBGPU)
+    #include "backend/platforms/WebGPUPlatform.h"
+#endif

 namespace filament::backend {

@@ -114,11 +108,7 @@ Platform* PlatformFactory::create(Backend* backend) noexcept {
    }
    if (*backend == Backend::VULKAN) {
        #if defined(FILAMENT_DRIVER_SUPPORTS_VULKAN)
-            #if defined(__ANDROID__)
-                return new VulkanPlatformAndroid();
-            #else
-                return new VulkanPlatform();
-            #endif
+            return new VulkanPlatform();
        #else
            return nullptr;
        #endif
@@ -241,7 +241,7 @@ size_t NoopDriver::getMaxUniformBufferSize() {
 }

 size_t NoopDriver::getMaxTextureSize(SamplerType target) {
-    return 4096u;
+    return 2048u;
 }

 size_t NoopDriver::getMaxArrayTextureLayers() {
@@ -20,7 +20,7 @@

 namespace filament::backend {

-Driver* PlatformNoop::createDriver(void* sharedGLContext, const Platform::DriverConfig& driverConfig) noexcept {
+Driver* PlatformNoop::createDriver(void* const sharedGLContext, const Platform::DriverConfig& driverConfig) noexcept {
    return NoopDriver::create();
 }

@@ -148,8 +148,8 @@ using namespace utils;
 namespace filament::backend {

 Driver* OpenGLDriverFactory::create(
-        OpenGLPlatform* platform,
-        void* sharedGLContext,
+        OpenGLPlatform* const platform,
+        void* const sharedGLContext,
        const Platform::DriverConfig& driverConfig) noexcept {
    return OpenGLDriver::create(platform, sharedGLContext, driverConfig);
 }
@@ -159,10 +159,10 @@ using namespace GLUtils;
 // ------------------------------------------------------------------------------------------------

 UTILS_NOINLINE
-OpenGLDriver* OpenGLDriver::create(OpenGLPlatform* platform,
-        void* /*sharedGLContext*/, const Platform::DriverConfig& driverConfig) noexcept {
+OpenGLDriver* OpenGLDriver::create(OpenGLPlatform* const platform,
+        void* const /*sharedGLContext*/, const Platform::DriverConfig& driverConfig) noexcept {
    assert_invariant(platform);
-    OpenGLPlatform* ec = platform;
+    OpenGLPlatform* const ec = platform;

 #if 0
    // this is useful for development, but too verbose even for debug builds
@@ -230,7 +230,7 @@ OpenGLDriver* OpenGLDriver::create(OpenGLPlatform* platform,
    constexpr size_t defaultSize = FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB * 1024U * 1024U;
    Platform::DriverConfig validConfig{ driverConfig };
    validConfig.handleArenaSize = std::max(driverConfig.handleArenaSize, defaultSize);
-    OpenGLDriver* driver = new(std::nothrow) OpenGLDriver(ec, validConfig);
+    OpenGLDriver* const driver = new(std::nothrow) OpenGLDriver(ec, validConfig);
    return driver;
 }

@@ -64,7 +64,7 @@ PlatformCocoaTouchGL::~PlatformCocoaTouchGL() noexcept {
    delete pImpl;
 }

-Driver* PlatformCocoaTouchGL::createDriver(void* sharedGLContext, const Platform::DriverConfig& driverConfig) noexcept {
+Driver* PlatformCocoaTouchGL::createDriver(void* const sharedGLContext, const Platform::DriverConfig& driverConfig) noexcept {
    EAGLSharegroup* sharegroup = (__bridge EAGLSharegroup*) sharedGLContext;

    EAGLContext *context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES3 sharegroup:sharegroup];
@@ -19,7 +19,6 @@
 #include <backend/platforms/PlatformEGL.h>
 #include <backend/platforms/PlatformEGLAndroid.h>

-#include <private/backend/BackendUtilsAndroid.h>
 #include <private/backend/VirtualMachineEnv.h>

 #include "opengl/GLUtils.h"
@@ -35,8 +34,6 @@
 #include <utils/ostream.h>
 #include <utils/Panic.h>
 #include <utils/Log.h>
-#include <utils/compiler.h>
-#include <utils/ostream.h>

 #include <EGL/egl.h>
 #include <EGL/eglext.h>
@@ -234,133 +231,26 @@ Driver* PlatformEGLAndroid::createDriver(void* sharedContext,
    return driver;
 }

-PlatformEGLAndroid::ExternalImageEGLAndroid::~ExternalImageEGLAndroid() {
-    if (__builtin_available(android 26, *)) {
-        if (aHardwareBuffer) {
-            AHardwareBuffer_release(aHardwareBuffer);
-        }
-    }
-}
+PlatformEGLAndroid::ExternalImageEGLAndroid::~ExternalImageEGLAndroid() = default;

-Platform::ExternalImageHandle PlatformEGLAndroid::createExternalImage(AHardwareBuffer const* buffer,
-        bool sRGB) noexcept {
-    if (__builtin_available(android 26, *)) {
-        auto* const p = new (std::nothrow) ExternalImageEGLAndroid;
-        auto hardwareBuffer = const_cast<AHardwareBuffer*>(buffer);
-        AHardwareBuffer_acquire(hardwareBuffer);
-        p->aHardwareBuffer = hardwareBuffer;
-        p->sRGB = sRGB;
-        AHardwareBuffer_Desc hardwareBufferDescription = {};
-        AHardwareBuffer_describe(hardwareBuffer, &hardwareBufferDescription);
-        p->height = hardwareBufferDescription.height;
-        p->width = hardwareBufferDescription.width;
-        auto textureFormat = mapToFilamentFormat(hardwareBufferDescription.format, sRGB);
-        p->usage = mapToFilamentUsage(hardwareBufferDescription.usage, textureFormat);
-        return ExternalImageHandle{ p };
-    }
-
-    return Platform::ExternalImageHandle{};
-}
-
-PlatformEGLAndroid::ExternalImageDescAndroid PlatformEGLAndroid::getExternalImageDesc(
-        ExternalImageHandle externalImage) noexcept {
-    auto const* const eglExternalImage =
-            static_cast<ExternalImageEGLAndroid const*>(externalImage.get());
-    ExternalImageDescAndroid metadata = {};
-    if (!eglExternalImage) {
-        return metadata;
-    }
-    metadata.height = eglExternalImage->height;
-    metadata.width = eglExternalImage->width;
-    metadata.format = eglExternalImage->format;
-    metadata.usage = eglExternalImage->usage;
-    return metadata;
+Platform::ExternalImageHandle PlatformEGLAndroid::createExternalImage(AHardwareBuffer const* buffer, bool sRGB) noexcept {
+    auto* const p = new(std::nothrow) ExternalImageEGLAndroid;
+    p->aHardwareBuffer = const_cast<AHardwareBuffer*>(buffer);
+    p->sRGB = sRGB;
+    return ExternalImageHandle{ p };
 }

 bool PlatformEGLAndroid::setExternalImage(ExternalImageHandleRef externalImage,
        UTILS_UNUSED_IN_RELEASE ExternalTexture* texture) noexcept {
-    auto const* const eglExternalImage =
-            static_cast<ExternalImageEGLAndroid const*>(externalImage.get());
+    auto const* const eglExternalImage = static_cast<ExternalImageEGLAndroid const*>(externalImage.get());
    if (eglExternalImage->aHardwareBuffer) {
-        return PlatformEGLAndroid::setImage(eglExternalImage, texture);
+        // TODO: implement PlatformEGLAndroid::setExternalImage w/ AHardwareBuffer
+        return true;
    }
    // not a AHardwareBuffer, fallback to the inherited version
    return PlatformEGL::setExternalImage(externalImage, texture);
 }

-OpenGLPlatform::ExternalTexture* PlatformEGLAndroid::createExternalImageTexture() noexcept {
-    ExternalTexture* outTexture = new (std::nothrow) ExternalTexture{};
-    glGenTextures(1, &outTexture->id);
-    return outTexture;
-}
-
-void PlatformEGLAndroid::destroyExternalImageTexture(ExternalTexture* texture) noexcept {
-    glDeleteTextures(1, &texture->id);
-    delete texture;
-}
-
-bool PlatformEGLAndroid::setImage(ExternalImageEGLAndroid const* eglExternalImage,
-        UTILS_UNUSED_IN_RELEASE ExternalTexture* texture) noexcept {
-    AHardwareBuffer* hardwareBuffer = eglExternalImage->aHardwareBuffer;
-
-    // Get the EGL client buffer from AHardwareBuffer
-    EGLClientBuffer clientBuffer = eglGetNativeClientBufferANDROID(hardwareBuffer);
-    EGLint imageAttrs[] = {
-        EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
-        EGL_NONE, EGL_NONE,  // Reserve space
-        EGL_NONE, EGL_NONE,  // Reserve space
-        EGL_NONE             // Ensure the list always ends with EGL_NONE
-    };
-    int attrIndex = 2;
-    if (eglExternalImage->sRGB) {
-        imageAttrs[attrIndex++] = EGL_GL_COLORSPACE;
-        imageAttrs[attrIndex++] = EGL_GL_COLORSPACE_SRGB;
-    }
-
-    if (static_cast<bool>(eglExternalImage->usage & TextureUsage::PROTECTED)) {
-        imageAttrs[attrIndex++] = EGL_PROTECTED_CONTENT_EXT;
-        imageAttrs[attrIndex++] = EGL_TRUE;
-    }
-    // Create an EGLImage from the client buffer
-    EGLImageKHR eglImage = eglCreateImageKHR(eglGetCurrentDisplay(), EGL_NO_CONTEXT,
-            EGL_NATIVE_BUFFER_ANDROID, clientBuffer, imageAttrs);
-    if (eglImage == EGL_NO_IMAGE_KHR) {
-        // Handle error
-        slog.e << "Failed to create EGL image" << io::endl;
-        glDeleteTextures(1, &texture->id);
-        return false;
-    }
-
-    // Create and bind the OpenGL texture
-    GLint prevActiveTexture, prevTexture;
-    glGetIntegerv(GL_ACTIVE_TEXTURE, &prevActiveTexture);
-    glGetIntegerv(GL_TEXTURE_BINDING_2D, &prevTexture);
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(texture->target, texture->id);
-    GLenum error = glGetError();
-    if (UTILS_UNLIKELY(error != GL_NO_ERROR)) {
-        slog.e << "Error after glBindTexture: " << error << io::endl;
-        glDeleteTextures(1, &texture->id);
-        eglDestroyImageKHR(eglGetCurrentDisplay(), eglImage);
-        glActiveTexture(prevActiveTexture);
-        glBindTexture(GL_TEXTURE_2D, prevTexture);
-        return false;
-    }
-    glEGLImageTargetTexture2DOES(texture->target, static_cast<GLeglImageOES>(eglImage));
-    error = glGetError();
-    if (UTILS_UNLIKELY(error != GL_NO_ERROR)) {
-        slog.e << "Error after glEGLImageTargetTexture2DOES: " << error << io::endl;
-        glDeleteTextures(1, &texture->id);
-        eglDestroyImageKHR(eglGetCurrentDisplay(), eglImage);
-        glActiveTexture(prevActiveTexture);
-        glBindTexture(GL_TEXTURE_2D, prevTexture);
-        return false;
-    }
-    glActiveTexture(prevActiveTexture);
-    glBindTexture(GL_TEXTURE_2D, prevTexture);
-    return true;
-}
-
 void PlatformEGLAndroid::setPresentationTime(int64_t presentationTimeInNanosecond) noexcept {
    EGLSurface currentDrawSurface = eglGetCurrentSurface(EGL_DRAW);
    if (currentDrawSurface != EGL_NO_SURFACE) {
@@ -128,7 +128,7 @@ namespace filament::backend {

 using namespace backend;

-Driver* PlatformGLX::createDriver(void* sharedGLContext,
+Driver* PlatformGLX::createDriver(void* const sharedGLContext,
        const DriverConfig& driverConfig) noexcept {
    loadLibraries();
    // Get the display device
@@ -112,7 +112,7 @@ private:

 }// anonymous namespace

-Driver* PlatformOSMesa::createDriver(void* sharedGLContext,
+Driver* PlatformOSMesa::createDriver(void* const sharedGLContext,
        const DriverConfig& driverConfig) noexcept {

    OSMesaAPI* api = new OSMesaAPI();
@@ -75,7 +75,7 @@ struct WGLSwapChain {

 static PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribs = nullptr;

-Driver* PlatformWGL::createDriver(void* sharedGLContext,
+Driver* PlatformWGL::createDriver(void* const sharedGLContext,
        const Platform::DriverConfig& driverConfig) noexcept {
    int result = 0;
    int pixelFormat = 0;
@@ -20,7 +20,7 @@ namespace filament::backend {

 using namespace backend;

-Driver* PlatformWebGL::createDriver(void* sharedGLContext,
+Driver* PlatformWebGL::createDriver(void* const sharedGLContext,
        const Platform::DriverConfig& driverConfig) noexcept {
    return OpenGLPlatform::createDefaultDriver(this, sharedGLContext, driverConfig);
 }
@@ -1,110 +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 "VulkanDescriptorSetLayoutCache.h"
-
-#include "VulkanHandles.h"
-
-namespace filament::backend {
-
-namespace {
-
-using BitmaskGroup = VulkanDescriptorSetLayout::Bitmask;
-
-template<typename Bitmask>
-uint32_t appendBindings(VkDescriptorSetLayoutBinding* toBind, VkDescriptorType type,
-        Bitmask const& mask) {
-    uint32_t count = 0;
-    Bitmask alreadySeen;
-    mask.forEachSetBit([&](size_t index) {
-        VkShaderStageFlags stages = 0;
-        uint32_t binding = 0;
-        if (index < fvkutils::getFragmentStageShift<Bitmask>()) {
-            binding = (uint32_t) index;
-            stages |= VK_SHADER_STAGE_VERTEX_BIT;
-            auto fragIndex = index + fvkutils::getFragmentStageShift<Bitmask>();
-            if (mask.test(fragIndex)) {
-                stages |= VK_SHADER_STAGE_FRAGMENT_BIT;
-                alreadySeen.set(fragIndex);
-            }
-        } else if (!alreadySeen.test(index)) {
-            // We are in fragment stage bits
-            binding = (uint32_t) (index - fvkutils::getFragmentStageShift<Bitmask>());
-            stages |= VK_SHADER_STAGE_FRAGMENT_BIT;
-        }
-
-        if (stages) {
-            toBind[count++] = {
-                .binding = binding,
-                .descriptorType = type,
-                .descriptorCount = 1,
-                .stageFlags = stages,
-            };
-        }
-    });
-    return count;
-}
-
-} // anonymous namespace
-
-VulkanDescriptorSetLayoutCache::VulkanDescriptorSetLayoutCache(VkDevice device,
-        fvkmemory::ResourceManager* resourceManager)
-    : mDevice(device),
-      mResourceManager(resourceManager) {}
-
-VulkanDescriptorSetLayoutCache::~VulkanDescriptorSetLayoutCache() = default;
-
-void VulkanDescriptorSetLayoutCache::terminate() noexcept {
-    for (auto& itr: mVkLayouts) {
-        vkDestroyDescriptorSetLayout(mDevice, itr.second, VKALLOC);
-    }
-}
-
-fvkmemory::resource_ptr<VulkanDescriptorSetLayout> VulkanDescriptorSetLayoutCache::createLayout(
-        Handle<HwDescriptorSetLayout> handle, backend::DescriptorSetLayout&& info) {
-    auto layout = fvkmemory::resource_ptr<VulkanDescriptorSetLayout>::make(mResourceManager, handle,
-            info);
-    VkDescriptorSetLayout vklayout = VK_NULL_HANDLE;
-    auto const& bitmasks = layout->bitmask;
-    if (auto itr = mVkLayouts.find(bitmasks); itr != mVkLayouts.end()) {
-        vklayout = itr->second;
-    } else {
-        VkDescriptorSetLayoutBinding toBind[VulkanDescriptorSetLayout::MAX_BINDINGS];
-        uint32_t count = 0;
-        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
-                bitmasks.dynamicUbo);
-        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, bitmasks.ubo);
-        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-                bitmasks.sampler);
-        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
-                bitmasks.inputAttachment);
-
-        assert_invariant(count != 0 && "Need at least one binding for descriptor set layout.");
-        VkDescriptorSetLayoutCreateInfo dlinfo = {
-            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-            .pNext = nullptr,
-            .bindingCount = count,
-            .pBindings = toBind,
-        };
-
-        vkCreateDescriptorSetLayout(mDevice, &dlinfo, VKALLOC, &vklayout);
-        mVkLayouts[bitmasks] = vklayout;
-    }
-    layout->setVkLayout(vklayout);
-    return layout;
-}
-
-} // namespace filament::backend
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2025 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETLAYOUTCACHE_H
-#define TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETLAYOUTCACHE_H
-
-#include "VulkanHandles.h"
-
-#include "vulkan/memory/ResourcePointer.h"
-
-#include <backend/DriverEnums.h>
-#include <backend/Program.h>
-#include <backend/TargetBufferInfo.h>
-
-#include <utils/bitset.h>
-
-#include <bluevk/BlueVK.h>
-#include <tsl/robin_map.h>
-
-#include <memory>
-
-namespace filament::backend {
-
-class VulkanDescriptorSetLayoutCache {
-public:
-    VulkanDescriptorSetLayoutCache(VkDevice device, fvkmemory::ResourceManager* resourceManager);
-    ~VulkanDescriptorSetLayoutCache();
-
-    void terminate() noexcept;
-
-    fvkmemory::resource_ptr<VulkanDescriptorSetLayout> createLayout(
-            Handle<HwDescriptorSetLayout> handle, backend::DescriptorSetLayout&& info);
-
-private:
-    VkDevice mDevice;
-    fvkmemory::ResourceManager* mResourceManager;
-
-    using BitmaskGroup = VulkanDescriptorSetLayout::Bitmask;
-    using BitmaskGroupHashFn = utils::hash::MurmurHashFn<BitmaskGroup>;
-    struct BitmaskGroupEqual {
-        bool operator()(BitmaskGroup const& k1, BitmaskGroup const& k2) const { return k1 == k2; }
-    };
-
-    tsl::robin_map<BitmaskGroup, VkDescriptorSetLayout, BitmaskGroupHashFn, BitmaskGroupEqual>
-            mVkLayouts;
-};
-
-} // namespace filament::backend
-
-#endif// TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETLAYOUTCACHE_H
@@ -17,6 +17,7 @@
 #include "VulkanDriver.h"

 #include "CommandStreamDispatcher.h"
+#include "DataReshaper.h"
 #include "SystraceProfile.h"
 #include "VulkanAsyncHandles.h"
 #include "VulkanBuffer.h"
@@ -34,6 +35,7 @@
 #include <backend/platforms/VulkanPlatform.h>

 #include <utils/CString.h>
+#include <utils/FixedCapacityVector.h>
 #include <utils/Panic.h>

 #ifndef NDEBUG
@@ -42,6 +44,8 @@

 using namespace bluevk;

+using utils::FixedCapacityVector;
+
 #if defined(__clang__)
 // Vulkan functions often immediately dereference pointers, so it's fine to pass in a pointer
 // to a stack-allocated variable.
@@ -215,8 +219,7 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
      mSamplerCache(mPlatform->getDevice()),
      mBlitter(mPlatform->getPhysicalDevice(), &mCommands),
      mReadPixels(mPlatform->getDevice()),
-      mDescriptorSetLayoutCache(mPlatform->getDevice(), &mResourceManager),
-      mDescriptorSetCache(mPlatform->getDevice(), &mResourceManager),
+      mDescriptorSetManager(mPlatform->getDevice(), &mResourceManager),
      mQueryManager(mPlatform->getDevice()),
      mIsSRGBSwapChainSupported(mPlatform->getCustomization().isSRGBSwapChainSupported),
      mStereoscopicType(driverConfig.stereoscopicType) {
@@ -326,8 +329,7 @@ void VulkanDriver::terminate() {
    mPipelineCache.terminate();
    mFramebufferCache.reset();
    mSamplerCache.terminate();
-    mDescriptorSetLayoutCache.terminate();
-    mDescriptorSetCache.terminate();
+    mDescriptorSetManager.terminate();
    mPipelineLayoutCache.terminate();

    // Before terminating ResourceManager, we must make sure all of the resource_ptrs have been unset.
@@ -363,7 +365,7 @@ void VulkanDriver::collectGarbage() {
    FVK_SYSTRACE_SCOPE();
    // Command buffers need to be submitted and completed before other resources can be gc'd.
    mCommands.gc();
-    mDescriptorSetCache.clearHistory();
+    mDescriptorSetManager.clearHistory();
    mStagePool.gc();
    mFramebufferCache.gc();
    mPipelineCache.gc();
@@ -406,7 +408,7 @@ void VulkanDriver::updateDescriptorSetBuffer(
    FVK_SYSTRACE_SCOPE();
    auto set = resource_ptr<VulkanDescriptorSet>::cast(&mResourceManager, dsh);
    auto buffer = resource_ptr<VulkanBufferObject>::cast(&mResourceManager, boh);
-    mDescriptorSetCache.updateBuffer(set, binding, buffer, offset, size);
+    mDescriptorSetManager.updateBuffer(set, binding, buffer, offset, size);
 }

 void VulkanDriver::updateDescriptorSetTexture(
@@ -419,7 +421,7 @@ void VulkanDriver::updateDescriptorSetTexture(
    auto texture = resource_ptr<VulkanTexture>::cast(&mResourceManager, th);

    VkSampler const vksampler = mSamplerCache.getSampler(params);
-    mDescriptorSetCache.updateSampler(set, binding, texture, vksampler);
+    mDescriptorSetManager.updateSampler(set, binding, texture, vksampler);
 }

 void VulkanDriver::flush(int) {
@@ -776,7 +778,8 @@ void VulkanDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {

 void VulkanDriver::createDescriptorSetLayoutR(Handle<HwDescriptorSetLayout> dslh,
        backend::DescriptorSetLayout&& info) {
-    auto layout = mDescriptorSetLayoutCache.createLayout(dslh, std::move(info));
+    auto layout = resource_ptr<VulkanDescriptorSetLayout>::make(&mResourceManager, dslh, info);
+    mDescriptorSetManager.initVkLayout(layout);
    layout.inc();
 }

@@ -785,7 +788,7 @@ void VulkanDriver::createDescriptorSetR(Handle<HwDescriptorSet> dsh,
    FVK_SYSTRACE_SCOPE();
    fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout =
            fvkmemory::resource_ptr<VulkanDescriptorSetLayout>::cast(&mResourceManager, dslh);
-    auto set = mDescriptorSetCache.createSet(dsh, layout);
+    auto set = mDescriptorSetManager.createSet(dsh, layout);
    set.inc();
 }

@@ -1057,7 +1060,7 @@ bool VulkanDriver::isDepthStencilBlitSupported(TextureFormat format) {
           formats.end();
 }

-bool VulkanDriver::isProtectedTexturesSupported() { return isProtectedContentSupported(); }
+bool VulkanDriver::isProtectedTexturesSupported() { return false; }

 bool VulkanDriver::isDepthClampSupported() {
    return mContext.isDepthClampSupported();
@@ -1146,7 +1149,7 @@ size_t VulkanDriver::getMaxUniformBufferSize() {

 size_t VulkanDriver::getMaxTextureSize(SamplerType) {
    // TODO: return the actual size instead of hardcoded value
-    return 4096;
+    return 2048;
 }

 size_t VulkanDriver::getMaxArrayTextureLayers() {
@@ -1490,7 +1493,7 @@ void VulkanDriver::nextSubpass(int) {

    if (mCurrentRenderPass.params.subpassMask & 0x1) {
        VulkanAttachment& subpassInput = renderTarget->getColor0();
-        mDescriptorSetCache.updateInputAttachment({}, subpassInput);
+        mDescriptorSetManager.updateInputAttachment({}, subpassInput);
    }
 }

@@ -1817,9 +1820,9 @@ void VulkanDriver::bindDescriptorSet(
        backend::DescriptorSetOffsetArray&& offsets) {
    if (dsh) {
        auto set = resource_ptr<VulkanDescriptorSet>::cast(&mResourceManager, dsh);
-        mDescriptorSetCache.bind(setIndex, set, std::move(offsets));
+        mDescriptorSetManager.bind(setIndex, set, std::move(offsets));
    } else {
-        mDescriptorSetCache.unbind(setIndex);
+        mDescriptorSetManager.unbind(setIndex);
    }
 }

@@ -1827,7 +1830,7 @@ void VulkanDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
    FVK_SYSTRACE_SCOPE();
    VkCommandBuffer cmdbuffer = mCurrentRenderPass.commandBuffer->buffer();

-    mDescriptorSetCache.commit(mCurrentRenderPass.commandBuffer,
+    mDescriptorSetManager.commit(mCurrentRenderPass.commandBuffer,
            mBoundPipeline.pipelineLayout,
            mBoundPipeline.descriptorSetMask);

@@ -27,9 +27,8 @@
 #include "VulkanSamplerCache.h"
 #include "VulkanStagePool.h"
 #include "VulkanQueryManager.h"
-#include "vulkan/VulkanDescriptorSetCache.h"
-#include "vulkan/VulkanDescriptorSetLayoutCache.h"
-#include "vulkan/VulkanPipelineLayoutCache.h"
+#include "vulkan/caching/VulkanDescriptorSetManager.h"
+#include "vulkan/caching/VulkanPipelineLayoutCache.h"
 #include "vulkan/memory/ResourceManager.h"
 #include "vulkan/memory/ResourcePointer.h"
 #include "vulkan/utils/Definitions.h"
@@ -138,8 +137,7 @@ private:
    VulkanSamplerCache mSamplerCache;
    VulkanBlitter mBlitter;
    VulkanReadPixels mReadPixels;
-    VulkanDescriptorSetLayoutCache mDescriptorSetLayoutCache;
-    VulkanDescriptorSetCache mDescriptorSetCache;
+    VulkanDescriptorSetManager mDescriptorSetManager;
    VulkanQueryManager mQueryManager;

    // This is necessary for us to write to push constants after binding a pipeline.
@@ -15,12 +15,15 @@
 */

 #include "VulkanPipelineCache.h"
+#include "VulkanMemory.h"
+#include "caching/VulkanDescriptorSetManager.h"

 #include <utils/Log.h>
 #include <utils/Panic.h>

 #include "VulkanConstants.h"
 #include "VulkanHandles.h"
+#include "VulkanTexture.h"
 #include "vulkan/utils/Conversion.h"

 #if defined(__clang__)
@@ -14,25 +14,35 @@
 * limitations under the License.
 */

-#include "VulkanDescriptorSetCache.h"
+#include "VulkanDescriptorSetManager.h"

-#include "VulkanCommands.h"
-#include "VulkanHandles.h"
-#include "VulkanConstants.h"
+#include "vulkan/VulkanCommands.h"
+#include "vulkan/VulkanHandles.h"
+#include "vulkan/VulkanConstants.h"

 #include <utils/FixedCapacityVector.h>
 #include <utils/Panic.h>

+#include <math.h>
+
 #include <algorithm>
 #include <memory>
+#include <type_traits>
 #include <vector>

 namespace filament::backend {

 namespace {

+using BitmaskGroup = VulkanDescriptorSetLayout::Bitmask;
 using DescriptorCount = VulkanDescriptorSetLayout::Count;
-using DescriptorSetLayoutArray = VulkanDescriptorSetCache::DescriptorSetLayoutArray;
+using DescriptorSetLayoutArray = VulkanDescriptorSetManager::DescriptorSetLayoutArray;
+using BitmaskGroupHashFn = utils::hash::MurmurHashFn<BitmaskGroup>;
+struct BitmaskGroupEqual {
+    bool operator()(BitmaskGroup const& k1, BitmaskGroup const& k2) const {
+        return k1 == k2;
+    }
+};

 // We create a pool for each layout as defined by the number of descriptors of each type. For
 // example, a layout of
@@ -189,12 +199,72 @@ struct Equal {
    }
 };

+template<typename Bitmask>
+uint32_t createBindings(VkDescriptorSetLayoutBinding* toBind, uint32_t count, VkDescriptorType type,
+        Bitmask const& mask) {
+    Bitmask alreadySeen;
+    mask.forEachSetBit([&](size_t index) {
+        VkShaderStageFlags stages = 0;
+        uint32_t binding = 0;
+        if (index < fvkutils::getFragmentStageShift<Bitmask>()) {
+            binding = (uint32_t) index;
+            stages |= VK_SHADER_STAGE_VERTEX_BIT;
+            auto fragIndex = index + fvkutils::getFragmentStageShift<Bitmask>();
+            if (mask.test(fragIndex)) {
+                stages |= VK_SHADER_STAGE_FRAGMENT_BIT;
+                alreadySeen.set(fragIndex);
+            }
+        } else if (!alreadySeen.test(index)) {
+            // We are in fragment stage bits
+            binding = (uint32_t) (index - fvkutils::getFragmentStageShift<Bitmask>());
+            stages |= VK_SHADER_STAGE_FRAGMENT_BIT;
+        }
+
+        if (stages) {
+            toBind[count++] = {
+                .binding = binding,
+                .descriptorType = type,
+                .descriptorCount = 1,
+                .stageFlags = stages,
+            };
+        }
+    });
+    return count;
+}
+
+inline VkDescriptorSetLayout createLayout(VkDevice device, BitmaskGroup const& bitmaskGroup) {
+    // Note that the following *needs* to be static so that VkDescriptorSetLayoutCreateInfo will not
+    // refer to stack memory.
+    VkDescriptorSetLayoutBinding toBind[VulkanDescriptorSetLayout::MAX_BINDINGS];
+    uint32_t count = 0;
+
+    count = createBindings(toBind, count, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
+            bitmaskGroup.dynamicUbo);
+    count = createBindings(toBind, count, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, bitmaskGroup.ubo);
+    count = createBindings(toBind, count, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+            bitmaskGroup.sampler);
+    count = createBindings(toBind, count, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+            bitmaskGroup.inputAttachment);
+
+    assert_invariant(count != 0 && "Need at least one binding for descriptor set layout.");
+    VkDescriptorSetLayoutCreateInfo dlinfo = {
+            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+            .pNext = nullptr,
+            .bindingCount = count,
+            .pBindings = toBind,
+    };
+
+    VkDescriptorSetLayout layout;
+    vkCreateDescriptorSetLayout(device, &dlinfo, VKALLOC, &layout);
+    return layout;
+}
+
 } // anonymous namespace

 // This is an ever-expanding pool of sets where it
 //    1. Keeps a list of smaller pools of different layout-dimensions.
 //    2. Will add a pool if existing pool are not compatible with the requested layout o runs out.
-class VulkanDescriptorSetCache::DescriptorInfinitePool {
+class VulkanDescriptorSetManager::DescriptorInfinitePool {
 private:
    static constexpr uint16_t EXPECTED_SET_COUNT = 10;
    static constexpr float SET_COUNT_GROWTH_FACTOR = 1.5;
@@ -249,34 +319,61 @@ private:
    std::vector<std::unique_ptr<DescriptorPool>> mPools;
 };

+class VulkanDescriptorSetManager::DescriptorSetLayoutManager {
+public:
+    DescriptorSetLayoutManager(VkDevice device)
+        : mDevice(device) {}

-VulkanDescriptorSetCache::VulkanDescriptorSetCache(VkDevice device,
+    VkDescriptorSetLayout getVkLayout(VulkanDescriptorSetLayout::Bitmask const& bitmasks) {
+        if (auto itr = mVkLayouts.find(bitmasks); itr != mVkLayouts.end()) {
+            return itr->second;
+        }
+        auto vklayout = createLayout(mDevice, bitmasks);
+        mVkLayouts[bitmasks] = vklayout;
+        return vklayout;
+    }
+
+    ~DescriptorSetLayoutManager() {
+        for (auto& itr: mVkLayouts) {
+            vkDestroyDescriptorSetLayout(mDevice, itr.second, VKALLOC);
+        }
+    }
+
+private:
+    VkDevice mDevice;
+    tsl::robin_map<BitmaskGroup, VkDescriptorSetLayout, BitmaskGroupHashFn, BitmaskGroupEqual>
+            mVkLayouts;
+};
+
+VulkanDescriptorSetManager::VulkanDescriptorSetManager(VkDevice device,
        fvkmemory::ResourceManager* resourceManager)
    : mDevice(device),
      mResourceManager(resourceManager),
+      mLayoutManager(std::make_unique<DescriptorSetLayoutManager>(device)),
      mDescriptorPool(std::make_unique<DescriptorInfinitePool>(device)) {}

-VulkanDescriptorSetCache::~VulkanDescriptorSetCache() = default;
+VulkanDescriptorSetManager::~VulkanDescriptorSetManager() = default;

-void VulkanDescriptorSetCache::terminate() noexcept{
+void VulkanDescriptorSetManager::terminate() noexcept{
+    mLayoutManager.reset();
    mDescriptorPool.reset();
    clearHistory();
 }

 // bind() is not really binding the set but just stashing until we have all the info
 // (pipelinelayout).
-void VulkanDescriptorSetCache::bind(uint8_t setIndex,
+void VulkanDescriptorSetManager::bind(uint8_t setIndex,
        fvkmemory::resource_ptr<VulkanDescriptorSet> set,
        backend::DescriptorSetOffsetArray&& offsets) {
    set->setOffsets(std::move(offsets));
    mStashedSets[setIndex] = set;
 }

-void VulkanDescriptorSetCache::unbind(uint8_t setIndex) {
+void VulkanDescriptorSetManager::unbind(uint8_t setIndex) {
    mStashedSets[setIndex] = {};
 }

-void VulkanDescriptorSetCache::commit(VulkanCommandBuffer* commands,
+void VulkanDescriptorSetManager::commit(VulkanCommandBuffer* commands,
        VkPipelineLayout pipelineLayout, fvkutils::DescriptorSetMask const& setMask) {
    // setMask indicates the set of descriptor sets the driver wants to bind, curMask is the
    // actual set of sets that *needs* to be bound.
@@ -315,7 +412,7 @@ void VulkanDescriptorSetCache::commit(VulkanCommandBuffer* commands,
    };
 }

-void VulkanDescriptorSetCache::updateBuffer(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
+void VulkanDescriptorSetManager::updateBuffer(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
        uint8_t binding, fvkmemory::resource_ptr<VulkanBufferObject> bufferObject,
        VkDeviceSize offset, VkDeviceSize size) noexcept {
    VkDescriptorBufferInfo const info = {
@@ -341,7 +438,7 @@ void VulkanDescriptorSetCache::updateBuffer(fvkmemory::resource_ptr<VulkanDescri
    set->acquire(bufferObject);
 }

-void VulkanDescriptorSetCache::updateSampler(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
+void VulkanDescriptorSetManager::updateSampler(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
        uint8_t binding, fvkmemory::resource_ptr<VulkanTexture> texture,
        VkSampler sampler) noexcept {
    VkDescriptorImageInfo info{
@@ -373,13 +470,13 @@ void VulkanDescriptorSetCache::updateSampler(fvkmemory::resource_ptr<VulkanDescr
    set->acquire(texture);
 }

-void VulkanDescriptorSetCache::updateInputAttachment(
+void VulkanDescriptorSetManager::updateInputAttachment(
        fvkmemory::resource_ptr<VulkanDescriptorSet> set,
        VulkanAttachment const& attachment) noexcept {
-    // TOOD: fill this in.
+    // TOOD: fill-in this region
 }

-fvkmemory::resource_ptr<VulkanDescriptorSet> VulkanDescriptorSetCache::createSet(
+fvkmemory::resource_ptr<VulkanDescriptorSet> VulkanDescriptorSetManager::createSet(
        Handle<HwDescriptorSet> handle, fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout) {
    auto const vkSet = mDescriptorPool->obtainSet(layout);
    auto const& count = layout->count;
@@ -395,7 +492,12 @@ fvkmemory::resource_ptr<VulkanDescriptorSet> VulkanDescriptorSetCache::createSet
            });
 }

-void VulkanDescriptorSetCache::clearHistory() {
+void VulkanDescriptorSetManager::initVkLayout(
+        fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout) {
+    layout->setVkLayout(mLayoutManager->getVkLayout(layout->bitmask));
+}
+
+void VulkanDescriptorSetManager::clearHistory() {
    mStashedSets = {};
 }

@@ -14,10 +14,10 @@
 * limitations under the License.
 */

-#ifndef TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETCACHE_H
-#define TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETCACHE_H
+#ifndef TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETMANAGER_H
+#define TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETMANAGER_H

-#include "VulkanHandles.h"
+#include "vulkan/VulkanHandles.h"
 #include "vulkan/memory/ResourcePointer.h"
 #include "vulkan/utils/Definitions.h"  // For DescriptorSetMask

@@ -34,16 +34,20 @@

 namespace filament::backend {

-// Abstraction over the descriptor set pool.
-class VulkanDescriptorSetCache {
+// [GDSR]: Great-Descriptor-Set-Refactor: As of 03/20/24, the Filament frontend is planning to
+// introduce descriptor set. This PR will arrive before that change is complete. As such, some of
+// the methods introduced here will be obsolete, and certain logic will be generalized.
+
+// Abstraction over the pool and the layout cache.
+class VulkanDescriptorSetManager {
 public:
    static constexpr uint8_t UNIQUE_DESCRIPTOR_SET_COUNT =
            VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT;

    using DescriptorSetLayoutArray = VulkanDescriptorSetLayout::DescriptorSetLayoutArray;

-    VulkanDescriptorSetCache(VkDevice device, fvkmemory::ResourceManager* resourceManager);
-    ~VulkanDescriptorSetCache();
+    VulkanDescriptorSetManager(VkDevice device, fvkmemory::ResourceManager* resourceManager);
+    ~VulkanDescriptorSetManager();

    void terminate() noexcept;

@@ -68,9 +72,12 @@ public:
    fvkmemory::resource_ptr<VulkanDescriptorSet> createSet(Handle<HwDescriptorSet> handle,
            fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout);

+    void initVkLayout(fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout);
+
    void clearHistory();

 private:
+    class DescriptorSetLayoutManager;
    class DescriptorInfinitePool;

    using DescriptorSetArray =
@@ -78,6 +85,7 @@ private:

    VkDevice mDevice;
    fvkmemory::ResourceManager* mResourceManager;
+    std::unique_ptr<DescriptorSetLayoutManager> mLayoutManager;
    std::unique_ptr<DescriptorInfinitePool> mDescriptorPool;
    std::pair<VulkanAttachment, VkDescriptorImageInfo> mInputAttachment;
    DescriptorSetArray mStashedSets = {};
@@ -91,4 +99,4 @@ private:

 }// namespace filament::backend

-#endif// TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETCACHE_H
+#endif// TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETMANAGER_H
@@ -17,8 +17,7 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANPIPELINELAYOUTCACHE_H
 #define TNT_FILAMENT_BACKEND_VULKANPIPELINELAYOUTCACHE_H

-#include "VulkanHandles.h"
-
+#include <vulkan/VulkanHandles.h>
 #include <bluevk/BlueVK.h>

 #include <utils/Hash.h>
@@ -736,6 +736,10 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
    chainStruct(&context.mPhysicalDeviceFeatures, &queryProtectedMemoryFeatures);
    chainStruct(&context.mPhysicalDeviceProperties, &protectedMemoryProperties);

+    // We know we need to allocate the protected version of the VK objects
+    context.mProtectedMemorySupported =
+            static_cast<bool>(queryProtectedMemoryFeatures.protectedMemory);
+
    // Initialize the following fields: physicalDeviceProperties, memoryProperties,
    // physicalDeviceFeatures, graphicsQueueFamilyIndex.
    vkGetPhysicalDeviceProperties2(mImpl->mPhysicalDevice, &context.mPhysicalDeviceProperties);
@@ -755,10 +759,6 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
        mImpl->mGraphicsQueueIndex = 0;
    }

-    // We know we need to allocate the protected version of the VK objects
-    context.mProtectedMemorySupported =
-            static_cast<bool>(queryProtectedMemoryFeatures.protectedMemory);
-
    if (context.mProtectedMemorySupported) {
        mImpl->mProtectedGraphicsQueueFamilyIndex = identifyGraphicsQueueFamilyIndex(
                mImpl->mPhysicalDevice, (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_PROTECTED_BIT));
@@ -1000,15 +1000,6 @@ VkImageView VulkanPlatform::createExternalImageView(SamplerYcbcrConversion chrom
    return createExternalImageViewImpl(mImpl->mDevice, chroma, internalFormat, image, range,
            viewType, swizzle);
 }
-
-ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() const {
-    return getSwapchainInstanceExtensionsImpl();
-}
-
-VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWindow,
-        VkInstance instance, uint64_t flags) const noexcept {
-    return createVkSurfaceKHRImpl(nativeWindow, instance, flags);
-}
 #undef SWAPCHAIN_RET_FUNC

 }// namespace filament::backend
@@ -13,9 +13,10 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-#include <backend/platforms/VulkanPlatformAndroid.h>
+#include <backend/platforms/VulkanPlatform.h>

 #include <backend/DriverEnums.h>
+#include <backend/platforms/VulkanPlatformAndroid.h>
 #include <private/backend/BackendUtilsAndroid.h>

 #include "vulkan/VulkanConstants.h"
@@ -156,7 +157,7 @@ VulkanPlatform::ImageData allocateExternalImage(AHardwareBuffer* buffer, VkDevic
        .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
    };

-    VkImageCreateInfo imageInfo{ .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+    VkImageCreateInfo imageInfo{.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
    imageInfo.pNext = &externalCreateInfo;
    imageInfo.format = metadata.format;
    imageInfo.imageType = VK_IMAGE_TYPE_2D;
@@ -199,12 +200,14 @@ VulkanPlatform::ImageData allocateExternalImage(AHardwareBuffer* buffer, VkDevic
    return data;
 }

-}// namespace
+} // namespace

-VulkanPlatformAndroid::ExternalImageVulkanAndroid::~ExternalImageVulkanAndroid() = default;
+namespace fvkandroid {

-Platform::ExternalImageHandle VulkanPlatformAndroid::createExternalImage(
-        AHardwareBuffer const* buffer, bool sRGB) noexcept {
+ExternalImageVulkanAndroid::~ExternalImageVulkanAndroid() = default;
+
+Platform::ExternalImageHandle createExternalImage(AHardwareBuffer const* buffer,
+        bool sRGB) noexcept {
    if (__builtin_available(android 26, *)) {
        AHardwareBuffer_Desc hardwareBufferDescription = {};
        AHardwareBuffer_describe(buffer, &hardwareBufferDescription);
@@ -223,23 +226,12 @@ Platform::ExternalImageHandle VulkanPlatformAndroid::createExternalImage(
    return Platform::ExternalImageHandle{};
 }

-VulkanPlatformAndroid::ExternalImageDescAndroid VulkanPlatformAndroid::getExternalImageDesc(
-        ExternalImageHandleRef externalImage) const noexcept {
-    auto const* fvkExternalImage =
-            static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());
+} // namespace fvkandroid

-    return {
-        .width = fvkExternalImage->width,
-        .height = fvkExternalImage->height,
-        .format = fvkExternalImage->format,
-        .usage = fvkExternalImage->usage,
-    };
-}
-
-VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::getExternalImageMetadata(
-        ExternalImageHandleRef externalImage) {
+VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device) {
    auto const* fvkExternalImage =
-            static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());
+            static_cast<fvkandroid::ExternalImageVulkanAndroid const*>(externalImage.get());

    ExternalImageMetadata metadata;
    AHardwareBuffer* buffer = fvkExternalImage->aHardwareBuffer;
@@ -253,7 +245,7 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::getExternalImageMet
        std::tie(metadata.format, metadata.usage) =
                getVKFormatAndUsage(bufferDesc, fvkExternalImage->sRGB);
    }
-
+    
    metadata.samples = VK_SAMPLE_COUNT_1_BIT;

    VkAndroidHardwareBufferFormatPropertiesANDROID formatInfo = {
@@ -264,11 +256,11 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::getExternalImageMet
        .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
        .pNext = &formatInfo,
    };
-    VkResult result = vkGetAndroidHardwareBufferPropertiesANDROID(getDevice(), buffer, &properties);
+    VkResult result = vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer, &properties);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkGetAndroidHardwareBufferProperties failed with error="
-            << static_cast<int32_t>(result);
-
+        << "vkGetAndroidHardwareBufferProperties failed with error="
+        << static_cast<int32_t>(result);
+                            
    VkFormat bufferPropertiesFormat = transformVkFormat(formatInfo.format, fvkExternalImage->sRGB);
    FILAMENT_CHECK_POSTCONDITION(metadata.format == bufferPropertiesFormat)
            << "mismatched image format( " << metadata.format << ") and queried format("
@@ -279,14 +271,14 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::getExternalImageMet
    return metadata;
 }

-VulkanPlatformAndroid::ImageData VulkanPlatformAndroid::createExternalImageData(
-        ExternalImageHandleRef externalImage, const ExternalImageMetadata& metadata,
-        uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
+VulkanPlatform::ImageData VulkanPlatform::createExternalImageDataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device,
+        const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
    auto const* fvkExternalImage =
-            static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());
-    ImageData data = allocateExternalImage(fvkExternalImage->aHardwareBuffer, getDevice(), metadata,
+            static_cast<fvkandroid::ExternalImageVulkanAndroid const*>(externalImage.get());
+    ImageData data = allocateExternalImage(fvkExternalImage->aHardwareBuffer, device, metadata,
            memoryTypeIndex, usage);
-    VkResult result = vkBindImageMemory(getDevice(), data.first, data.second, 0);
+    VkResult result = vkBindImageMemory(device, data.first, data.second, 0);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
        << "vkBindImageMemory error=" << static_cast<int32_t>(result);
    return data;
@@ -405,14 +397,14 @@ VkSampler VulkanPlatform::createExternalSamplerImpl(
    return sampler;
 }

-VulkanPlatform::ExtensionSet VulkanPlatformAndroid::getSwapchainInstanceExtensions() const {
+VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() {
    return {
        VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
    };
 }

-VulkanPlatform::SurfaceBundle VulkanPlatformAndroid::createVkSurfaceKHR(void* nativeWindow,
-        VkInstance instance, uint64_t flags) const noexcept {
+VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWindow,
+    VkInstance instance, uint64_t flags) noexcept {
    VkSurfaceKHR surface;
    VkExtent2D extent;

@@ -424,26 +416,6 @@ VulkanPlatform::SurfaceBundle VulkanPlatformAndroid::createVkSurfaceKHR(void* na
            vkCreateAndroidSurfaceKHR(instance, &createInfo, VKALLOC, (VkSurfaceKHR*) &surface);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
            << "vkCreateAndroidSurfaceKHR with error=" << static_cast<int32_t>(result);
-    return { surface, extent };
+    return {surface, extent};
 }
-
-// Deprecated platform dependent helper methods
-VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl() { return {}; }
-
-VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataImpl(
-        ExternalImageHandleRef externalImage, VkDevice device) {
-    return ExternalImageMetadata{};
 }
-
-VulkanPlatform::ImageData VulkanPlatform::createExternalImageDataImpl(
-        ExternalImageHandleRef externalImage, VkDevice device,
-        const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
-    return ImageData{};
-}
-
-VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
-        VkInstance instance, uint64_t flags) noexcept {
-    return SurfaceBundle{};
-}
-
-}// namespace filament::backend
@@ -52,7 +52,7 @@ using namespace bluevk;

 namespace filament::backend {

-VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl() {
+VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() {
    ExtensionSet const ret = {
    #if defined(__APPLE__)
        VK_MVK_MACOS_SURFACE_EXTENSION_NAME,  // TODO: replace with VK_EXT_metal_surface
@@ -87,7 +87,7 @@ VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device,
    return VK_NULL_HANDLE;
 }

-VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
+VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWindow,
        VkInstance instance, uint64_t flags) noexcept {
    VkSurfaceKHR surface;
    #if defined(__APPLE__)
@@ -108,7 +108,7 @@ VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device,
    return VK_NULL_HANDLE;
 }

-VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl() {
+VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() {
    VulkanPlatform::ExtensionSet const ret = {
 #if defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
        VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
@@ -126,7 +126,7 @@ VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl(
    return ret;
 }

-VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
+VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWindow,
        VkInstance instance, uint64_t flags) noexcept {
    VkSurfaceKHR surface;

@@ -651,11 +651,11 @@ uint8_t WebGPUDriver::getMaxDrawBuffers() {
    return MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT;
 }

-size_t WebGPUDriver::getMaxUniformBufferSize() {
+size_t WebGPUDriver::getMaxUniformBufferSize(SamplerType) {
    return 16384u;
 }

-size_t WebGPUDriver::getMaxTextureSize(SamplerType target) {
+size_t WebGPUDriver::getMaxTextureSize() {
    return 2048u;
 }

@@ -143,7 +143,7 @@ wgpu::Device WebGPUPlatform::requestDevice(wgpu::Adapter const& adapter) {
    return device;
 }

-Driver* WebGPUPlatform::createDriver(void* sharedContext,
+Driver* WebGPUPlatform::createDriver(void* const sharedContext,
        const Platform::DriverConfig& /*driverConfig*/) noexcept {
    if (sharedContext) {
        FWGPU_LOGW << "sharedContext is ignored/unused in the WebGPU backend. A non-null "
@@ -15,8 +15,6 @@
 */
 #include <backend/platforms/WebGPUPlatform.h>

-#include <backend/DriverEnums.h>
-
 #include <utils/Panic.h>

 #include <webgpu/webgpu_cpp.h>
@@ -120,9 +118,7 @@ wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t flags)
        if (useXcb) {
            wgpu::SurfaceSourceXCBWindow surfaceSourceXcb{};
            surfaceSourceXcb.connection = g_x11.connection;
-
-            // TODO: this looks really wrong, please fix!!
-            surfaceSourceXcb.window = *((uint32_t*) nativeWindow);
+            surfaceSourceXcb.window = reinterpret_cast<uint32_t>(nativeWindow);
            wgpu::SurfaceDescriptor surfaceDescriptor{
                .nextInChain = &surfaceSourceXcb,
                .label = "linux_xcb_surface"
@@ -64,8 +64,9 @@ class ColorSpace;
 * Performance
 * ===========
 *
- * Creating a new ColorGrading object may be more expensive than other Filament objects as a LUT may
- * need to be generated. The generation of this LUT, if necessary, may happen on the CPU.
+ * Creating a new ColorGrading object may be more expensive than other Filament objects as a
+ * 3D LUT may need to be generated. The generation of a 3D LUT, if necessary, may happen on
+ * the CPU.
 *
 * Ordering
 * ========
@@ -154,9 +155,6 @@ public:
         * 3D texture. For instance, a low quality level will use a 16x16x16 10 bit LUT, a medium
         * quality level will use a 32x32x32 10 bit LUT, a high quality will use a 32x32x32 16 bit
         * LUT, and a ultra quality will use a 64x64x64 16 bit LUT.
-         *
-         * This setting has no effect if generating a 1D LUT.
-         *
         * This overrides the values set by format() and dimensions().
         *
         * The default quality is medium.
@@ -171,8 +169,6 @@ public:
         * When color grading is implemented using a 3D LUT, this sets the texture format of
         * of the LUT. This overrides the value set by quality().
         *
-         * This setting has no effect if generating a 1D LUT.
-         *
         * The default is INTEGER
         *
         * @param format The desired format of the 3D LUT.
@@ -185,8 +181,6 @@ public:
         * When color grading is implemented using a 3D LUT, this sets the dimension of the LUT.
         * This overrides the value set by quality().
         *
-         * This setting has no effect if generating a 1D LUT.
-         *
         * The default is 32
         *
         * @param dim The desired dimension of the LUT. Between 16 and 64.
@@ -68,21 +68,6 @@ struct UTILS_PUBLIC ToneMapper {
     *         function applied ("linear")
     */
    virtual math::float3 operator()(math::float3 c) const noexcept = 0;
-
-    /**
-     * If true, then this function holds that f(x) = vec3(f(x.r), f(x.g), f(x.b))
-     *
-     * This may be used to indicate that the color grading's LUT only requires a 1D texture instead
-     * of a 3D texture, potentially saving a significant amount of memory and generation time.
-     */
-    virtual bool isOneDimensional() const noexcept { return false; }
-
-    /**
-     * True if this tonemapper only works in low-dynamic-range.
-     *
-     * This may be used to indicate that the color grading's LUT doesn't need to be log encoded.
-     */
-    virtual bool isLDR() const noexcept { return false; }
 };

 /**
@@ -94,8 +79,6 @@ struct UTILS_PUBLIC LinearToneMapper final : public ToneMapper {
    ~LinearToneMapper() noexcept final;

    math::float3 operator()(math::float3 c) const noexcept override;
-    bool isOneDimensional() const noexcept override { return true; }
-    bool isLDR() const noexcept override { return true; }
 };

 /**
@@ -108,8 +91,6 @@ struct UTILS_PUBLIC ACESToneMapper final : public ToneMapper {
    ~ACESToneMapper() noexcept final;

    math::float3 operator()(math::float3 c) const noexcept override;
-    bool isOneDimensional() const noexcept override { return false; }
-    bool isLDR() const noexcept override { return false; }
 };

 /**
@@ -123,8 +104,6 @@ struct UTILS_PUBLIC ACESLegacyToneMapper final : public ToneMapper {
    ~ACESLegacyToneMapper() noexcept final;

    math::float3 operator()(math::float3 c) const noexcept override;
-    bool isOneDimensional() const noexcept override { return false; }
-    bool isLDR() const noexcept override { return false; }
 };

 /**
@@ -138,8 +117,6 @@ struct UTILS_PUBLIC FilmicToneMapper final : public ToneMapper {
    ~FilmicToneMapper() noexcept final;

    math::float3 operator()(math::float3 x) const noexcept override;
-    bool isOneDimensional() const noexcept override { return true; }
-    bool isLDR() const noexcept override { return false; }
 };

 /**
@@ -152,8 +129,6 @@ struct UTILS_PUBLIC PBRNeutralToneMapper final : public ToneMapper {
    ~PBRNeutralToneMapper() noexcept final;

    math::float3 operator()(math::float3 x) const noexcept override;
-    bool isOneDimensional() const noexcept override { return false; }
-    bool isLDR() const noexcept override { return false; }
 };

 /**
@@ -175,8 +150,6 @@ struct UTILS_PUBLIC AgxToneMapper final : public ToneMapper {
    ~AgxToneMapper() noexcept final;

    math::float3 operator()(math::float3 x) const noexcept override;
-    bool isOneDimensional() const noexcept override { return false; }
-    bool isLDR() const noexcept override { return false; }

    AgxLook look;
 };
@@ -221,8 +194,6 @@ struct UTILS_PUBLIC GenericToneMapper final : public ToneMapper {
    GenericToneMapper& operator=(GenericToneMapper&& rhs) noexcept;

    math::float3 operator()(math::float3 x) const noexcept override;
-    bool isOneDimensional() const noexcept override { return true; }
-    bool isLDR() const noexcept override { return false; }

    /** Returns the contrast of the curve as a strictly positive value. */
    float getContrast() const noexcept;
@@ -285,8 +256,6 @@ struct UTILS_PUBLIC DisplayRangeToneMapper final : public ToneMapper {
    ~DisplayRangeToneMapper() noexcept override;

    math::float3 operator()(math::float3 c) const noexcept override;
-    bool isOneDimensional() const noexcept override { return false; }
-    bool isLDR() const noexcept override { return false; }
 };

 } // namespace filament
@@ -2306,11 +2306,36 @@ void PostProcessManager::colorGradingPrepareSubpass(DriverApi& driver,
        const FColorGrading* colorGrading, ColorGradingConfig const& colorGradingConfig,
        VignetteOptions const& vignetteOptions, uint32_t const width, uint32_t const height) noexcept {

-    auto& material = getPostProcessMaterial("colorGradingAsSubpass");
-    FMaterialInstance* const mi =
-            configureColorGradingMaterial(material, colorGrading, colorGradingConfig,
-                    vignetteOptions, width, height);
+    float4 const vignetteParameters = getVignetteParameters(vignetteOptions, width, height);
+
+    auto const& material = getPostProcessMaterial("colorGradingAsSubpass");
+    FMaterialInstance* const mi = PostProcessMaterial::getMaterialInstance(mEngine, material);
+
+    mi->setParameter("lut", colorGrading->getHwHandle(), {
+            .filterMag = SamplerMagFilter::LINEAR,
+            .filterMin = SamplerMinFilter::LINEAR,
+            .wrapS = SamplerWrapMode::CLAMP_TO_EDGE,
+            .wrapT = SamplerWrapMode::CLAMP_TO_EDGE,
+            .wrapR = SamplerWrapMode::CLAMP_TO_EDGE,
+            .anisotropyLog2 = 0
+    });
+    const float lutDimension = float(colorGrading->getDimension());
+    mi->setParameter("lutSize", float2{
+        0.5f / lutDimension, (lutDimension - 1.0f) / lutDimension,
+    });
+
+    const float temporalNoise = mUniformDistribution(mEngine.getRandomEngine());
+
+    mi->setParameter("vignette", vignetteParameters);
+    mi->setParameter("vignetteColor", vignetteOptions.color);
+    mi->setParameter("dithering", colorGradingConfig.dithering);
+    mi->setParameter("outputLuminance", colorGradingConfig.outputLuminance);
+    mi->setParameter("temporalNoise", temporalNoise);
    mi->commit(driver);
+
+    // load both variants
+    material.getMaterial(mEngine, PostProcessVariant::OPAQUE);
+    material.getMaterial(mEngine, PostProcessVariant::TRANSLUCENT);
 }

 void PostProcessManager::colorGradingSubpass(DriverApi& driver,
@@ -2462,14 +2487,22 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::colorGrading(FrameGraph& fg,

                auto const& out = resources.getRenderPassInfo();

-                auto const& input = resources.getDescriptor(data.input);
-                auto const& output = resources.getDescriptor(data.output);
+                auto const& material = getPostProcessMaterial("colorGrading");
+
+                PostProcessVariant const variant = colorGradingConfig.translucent ?
+                        PostProcessVariant::TRANSLUCENT : PostProcessVariant::OPAQUE;

-                auto& material = getPostProcessMaterial("colorGrading");
                FMaterialInstance* const mi =
-                        configureColorGradingMaterial(material, colorGrading, colorGradingConfig,
-                                vignetteOptions, output.width, output.height);
+                        PostProcessMaterial::getMaterialInstance(mEngine, material, variant);

+                mi->setParameter("lut", colorGrading->getHwHandle(), {
+                        .filterMag = SamplerMagFilter::LINEAR,
+                        .filterMin = SamplerMinFilter::LINEAR
+                });
+                const float lutDimension = float(colorGrading->getDimension());
+                mi->setParameter("lutSize", float2{
+                        0.5f / lutDimension, (lutDimension - 1.0f) / lutDimension,
+                });
                mi->setParameter("colorBuffer", colorTexture, { /* shader uses texelFetch */ });
                mi->setParameter("bloomBuffer", bloomTexture, {
                        .filterMag = SamplerMagFilter::LINEAR,
@@ -2501,7 +2534,19 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::colorGrading(FrameGraph& fg,
                    bloomParameters.y = 1.0f - bloomParameters.x;
                }

+                auto const& input = resources.getDescriptor(data.input);
+                auto const& output = resources.getDescriptor(data.output);
+                float4 const vignetteParameters = getVignetteParameters(
+                        vignetteOptions, output.width, output.height);
+
+                const float temporalNoise = mUniformDistribution(mEngine.getRandomEngine());
+
+                mi->setParameter("dithering", colorGradingConfig.dithering);
                mi->setParameter("bloom", bloomParameters);
+                mi->setParameter("vignette", vignetteParameters);
+                mi->setParameter("vignetteColor", vignetteOptions.color);
+                mi->setParameter("outputLuminance", colorGradingConfig.outputLuminance);
+                mi->setParameter("temporalNoise", temporalNoise);
                mi->setParameter("viewport", float4{
                        float(vp.left)   / input.width,
                        float(vp.bottom) / input.height,
@@ -2509,9 +2554,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::colorGrading(FrameGraph& fg,
                        float(vp.height) / input.height
                });

-                commitAndRenderFullScreenQuad(driver, out, mi,
-                        colorGradingConfig.translucent
-                        ? PostProcessVariant::TRANSLUCENT : PostProcessVariant::OPAQUE);
+                commitAndRenderFullScreenQuad(driver, out, mi, variant);
            }
    );

@@ -2649,70 +2692,11 @@ void PostProcessManager::configureTemporalAntiAliasingMaterial(
    setConstantParameter(ma, "varianceGamma", taaOptions.varianceGamma);
    if (dirty) {
        ma->invalidate();
-        // TODO: call Material::compile(), we can't do that now because it works only
+        // TODO: call Material::compile(), we can't si that now because it works only
        //       with surface materials
    }
 }

-FMaterialInstance* PostProcessManager::configureColorGradingMaterial(
-        PostProcessMaterial& material, FColorGrading const* colorGrading,
-        ColorGradingConfig const& colorGradingConfig, VignetteOptions const& vignetteOptions,
-        uint32_t const width, uint32_t const height) noexcept {
-    FMaterial* const ma = material.getMaterial(mEngine);
-    bool dirty = false;
-
-    auto setConstantParameter =
-            [&dirty](FMaterial* const material, std::string_view const name, auto value) noexcept {
-        auto id = material->getSpecializationConstantId(name);
-        if (id.has_value()) {
-            if (material->setConstant(id.value(), value)) {
-                dirty = true;
-            }
-        }
-    };
-
-    setConstantParameter(ma, "isOneDimensional", colorGrading->isOneDimensional());
-    setConstantParameter(ma, "isLDR", colorGrading->isLDR());
-
-    if (dirty) {
-        ma->invalidate();
-        // TODO: call Material::compile(), we can't do that now because it works only
-        //       with surface materials
-    }
-
-    PostProcessVariant const variant = colorGradingConfig.translucent ?
-            PostProcessVariant::TRANSLUCENT : PostProcessVariant::OPAQUE;
-    FMaterialInstance* const mi =
-            PostProcessMaterial::getMaterialInstance(mEngine, material, variant);
-
-    const SamplerParams params = {
-            .filterMag = SamplerMagFilter::LINEAR,
-            .filterMin = SamplerMinFilter::LINEAR,
-            .wrapS = SamplerWrapMode::CLAMP_TO_EDGE,
-            .wrapT = SamplerWrapMode::CLAMP_TO_EDGE,
-            .wrapR = SamplerWrapMode::CLAMP_TO_EDGE,
-            .anisotropyLog2 = 0
-    };
-
-    mi->setParameter("lut", colorGrading->getHwHandle(), params);
-
-    const float lutDimension = float(colorGrading->getDimension());
-    mi->setParameter("lutSize", float2{
-        0.5f / lutDimension, (lutDimension - 1.0f) / lutDimension,
-    });
-
-    const float temporalNoise = mUniformDistribution(mEngine.getRandomEngine());
-
-    float4 const vignetteParameters = getVignetteParameters(vignetteOptions, width, height);
-    mi->setParameter("vignette", vignetteParameters);
-    mi->setParameter("vignetteColor", vignetteOptions.color);
-    mi->setParameter("dithering", colorGradingConfig.dithering);
-    mi->setParameter("outputLuminance", colorGradingConfig.outputLuminance);
-    mi->setParameter("temporalNoise", temporalNoise);
-
-    return mi;
-}
-
 FrameGraphId<FrameGraphTexture> PostProcessManager::taa(FrameGraph& fg,
        FrameGraphId<FrameGraphTexture> input,
        FrameGraphId<FrameGraphTexture> const depth,
@@ -401,13 +401,6 @@ public:
            FMaterialInstance const* mi,
            PostProcessVariant variant = PostProcessVariant::OPAQUE) const noexcept;

-    // Sets the necessary spec constants and uniforms common to both colorGrading.mat and
-    // colorGradingAsSubpass.mat.
-    FMaterialInstance* configureColorGradingMaterial(
-            PostProcessMaterial& material, FColorGrading const* colorGrading,
-            ColorGradingConfig const& colorGradingConfig, VignetteOptions const& vignetteOptions,
-            uint32_t const width, uint32_t const height) noexcept;
-
 private:
    backend::RenderPrimitiveHandle mFullScreenQuadRph;
    backend::VertexBufferInfoHandle mFullScreenQuadVbih;
@@ -35,6 +35,7 @@

 #include <cmath>
 #include <cstdlib>
+#include <mutex>
 #include <tuple>

 namespace filament {
@@ -580,11 +581,8 @@ static float3 luminanceScaling(float3 x,
 // Quality
 //------------------------------------------------------------------------------

-static std::tuple<TextureFormat, PixelDataFormat, PixelDataType> selectLutTextureParams(
-        ColorGrading::LutFormat const lutFormat, const bool isOneDimensional) noexcept {
-    if (isOneDimensional) {
-        return { TextureFormat::R16F, PixelDataFormat::R, PixelDataType::HALF };
-    }
+static std::tuple<TextureFormat, PixelDataFormat, PixelDataType>
+        selectLutTextureParams(ColorGrading::LutFormat const lutFormat) noexcept {
    // We use RGBA16F for high quality modes instead of RGB16F because RGB16F
    // is not supported everywhere
    switch (lutFormat) {
@@ -660,44 +658,27 @@ FColorGrading::FColorGrading(FEngine& engine, const Builder& builder) {

    DriverApi& driver = engine.getDriverApi();

-    // XXX: The following two conditions also only hold true as long as the input and output color
-    // spaces are the same, but we currently don't check that. We must revise these conditions if we
-    // ever handle this case.
-    mIsOneDimensional = !builder->hasAdjustments && !builder->luminanceScaling
-            && builder->toneMapper->isOneDimensional()
-            && engine.features.engine.color_grading.use_1d_lut;
-    mIsLDR = mIsOneDimensional && builder->toneMapper->isLDR();
-
-    const Config config = {
-            mIsOneDimensional ? 512u : builder->dimension,
-            adaptationTransform(builder->whiteBalance),
-            selectColorGradingTransformIn(builder->toneMapping),
-            selectColorGradingTransformOut(builder->toneMapping),
-            selectColorGradingLuminance(builder->toneMapping),
-            selectOETF(builder->outputColorSpace),
-    };
-
-    mDimension = config.lutDimension;
-
-    uint32_t width;
-    uint32_t height;
-    uint32_t depth;
-    if (mIsOneDimensional) {
-        width = config.lutDimension;
-        height = 1;
-        depth = 1;
-    } else {
-        width = config.lutDimension;
-        height = config.lutDimension;
-        depth = config.lutDimension;
+    Config c;
+    // This lock protects the data inside Config, which is written to by the Filament thread,
+    // and read from multiple Job threads.
+    Mutex configLock;
+    {
+        std::lock_guard<Mutex> const lock(configLock);
+        c.lutDimension          = builder->dimension;
+        c.adaptationTransform   = adaptationTransform(builder->whiteBalance);
+        c.colorGradingIn        = selectColorGradingTransformIn(builder->toneMapping);
+        c.colorGradingOut       = selectColorGradingTransformOut(builder->toneMapping);
+        c.colorGradingLuminance = selectColorGradingLuminance(builder->toneMapping);
+        c.oetf                  = selectOETF(builder->outputColorSpace);
    }

-    size_t lutElementCount = width * height * depth;
-    size_t elementSize = mIsOneDimensional ? sizeof(half) : sizeof(half4);
+    mDimension = c.lutDimension;
+
+    size_t lutElementCount = c.lutDimension * c.lutDimension * c.lutDimension;
+    size_t elementSize = sizeof(half4);
    void* data = malloc(lutElementCount * elementSize);

-    auto [textureFormat, format, type] =
-            selectLutTextureParams(builder->format, mIsOneDimensional);
+    auto [textureFormat, format, type] = selectLutTextureParams(builder->format);
    assert_invariant(FTexture::isTextureFormatSupported(engine, textureFormat));
    assert_invariant(FTexture::validatePixelFormatAndType(textureFormat, format, type));

@@ -707,185 +688,170 @@ FColorGrading::FColorGrading(FEngine& engine, const Builder& builder) {
        converted = malloc(lutElementCount * sizeof(uint32_t));
    }

-    auto hdrColorAt = [builder, config](size_t r, size_t g, size_t b) {
-        float3 v = float3{r, g, b} * (1.0f / float(config.lutDimension - 1u));
-
-        // LogC encoding
-        v = LogC_to_linear(v);
-
-        // Kill negative values near 0.0f due to imprecision in the log conversion
-        v = max(v, 0.0f);
-
-        if (builder->hasAdjustments) {
-            // Exposure
-            v = adjustExposure(v, builder->exposure);
-
-            // Purkinje shift ("low-light" vision)
-            v = scotopicAdaptation(v, builder->nightAdaptation);
-        }
-
-        // Move to color grading color space
-        v = config.colorGradingIn * v;
-
-        if (builder->hasAdjustments) {
-            // White balance
-            v = chromaticAdaptation(v, config.adaptationTransform);
-
-            // Kill negative values before the next transforms
-            v = max(v, 0.0f);
-
-            // Channel mixer
-            v = channelMixer(v, builder->outRed, builder->outGreen, builder->outBlue);
-
-            // Shadows/mid-tones/highlights
-            v = tonalRanges(v, config.colorGradingLuminance,
-                    builder->shadows, builder->midtones, builder->highlights,
-                    builder->tonalRanges);
-
-            // The adjustments below behave better in log space
-            v = linear_to_LogC(v);
-
-            // ASC CDL
-            v = colorDecisionList(v, builder->slope, builder->offset, builder->power);
-
-            // Contrast in log space
-            v = contrast(v, builder->contrast);
-
-            // Back to linear space
-            v = LogC_to_linear(v);
-
-            // Vibrance in linear space
-            v = vibrance(v, config.colorGradingLuminance, builder->vibrance);
-
-            // Saturation in linear space
-            v = saturation(v, config.colorGradingLuminance, builder->saturation);
-
-            // Kill negative values before curves
-            v = max(v, 0.0f);
-
-            // RGB curves
-            v = curves(v,
-                    builder->shadowGamma, builder->midPoint, builder->highlightScale);
-        }
-
-        // Tone mapping
-        if (builder->luminanceScaling) {
-            v = luminanceScaling(v, *builder->toneMapper, config.colorGradingLuminance);
-        } else {
-            v = (*builder->toneMapper)(v);
-        }
-
-        // Go back to display color space
-        v = config.colorGradingOut * v;
-
-        // Apply gamut mapping
-        if (builder->gamutMapping) {
-            // TODO: This should depend on the output color space
-            v = gamutMapping_sRGB(v);
-        }
-
-        // TODO: We should convert to the output color space if we use a working
-        //       color space that's not sRGB
-        // TODO: Allow the user to customize the output color space
-
-        // We need to clamp for the output transfer function
-        v = saturate(v);
-
-        // Apply OETF
-        v = config.oetf(v);
-
-        return v;
-    };
-
    //auto now = std::chrono::steady_clock::now();

-    if (mIsOneDimensional) {
-        half* UTILS_RESTRICT p = (half*) data;
-        if (mIsLDR) {
-            for (size_t rgb = 0; rgb < config.lutDimension; rgb++) {
-                float3 v = float3(rgb) * (1.0f / float(config.lutDimension - 1u));
-
-                v = (*builder->toneMapper)(float3(v));
-
-                // We need to clamp for the output transfer function
-                v = saturate(v);
-
-                // Apply OETF
-                v = config.oetf(v);
-
-                *p++ = half(v.r);
+    // Multithreadedly generate the tone mapping 3D look-up table using 32 jobs
+    // Slices are 8 KiB (128 cache lines) apart.
+    // This takes about 3-6ms on Android in Release
+    JobSystem& js = engine.getJobSystem();
+    auto *slices = js.createJob();
+    for (size_t b = 0; b < c.lutDimension; b++) {
+        auto *job = js.createJob(slices,
+                [data, converted, b, &c, &configLock, builder](JobSystem&, JobSystem::Job*) {
+            Config config;
+            {
+                std::lock_guard<Mutex> lock(configLock);
+                config = c;
            }
-        } else {
-            for (size_t rgb = 0; rgb < config.lutDimension; rgb++) {
-                *p++ = half(hdrColorAt(rgb, rgb, rgb).r);
-            }
-        }
-    } else {
-        // Multithreadedly generate the tone mapping 3D look-up table using 32 jobs
-        // Slices are 8 KiB (128 cache lines) apart.
-        // This takes about 3-6ms on Android in Release
-        JobSystem& js = engine.getJobSystem();
-        auto *slices = js.createJob();
-        for (size_t b = 0; b < config.lutDimension; b++) {
-            auto* job = js.createJob(slices,
-                    [data, converted, b, &config, builder, &hdrColorAt](
-                            JobSystem&, JobSystem::Job*) {
-                half4* UTILS_RESTRICT p =
-                        (half4*) data + b * config.lutDimension * config.lutDimension;
-                for (size_t g = 0; g < config.lutDimension; g++) {
-                    for (size_t r = 0; r < config.lutDimension; r++) {
-                        *p++ = half4{hdrColorAt(r, g, b), 0.0f};
+            half4* UTILS_RESTRICT p = (half4*) data + b * config.lutDimension * config.lutDimension;
+            for (size_t g = 0; g < config.lutDimension; g++) {
+                for (size_t r = 0; r < config.lutDimension; r++) {
+                    float3 v = float3{r, g, b} * (1.0f / float(config.lutDimension - 1u));
+
+                    // LogC encoding
+                    v = LogC_to_linear(v);
+
+                    // Kill negative values near 0.0f due to imprecision in the log conversion
+                    v = max(v, 0.0f);
+
+                    if (builder->hasAdjustments) {
+                        // Exposure
+                        v = adjustExposure(v, builder->exposure);
+
+                        // Purkinje shift ("low-light" vision)
+                        v = scotopicAdaptation(v, builder->nightAdaptation);
                    }
-                }

-                if (converted) {
-                    uint32_t* const UTILS_RESTRICT dst = (uint32_t*) converted +
-                            b * config.lutDimension * config.lutDimension;
-                    half4* UTILS_RESTRICT src = (half4*) data +
-                            b * config.lutDimension * config.lutDimension;
-                    // we use a vectorize width of 8 because, on ARMv8 it allows the compiler to
-                    // write eight 32-bits results in one go.
-                    const size_t count = (config.lutDimension * config.lutDimension) & ~0x7u; // tell the compiler that we're a multiple of 8
+                    // Move to color grading color space
+                    v = c.colorGradingIn * v;
+
+                    if (builder->hasAdjustments) {
+                        // White balance
+                        v = chromaticAdaptation(v, config.adaptationTransform);
+
+                        // Kill negative values before the next transforms
+                        v = max(v, 0.0f);
+
+                        // Channel mixer
+                        v = channelMixer(v, builder->outRed, builder->outGreen, builder->outBlue);
+
+                        // Shadows/mid-tones/highlights
+                        v = tonalRanges(v, c.colorGradingLuminance,
+                                builder->shadows, builder->midtones, builder->highlights,
+                                builder->tonalRanges);
+
+                        // The adjustments below behave better in log space
+                        v = linear_to_LogC(v);
+
+                        // ASC CDL
+                        v = colorDecisionList(v, builder->slope, builder->offset, builder->power);
+
+                        // Contrast in log space
+                        v = contrast(v, builder->contrast);
+
+                        // Back to linear space
+                        v = LogC_to_linear(v);
+
+                        // Vibrance in linear space
+                        v = vibrance(v, c.colorGradingLuminance, builder->vibrance);
+
+                        // Saturation in linear space
+                        v = saturation(v, c.colorGradingLuminance, builder->saturation);
+
+                        // Kill negative values before curves
+                        v = max(v, 0.0f);
+
+                        // RGB curves
+                        v = curves(v,
+                                builder->shadowGamma, builder->midPoint, builder->highlightScale);
+                    }
+
+                    // Tone mapping
+                    if (builder->luminanceScaling) {
+                        v = luminanceScaling(v, *builder->toneMapper, c.colorGradingLuminance);
+                    } else {
+                        v = (*builder->toneMapper)(v);
+                    }
+
+                    // Go back to display color space
+                    v = c.colorGradingOut * v;
+
+                    // Apply gamut mapping
+                    if (builder->gamutMapping) {
+                        // TODO: This should depend on the output color space
+                        v = gamutMapping_sRGB(v);
+                    }
+
+                    // TODO: We should convert to the output color space if we use a working
+                    //       color space that's not sRGB
+                    // TODO: Allow the user to customize the output color space
+
+                    // We need to clamp for the output transfer function
+                    v = saturate(v);
+
+                    // Apply OETF
+                    v = c.oetf(v);
+
+                    *p++ = half4{v, 0.0f};
+                }
+            }
+
+            if (converted) {
+                uint32_t* const UTILS_RESTRICT dst = (uint32_t*) converted +
+                        b * config.lutDimension * config.lutDimension;
+                half4* UTILS_RESTRICT src = (half4*) data +
+                        b * config.lutDimension * config.lutDimension;
+                // we use a vectorize width of 8 because, on ARMv8 it allows the compiler to write eight
+                // 32-bits results in one go.
+                const size_t count = (config.lutDimension * config.lutDimension) & ~0x7u; // tell the compiler that we're a multiple of 8
 #if defined(__clang__)
-#pragma clang loop vectorize_width(8)
+                #pragma clang loop vectorize_width(8)
 #endif
-                    for (size_t i = 0; i < count; ++i) {
-                        float4 v{src[i]};
-                        uint32_t pr = uint32_t(std::floor(v.x * 1023.0f + 0.5f));
-                        uint32_t pg = uint32_t(std::floor(v.y * 1023.0f + 0.5f));
-                        uint32_t pb = uint32_t(std::floor(v.z * 1023.0f + 0.5f));
-                        dst[i] = (pb << 20u) | (pg << 10u) | pr;
-                    }
+                for (size_t i = 0; i < count; ++i) {
+                    float4 v{src[i]};
+                    uint32_t pr = uint32_t(std::floor(v.x * 1023.0f + 0.5f));
+                    uint32_t pg = uint32_t(std::floor(v.y * 1023.0f + 0.5f));
+                    uint32_t pb = uint32_t(std::floor(v.z * 1023.0f + 0.5f));
+                    dst[i] = (pb << 20u) | (pg << 10u) | pr;
                }
-            });
-            js.run(job);
-        }
+            }

-        // TODO: Should we do a runAndRetain() and defer the wait() + texture creation until
-        //       getHwHandle() is invoked?
-        js.runAndWait(slices);
+        });
+        js.run(job);
    }

+    // TODO: Should we do a runAndRetain() and defer the wait() + texture creation until
+    //       getHwHandle() is invoked?
+    js.runAndWait(slices);
+
    //std::chrono::duration<float, std::milli> duration = std::chrono::steady_clock::now() - now;
    //slog.d << "LUT generation time: " << duration.count() << " ms" << io::endl;

+    mLutHandle = driver.createTexture(
+            SamplerType::SAMPLER_3D,
+            1,
+            textureFormat,
+            1,
+            c.lutDimension,
+            c.lutDimension,
+            c.lutDimension,
+            TextureUsage::DEFAULT
+    );
+
    if (converted) {
        free(data);
        data = converted;
        elementSize = sizeof(uint32_t);
    }

-    // Create texture.
-    mLutHandle = driver.createTexture(SamplerType::SAMPLER_3D, 1, textureFormat, 1,
-            width, height, depth, TextureUsage::DEFAULT);
-
    driver.update3DImage(mLutHandle, 0,
            0, 0, 0,
-            width, height, depth,
+            c.lutDimension, c.lutDimension, c.lutDimension,
            PixelBufferDescriptor{
-                data, lutElementCount * elementSize, format, type,
-                        [](void* buffer, size_t, void*) { free(buffer); }
-                        });
+                    data, lutElementCount * elementSize,format, type,
+                    [](void* buffer, size_t, void*) { free(buffer); }
+            }
+    );
 }

 FColorGrading::~FColorGrading() noexcept = default;
@@ -42,15 +42,12 @@ public:
    void terminate(FEngine& engine);

    backend::TextureHandle getHwHandle() const noexcept { return mLutHandle; }
+
    uint32_t getDimension() const noexcept { return mDimension; }
-    bool isOneDimensional() const noexcept { return mIsOneDimensional; }
-    bool isLDR() const noexcept { return mIsLDR; }

 private:
    backend::TextureHandle mLutHandle;
    uint32_t mDimension;
-    bool mIsOneDimensional;
-    bool mIsLDR;
 };

 FILAMENT_DOWNCAST(ColorGrading)
@@ -687,9 +687,6 @@ public:

    struct {
        struct {
-            struct {
-                bool use_1d_lut = false;
-            } color_grading;
            struct {
                bool use_shadow_atlas = false;
            } shadows;
@@ -722,9 +719,6 @@ public:
            { "backend.opengl.assert_native_window_is_valid",
              "Asserts that the ANativeWindow is valid when rendering starts.",
              &features.backend.opengl.assert_native_window_is_valid, true },
-            { "engine.color_grading.use_1d_lut",
-              "Uses a 1D LUT for color grading.",
-              &features.engine.color_grading.use_1d_lut, false },
            { "engine.shadows.use_shadow_atlas",
              "Uses an array of atlases to store shadow maps.",
              &features.engine.shadows.use_shadow_atlas, false },
@@ -153,10 +153,9 @@ Texture::Builder& Texture::Builder::name(const char* name, size_t const len) noe
 }

 Texture* Texture::Builder::build(Engine& engine) {
-    if (mImpl->mTarget != SamplerType::SAMPLER_EXTERNAL) {
-        FILAMENT_CHECK_PRECONDITION(Texture::isTextureFormatSupported(engine, mImpl->mFormat))
-                << "Texture format " << uint16_t(mImpl->mFormat) << " not supported on this platform";
-    }
+    FILAMENT_CHECK_PRECONDITION(Texture::isTextureFormatSupported(engine, mImpl->mFormat))
+            << "Texture format " << uint16_t(mImpl->mFormat) << " not supported on this platform";
+
    const bool isProtectedTexturesSupported =
            downcast(engine).getDriverApi().isProtectedTexturesSupported();
    const bool useProtectedMemory = bool(mImpl->mUsage & TextureUsage::PROTECTED);
@@ -1,29 +1,13 @@
-vec3 LogC_to_linear(const vec3 x) {
+vec3 colorGrade(mediump sampler3D lut, const vec3 x) {
    // Alexa LogC EI 1000
    const float a = 5.555556;
    const float b = 0.047996;
    const float c = 0.244161 / log2(10.0);
    const float d = 0.386036;
-    return c * log2(a * x + b) + d;
-}
+    vec3 logc = c * log2(a * x + b) + d;

-vec3 colorGrade3D(mediump sampler3D lut, const vec3 v) {
-    return textureLod(lut, v, 0.0).rgb;
-}
+    // Remap to sample pixel centers
+    logc = materialParams.lutSize.x + logc * materialParams.lutSize.y;

-vec3 colorGrade1D(mediump sampler3D lut, const vec3 v) {
-    return vec3(
-        textureLod(lut, vec3(v.r, 0.5, 0.5), 0.0).r,
-        textureLod(lut, vec3(v.g, 0.5, 0.5), 0.0).r,
-        textureLod(lut, vec3(v.b, 0.5, 0.5), 0.0).r);
-}
-
-vec3 colorGrade(mediump sampler3D lut, vec3 v) {
-    if (!materialConstants_isLDR) {
-        v = LogC_to_linear(v);
-    }
-    // Remap to sample pixel centers.
-    v = materialParams.lutSize.x + v * materialParams.lutSize.y;
-    return materialConstants_isOneDimensional
-            ? colorGrade1D(lut, v) : colorGrade3D(lut, v);
+    return textureLod(lut, logc, 0.0).rgb;
 }
@@ -66,16 +66,6 @@ material {
            precision : high
        }
    ],
-    constants : [
-        {
-            type : bool,
-            name : isOneDimensional
-        },
-        {
-            type : bool,
-            name : isLDR
-        }
-    ],
    variables : [
        vertex
    ],
@@ -164,7 +154,7 @@ void postProcess(inout PostProcessInputs postProcess) {
    }

    // Color grading
-    color.rgb = colorGrade(materialParams_lut, color.rgb);
+    color.rgb  = colorGrade(materialParams_lut, color.rgb);

    // output in premultiplied alpha
 #if !POST_PROCESS_OPAQUE
@@ -32,16 +32,6 @@ material {
            name : vignetteColor
        }
    ],
-    constants : [
-        {
-            type : bool,
-            name : isOneDimensional
-        },
-        {
-            type : bool,
-            name : isLDR
-        }
-    ],
    subpasses : [
        {
            type : subpassInput,
@@ -113,7 +103,7 @@ void postProcess(inout PostProcessInputs postProcess) {
    }

    // Color grading
-    color.rgb = colorGrade(materialParams_lut, color.rgb);
+    color.rgb  = colorGrade(materialParams_lut, color.rgb);

    // output in premultiplied alpha
 #if !POST_PROCESS_OPAQUE
@@ -88,12 +88,7 @@ void minLeftMaxRight(inout vec4 a, inout vec4 b, inout vec4 c, inout vec4 d, ino

 // - we can't use a function because offset must be a constant expression
 // - we can't use line continuation because that's not supported on desktop
-#ifdef TARGET_WEBGPU_ENVIRONMENT
-//WebGPU can not handle texelFetchOffset without an error about "ConstOffset is only permitted...".
-#define makeSample(ij, o) vec4(texelFetch(materialParams_dof, ij+o, 0).rgb, texelFetch(materialParams_alpha, ij+o, 0).r)
-#else
 #define makeSample(ij, o) vec4(texelFetchOffset(materialParams_dof, ij, 0, o).rgb, texelFetchOffset(materialParams_alpha, ij, 0, o).r)
-#endif

 vec4 median(ivec2 ij) {
    vec4 v[9];
@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
  spec.name = "Filament"
-  spec.version = "1.58.1"
+  spec.version = "1.58.0"
  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.0/filament-v1.58.0-ios.tgz" }

  # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
  spec.pod_target_xcconfig = {
@@ -12,7 +12,7 @@

 ## Capabilities

-fgviewer is a library and web application for real-time visualization of the frame graph in Filament.
+fgviewer is a library and web application for real-time visualization of the frame graph in Filament.  
 It displays active passes and resource usage, providing insights into the rendering pipeline.

 ## Setup for Desktop
@@ -58,7 +58,7 @@ public:
            utils::CString name;
            utils::CString value;
        };
-
+        
        Resource(ResourceId id, utils::CString name,
                 std::vector<Property> properties);

@@ -17,22 +17,14 @@

 #include "ApiHandler.h"

-#include <__chrono/duration.h>
 #include <fgviewer/DebugServer.h>
 #include <fgviewer/JsonWriter.h>

 #include <utils/FixedCapacityVector.h>
 #include <utils/Log.h>
-#include <utils/ostream.h>

 #include <CivetServer.h>

-#include <cstdint>
-#include <cstdio>
-#include <cstring>
-#include <mutex>
-#include <string>
-
 namespace filament::fgviewer {

 using namespace std::chrono_literals;
@@ -21,45 +21,36 @@

 #include <CivetServer.h>

+#include <utils/FixedCapacityVector.h>
+#include <utils/Hash.h>
 #include <utils/Log.h>
-#include <utils/Mutex.h>
-#include <utils/ostream.h>

-#include <mutex>
 #include <string>
 #include <string_view>

+namespace filament::fgviewer {

 // If set to 0, this serves HTML from a resgen resource. Use 1 only during local development, which
 // serves files directly from the source code tree.
 #define SERVE_FROM_SOURCE_TREE 0

 #if SERVE_FROM_SOURCE_TREE
-
 namespace {
 std::string const BASE_URL = "libs/fgviewer/web";
 } // anonymous
-
 #else
-
 #include "fgviewer_resources.h"
 #include <unordered_map>

 namespace {
-
 struct Asset {
    std::string_view mime;
    std::string_view data;
 };
-
 std::unordered_map<std::string_view, Asset> ASSET_MAP;
-
 } // anonymous
-
 #endif // SERVE_FROM_SOURCE_TREE

-namespace filament::fgviewer {
-
 using namespace utils;

 std::string_view const DebugServer::kSuccessHeader =
@@ -16,11 +16,6 @@

 #include <fgviewer/FrameGraphInfo.h>

-#include <utils/CString.h>
-
-#include <unordered_map>
-#include <vector>
-
 namespace filament::fgviewer {

 FrameGraphInfo::FrameGraphInfo(utils::CString viewName):
@@ -14,15 +14,11 @@
 * limitations under the License.
 */

-#include <fgviewer/FrameGraphInfo.h>
 #include <fgviewer/JsonWriter.h>
+#include <fgviewer/FrameGraphInfo.h>

-#include <utils/CString.h>
-
-#include <cstddef>
-#include <ostream>
+#include <iomanip>
 #include <sstream>
-#include <vector>

 namespace filament::fgviewer {

@@ -223,8 +223,8 @@ class FrameGraphSidePanel extends LitElement {
            return html`
                <menu-section title="${title}">
                    ${this.framegraphs.map(({ fgid, name }) => html`
-                        <div class="framegraph"
-                            @click="${() => this._handleFrameGraphClick(fgid)}"
+                        <div class="framegraph" 
+                            @click="${() => this._handleFrameGraphClick(fgid)}" 
                            data-id="${fgid}">
                            ${fgid === this.selectedFrameGraph ? '● ' : ''}${name}
                        </div>
@@ -440,15 +440,15 @@ class FrameGraphTable extends LitElement {
        return html`
            <tr id="resource-${resourceIndex}">
                <th class="sticky-col resource ${selectedStyle}" @click="${onClickResource}">
-                    ${hasSubresources
+                    ${hasSubresources 
                        ? html`
                            <span class="toggle-icon"
                                  @click="${(e) => { e.stopPropagation(); this._toggleCollapse(resourceIndex); }}">
                              ${isExpanded ? '▼' : '▶'}
-                            </span>`
+                            </span>` 
                        : nothing}
                    ${resource.name}
-                    ${hasSubresources && !isExpanded ? html`(${subresourceIds.length})` : nothing}
+                    ${hasSubresources && isExpanded ? nothing : html`(${subresourceIds.length})`}
                </th>
                ${this._renderResourceUsage(allPasses, resourceIds, DEFAULT_COLOR)}
            </tr>
@@ -592,12 +592,12 @@ class FrameGraphViewer extends LitElement {
        return html`
            <framegraph-sidepanel id="sidepanel"
                ?connected="${this.connected}"
-                selected-framegraph="${this.selectedFrameGraph}"
+                selected-framegraph="${this.selectedFrameGraph}" 
                selected-resource="${this.selectedResourceId}">
            </framegraph-sidepanel>
-            <framegraph-table id="table"
+            <framegraph-table id="table" 
                ?connected="${this.connected}"
-                selected-framegraph="${this.selectedFrameGraph}"
+                selected-framegraph="${this.selectedFrameGraph}" 
                selected-resource="${this.selectedResourceId}">
            </framegraph-table>
        `;
@@ -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 = 57;

 /**
 * Supported shading models
@@ -203,7 +203,7 @@ enum class ReflectionMode : uint8_t {
 // can't really use std::underlying_type<AttributeIndex>::type because the driver takes a uint32_t
 using AttributeBitset = utils::bitset32;

-static constexpr size_t MATERIAL_PROPERTIES_COUNT = 30;
+static constexpr size_t MATERIAL_PROPERTIES_COUNT = 29;
 enum class Property : uint8_t {
    BASE_COLOR,              //!< float4, all shading models
    ROUGHNESS,               //!< float,  lit shading models only
@@ -234,7 +234,6 @@ enum class Property : uint8_t {
    BENT_NORMAL,             //!< float3, all shading models only, except unlit
    SPECULAR_FACTOR,         //!< float, lit shading models only, except subsurface and cloth
    SPECULAR_COLOR_FACTOR,   //!< float3, lit shading models only, except subsurface and cloth
-    SHADOW_STRENGTH,         //!< float, [0, 1] strength of shadows received by this material

    // when adding new Properties, make sure to update MATERIAL_PROPERTIES_COUNT
 };
@@ -217,13 +217,12 @@ public:
    MaterialBuilder(MaterialBuilder&& rhs) noexcept = default;
    MaterialBuilder& operator=(MaterialBuilder&& rhs) noexcept = default;

-    static constexpr size_t MATERIAL_VARIABLES_COUNT = 5;
+    static constexpr size_t MATERIAL_VARIABLES_COUNT = 4;
    enum class Variable : uint8_t {
        CUSTOM0,
        CUSTOM1,
        CUSTOM2,
-        CUSTOM3,
-        CUSTOM4, // CUSTOM4 is only available if the vertex attribute `color` is not required.
+        CUSTOM3
        // when adding more variables, make sure to update MATERIAL_VARIABLES_COUNT
    };

@@ -49,8 +49,7 @@ std::unordered_map<std::string, Property> Enums::mStringToProperty = {
        { "microThickness",      Property::MICRO_THICKNESS },
        { "bentNormal",          Property::BENT_NORMAL },
        { "specularFactor",      Property::SPECULAR_FACTOR },
-        { "specularColorFactor", Property::SPECULAR_COLOR_FACTOR },
-        { "shadowStrength",       Property::SHADOW_STRENGTH }
+        { "specularColorFactor",  Property::SPECULAR_COLOR_FACTOR }
 };

 template <>
@@ -517,104 +517,29 @@ 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();
-    uint32_t* data = spirv.data();
-
-    struct Descriptor {
-        uint32_t binding = 0xFFFFFFFF;
-        bool fixed = false;
-    };
-
-    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;
-        if (itr = descriptors.find(var); itr == descriptors.end()) {
-            itr = descriptors.insert({var, {}}).first;
-        }
-        return itr->second;
-    };
-
-    auto pass = [&](uint32_t targetOp, std::function<void(uint32_t)> f) {
-        for (uint32_t cursor = HEADER_SIZE, cursorEnd = dataSize; cursor < cursorEnd;) {
-            uint32_t const firstWord = data[cursor];
-            uint32_t const wordCount = firstWord >> 16;
-            uint32_t const op = firstWord & 0x0000FFFF;
-            if (targetOp == op) {
-                f(cursor+1);
-            }
-            cursor += wordCount;
-        }
-    };
-
-    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);
-        }
-});
-
-
-    // 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;
-            }
-        }
-    });
-}

 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());
+    // We need to remove dead code for our variant-filter workaround for WebGPU to work
+    // This is especially relevant for removing the push constants that morphing uses when not disabled
+    spv::spirvbin_t remapper(0);
+    remapper.remap(*spirv, spv::spirvbin_base_t::DCE_ALL);

-    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
-    const tint::spirv::reader::Options readerOpts{true};
+    //Currently no options we want to use
+    const tint::spirv::reader::Options readerOpts{};
    tint::wgsl::writer::Options writerOpts{};

    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
+        //TODO remove this if block once combined image sampler conversion works.
+        if (tintRead.Diagnostics().Str().rfind("error: WGSL does not support combined image-samplers") != std::string::npos) {
+            slog.w << "This tint reader error is currently ignored during WebGPU bringup: " << tintRead.Diagnostics().Str() << io::endl;
+        }
+        else {
+            slog.e << "Tint Reader Error: " << tintRead.Diagnostics().Str() << io::endl;
+            return false;
+        }
    }

    tint::Result<tint::wgsl::writer::Output> wgslOut = tint::wgsl::writer::Generate(tintRead,writerOpts);
@@ -962,8 +887,10 @@ bool GLSLPostProcessor::fullOptimization(const TShader& tShader,
    return true;
 }

-std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createEmptyOptimizer() {
+std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createOptimizer(
+        MaterialBuilder::Optimization optimization, Config const& config) {
    auto optimizer = std::make_shared<spvtools::Optimizer>(SPV_ENV_UNIVERSAL_1_3);
+
    optimizer->SetMessageConsumer([](spv_message_level_t level,
            const char* source, const spv_position_t& position, const char* message) {
        if (!filterSpvOptimizerMessage(level)) {
@@ -972,12 +899,6 @@ std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createEmptyOptimizer() {
        slog.e << stringifySpvOptimizerMessage(level, source, position, message)
                << io::endl;
    });
-    return optimizer;
-}
-
-std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createOptimizer(
-        MaterialBuilder::Optimization optimization, Config const& config) {
-    auto optimizer = createEmptyOptimizer();

    if (optimization == MaterialBuilder::Optimization::SIZE) {
        // When optimizing for size, we don't run the SPIR-V through any size optimization passes
@@ -1002,7 +923,7 @@ std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createOptimizer(
    return optimizer;
 }

-void GLSLPostProcessor::optimizeSpirv(OptimizerPtr optimizer, SpirvBlob& spirv) {
+void GLSLPostProcessor::optimizeSpirv(OptimizerPtr optimizer, SpirvBlob& spirv) const {
    if (!optimizer->Run(spirv.data(), spirv.size(), &spirv)) {
        slog.e << "SPIR-V optimizer pass failed" << io::endl;
        return;
@@ -1056,7 +977,7 @@ void GLSLPostProcessor::registerPerformancePasses(Optimizer& optimizer, Config c

    RegisterPass(CreateWrapOpKillPass());
    RegisterPass(CreateDeadBranchElimPass());
-    RegisterPass(CreateMergeReturnPass(), MaterialBuilder::TargetApi::METAL | MaterialBuilder::TargetApi::WEBGPU);
+    RegisterPass(CreateMergeReturnPass(), MaterialBuilder::TargetApi::METAL);
    RegisterPass(CreateInlineExhaustivePass());
    RegisterPass(CreateAggressiveDCEPass());
    RegisterPass(CreatePrivateToLocalPass());
@@ -114,20 +114,14 @@ private:
     * Retrieve an optimizer instance tuned for the given optimization level and shader configuration.
     */
    using OptimizerPtr = std::shared_ptr<spvtools::Optimizer>;
-
    static OptimizerPtr createOptimizer(
            MaterialBuilder::Optimization optimization,
            Config const& config);

-    static OptimizerPtr createEmptyOptimizer();
-
    static void registerSizePasses(spvtools::Optimizer& optimizer, Config const& config);
-
    static void registerPerformancePasses(spvtools::Optimizer& optimizer, Config const& config);

-    static void optimizeSpirv(OptimizerPtr optimizer, SpirvBlob &spirv);
-
-    static void rebindImageSamplerForWGSL(std::vector<uint32_t>& spirv);
+    void optimizeSpirv(OptimizerPtr optimizer, SpirvBlob& spirv) const;

    void fixupClipDistance(SpirvBlob& spirv, GLSLPostProcessor::Config const& config) const;

@@ -252,7 +252,6 @@ MaterialBuilder& MaterialBuilder::variable(Variable v, const char* name) noexcep
        case Variable::CUSTOM1:
        case Variable::CUSTOM2:
        case Variable::CUSTOM3:
-        case Variable::CUSTOM4:
            assert(size_t(v) < MATERIAL_VARIABLES_COUNT);
            mVariables[size_t(v)] = { CString(name), Precision::DEFAULT, false };
            break;
@@ -267,7 +266,6 @@ MaterialBuilder& MaterialBuilder::variable(Variable v,
        case Variable::CUSTOM1:
        case Variable::CUSTOM2:
        case Variable::CUSTOM3:
-        case Variable::CUSTOM4:
            assert(size_t(v) < MATERIAL_VARIABLES_COUNT);
            mVariables[size_t(v)] = { CString(name), precision, true };
            break;
@@ -1256,15 +1254,6 @@ error:
                OutputTarget::COLOR, Precision::DEFAULT, OutputType::FLOAT4, "color");
    }

-    if (mMaterialDomain == MaterialDomain::SURFACE) {
-        if (mRequiredAttributes[VertexAttribute::COLOR] &&
-            !mVariables[int(Variable::CUSTOM4)].name.empty()) {
-            // both the color attribute and the custom4 variable are present, that's not supported
-            slog.e << "Error: when the 'color' attribute is required 'Variable::CUSTOM4' is not supported." << io::endl;
-            goto error;
-        }
-    }
-
    // TODO: maybe check MaterialDomain::COMPUTE has outputs

    // Resolve all the #include directives within user code.
@@ -937,15 +937,6 @@ utils::io::sstream& CodeGenerator::generateSpecializationConstant(utils::io::sst
    std::string const constantString = std::visit(SpecializationConstantFormatter(), value);

    static const char* types[] = { "int", "float", "bool" };
-
-    // Spec constants aren't fully supported in Tint,
-    //  workaround until https://issues.chromium.org/issues/42250586 is resolved
-    if (mTargetApi == TargetApi::WEBGPU) {
-        out << "layout (constant_id = " << id << ") const "
-                << types[value.index()] << " " << name << "_hack = " << constantString << ";\n"
-                << types[value.index()] << " " << name << " = " << name << "_hack;\n";
-        return out;
-    }
    if (mTargetLanguage == MaterialBuilderBase::TargetLanguage::SPIRV) {
        out << "layout (constant_id = " << id << ") const "
            << types[value.index()] << " " << name << " = " << constantString << ";\n";
@@ -1227,7 +1218,6 @@ char const* CodeGenerator::getConstantName(MaterialBuilder::Property property) n
        case Property::BENT_NORMAL:                 return "BENT_NORMAL";
        case Property::SPECULAR_FACTOR:             return "SPECULAR_FACTOR";
        case Property::SPECULAR_COLOR_FACTOR:       return "SPECULAR_COLOR_FACTOR";
-        case Property::SHADOW_STRENGTH:             return "SHADOW_STRENGTH";
    }
 }

@@ -696,25 +696,6 @@ TEST_F(MaterialCompiler, StaticCodeAnalyzerBentNormal) {
    EXPECT_TRUE(PropertyListsMatch(expected, properties));
 }

-TEST_F(MaterialCompiler, StaticCodeAnalyzerShadowStrength) {
-    std::string fragmentCode(R"(
-        void material(inout MaterialInputs material) {
-            prepareMaterial(material);
-            material.shadowStrength = 0.1;
-        }
-    )");
-
-    std::string shaderCode = shaderWithAllProperties(*jobSystem, ShaderStage::FRAGMENT,
-            fragmentCode);
-
-    GLSLTools glslTools;
-    MaterialBuilder::PropertyList properties{ false };
-    glslTools.findProperties(ShaderStage::FRAGMENT, shaderCode, properties);
-    MaterialBuilder::PropertyList expected{ false };
-    expected[size_t(filamat::MaterialBuilder::Property::SHADOW_STRENGTH)] = true;
-    EXPECT_TRUE(PropertyListsMatch(expected, properties));
-}
-
 TEST_F(MaterialCompiler, StaticCodeAnalyzerOutputFactor) {
    std::string fragmentCode(R"(
        void material(inout MaterialInputs material) {
@@ -778,48 +759,6 @@ TEST_F(MaterialCompiler, Uv0AndUv1) {
    EXPECT_TRUE(result.isValid());
 }

-TEST_F(MaterialCompiler, FiveCustomVariables) {
-    filamat::MaterialBuilder builder;
-    builder.variable(MaterialBuilder::Variable::CUSTOM0, "custom0");
-    builder.variable(MaterialBuilder::Variable::CUSTOM1, "custom1");
-    builder.variable(MaterialBuilder::Variable::CUSTOM2, "custom2");
-    builder.variable(MaterialBuilder::Variable::CUSTOM3, "custom3");
-    builder.variable(MaterialBuilder::Variable::CUSTOM4, "custom4");
-    filamat::Package result = builder.build(*jobSystem);
-    EXPECT_TRUE(result.isValid());
-}
-
-TEST_F(MaterialCompiler, FourCustomVariablesAndColorAttribute) {
-    filamat::MaterialBuilder builder;
-    builder.require(filament::VertexAttribute::COLOR);
-    builder.variable(MaterialBuilder::Variable::CUSTOM0, "custom0");
-    builder.variable(MaterialBuilder::Variable::CUSTOM1, "custom1");
-    builder.variable(MaterialBuilder::Variable::CUSTOM2, "custom2");
-    builder.variable(MaterialBuilder::Variable::CUSTOM3, "custom3");
-    filamat::Package result = builder.build(*jobSystem);
-    EXPECT_TRUE(result.isValid());
-}
-
-TEST_F(MaterialCompiler, FiveCustomVariablesAndColorAttributeFails) {
-    filamat::MaterialBuilder builder;
-    builder.require(filament::VertexAttribute::COLOR);
-    builder.variable(MaterialBuilder::Variable::CUSTOM0, "custom0");
-    builder.variable(MaterialBuilder::Variable::CUSTOM1, "custom1");
-    builder.variable(MaterialBuilder::Variable::CUSTOM2, "custom2");
-    builder.variable(MaterialBuilder::Variable::CUSTOM3, "custom3");
-    builder.variable(MaterialBuilder::Variable::CUSTOM4, "custom4");
-    filamat::Package result = builder.build(*jobSystem);
-    EXPECT_FALSE(result.isValid());
-}
-
-TEST_F(MaterialCompiler, CustomVariable4AndColorAttributeFails) {
-    filamat::MaterialBuilder builder;
-    builder.require(filament::VertexAttribute::COLOR);
-    builder.variable(MaterialBuilder::Variable::CUSTOM4, "custom4");
-    filamat::Package result = builder.build(*jobSystem);
-    EXPECT_FALSE(result.isValid());
-}
-
 TEST_F(MaterialCompiler, Arrays) {
    filamat::MaterialBuilder builder;

@@ -20,9 +20,6 @@ struct PostProcessVertexInputs {
 #ifdef VARIABLE_CUSTOM3
    vec4 VARIABLE_CUSTOM3;
 #endif
-#ifdef VARIABLE_CUSTOM4
-    vec4 VARIABLE_CUSTOM4;
-#endif
 };

 void initPostProcessMaterialVertex(out PostProcessVertexInputs inputs) {
@@ -38,7 +35,4 @@ void initPostProcessMaterialVertex(out PostProcessVertexInputs inputs) {
 #ifdef VARIABLE_CUSTOM3
    inputs.VARIABLE_CUSTOM3 = vec4(0.0);
 #endif
-#ifdef VARIABLE_CUSTOM4
-    inputs.VARIABLE_CUSTOM4 = vec4(0.0);
-#endif
 }
@@ -39,9 +39,6 @@ void main() {
 #if defined(VARIABLE_CUSTOM3)
    VARIABLE_CUSTOM_AT3 = inputs.VARIABLE_CUSTOM3;
 #endif
-#if defined(VARIABLE_CUSTOM4)
-    VARIABLE_CUSTOM_AT4 = inputs.VARIABLE_CUSTOM4;
-#endif

    // some PowerVR drivers crash when gl_Position is written more than once
    gl_Position = inputs.position;
@@ -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.
@@ -52,15 +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);
-#if defined(MATERIAL_HAS_SHADOW_STRENGTH)
-            applyShadowStrength(visibility, material.shadowStrength);
-#endif
+            visibility = shadow(true, sampler0_shadowMap, cascade, shadowPosition, 0.0);
            // shadow far attenuation
            highp vec3 v = getWorldPosition() - getWorldCameraPosition();
            // (viewFromWorld * v).z == dot(transpose(viewFromWorld), v)
@@ -222,9 +222,6 @@ void evaluatePunctualLights(const MaterialInputs material,
                highp vec4 shadowPosition = getShadowPosition(shadowIndex, light.direction, light.zLight);
                visibility = shadow(false, sampler0_shadowMap, shadowIndex,
                        shadowPosition, light.zLight);
-#if defined(MATERIAL_HAS_SHADOW_STRENGTH)
-                applyShadowStrength(visibility, material.shadowStrength);
-#endif
            }
            if (light.contactShadows && visibility > 0.0) {
                if ((object_uniforms_flagsChannels & FILAMENT_OBJECT_CONTACT_SHADOWS_BIT) != 0) {
@@ -151,9 +151,6 @@ void main() {
 #if defined(VARIABLE_CUSTOM3)
    VARIABLE_CUSTOM_AT3 = material.VARIABLE_CUSTOM3;
 #endif
-#if defined(VARIABLE_CUSTOM4) && !defined(HAS_ATTRIBUTE_COLOR)
-    VARIABLE_CUSTOM_AT4 = material.VARIABLE_CUSTOM4;
-#endif

    // The world position can be changed by the user in materialVertex()
    vertex_worldPosition.xyz = material.worldPosition.xyz;
@@ -98,10 +98,6 @@ struct MaterialInputs {
    vec3 specularColorFactor;
 #endif

-#if defined(MATERIAL_HAS_SHADOW_STRENGTH)
-    float shadowStrength;
-#endif
-
 };

 void initMaterial(out MaterialInputs material) {
@@ -199,9 +195,6 @@ void initMaterial(out MaterialInputs material) {
    material.specularColorFactor = vec3(1.0);
 #endif

-#if defined(MATERIAL_HAS_SHADOW_STRENGTH)
-    material.shadowStrength = 0.0;
-#endif
 }

 #if defined(MATERIAL_HAS_CUSTOM_SURFACE_SHADING)
@@ -20,9 +20,6 @@ struct MaterialVertexInputs {
 #ifdef VARIABLE_CUSTOM3
    vec4 VARIABLE_CUSTOM3;
 #endif
-#if defined(VARIABLE_CUSTOM4) && !defined(HAS_ATTRIBUTE_COLOR)
-    vec4 VARIABLE_CUSTOM4;
-#endif
 #ifdef HAS_ATTRIBUTE_TANGENTS
    vec3 worldNormal;
 #endif
@@ -77,9 +74,6 @@ void initMaterialVertex(out MaterialVertexInputs material) {
 #endif
 #ifdef VARIABLE_CUSTOM3
    material.VARIABLE_CUSTOM3 = vec4(0.0);
-#endif
-#if defined(VARIABLE_CUSTOM4) && !defined(HAS_ATTRIBUTE_COLOR)
-    material.VARIABLE_CUSTOM4 = vec4(0.0);
 #endif
    material.worldPosition = computeWorldPosition();
 #ifdef VERTEX_DOMAIN_DEVICE
@@ -41,15 +41,12 @@ 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) {
        highp vec4 shadowPosition = getShadowPosition(cascade);
        visibility = shadow(true, sampler0_shadowMap, cascade, shadowPosition, 0.0);
-#if defined(MATERIAL_HAS_SHADOW_STRENGTH)
-        applyShadowStrength(visibility, material.shadowStrength);
-#endif
        // shadow far attenuation
        highp vec3 v = getWorldPosition() - getWorldCameraPosition();
        // (viewFromWorld * v).z == dot(transpose(viewFromWorld), v)
@@ -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
@@ -511,12 +511,6 @@ int getPointLightFace(const highp vec3 r) {
    }
 }

-#if defined(MATERIAL_HAS_SHADOW_STRENGTH)
-void applyShadowStrength(inout float visibility, float strength) {
-    visibility = 1.0 - (1.0 - visibility) * strength;
-}
-#endif
-
 // PCF sampling
 float shadow(const bool DIRECTIONAL,
        const mediump sampler2DArrayShadow shadowMap,
@@ -2,30 +2,30 @@
 // Varyings
 //------------------------------------------------------------------------------

+LAYOUT_LOCATION(4) VARYING highp vec4 vertex_worldPosition;
+
+#if defined(HAS_ATTRIBUTE_TANGENTS)
+LAYOUT_LOCATION(5) SHADING_INTERPOLATION VARYING mediump vec3 vertex_worldNormal;
+#if defined(MATERIAL_NEEDS_TBN)
+LAYOUT_LOCATION(6) SHADING_INTERPOLATION VARYING mediump vec4 vertex_worldTangent;
+#endif
+#endif
+
+LAYOUT_LOCATION(7) VARYING highp vec4 vertex_position;
+
+#if defined(FILAMENT_HAS_FEATURE_INSTANCING)
+LAYOUT_LOCATION(8) flat VARYING highp int instance_index;
+highp int logical_instance_index;
+#endif
+
 #if defined(HAS_ATTRIBUTE_COLOR)
-LAYOUT_LOCATION(4) VARYING mediump vec4 vertex_color;
+LAYOUT_LOCATION(9) VARYING mediump vec4 vertex_color;
 #endif

 #if defined(HAS_ATTRIBUTE_UV0) && !defined(HAS_ATTRIBUTE_UV1)
-LAYOUT_LOCATION(5) VARYING highp vec2 vertex_uv01;
+LAYOUT_LOCATION(10) VARYING highp vec2 vertex_uv01;
 #elif defined(HAS_ATTRIBUTE_UV1)
-LAYOUT_LOCATION(5) VARYING highp vec4 vertex_uv01;
-#endif
-
-LAYOUT_LOCATION(6) VARYING highp vec4 vertex_worldPosition;
-
-#if defined(HAS_ATTRIBUTE_TANGENTS)
-LAYOUT_LOCATION(7) SHADING_INTERPOLATION VARYING mediump vec3 vertex_worldNormal;
-#if defined(MATERIAL_NEEDS_TBN)
-LAYOUT_LOCATION(8) SHADING_INTERPOLATION VARYING mediump vec4 vertex_worldTangent;
-#endif
-#endif
-
-LAYOUT_LOCATION(9) VARYING highp vec4 vertex_position;
-
-#if defined(FILAMENT_HAS_FEATURE_INSTANCING)
-LAYOUT_LOCATION(10) flat VARYING highp int instance_index;
-highp int logical_instance_index;
+LAYOUT_LOCATION(10) VARYING highp vec4 vertex_uv01;
 #endif

 #if defined(VARIANT_HAS_SHADOWING) && defined(VARIANT_HAS_DIRECTIONAL_LIGHTING)
@@ -8,8 +8,7 @@
            "models": ["lucy", "DamagedHelmet"],
            "rendering": {
                "viewer.cameraFocusDistance": 0,
-                "view.postProcessingEnabled": true,
-                "view.dithering": "NONE"
+                "view.postProcessingEnabled": true
            }
        }
    ],
@@ -39,7 +39,7 @@ if [[ "$os_name" == "Linux" ]]; then
        sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-${GITHUB_CLANG_VERSION} 100
    else
        set +e
-        sudo apt-get -y build-dep mesa
+        apt-get -y build-dep mesa
        sudo apt -y remove llvm-18 llvm-18-* llvm-19 llvm-19-*
        set -e
        CURRENT_CLANG_VERSION=$(clang --version | head -n 1 | awk '{ print $4 }' | awk 'BEGIN { FS="\\." } { print $1 }')
@@ -51,12 +51,6 @@ if [[ "$os_name" == "Linux" ]]; then
             llvm-${LLVM_VERSION}-{dev,tools,runtime}
     fi # [[ "$GITHUB_WORKFLOW" ]]
 elif [[ "$os_name" == "Darwin" ]]; then
-    if [[ ! "$GITHUB_WORKFLOW" ]]; then
-        if [ ! command -v brew > /dev/null 2>&1 ]; then
-            echo "Error: need to install homebrew to continue"
-            exit 1
-        fi
-    fi
    brew install autoconf automake libx11 libxext libxrandr llvm@${LLVM_VERSION} ninja meson pkg-config libxshmfence

    NEEDED_PYTHON_DEPS=("mako" "setuptools")
@@ -74,7 +68,7 @@ LOCAL_CXX=$(which clang++)
 LOCAL_CC=$(which clang)

 CHECKOUT_MESA=false
-if [[ -d "${MESA_DIR}" ]]; then
+if [ -d "${MESA_DIR}" ]; then
    cd ${MESA_DIR}
    if ! git fsck --connectivity-only > /dev/null 2>&1; then
        echo "git fsck failed for mesa; try redownloading"
@@ -85,15 +79,13 @@ else
    CHECKOUT_MESA=true
 fi

-if [[ "$CHECKOUT_MESA" = "true" ]]; then
+if [ "$CHECKOUT_MESA" = "true" ]; then
    rm -rf ${MESA_DIR}

    #git clone https://gitlab.freedesktop.org/mesa/mesa.git
    git clone git://anongit.freedesktop.org/mesa/mesa
-    # Due to gitlab mesa outage.    
-    if [[ "${MESA_DIR}" != "$(pwd)/mesa" ]]; then
-        mv mesa ${MESA_DIR}
-    fi
+    mv mesa ${MESA_DIR}
+    # Due to gitlab mesa outage.
 fi

 pushd .
@@ -108,18 +100,14 @@ if  [[ "$os_name" == "Darwin" ]]; then
    LOCAL_LDFLAGS="-L/opt/homebrew/opt/llvm@${LLVM_VERSION}/lib"
    LOCAL_CPPFLAGS="-I/opt/homebrew/opt/llvm@${LLVM_VERSION}/include -I/opt/homebrew/include"
    LOCAL_PATH=${PATH}:/opt/homebrew/opt/llvm@${LLVM_VERSION}/bin
-
-    # This is necessary to be able to build vk (lavapipe) on macOS.  Doesn't seem like a real dependency.
-    sed -I '' "s/error('Vulkan drivers require dri3 for X11 support')//g" meson.build
 fi

 # -Dosmesa=true    => builds OSMesa, which is an offscreen GL context
 # -Dgallium-drivers=swrast  => builds GL software rasterizer
 # -Dvulkan-drivers=swrast   => builds VK software rasterizer
-# -Dgallium-drivers=llvmpipe is needed for GL >= 4.1 pipe-screen (see src/gallium/auxiliary/target-helpers/inline_sw_helper.h)
-CXX=${LOCAL_CXX} CC=${LOCAL_CC} PATH=${LOCAL_PATH} LDFLAGS=${LOCAL_LDFLAGS} CPPFLAGS=${LOCAL_CPPFLAGS} \
-   meson setup --wipe builddir/ -Dprefix="$(pwd)/out" -Dglx=xlib -Dosmesa=true -Dgallium-drivers=llvmpipe,swrast -Dvulkan-drivers=swrast
-CXX=${LOCAL_CXX} CC=${LOCAL_CC} PATH=${LOCAL_PATH} LDFLAGS=${LOCAL_LDFLAGS} CPPFLAGS=${LOCAL_CPPFLAGS} \
-   meson install -C builddir/
+# -Dgallium-drivers=llvmpipe is needed for GL >= 4.1 (see src/gallium/auxiliary/target-helpers/inline_sw_helper.h)
+# We are unable to enable vulkan swrast for macOS because of this failure "Vulkan drivers require dri3 for X11 support"
+CXX=${LOCAL_CXX} CC=${LOCAL_CC} PATH=${LOCAL_PATH} LDFLAGS=${LOCAL_LDFLAGS} CPPFLAGS=${LOCAL_CPPFLAGS} meson setup --wipe builddir/ -Dprefix="$(pwd)/out" -Dglx=xlib -Dosmesa=true -Dgallium-drivers=llvmpipe,swrast -Dvulkan-drivers=swrast
+CXX=${LOCAL_CXX} CC=${LOCAL_CC} PATH=${LOCAL_PATH} LDFLAGS=${LOCAL_LDFLAGS} CPPFLAGS=${LOCAL_CPPFLAGS} meson install -C builddir/

 popd
@@ -172,13 +172,11 @@ SPVTOOLS_OPT_SRC_FILES := \
 		source/opt/remove_unused_interface_variables_pass.cpp \
 		source/opt/replace_desc_array_access_using_var_index.cpp \
 		source/opt/replace_invalid_opc.cpp \
-		source/opt/resolve_binding_conflicts_pass.cpp \
 		source/opt/scalar_analysis.cpp \
 		source/opt/scalar_analysis_simplification.cpp \
 		source/opt/scalar_replacement_pass.cpp \
 		source/opt/set_spec_constant_default_value_pass.cpp \
 		source/opt/simplification_pass.cpp \
-		source/opt/split_combined_image_sampler_pass.cpp \
 		source/opt/spread_volatile_semantics.cpp \
 		source/opt/ssa_rewrite_pass.cpp \
 		source/opt/strength_reduction_pass.cpp \
@@ -201,7 +201,6 @@ cc_library(
    deps = [
        ":spirv_tools_internal",
        "@spirv_headers//:spirv_common_headers",
-        "@spirv_headers//:spirv_c_headers",
    ],
 )

@@ -771,8 +771,6 @@ static_library("spvtools_opt") {
    "source/opt/replace_desc_array_access_using_var_index.h",
    "source/opt/replace_invalid_opc.cpp",
    "source/opt/replace_invalid_opc.h",
-    "source/opt/resolve_binding_conflicts_pass.cpp",
-    "source/opt/resolve_binding_conflicts_pass.h",
    "source/opt/scalar_analysis.cpp",
    "source/opt/scalar_analysis.h",
    "source/opt/scalar_analysis_nodes.h",
@@ -783,8 +781,6 @@ static_library("spvtools_opt") {
    "source/opt/set_spec_constant_default_value_pass.h",
    "source/opt/simplification_pass.cpp",
    "source/opt/simplification_pass.h",
-    "source/opt/split_combined_image_sampler_pass.cpp",
-    "source/opt/split_combined_image_sampler_pass.h",
    "source/opt/spread_volatile_semantics.cpp",
    "source/opt/spread_volatile_semantics.h",
    "source/opt/ssa_rewrite_pass.cpp",
@@ -1386,7 +1382,6 @@ if (build_with_chromium && spvtools_build_executables) {
      "test/libspirv_macros_test.cpp",
      "test/name_mapper_test.cpp",
      "test/named_id_test.cpp",
-      "test/op_unknown_test.cpp",
      "test/opcode_make_test.cpp",
      "test/opcode_require_capabilities_test.cpp",
      "test/opcode_split_test.cpp",
@@ -1,40 +1,5 @@
 Revision history for SPIRV-Tools

-v2025.1 2025-02-28
-  - General
-    - diff: Fix crash in OpString matching (#5988)
-    - Add SPV_AMDX_shader_enqueue version 2 support (#5838)
-    - add support for SPV_INTEL_subgroup_matrix_multiply_accumulate (#5928)
-    - update cmake_minimum_required to 3.22.1 (#5925)
-    - Add OpImageSampleFootprintNV to IsAllowedSampledImageOperand (#5914)
-    - assembler: ensure progress when seeking the version string (#5910)
-  - Optimizer
-    - opt: keep all OpSource instructions (#5901)
-    - [opt] Fix bug opt::InstructionBuilder::AddVariable (#6007)
-    - [OPT] Add SPV_KHR_ray_tracing to allow list (#5941)
-    - opt: keep all OpSource instructions (#5901)
-  - Validator
-    - spirv-val: Add AllowVulkan32BitBitwise option (#6001)
-    - Fix untyped pointer comparison validation (#6004)
-    - spirv-val: Update VUIDs for 308 header (#5990)
-    - spirv-val: fix env parsing for vk1.1spv1.4 (#5985)
-    - Add validation for SPV_NV_linear_swept_spheres. (#5975)
-    - Add validation SPV_NV_cluster_acceleration_structure. (#5974)
-    - Improve the instruction diagnostic for some access chain errors (#5978)
-    - Update physical storage buffer validation to match SPIR-V 1.6.5 (#5977)
-    - Validate SPV_NV_cooperative_vector (#5972)
-    - Fix layout checks with untyped pointers (#5970)
-    - spirv-val: Update mislabeled VUIDs (#5964)
-    - More explicit layout validation (#5958)
-    - spirv-val: Add VK_KHR_maintenance8 support (#5951)
-    - Add EXT_mesh_shader validation support (#5640)
-    - spirv-val: Remove OpenCL ivec3 req (#5940)
-    - spirv-val: Validate zero product workgroup size (#5407)
-    - Relax DebugLine validation (#5916)
-  - Linker
-    - linker: remove LinkOnceODR decorations when linking executables (#5979)
-    - fix: handle LinkOnceODR correctly (#5938)
-
 v2024.4 2024-12-04
  - General
    - Add FPEncoding operand type. (#5726)
@@ -3,18 +3,18 @@ use_relative_paths = True
 vars = {
  'github': 'https://github.com',

-  'abseil_revision': '9f5fc9d1e934571a1f713b5a00cd5f15db8c71ed',
+  'abseil_revision': '69b58f9227bf91a9315475579df15fbb7c5c612e',

-  'effcee_revision': '874b47102c57a8979c0f154cf8e0eab53c0a0502',
+  'effcee_revision': '12241cbc30f20730b656db7fd5a3fa36cd420843',

-  'googletest_revision': '3af834740f58ef56058e6f8a1be51f62bc3a6515',
+  'googletest_revision': 'e235eb34c6c4fed790ccdad4b16394301360dcd4',

  # Use protobufs before they gained the dependency on abseil
  'protobuf_revision': 'v21.12',

-  're2_revision': 'c84a140c93352cdabbfb547c531be34515b12228',
+  're2_revision': '6dcd83d60f7944926bfd308cc13979fc53dd69ca',

-  'spirv_headers_revision': '0e710677989b4326ac974fd80c5308191ed80965',
+  'spirv_headers_revision': 'e7294a8ebed84f8c5bd3686c68dbe12a4e65b644',
 }

 deps = {
@@ -215,50 +215,6 @@ Note that this has some interesting consequences, including:
  that named ID being output.  This may be valid SPIR-V, contrary to the
  presumed intention of the writer.

-## OpUnknown
-<a name="op-unknown"></a>
-
-HLSL has a feature that allows users to specify an exact SPIR-V type using [the
-`SpirvType` template](https://github.com/microsoft/hlsl-specs/blob/main/proposals/0011-inline-spirv.md#types).
-This feature allows the user to specify a type opcode that the compiler does
-not know. In this case, it will be unable to generate assembly using the
-correct mnemonic.
-
-In order to represent unknown opcodes in assembly format, the `OpUnknown`
-pseudo-instruction may be used. The syntax is:
-
-```
-OpUnknown(<enumerant>, <WordCount>) <operand 1> ...
-```
-
-`enumerant` is the opcode enumerant, and `WordCount` is the number of words in
-the instruction. These will be assembled into a single word representing the
-opcode. Operands will be parsed according to the alternate parsing mode
-described in [Arbitrary Integers](#op-unknown). Named enumerated values cannot
-be handled by this mode and must be represented using the arbitrary integer
-syntax.
-
-It must be used at the beginning of a new instruction, and if there is a result
-ID it must explicitly be passed in as an operand. This is because the physical
-layout of a SPIR-V instruction may include a result type operand before the
-result ID operand, but it depends on the opcode and cannot be inferred for an
-unknown operand.
-
-For example, a 32-bit signed integer type could be represented like this:
-
-```
-OpUnknown(21, 4) %int_t 32 1
-```
-
-An OpStore instruction could be represented as:
-
-```
-OpUnknown(62, 3) %9 %12
-```
-
-The enumerant and word count must be decimal integers.
-
-
 ## Notes

 * Some enumerants cannot be used by name, because the target instruction
@@ -740,10 +740,6 @@ SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowLocalSizeId(
 SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowOffsetTextureOperand(
    spv_validator_options options, bool val);

-// Allow base operands of some bit operations to be non-32-bit wide.
-SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowVulkan32BitBitwise(
-    spv_validator_options options, bool val);
-
 // Whether friendly names should be used in validation error messages.
 SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetFriendlyNames(
    spv_validator_options options, bool val);
@@ -132,11 +132,6 @@ class SPIRV_TOOLS_EXPORT ValidatorOptions {
    spvValidatorOptionsSetAllowOffsetTextureOperand(options_, val);
  }

-  // Allow base operands of some bit operations to be non-32-bit wide.
-  void SetAllowVulkan32BitBitwise(bool val) {
-    spvValidatorOptionsSetAllowVulkan32BitBitwise(options_, val);
-  }
-
  // Records whether or not the validator should relax the rules on pointer
  // usage in logical addressing mode.
  //
@@ -240,7 +240,7 @@ class SPIRV_TOOLS_EXPORT Optimizer {

 private:
  struct SPIRV_TOOLS_LOCAL Impl;  // Opaque struct for holding internal data.
-  std::unique_ptr<Impl> impl_;    // Unique pointer to internal data.
+  std::unique_ptr<Impl> impl_;  // Unique pointer to internal data.
 };

 // Creates a null pass.
@@ -655,7 +655,7 @@ Optimizer::PassToken CreateRedundancyEliminationPass();
 // element if those elements are accessed individually.  The parameter is a
 // limit on the number of members in the composite variable that the pass will
 // consider replacing.
-Optimizer::PassToken CreateScalarReplacementPass(uint32_t size_limit = 0);
+Optimizer::PassToken CreateScalarReplacementPass(uint32_t size_limit = 100);

 // Create a private to local pass.
 // This pass looks for variables declared in the private storage class that are
@@ -968,60 +968,6 @@ Optimizer::PassToken CreateInvocationInterlockPlacementPass();
 // Creates a pass to add/remove maximal reconvergence execution mode.
 // This pass either adds or removes maximal reconvergence from all entry points.
 Optimizer::PassToken CreateModifyMaximalReconvergencePass(bool add);
-
-// Creates a pass to split combined image+sampler variables and function
-// parameters into separate image and sampler parts. Binding numbers and
-// other decorations are copied.
-Optimizer::PassToken CreateSplitCombinedImageSamplerPass();
-
-// Creates a pass to remap bindings to avoid conflicts, assuming the module
-// is valid for Vulkan.  A conflict exits when an entry point uses two distinct
-// variables with the same descriptor set and binding.  Vulkan allows one kind
-// of conflict: when one varible is an image (or array of images), and the
-// other is a sampler (or an array of samplers).
-
-// Conflicts are eliminated by incrementing the binding number of the sampler
-// part, and then propagating that increment through variables with
-// higher-numbered bindings until no conflict remains. This handles the case
-// when multiple shaders may share the same resource variables; this can
-// introduce holes in binding slots.
-//
-// Here's an example where shaders Alpha, Beta, Gamma, Delta collectively use
-// resource variables %100, %101, %102, %103, %104 all with the same
-// DescriptorSet and with Bindings as in the following table:
-//
-// Before:
-//
-//   Binding:   0          1        2        3
-//   Alpha:    %100,%101
-//   Beta:     %100       %102
-//   Gamma:               %102     %103
-//   Delta:                        %103     %104
-//
-// The Alpha shader has a conflict where variables %100, %101 have the same
-// descriptor set and binding.  If %100 is a sampler resource variable, then
-// the conflict is resolved by incrementing the binding number on %100 from 0
-// to 1.  But this causes a new confict for shader Beta because it now uses
-// both %100 and %102 with binding number 1.  That conflict is resolved by
-// incrementing the binding number on its variable that originally appeared
-// second (i.e. %102), so %102 gets binding 2. This now produces a conflict
-// for Gamma between %102 and %103 using binding number 2. Since %103 originally
-// appeared second (in the view from Gamma), the algorithm bumps %103 to binding
-// number %103. Now Delta has a conflict between %103 and %104, resulting in
-// %104 getting the next binding number, 4.  The picture afterward is:
-//
-// After:
-//
-//   Binding:   0          1        2        3        4
-//   Alpha:    %101       %100
-//   Beta:                %100     %102
-//   Gamma:                        %102     %103
-//   Delta:                                 %103     %104
-//
-//
-// This pass assumes binding numbers are not applid via decoration groups
-// (OpDecorationGroup).
-Optimizer::PassToken CreateResolveBindingConflictsPass();
 }  // namespace spvtools

 #endif  // INCLUDE_SPIRV_TOOLS_OPTIMIZER_HPP_
@@ -1,26 +0,0 @@
-#!/bin/bash
-# Copyright (c) 2025 Google LLC
-#
-# 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.
-
-# Fail on any error.
-set -e
-
-# This is required to run any git command in the docker since owner will
-# have changed between the clone environment, and the docker container.
-# Marking the root of the repo as safe for ownership changes.
-git config --global --add safe.directory "$PWD"
-
-echo $(date): Check formatting...
-./utils/check_code_format.sh ${1:-main}
-echo $(date): check completed.
@@ -1,5 +1,5 @@
 #!/bin/bash
-# Copyright (c) 2025 Google LLC
+# Copyright (c) 2018 Google LLC.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,16 +12,37 @@
 # 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.
+#
+# Android Build Script.

 # Fail on any error.
 set -e
+# Display commands being run.
+set -x

-SCRIPT_DIR="$( cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd )"
-SRC_ROOT="$( cd "${SCRIPT_DIR}/../.." >/dev/null 2>&1 && pwd )"
-TARGET_BRANCH="${KOKORO_GITHUB_PULL_REQUEST_TARGET_BRANCH-main}"
+BUILD_ROOT=$PWD
+SRC=$PWD/github/SPIRV-Tools

-docker run --rm -i \
-  --volume "${SRC_ROOT}:${SRC_ROOT}" \
-  --workdir "${SRC_ROOT}" \
-  "us-east4-docker.pkg.dev/shaderc-build/radial-docker/ubuntu-24.04-amd64/formatter" \
-  "${SCRIPT_DIR}/build-docker.sh" "${TARGET_BRANCH}"
+# This is required to run any git command in the docker since owner will
+# have changed between the clone environment, and the docker container.
+# Marking the root of the repo as safe for ownership changes.
+git config --global --add safe.directory $SRC
+
+# Get clang-format-5.0.0.
+# Once kokoro upgrades the Ubuntu VMs, we can use 'apt-get install clang-format'
+curl -L http://releases.llvm.org/5.0.0/clang+llvm-5.0.0-linux-x86_64-ubuntu14.04.tar.xz -o clang-llvm.tar.xz
+tar xf clang-llvm.tar.xz
+export PATH=$PWD/clang+llvm-5.0.0-linux-x86_64-ubuntu14.04/bin:$PATH
+
+cd $SRC
+git clone --depth=1 https://github.com/KhronosGroup/SPIRV-Headers external/spirv-headers
+git clone https://github.com/google/googletest          external/googletest
+cd external && cd googletest && git reset --hard 1fb1bb23bb8418dc73a5a9a82bbed31dc610fec7 && cd .. && cd ..
+git clone --depth=1 https://github.com/google/effcee              external/effcee
+git clone --depth=1 https://github.com/google/re2                 external/re2
+# The --fail flag causes the command to fail on HTTP error response codes, like 404.
+curl -L --fail https://raw.githubusercontent.com/llvm/llvm-project/main/clang/tools/clang-format/clang-format-diff.py -o utils/clang-format-diff.py
+
+echo $(date): Check formatting...
+./utils/check_code_format.sh;
+echo $(date): check completed.
@@ -52,7 +52,7 @@ docker run --rm -i \
  --env KOKORO_ARTIFACTS_DIR="${KOKORO_ARTIFACTS_DIR}" \
  --env BUILD_SHA="${BUILD_SHA}" \
  --entrypoint "${SCRIPT_DIR}/build-docker.sh" \
-  us-east4-docker.pkg.dev/shaderc-build/radial-docker/ubuntu-24.04-amd64/cpp-builder
+  "gcr.io/shaderc-build/radial-build:latest"
 RESULT=$?

 # This is important. If the permissions are not fixed, kokoro will fail
@@ -67,9 +67,7 @@ void CompactIds(std::vector<uint32_t>& ids) {
  ids.resize(write_index);
 }

-// A mapping from ids in one module to ids in the other.
-//
-// Differ contains two of these, for src->dst and dst->src.
+// A mapping between src and dst ids.
 class IdMap {
 public:
  IdMap(size_t id_bound) { id_map_.resize(id_bound, 0); }
@@ -192,7 +190,6 @@ class SrcDstIdMap {
  IdMap dst_to_src_;
 };

-// Mappings from ids to instructions and metadata, for a single module's ids.
 struct IdInstructions {
  IdInstructions(const opt::Module* module)
      : inst_map_(module->IdBound(), nullptr),
@@ -201,10 +198,6 @@ struct IdInstructions {
        forward_pointer_map_(module->IdBound()) {
    // Map ids from all sections to instructions that define them.
    MapIdsToInstruction(module->ext_inst_imports());
-    MapIdsToInstruction(module->debugs1());
-    MapIdsToInstruction(module->debugs2());
-    MapIdsToInstruction(module->debugs3());
-    MapIdsToInstruction(module->ext_inst_debuginfo());
    MapIdsToInstruction(module->types_values());
    for (const opt::Function& function : *module) {
      function.ForEachInst(
@@ -328,8 +321,6 @@ class Differ {
  // Get various properties from an id.  These Helper functions are passed to
  // `GroupIds` and `GroupIdsAndMatch` below (as the `get_group` argument).
  uint32_t GroupIdsHelperGetTypeId(const IdInstructions& id_to, uint32_t id);
-  uint32_t GroupIdsHelperGetFunctionTypeId(const IdInstructions& id_to,
-                                           uint32_t id);
  spv::StorageClass GroupIdsHelperGetTypePointerStorageClass(
      const IdInstructions& id_to, uint32_t id);
  spv::Op GroupIdsHelperGetTypePointerTypeOp(const IdInstructions& id_to,
@@ -892,17 +883,6 @@ uint32_t Differ::GroupIdsHelperGetTypeId(const IdInstructions& id_to,
  return GetInst(id_to, id)->type_id();
 }

-// Return an `OpFunction` instruction's full `OpTypeFunction` type,
-// which includes parameter types.
-//
-// `GroupIdsHelperGetTypeId` applied to an `OpFunction` only gets the
-// function's return type, so this is a slightly more precise way to
-// match up functions by signature.
-uint32_t Differ::GroupIdsHelperGetFunctionTypeId(const IdInstructions& id_to,
-                                                 uint32_t id) {
-  return GetInst(id_to, id)->GetSingleWordOperand(3);
-}
-
 spv::StorageClass Differ::GroupIdsHelperGetTypePointerStorageClass(
    const IdInstructions& id_to, uint32_t id) {
  const opt::Instruction* inst = GetInst(id_to, id);
@@ -922,24 +902,6 @@ spv::Op Differ::GroupIdsHelperGetTypePointerTypeOp(const IdInstructions& id_to,
  return type_inst->opcode();
 }

-// Group unmatched ids in `ids` according to some characteristic,
-// determined by `get_group`.
-//
-// Using `get_group` to compute some sort of key for each id, set
-// `groups` to map each key to all the ids that have that key.
-//
-// For example, to group ids by name, pass `Differ::GetName` as
-// `get_group`. This will fill `groups` with a map from each name to
-// all the ids with that name.
-//
-// Under the assumption that we're trying to establish new pairings,
-// ids that are already paired are omitted from `groups`.
-//
-// The `is_src` parameter indicates whether `ids` are drawn from the
-// source module or the destination module.
-//
-// The template parameter `T` is the key type, like `std::string` or
-// `uint32_t`.
 template <typename T>
 void Differ::GroupIds(const IdGroup& ids, bool is_src,
                      std::map<T, IdGroup>* groups,
@@ -962,10 +924,6 @@ void Differ::GroupIds(const IdGroup& ids, bool is_src,
  }
 }

-// Group `src_ids` and `dst_ids` according to `get_group`, and then use
-// `match_group` to pair up ids in corresponding groups.
-//
-// Don't try to pair ids in groups whose key is `invalid_group_key`.
 template <typename T>
 void Differ::GroupIdsAndMatch(
    const IdGroup& src_ids, const IdGroup& dst_ids, T invalid_group_key,
@@ -2525,7 +2483,7 @@ void Differ::MatchFunctions() {

        // If there are multiple functions with the same name, group them by
        // type, and match only if the types match (and are unique).
-        GroupIdsAndMatchByMappedId(src_group, dst_group,
+        GroupIdsAndMatch<uint32_t>(src_group, dst_group, 0,
                                   &Differ::GroupIdsHelperGetTypeId,
                                   [this](const IdGroup& src_group_by_type_id,
                                          const IdGroup& dst_group_by_type_id) {
@@ -2568,19 +2526,9 @@ void Differ::MatchFunctions() {
                             dst_match_result, 0);
  }

-  // Best effort match functions with matching return and argument types.
-  GroupIdsAndMatchByMappedId(
-      src_func_ids, dst_func_ids, &Differ::GroupIdsHelperGetFunctionTypeId,
-      [this](const IdGroup& src_group_by_func_type_id,
-             const IdGroup& dst_group_by_func_type_id) {
-        BestEffortMatchFunctions(src_group_by_func_type_id,
-                                 dst_group_by_func_type_id, src_func_insts_,
-                                 dst_func_insts_);
-      });
-
-  // Best effort match functions with matching return types.
-  GroupIdsAndMatchByMappedId(
-      src_func_ids, dst_func_ids, &Differ::GroupIdsHelperGetTypeId,
+  // Best effort match functions with matching type.
+  GroupIdsAndMatch<uint32_t>(
+      src_func_ids, dst_func_ids, 0, &Differ::GroupIdsHelperGetTypeId,
      [this](const IdGroup& src_group_by_type_id,
             const IdGroup& dst_group_by_type_id) {
        BestEffortMatchFunctions(src_group_by_type_id, dst_group_by_type_id,
@@ -676,10 +676,8 @@ spv_result_t RemoveLinkageSpecificInstructions(
      if (inst->opcode() == spv::Op::OpDecorate &&
          spv::Decoration(inst->GetSingleWordOperand(1u)) ==
              spv::Decoration::LinkageAttributes &&
-          (spv::LinkageType(inst->GetSingleWordOperand(3u)) ==
-               spv::LinkageType::Export ||
-           spv::LinkageType(inst->GetSingleWordOperand(3u)) ==
-               spv::LinkageType::LinkOnceODR)) {
+          spv::LinkageType(inst->GetSingleWordOperand(3u)) ==
+              spv::LinkageType::Export) {
        linked_context->KillInst(&*inst);
      }
    }
@@ -109,13 +109,11 @@ set(SPIRV_TOOLS_OPT_SOURCES
  remove_unused_interface_variables_pass.h
  replace_desc_array_access_using_var_index.h
  replace_invalid_opc.h
-  resolve_binding_conflicts_pass.h
  scalar_analysis.h
  scalar_analysis_nodes.h
  scalar_replacement_pass.h
  set_spec_constant_default_value_pass.h
  simplification_pass.h
-  split_combined_image_sampler_pass.h
  spread_volatile_semantics.h
  ssa_rewrite_pass.h
  strength_reduction_pass.h
@@ -227,13 +225,11 @@ set(SPIRV_TOOLS_OPT_SOURCES
  remove_unused_interface_variables_pass.cpp
  replace_desc_array_access_using_var_index.cpp
  replace_invalid_opc.cpp
-  resolve_binding_conflicts_pass.cpp
  scalar_analysis.cpp
  scalar_analysis_simplification.cpp
  scalar_replacement_pass.cpp
  set_spec_constant_default_value_pass.cpp
  simplification_pass.cpp
-  split_combined_image_sampler_pass.cpp
  spread_volatile_semantics.cpp
  ssa_rewrite_pass.cpp
  strength_reduction_pass.cpp
--- a/Show More
+++ b/Show More