Fix Android build.

NEW_RELEASE_NOTES.md

@@ -6,3 +6,5 @@
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).
 
 ## Release notes for next branch cut
+
+- engine: add `View::getLastDynamicResolutionScale()` (b/457753622)

README.md

@@ -31,7 +31,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.68.1'
+    implementation 'com.google.android.filament:filament-android:1.67.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.68.1'
+pod 'Filament', '~> 1.67.0'
 ```
 
 ## Documentation

RELEASE_NOTES.md

@@ -7,15 +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.68.1
-
-
-## v1.68.0
-
-- engine: add `View::getLastDynamicResolutionScale()` (b/457753622)
-- Metal: report GPU errors to the platform via `debugUpdateStat` (b/431665753).
-- materials: Make Material Instances' UBO descriptor use dynamic offsets. [⚠️ **Recompile Materials**]
-
 ## v1.67.1
 
 - Metal: Add support for the `SwapChain::CONFIG_MSAA_4_SAMPLES` flag.

android/filament-utils-android/src/main/java/com/google/android/filament/utils/ModelViewer.kt

@@ -16,9 +16,6 @@
 
 package com.google.android.filament.utils
 
-import android.graphics.Bitmap
-import android.os.Handler
-import android.os.Looper
 import android.view.MotionEvent
 import android.view.Surface
 import android.view.SurfaceView
@@ -29,7 +26,6 @@ import com.google.android.filament.android.UiHelper
 import com.google.android.filament.gltfio.*
 import kotlinx.coroutines.*
 import java.nio.Buffer
-import java.nio.ByteBuffer
 
 private const val kNearPlane = 0.05f     // 5 cm
 private const val kFarPlane = 1000.0f    // 1 km
@@ -123,8 +119,6 @@ class ModelViewer(
     private val target = DoubleArray(3)
     private val upward = DoubleArray(3)
 
-    private var debugFrameCallback: ((Bitmap) -> Unit)? = null
-
     init {
         renderer = engine.createRenderer()
         scene = engine.createScene()
@@ -311,39 +305,10 @@ class ModelViewer(
         // Render the scene, unless the renderer wants to skip the frame.
         if (renderer.beginFrame(swapChain!!, frameTimeNanos)) {
             renderer.render(view)
-
-            debugFrameCallback?.let {
-                val viewport = view.viewport
-                val bitmap = Bitmap.createBitmap(viewport.width, viewport.height,
-                        Bitmap.Config.ARGB_8888)
-                val buffer = ByteBuffer.allocateDirect(viewport.width * viewport.height * 4)
-
-                val handler = Handler(Looper.getMainLooper())
-                val pixelBufferDescriptor = Texture.PixelBufferDescriptor(buffer,
-                        Texture.Format.RGBA, Texture.Type.UBYTE, 1, 0, 0, 0, handler) {
-                    buffer.rewind()
-                    bitmap.copyPixelsFromBuffer(buffer)
-                    it(bitmap)
-                }
-                renderer.readPixels(viewport.left, viewport.bottom, viewport.width,
-                                    viewport.height, pixelBufferDescriptor)
-                debugFrameCallback = null
-            }
-
             renderer.endFrame()
         }
     }
 
-    /*
-     * Sets a callback that will be invoked with the next rendered frame as a Bitmap. Note that this
-     * is a one-time callback.
-     *
-     *  @param callback   callback to be invoked with a rendered frame as [Bitmap]
-     */
-    fun debugGetNextFrameCallback(callback: (Bitmap) -> Unit) {
-        debugFrameCallback = callback
-    }
-
     private fun populateScene(asset: FilamentAsset) {
         val rcm = engine.renderableManager
         var count = 0

android/filament-utils-android/src/main/java/com/google/android/filament/utils/Utils.kt

@@ -22,7 +22,6 @@ object Utils {
     /**
      * Initializes the utils JNI layer. Must be called before using any utils functionality.
      */
-    @JvmStatic
     fun init() {
         // Load Filament first to ensure that the NioUtils Java class is available in the JNIEnv.
         Filament.init()

android/gradle.properties

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

android/samples/sample-gltf-viewer/build.gradle

@@ -17,20 +17,12 @@ filamentTools {
 }
 
 // don't forget to update MainACtivity.kt when/if changing this.
-tasks.register('copyDamagedHelmetGltf', Copy) {
-    from file("../../../third_party/models/DamagedHelmet/DamagedHelmet.glb")
-    into file("src/main/assets/models")
-    rename {String fileName -> "helmet.glb"}
-}
-
-// don't forget to update MainACtivity.kt when/if changing this.
-tasks.register('copyBusterGltf', Copy) {
+tasks.register('copyMesh', Copy) {
     from "../../../third_party/models/BusterDrone"
     into "src/main/assets/models"
 }
 
-preBuild.dependsOn copyDamagedHelmetGltf
-preBuild.dependsOn copyBusterGltf
+preBuild.dependsOn copyMesh
 
 clean.doFirst {
     delete "src/main/assets"

docs/dup/intro.html

@@ -181,7 +181,7 @@ important for <code>matc</code> (material compiler).</p>
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.67.1'
+    implementation 'com.google.android.filament:filament-android:1.66.2'
 }
 </code></pre>
 <p>Here are all the libraries available in the group <code>com.google.android.filament</code>:</p>
@@ -196,7 +196,7 @@ dependencies {
 </div>
 <h3 id="ios"><a class="header" href="#ios">iOS</a></h3>
 <p>iOS projects can use CocoaPods to install the latest release:</p>
-<pre><code class="language-shell">pod 'Filament', '~&gt; 1.67.1'
+<pre><code class="language-shell">pod 'Filament', '~&gt; 1.66.2'
 </code></pre>
 <h2 id="documentation"><a class="header" href="#documentation">Documentation</a></h2>
 <ul>

filament/backend/CMakeLists.txt

@@ -206,8 +206,6 @@ if (FILAMENT_SUPPORTS_VULKAN)
             src/vulkan/VulkanDriverFactory.h
             src/vulkan/VulkanExternalImageManager.cpp
             src/vulkan/VulkanExternalImageManager.h
-            src/vulkan/VulkanStreamedImageManager.cpp
-            src/vulkan/VulkanStreamedImageManager.h
             src/vulkan/VulkanFboCache.cpp
             src/vulkan/VulkanFboCache.h
             src/vulkan/VulkanHandles.cpp
@@ -216,6 +214,14 @@ if (FILAMENT_SUPPORTS_VULKAN)
             src/vulkan/VulkanMemory.h
             src/vulkan/VulkanPipelineCache.cpp
             src/vulkan/VulkanPipelineCache.h
+            src/vulkan/VulkanPipelineStateSerializer.cpp
+            src/vulkan/VulkanPipelineStateSerializer.h
+            src/vulkan/VulkanSamplerStateSerializer.h
+            src/vulkan/VulkanSamplerStateSerializer.cpp
+            src/vulkan/VulkanRenderPassStateSerializer.h
+            src/vulkan/VulkanRenderPassStateSerializer.cpp
+            src/vulkan/VulkanDescriptorSetLayoutSerializer.h
+            src/vulkan/VulkanDescriptorSetLayoutSerializer.cpp
             src/vulkan/VulkanPipelineLayoutCache.cpp
             src/vulkan/VulkanPipelineLayoutCache.h
             src/vulkan/VulkanQueryManager.cpp

filament/backend/include/backend/Platform.h

@@ -19,17 +19,13 @@
 #ifndef TNT_FILAMENT_BACKEND_PLATFORM_H
 #define TNT_FILAMENT_BACKEND_PLATFORM_H
 
-#include <utils/CString.h>
 #include <utils/compiler.h>
 #include <utils/Invocable.h>
-#include <utils/Mutex.h>
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <atomic>
-#include <memory>
-#include <mutex>
 
 namespace filament::backend {
 
@@ -74,9 +70,6 @@ public:
         ExternalImageHandle& operator=(ExternalImageHandle const& rhs) noexcept;
         ExternalImageHandle& operator=(ExternalImageHandle&& rhs) noexcept;
 
-        bool operator==(const ExternalImageHandle& rhs) const noexcept {
-            return mTarget == rhs.mTarget;
-        }
         explicit operator bool() const noexcept { return mTarget != nullptr; }
 
         ExternalImage* UTILS_NULLABLE get() noexcept { return mTarget; }
@@ -515,22 +508,13 @@ public:
     // --------------------------------------------------------------------------------------------
     // Debugging APIs
 
-    using DebugUpdateStatFunc = utils::Invocable<void(const char* UTILS_NONNULL key,
-            uint64_t intValue, utils::CString stringValue)>;
+    using DebugUpdateStatFunc = utils::Invocable<void(const char* UTILS_NONNULL key, uint64_t value)>;
 
     /**
      * Sets the callback function that the backend can use to update backend-specific statistics
      * to aid with debugging. This callback is guaranteed to be called on the Filament driver
      * thread.
      *
-     * The callback signature is (key, intValue, stringValue). Note that for any given call,
-     * only one of the value parameters (intValue or stringValue) will be meaningful, depending on
-     * the specific key.
-     *
-     * IMPORTANT_NOTE: because the callback is called on the driver thread, only quick, non-blocking
-     * work should be done inside it. Furthermore, no graphics API calls (such as GL calls) should
-     * be made, which could interfere with Filament's driver state.
-     *
      * @param debugUpdateStat   an Invocable that updates debug statistics
      */
     void setDebugUpdateStatFunc(DebugUpdateStatFunc&& debugUpdateStat) noexcept;
@@ -549,32 +533,15 @@ public:
      * This function is guaranteed to be called only on a single thread, the Filament driver
      * thread.
      *
-     * @param key           a null-terminated C-string with the key of the debug statistic
-     * @param intValue      the updated integer value of key (the string value passed to the
-     *                      callback will be empty)
+     * @param key          a null-terminated C-string with the key of the debug statistic
+     * @param value        the updated value of key
      */
-    void debugUpdateStat(const char* UTILS_NONNULL key, uint64_t intValue);
-
-    /**
-     * To track backend-specific statistics, the backend implementation can call the
-     * application-provided callback function debugUpdateStatFunc to associate or update a value
-     * with a given key. It is possible for this function to be called multiple times with the
-     * same key, in which case newer values should overwrite older values.
-     *
-     * This function is guaranteed to be called only on a single thread, the Filament driver
-     * thread.
-     *
-     * @param key           a null-terminated C-string with the key of the debug statistic
-     * @param stringValue   the updated string value of key (the integer value passed to the
-     *                      callback will be 0)
-     */
-    void debugUpdateStat(const char* UTILS_NONNULL key, utils::CString stringValue);
+    void debugUpdateStat(const char* UTILS_NONNULL key, uint64_t value);
 
 private:
-    std::shared_ptr<InsertBlobFunc> mInsertBlob;
-    std::shared_ptr<RetrieveBlobFunc> mRetrieveBlob;
-    std::shared_ptr<DebugUpdateStatFunc> mDebugUpdateStat;
-    mutable utils::Mutex mMutex;
+    InsertBlobFunc mInsertBlob;
+    RetrieveBlobFunc mRetrieveBlob;
+    DebugUpdateStatFunc mDebugUpdateStat;
 };
 
 } // namespace filament

filament/backend/include/backend/platforms/PlatformEGLAndroid.h

@@ -17,6 +17,8 @@
 #ifndef TNT_FILAMENT_BACKEND_OPENGL_OPENGL_PLATFORM_EGL_ANDROID_H
 #define TNT_FILAMENT_BACKEND_OPENGL_OPENGL_PLATFORM_EGL_ANDROID_H
 
+#include "AndroidSwapChainHelper.h"
+#include "AndroidFrameCallback.h"
 #include "AndroidNdk.h"
 
 #include <backend/AcquiredImage.h>
@@ -30,6 +32,8 @@
 
 #include <math/mat3.h>
 
+#include "AndroidNativeWindow.h"
+
 #include <chrono>
 
 #include <stddef.h>
@@ -167,10 +171,19 @@ protected:
             SwapChain* drawSwapChain,
             SwapChain* readSwapChain) override;
 
-private:
-    struct SwapChainEGLAndroid;
-    struct AndroidDetails;
+    struct SwapChainEGLAndroid : public SwapChainEGL {
+        SwapChainEGLAndroid(PlatformEGLAndroid const& platform,
+                void* nativeWindow, uint64_t flags);
+        SwapChainEGLAndroid(PlatformEGLAndroid const& platform,
+                uint32_t width, uint32_t height, uint64_t flags);
+        void terminate(PlatformEGLAndroid& platform);
+        bool setPresentFrameId(uint64_t frameId) const noexcept;
+        uint64_t getFrameId(uint64_t frameId) const noexcept;
+    private:
+        AndroidSwapChainHelper mImpl{};
+    };
 
+private:
     // prevent derived classes' implementations to call through
     [[nodiscard]] SwapChain* createSwapChain(void* nativeWindow, uint64_t flags) override;
     [[nodiscard]] SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) override;
@@ -190,14 +203,17 @@ private:
 
     int mOSVersion;
     ExternalStreamManagerAndroid& mExternalStreamManager;
-    AndroidDetails& mAndroidDetails;
     InitializeJvmForPerformanceManagerIfNeeded const mInitializeJvmForPerformanceManagerIfNeeded;
     utils::PerformanceHintManager mPerformanceHintManager;
     utils::PerformanceHintManager::Session mPerformanceHintSession;
+    SwapChainEGLAndroid* mCurrentDrawSwapChain{};
+
     using clock = std::chrono::high_resolution_clock;
     clock::time_point mStartTimeOfActualWork;
-    SwapChainEGLAndroid* mCurrentDrawSwapChain{};
+    AndroidProducerThrottling mProducerThrottling;
     bool mAssertNativeWindowIsValid = false;
+
+    AndroidFrameCallback mAndroidFrameCallback;
 };
 
 } // namespace filament::backend

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

@@ -444,11 +444,6 @@ protected:
 
     virtual VkExternalFenceHandleTypeFlagBits getFenceExportFlags() const noexcept;
 
-    /**
-     * Query if transient attachments are supported by the backend.
-     */
-    bool isTransientAttachmentSupported() const noexcept;
-
 private:
     friend struct VulkanPlatformPrivate;
 };

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

@@ -17,13 +17,12 @@
 #ifndef TNT_FILAMENT_BACKEND_PLATFORMS_VULKAN_PLATFORM_ANDROID_H
 #define TNT_FILAMENT_BACKEND_PLATFORMS_VULKAN_PLATFORM_ANDROID_H
 
+#include "AndroidFrameCallback.h"
 #include "AndroidNdk.h"
 
 #include <backend/DriverEnums.h>
 #include <backend/platforms/VulkanPlatform.h>
 
-#include <utils/compiler.h>
-
 #include <android/hardware_buffer.h>
 
 namespace filament::backend {
@@ -92,8 +91,6 @@ protected:
     VkExternalFenceHandleTypeFlagBits getFenceExportFlags() const noexcept override;
 
 private:
-    struct AndroidDetails;
-
     struct ExternalImageVulkanAndroid : public ExternalImage {
         AHardwareBuffer* aHardwareBuffer = nullptr;
         bool sRGB = false;
@@ -102,7 +99,7 @@ private:
         ~ExternalImageVulkanAndroid() override;
     };
 
-    AndroidDetails& mAndroidDetails;
+    AndroidFrameCallback mAndroidFrameCallback;
     int mOSVersion{};
 };
 

filament/backend/src/AndroidNativeWindow.cpp

@@ -61,16 +61,6 @@ int NativeWindow::enableFrameTimestamps(ANativeWindow* anw, bool enable) {
     return pWindow->perform(anw, ENABLE_FRAME_TIMESTAMPS, enable);
 }
 
-int NativeWindow::frameTimestampsSupportsPresent(ANativeWindow* anw, bool* outSupportsPresent) {
-    NativeWindow const* pWindow = reinterpret_cast<NativeWindow const*>(anw);
-    int value = 0;
-    bool const success = pWindow->perform(anw, FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &value);
-    if (success) {
-        *outSupportsPresent = bool(value);
-    }
-    return success;
-}
-
 int NativeWindow::getCompositorTiming(ANativeWindow* anw,
         int64_t* compositeDeadline, int64_t* compositeInterval,
         int64_t* compositeToPresentLatency) {

filament/backend/src/AndroidNativeWindow.h

@@ -32,7 +32,6 @@ struct NativeWindow {
     // is valid query enum value
     enum {
         IS_VALID                = 17,
-        FRAME_TIMESTAMPS_SUPPORTS_PRESENT = 18,
         GET_NEXT_FRAME_ID       = 24,
         ENABLE_FRAME_TIMESTAMPS = 25,
         GET_COMPOSITOR_TIMING   = 26,
@@ -52,7 +51,6 @@ struct NativeWindow {
 
     static int getNextFrameId(ANativeWindow* anw, uint64_t* frameId);
     static int enableFrameTimestamps(ANativeWindow* anw, bool enable);
-    static int frameTimestampsSupportsPresent(ANativeWindow* anw, bool* outSupportsPresent);
     static int getCompositorTiming(ANativeWindow* anw,
             int64_t* compositeDeadline, int64_t* compositeInterval,
             int64_t* compositeToPresentLatency);

filament/backend/src/AndroidNdk.cpp

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include <backend/platforms/AndroidNdk.h>
+#include "AndroidNdk.h"
 
 #include <android/hardware_buffer.h>
 

filament/backend/src/AndroidSwapChainHelper.cpp

@@ -19,9 +19,6 @@
 
 #include <android/native_window.h>
 
-#include <utils/compiler.h>
-#include <utils/Logger.h>
-
 #include <cstddef>
 #include <cstdint>
 #include <limits>
@@ -39,23 +36,11 @@ bool AndroidSwapChainHelper::setPresentFrameId(
     int const status = NativeWindow::getNextFrameId(anw, &sysFrameId);
     if (status == 0) {
         std::lock_guard const lock(mLock);
-        // frameIds must be strictly monotonic, if that's not the case (i.e. the new frameId is
-        // less or equal to the last one in the map), we have to clear the map, because the
-        // map's find() assume sorted keys.
-        // This case can happen if two different filament::Renderer are used with the same
-        // ANativeWindow (the Renderer would have different frameIds). This is expected to
-        // be a rare case.
-        if (UTILS_UNLIKELY(!mFrameIdToSystemFrameId.empty() &&
-                frameId <= mFrameIdToSystemFrameId.back().first)) {
-            // this log is expected to happen very rarely
-            DLOG(INFO) << "clearing frame history anw=" << anw
-                    << ", frameId=" << frameId
-                    << ", previous=" << mFrameIdToSystemFrameId.back().first
-                    << ", sysFrameId=" << sysFrameId;
-            // clear the frame history
-            mFrameIdToSystemFrameId.clear();
+        auto const pos = mFrameIdToSystemFrameId.find(frameId);
+        if (pos && *pos != sysFrameId) {
+            // we're trying to associate the same frame id to a different frame!
+            return false;
         }
-
         // oldest entry is removed
         mFrameIdToSystemFrameId.insert(frameId, sysFrameId);
         return true;

filament/backend/src/Platform.cpp

@@ -139,73 +139,42 @@ bool Platform::queryFrameTimestamps(SwapChain const*, uint64_t, FrameTimestamps*
 }
 
 void Platform::setBlobFunc(InsertBlobFunc&& insertBlob, RetrieveBlobFunc&& retrieveBlob) noexcept {
-    std::lock_guard<decltype(mMutex)> lock(mMutex);
-    mInsertBlob = std::make_shared<InsertBlobFunc>(std::move(insertBlob));
-    mRetrieveBlob = std::make_shared<RetrieveBlobFunc>(std::move(retrieveBlob));
+    mInsertBlob = std::move(insertBlob);
+    mRetrieveBlob = std::move(retrieveBlob);
 }
 
 bool Platform::hasInsertBlobFunc() const noexcept {
-    std::lock_guard<decltype(mMutex)> lock(mMutex);
-    return mInsertBlob && bool(*mInsertBlob);
+    return bool(mInsertBlob);
 }
 
 bool Platform::hasRetrieveBlobFunc() const noexcept {
-    std::lock_guard<decltype(mMutex)> lock(mMutex);
-    return mRetrieveBlob && bool(*mRetrieveBlob);
+    return bool(mRetrieveBlob);
 }
 
 void Platform::insertBlob(void const* key, size_t keySize, void const* value, size_t valueSize) {
-    std::shared_ptr<InsertBlobFunc> callback;
-    {
-        std::unique_lock<decltype(mMutex)> lock(mMutex);
-        callback = mInsertBlob;
-    }
-    if (callback) {
-        (*callback)(key, keySize, value, valueSize);
+    if (mInsertBlob) {
+        mInsertBlob(key, keySize, value, valueSize);
     }
 }
 
 size_t Platform::retrieveBlob(void const* key, size_t keySize, void* value, size_t valueSize) {
-    std::shared_ptr<RetrieveBlobFunc> callback;
-    {
-        std::unique_lock<decltype(mMutex)> lock(mMutex);
-        callback = mRetrieveBlob;
-    }
-    if (callback) {
-        return (*callback)(key, keySize, value, valueSize);
+    if (mRetrieveBlob) {
+        return mRetrieveBlob(key, keySize, value, valueSize);
     }
     return 0;
 }
 
 void Platform::setDebugUpdateStatFunc(DebugUpdateStatFunc&& debugUpdateStat) noexcept {
-    std::lock_guard<decltype(mMutex)> lock(mMutex);
-    mDebugUpdateStat = std::make_shared<DebugUpdateStatFunc>(std::move(debugUpdateStat));
+    mDebugUpdateStat = std::move(debugUpdateStat);
 }
 
 bool Platform::hasDebugUpdateStatFunc() const noexcept {
-    std::lock_guard<decltype(mMutex)> lock(mMutex);
-    return mDebugUpdateStat && bool(*mDebugUpdateStat);
+    return bool(mDebugUpdateStat);
 }
 
-void Platform::debugUpdateStat(const char* key, uint64_t intValue) {
-    std::shared_ptr<DebugUpdateStatFunc> callback;
-    {
-        std::unique_lock<decltype(mMutex)> lock(mMutex);
-        callback = mDebugUpdateStat;
-    }
-    if (callback) {
-        (*callback)(key, intValue, "");
-    }
-}
-
-void Platform::debugUpdateStat(const char* key, utils::CString stringValue) {
-    std::shared_ptr<DebugUpdateStatFunc> callback;
-    {
-        std::unique_lock<decltype(mMutex)> lock(mMutex);
-        callback = mDebugUpdateStat;
-    }
-    if (callback) {
-        (*callback)(key, 0, stringValue);
+void Platform::debugUpdateStat(const char* key, uint64_t value) {
+    if (mDebugUpdateStat) {
+        mDebugUpdateStat(key, value);
     }
 }
 

filament/backend/src/metal/MetalBuffer.h

@@ -165,7 +165,7 @@ public:
          size_t size, bool forceGpuBuffer = false);
     ~MetalBuffer();
 
-    [[nodiscard]] bool wasAllocationSuccessful() const noexcept { return mBuffer; }
+    [[nodiscard]] bool wasAllocationSuccessful() const noexcept { return mBuffer || mCpuBuffer; }
 
     MetalBuffer(const MetalBuffer& rhs) = delete;
     MetalBuffer& operator=(const MetalBuffer& rhs) = delete;
@@ -185,12 +185,14 @@ public:
      * Denotes that this buffer is used for a draw call ensuring that its allocation remains valid
      * until the end of the current frame.
      *
-     * @return The MTLBuffer representing the current state of the buffer to bind, it never returns
-     * nil.
+     * @return The MTLBuffer representing the current state of the buffer to bind, or nil if there
+     * is no device allocation.
      *
      */
     id<MTLBuffer> getGpuBufferForDraw() noexcept;
 
+    void* getCpuBuffer() const noexcept { return mCpuBuffer; }
+
     void setLabel(const utils::ImmutableCString& label) {
 #if FILAMENT_METAL_DEBUG_LABELS
         if (label.empty()) {
@@ -233,6 +235,7 @@ private:
     UploadStrategy mUploadStrategy;
     TrackedMetalBuffer mBuffer;
     size_t mBufferSize = 0;
+    void* mCpuBuffer = nullptr;
     MetalContext& mContext;
 };
 

filament/backend/src/metal/MetalBuffer.mm

@@ -39,30 +39,34 @@ MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType,
         mUploadStrategy = UploadStrategy::POOL;
     }
 
-    MTLResourceOptions options = MTLResourceStorageModePrivate;
+    // If the buffer is less than 4K in size and is updated frequently, we don't use an explicit
+    // buffer. Instead, we use immediate command encoder methods like setVertexBytes:length:atIndex:.
+    // This won't work for SSBOs, since they are read/write.
 
-    // The buffer will be memory mapped for write operations.
-    if (any(usage & BufferUsage::SHARED_WRITE_BIT)) {
-#if defined(FILAMENT_IOS) || defined(__arm64__) || defined(__aarch64__)
-        // iOS and Apple Silicon devices use UMA (Unified Memory Architecture), so we use Shared memory.
-        options = MTLResourceStorageModeShared;
-#else
-        // Intel Macs require Managed memory for CPU/GPU synchronization.
-        options = MTLResourceStorageModeManaged;
-#endif
+    /*
+    if (size <= 4 * 1024 && bindingType != BufferObjectBinding::SHADER_STORAGE &&
+            usage == BufferUsage::DYNAMIC && !forceGpuBuffer) {
+        mBuffer = nil;
+        mCpuBuffer = malloc(size);
+        return;
     }
+    */
 
+    // Otherwise, we allocate a private GPU buffer.
     {
         ScopedAllocationTimer timer("generic");
-        mBuffer = { [context.device newBufferWithLength:size options:options],
+        mBuffer = { [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate],
             TrackedMetalBuffer::Type::GENERIC };
     }
-
     // mBuffer might fail to be allocated. Clients can check for this by calling
     // wasAllocationSuccessful().
 }
 
-MetalBuffer::~MetalBuffer() = default;
+MetalBuffer::~MetalBuffer() {
+    if (mCpuBuffer) {
+        free(mCpuBuffer);
+    }
+}
 
 void MetalBuffer::copyIntoBuffer(
         void* src, size_t size, size_t byteOffset, TagResolver&& getHandleTag) {
@@ -79,6 +83,12 @@ void MetalBuffer::copyIntoBuffer(
     FILAMENT_CHECK_PRECONDITION(!(byteOffset & 0x3))
             << "byteOffset must be a multiple of 4, tag=" << getHandleTag();
 
+    // If we have a cpu buffer, we can directly copy into it.
+    if (mCpuBuffer) {
+        memcpy(static_cast<uint8_t*>(mCpuBuffer) + byteOffset, src, size);
+        return;
+    }
+
     switch (mUploadStrategy) {
         case UploadStrategy::BUMP_ALLOCATOR:
             uploadWithBumpAllocator(src, size, byteOffset, std::move(getHandleTag));
@@ -96,6 +106,11 @@ void MetalBuffer::copyIntoBufferUnsynchronized(
 }
 
 id<MTLBuffer> MetalBuffer::getGpuBufferForDraw() noexcept {
+    // If there's a CPU buffer, then we return nil here, as the CPU-side buffer will be bound
+    // separately.
+    if (mCpuBuffer) {
+        return nil;
+    }
     assert_invariant(mBuffer);
     return mBuffer.get();
 }
@@ -156,6 +171,41 @@ void MetalBuffer::bindBuffers(id<MTLCommandBuffer> cmdBuffer, id<MTLCommandEncod
                                                    offsets:metalOffsets.data()
                                                  withRange:bufferRange];
     }
+
+    for (size_t b = 0; b < count; b++) {
+        MetalBuffer* const buffer = buffers[b];
+        if (!buffer) {
+            continue;
+        }
+
+        const void* cpuBuffer = buffer->getCpuBuffer();
+        if (!cpuBuffer) {
+            continue;
+        }
+
+        const size_t bufferIndex = bufferStart + b;
+        const size_t offset = offsets[b];
+        auto* bytes = static_cast<const uint8_t*>(cpuBuffer);
+
+        if (stages & Stage::VERTEX) {
+            [(id<MTLRenderCommandEncoder>) encoder setVertexBytes:(bytes + offset)
+                                                           length:(buffer->getSize() - offset)
+                                                          atIndex:bufferIndex];
+        }
+        if (stages & Stage::FRAGMENT) {
+            [(id<MTLRenderCommandEncoder>) encoder setFragmentBytes:(bytes + offset)
+                                                             length:(buffer->getSize() - offset)
+                                                            atIndex:bufferIndex];
+        }
+        if (stages & Stage::COMPUTE) {
+            // TODO: using setBytes means the data is read-only, which currently isn't enforced.
+            // In practice this won't be an issue since MetalBuffer ensures all SSBOs are realized
+            // through actual id<MTLBuffer> allocations.
+            [(id<MTLComputeCommandEncoder>) encoder setBytes:(bytes + offset)
+                                                      length:(buffer->getSize() - offset)
+                                                     atIndex:bufferIndex];
+        }
+    }
 }
 
 void MetalBuffer::uploadWithPoolBuffer(

filament/backend/src/metal/MetalContext.h

@@ -17,7 +17,6 @@
 #ifndef TNT_METALCONTEXT_H
 #define TNT_METALCONTEXT_H
 
-#include "MetalErrorQueue.h"
 #include "MetalResourceTracker.h"
 #include "MetalShaderCompiler.h"
 #include "MetalState.h"
@@ -130,7 +129,6 @@ struct MetalContext {
     id<MTLCommandBuffer> pendingCommandBuffer = nil;
     id<MTLRenderCommandEncoder> currentRenderPassEncoder = nil;
     uint32_t currentFrame = 0;
-    MetalErrorQueue commandBufferErrors;
 
     std::atomic<bool> memorylessLimitsReached = false;
 

filament/backend/src/metal/MetalContext.mm

@@ -153,7 +153,6 @@ id<MTLCommandBuffer> getPendingCommandBuffer(MetalContext* context) {
 
         if (UTILS_UNLIKELY(errorCode != MTLCommandBufferErrorNone)) {
             logMTLCommandBufferError(errorCode);
-            context->commandBufferErrors.push(buffer.error);
         }
     }];
     FILAMENT_CHECK_POSTCONDITION(context->pendingCommandBuffer)

filament/backend/src/metal/MetalDriver.h

@@ -61,8 +61,6 @@ public:
 
     MetalContext* getContext() { return mContext; }
 
-    using DriverBase::scheduleDestroy;
-
 private:
 
     friend class MetalSwapChain;

filament/backend/src/metal/MetalDriver.mm

@@ -254,18 +254,6 @@ MetalDriver::~MetalDriver() noexcept {
 void MetalDriver::tick(int) {
     executeTickOps();
     executeDeferredOps();
-
-    // Notify platform of GPU errors.
-    auto& platform = mPlatform;
-    if (UTILS_UNLIKELY(!mContext->commandBufferErrors.isEmpty())) {
-        mContext->commandBufferErrors.flush([&platform](NSError* error) {
-            if (UTILS_VERY_UNLIKELY(!error)) {
-                return;
-            }
-            const utils::CString errorString(error.localizedDescription.UTF8String);
-            platform.debugUpdateStat("filament.metal.command_buffer_error", errorString);
-        });
-    }
 }
 
 void MetalDriver::beginFrame(int64_t monotonic_clock_ns,
@@ -2275,10 +2263,7 @@ MemoryMappedBufferHandle MetalDriver::mapBufferS() noexcept {
 void MetalDriver::mapBufferR(MemoryMappedBufferHandle mmbh,
         BufferObjectHandle boh, size_t offset,
         size_t size, MapBufferAccessFlags access, utils::ImmutableCString&& tag) {
-    assert_invariant(boh);
-    MetalBufferObject* bo = mHandleAllocator.handle_cast<MetalBufferObject*>(boh);
-    assert_invariant(bo);
-    construct_handle<MetalMemoryMappedBuffer>(mmbh, bo, offset, size, access);
+    construct_handle<MetalMemoryMappedBuffer>(mmbh, boh, offset, size, access);
     mHandleAllocator.associateTagToHandle(mmbh.getId(), std::move(tag));
 }
 
@@ -2286,16 +2271,21 @@ void MetalDriver::unmapBuffer(MemoryMappedBufferHandle mmbh) {
     if (UTILS_UNLIKELY(!mmbh)) {
         return;
     }
-
-    auto* mmb = handle_cast<MetalMemoryMappedBuffer>(mmbh);
-    mmb->unmap();
     destruct_handle<MetalMemoryMappedBuffer>(mmbh);
 }
 
 void MetalDriver::copyToMemoryMappedBuffer(MemoryMappedBufferHandle mmbh, size_t offset,
         BufferDescriptor&& data) {
-    auto* mmb = handle_cast<MetalMemoryMappedBuffer>(mmbh);
-    mmb->copy(*this, offset, std::move(data));
+    auto mmb = handle_cast<MetalMemoryMappedBuffer>(mmbh);
+
+    assert_invariant(any(mmb->access & MapBufferAccessFlags::WRITE_BIT));
+    assert_invariant(offset + data.size <= mmb->size);
+
+    // TODO: this isa zero-effort implementation of copyToMemoryMappedBuffer(), where we just
+    //       call updateBufferObject(). This could be a fallback implementation for when
+    //       shared memory is not available.
+    //       On UMA systems, this should just be a memcpy into the memory-mapped buffer.
+    updateBufferObject(mmb->boh, std::move(data), mmb->offset + offset);
 }
 
 // explicit instantiation of the Dispatcher

filament/backend/src/metal/MetalErrorQueue.h

@@ -1,66 +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_DRIVER_METALERRORQUEUE_H
-#define TNT_FILAMENT_DRIVER_METALERRORQUEUE_H
-
-#import <Foundation/Foundation.h>
-
-#include <utils/compiler.h>
-
-#include <atomic>
-#include <functional>
-#include <mutex>
-#include <vector>
-
-class MetalErrorQueue {
-public:
-    bool isEmpty() const {
-        return !mHasErrors.load(std::memory_order_relaxed);
-    }
-
-    void push(NSError* error) {
-        std::lock_guard<std::mutex> lock(mMutex);
-        mErrors.push_back(error);
-        mHasErrors.store(true, std::memory_order_relaxed);
-    }
-
-    void flush(const std::function<void(NSError*)>& callback) {
-        if (UTILS_LIKELY(isEmpty())) {
-            return;
-        }
-        std::vector<NSError*> errors;
-        {
-            std::lock_guard<std::mutex> lock(mMutex);
-            std::swap(mErrors, errors);
-            mHasErrors.store(false, std::memory_order_relaxed);
-        }
-
-        for (const auto& error: errors) {
-            callback(error);
-        }
-    }
-
-private:
-    std::vector<NSError*> mErrors;
-    std::mutex mMutex;
-
-    // Optimization to avoid locking the mutex at each call to flush.
-    std::atomic<bool> mHasErrors;
-};
-
-
-#endif // TNT_FILAMENT_DRIVER_METALERRORQUEUE_H

filament/backend/src/metal/MetalHandles.h

@@ -569,22 +569,14 @@ struct MetalDescriptorSet : public HwDescriptorSet {
 
 
 struct MetalMemoryMappedBuffer : public HwMemoryMappedBuffer {
+    MetalMemoryMappedBuffer(BufferObjectHandle boh, size_t const offset,
+            size_t const size, MapBufferAccessFlags const access)
+        : boh(boh), access(access), size(size), offset(offset) {
+    }
+    BufferObjectHandle boh{};
     MapBufferAccessFlags access{};
-    struct {
-        MetalBufferObject* bo;
-        void* vaddr = nullptr;
-        uint32_t size = 0;
-        uint32_t offset = 0;
-    } mtl;
-
-    MetalMemoryMappedBuffer(MetalBufferObject* bo, size_t offset, size_t size,
-            MapBufferAccessFlags access) noexcept;
-
-    ~MetalMemoryMappedBuffer();
-
-    void unmap();
-
-    void copy(MetalDriver& mtld, size_t offset, BufferDescriptor&& data) const;
+    uint32_t size = 0;
+    uint32_t offset = 0;
 };
 
 } // namespace backend

filament/backend/src/metal/MetalHandles.mm

@@ -1664,44 +1664,5 @@ id<MTLBuffer> MetalDescriptorSet::finalizeAndGetBuffer(MetalDriver* driver, Shad
     return buffer.get();
 }
 
-MetalMemoryMappedBuffer::MetalMemoryMappedBuffer(MetalBufferObject* bo, size_t offset, size_t size,
-    MapBufferAccessFlags access) noexcept : access(access) {
-    MetalBuffer* buffer = bo->getBuffer();
-    assert_invariant(buffer);
-    id<MTLBuffer> mtlBuffer = buffer->getGpuBufferForDraw();
-
-    assert_invariant(offset + size <= bo->byteCount);
-    assert_invariant(mtlBuffer.storageMode != MTLStorageModePrivate);
-
-    mtl.bo = bo;
-    mtl.vaddr = static_cast<char*>(mtlBuffer.contents) + offset;
-    mtl.size = size;
-    mtl.offset = offset;
-}
-
-MetalMemoryMappedBuffer::~MetalMemoryMappedBuffer() = default;
-
-void MetalMemoryMappedBuffer::unmap() {
-#if !defined(FILAMENT_IOS) && defined(__x86_64__)
-    // Managed memory requires didModifyRange to synchronize changes to the GPU. This is specific to Intel Macs.
-    MetalBuffer* buffer = mtl.bo->getBuffer();
-    id<MTLBuffer> mtlBuffer = buffer->getGpuBufferForDraw();
-    if (mtlBuffer && mtlBuffer.storageMode == MTLStorageModeManaged) {
-        [mtlBuffer didModifyRange:NSMakeRange(mtl.offset, mtl.size)];
-    }
-#endif
-    // Shared memory on UMA systems is coherent; no explicit synchronization is required.
-}
-
-void MetalMemoryMappedBuffer::copy(MetalDriver& mtld, size_t offset, BufferDescriptor&& data) const {
-    assert_invariant(any(access & MapBufferAccessFlags::WRITE_BIT));
-    assert_invariant(offset + data.size <= mtl.size);
-    assert_invariant(mtl.vaddr);
-
-    memcpy(static_cast<char*>(mtl.vaddr) + offset, data.buffer, data.size);
-
-    mtld.scheduleDestroy(std::move(data));
-}
-
 } // namespace backend
 } // namespace filament

filament/backend/src/opengl/OpenGLContext.h

@@ -735,7 +735,7 @@ void OpenGLContext::bindVertexArray(RenderPrimitive const* p) noexcept {
         // - the nameVersion is out of date *and* we're on the protected context, in this case:
         //      - the name must be stale from a previous use of this context because we always
         //        destroy the protected context when we're done with it.
-        bool const recreateVaoName = vao != &mDefaultVAO &&
+        bool const recreateVaoName = p != &mDefaultVAO &&
                 ((vao->vao[contextIndex] == 0) ||
                         (vao->nameVersion != state.age && contextIndex == 1));
         if (UTILS_UNLIKELY(recreateVaoName)) {

filament/backend/src/opengl/platforms/PlatformEGLAndroid.cpp

@@ -28,13 +28,14 @@
 #include <private/backend/VirtualMachineEnv.h>
 
 #include "AndroidNativeWindow.h"
-#include "AndroidFrameCallback.h"
 #include "AndroidSwapChainHelper.h"
 #include "ExternalStreamManagerAndroid.h"
 
 #include <android/api-level.h>
 #include <android/native_window.h>
 #include <android/hardware_buffer.h>
+#include <android/choreographer.h>
+#include <android/looper.h>
 
 #include <utils/android/PerformanceHintManager.h>
 #include <utils/compiler.h>
@@ -98,27 +99,6 @@ using namespace glext;
 
 // ---------------------------------------------------------------------------------------------
 
-struct PlatformEGLAndroid::SwapChainEGLAndroid : public SwapChainEGL {
-    SwapChainEGLAndroid(PlatformEGLAndroid const& platform,
-            void* nativeWindow, uint64_t flags);
-    SwapChainEGLAndroid(PlatformEGLAndroid const& platform,
-            uint32_t width, uint32_t height, uint64_t flags);
-    void terminate(PlatformEGLAndroid& platform);
-    bool setPresentFrameId(uint64_t frameId) const noexcept;
-    uint64_t getFrameId(uint64_t frameId) const noexcept;
-    bool compositorTimingSupported = false;
-    bool frameTimestampsSupported = false;
-private:
-    AndroidSwapChainHelper mImpl{};
-};
-
-struct PlatformEGLAndroid::AndroidDetails {
-    AndroidProducerThrottling producerThrottling;
-    AndroidFrameCallback androidFrameCallback;
-};
-
-// ---------------------------------------------------------------------------------------------
-
 PlatformEGLAndroid::InitializeJvmForPerformanceManagerIfNeeded::InitializeJvmForPerformanceManagerIfNeeded() {
     // PerformanceHintManager() needs the calling thread to be a Java thread; so we need
     // to attach this thread to the JVM before we initialize PerformanceHintManager.
@@ -132,20 +112,17 @@ PlatformEGLAndroid::InitializeJvmForPerformanceManagerIfNeeded::InitializeJvmFor
 // ---------------------------------------------------------------------------------------------
 
 PlatformEGLAndroid::PlatformEGLAndroid() noexcept
-        : mExternalStreamManager(ExternalStreamManagerAndroid::create()),
-          mAndroidDetails(*(new(std::nothrow) AndroidDetails{})) {
+        : mExternalStreamManager(ExternalStreamManagerAndroid::create()) {
     mOSVersion = android_get_device_api_level();
     if (mOSVersion < 0) {
         mOSVersion = __ANDROID_API_FUTURE__;
     }
 }
 
-PlatformEGLAndroid::~PlatformEGLAndroid() noexcept {
-    delete &mAndroidDetails;
-}
+PlatformEGLAndroid::~PlatformEGLAndroid() noexcept = default;
 
 void PlatformEGLAndroid::terminate() noexcept {
-    mAndroidDetails.androidFrameCallback.terminate();
+    mAndroidFrameCallback.terminate();
     ExternalStreamManagerAndroid::destroy(&mExternalStreamManager);
     PlatformEGL::terminate();
 }
@@ -178,30 +155,20 @@ void PlatformEGLAndroid::beginFrame(
         int64_t const monotonic_clock_ns,
         int64_t refreshIntervalNs,
         uint32_t const frameId) noexcept {
-    // if frameId is 0, it means we're not associated to a particular frame, which is the case
-    // for standalone views. And in this case we skip the performance hint (since we wouldn't get
-    // the right timing anyway as well as the frame info timing collections)
+    // associate the user frameid with the system frame id
+    setPresentFrameId(mCurrentDrawSwapChain, frameId);
 
-    // associate the user frameid with the system frame id.
-    if (frameId && mCurrentDrawSwapChain) {
-        // mCurrentDrawSwapChain could be null if we're called from renderStandaloneView
-        setPresentFrameId(mCurrentDrawSwapChain, frameId);
-    }
-
-    if (frameId && mPerformanceHintSession.isValid()) {
+    if (mPerformanceHintSession.isValid()) {
         if (refreshIntervalNs <= 0) {
             // we're not provided with a target time, use the display period, if everything fails,
             // assume 16.67ms
             refreshIntervalNs = 16'666'667;
 
-            if (mCurrentDrawSwapChain) {
-                // mCurrentDrawSwapChain could be null if we're called from renderStandaloneView
-                CompositorTiming compositorTiming{};
-                bool const hasCompositorTiming =
-                        queryCompositorTiming(mCurrentDrawSwapChain, &compositorTiming);
-                if (hasCompositorTiming && compositorTiming.compositeInterval > 0) {
-                    refreshIntervalNs = compositorTiming.compositeInterval;
-                }
+            CompositorTiming compositorTiming{};
+            bool const hasCompositorTiming =
+                    queryCompositorTiming(mCurrentDrawSwapChain, &compositorTiming);
+            if (hasCompositorTiming && compositorTiming.compositeInterval > 0) {
+                refreshIntervalNs = compositorTiming.compositeInterval;
             }
         }
         mStartTimeOfActualWork = clock::time_point(std::chrono::nanoseconds(monotonic_clock_ns));
@@ -240,9 +207,9 @@ Driver* PlatformEGLAndroid::createDriver(void* sharedContext,
                     "eglGetNativeClientBufferANDROID"));
 
     if (ext.egl.ANDROID_presentation_time) {
-        eglPresentationTimeANDROID =
-                PFNEGLPRESENTATIONTIMEANDROIDPROC(eglGetProcAddress(
-                        "eglPresentationTimeANDROID"));
+        eglGetNativeClientBufferANDROID =
+                PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC(eglGetProcAddress(
+                        "eglGetNativeClientBufferANDROID"));
     }
 
     if (ext.egl.ANDROID_get_frame_timestamps) {
@@ -273,7 +240,7 @@ Driver* PlatformEGLAndroid::createDriver(void* sharedContext,
 
     mAssertNativeWindowIsValid = driverConfig.assertNativeWindowIsValid;
 
-    mAndroidDetails.androidFrameCallback.init();
+    mAndroidFrameCallback.init();
 
     return driver;
 }
@@ -297,25 +264,15 @@ bool PlatformEGLAndroid::queryCompositorTiming(SwapChain const* swapchain,
     }
 
     AndroidFrameCallback::Timeline const preferredTimeline{
-            mAndroidDetails.androidFrameCallback.getPreferredTimeline() };
+            mAndroidFrameCallback.getPreferredTimeline() };
     outCompositorTiming->frameTime = preferredTimeline.frameTime;
     outCompositorTiming->expectedPresentTime = preferredTimeline.expectedPresentTime;
     outCompositorTiming->frameTimelineDeadline = preferredTimeline.frameTimelineDeadline;
-    outCompositorTiming->compositeDeadline = CompositorTiming::INVALID;
-    outCompositorTiming->compositeInterval = CompositorTiming::INVALID;
-    outCompositorTiming->compositeToPresentLatency = CompositorTiming::INVALID;
-
-    // From this point on, we always return "success" because some timings were returned.
-
-    if (!static_cast<SwapChainEGLAndroid const *>(swapchain)->compositorTimingSupported) {
-        // if this surface doesn't support it, don't attempt to query the values.
-        return true;
-    }
 
     if (UTILS_LIKELY(ext.egl.ANDROID_get_frame_timestamps)) {
         EGLSurface const sur = static_cast<SwapChainEGL const *>(swapchain)->sur;
         if (sur == EGL_NO_SURFACE) {
-            return true;
+            return false;
         }
 
         std::array<EGLnsecsANDROID, 3> values;
@@ -326,16 +283,26 @@ bool PlatformEGLAndroid::queryCompositorTiming(SwapChain const* swapchain,
         };
         EGLBoolean const success = eglGetCompositorTimingANDROID(getEglDisplay(), sur,
                 names.size(), names.data(), values.data());
-        if (UTILS_UNLIKELY(!success)) {
-            // reset current error to EGL_SUCCESS
-            eglGetError();
-        } else {
-            outCompositorTiming->compositeDeadline = values[0];
-            outCompositorTiming->compositeInterval = values[1];
-            outCompositorTiming->compositeToPresentLatency = values[2];
+        if (!success) {
+            return false;
         }
+        outCompositorTiming->compositeDeadline = values[0];
+        outCompositorTiming->compositeInterval = values[1];
+        outCompositorTiming->compositeToPresentLatency = values[2];
+        return true;
     }
-    return true;
+
+    // fallback to private APIs
+    auto const anw = static_cast<SwapChainEGL const *>(swapchain)->nativeWindow;
+    int const status = NativeWindow::getCompositorTiming(anw,
+            &outCompositorTiming->compositeDeadline,
+            &outCompositorTiming->compositeInterval,
+            &outCompositorTiming->compositeToPresentLatency);
+    if (status == 0) {
+        return true;
+    }
+
+    return PlatformEGL::queryCompositorTiming(swapchain, outCompositorTiming);
 }
 
 bool PlatformEGLAndroid::setPresentFrameId(SwapChain const* swapchain,
@@ -360,10 +327,6 @@ bool PlatformEGLAndroid::queryFrameTimestamps(SwapChain const* swapchain, uint64
         return false;
     }
 
-    if (!static_cast<SwapChainEGLAndroid const *>(swapchain)->frameTimestampsSupported) {
-        return false;
-    }
-
     if (UTILS_LIKELY(ext.egl.ANDROID_get_frame_timestamps)) {
         EGLSurface const sur = sc->sur;
         if (sur == EGL_NO_SURFACE) {
@@ -384,9 +347,7 @@ bool PlatformEGLAndroid::queryFrameTimestamps(SwapChain const* swapchain, uint64
         };
         EGLBoolean const success = eglGetFrameTimestampsANDROID(getEglDisplay(), sur, hwFrameId,
                 names.size(), names.data(), values.data());
-        if (UTILS_UNLIKELY(!success)) {
-            // reset current error to EGL_SUCCESS
-            eglGetError();
+        if (!success) {
             return false;
         }
         outFrameTimestamps->requestedPresentTime = values[0];
@@ -400,44 +361,28 @@ bool PlatformEGLAndroid::queryFrameTimestamps(SwapChain const* swapchain, uint64
         outFrameTimestamps->releaseTime = values[8];
         return true;
     }
+
+    // fallback to private APIs
+    auto const anw = sc->nativeWindow;
+    int const status = NativeWindow::getFrameTimestamps(anw, hwFrameId,
+            &outFrameTimestamps->requestedPresentTime,
+            &outFrameTimestamps->acquireTime,
+            &outFrameTimestamps->latchTime,
+            &outFrameTimestamps->firstCompositionStartTime,
+            &outFrameTimestamps->lastCompositionStartTime,
+            &outFrameTimestamps->gpuCompositionDoneTime,
+            &outFrameTimestamps->displayPresentTime,
+            &outFrameTimestamps->dequeueReadyTime,
+            &outFrameTimestamps->releaseTime);
+    if (status == 0) {
+        return true;
+    }
+
     return PlatformEGL::queryFrameTimestamps(swapchain, frameId, outFrameTimestamps);
 }
 
 Platform::SwapChain* PlatformEGLAndroid::createSwapChain(void* nativeWindow, uint64_t const flags) {
     auto* const sc = new(std::nothrow) SwapChainEGLAndroid(*this, nativeWindow, flags);
-    if (UTILS_LIKELY(ext.egl.ANDROID_get_frame_timestamps)) {
-        EGLDisplay const dpy = getEglDisplay();
-        sc->compositorTimingSupported =
-                eglGetCompositorTimingSupportedANDROID(dpy, sc->sur,
-                        EGL_COMPOSITE_DEADLINE_ANDROID) &&
-                eglGetCompositorTimingSupportedANDROID(dpy, sc->sur,
-                        EGL_COMPOSITE_INTERVAL_ANDROID) &&
-                eglGetCompositorTimingSupportedANDROID(dpy, sc->sur,
-                        EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID);
-        sc->frameTimestampsSupported =
-                eglGetFrameTimestampSupportedANDROID(dpy, sc->sur,
-                        EGL_REQUESTED_PRESENT_TIME_ANDROID) &&
-                eglGetFrameTimestampSupportedANDROID(dpy, sc->sur,
-                        EGL_RENDERING_COMPLETE_TIME_ANDROID) &&
-                eglGetFrameTimestampSupportedANDROID(dpy, sc->sur,
-                        EGL_COMPOSITION_LATCH_TIME_ANDROID) &&
-                eglGetFrameTimestampSupportedANDROID(dpy, sc->sur,
-                        EGL_FIRST_COMPOSITION_START_TIME_ANDROID) &&
-                eglGetFrameTimestampSupportedANDROID(dpy, sc->sur,
-                        EGL_LAST_COMPOSITION_START_TIME_ANDROID) &&
-                eglGetFrameTimestampSupportedANDROID(dpy, sc->sur,
-                        EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID) &&
-                eglGetFrameTimestampSupportedANDROID(dpy, sc->sur,
-                        EGL_DISPLAY_PRESENT_TIME_ANDROID) &&
-                eglGetFrameTimestampSupportedANDROID(dpy, sc->sur,
-                        EGL_DEQUEUE_READY_TIME_ANDROID) &&
-                eglGetFrameTimestampSupportedANDROID(dpy, sc->sur,
-                        EGL_READS_DONE_TIME_ANDROID);
-    }
-    // This is expected to be a low frequency log, only turned on in debug builds
-    DLOG(INFO) << "anw: " << nativeWindow
-            << ", compositorTimingSupported=" << sc->compositorTimingSupported
-            << ", frameTimestampsSupported=" << sc->frameTimestampsSupported;
     return sc;
 }
 
@@ -450,10 +395,6 @@ Platform::SwapChain* PlatformEGLAndroid::createSwapChain(
 void PlatformEGLAndroid::destroySwapChain(SwapChain* swapChain) noexcept {
     if (swapChain) {
         SwapChainEGLAndroid* const sc = static_cast<SwapChainEGLAndroid*>(swapChain);
-        if (mCurrentDrawSwapChain == sc) {
-            // don't keep a dangling pointer around
-            mCurrentDrawSwapChain = nullptr;
-        }
         sc->terminate(*this);
         delete sc;
     }
@@ -734,12 +675,12 @@ AcquiredImage PlatformEGLAndroid::transformAcquiredImage(AcquiredImage const sou
 
 
 bool PlatformEGLAndroid::isProducerThrottlingControlSupported() const {
-    return mAndroidDetails.producerThrottling.isSupported();
+    return mProducerThrottling.isSupported();
 }
 
 int32_t PlatformEGLAndroid::setProducerThrottlingEnabled(
     EGLNativeWindowType const nativeWindow, bool const enabled) const {
-    return mAndroidDetails.producerThrottling.setProducerThrottlingEnabled(nativeWindow, enabled);
+    return mProducerThrottling.setProducerThrottlingEnabled(nativeWindow, enabled);
 }
 
 // ---------------------------------------------------------------------------------------------
@@ -763,6 +704,8 @@ PlatformEGLAndroid::SwapChainEGLAndroid::SwapChainEGLAndroid(PlatformEGLAndroid
             // we ignore the result, it doesn't matter much if it fails
             eglSurfaceAttrib(platform.getEglDisplay(), sur, EGL_TIMESTAMPS_ANDROID, EGL_TRUE);
         }
+    } else {
+        NativeWindow::enableFrameTimestamps(EGLNativeWindowType(nativeWindow), true);
     }
 }
 

filament/backend/src/vulkan/VulkanConstants.h

@@ -214,10 +214,4 @@ constexpr static const int FVK_MAX_PIPELINE_AGE = FVK_MAX_COMMAND_BUFFERS;
 // destroying any unused pipeline object.
 static_assert(FVK_MAX_PIPELINE_AGE >= FVK_MAX_COMMAND_BUFFERS);
 
-// Indicates if the backend must be setup to allow doing a RenderDoc capture.
-//
-// If this is true, the features not supported by RenderDoc must be disabled, otherwise
-// when using RenderDoc the application will crash or will fail to do a capture.
-constexpr static const int FVK_RENDERDOC_CAPTURE_MODE = false;
-
 #endif

filament/backend/src/vulkan/VulkanContext.h

@@ -154,10 +154,6 @@ public:
         return mStagingBufferBypassEnabled;
     }
 
-    inline bool pipelineCreationFeedbackSupported() const noexcept {
-        return mPipelineCreationFeedbackSupported;
-    }
-
 private:
     VkPhysicalDeviceMemoryProperties mMemoryProperties = {};
     VkPhysicalDeviceProperties2 mPhysicalDeviceProperties = {
@@ -185,7 +181,6 @@ private:
     bool mProtectedMemorySupported = false;
     bool mIsUnifiedMemoryArchitecture = false;
     bool mStagingBufferBypassEnabled = false;
-    bool mPipelineCreationFeedbackSupported = false;
 
     fvkutils::VkFormatList mDepthStencilFormats;
     fvkutils::VkFormatList mBlittableDepthStencilFormats;

filament/backend/src/vulkan/VulkanDescriptorSetCache.cpp

@@ -19,7 +19,6 @@
 #include "VulkanCommands.h"
 #include "VulkanHandles.h"
 #include "VulkanConstants.h"
-#include "utils/compiler.h"
 
 #include <utils/FixedCapacityVector.h>
 #include <utils/Panic.h>
@@ -32,18 +31,6 @@ namespace filament::backend {
 
 namespace {
 
-using Bitmask = fvkutils::UniformBufferBitmask;
-static_assert(sizeof(Bitmask) * 8 == fvkutils::MAX_DESCRIPTOR_SET_BITMASK_BITS);
-
-Bitmask foldBitsInHalf(Bitmask bitset) {
-    Bitmask outBitset;
-    bitset.forEachSetBit([&](size_t index) {
-        constexpr size_t BITMASK_LOWER_BITS_LEN = sizeof(outBitset) * 4;
-        outBitset.set(index % BITMASK_LOWER_BITS_LEN);
-    });
-    return outBitset;
-}
-
 using DescriptorSetLayoutArray = VulkanDescriptorSetCache::DescriptorSetLayoutArray;
 using DescriptorCount = VulkanDescriptorSetCache::DescriptorCount;
 
@@ -317,7 +304,8 @@ void VulkanDescriptorSetCache::commit(VulkanCommandBuffer* commands,
         // This code actually binds the descriptor sets.
         auto set = updateSets[index];
         VkCommandBuffer const cmdbuffer = commands->buffer();
-        VkDescriptorSet const vkset = set->getVkSet();
+        VkDescriptorSet vkset = useExternalSamplers[index] ? set->getExternalSamplerVkSet() :
+            set->getVkSet();
         commands->acquire(set);
         vkCmdBindDescriptorSets(cmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, index,
                 1, &vkset, set->uniqueDynamicUboCount, set->getOffsets()->data());
@@ -353,39 +341,17 @@ void VulkanDescriptorSetCache::updateBuffer(fvkmemory::resource_ptr<VulkanDescri
         .pBufferInfo = &info,
     };
     vkUpdateDescriptorSets(mDevice, 1, &descriptorWrite, 0, nullptr);
+
+    if (auto externalSamplerSet = set->getExternalSamplerVkSet();
+            externalSamplerSet != VK_NULL_HANDLE) {
+        descriptorWrite.dstSet = externalSamplerSet;
+        vkUpdateDescriptorSets(mDevice, 1, &descriptorWrite, 0, nullptr);
+    }
     set->acquire(bufferObject);
 }
 
-void VulkanDescriptorSetCache::updateSampler(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
-        uint8_t binding, fvkmemory::resource_ptr<VulkanTexture> texture,
-        VkSampler sampler, VkDescriptorSetLayout externalSamplerLayout) noexcept {
-
-    // We have to update a bound set for two use cases
-    //   - streaming API (a changing feed of AHardwareBuffer)
-    //   - external samplers - potential changing of dataspace per-frame
-    if (UTILS_UNLIKELY(set->isBound())) {
-        auto layout = set->getLayout();
-        // Build a new descriptor set from the new layout
-        auto genLayout = externalSamplerLayout != VK_NULL_HANDLE ?
-                externalSamplerLayout : layout->getVkLayout();
-        VkDescriptorSet const newSet = getVkSet(layout->count, genLayout);
-        Bitmask const ubo = layout->bitmask.ubo | layout->bitmask.dynamicUbo;
-        Bitmask samplers = layout->bitmask.sampler;
-        samplers.unset(binding);
-
-        // Each bitmask denotes a binding index, and separated into two stages - vertex and buffer
-        // We fold the two stages into just the lower half of the bits to denote a combined set of
-        // bindings.
-        Bitmask const copyBindings = foldBitsInHalf(ubo | samplers);
-        VkDescriptorSet const srcSet = set->getVkSet();
-        copySet(srcSet, newSet, copyBindings);
-        set->addNewSet(newSet,
-                [this, layoutCount = layout->count, genLayout, newSet](VulkanDescriptorSet*) {
-                    this->manualRecycle(layoutCount, genLayout, newSet);
-                });
-    }
-
-    VkDescriptorSet const vkset = set->getVkSet();
+void VulkanDescriptorSetCache::updateSamplerImpl(VkDescriptorSet vkset, uint8_t binding,
+        fvkmemory::resource_ptr<VulkanTexture> texture, VkSampler sampler) noexcept {
     VkImageSubresourceRange range = texture->getPrimaryViewRange();
     VkImageViewType const expectedType = texture->getViewType();
     if (any(texture->usage & TextureUsage::DEPTH_ATTACHMENT) &&
@@ -410,6 +376,19 @@ void VulkanDescriptorSetCache::updateSampler(fvkmemory::resource_ptr<VulkanDescr
         .pImageInfo = &info,
     };
     vkUpdateDescriptorSets(mDevice, 1, &descriptorWrite, 0, nullptr);
+}
+
+void VulkanDescriptorSetCache::updateSampler(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
+        uint8_t binding, fvkmemory::resource_ptr<VulkanTexture> texture,
+        VkSampler sampler) noexcept {
+    updateSamplerImpl(set->getVkSet(), binding, texture, sampler);
+    set->acquire(texture);
+}
+
+void VulkanDescriptorSetCache::updateSamplerForExternalSamplerSet(
+        fvkmemory::resource_ptr<VulkanDescriptorSet> set, uint8_t binding,
+        fvkmemory::resource_ptr<VulkanTexture> texture) noexcept {
+    updateSamplerImpl(set->getExternalSamplerVkSet(), binding, texture, VK_NULL_HANDLE);
     set->acquire(texture);
 }
 
@@ -426,7 +405,7 @@ fvkmemory::resource_ptr<VulkanDescriptorSet> VulkanDescriptorSetCache::createSet
     auto const& count = layout->count;
     auto const vklayout = layout->getVkLayout();
     auto set = fvkmemory::resource_ptr<VulkanDescriptorSet>::make(
-            mResourceManager, handle, layout,
+            mResourceManager, handle, layout->bitmask.dynamicUbo, layout->count.dynamicUbo,
             [vkSet, count, vklayout, this](
                     VulkanDescriptorSet*) { this->manualRecycle(count, vklayout, vkSet); },
             vkSet);
@@ -449,22 +428,4 @@ void VulkanDescriptorSetCache::manualRecycle(VulkanDescriptorSetLayout::Count co
 
 void VulkanDescriptorSetCache::gc() { mStashedSets = {}; }
 
-void VulkanDescriptorSetCache::copySet(VkDescriptorSet srcSet, VkDescriptorSet dstSet,
-        fvkutils::SamplerBitmask bindings) const {
-    // TODO: fix the size for better memory management
-    std::vector<VkCopyDescriptorSet> copies;
-    bindings.forEachSetBit([&](size_t index) {
-        copies.push_back({
-            .sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET,
-            .srcSet = srcSet,
-            .srcBinding = (uint32_t) index,
-            .dstSet = dstSet,
-            .dstBinding = (uint32_t) index,
-            .descriptorCount = 1,
-        });
-    });
-    vkUpdateDescriptorSets(mDevice, 0, nullptr, copies.size(), copies.data());
-}
-
-
 } // namespace filament::backend

filament/backend/src/vulkan/VulkanDescriptorSetCache.h

@@ -55,8 +55,7 @@ public:
             VkDeviceSize size) noexcept;
 
     void updateSampler(fvkmemory::resource_ptr<VulkanDescriptorSet> set, uint8_t binding,
-            fvkmemory::resource_ptr<VulkanTexture> texture, VkSampler sampler,
-            VkDescriptorSetLayout externalSamplerLayout = VK_NULL_HANDLE) noexcept;
+            fvkmemory::resource_ptr<VulkanTexture> texture, VkSampler sampler) noexcept;
 
     void updateSamplerForExternalSamplerSet(fvkmemory::resource_ptr<VulkanDescriptorSet> set, uint8_t binding,
             fvkmemory::resource_ptr<VulkanTexture> texture) noexcept;
@@ -91,8 +90,8 @@ public:
     void resetCachedState() noexcept { mLastBoundInfo = {}; }
 
 private:
-    void copySet(VkDescriptorSet srcSet, VkDescriptorSet destSet,
-            fvkutils::SamplerBitmask copyBindings) const;
+    void updateSamplerImpl(VkDescriptorSet set, uint8_t binding,
+            fvkmemory::resource_ptr<VulkanTexture> texture, VkSampler sampler) noexcept;
 
     class DescriptorInfinitePool;
 

filament/backend/src/vulkan/VulkanDescriptorSetLayoutCache.cpp

@@ -15,6 +15,7 @@
  */
 
 #include "VulkanDescriptorSetLayoutCache.h"
+#include "VulkanDescriptorSetLayoutSerializer.h"
 
 #include "VulkanHandles.h"
 
@@ -100,22 +101,32 @@ uint32_t appendSamplerBindings(VkDescriptorSetLayoutBinding* toBind,
     return count;
 }
 
-uint64_t computeImmutableSamplerHash(utils::FixedCapacityVector<VkSampler> const& samplers) {
+uint64_t computeImmutableSamplerHash(utils::FixedCapacityVector<VkSampler> const& samplers, VulkanSamplerCache* cache) {
     size_t const size = samplers.size();
     if (size == 0) {
         return 0;
-    } else if (size == 1) {
-        return (uint64_t) samplers[0];
     }
-    return utils::hash::murmur3((uint32_t*) samplers.data(), samplers.size() * 2, 0);
+
+    utils::FixedCapacityVector<uint32_t> samplerHash;
+    if (size > 0) {
+        samplerHash.reserve(MAX_SAMPLER_COUNT);
+        for (auto sampler : samplers) {
+            samplerHash.push_back(cache->getKey(sampler));
+        }
+    }
+
+    if (size == 1) {
+        return (uint64_t) samplerHash[0];
+    }
+    return utils::hash::murmur3((uint32_t*) samplerHash.data(), samplerHash.size() * 2, 0);
 }
 
 } // anonymous namespace
 
 VulkanDescriptorSetLayoutCache::VulkanDescriptorSetLayoutCache(VkDevice device,
-        fvkmemory::ResourceManager* resourceManager)
+        fvkmemory::ResourceManager* resourceManager, VulkanSamplerCache* cache)
     : mDevice(device),
-      mResourceManager(resourceManager) {}
+      mResourceManager(resourceManager), mSamplerCache(cache) {}
 
 VulkanDescriptorSetLayoutCache::~VulkanDescriptorSetLayoutCache() = default;
 
@@ -131,7 +142,7 @@ VkDescriptorSetLayout VulkanDescriptorSetLayoutCache::getVkLayout(
         utils::FixedCapacityVector<VkSampler> immutableSamplers) {
     LayoutKey key = {
         .bitmask = bitmasks,
-        .immutableSamplerHash = computeImmutableSamplerHash(immutableSamplers),
+        .immutableSamplerHash = computeImmutableSamplerHash(immutableSamplers, mSamplerCache),
     };
     if (auto itr = mVkLayouts.find(key); itr != mVkLayouts.end()) {
         return itr->second;
@@ -153,9 +164,20 @@ VkDescriptorSetLayout VulkanDescriptorSetLayoutCache::getVkLayout(
         .bindingCount = count,
         .pBindings = toBind,
     };
+    LayoutKeyHashFn hashFunc;
+    uint32_t hashedKey = hashFunc(key);
+    utils::FixedCapacityVector<uint32_t> immutableSamplersHashes;
+    immutableSamplersHashes.reserve(MAX_SAMPLER_COUNT);
+    for (auto sampler: immutableSamplers) {
+        immutableSamplersHashes.push_back(mSamplerCache->getKey(sampler));
+    }
+    VulkanDescriptorSetLayoutSerializer setSer(dlinfo, immutableSamplersHashes, hashedKey);
+
     VkDescriptorSetLayout vklayout;
     vkCreateDescriptorSetLayout(mDevice, &dlinfo, VKALLOC, &vklayout);
     mVkLayouts[key] = vklayout;
+
+    mLayoutToKey[vklayout] = hashedKey;
     return vklayout;
 }
 

filament/backend/src/vulkan/VulkanDescriptorSetLayoutCache.h

@@ -19,6 +19,8 @@
 
 #include "VulkanHandles.h"
 
+#include "VulkanSamplerCache.h"
+
 #include "vulkan/memory/ResourcePointer.h"
 
 #include <backend/DriverEnums.h>
@@ -35,7 +37,8 @@ namespace filament::backend {
 
 class VulkanDescriptorSetLayoutCache {
 public:
-    VulkanDescriptorSetLayoutCache(VkDevice device, fvkmemory::ResourceManager* resourceManager);
+    VulkanDescriptorSetLayoutCache(VkDevice device, fvkmemory::ResourceManager* resourceManager,
+            VulkanSamplerCache* cache);
     ~VulkanDescriptorSetLayoutCache();
 
     void terminate() noexcept;
@@ -48,10 +51,19 @@ public:
     VkDescriptorSetLayout getVkLayout(VulkanDescriptorSetLayout::Bitmask const& bitmasks,
             fvkutils::SamplerBitmask externalSamplers,
             utils::FixedCapacityVector<VkSampler> immutableSamplers = {});
+    uint32_t getKey(VkDescriptorSetLayout layout) {
+        uint32_t key = 0;
+        auto iter = mLayoutToKey.find(layout);
+        if (iter != mLayoutToKey.end()) {
+            key = iter->second;
+        }
+        return key;
+    }
 
 private:
     VkDevice mDevice;
     fvkmemory::ResourceManager* mResourceManager;
+    VulkanSamplerCache* mSamplerCache;
 
     struct LayoutKey {
         // this describes the layout using bitset.
@@ -69,6 +81,7 @@ private:
     };
 
     tsl::robin_map<LayoutKey, VkDescriptorSetLayout, LayoutKeyHashFn, LayoutKeyEqual> mVkLayouts;
+    std::map<VkDescriptorSetLayout, uint32_t> mLayoutToKey;
 };
 
 } // namespace filament::backend

filament/backend/src/vulkan/VulkanDescriptorSetLayoutSerializer.cpp

@@ -0,0 +1,87 @@
+#include "VulkanDescriptorSetLayoutSerializer.h"
+#include <fstream>
+#include <sstream>
+#include <utils/Hash.h>
+
+namespace filament::backend {
+VulkanDescriptorSetLayoutSerializer::VulkanDescriptorSetLayoutSerializer(
+        const VkDescriptorSetLayoutCreateInfo& info,
+        utils::FixedCapacityVector<uint32_t> immutableSamplers, uint32_t hash) {
+    std::stringstream filename;
+    filename << "descriptor_set_layout_" << hash << ".json";
+
+    std::ofstream file(filename.str());
+    if (file.is_open()) {
+        std::stringstream buffer;
+        buffer << "[" << std::endl;
+        for (uint32_t i = 0; i < info.bindingCount; ++i) {
+            buffer << "{" << std::endl;
+            buffer << "\"binding\":" << info.pBindings[i].binding << "," << std::endl;
+            buffer << "\"descriptor_type\":" << info.pBindings[i].descriptorType << "," << std::endl;
+            buffer << "\"stage_flags\":" << info.pBindings[i].stageFlags;
+            if (immutableSamplers.size()) {
+                buffer << "," << std::endl;
+                buffer << "\"immutable_samplers\":[" << std::endl;
+                for (uint32_t i = 0; i < immutableSamplers.size(); ++i) {
+                    buffer << immutableSamplers[i];
+                    if (i < immutableSamplers.size() - 1) {
+                        buffer << ",";
+                    }
+                }
+                buffer << "]";
+            }
+            buffer << std::endl;
+            buffer << "}";
+            if (i < info.bindingCount - 1) {
+                buffer << ",";
+            }
+            buffer << std::endl;
+        }
+        buffer << "]" << std::endl;
+
+        file << buffer.str();
+    }
+    file.close();
+}
+
+VulkanPipelineLayoutSerializer::VulkanPipelineLayoutSerializer(
+        const VkPipelineLayoutCreateInfo& info, VulkanDescriptorSetLayoutCache* cache,
+        uint32_t hash) {
+    std::stringstream filename;
+    filename << "pipeline_layout_" << hash << ".json";
+    std::ofstream file(filename.str());
+    if (file.is_open()) {
+        std::stringstream buffer;
+        buffer << "{" << std::endl;
+        buffer << "\"flags\":" << info.flags << "," << std::endl;
+
+        buffer << "\"layouts\":[" << std::endl;
+        for (uint32_t i = 0; i < info.setLayoutCount; ++i) {
+            buffer << cache->getKey(info.pSetLayouts[i]);
+            if (i < info.setLayoutCount - 1) {
+                buffer << ",";
+            }
+        }
+        buffer << "]," << std::endl;
+
+        buffer << "\"push_constants\":[" << std::endl;
+        for (uint32_t i = 0; i < info.pushConstantRangeCount; ++i) {
+            buffer << "{" << std::endl;
+            buffer << "\"stage_flags\":" << info.pPushConstantRanges[i].stageFlags << "," << std::endl;
+            buffer << "\"offset\":" << info.pPushConstantRanges[i].offset << ","
+                   << std::endl;
+            buffer << "\"size\":" << info.pPushConstantRanges[i].size
+                   << std::endl;
+            buffer << "}" << std::endl;
+            if (i < info.pushConstantRangeCount - 1) {
+                buffer << ",";
+            }
+        }
+        buffer << "]" << std::endl;
+
+        buffer << "}" << std::endl;
+        file << buffer.str();
+    }
+    file.close();
+ }
+} // namespace filament::backend

filament/backend/src/vulkan/VulkanDescriptorSetLayoutSerializer.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2022 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_VULKANDESCRIPTORSETLAYOUTSERIALIZER_H
+#define TNT_FILAMENT_BACKEND_VULKANDESCRIPTORSETLAYOUTSERIALIZER_H
+
+#include "VulkanPipelineLayoutCache.h"
+#include "VulkanYcbcrConversionCache.h"
+#include <backend/DriverEnums.h>
+
+#include <bluevk/BlueVK.h>
+#include <iostream>
+#include <sstream>
+#include <vector>
+
+namespace filament::backend {
+
+class VulkanDescriptorSetLayoutSerializer {
+public:
+    VulkanDescriptorSetLayoutSerializer(VulkanDescriptorSetLayoutSerializer const&) = delete;
+    VulkanDescriptorSetLayoutSerializer& operator=(
+            VulkanDescriptorSetLayoutSerializer const&) = delete;
+
+    VulkanDescriptorSetLayoutSerializer(const VkDescriptorSetLayoutCreateInfo& info,
+            utils::FixedCapacityVector<uint32_t> immutableSamplers,
+            uint32_t hash);
+};
+
+class VulkanPipelineLayoutSerializer {
+public:
+    VulkanPipelineLayoutSerializer(VulkanPipelineLayoutSerializer const&) = delete;
+    VulkanPipelineLayoutSerializer& operator=(VulkanPipelineLayoutSerializer const&) = delete;
+
+    VulkanPipelineLayoutSerializer(const VkPipelineLayoutCreateInfo& layout,
+            VulkanDescriptorSetLayoutCache* cache, uint32_t hash);
+};
+
+} // namespace filament::backend
+
+#endif // TNT_FILAMENT_BACKEND_VULKANDESCRIPTORSETLAYOUTSERIALIZER_H

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -31,7 +31,6 @@
 #include "vulkan/memory/ResourcePointer.h"
 #include "vulkan/utils/Conversion.h"
 #include "vulkan/utils/Definitions.h"
-#include "vulkan/utils/Image.h"
 
 #include <backend/DriverEnums.h>
 #include <backend/platforms/VulkanPlatform.h>
@@ -150,31 +149,6 @@ static CallbackHandler::Callback syncCallbackWrapper = [](void* userData) {
     cbData->cb(cbData->sync, cbData->userData);
 };
 
-// This needs to be discussed because Vulkan has different default Matrix formats
-// right now this is following GL.
-static void copyMat3f(void* addr, size_t const offset, const math::mat3f& v) noexcept {
-    struct mat43 {
-        float v[3][4];
-    };
-
-    addr = static_cast<char*>(addr) + offset;
-    mat43& temp = *static_cast<mat43*>(addr);
-
-    temp.v[0][0] = v[0][0];
-    temp.v[0][1] = v[0][1];
-    temp.v[0][2] = v[0][2];
-
-    temp.v[1][0] = v[1][0];
-    temp.v[1][1] = v[1][1];
-    temp.v[1][2] = v[1][2];
-
-    temp.v[2][0] = v[2][0];
-    temp.v[2][1] = v[2][1];
-    temp.v[2][2] = v[2][2];
-
-    // don't store anything in temp.v[][3] because there could be uniforms packed there
-}
-
 }// anonymous namespace
 
 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
@@ -256,21 +230,20 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext& context,
       mCommands(mPlatform->getDevice(), mPlatform->getGraphicsQueue(),
               mPlatform->getGraphicsQueueFamilyIndex(), mPlatform->getProtectedGraphicsQueue(),
               mPlatform->getProtectedGraphicsQueueFamilyIndex(), mContext, &mSemaphoreManager),
-      mPipelineLayoutCache(mPlatform->getDevice()),
-      mPipelineCache(mPlatform->getDevice(), mContext),
+      mPipelineCache(mPlatform->getDevice()),
       mStagePool(mAllocator, &mResourceManager, &mCommands, &mContext.getPhysicalDeviceLimits()),
       mBufferCache(mContext, mResourceManager, mAllocator),
       mFramebufferCache(mPlatform->getDevice()),
       mYcbcrConversionCache(mPlatform->getDevice()),
-      mSamplerCache(mPlatform->getDevice()),
+      mSamplerCache(mPlatform->getDevice(), &mYcbcrConversionCache),
       mBlitter(mPlatform->getPhysicalDevice(), &mCommands),
       mReadPixels(mPlatform->getDevice()),
-      mDescriptorSetLayoutCache(mPlatform->getDevice(), &mResourceManager),
+      mDescriptorSetLayoutCache(mPlatform->getDevice(), &mResourceManager, &mSamplerCache),
+      mPipelineLayoutCache(mPlatform->getDevice(), &mDescriptorSetLayoutCache),
       mDescriptorSetCache(mPlatform->getDevice(), &mResourceManager),
       mQueryManager(mPlatform->getDevice()),
       mExternalImageManager(platform, &mSamplerCache, &mYcbcrConversionCache, &mDescriptorSetCache,
               &mDescriptorSetLayoutCache),
-      mStreamedImageManager(&mExternalImageManager),
       mIsSRGBSwapChainSupported(mPlatform->getCustomization().isSRGBSwapChainSupported),
       mIsMSAASwapChainSupported(false), // TODO: support MSAA swapchain
       mStereoscopicType(driverConfig.stereoscopicType) {
@@ -447,14 +420,12 @@ void VulkanDriver::beginFrame(int64_t monotonic_clock_ns,
         int64_t refreshIntervalNs, uint32_t frameId) {
     FVK_PROFILE_MARKER(PROFILE_NAME_BEGINFRAME);
 
-    // if frameId is 0, it means we're not associated to a particular frame, which is the case
-    // for standalone views. And in this case we skip the frame info timing collection.
-    if (frameId && mCurrentSwapChain) { // This should be guaranteed
+    if (mCurrentSwapChain) { // This should be guaranteed
         mPlatform->setPresentFrameId(mCurrentSwapChain->swapChain, frameId);
     }
 
     // Check if any command have finished and reset all its used resources. The resources
-    // won't be destroyed but their reference count will be decreased if the command is already
+    // wont be destroyed but their reference count will decreased if the command is already
     // completed.
     //
     // This will let us check if any VulkanBuffer is currently in flight or not.
@@ -508,9 +479,6 @@ void VulkanDriver::updateDescriptorSetTexture(
     if (UTILS_UNLIKELY(mExternalImageManager.isExternallySampledTexture(texture))) {
         mExternalImageManager.bindExternallySampledTexture(set, binding, texture, params);
         mAppState.hasBoundExternalImages = true;
-    } else if (bool(texture->getStream())) {
-        mStreamedImageManager.bindStreamedTexture(set, binding, texture, params);
-        mAppState.hasBoundExternalImages = true;
     } else {
         VulkanSamplerCache::Params cacheParams = {
             .sampler = params,
@@ -518,7 +486,6 @@ void VulkanDriver::updateDescriptorSetTexture(
         VkSampler const vksampler = mSamplerCache.getSampler(cacheParams);
         mDescriptorSetCache.updateSampler(set, binding, texture, vksampler);
         mExternalImageManager.clearTextureBinding(set, binding);
-        mStreamedImageManager.unbindStreamedTexture(set, binding);
     }
 }
 
@@ -954,6 +921,14 @@ void VulkanDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
         }
     }
 
+#if defined(__ANDROID__)
+    // on Android, disable producer throttling
+    if (mProducerThrottling.isSupported()) {
+        mProducerThrottling.setProducerThrottlingEnabled(
+                static_cast<ANativeWindow*>(nativeWindow), false);
+    }
+#endif
+
     auto swapChain = resource_ptr<VulkanSwapChain>::make(&mResourceManager, sch, mPlatform,
             mContext, &mResourceManager, mAllocator, &mCommands, mStagePool, nativeWindow, flags);
     swapChain.inc();
@@ -1141,12 +1116,6 @@ void VulkanDriver::destroySwapChain(Handle<HwSwapChain> sch) {
 }
 
 void VulkanDriver::destroyStream(Handle<HwStream> sh) {
-    FVK_SYSTRACE_SCOPE();
-    if (!sh) {
-        return;
-    }
-    auto stream = resource_ptr<VulkanStream>::cast(&mResourceManager, sh);
-    stream.dec();
 }
 
 void VulkanDriver::destroySync(Handle<HwSync> sh) {
@@ -1184,39 +1153,18 @@ void VulkanDriver::destroyDescriptorSet(Handle<HwDescriptorSet> dsh) {
 }
 
 Handle<HwStream> VulkanDriver::createStreamNative(void* nativeStream, utils::ImmutableCString tag) {
-    FILAMENT_CHECK_PRECONDITION(false) << "createStreamNative not supported in Vulkan.";
     return {};
 }
 
 Handle<HwStream> VulkanDriver::createStreamAcquired(utils::ImmutableCString tag) {
-    // @TODO This is still not thread-safe. We might have to revisit this question.
-    FVK_SYSTRACE_SCOPE();
-    auto handle = mResourceManager.allocHandle<VulkanStream>();
-    auto stream = resource_ptr<VulkanStream>::make(&mResourceManager, handle);
-    stream.inc();
-    return handle;
+    return {};
 }
 
 void VulkanDriver::setAcquiredImage(Handle<HwStream> sh, void* image, const math::mat3f& transform,
         CallbackHandler* handler, StreamCallback cb, void* userData) {
-    FVK_SYSTRACE_SCOPE();
-    auto stream = resource_ptr<VulkanStream>::cast(&mResourceManager, sh);
-    assert_invariant(stream->streamType == StreamType::ACQUIRED);
-    assert_invariant(image != nullptr);
-    // This covers the case where setAcquiredImage is called back to back (no updateStreams in between)
-    if (stream->previousNeedsRelease()) {
-        scheduleRelease(stream->takePrevious());
-    }
-    stream->acquire({ image, cb, userData, handler});
-    stream->setFrontEndTransform(transform);
-    mStreamsWithPendingAcquiredImage.push_back(stream);
 }
 
 void VulkanDriver::setStreamDimensions(Handle<HwStream> sh, uint32_t width, uint32_t height) {
-    FVK_SYSTRACE_SCOPE();
-    auto stream = resource_ptr<VulkanStream>::cast(&mResourceManager, sh);
-    stream->width = width;
-    stream->height = height;
 }
 
 int64_t VulkanDriver::getStreamTimestamp(Handle<HwStream> sh) {
@@ -1224,72 +1172,6 @@ int64_t VulkanDriver::getStreamTimestamp(Handle<HwStream> sh) {
 }
 
 void VulkanDriver::updateStreams(CommandStream* driver) {
-    FVK_SYSTRACE_SCOPE();
-    if (UTILS_UNLIKELY(!mStreamsWithPendingAcquiredImage.empty())) {
-        for (auto& stream: mStreamsWithPendingAcquiredImage) {
-            if (stream->previousNeedsRelease()) {
-                scheduleRelease(stream->takePrevious());
-            }
-
-            // This executes on the backend thread (updateStreams is synchonous which means it
-            // executes on the user thread) Note: stream is captured by copy which is fine, this is
-            // a copy of a resource_ptr<VulkanStream>. We only need it find the associated stream
-            // inside the mStreamedImageManager texture bindings
-            driver->queueCommand([this, stream, s = stream.get(),
-                                        image = stream->getAcquired().image,
-                                        transform = stream->getFrontEndTransform()]() {
-                auto texture = s->getTexture(image);
-                s->setBackendTransform(transform);
-                if (!texture) {
-                    auto externalImage = fvkutils::createExternalImageFromRaw(mPlatform, image, false);
-                    auto metadata = mPlatform->extractExternalImageMetadata(externalImage);
-                    auto imgData = mPlatform->createVkImageFromExternal(externalImage);
-
-                    assert_invariant(imgData.internal.valid() || imgData.external.valid());
-
-                    VkFormat vkformat = metadata.format;
-                    VkImage vkimage = VK_NULL_HANDLE;
-                    VkDeviceMemory memory = VK_NULL_HANDLE;
-                    if (imgData.internal.valid()) {
-                        metadata.externalFormat = 0;
-                        vkimage = imgData.internal.image;
-                        memory = imgData.internal.memory;
-                    } else {
-                        vkformat = VK_FORMAT_UNDEFINED;
-                        vkimage = imgData.external.image;
-                        memory = imgData.external.memory;
-                    }
-
-                    VkSamplerYcbcrConversion const conversion =
-                            mExternalImageManager.getVkSamplerYcbcrConversion(metadata);
-
-                    auto newTexture = resource_ptr<VulkanTexture>::construct(&mResourceManager,
-                            mContext, mPlatform->getDevice(), mAllocator, &mResourceManager,
-                            &mCommands, vkimage, memory, vkformat, conversion, metadata.samples,
-                            metadata.width, metadata.height, metadata.layers,
-                            metadata.filamentUsage, mStagePool);
-
-                    auto& commands = mCommands.get();
-                    // Unlike uploaded textures or swapchains, we need to explicit transition this
-                    // texture into the read layout.
-                    newTexture->transitionLayout(&commands, newTexture->getPrimaryViewRange(),
-                            VulkanLayout::FRAG_READ);
-
-                    if (imgData.external.valid()) {
-                        mExternalImageManager.addExternallySampledTexture(newTexture,
-                                externalImage);
-                        // Cache the AHB backed image. Acquires the image here.
-                        s->pushImage(image, newTexture);
-                    }
-
-                    texture = newTexture;
-                }
-
-                mStreamedImageManager.onStreamAcquireImage(texture, stream);
-            });
-        }
-        mStreamsWithPendingAcquiredImage.clear();
-    }
 }
 
 void VulkanDriver::destroyFence(Handle<HwFence> fh) {
@@ -1587,9 +1469,7 @@ void VulkanDriver::updateIndexBuffer(Handle<HwIndexBuffer> ibh, BufferDescriptor
 
 void VulkanDriver::registerBufferObjectStreams(Handle<HwBufferObject> boh,
         BufferObjectStreamDescriptor&& streams) {
-
-    auto bo = resource_ptr<VulkanBufferObject>::cast(&mResourceManager, boh);
-    mStreamUniformDescriptors[bo.get()] = std::move(streams);
+    // Noop
 }
 
 void VulkanDriver::updateBufferObject(Handle<HwBufferObject> boh, BufferDescriptor&& bd,
@@ -1598,34 +1478,6 @@ void VulkanDriver::updateBufferObject(Handle<HwBufferObject> boh, BufferDescript
 
     auto bo = resource_ptr<VulkanBufferObject>::cast(&mResourceManager, boh);
     commands.acquire(bo);
-
-    if (UTILS_UNLIKELY(!mStreamUniformDescriptors.empty())) {
-        auto streamDescriptors = mStreamUniformDescriptors.find(bo.get());
-        if (streamDescriptors != mStreamUniformDescriptors.end()) {
-            for (auto const& [offset, streamHandle, associationType]:
-                    streamDescriptors->second.mStreams) {
-                if (associationType == BufferObjectStreamAssociationType::TRANSFORM_MATRIX) {
-                    math::mat3f transform;
-                    if (streamHandle) {
-                        auto stream =
-                                resource_ptr<VulkanStream>::cast(&mResourceManager, streamHandle);
-                        if (stream->streamType == StreamType::NATIVE) {
-                            FILAMENT_CHECK_PRECONDITION(false)
-                                    << "Native Stream not supported in Vulkan.";
-                        } else {
-                            // Backend call since getStreamTransformMatrix is called from async
-                            // updateBufferObject.
-                            transform = stream->getBackEndTransform();
-                        }
-                    }
-
-                    copyMat3f(bd.buffer, offset, transform);
-                }
-            }
-            mStreamUniformDescriptors.erase(streamDescriptors);
-        }
-    }
-
     bo->loadFromCpu(commands, bd.buffer, byteOffset, bd.size);
 
     scheduleDestroy(std::move(bd));
@@ -1693,12 +1545,6 @@ TimerQueryResult VulkanDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint
 }
 
 void VulkanDriver::setExternalStream(Handle<HwTexture> th, Handle<HwStream> sh) {
-    FVK_SYSTRACE_SCOPE();
-    auto t = resource_ptr<VulkanTexture>::cast(&mResourceManager, th);
-    assert_invariant(t);
-    auto s = resource_ptr<VulkanStream>::cast(&mResourceManager, sh);
-    assert_invariant(s);
-    t->setStream(s);
 }
 
 void VulkanDriver::generateMipmaps(Handle<HwTexture> th) {
@@ -1820,7 +1666,7 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
     rpkey.subpassMask = uint8_t(params.subpassMask);
 
     VkRenderPass renderPass = mFramebufferCache.getRenderPass(rpkey);
-    mPipelineCache.bindRenderPass(renderPass, 0);
+    mPipelineCache.bindRenderPass(renderPass, mFramebufferCache.getRenderPassKey(renderPass), 0);
 
     // Create the VkFramebuffer or fetch it from cache.
     VulkanFboCache::FboKey fbkey = rt->getFboKey();
@@ -1939,6 +1785,7 @@ void VulkanDriver::nextSubpass(int) {
             VK_SUBPASS_CONTENTS_INLINE);
 
     mPipelineCache.bindRenderPass(mCurrentRenderPass.renderPass,
+            mFramebufferCache.getRenderPassKey(mCurrentRenderPass.renderPass),
             ++mCurrentRenderPass.currentSubpass);
 
     if (mCurrentRenderPass.params.subpassMask & 0x1) {
@@ -2314,7 +2161,8 @@ void VulkanDriver::bindPipelineImpl(PipelineState const& pipelineState,
     mPipelineState.pipelineLayout = pipelineLayout;
     mPipelineState.descriptorSetMask = descriptorSetMask;
 
-    mPipelineCache.bindLayout(pipelineLayout);
+    auto key = mPipelineLayoutCache.getKey(pipelineLayout);
+    mPipelineCache.bindLayout(pipelineLayout, key);
     mPipelineCache.bindPipeline(mCurrentRenderPass.commandBuffer);
 }
 

filament/backend/src/vulkan/VulkanDriver.h

@@ -34,14 +34,12 @@
 #include "vulkan/VulkanDescriptorSetCache.h"
 #include "vulkan/VulkanDescriptorSetLayoutCache.h"
 #include "vulkan/VulkanExternalImageManager.h"
-#include "vulkan/VulkanStreamedImageManager.h"
 #include "vulkan/VulkanPipelineLayoutCache.h"
 #include "vulkan/memory/ResourceManager.h"
 #include "vulkan/memory/ResourcePointer.h"
 #include "vulkan/utils/Definitions.h"
 
 #include "backend/DriverEnums.h"
-#include "backend/BufferObjectStreamDescriptor.h"
 
 #include "DriverBase.h"
 #include "private/backend/Driver.h"
@@ -50,6 +48,10 @@
 #include <utils/Allocator.h>
 #include <utils/compiler.h>
 
+#if defined(__ANDROID__)
+#include "AndroidNativeWindow.h"
+#endif
+
 namespace filament::backend {
 
 class VulkanPlatform;
@@ -146,7 +148,6 @@ private:
 
     VulkanSemaphoreManager mSemaphoreManager;
     VulkanCommands mCommands;
-    VulkanPipelineLayoutCache mPipelineLayoutCache;
     VulkanPipelineCache mPipelineCache;
     VulkanStagePool mStagePool;
     VulkanBufferCache mBufferCache;
@@ -156,15 +157,10 @@ private:
     VulkanBlitter mBlitter;
     VulkanReadPixels mReadPixels;
     VulkanDescriptorSetLayoutCache mDescriptorSetLayoutCache;
+    VulkanPipelineLayoutCache mPipelineLayoutCache;
     VulkanDescriptorSetCache mDescriptorSetCache;
     VulkanQueryManager mQueryManager;
     VulkanExternalImageManager mExternalImageManager;
-    VulkanStreamedImageManager mStreamedImageManager;
-
-    // Stream transforms
-    std::unordered_map<VulkanBufferObject*, BufferObjectStreamDescriptor> mStreamUniformDescriptors;
-    math::mat3f getStreamTransformMatrix(Handle<HwStream> sh);
-
 
     // This maps a VulkanSwapchain to a native swapchain. VulkanSwapchain should have a copy of the
     // Platform::Swapchain pointer, but queryFrameTimestamps() and queryCompositorTiming() are
@@ -210,10 +206,9 @@ private:
     bool const mIsSRGBSwapChainSupported;
     bool const mIsMSAASwapChainSupported;
     backend::StereoscopicType const mStereoscopicType;
-
-    // setAcquiredImage is a DECL_DRIVER_API_SYNCHRONOUS_N which means we don't necessarily have the
-    // data to process it at call time. So we store it and process it during updateStreams.
-    std::vector<resource_ptr<VulkanStream>> mStreamsWithPendingAcquiredImage;
+#if defined(__ANDROID__)
+    AndroidProducerThrottling mProducerThrottling;
+#endif
 };
 
 } // namespace filament::backend

filament/backend/src/vulkan/VulkanExternalImageManager.cpp

@@ -31,6 +31,9 @@ namespace filament::backend {
 
 namespace {
 
+using Bitmask = fvkutils::UniformBufferBitmask;
+static_assert(sizeof(Bitmask) * 8 == fvkutils::MAX_DESCRIPTOR_SET_BITMASK_BITS);
+
 template<typename T>
 void erasep(std::vector<T>& v, std::function<bool(T const&)> f) {
     auto newEnd = std::remove_if(v.begin(), v.end(), f);
@@ -47,6 +50,31 @@ ImageData& findImage(std::vector<ImageData>& images,
     return *itr;
 }
 
+void copySet(VkDevice device, VkDescriptorSet srcSet, VkDescriptorSet dstSet, Bitmask bindings) {
+    // TODO: fix the size for better memory management
+    std::vector<VkCopyDescriptorSet> copies;
+    bindings.forEachSetBit([&](size_t index) {
+        copies.push_back({
+            .sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET,
+            .srcSet = srcSet,
+            .srcBinding = (uint32_t) index,
+            .dstSet = dstSet,
+            .dstBinding = (uint32_t) index,
+            .descriptorCount = 1,
+        });
+    });
+    vkUpdateDescriptorSets(device, 0, nullptr, copies.size(), copies.data());
+}
+
+Bitmask foldBitsInHalf(Bitmask bitset) {
+    Bitmask outBitset;
+    bitset.forEachSetBit([&](size_t index) {
+        constexpr size_t BITMASK_LOWER_BITS_LEN = sizeof(outBitset) * 4;
+        outBitset.set(index % BITMASK_LOWER_BITS_LEN);
+    });
+    return outBitset;
+}
+
 }// namespace
 
 VulkanExternalImageManager::VulkanExternalImageManager(VulkanPlatform* platform,
@@ -113,9 +141,6 @@ void VulkanExternalImageManager::updateSetAndLayout(
             continue;
         }
         auto& imageData = findImage(mImages, bindingInfo.image);
-        // For non YUV images (some ext images are NOT ext FMT)
-        // getVkSamplerYcbcrConversion(metadata) will return NULL, and image->conversion will be
-        // null
         updateImage(&imageData);
 
         auto samplerParams = bindingInfo.samplerParams;
@@ -147,14 +172,38 @@ void VulkanExternalImageManager::updateSetAndLayout(
     std::for_each(samplerAndBindings.begin(), samplerAndBindings.end(),
             [&](auto const& b) { outSamplers.push_back(std::get<1>(b)); });
 
+    VkDescriptorSetLayout const oldLayout = layout->getExternalSamplerVkLayout();
     VkDescriptorSetLayout const newLayout = mDescriptorSetLayoutCache->getVkLayout(layout->bitmask,
             actualExternalSamplers, outSamplers);
-    layout->setExternalSamplerVkLayout(newLayout);
+
+    // Need to copy the set
+    VkDescriptorSet const oldSet = set->getExternalSamplerVkSet();
+    if (oldLayout != newLayout || oldSet == VK_NULL_HANDLE) {
+        // Build a new descriptor set from the new layout
+        VkDescriptorSet const newSet = mDescriptorSetCache->getVkSet(layout->count, newLayout);
+        auto const ubo = layout->bitmask.ubo | layout->bitmask.dynamicUbo;
+        auto const samplers = layout->bitmask.sampler & (~actualExternalSamplers);
+
+        // Each bitmask denotes a binding index, and separated into two stages - vertex and buffer
+        // We fold the two stages into just the lower half of the bits to denote a combined set of
+        // bindings.
+        Bitmask const copyBindings = foldBitsInHalf(ubo | samplers);
+        VkDescriptorSet const srcSet = oldSet != VK_NULL_HANDLE ? oldSet : set->getVkSet();
+        copySet(mPlatform->getDevice(), srcSet, newSet, copyBindings);
+
+        set->setExternalSamplerVkSet(newSet,
+                [&descriptorSetCache = mDescriptorSetCache, layoutCount = layout->count, newLayout,
+                        newSet](VulkanDescriptorSet*) {
+                    descriptorSetCache->manualRecycle(layoutCount, newLayout, newSet);
+                });
+        if (oldLayout != newLayout) {
+            layout->setExternalSamplerVkLayout(newLayout);
+        }
+    }
+
     // Update the external samplers in the set
     for (auto& [binding, sampler, image]: samplerAndBindings) {
-        // We cannot call updateSamplerForExternalSamplerSet because some samplers are non NULL
-        // (RGB) and we cannot do a combined update with a NULL sampler.
-        mDescriptorSetCache->updateSampler(set, binding, image, sampler, newLayout);
+        mDescriptorSetCache->updateSamplerForExternalSamplerSet(set, binding, image);
     }
 }
 
@@ -212,25 +261,13 @@ void VulkanExternalImageManager::bindExternallySampledTexture(
         fvkmemory::resource_ptr<VulkanTexture> image, SamplerParams samplerParams) {
     // Should we do duplicate validation here?
     auto& imageData = findImage(mImages, image);
-    auto itr = std::find_if(mSetBindings.begin(), mSetBindings.end(),
-            [&](SetBindingInfo const& binding) {
-                return (binding.set == set && binding.binding == bindingPoint);
-            });
-    if (itr == mSetBindings.end()) {
-        mSetBindings.push_back({ bindingPoint, imageData.image, set, samplerParams });
-    } else {
-        // override the image data in the binding point
-        itr->image = image;
-        itr->samplerParams = samplerParams;
-    }
+    mSetBindings.push_back({ bindingPoint, imageData.image, set, samplerParams });
 }
 
 void VulkanExternalImageManager::addExternallySampledTexture(
        fvkmemory::resource_ptr<VulkanTexture> image,
         Platform::ExternalImageHandleRef platformHandleRef) {
-    // By passing VK_NULL_HANDLE which is already there by default.
-    // We make it clear that all default images do NOT have a chroma conversion.
-    mImages.push_back({ image, platformHandleRef, false, VK_NULL_HANDLE });
+    mImages.push_back({ image, platformHandleRef, false });
 }
 
 void VulkanExternalImageManager::removeExternallySampledTexture(

filament/backend/src/vulkan/VulkanExternalImageManager.h

@@ -31,7 +31,7 @@ class VulkanSamplerCache;
 class VulkanDescriptorSetLayoutCache;
 class VulkanDescriptorSetCache;
 
-// Manages the logic of external images and their quirks wrt Vulkan.
+// Manages the logic of external images and their quirks wrt Vulikan.
 class VulkanExternalImageManager {
 public:
 

filament/backend/src/vulkan/VulkanFboCache.cpp

@@ -15,6 +15,7 @@
  */
 
 #include "VulkanFboCache.h"
+#include "VulkanRenderPassStateSerializer.h"
 
 #include "VulkanConstants.h"
 #include "vulkan/utils/Image.h"
@@ -69,6 +70,15 @@ VulkanFboCache::~VulkanFboCache() {
             << "Please explicitly call terminate() while the VkDevice is still alive.";
 }
 
+uint32_t VulkanFboCache::getRenderPassKey(VkRenderPass pass) noexcept {
+    uint32_t key = 0;
+    auto iter = mRenderPassToKey.find(pass);
+    if (iter != mRenderPassToKey.end()) {
+        key = iter->second;
+    }
+    return key;
+}
+
 VkFramebuffer VulkanFboCache::getFramebuffer(FboKey const& config) noexcept {
     FboMap::iterator iter = mFramebufferCache.find(config);
     if (UTILS_LIKELY(iter != mFramebufferCache.end() && iter->second.handle != VK_NULL_HANDLE)) {
@@ -117,6 +127,7 @@ VkFramebuffer VulkanFboCache::getFramebuffer(FboKey const& config) noexcept {
     VkResult error = vkCreateFramebuffer(mDevice, &info, VKALLOC, &framebuffer);
     FILAMENT_CHECK_POSTCONDITION(error == VK_SUCCESS) << "Unable to create framebuffer."
                                                      << " error=" << static_cast<int32_t>(error);
+
     mFramebufferCache[config] = {framebuffer, mCurrentTime};
     return framebuffer;
 }
@@ -326,6 +337,12 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey const& config) noexcept
     VkResult error = vkCreateRenderPass(mDevice, &renderPassInfo, VKALLOC, &renderPass);
     FILAMENT_CHECK_POSTCONDITION(error == VK_SUCCESS) << "Unable to create render pass."
                                                       << " error=" << error;
+
+    RenderPassHash hashFunc;
+    uint32_t key = hashFunc(config);
+    VulkanRenderPassStateSerializer passSer(renderPassInfo, key); 
+    mRenderPassToKey[renderPass] = key;
+
     mRenderPassCache[config] = {renderPass, mCurrentTime};
 
 #if FVK_ENABLED(FVK_DEBUG_FBO_CACHE)

filament/backend/src/vulkan/VulkanFboCache.h

@@ -24,6 +24,7 @@
 #include <backend/TargetBufferInfo.h>
 
 #include <tsl/robin_map.h>
+#include <map>
 
 namespace filament::backend {
 
@@ -97,6 +98,8 @@ public:
     explicit VulkanFboCache(VkDevice device);
     ~VulkanFboCache();
 
+    uint32_t getRenderPassKey(VkRenderPass pass) noexcept;
+
     // Retrieves or creates a VkFramebuffer handle.
     VkFramebuffer getFramebuffer(FboKey const& config) noexcept;
 
@@ -118,6 +121,7 @@ private:
     FboMap mFramebufferCache;
 
     tsl::robin_map<RenderPassKey, RenderPassVal, RenderPassHash, RenderPassEq> mRenderPassCache;
+    std::map<VkRenderPass, uint32_t> mRenderPassToKey;
     tsl::robin_map<VkRenderPass, uint32_t> mRenderPassRefCount;
     uint32_t mCurrentTime = 0;
 };

filament/backend/src/vulkan/VulkanHandles.cpp

@@ -33,6 +33,7 @@
 #include <utils/compiler.h> // UTILS_FALLTHROUGH
 #include <utils/Panic.h>    // ASSERT_POSTCONDITION
 #include <utils/CString.h>
+#include <fstream>
 
 using namespace bluevk;
 
@@ -40,11 +41,6 @@ namespace filament::backend {
 
 namespace {
 
-// We don't have a good estimate for this magic number. This is used to remove empty
-// slots from a descriptor set (a VulkanDescriptorset is backed by multiple
-// VkDescriptorSet.
-size_t DESCRIPTOR_SET_GC_LIMIT = 10;
-
 inline VulkanBufferBinding getBufferObjectBinding(BufferObjectBinding bindingType) noexcept {
     switch (bindingType) {
         case BufferObjectBinding::VERTEX:
@@ -184,6 +180,23 @@ VulkanAttachment createSwapchainAttachment(const fvkmemory::resource_ptr<VulkanT
     };
 }
 
+static inline uint64_t serializeShaderModule(utils::CString progName, VkShaderModuleCreateInfo info,
+        VkShaderStageFlagBits stage) {
+    std::stringstream filename;
+    filename << progName.c_str() << "_" << stage << "_";
+    constexpr uint32_t wordReadCount = 8;
+    uint64_t key = utils::hash::murmur3(info.pCode, wordReadCount, 0);
+    key |= uint64_t(utils::hash::murmur3(info.pCode + (wordReadCount / 2), wordReadCount, 0)) << 32;
+    filename << key << ".bin";
+
+    std::ofstream file(filename.str());
+    if (file.is_open()) {
+        file.write(reinterpret_cast<const char*>(info.pCode), info.codeSize);
+    }
+    file.close();
+    return key;
+}
+
 } // anonymous namespace
 
 VulkanDescriptorSetLayout::VulkanDescriptorSetLayout(DescriptorSetLayout&& layout,
@@ -197,70 +210,15 @@ VulkanDescriptorSetLayout::Bitmask VulkanDescriptorSetLayout::Bitmask::fromLayou
     return fromBackendLayout(layout);
 }
 
-VulkanDescriptorSet::~VulkanDescriptorSet() {
-    for (auto setBundle: mSets) {
-        if (setBundle.onRecycleFn) {
-            setBundle.onRecycleFn(this);
-        }
-    }
-}
-
-VulkanDescriptorSet::VulkanDescriptorSet(fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout,
-        OnRecycle&& onRecycleFn, VkDescriptorSet vkSet)
-    : dynamicUboMask(layout->bitmask.dynamicUbo),
-      uniqueDynamicUboCount(layout->count.dynamicUbo),
-      mLayout(layout),
-      mCurrentSetIndex(0) {
-    addNewSet(vkSet, std::move(onRecycleFn));
-}
-
+// This method will store an age associated with this command buffer into the VulkanBuffer, which
+// will allow us to determine whether a barrier is necessary or not.
 void VulkanDescriptorSet::referencedBy(VulkanCommandBuffer& commands) {
-    // This will store an age associated with this command buffer into the VulkanBuffer, which
-    // will allow us to determine whether a barrier is necessary or not.
     mUboMask.forEachSetBit([this, &commands](size_t index) {
         auto& res = mResources[index];
         fvkmemory::resource_ptr<VulkanBufferObject> bo =
                 fvkmemory::resource_ptr<VulkanBufferObject>::cast((VulkanBufferObject*) res.get());
         bo->referencedBy(commands);
     });
-    mSets[mCurrentSetIndex].fenceStatus = commands.getFenceStatus();
-}
-
-void VulkanDescriptorSet::gc() {
-    size_t empty = 0;
-    for (auto& setBundle: mSets) {
-        assert_invariant(setBundle.onRecycleFn);
-        if (setBundle.vkSet == VK_NULL_HANDLE) {
-            empty++;
-            continue;
-        }
-        if (setBundle.fenceStatus && setBundle.fenceStatus->getStatus() == VK_SUCCESS) {
-            setBundle.onRecycleFn(this);
-            setBundle.vkSet = VK_NULL_HANDLE;
-            setBundle.fenceStatus = {};
-            empty++;
-        }
-    }
-
-    if (empty > DESCRIPTOR_SET_GC_LIMIT) {
-        std::vector<InternalVkSet> retainedSets;
-        for (auto& setBundle: mSets) {
-            if (setBundle.vkSet != VK_NULL_HANDLE) {
-                retainedSets.push_back({
-                    setBundle.vkSet,
-                    std::move(setBundle.onRecycleFn),
-                    std::move(setBundle.fenceStatus)
-                });
-            }
-        }
-        std::swap(mSets, retainedSets);
-    }
-}
-
-void VulkanDescriptorSet::addNewSet(VkDescriptorSet vkSet, OnRecycle&& onRecycleFn) {
-    gc();
-    mCurrentSetIndex = mSets.size();
-    mSets.push_back({ vkSet, std::move(onRecycleFn) });
 }
 
 PushConstantDescription::PushConstantDescription(backend::Program const& program) {
@@ -340,6 +298,12 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
             .codeSize = dataSize,
             .pCode = data,
         };
+        if (i == 0) {
+            mVertexShaderHash = serializeShaderModule(name, moduleInfo, VK_SHADER_STAGE_VERTEX_BIT);
+        } else if (i == 1) {
+            mFragmentShaderHash =
+                    serializeShaderModule(name, moduleInfo, VK_SHADER_STAGE_FRAGMENT_BIT);
+        }
         VkResult result = vkCreateShaderModule(mDevice, &moduleInfo, VKALLOC, &module);
         FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
                 << "Unable to create shader module."

filament/backend/src/vulkan/VulkanHandles.h

@@ -28,7 +28,6 @@
 #include "VulkanTexture.h"
 #include "vulkan/VulkanCommands.h"
 #include "vulkan/memory/Resource.h"
-#include "vulkan/memory/ResourcePointer.h"
 #include "vulkan/utils/Definitions.h"
 #include "vulkan/utils/StaticVector.h"
 
@@ -58,8 +57,6 @@ inline uint8_t collapsedCount(Bitmask const& mask) {
 
 } // anonymous namespace
 
-class VulkanDescriptorSetCache;
-
 struct VulkanBufferObject;
 
 struct VulkanDescriptorSetLayout : public HwDescriptorSetLayout, fvkmemory::Resource {
@@ -68,6 +65,8 @@ struct VulkanDescriptorSetLayout : public HwDescriptorSetLayout, fvkmemory::Reso
 
     using DescriptorSetLayoutArray = std::array<VkDescriptorSetLayout,
             VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;
+    using DescriptorSetLayoutHashArray = std::array<uint64_t,
+            VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;
 
     // The bitmask representation of a set layout.
     struct Bitmask {
@@ -162,14 +161,38 @@ public:
     using OnRecycle = std::function<void(VulkanDescriptorSet*)>;
 
     VulkanDescriptorSet(
-            fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout,
-            OnRecycle&& onRecycleFn, VkDescriptorSet vkSet);
+            fvkutils::UniformBufferBitmask const& dynamicUboMask,
+            uint8_t uniqueDynamicUboCount,
+            OnRecycle&& onRecycleFn, VkDescriptorSet vkSet)
+        : dynamicUboMask(dynamicUboMask),
+          uniqueDynamicUboCount(uniqueDynamicUboCount),
+          mVkSet(vkSet),
+          mOnRecycleFn(std::move(onRecycleFn)) {}
 
     // NOLINTNEXTLINE(bugprone-exception-escape)
-    ~VulkanDescriptorSet();
+    ~VulkanDescriptorSet() {
+        if (mOnRecycleFn) {
+            mOnRecycleFn(this);
+        }
+        if (mOnRecycleExternalSamplerFn) {
+            mOnRecycleExternalSamplerFn(this);
+        }
+    }
 
     VkDescriptorSet getVkSet() const noexcept {
-        return mSets[mCurrentSetIndex].vkSet;
+        return mVkSet;
+    }
+
+    VkDescriptorSet getExternalSamplerVkSet() const noexcept {
+        return mExternalSamplerVkSet;
+    }
+
+    void setExternalSamplerVkSet(VkDescriptorSet vkset, OnRecycle onRecycle) {
+        mExternalSamplerVkSet = vkset;
+        if (mOnRecycleExternalSamplerFn) {
+            mOnRecycleExternalSamplerFn(this);
+        }
+        mOnRecycleExternalSamplerFn = onRecycle;
     }
 
     void setOffsets(backend::DescriptorSetOffsetArray&& offsets) noexcept {
@@ -190,33 +213,17 @@ public:
 
     void referencedBy(VulkanCommandBuffer& commands);
 
-    bool isBound() const {
-        return bool(mSets[mCurrentSetIndex].fenceStatus);
-    }
-
-    fvkmemory::resource_ptr<VulkanDescriptorSetLayout> getLayout() const { return mLayout; }
-
-    fvkutils::UniformBufferBitmask const& dynamicUboMask;
+    fvkutils::UniformBufferBitmask const dynamicUboMask;
     uint8_t const uniqueDynamicUboCount;
 
 private:
-    friend class VulkanDescriptorSetCache;
+    VkDescriptorSet const mVkSet;
+    VkDescriptorSet mExternalSamplerVkSet = VK_NULL_HANDLE;
 
-    void addNewSet(VkDescriptorSet vkSet, OnRecycle&& onRecycleFn);
-
-    void gc();
-
-    struct InternalVkSet {
-        VkDescriptorSet vkSet = {};
-        OnRecycle onRecycleFn;
-        std::shared_ptr<VulkanCmdFence> fenceStatus;
-    };
-
-    fvkmemory::resource_ptr<VulkanDescriptorSetLayout> mLayout;
     backend::DescriptorSetOffsetArray mOffsets;
     std::vector<fvkmemory::resource_ptr<fvkmemory::Resource>> mResources;
-    uint8_t mCurrentSetIndex;
-    std::vector<InternalVkSet> mSets;
+    OnRecycle mOnRecycleFn;
+    OnRecycle mOnRecycleExternalSamplerFn;
     fvkutils::UniformBufferBitmask mUboMask;
 };
 
@@ -275,6 +282,10 @@ struct VulkanProgram : public HwProgram, fvkmemory::Resource {
         mInfo->pushConstantDescription.write(cmdbuf, layout, stage, index, value);
     }
 
+    inline uint64_t getVertexShaderHash() { return mVertexShaderHash;
+    }
+    inline uint64_t getFragmentShaderHash() { return mFragmentShaderHash; }
+
     // TODO: handle compute shaders.
     // The expected order of shaders - from frontend to backend - is vertex, fragment, compute.
     static constexpr uint8_t const MAX_SHADER_MODULES = 2;
@@ -290,6 +301,8 @@ private:
     };
 
     PipelineInfo* mInfo;
+    uint64_t mVertexShaderHash;
+    uint64_t mFragmentShaderHash;
     VkDevice mDevice = VK_NULL_HANDLE;
 };
 

filament/backend/src/vulkan/VulkanPipelineCache.cpp

@@ -15,6 +15,7 @@
  */
 
 #include "VulkanPipelineCache.h"
+#include "VulkanPipelineStateSerializer.h"
 
 #include <utils/Log.h>
 #include <utils/Panic.h>
@@ -34,49 +35,17 @@ using namespace bluevk;
 
 namespace filament::backend {
 
-namespace {
-
-#if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
-void printPipelineFeedbackInfo(VkPipelineCreationFeedbackCreateInfo const& feedbackInfo) {
-    VkPipelineCreationFeedback const& pipelineInfo = *feedbackInfo.pPipelineCreationFeedback;
-    if (!(pipelineInfo.flags & VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT)) {
-        return;
-    }
-
-    bool const isCacheHit =
-            (pipelineInfo.flags & VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT);
-    FVK_LOGD << "Pipeline build stats - Cache hit: " << isCacheHit
-             << ", Time: " << pipelineInfo.duration / 1000000.0 << "ms";
-
-    for (uint32_t i = 0; i < feedbackInfo.pipelineStageCreationFeedbackCount; ++i) {
-        VkPipelineCreationFeedback const& stageInfo = feedbackInfo.pPipelineStageCreationFeedbacks[i];
-        if (!(stageInfo.flags & VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT)) {
-            continue;
-        }
-
-        bool const isVertexShader = (i == 0);
-        bool const isCacheHit = (stageInfo.flags &
-                                 VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT);
-        FVK_LOGD << (isVertexShader ? "Vertex" : "Fragment")
-                 << " shader build stats - Cache hit: " << isCacheHit
-                 << ", Time: " << stageInfo.duration / 1000000.0 << "ms";
-    }
-}
-#endif
-
-} // namespace
-
-VulkanPipelineCache::VulkanPipelineCache(VkDevice device, VulkanContext const& context)
-        : mDevice(device),
-          mContext(context) {
+VulkanPipelineCache::VulkanPipelineCache(VkDevice device)
+    : mDevice(device) {
     VkPipelineCacheCreateInfo createInfo = {
         .sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
     };
     bluevk::vkCreatePipelineCache(mDevice, &createInfo, VKALLOC, &mPipelineCache);
 }
 
-void VulkanPipelineCache::bindLayout(VkPipelineLayout layout) noexcept {
+void VulkanPipelineCache::bindLayout(VkPipelineLayout layout, uint32_t key) noexcept {
     mPipelineRequirements.layout = layout;
+    mPipelineLayoutKey = key;
 }
 
 VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::getOrCreatePipeline() noexcept {
@@ -110,6 +79,7 @@ void VulkanPipelineCache::bindPipeline(VulkanCommandBuffer* commands) {
 VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() noexcept {
     assert_invariant(mPipelineRequirements.shaders[0] && "Vertex shader is not bound.");
     assert_invariant(mPipelineRequirements.layout && "No pipeline layout specified");
+    VulkanPipelineStateSerializer serializer(mProgramName);
 
     VkPipelineShaderStageCreateInfo shaderStages[SHADER_MODULE_COUNT];
     shaderStages[0] = {
@@ -122,6 +92,12 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
     shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
     shaderStages[1].module = mPipelineRequirements.shaders[1];
 
+    VulkanPipelineStateSerializer::ShaderStageInfo vtx = { shaderStages[0].stage, mVertexShaderHash,
+        shaderStages[0].pName };
+    VulkanPipelineStateSerializer::ShaderStageInfo frg = { shaderStages[1].stage, mFragmentShaderHash,
+        shaderStages[1].pName };
+    serializer << vtx << frg;
+
     bool const hasFragmentShader = shaderStages[1].module != VK_NULL_HANDLE;
 
     VkPipelineColorBlendAttachmentState colorBlendAttachments[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT];
@@ -140,9 +116,11 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
     for (uint32_t i = 0; i < VERTEX_ATTRIBUTE_COUNT; i++) {
         if (mPipelineRequirements.vertexAttributes[i].format > 0) {
             vertexAttributes[numVertexAttribs++] = mPipelineRequirements.vertexAttributes[i];
+            serializer << mPipelineRequirements.vertexAttributes[i];
         }
         if (mPipelineRequirements.vertexBuffers[i].stride > 0) {
             vertexBuffers[numVertexBuffers++] = mPipelineRequirements.vertexBuffers[i];
+            serializer << mPipelineRequirements.vertexBuffers[i];
         }
     }
     VkPipelineVertexInputStateCreateInfo vertexInputState = {
@@ -156,11 +134,15 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
         .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
         .topology = (VkPrimitiveTopology) mPipelineRequirements.topology,
     };
+    serializer << inputAssemblyState;
+
     VkPipelineViewportStateCreateInfo viewportState = {
         .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
         .viewportCount = 1,
         .scissorCount = 1,
     };
+    serializer << viewportState;
+
     VkDynamicState dynamicStateEnables[] = {
         VK_DYNAMIC_STATE_VIEWPORT,
         VK_DYNAMIC_STATE_SCISSOR,
@@ -170,6 +152,8 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
         .dynamicStateCount = 2,
         .pDynamicStates = dynamicStateEnables,
     };
+    serializer << dynamicState;
+
     auto const& raster = mPipelineRequirements.rasterState;
     VkPipelineRasterizationStateCreateInfo vkRaster = {
         .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
@@ -183,6 +167,8 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
         .depthBiasSlopeFactor = raster.depthBiasSlopeFactor,
         .lineWidth = 1.0f,
     };
+    serializer << vkRaster;
+
     VkPipelineMultisampleStateCreateInfo vkMs = {
         .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .rasterizationSamples = (VkSampleCountFlagBits) raster.rasterizationSamples,
@@ -191,12 +177,11 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
         .alphaToCoverageEnable = raster.alphaToCoverageEnable,
         .alphaToOneEnable = VK_FALSE,
     };
-    bool const enableDepthTest =
-        raster.depthCompareOp != SamplerCompareFunc::A ||
-        raster.depthWriteEnable;
+    serializer << vkMs;
+
     VkPipelineDepthStencilStateCreateInfo vkDs = {
         .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
-        .depthTestEnable = enableDepthTest ? VK_TRUE : VK_FALSE,
+        .depthTestEnable = VK_TRUE,
         .depthWriteEnable = raster.depthWriteEnable,
         .depthCompareOp = fvkutils::getCompareOp(raster.depthCompareOp),
         .depthBoundsTestEnable = VK_FALSE,
@@ -213,6 +198,12 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
         .writeMask = 0u,
         .reference = 0u,
     };
+    serializer << vkDs;
+
+    //layout
+    serializer.setPipelineLayoutKey(mPipelineLayoutKey);
+    // renderPass
+    serializer.setRenderPassKey(mRenderPassKey);
 
     VkGraphicsPipelineCreateInfo pipelineCreateInfo = {
         .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
@@ -251,52 +242,36 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
             colorBlendAttachments[i] = colorBlendAttachments[0];
         }
     }
+    serializer << colorBlendState;
 
-#if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
-    FVK_LOGD << "vkCreateGraphicsPipelines with shaders = (" << shaderStages[0].module << ", "
-             << shaderStages[1].module << ")";
-
-    VkPipelineCreationFeedback stageFeedbacks[SHADER_MODULE_COUNT] = {};
-    VkPipelineCreationFeedback pipelineFeedback = {};
-    VkPipelineCreationFeedbackCreateInfo feedbackInfo = {
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT,
-        .pNext = nullptr,
-        .pPipelineCreationFeedback = &pipelineFeedback,
-        .pipelineStageCreationFeedbackCount = hasFragmentShader ? SHADER_MODULE_COUNT : 1,
-        .pPipelineStageCreationFeedbacks = stageFeedbacks,
-    };
-
-    if (mContext.pipelineCreationFeedbackSupported()) {
-        feedbackInfo.pNext = pipelineCreateInfo.pNext;
-        pipelineCreateInfo.pNext = &feedbackInfo;
-    }
-#endif
+    #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
+        FVK_LOGD << "vkCreateGraphicsPipelines with shaders = ("
+                 << shaderStages[0].module << ", " << shaderStages[1].module << ")";
+    #endif
     PipelineCacheEntry cacheEntry = {
         .lastUsed = mCurrentTime,
     };
     VkResult error = vkCreateGraphicsPipelines(mDevice, mPipelineCache, 1, &pipelineCreateInfo,
             VKALLOC, &cacheEntry.handle);
-
-#if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
-    FVK_LOGD << "vkCreateGraphicsPipelines with shaders = (" << shaderStages[0].module << ", "
-             << shaderStages[1].module << ")";
-
-    if (mContext.pipelineCreationFeedbackSupported()) {
-        printPipelineFeedbackInfo(feedbackInfo);
-    }
-#endif
-
     assert_invariant(error == VK_SUCCESS);
     if (error != VK_SUCCESS) {
         FVK_LOGE << "vkCreateGraphicsPipelines error " << error;
         return nullptr;
     }
+
+    PipelineHashFn hashFunc;
+
+    serializer.setID(hashFunc(mPipelineRequirements));
     return &mPipelines.emplace(mPipelineRequirements, cacheEntry).first.value();
 }
 
 void VulkanPipelineCache::bindProgram(fvkmemory::resource_ptr<VulkanProgram> program) noexcept {
     mPipelineRequirements.shaders[0] = program->getVertexShader();
     mPipelineRequirements.shaders[1] = program->getFragmentShader();
+    mProgramName = program->name;
+    mVertexShaderHash = program->getVertexShaderHash();
+    mFragmentShaderHash= program->getFragmentShaderHash();
+    
 
     // If this is a debug build, validate the current shader.
 #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
@@ -311,9 +286,10 @@ void VulkanPipelineCache::bindRasterState(RasterState const& rasterState) noexce
     mPipelineRequirements.rasterState = rasterState;
 }
 
-void VulkanPipelineCache::bindRenderPass(VkRenderPass renderPass, int subpassIndex) noexcept {
+void VulkanPipelineCache::bindRenderPass(VkRenderPass renderPass, uint32_t passKey, int subpassIndex) noexcept {
     mPipelineRequirements.renderPass = renderPass;
     mPipelineRequirements.subpassIndex = subpassIndex;
+    mRenderPassKey = passKey;
 }
 
 void VulkanPipelineCache::bindPrimitiveTopology(VkPrimitiveTopology topology) noexcept {

filament/backend/src/vulkan/VulkanPipelineCache.h

@@ -86,9 +86,9 @@ public:
 
     static_assert(sizeof(RasterState) == 16, "RasterState must not have implicit padding.");
 
-    VulkanPipelineCache(VkDevice device, VulkanContext const& context);
+    VulkanPipelineCache(VkDevice device);
 
-    void bindLayout(VkPipelineLayout layout) noexcept;
+    void bindLayout(VkPipelineLayout layout, uint32_t key) noexcept;
 
     // Creates a new pipeline if necessary and binds it using vkCmdBindPipeline.
     void bindPipeline(VulkanCommandBuffer* commands);
@@ -96,7 +96,7 @@ public:
     // Each of the following methods are fast and do not make Vulkan calls.
     void bindProgram(fvkmemory::resource_ptr<VulkanProgram> program) noexcept;
     void bindRasterState(RasterState const& rasterState) noexcept;
-    void bindRenderPass(VkRenderPass renderPass, int subpassIndex) noexcept;
+    void bindRenderPass(VkRenderPass renderPass, uint32_t passKey, int subpassIndex) noexcept;
     void bindPrimitiveTopology(VkPrimitiveTopology topology) noexcept;
     void bindVertexArray(VkVertexInputAttributeDescription const* attribDesc,
             VkVertexInputBindingDescription const* bufferDesc, uint8_t count);
@@ -207,11 +207,14 @@ private:
 
     // Current requirements for the pipeline layout, pipeline, and descriptor sets.
     PipelineKey mPipelineRequirements = {};
+    utils::CString mProgramName;
+    uint64_t mVertexShaderHash;
+    uint64_t mFragmentShaderHash;
+    uint32_t mPipelineLayoutKey;
+    uint32_t mRenderPassKey;
 
     // Current bindings for the pipeline and descriptor sets.
     PipelineKey mBoundPipeline = {};
-
-    [[maybe_unused]] VulkanContext const& mContext;
 };
 
 } // namespace filament::backend

filament/backend/src/vulkan/VulkanPipelineLayoutCache.cpp

@@ -15,6 +15,7 @@
  */
 
 #include "VulkanPipelineLayoutCache.h"
+#include "VulkanDescriptorSetLayoutSerializer.h"
 
 namespace filament::backend {
 
@@ -23,7 +24,11 @@ VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
         fvkmemory::resource_ptr<VulkanProgram> program) {
     PipelineLayoutKey key = {};
     uint8_t descSetLayoutCount = 0;
-    key.descSetLayouts = descriptorSetLayouts;
+    DescriptorSetLayoutHashArray hashArray;
+    for (uint32_t i = 0; i < descriptorSetLayouts.size(); ++i) {
+        hashArray[i] = mDescriptorSetCache->getKey(descriptorSetLayouts[i]);
+    }
+    key.descSetLayouts = hashArray;
     for (auto layoutHandle: descriptorSetLayouts) {
         if (layoutHandle == VK_NULL_HANDLE) {
             break;
@@ -62,11 +67,14 @@ VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
         .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
         .pNext = nullptr,
         .setLayoutCount = (uint32_t) descSetLayoutCount,
-        .pSetLayouts = key.descSetLayouts.data(),
+        .pSetLayouts = descriptorSetLayouts.data(),
         .pushConstantRangeCount = pushConstantRangeCount,
         .pPushConstantRanges = pushConstantRanges,
     };
 
+    PipelineLayoutKeyHashFn hashFunc;
+    uint32_t hashedKey = hashFunc(key);
+    VulkanPipelineLayoutSerializer pipelineSer(info, mDescriptorSetCache, hashedKey);
     VkPipelineLayout layout;
     vkCreatePipelineLayout(mDevice, &info, VKALLOC, &layout);
 
@@ -74,6 +82,8 @@ VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
         .handle = layout,
         .lastUsed = mTimestamp++,
     };
+
+    mPipelineToKey[layout] = hashedKey;
     return layout;
 }
 

filament/backend/src/vulkan/VulkanPipelineLayoutCache.h

@@ -18,6 +18,7 @@
 #define TNT_FILAMENT_BACKEND_VULKANPIPELINELAYOUTCACHE_H
 
 #include "VulkanHandles.h"
+#include "VulkanDescriptorSetLayoutCache.h"
 
 #include <bluevk/BlueVK.h>
 
@@ -30,10 +31,11 @@ namespace filament::backend {
 class VulkanPipelineLayoutCache {
 public:
     using DescriptorSetLayoutArray = VulkanDescriptorSetLayout::DescriptorSetLayoutArray;
+    using DescriptorSetLayoutHashArray = VulkanDescriptorSetLayout::DescriptorSetLayoutHashArray;
     
-    VulkanPipelineLayoutCache(VkDevice device)
+    VulkanPipelineLayoutCache(VkDevice device, VulkanDescriptorSetLayoutCache* cache)
         : mDevice(device),
-          mTimestamp(0) {}
+          mTimestamp(0), mDescriptorSetCache(cache) {}
 
     void terminate() noexcept;
 
@@ -45,7 +47,7 @@ public:
     };
 
     struct PipelineLayoutKey {
-        DescriptorSetLayoutArray descSetLayouts = {};                                     // 8 * 4
+        DescriptorSetLayoutHashArray descSetLayouts = {};              // 8 * 4
         PushConstantKey pushConstant[Program::SHADER_TYPE_COUNT] = {};                    // 2 * 3
         uint16_t padding = 0;
     };
@@ -58,6 +60,14 @@ public:
     // are described in the program.
     VkPipelineLayout getLayout(DescriptorSetLayoutArray const& descriptorSetLayouts,
             fvkmemory::resource_ptr<VulkanProgram> program);
+    uint32_t getKey(VkPipelineLayout layout) {
+        uint32_t key = 0;
+        auto iter = mPipelineToKey.find(layout);
+        if (iter != mPipelineToKey.end()) {
+            key = iter->second;
+        }
+        return key;
+    }
 
 private:
     using Timestamp = uint64_t;
@@ -79,6 +89,8 @@ private:
     VkDevice mDevice;
     Timestamp mTimestamp;
     PipelineLayoutMap mPipelineLayouts;
+    std::map<VkPipelineLayout, uint32_t> mPipelineToKey;
+    VulkanDescriptorSetLayoutCache* mDescriptorSetCache;
 };
 
 } // filament::backend

filament/backend/src/vulkan/VulkanPipelineStateSerializer.cpp

@@ -0,0 +1,251 @@
+/*
+ * Copyright (C) 2022 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 <fstream>
+
+#include "VulkanPipelineStateSerializer.h"
+#include <utils/Log.h>
+#include <utils/Panic.h>
+
+#include "VulkanConstants.h"
+#include "VulkanHandles.h"
+
+#if defined(__clang__)
+// Vulkan functions often immediately dereference pointers, so it's fine to pass in a pointer
+// to a stack-allocated variable.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-stack-address"
+#endif
+
+using namespace bluevk;
+
+namespace filament::backend {
+
+VulkanPipelineStateSerializer::VulkanPipelineStateSerializer(const utils::CString& name) { 
+    mBuffer << "{" << std::endl;
+    mBuffer << "\"program_name\":" << "\"" << name.c_str() << "\"" << "," << std::endl;
+}
+VulkanPipelineStateSerializer::~VulkanPipelineStateSerializer() {
+    //Shader Modules
+    mBuffer << "\"shader_modules\":[" << std::endl;
+    for (uint32_t i = 0; i < mShaderStages.size(); ++i) {
+        mBuffer << "{" << std::endl;
+        mBuffer << "\"stage\":" << mShaderStages[i].stage << "," << std::endl;
+        mBuffer << "\"key\":" << mShaderStages[i].module  << "," << std::endl;
+        mBuffer << "\"name\":" << "\"" << mShaderStages[i].mName << "\"" << std::endl;
+        mBuffer << "}";
+        if (i < mShaderStages.size() - 1) {
+            mBuffer << ",";
+        }
+        mBuffer <<  std::endl;
+    }
+    mBuffer << "]," << std::endl;
+
+    //Vertex Attribute
+    mBuffer << "\"vertex_attributes\":[" << std::endl;
+    for (uint32_t i = 0; i < mVtxAttribs.size(); ++i) {
+        mBuffer << "{" << std::endl;
+        mBuffer << "\"location\":" << mVtxAttribs[i].location << "," << std::endl;
+        mBuffer << "\"binding\":" <<  mVtxAttribs[i].binding << "," << std::endl;
+        mBuffer << "\"format\":" << mVtxAttribs[i].format << "," << std::endl;
+        mBuffer << "\"offset\":" << mVtxAttribs[i].offset << std::endl;
+        mBuffer << "}";
+        if (i < mVtxAttribs.size() - 1) {
+            mBuffer << ",";
+        }
+        mBuffer << std::endl;
+    }
+    mBuffer << "]," << std::endl;
+
+    // Vertex Bindings
+    mBuffer << "\"vertex_bindings\":[" << std::endl;
+    for (uint32_t i = 0; i < mVtxBindings.size(); ++i) {
+        mBuffer << "{" << std::endl;
+        mBuffer << "\"binding\":" << mVtxBindings[i].binding << "," << std::endl;
+        mBuffer << "\"stride\":" << mVtxBindings[i].stride << "," << std::endl;
+        mBuffer << "\"input_rate\":" << mVtxBindings[i].inputRate << std::endl;
+        mBuffer << "}";
+        if (i < mVtxBindings.size() - 1) {
+            mBuffer << ",";
+        }
+        mBuffer << std::endl;
+    }
+    mBuffer << "]" << std::endl;
+
+    mBuffer << "}" << std::endl;
+
+    std::ofstream file(mFileName);
+    if (file.is_open()) {
+        file << mBuffer.str();
+    }
+    file.close();
+}
+
+void VulkanPipelineStateSerializer::setPipelineLayoutKey(uint32_t pipelineLayoutKey) {
+    mBuffer << "\"layout\":" << pipelineLayoutKey << "," << std::endl;
+}
+
+void VulkanPipelineStateSerializer::setRenderPassKey(uint32_t renderPassKey) {
+    mBuffer << "\"render_pass\":" << renderPassKey << "," << std::endl;
+}
+
+void VulkanPipelineStateSerializer::setID(uint32_t key) {
+    std::stringstream temp;
+    temp << "pipeline_" << key << ".json";
+    temp >> mFileName;
+}
+
+VulkanPipelineStateSerializer& VulkanPipelineStateSerializer::operator<<(
+        const VkPipelineInputAssemblyStateCreateInfo& inputAsm) {
+    mBuffer << "\"topology\":" << inputAsm.topology << "," << std::endl;
+    return *this;
+}
+
+VulkanPipelineStateSerializer& VulkanPipelineStateSerializer::operator<<(
+        const VkPipelineViewportStateCreateInfo& viewport) {
+    mBuffer << "\"viewport_count\":" << viewport.viewportCount << "," << std::endl;
+    mBuffer << "\"scissor_count\":" << viewport.scissorCount << "," << std::endl;
+    return *this;
+}
+
+VulkanPipelineStateSerializer& VulkanPipelineStateSerializer::operator<<(
+        const VkPipelineRasterizationStateCreateInfo& rasterState) {
+    mBuffer << "\"raster_states\":{" << std::endl;
+    mBuffer << "\"depth_clamp_enable\":" << rasterState.depthClampEnable << "," << std::endl;
+    mBuffer << "\"polygon_mode\":" << rasterState.polygonMode << "," << std::endl;
+    mBuffer << "\"cull_mode\":" << rasterState.cullMode << "," << std::endl;
+    mBuffer << "\"front_face\":" << rasterState.frontFace << "," << std::endl;
+    mBuffer << "\"depth_bias_enable\":" << rasterState.depthBiasEnable << "," << std::endl;
+    mBuffer << "\"depth_bias_constant_factor\":" << rasterState.depthBiasConstantFactor << ","
+            << std::endl;
+    mBuffer << "\"depth_bias_clamp\":" << rasterState.depthBiasClamp << "," << std::endl;
+    mBuffer << "\"depth_bias_slope_factor\":" << rasterState.depthBiasSlopeFactor << "," << std::endl;
+    mBuffer << "\"line_width\":" << rasterState.lineWidth << std::endl;
+    mBuffer << "}," << std::endl;
+    return *this;
+}
+
+VulkanPipelineStateSerializer& VulkanPipelineStateSerializer::operator<<(
+        const VkPipelineDepthStencilStateCreateInfo& depthStencil) {
+    mBuffer << "\"depth_stencil_states\":{" << std::endl;
+    mBuffer << "\"depth_test_enable\":" << depthStencil.depthTestEnable << "," << std::endl;
+    mBuffer << "\"depth_write_enable\":" << depthStencil.depthWriteEnable << "," << std::endl;
+    mBuffer << "\"depth_compare_op\":" << depthStencil.depthCompareOp << "," << std::endl;
+    mBuffer << "\"depth_bounds_test_enable\":" << depthStencil.depthBoundsTestEnable << ","
+            << std::endl;
+    mBuffer << "\"min_depth_bounds\":" << depthStencil.minDepthBounds << "," << std::endl;
+    mBuffer << "\"max_depth_bounds\":" << depthStencil.maxDepthBounds << "," << std::endl;
+    mBuffer << "\"front\":{" << std::endl;
+    mBuffer << "\"fail_op\":" << depthStencil.front.failOp << "," << std::endl;
+    mBuffer << "\"pass_op\":" << depthStencil.front.passOp << "," << std::endl;
+    mBuffer << "\"depth_fail_op\":" << depthStencil.front.depthFailOp << "," << std::endl;
+    mBuffer << "\"compare_op\":" << depthStencil.front.compareOp << "," << std::endl;
+    mBuffer << "\"compare_mask\":" << depthStencil.front.compareMask << "," << std::endl;
+    mBuffer << "\"write_mask\":" << depthStencil.front.writeMask << "," << std::endl;
+    mBuffer << "\"reference\":" << depthStencil.front.reference << std::endl;
+    mBuffer << "}," << std::endl;
+    mBuffer << "\"back\":{" << std::endl;
+    mBuffer << "\"fail_op\":" << depthStencil.back.failOp << "," << std::endl;
+    mBuffer << "\"pass_op\":" << depthStencil.back.passOp << "," << std::endl;
+    mBuffer << "\"depth_fail_op\":" << depthStencil.back.depthFailOp << "," << std::endl;
+    mBuffer << "\"compare_op\":" << depthStencil.back.compareOp << "," << std::endl;
+    mBuffer << "\"compare_mask\":" << depthStencil.back.compareMask << "," << std::endl;
+    mBuffer << "\"write_mask\":" << depthStencil.back.writeMask << "," << std::endl;
+    mBuffer << "\"reference\":" << depthStencil.back.reference << std::endl;
+    mBuffer << "}" << std::endl;
+    mBuffer << "}," << std::endl;
+    return *this;
+}
+
+VulkanPipelineStateSerializer& VulkanPipelineStateSerializer::operator<<(
+        const VkPipelineMultisampleStateCreateInfo& multiSample) {
+    mBuffer << "\"multisample_states\":{" << std::endl;
+    mBuffer << "\"rasterization_samples\":" << multiSample.rasterizationSamples << "," << std::endl;
+    mBuffer << "\"sample_shading_enable\":" << multiSample.sampleShadingEnable << "," << std::endl;
+    mBuffer << "\"min_sample_shading\":" << multiSample.minSampleShading << "," << std::endl;
+    mBuffer << "\"alpha_to_coverage_enable\":" << multiSample.alphaToCoverageEnable << ","
+            << std::endl;
+    mBuffer << "\"alpha_to_one_enable\":" << multiSample.alphaToOneEnable << std::endl;
+    mBuffer << "}," << std::endl;
+    return *this;
+}
+
+VulkanPipelineStateSerializer& VulkanPipelineStateSerializer::operator<<(
+        const VkPipelineDynamicStateCreateInfo& dyStates) {
+    mBuffer << "\"dynamic_states\":[" << std::endl;
+    for (uint32_t i = 0; i < dyStates.dynamicStateCount; ++i) {
+        mBuffer << dyStates.pDynamicStates[i];
+        if (i < dyStates.dynamicStateCount - 1) {
+            mBuffer << ",";
+        }
+        mBuffer << std::endl;
+    }
+    mBuffer << "]," << std::endl;
+    return *this;
+}
+
+VulkanPipelineStateSerializer& VulkanPipelineStateSerializer::operator<<(
+        const VkPipelineColorBlendStateCreateInfo& blendStateInfo) {
+    mBuffer << "\"color_blend_state_attachments\":[" << std::endl;
+    for (uint32_t i = 0; i < blendStateInfo.attachmentCount; ++i) {
+        mBuffer << "{" << std::endl;
+        mBuffer << "\"blend_enable\":" << blendStateInfo.pAttachments[i].blendEnable << ","
+                << std::endl;
+        mBuffer << "\"src_color_blend_factor\":" << blendStateInfo.pAttachments[i].srcColorBlendFactor
+                << ","
+                << std::endl;
+        mBuffer << "\"dst_color_blend_factor\":" << blendStateInfo.pAttachments[i].dstColorBlendFactor
+                << ","
+                << std::endl;
+        mBuffer << "\"color_blend_op\":" << blendStateInfo.pAttachments[i].colorBlendOp << ","
+                << std::endl;
+        mBuffer << "\"src_alpha_blend_factor\":" << blendStateInfo.pAttachments[i].srcAlphaBlendFactor
+                << ","
+                << std::endl;
+        mBuffer << "\"dst_alpha_blend_factor\":" << blendStateInfo.pAttachments[i].dstAlphaBlendFactor
+                << ","
+                << std::endl;
+        mBuffer << "\"alpha_blend_op\":" << blendStateInfo.pAttachments[i].alphaBlendOp << ","
+                << std::endl;
+        mBuffer << "\"color_write_mask\":" << blendStateInfo.pAttachments[i].colorWriteMask
+                << std::endl;
+        mBuffer << "}";
+        if (i < blendStateInfo.attachmentCount - 1) {
+            mBuffer << ",";
+        }
+        mBuffer << std::endl;
+    }
+    mBuffer << "]," << std::endl;
+    return *this;
+}
+
+VulkanPipelineStateSerializer& VulkanPipelineStateSerializer::operator<<(
+        const ShaderStageInfo& shaderStages) {
+    mShaderStages.push_back(shaderStages);
+    return *this;
+}
+
+VulkanPipelineStateSerializer& VulkanPipelineStateSerializer::operator<<(
+    const VkVertexInputAttributeDescription& attrib) {
+    mVtxAttribs.push_back(attrib);
+    return *this;
+}
+VulkanPipelineStateSerializer& VulkanPipelineStateSerializer::operator<<(
+    const VkVertexInputBindingDescription& binding) {
+    mVtxBindings.push_back(binding);
+    return *this;
+}
+}

filament/backend/src/vulkan/VulkanPipelineStateSerializer.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2022 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_VULKANPIPELINESTATESERIALIZER_H
+#define TNT_FILAMENT_BACKEND_VULKANPIPELINESTATESERIALIZER_H
+
+#include "VulkanCommands.h"
+
+#include <backend/DriverEnums.h>
+#include <backend/TargetBufferInfo.h>
+
+#include <bluevk/BlueVK.h>
+#include <iostream>
+#include <type_traits>
+#include <sstream>
+#include <vector>
+
+namespace filament::backend {
+
+// VulkanPipelineStateSerializer stores to a file the pipeline states.
+class VulkanPipelineStateSerializer {
+public:
+    VulkanPipelineStateSerializer(VulkanPipelineStateSerializer const&) = delete;
+    VulkanPipelineStateSerializer& operator=(VulkanPipelineStateSerializer const&) = delete;
+
+    VulkanPipelineStateSerializer(const utils::CString& name);
+    ~VulkanPipelineStateSerializer();
+
+    void setID(uint32_t key);
+    void setPipelineLayoutKey(uint32_t pipelineLayoutKey);
+    void setRenderPassKey(uint32_t renderPassKey); 
+    VulkanPipelineStateSerializer& operator<<(
+            const VkPipelineInputAssemblyStateCreateInfo& inputAsm);
+    VulkanPipelineStateSerializer& operator<<(const VkPipelineViewportStateCreateInfo& viewport);
+    VulkanPipelineStateSerializer& operator<<(const VkPipelineDynamicStateCreateInfo& dyStates);
+    VulkanPipelineStateSerializer& operator<<(
+            const VkPipelineRasterizationStateCreateInfo& rasterState);
+    VulkanPipelineStateSerializer& operator<<(
+            const VkPipelineDepthStencilStateCreateInfo& depthStencil);
+    VulkanPipelineStateSerializer& operator<<(const VkPipelineMultisampleStateCreateInfo& multiSample);
+    VulkanPipelineStateSerializer& operator<<(
+            const VkPipelineColorBlendStateCreateInfo& blendStateInfo);
+
+    struct ShaderStageInfo {
+        VkShaderStageFlagBits stage;
+        uint64_t module;
+        std::string mName;
+    };
+    VulkanPipelineStateSerializer& operator<<(const ShaderStageInfo& shaderStages);
+    VulkanPipelineStateSerializer& operator<<(
+            const VkVertexInputAttributeDescription& attrib);
+    VulkanPipelineStateSerializer& operator<<(const VkVertexInputBindingDescription& binding);
+
+private:
+    std::string mFileName;
+    std::stringstream mBuffer;
+
+    //temp data
+    utils::CString mProgramName;
+    std::vector<ShaderStageInfo> mShaderStages;
+    std::vector<VkVertexInputAttributeDescription> mVtxAttribs;
+    std::vector<VkVertexInputBindingDescription> mVtxBindings;
+};
+} // namespace filament::backend
+
+#endif //TNT_FILAMENT_BACKEND_VULKANPIPELINESTATESERIALIZER_H

filament/backend/src/vulkan/VulkanRenderPassStateSerializer.cpp

@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2022 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 <fstream>
+
+#include "VulkanRenderPassStateSerializer.h"
+#include <utils/Log.h>
+#include <utils/Panic.h>
+
+#include "VulkanConstants.h"
+#include "VulkanHandles.h"
+
+#if defined(__clang__)
+// Vulkan functions often immediately dereference pointers, so it's fine to pass in a pointer
+// to a stack-allocated variable.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-stack-address"
+#endif
+
+using namespace bluevk;
+
+namespace filament::backend {
+
+VulkanRenderPassStateSerializer::VulkanRenderPassStateSerializer(
+        const VkRenderPassCreateInfo& info, uint32_t key) {
+    std::stringstream filename;
+    filename << "render_pass_" << key << ".json";
+
+    std::ofstream file(filename.str());
+    if (file.is_open()) {
+        std::stringstream buffer;
+        buffer << "{" << std::endl;
+        buffer << "\"attachments\":[" << std::endl;
+        for (uint32_t i = 0; i < info.attachmentCount; ++i) {
+            buffer << "{" << std::endl;
+            buffer << "\"flags\":" << info.pAttachments[i].flags << "," << std::endl;
+            buffer << "\"format\":" << info.pAttachments[i].format << "," << std::endl;
+            buffer << "\"samples\":" << info.pAttachments[i].samples << "," << std::endl;
+            buffer << "\"load_op\":" << info.pAttachments[i].loadOp << "," << std::endl;
+            buffer << "\"store_op\":" << info.pAttachments[i].storeOp << "," << std::endl;
+            buffer << "\"stencil_load_op\":" << info.pAttachments[i].stencilLoadOp << "," << std::endl;
+            buffer << "\"stencil_store_op\":" << info.pAttachments[i].stencilStoreOp << "," << std::endl;
+            buffer << "\"initial_layout\":" << info.pAttachments[i].initialLayout << "," << std::endl;
+            buffer << "\"final_layout\":" << info.pAttachments[i].finalLayout << std::endl;
+            buffer << "}";
+            if (i < info.attachmentCount - 1) {
+                buffer << ",";
+            }
+            buffer << std::endl;
+        }
+        buffer << "]," << std::endl;
+
+        buffer << "\"subpasses\":[" << std::endl;
+        for (uint32_t i = 0; i < info.subpassCount; ++i) {
+            buffer << "{" << std::endl;
+            buffer << "\"flags\":" << info.pSubpasses[i].flags << "," << std::endl;
+            buffer << "\"pipeline_bind_point\":" << info.pSubpasses[i].pipelineBindPoint;
+            
+            //------------depth stencil-------------------
+            if (info.pSubpasses[i].pDepthStencilAttachment) {
+                buffer << "," << std::endl;
+                buffer << "\"depth_stencil_attachment\":{" << std::endl;
+                buffer << "\"attachement\":"
+                       << info.pSubpasses[i].pDepthStencilAttachment->attachment << ","
+                       << std::endl;
+                buffer << "\"layout\":" << info.pSubpasses[i].pDepthStencilAttachment->layout
+                       << std::endl;
+                buffer << "}";
+            }
+
+            //------------Resolve-------------------
+            if (info.pSubpasses[i].pResolveAttachments) {
+                buffer << "," << std::endl;
+                buffer << "\"resolve_attachments\":[" << std::endl;
+                for (uint32_t j = 0; j < info.pSubpasses[i].colorAttachmentCount; ++j) {
+                    buffer << "{" << std::endl;
+                    buffer << "\"attachement\":"
+                           << info.pSubpasses[i].pResolveAttachments[j].attachment << ","
+                           << std::endl;
+                    buffer << "\"layout\":" << info.pSubpasses[i].pResolveAttachments[j].layout
+                           << std::endl;
+                    buffer << "}" << std::endl;
+                    if (j < info.pSubpasses[i].colorAttachmentCount - 1) {
+                        buffer << ",";
+                    }
+                    buffer << std::endl;
+                }
+                buffer << "]";
+            }
+
+            //------------Color-------------------
+            if (info.pSubpasses[i].pColorAttachments) {
+                buffer << "," << std::endl;
+                buffer << "\"color_attachments\":[" << std::endl;
+                for (uint32_t j = 0; j < info.pSubpasses[i].colorAttachmentCount; ++j) {
+                    buffer << "{" << std::endl;
+                    buffer << "\"attachement\":"
+                           << info.pSubpasses[i].pColorAttachments[j].attachment << ","
+                           << std::endl;
+                    buffer << "\"layout\":" << info.pSubpasses[i].pColorAttachments[j].layout
+                           << std::endl;
+                    buffer << "}" << std::endl;
+                    if (j < info.pSubpasses[i].colorAttachmentCount - 1) {
+                        buffer << ",";
+                    }
+                    buffer << std::endl;
+                }
+                buffer << "]";
+            }
+
+            //------------Input-------------------
+            if (info.pSubpasses[i].pInputAttachments) {
+                buffer << "," << std::endl;
+                buffer << "\"input_attachments\":[" << std::endl;
+                for (uint32_t j = 0; j < info.pSubpasses[i].inputAttachmentCount; ++j) {
+                    buffer << "{" << std::endl;
+                    buffer << "\"attachement\":"
+                           << info.pSubpasses[i].pInputAttachments[j].attachment << ","
+                           << std::endl;
+                    buffer << "\"layout\":" << info.pSubpasses[i].pInputAttachments[j].layout
+                           << std::endl;
+                    buffer << "}" << std::endl;
+                    if (j < info.pSubpasses[i].inputAttachmentCount - 1) {
+                        buffer << ",";
+                    }
+                    buffer << std::endl;
+                }
+                buffer << "]" << std::endl;
+            }
+
+            buffer << "}";
+            if (i < info.subpassCount - 1) {
+                buffer << ",";
+            }
+            buffer << std::endl;
+        }
+        buffer << "]" << std::endl;
+
+        buffer << "}";
+        file << buffer.str();
+    }
+    file.close();
+}
+}

filament/backend/src/vulkan/VulkanRenderPassStateSerializer.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2022 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_VULKANRENDERPASSSTATESERIALIZER_H
+#define TNT_FILAMENT_BACKEND_VULKANRENDERPASSSTATESERIALIZER_H
+
+#include "VulkanCommands.h"
+
+#include <backend/DriverEnums.h>
+#include <backend/TargetBufferInfo.h>
+
+#include <bluevk/BlueVK.h>
+#include <iostream>
+#include <type_traits>
+#include <sstream>
+#include <vector>
+
+namespace filament::backend {
+
+class VulkanRenderPassStateSerializer {
+public:
+    VulkanRenderPassStateSerializer(VulkanRenderPassStateSerializer const&) = delete;
+    VulkanRenderPassStateSerializer& operator=(VulkanRenderPassStateSerializer const&) = delete;
+
+    VulkanRenderPassStateSerializer(const VkRenderPassCreateInfo& info, uint32_t key);
+};
+} // namespace filament::backend
+
+#endif //TNT_FILAMENT_BACKEND_VULKANRENDERPASSSTATESERIALIZER_H

filament/backend/src/vulkan/VulkanSamplerCache.cpp

@@ -21,12 +21,14 @@
 
 #include <utils/Panic.h>
 
+#include "VulkanSamplerStateSerializer.h"
+
 using namespace bluevk;
 
 namespace filament::backend {
 
-VulkanSamplerCache::VulkanSamplerCache(VkDevice device)
-    : mDevice(device) {}
+VulkanSamplerCache::VulkanSamplerCache(VkDevice device, VulkanYcbcrConversionCache* conversionCache)
+    : mDevice(device), mConversionCache(conversionCache) {}
 
 VkSampler VulkanSamplerCache::getSampler(Params params) {
     auto iter = mCache.find(params);
@@ -57,11 +59,16 @@ VkSampler VulkanSamplerCache::getSampler(Params params) {
         .borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
         .unnormalizedCoordinates = VK_FALSE,
     };
+    VulkanSamplerStateSerializer samplerSer(params,
+            params.conversion != VK_NULL_HANDLE ? mConversionCache->getKey(params.conversion) : 0);
+
     VkSampler sampler;
     VkResult result = vkCreateSampler(mDevice, &samplerInfo, VKALLOC, &sampler);
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to create sampler."
                                                        << " error=" << static_cast<int32_t>(result);
     mCache.insert({ params, sampler });
+    SamplerHashFn hashFn;
+    mSamplerToKey[sampler] = hashFn(params);
     return sampler;
 }
 

filament/backend/src/vulkan/VulkanSamplerCache.h

@@ -17,9 +17,11 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANSAMPLERCACHE_H
 #define TNT_FILAMENT_BACKEND_VULKANSAMPLERCACHE_H
 
+#include "VulkanYcbcrConversionCache.h"
 #include <backend/DriverEnums.h>
 
 #include <utils/Hash.h>
+#include <map>
 
 #include <bluevk/BlueVK.h>
 #include <tsl/robin_map.h>
@@ -37,11 +39,20 @@ public:
 
     static_assert(sizeof(Params) == 16);
 
-    explicit VulkanSamplerCache(VkDevice device);
+    explicit VulkanSamplerCache(VkDevice device, VulkanYcbcrConversionCache* conversionCache);
     VkSampler getSampler(Params params);
+    uint32_t getKey(VkSampler sampler) {
+        uint32_t key = 0;
+        auto iter = mSamplerToKey.find(sampler);
+        if (iter != mSamplerToKey.end()) {
+            key = iter->second;
+        }
+        return key;
+    }
     void terminate() noexcept;
 private:
     VkDevice mDevice;
+    VulkanYcbcrConversionCache* mConversionCache;
 
     struct SamplerEqualTo {
         bool operator()(Params lhs, Params rhs) const noexcept {
@@ -51,6 +62,7 @@ private:
     };
     using SamplerHashFn = utils::hash::MurmurHashFn<Params>;
     tsl::robin_map<Params, VkSampler, SamplerHashFn, SamplerEqualTo> mCache;
+    std::map<VkSampler, uint32_t> mSamplerToKey;
 };
 
 } // namespace filament::backend

filament/backend/src/vulkan/VulkanSamplerStateSerializer.cpp

@@ -0,0 +1,64 @@
+#include "VulkanSamplerStateSerializer.h"
+#include <fstream>
+#include <sstream>
+#include <utils/Hash.h>
+
+namespace filament::backend {
+VulkanYcbcrConversionSerializer::VulkanYcbcrConversionSerializer(
+        const VulkanYcbcrConversionCache::Params& params) {
+    using ConversionHashFn = utils::hash::MurmurHashFn<VulkanYcbcrConversionCache::Params>;
+    ConversionHashFn hashFn;
+    uint32_t key = hashFn(params);
+    std::stringstream filename;
+    filename << "ycbcr_conv_" << key << ".json";
+
+    std::ofstream file(filename.str());
+    if (file.is_open()) {
+        std::stringstream buffer;
+        auto const& chroma = params.conversion;
+        buffer << "{" << std::endl;
+        buffer << "\"format\":" << params.format << "," << std::endl;
+        buffer << "\"external_format\":" << params.externalFormat << "," << std::endl;
+        buffer << "\"ycbcr_model\":" << uint8_t(chroma.ycbcrModel) << "," << std::endl;
+        buffer << "\"ycbcr_range\":" << uint8_t(chroma.ycbcrRange) << "," << std::endl;
+        buffer << "\"swizzle_array\":[" << uint8_t(chroma.r) << "," << uint8_t(chroma.g) << ","
+               << uint8_t(chroma.b) << "," << uint8_t(chroma.a) << "]," << std::endl;
+        buffer << "\"x_chroma_offset\":" << uint8_t(chroma.xChromaOffset) << "," << std::endl;
+        buffer << "\"y_chroma_offset\":" << uint8_t(chroma.yChromaOffset) << "," << std::endl;
+        buffer << "\"chroma_filter\":" << uint8_t(chroma.chromaFilter) << std::endl;
+        buffer << "}" << std::endl;
+
+        file << buffer.str();
+    }
+    file.close();
+}
+
+VulkanSamplerStateSerializer::VulkanSamplerStateSerializer(const VulkanSamplerCache::Params& params, uint32_t ycbcr_conv_key) {
+    using ConversionHashFn = utils::hash::MurmurHashFn<VulkanSamplerCache::Params>;
+    ConversionHashFn hashFn;
+    uint32_t key = hashFn(params);
+    std::stringstream filename;
+    filename << "sampler_" << key << ".json";
+
+    std::ofstream file(filename.str());
+    if (file.is_open()) {
+        std::stringstream buffer;
+        auto const& samplerParams = params.sampler;
+        buffer << "{" << std::endl;
+        buffer << "\"filter_mag\":" << uint32_t(samplerParams.filterMag) << "," << std::endl;
+        buffer << "\"filter_min\":" << uint32_t(samplerParams.filterMin) << "," << std::endl;
+        buffer << "\"wrap_s\":" << uint32_t(samplerParams.wrapS) << "," << std::endl;
+        buffer << "\"wrap_t\":" << uint32_t(samplerParams.wrapT) << "," << std::endl;
+        buffer << "\"wrap_r\":" << uint32_t(samplerParams.wrapR) << "," << std::endl;
+        buffer << "\"anisotropy_log2\":" << uint32_t(samplerParams.anisotropyLog2) << "," << std::endl;
+        buffer << "\"compare_mode\":" << uint32_t(samplerParams.compareMode) << "," << std::endl;
+        buffer << "\"compare_func\":" << uint32_t(samplerParams.compareFunc) << "," << std::endl;
+        buffer << "\"ycbcr_conv_key\":" << ycbcr_conv_key << std::endl;
+        buffer << "}" << std::endl;
+
+        file << buffer.str();
+    }
+    file.close();
+}
+
+} // namespace filament::backend

filament/backend/src/vulkan/VulkanSamplerStateSerializer.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2022 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_VULKANSAMPLERSTATESERIALIZER_H
+#define TNT_FILAMENT_BACKEND_VULKANSAMPLERSTATESERIALIZER_H
+
+#include <backend/DriverEnums.h>
+#include "VulkanYcbcrConversionCache.h"
+#include "VulkanSamplerCache.h"
+
+#include <bluevk/BlueVK.h>
+#include <vector>
+#include <iostream>
+#include <sstream>
+
+namespace filament::backend {
+
+class VulkanYcbcrConversionSerializer {
+public:
+    VulkanYcbcrConversionSerializer(VulkanYcbcrConversionSerializer const&) = delete;
+    VulkanYcbcrConversionSerializer& operator=(VulkanYcbcrConversionSerializer const&) = delete;
+
+    VulkanYcbcrConversionSerializer(const VulkanYcbcrConversionCache::Params& params);
+};
+        // VulkanPipelineStateSerializer stores to a file the pipeline states.
+class VulkanSamplerStateSerializer {
+public:
+    VulkanSamplerStateSerializer(VulkanSamplerStateSerializer const&) = delete;
+    VulkanSamplerStateSerializer& operator=(VulkanSamplerStateSerializer const&) = delete;
+
+    VulkanSamplerStateSerializer(const VulkanSamplerCache::Params& params, uint32_t ycbcr_conv_key);
+};
+}
+
+#endif //TNT_FILAMENT_BACKEND_VULKANSAMPLERSTATESERIALIZER_H

filament/backend/src/vulkan/VulkanStreamedImageManager.cpp

@@ -1,60 +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 "VulkanStreamedImageManager.h"
-
-#include "VulkanDescriptorSetCache.h"
-#include "VulkanExternalImageManager.h"
-#include "VulkanDescriptorSetLayoutCache.h"
-#include "VulkanSamplerCache.h"
-
-namespace filament::backend {
-VulkanStreamedImageManager::VulkanStreamedImageManager(VulkanExternalImageManager* manager)
-        : mExternalImageManager(manager) {}
-
-VulkanStreamedImageManager::~VulkanStreamedImageManager() = default;
-
-void VulkanStreamedImageManager::terminate() { mStreamedTexturesBindings.clear(); }
-
-void VulkanStreamedImageManager::bindStreamedTexture(
-        fvkmemory::resource_ptr<VulkanDescriptorSet> set,
-        uint8_t bindingPoint, fvkmemory::resource_ptr<VulkanTexture> image,
-        SamplerParams samplerParams) {
-    mStreamedTexturesBindings.push_back({ bindingPoint, image, set, samplerParams });
-}
-
-void VulkanStreamedImageManager::unbindStreamedTexture(
-        fvkmemory::resource_ptr<VulkanDescriptorSet> set,
-        uint8_t bindingPoint) {
-    auto iter = std::remove_if(mStreamedTexturesBindings.begin(), mStreamedTexturesBindings.end(),
-            [&](StreamedTextureBinding& binding) {
-                return ((binding.set == set) && (binding.binding == bindingPoint));
-            });
-    mStreamedTexturesBindings.erase(iter, mStreamedTexturesBindings.end());
-}
-
-void VulkanStreamedImageManager::onStreamAcquireImage(fvkmemory::resource_ptr<VulkanTexture> image,
-        fvkmemory::resource_ptr<VulkanStream> stream) {
-    for (StreamedTextureBinding const& data: mStreamedTexturesBindings) {
-        // Find the right stream
-        if (data.image->getStream() == stream) {
-            mExternalImageManager->bindExternallySampledTexture(data.set, data.binding, image,
-                    data.samplerParams);
-        }
-    }
-}
-
-} // namespace filament::backend

filament/backend/src/vulkan/VulkanStreamedImageManager.h

@@ -1,64 +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_VULKANSTREAMEDIMAGEMANAGER_H
-#define TNT_FILAMENT_BACKEND_CACHING_VULKANSTREAMEDIMAGEMANAGER_H
-
-#include "VulkanHandles.h"
-
-#include <backend/DriverEnums.h>
-
-#include <array>
-#include <vector>
-
-namespace filament::backend {
-
-class VulkanExternalImageManager;
-class VulkanDescriptorSetCache;
-class VulkanSamplerCache;
-
-// Manages the logic of streamed images.
-class VulkanStreamedImageManager {
-public:
-    VulkanStreamedImageManager(
-            VulkanExternalImageManager* manager);
-    ~VulkanStreamedImageManager();
-    void terminate();
-
-public:
-    void bindStreamedTexture(fvkmemory::resource_ptr<VulkanDescriptorSet> set, uint8_t bindingPoint,
-            fvkmemory::resource_ptr<VulkanTexture> image, SamplerParams samplerParams);
-    void unbindStreamedTexture(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
-            uint8_t bindingPoint);
-    void onStreamAcquireImage(fvkmemory::resource_ptr<VulkanTexture> image,
-            fvkmemory::resource_ptr<VulkanStream> stream);
-
-private:
-    struct StreamedTextureBinding {
-        uint8_t binding = 0;
-        fvkmemory::resource_ptr<VulkanTexture> image;
-        fvkmemory::resource_ptr<VulkanDescriptorSet> set;
-        SamplerParams samplerParams;
-    };
-    // keep track of all the stream bindings
-    std::vector<StreamedTextureBinding> mStreamedTexturesBindings;
-
-    VulkanExternalImageManager* mExternalImageManager;
-};
-
-} // namespace filament::backend
-
-#endif // TNT_FILAMENT_BACKEND_CACHING_VULKANSTREAMEDIMAGEMANAGER_H

filament/backend/src/vulkan/VulkanTexture.h

@@ -36,49 +36,6 @@ namespace filament::backend {
 
 struct VulkanTexture;
 
-struct VulkanStream : public HwStream, fvkmemory::Resource {
-
-    //-- These methods are only called from the frontend
-    void acquire(const AcquiredImage& image) {
-        user_thread.mPrevious = user_thread.mAcquired;
-        user_thread.mAcquired = image;
-    }
-    bool previousNeedsRelease() const { return (user_thread.mPrevious.image != nullptr); }
-    // this function will null the previous once the caller takes it.
-    // It ensures we don't schedule for release twice.
-    AcquiredImage takePrevious() {
-        AcquiredImage previous = user_thread.mPrevious;
-        user_thread.mPrevious = {};
-        return previous;
-    }
-    const AcquiredImage& getAcquired() const { return user_thread.mAcquired; }
-    void setFrontEndTransform(const math::mat3f& transform) { user_thread.mTransform = transform; }
-    const math::mat3f& getFrontEndTransform() const { return user_thread.mTransform; }
-
-    //-- These methods are only called from the backend thread
-    void setBackendTransform(const math::mat3f& transform) { mTransform = transform; }
-    const math::mat3f& getBackEndTransform() const { return mTransform; }
-    fvkmemory::resource_ptr<VulkanTexture> getTexture(void* ahb) {
-        if (auto itr = mTextures.find(ahb); itr != mTextures.end()) {
-            return itr->second;
-        }
-        return {};
-    }
-    void pushImage(void* ahb, fvkmemory::resource_ptr<VulkanTexture> tex) { mTextures[ahb] = tex; }
-
-private:
-    // These are only called from the frontend
-    struct {
-        AcquiredImage mAcquired;
-        AcquiredImage mPrevious;
-        math::mat3f mTransform;
-    } user_thread;
-
-    // #TODO b/442937292
-    math::mat3f mTransform;
-    std::unordered_map<void*, fvkmemory::resource_ptr<VulkanTexture>> mTextures;
-};
-
 struct VulkanTextureState : public fvkmemory::Resource {
     VulkanTextureState(VulkanStagePool& stagePool, VulkanCommands* commands, VmaAllocator allocator,
             VkDevice device, VkImage image, VkDeviceMemory deviceMemory, VkFormat format,
@@ -117,8 +74,6 @@ private:
 
     // The texture with the sidecar owns the sidecar.
     fvkmemory::resource_ptr<VulkanTexture> mSidecarMSAA;
-    // The stream this texture is associated with.
-    fvkmemory::resource_ptr<VulkanStream> mStream;
 
     VkImage const mTextureImage;
     VkDeviceMemory const mTextureImageMemory;
@@ -150,7 +105,6 @@ private:
     using ImageViewHash = utils::hash::MurmurHashFn<ImageViewKey>;
     std::unordered_map<ImageViewKey, VkImageView, ImageViewHash> mCachedImageViews;
 
-
     friend struct VulkanTexture;
 };
 
@@ -228,14 +182,6 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {
         return mState->mSidecarMSAA;
     }
 
-    void setStream(fvkmemory::resource_ptr<VulkanStream> stream) {
-        mState->mStream = stream;
-    }
-
-    fvkmemory::resource_ptr<VulkanStream> getStream() const {
-        return mState->mStream;
-    }
-
     bool isTransientAttachment() const {
         return mState->mUsage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
     }

filament/backend/src/vulkan/VulkanYcbcrConversionCache.cpp

@@ -15,6 +15,7 @@
  */
 
 #include "VulkanYcbcrConversionCache.h"
+#include "VulkanSamplerStateSerializer.h"
 
 #include "vulkan/VulkanConstants.h"
 #include "vulkan/utils/Conversion.h"
@@ -53,6 +54,7 @@ VkSamplerYcbcrConversion VulkanYcbcrConversionCache::getConversion(
         .yChromaOffset = fvkutils::getChromaLocation(chroma.yChromaOffset),
         .chromaFilter = fvkutils::getFilter(chroma.chromaFilter),
     };
+    VulkanYcbcrConversionSerializer ycbcr_ser(params);
 
     // We could put this in the platform class, but that seems like a bit of an overkill
 #if defined(__ANDROID__)
@@ -73,6 +75,8 @@ VkSamplerYcbcrConversion VulkanYcbcrConversionCache::getConversion(
                                                        << " error=" << static_cast<int32_t>(result);
 
     mCache.insert({ params, conversion });
+    ConversionHashFn hashFn;
+    mConversionToKey[conversion] = hashFn(params);
     return conversion;
 }
 

filament/backend/src/vulkan/VulkanYcbcrConversionCache.h

@@ -25,6 +25,7 @@
 
 #include <bluevk/BlueVK.h>
 #include <tsl/robin_map.h>
+#include <map>
 
 namespace filament::backend {
 
@@ -40,6 +41,14 @@ public:
 
     explicit VulkanYcbcrConversionCache(VkDevice device);
     VkSamplerYcbcrConversion getConversion(Params params);
+    uint32_t getKey(VkSamplerYcbcrConversion conv) { 
+        uint32_t key = 0;
+        auto iter = mConversionToKey.find(conv);
+        if (iter != mConversionToKey.end()) {
+            key = iter->second;
+        }
+        return key;
+    }
     void terminate() noexcept;
 
 private:
@@ -54,6 +63,7 @@ private:
     };
     using ConversionHashFn = utils::hash::MurmurHashFn<Params>;
     tsl::robin_map<Params, VkSamplerYcbcrConversion, ConversionHashFn, ConversionEqualTo> mCache;
+    std::map<VkSamplerYcbcrConversion, uint32_t> mConversionToKey;
 };
 
 } // namespace filament::backend

filament/backend/src/vulkan/memory/Resource.cpp

@@ -41,7 +41,6 @@ template ResourceType getTypeEnum<VulkanBuffer>() noexcept;
 template ResourceType getTypeEnum<VulkanSync>() noexcept;
 template ResourceType getTypeEnum<VulkanMemoryMappedBuffer>() noexcept;
 template ResourceType getTypeEnum<VulkanSemaphore>() noexcept;
-template ResourceType getTypeEnum<VulkanStream>() noexcept;
 
 template<typename D>
 ResourceType getTypeEnum() noexcept {
@@ -105,9 +104,6 @@ ResourceType getTypeEnum() noexcept {
     if constexpr (std::is_same_v<D, VulkanSemaphore>) {
         return ResourceType::SEMAPHORE;
     }
-    if constexpr (std::is_same_v<D, VulkanStream>) {
-        return ResourceType::STREAM;
-    }
     return ResourceType::UNDEFINED_TYPE;
 }
 
@@ -153,8 +149,6 @@ std::string_view getTypeStr(ResourceType type) {
             return "VulkanMemoryMappedBuffer";
         case ResourceType::SEMAPHORE:
             return "Semaphore";
-        case ResourceType::STREAM:
-            return "VulkanStream";
         case ResourceType::UNDEFINED_TYPE:
             return "";
     }

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

@@ -55,8 +55,7 @@ enum class ResourceType : uint8_t {
     SYNC = 17,
     MEMORY_MAPPED_BUFFER = 18,
     SEMAPHORE = 19,
-    STREAM = 20,
-    UNDEFINED_TYPE = 21,    // Must be the last enum because we use it for iterating over the enums.
+    UNDEFINED_TYPE = 20,    // Must be the last enum because we use it for iterating over the enums.
 };
 
 template<typename D>

filament/backend/src/vulkan/memory/ResourceManager.cpp

@@ -123,9 +123,6 @@ void ResourceManager::destroyWithType(ResourceType type, HandleId id) {
         case ResourceType::SEMAPHORE:
             destruct<VulkanSemaphore>(Handle<VulkanSemaphore>(id));
             break;
-        case ResourceType::STREAM:
-            destruct<VulkanStream>(Handle<VulkanStream>(id));
-            break;
         case ResourceType::UNDEFINED_TYPE:
             break;
     }

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

@@ -228,10 +228,6 @@ ExtensionSet getDeviceExtensions(VkPhysicalDevice device) {
         VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME,
 #endif
         VK_KHR_MULTIVIEW_EXTENSION_NAME,
-
-#if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
-        VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME,
-#endif
     };
     ExtensionSet exts;
     // Identify supported physical device extensions
@@ -869,8 +865,6 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
     if (!mImpl->mSharedContext) {
         context.mDebugUtilsSupported = setContains(instExts, VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
         context.mDebugMarkersSupported = setContains(deviceExts, VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
-        context.mPipelineCreationFeedbackSupported =
-                setContains(deviceExts, VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME);
     } else {
         VulkanSharedContext const* scontext = (VulkanSharedContext const*) sharedContext;
         context.mDebugUtilsSupported = scontext->debugUtilsSupported;
@@ -879,16 +873,13 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
 
     // Check the availability of lazily allocated memory
     context.mLazilyAllocatedMemorySupported = false;
-    // RenderDoc doesn't support lazy allocated memory
-    if constexpr (!FVK_RENDERDOC_CAPTURE_MODE) {
-        for (uint32_t i = 0, typeCount = context.mMemoryProperties.memoryTypeCount; i < typeCount;
-                ++i) {
-            VkMemoryType const type = context.mMemoryProperties.memoryTypes[i];
-            if (type.propertyFlags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) {
-                context.mLazilyAllocatedMemorySupported = true;
-                assert_invariant(type.propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-                break;
-            }
+    for (uint32_t i = 0, typeCount = context.mMemoryProperties.memoryTypeCount; i < typeCount;
+         ++i) {
+        VkMemoryType const type = context.mMemoryProperties.memoryTypes[i];
+        if (type.propertyFlags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) {
+            context.mLazilyAllocatedMemorySupported = true;
+            assert_invariant(type.propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+            break;
         }
     }
 
@@ -1031,8 +1022,4 @@ VkExternalFenceHandleTypeFlagBits VulkanPlatform::getFenceExportFlags() const no
     return static_cast<VkExternalFenceHandleTypeFlagBits>(0);
 }
 
-bool VulkanPlatform::isTransientAttachmentSupported() const noexcept {
-    return mImpl->mContext.isLazilyAllocatedMemorySupported();
-}
-
 } // namespace filament::backend

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 #include <backend/platforms/VulkanPlatformAndroid.h>
 
 #include "vulkan/VulkanConstants.h"
@@ -21,8 +20,6 @@
 #include "vulkan/platform/VulkanPlatformSwapChainImpl.h"
 #include "vulkan/utils/Image.h"
 
-#include "AndroidFrameCallback.h"
-
 #include <private/backend/BackendUtilsAndroid.h>
 
 #include <backend/DriverEnums.h>
@@ -35,7 +32,6 @@
 #include <android/hardware_buffer.h>
 #include <android/native_window.h>
 
-#include <new>
 #include <utility>
 
 using namespace bluevk;
@@ -162,55 +158,7 @@ std::pair<TextureFormat, TextureUsage> getFilamentFormatAndUsage(const AHardware
     };
 }
 
-uint32_t selectMemoryTypeForExternalImage(VkPhysicalDevice physicalDevice, VkDevice device,
-        VkImage image, uint32_t types, VkFlags requiredMemoryFlags) {
-    VkPhysicalDeviceMemoryProperties memoryProperties;
-    vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memoryProperties);
-    uint32_t const memoryTypeIndex =
-            VulkanContext::selectMemoryType(memoryProperties, types, requiredMemoryFlags);
-
-    if constexpr (FVK_RENDERDOC_CAPTURE_MODE) {
-        // RenderDoc will replay external resources as non-external.
-        // Adjust properties that will trip it up when replaying, even though these are not valid.
-        // Update memory type index if necessary so that we can replay the capture.
-
-        VkMemoryRequirements imageMemoryRequirements;
-        vkGetImageMemoryRequirements(device, image, &imageMemoryRequirements);
-
-        uint32_t const imageMemoryTypeBits = imageMemoryRequirements.memoryTypeBits;
-        bool const isMemoryTypeSupported = ((1 << memoryTypeIndex) & imageMemoryTypeBits) != 0;
-        if (isMemoryTypeSupported) {
-            return memoryTypeIndex;
-        }
-
-        // Current memory type will not be replayable by RenderDoc.
-        // Attempt to change the memory type index
-        VkMemoryPropertyFlags const kRenderDocFallBackReqs = 0;
-        uint32_t commonMemoryTypeBits = types & imageMemoryTypeBits;
-        uint32_t commonTypeIndex = VulkanContext::selectMemoryType(memoryProperties,
-                commonMemoryTypeBits, kRenderDocFallBackReqs);
-        if (commonMemoryTypeBits && commonTypeIndex != VK_MAX_MEMORY_TYPES) {
-            return commonTypeIndex;
-        }
-        uint32_t imageTypeIndex = VulkanContext::selectMemoryType(memoryProperties,
-                imageMemoryTypeBits, kRenderDocFallBackReqs);
-        if (imageTypeIndex != VK_MAX_MEMORY_TYPES) {
-            return imageTypeIndex;
-        }
-    }
-
-    return memoryTypeIndex;
-}
-
-} // namespace
-
-// ---------------------------------------------------------------------------------------------
-
-struct VulkanPlatformAndroid::AndroidDetails {
-    AndroidFrameCallback androidFrameCallback;
-};
-
-// ---------------------------------------------------------------------------------------------
+}// namespace
 
 VulkanPlatformAndroid::ExternalImageVulkanAndroid::~ExternalImageVulkanAndroid() {
     if (__builtin_available(android 26, *)) {
@@ -220,19 +168,14 @@ VulkanPlatformAndroid::ExternalImageVulkanAndroid::~ExternalImageVulkanAndroid()
     }
 }
 
-// ---------------------------------------------------------------------------------------------
-
-VulkanPlatformAndroid::VulkanPlatformAndroid() :
-        mAndroidDetails(*(new(std::nothrow) AndroidDetails{})) {
+VulkanPlatformAndroid::VulkanPlatformAndroid() {
     mOSVersion = android_get_device_api_level();
     if (mOSVersion < 0) {
         mOSVersion = __ANDROID_API_FUTURE__;
     }
 }
 
-VulkanPlatformAndroid::~VulkanPlatformAndroid() noexcept {
-    delete &mAndroidDetails;
-}
+VulkanPlatformAndroid::~VulkanPlatformAndroid() noexcept = default;
 
 Platform::ExternalImageHandle VulkanPlatformAndroid::createExternalImage(
         AHardwareBuffer const* buffer, bool sRGB) noexcept {
@@ -411,6 +354,8 @@ VulkanPlatform::ImageData VulkanPlatformAndroid::createVkImageFromExternal(
             .image = image,
             .buffer = VK_NULL_HANDLE,
         };
+        VkPhysicalDeviceMemoryProperties memoryProperties;
+        vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memoryProperties);
         VkMemoryPropertyFlags requiredMemoryFlags =
                 !isExternal && any(metadata.filamentUsage & TextureUsage::UPLOADABLE)
                         ? VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
@@ -420,8 +365,8 @@ VulkanPlatform::ImageData VulkanPlatformAndroid::createVkImageFromExternal(
             requiredMemoryFlags |= VK_MEMORY_PROPERTY_PROTECTED_BIT;
         }
 
-        uint32_t const memoryTypeIndex = selectMemoryTypeForExternalImage(physicalDevice, device,
-                image, metadata.memoryTypeBits, requiredMemoryFlags);
+        uint32_t const memoryTypeIndex = VulkanContext::selectMemoryType(memoryProperties,
+                metadata.memoryTypeBits, requiredMemoryFlags);
 
         VkMemoryAllocateInfo const allocInfo = {
             .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
@@ -514,14 +459,14 @@ int VulkanPlatformAndroid::getOSVersion() const noexcept {
 }
 
 void VulkanPlatformAndroid::terminate() {
-    mAndroidDetails.androidFrameCallback.terminate();
+    mAndroidFrameCallback.terminate();
     VulkanPlatform::terminate();
 }
 
 Driver* VulkanPlatformAndroid::createDriver(void* sharedContext, DriverConfig const& driverConfig) {
     Driver* driver = VulkanPlatform::createDriver(sharedContext, driverConfig);
     if (driver) {
-        mAndroidDetails.androidFrameCallback.init();
+        mAndroidFrameCallback.init();
     }
     return driver;
 }
@@ -537,19 +482,13 @@ bool VulkanPlatformAndroid::queryCompositorTiming(SwapChain const* swapchain,
     }
 
     AndroidFrameCallback::Timeline const preferredTimeline{
-        mAndroidDetails.androidFrameCallback.getPreferredTimeline() };
+        mAndroidFrameCallback.getPreferredTimeline() };
     outCompositorTiming->frameTime = preferredTimeline.frameTime;
     outCompositorTiming->expectedPresentTime = preferredTimeline.expectedPresentTime;
     outCompositorTiming->frameTimelineDeadline = preferredTimeline.frameTimelineDeadline;
-    outCompositorTiming->compositeDeadline = CompositorTiming::INVALID;
-    outCompositorTiming->compositeInterval = CompositorTiming::INVALID;
-    outCompositorTiming->compositeToPresentLatency = CompositorTiming::INVALID;
-
-    // From this point on, we always return "success" because some timings were returned.
 
     auto vulkanSwapchain = static_cast<VulkanPlatformSwapChainBase const *>(swapchain);
-    vulkanSwapchain->queryCompositorTiming(outCompositorTiming);
-    return true;
+    return vulkanSwapchain->queryCompositorTiming(outCompositorTiming);
 }
 
 bool VulkanPlatformAndroid::setPresentFrameId(SwapChain const* swapchain, uint64_t frameId) noexcept {

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

@@ -165,11 +165,6 @@ VulkanPlatformSurfaceSwapChain::~VulkanPlatformSurfaceSwapChain() {
 VkResult VulkanPlatformSurfaceSwapChain::create() {
 #ifdef __ANDROID__
     NativeWindow::enableFrameTimestamps(static_cast<ANativeWindow*>(mNativeWindow), true);
-    // on Android, disable producer throttling
-    if (mProducerThrottling.isSupported()) {
-        mProducerThrottling.setProducerThrottlingEnabled(
-                static_cast<ANativeWindow*>(mNativeWindow), false);
-    }
 #endif
 
     VkSurfaceFormatKHR surfaceFormat = {};
@@ -361,15 +356,13 @@ bool VulkanPlatformSurfaceSwapChain::queryCompositorTiming(
         CompositorTiming* outCompositorTiming) const {
 #ifdef __ANDROID__
     // fallback to private APIs
-    if (UTILS_VERY_LIKELY(mNativeWindow)) {
-        int const status = NativeWindow::getCompositorTiming(
-                static_cast<ANativeWindow*>(mNativeWindow),
-                &outCompositorTiming->compositeDeadline,
-                &outCompositorTiming->compositeInterval,
-                &outCompositorTiming->compositeToPresentLatency);
-        if (status == 0) {
-            return true;
-        }
+    int const status = NativeWindow::getCompositorTiming(
+            static_cast<ANativeWindow*>(mNativeWindow),
+            &outCompositorTiming->compositeDeadline,
+            &outCompositorTiming->compositeInterval,
+            &outCompositorTiming->compositeToPresentLatency);
+    if (status == 0) {
+        return true;
     }
 #endif
     return VulkanPlatformSwapChainBase::queryCompositorTiming(outCompositorTiming);

filament/backend/src/vulkan/platform/VulkanPlatformSwapChainImpl.h

@@ -25,8 +25,7 @@
 #include <bluevk/BlueVK.h>
 
 #ifdef __ANDROID__
-#include "AndroidSwapChainHelper.h"
-#include "AndroidNativeWindow.h"
+#include <AndroidSwapChainHelper.h>
 #endif
 
 #include <unordered_map>
@@ -123,7 +122,6 @@ private:
 
 #ifdef __ANDROID__
     AndroidSwapChainHelper mImpl{};
-    AndroidProducerThrottling mProducerThrottling;
 #endif
 };
 

filament/backend/src/vulkan/utils/Image.cpp

@@ -18,12 +18,6 @@
 
 #include "vulkan/VulkanTexture.h"
 
-#if defined(__ANDROID__)
-#include "backend/platforms/VulkanPlatformAndroid.h"
-#include <android/hardware_buffer.h>
-#include <android/native_window.h>
-#endif
-
 #include <utils/Panic.h>
 #include <utils/algorithm.h>
 #include <utils/debug.h>
@@ -240,19 +234,6 @@ uint8_t reduceSampleCount(uint8_t sampleCount, VkSampleCountFlags mask) {
     return mostSignificantBit((sampleCount - 1) & mask);
 }
 
-filament::backend::Platform::ExternalImageHandle createExternalImageFromRaw(
-        filament::backend::VulkanPlatform* platform, void* image, bool sRGB) {
-
-#if defined(__ANDROID__)
-    if (__builtin_available(android 26, *)) {
-        return static_cast<filament::backend::VulkanPlatformAndroid*>(platform)
-                ->createExternalImage(reinterpret_cast<AHardwareBuffer const*>(image), sRGB);
-    }
-#endif
-    return {};
-
-}
-
 } // namespace filament::backend::fvkutils
 
 bool operator<(const VkImageSubresourceRange& a, const VkImageSubresourceRange& b) {

filament/backend/src/vulkan/utils/Image.h

@@ -18,7 +18,6 @@
 #define TNT_FILAMENT_BACKEND_VULKAN_UTILS_IMAGE_H
 
 #include <backend/DriverEnums.h>
-#include <backend/platforms/VulkanPlatform.h>
 
 #include <utils/Log.h>
 
@@ -107,9 +106,6 @@ VkImageAspectFlags getImageAspect(VkFormat format);
 
 uint8_t reduceSampleCount(uint8_t sampleCount, VkSampleCountFlags mask);
 
-Platform::ExternalImageHandle createExternalImageFromRaw(filament::backend::VulkanPlatform* platform,
-        void* image,
-        bool sRGB);
 } // namespace fvkutils
 
 } // namespace filament::backend

filament/include/filament/Renderer.h

@@ -113,10 +113,8 @@ public:
     /**
      * Retrieve a history of frame timing information. The maximum frame history size is
      * given by getMaxFrameHistorySize().
-     * All or part of the history can be lost when using a different SwapChain in beginFrame().
      * @param historySize requested history size. The returned vector could be smaller.
      * @return A vector of FrameInfo.
-     * @see beginFrame()
      */
     utils::FixedCapacityVector<FrameInfo> getFrameInfoHistory(
             size_t historySize = 1) const noexcept;
@@ -328,8 +326,6 @@ public:
      *                                 or 0 if unknown. This value should be the timestamp of
      *                                 the last h/w vsync. It is expressed in the
      *                                 std::chrono::steady_clock time base.
-     *                                 On Android this should be the frame time received from
-     *                                 a Choreographer.
      * @param swapChain A pointer to the SwapChain instance to use.
      *
      * @return
@@ -341,8 +337,6 @@ public:
      *
      * @note
      * All calls to render() must happen *after* beginFrame().
-     * It is recommended to use the same swapChain for every call to beginFrame, failing to do
-     * so can result is losing all or part of the FrameInfo history.
      *
      * @see
      * endFrame()

filament/src/PostProcessManager.cpp

@@ -258,10 +258,6 @@ void PostProcessManager::bindPerRenderableDescriptorSet(DriverApi& driver) const
             { { 0, 0 }, driver });
 }
 
-UboManager* PostProcessManager::getUboManager() const noexcept {
-    return mEngine.getUboManager();
-}
-
 UTILS_NOINLINE
 void PostProcessManager::registerPostProcessMaterial(std::string_view const name,
         StaticMaterialInfo const& info) {
@@ -517,7 +513,7 @@ UTILS_NOINLINE
 void PostProcessManager::commitAndRenderFullScreenQuad(DriverApi& driver,
         FrameGraphResources::RenderPassInfo const& out, FMaterialInstance const* mi,
         PostProcessVariant const variant) const noexcept {
-    mi->commit(driver, getUboManager());
+    mi->commit(driver);
     mi->use(driver);
     FMaterial const* const ma = mi->getMaterial();
     PipelineState const pipeline = getPipelineState(ma, variant);
@@ -649,7 +645,7 @@ PostProcessManager::StructurePassOutput PostProcessManager::structure(FrameGraph
                     auto th = driver.createTextureView(in, level, 1);
                     mi->setParameter("depth", th, SamplerParams{
                         .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
-                    mi->commit(driver, getUboManager());
+                    mi->commit(driver);
                     mi->use(driver);
                     renderFullScreenQuad(out, pipeline, driver);
                     DescriptorSet::unbind(driver, DescriptorSetBindingPoints::PER_MATERIAL);
@@ -1083,7 +1079,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::screenSpaceAmbientOcclusion(
                 mi->setParameter("ssctRayCount",
                         float2{ options.ssct.rayCount, 1.0f / float(options.ssct.rayCount) });
 
-                mi->commit(driver, getUboManager());
+                mi->commit(driver);
                 mi->use(driver);
 
                 auto pipeline = getPipelineState(ma);
@@ -1204,7 +1200,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::bilateralBlurPass(FrameGraph
                 mi->setParameter("sampleCount", kGaussianCount);
                 mi->setParameter("farPlaneOverEdgeDistance", -zf / config.bilateralThreshold);
 
-                mi->commit(driver, getUboManager());
+                mi->commit(driver);
                 mi->use(driver);
 
                 auto pipeline = getPipelineState(ma);
@@ -1899,7 +1895,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::dof(FrameGraph& fg,
                             .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
                     mi->setParameter("weightScale", 0.5f / float(1u << level));   // FIXME: halfres?
                     mi->setParameter("texelSize", float2{ 1.0f / w, 1.0f / h });
-                    mi->commit(driver, getUboManager());
+                    mi->commit(driver);
                     mi->use(driver);
 
                     renderFullScreenQuad(out, pipeline, driver);
@@ -2429,7 +2425,7 @@ PostProcessManager::BloomPassOutput PostProcessManager::bloom(FrameGraph& fg,
                     mi->setParameter("source", hwOutView, SamplerParams{
                             .filterMag = SamplerMagFilter::LINEAR,
                             .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST});
-                    mi->commit(driver, getUboManager());
+                    mi->commit(driver);
                     mi->use(driver);
                     renderFullScreenQuad(hwDstRT, pipeline, driver);
                     DescriptorSet::unbind(driver, DescriptorSetBindingPoints::PER_MATERIAL);
@@ -2537,7 +2533,7 @@ void PostProcessManager::colorGradingPrepareSubpass(DriverApi& driver,
     FMaterialInstance* const mi =
             configureColorGradingMaterial(material, colorGrading, colorGradingConfig,
                     vignetteOptions, width, height);
-    mi->commit(driver, getUboManager());
+    mi->commit(driver);
 }
 
 void PostProcessManager::colorGradingSubpass(DriverApi& driver,
@@ -2570,7 +2566,7 @@ void PostProcessManager::customResolvePrepareSubpass(DriverApi& driver, CustomRe
     auto [mi, fixedIndex] = mMaterialInstanceManager.getFixedMaterialInstance(ma);
     mFixedMaterialInstanceIndex.customResolve = fixedIndex;
     mi->setParameter("direction", op == CustomResolveOp::COMPRESS ? 1.0f : -1.0f),
-    mi->commit(driver, getUboManager());
+    mi->commit(driver);
     material.getMaterial(mEngine);
 }
 
@@ -2623,7 +2619,7 @@ void PostProcessManager::clearAncillaryBuffersPrepare(DriverApi& driver) noexcep
     auto ma = material.getMaterial(mEngine, PostProcessVariant::OPAQUE);
     auto [mi, fixedIndex] = mMaterialInstanceManager.getFixedMaterialInstance(ma);
     mFixedMaterialInstanceIndex.clearDepth = fixedIndex;
-    mi->commit(driver, getUboManager());
+    mi->commit(driver);
     material.getMaterial(mEngine);
 }
 
@@ -3115,7 +3111,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::taa(FrameGraph& fg,
                         mat4f{ historyProjection * inverse(current.projection) } *
                         normalizedToClip);
 
-                mi->commit(driver, getUboManager());
+                mi->commit(driver);
                 mi->use(driver);
 
                 if (colorGradingConfig.asSubpass) {
@@ -3200,7 +3196,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::rcas(
                 mi->setParameter("resolution", float4{
                         outputDesc.width, outputDesc.height,
                         1.0f / outputDesc.width, 1.0f / outputDesc.height });
-                mi->commit(driver, getUboManager());
+                mi->commit(driver);
                 mi->use(driver);
 
                 auto pipeline = getPipelineState(material.getMaterial(mEngine), variant);
@@ -3291,7 +3287,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleBilinear(FrameGraph&
                         float(vp.width)  / inputDesc.width,
                         float(vp.height) / inputDesc.height
                 });
-                mi->commit(driver, getUboManager());
+                mi->commit(driver);
                 mi->use(driver);
 
                 auto out = resources.getRenderPassInfo();
@@ -3378,7 +3374,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleSGSR1(FrameGraph& fg,
                         float(inputDesc.height)
                 });
 
-                mi->commit(driver, getUboManager());
+                mi->commit(driver);
                 mi->use(driver);
 
                 auto const out = resources.getRenderPassInfo();
@@ -3473,7 +3469,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleFSR1(FrameGraph& fg,
                     mi->setParameter("resolution",
                             float4{ outputDesc.width, outputDesc.height,
                                     1.0f / outputDesc.width, 1.0f / outputDesc.height });
-                    mi->commit(driver, getUboManager());
+                    mi->commit(driver);
                     mi->use(driver);
                 }
 
@@ -3500,7 +3496,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscaleFSR1(FrameGraph& fg,
                             float(vp.width)  / inputDesc.width,
                             float(vp.height) / inputDesc.height
                     });
-                    mi->commit(driver, getUboManager());
+                    mi->commit(driver);
                     mi->use(driver);
                 }
 
@@ -3586,7 +3582,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::blit(FrameGraph& fg, bool co
                 if (layer) {
                     mi->setParameter("layerIndex", layer);
                 }
-                mi->commit(driver, getUboManager());
+                mi->commit(driver);
                 mi->use(driver);
 
                 auto pipeline = getPipelineState(ma);
@@ -3844,7 +3840,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::vsmMipmapPass(FrameGraph& fg
                 });
                 mi->setParameter("layer", uint32_t(layer));
                 mi->setParameter("uvscale", 1.0f / float(dim));
-                mi->commit(driver, getUboManager());
+                mi->commit(driver);
                 mi->use(driver);
 
                 renderFullScreenQuadWithScissor(out, pipeline, scissor, driver);
@@ -3946,7 +3942,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::debugCombineArrayTexture(Fra
                         float(vp.width) / inputDesc.width,
                         float(vp.height) / inputDesc.height
                     });
-                mi->commit(driver, getUboManager());
+                mi->commit(driver);
                 mi->use(driver);
 
                 auto pipeline = getPipelineState(ma);
@@ -3963,7 +3959,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::debugCombineArrayTexture(Fra
                 // Render all layers of the texture to the screen side-by-side.
                 for (uint32_t i = 0; i < inputTextureDesc.depth; ++i) {
                     mi->setParameter("layerIndex", i);
-                    mi->commit(driver, getUboManager());
+                    mi->commit(driver);
                     renderFullScreenQuad(out, pipeline, driver);
                     DescriptorSet::unbind(driver, DescriptorSetBindingPoints::PER_MATERIAL);
                     // From the second draw, don't clear the targetbuffer.

filament/src/PostProcessManager.h

@@ -65,7 +65,6 @@ class FMaterialInstance;
 class FrameGraph;
 class RenderPass;
 class RenderPassBuilder;
-class UboManager;
 struct CameraInfo;
 
 class PostProcessManager {
@@ -423,8 +422,6 @@ private:
         return getMaterialInstance(ma);
     }
 
-    UboManager* getUboManager() const noexcept;
-
     backend::RenderPrimitiveHandle mFullScreenQuadRph;
     backend::VertexBufferInfoHandle mFullScreenQuadVbih;
     backend::DescriptorSetLayoutHandle mPerRenderableDslh;

filament/src/RenderPass.cpp

@@ -1012,8 +1012,6 @@ void RenderPass::Executor::execute(FEngine const& engine, DriverApi& driver,
                     uint32_t const index = (first->key & CUSTOM_INDEX_MASK) >> CUSTOM_INDEX_SHIFT;
                     assert_invariant(index < mCustomCommands.size());
                     pCustomCommands[index]();
-                    currentPipeline = {};
-                    currentPrimitiveHandle ={};
                     continue;
                 }
 
@@ -1071,34 +1069,26 @@ void RenderPass::Executor::execute(FEngine const& engine, DriverApi& driver,
                     pipeline.pipelineLayout.setLayout[+DescriptorSetBindingPoints::PER_MATERIAL] =
                             ma->getDescriptorSetLayout(info.materialVariant).getHandle();
 
-                    // If we have a ColorPassDescriptorSet we use it to bind the per-view
-                    // descriptor-set (ideally only if it changed).
-                    // If we don't, it means the descriptor-set is already bound and the layout we
-                    // got from the material above should match. This is the case for situations
-                    // where we have a known per-view descriptor-set layout,
-                    // e.g.: postfx, shadow-maps, ssr and structure passes.
-                    if (mColorPassDescriptorSet) {
-                        if (UTILS_UNLIKELY(ma->getMaterialDomain() == MaterialDomain::POST_PROCESS)) {
-                            // It is possible to get a post-process material here (even though it's
-                            // not technically a public API yet, it is used by the IBLPrefilterLibrary.
-                            // Ideally we would have a more formal compute API). In this case, we need
-                            // to set the post-process descriptor-set.
-                            engine.getPostProcessManager().bindPostProcessDescriptorSet(driver);
-                        } else {
+
+                    if (UTILS_UNLIKELY(ma->getMaterialDomain() == MaterialDomain::POST_PROCESS)) {
+                        // It is possible to get a post-process material here (even though it's
+                        // not technically a public API yet, it is used by the IBLPrefilterLibrary.
+                        // Ideally we would have a more formal compute API). In this case, we need
+                        // to set the post-process descriptor-set.
+                        engine.getPostProcessManager().bindPostProcessDescriptorSet(driver);
+                    } else {
+                        // If we have a ColorPassDescriptorSet we use it to bind the per-view
+                        // descriptor-set (ideally only if it changed). If we don't, it means
+                        // the descriptor-set is already bound and the layout we got from the
+                        // material above should match. This is the case for situations where we
+                        // have a known per-view descriptor-set layout, e.g.: shadow-maps, ssr and
+                        // structure passes.
+                        if (mColorPassDescriptorSet) {
                             // We have a ColorPassDescriptorSet, we need to go through it for binding
                             // the per-view descriptor-set because its layout can change based on the
                             // material.
                             mColorPassDescriptorSet->bind(driver, ma->getPerViewLayoutIndex());
                         }
-                    } else {
-                        // if we're here it means the per-view descriptor set is constant and
-                        // already set. This will be the case for postfx, ssr, structure and
-                        // shadow passes. All these passes use a static descriptor set layout
-                        // (albeit potentially different for each pass). In particular the
-                        // per-view UBO must be compatible for all material domains.
-                        // This is the case by construction for postfx, ssr. However, shadows
-                        // and structure have their own UBO, but it's content is (must be)
-                        // compatible with POST_PROCESS and COMPUTE materials.
                     }
 
                     // Each MaterialInstance has its own descriptor set. This binds it.

filament/src/details/BufferAllocator.cpp

@@ -16,7 +16,6 @@
 
 #include "details/BufferAllocator.h"
 
-#include <private/utils/Tracing.h>
 #include <utils/Panic.h>
 #include <utils/debug.h>
 
@@ -143,11 +142,7 @@ void BufferAllocator::retire(AllocationId id) {
     InternalSlotNode* targetNode = getNodeById(id);
     assert_invariant(targetNode != nullptr);
 
-    Slot& slot = targetNode->slot;
-    slot.isAllocated = false;
-    if (slot.gpuUseCount == 0) {
-        mHasPendingFrees = true;
-    }
+    targetNode->slot.isAllocated = false;
 }
 
 void BufferAllocator::acquireGpu(AllocationId id) {
@@ -162,19 +157,10 @@ void BufferAllocator::releaseGpu(AllocationId id) {
     assert_invariant(targetNode != nullptr);
     assert_invariant(targetNode->slot.gpuUseCount > 0);
 
-    Slot& slot = targetNode->slot;
-    slot.gpuUseCount--;
-    if (slot.gpuUseCount == 0 && !slot.isAllocated) {
-        mHasPendingFrees = true;
-    }
+    targetNode->slot.gpuUseCount--;
 }
 
 void BufferAllocator::releaseFreeSlots() {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    if (!mHasPendingFrees) {
-        return;
-    }
-
     auto curr = mSlotPool.begin();
     while (curr != mSlotPool.end()) {
         if (!curr->slot.isFree()) {
@@ -213,7 +199,6 @@ void BufferAllocator::releaseFreeSlots() {
 
         curr = next;
     }
-    mHasPendingFrees = false;
 }
 
 BufferAllocator::allocation_size_t BufferAllocator::getTotalSize() const noexcept {

filament/src/details/BufferAllocator.h

@@ -113,9 +113,8 @@ private:
 
     [[nodiscard]] InternalSlotNode* getNodeById(AllocationId id) const noexcept;
 
-    bool mHasPendingFrees = false;
     allocation_size_t mTotalSize;
-    const allocation_size_t mSlotSize; // Size of a single slot in bytes
+    const allocation_size_t mSlotSize; // Size of a single slot in bytes.
     std::list<InternalSlotNode> mSlotPool; // All slots, including both allocated and freed
     std::multimap</*slot size*/allocation_size_t, InternalSlotNode*> mFreeList;
     std::unordered_map</*slot offset*/allocation_size_t, InternalSlotNode*> mOffsetMap;

filament/src/details/Engine.cpp

@@ -468,26 +468,11 @@ void FEngine::init() {
         }
         mDefaultMaterial = downcast(defaultMaterialBuilder.build(*this));
     }
-
     // We must commit the default material instance here. It may not be used in a scene, but its
     // descriptor set may still be used for shared variants.
-    //
-    // Note that this material instance is instantiated before the creation of UboManager, so at
-    // this point `isUboBatchingEnabled` is `false`, and it will fall back to individual UBO
-    // automatically.
-    mDefaultMaterial->getDefaultInstance()->commit(driverApi, mUboManager);
+    mDefaultMaterial->getDefaultInstance()->commit(driverApi);
 
     if (UTILS_UNLIKELY(getSupportedFeatureLevel() >= FeatureLevel::FEATURE_LEVEL_1)) {
-        // UBO batching is not supported in feature level 0
-        if (features.material.enable_material_instance_uniform_batching) {
-            // Ubo size of each material instance is at least 16 bytes.
-            constexpr BufferAllocator::allocation_size_t minSlotSize = 16;
-            auto const uboOffsetAlignment = static_cast<BufferAllocator::allocation_size_t>(
-                    driverApi.getUniformBufferOffsetAlignment());
-            BufferAllocator::allocation_size_t slotSize = std::max(minSlotSize, uboOffsetAlignment);
-            mUboManager = new UboManager(getDriverApi(), slotSize, mConfig.sharedUboInitialSizeInBytes);
-        }
-
         mDefaultColorGrading = downcast(ColorGrading::Builder().build(*this));
 
         constexpr float3 dummyPositions[1] = {};
@@ -668,12 +653,6 @@ void FEngine::shutdown() {
 
     driver.destroyRenderTarget(std::move(mDefaultRenderTarget));
 
-    if (isUboBatchingEnabled()) {
-        mUboManager->terminate(driver);
-        delete mUboManager;
-        mUboManager = nullptr;
-    }
-
     /*
      * Shutdown the backend...
      */
@@ -714,30 +693,18 @@ void FEngine::prepare() {
     // UBOs that are visible only. It's not such a big issue because the actual upload() is
     // skipped if the UBO hasn't changed. Still we could have a lot of these.
     DriverApi& driver = getDriverApi();
-    const bool useUboBatching = isUboBatchingEnabled();
 
-    if (useUboBatching) {
-        assert_invariant(mUboManager != nullptr);
-        mUboManager->beginFrame(driver);
-    }
-
-    UboManager* uboManager = mUboManager;
     for (auto& materialInstanceList: mMaterialInstances) {
-        materialInstanceList.second.forEach([&driver, uboManager](FMaterialInstance* item) {
+        materialInstanceList.second.forEach([&driver](FMaterialInstance* item) {
             // post-process materials instances must be commited explicitly because their
             // parameters are typically not set at this point in time.
             if (item->getMaterial()->getMaterialDomain() == MaterialDomain::SURFACE) {
                 item->commitStreamUniformAssociations(driver);
-                item->commit(driver, uboManager);
+                item->commit(driver);
             }
         });
     }
 
-    if (useUboBatching) {
-        assert_invariant(mUboManager != nullptr);
-        getUboManager()->finishBeginFrame(getDriverApi());
-    }
-
     mMaterials.forEach([](FMaterial* material) {
 #if FILAMENT_ENABLE_MATDBG // NOLINT(*-include-cleaner)
         material->checkProgramEdits();
@@ -754,13 +721,6 @@ void FEngine::gc() {
     mCameraManager.gc(*this, em);
 }
 
-void FEngine::submitFrame() {
-    if (isUboBatchingEnabled()) {
-        DriverApi& driver = getDriverApi();
-        getUboManager()->endFrame(driver);
-    }
-}
-
 void FEngine::flush() {
     // flush the command buffer
     flushCommandBuffer(mCommandBufferQueue);
@@ -991,10 +951,9 @@ FMaterialInstance* FEngine::createMaterialInstance(const FMaterial* material,
     return p;
 }
 
-FMaterialInstance* FEngine::createMaterialInstance(const FMaterial* material, const char* name,
-        UboBatchingMode batchingMode) noexcept {
-    FMaterialInstance* p =
-            mHeapAllocator.make<FMaterialInstance>(*this, material, name, batchingMode);
+FMaterialInstance* FEngine::createMaterialInstance(const FMaterial* material,
+                                                   const char* name) noexcept {
+    FMaterialInstance* p = mHeapAllocator.make<FMaterialInstance>(*this, material, name);
     if (UTILS_LIKELY(p)) {
         auto pos = mMaterialInstances.emplace(material, "MaterialInstance");
         pos.first->second.insert(p);

filament/src/details/Engine.h

@@ -21,17 +21,16 @@
 
 #include "Allocators.h"
 #include "DFG.h"
+#include "PostProcessManager.h"
+#include "ResourceList.h"
 #include "HwDescriptorSetLayoutFactory.h"
 #include "HwVertexBufferInfoFactory.h"
 #include "MaterialCache.h"
-#include "PostProcessManager.h"
-#include "ResourceList.h"
-#include "UboManager.h"
 
 #include "components/CameraManager.h"
 #include "components/LightManager.h"
-#include "components/RenderableManager.h"
 #include "components/TransformManager.h"
+#include "components/RenderableManager.h"
 
 #include "ds/DescriptorSetLayout.h"
 
@@ -264,14 +263,6 @@ public:
         return mBackend;
     }
 
-    bool isUboBatchingEnabled() const noexcept {
-        return mUboManager != nullptr;
-    }
-
-    UboManager* getUboManager() noexcept {
-        return mUboManager;
-    }
-
     Platform* getPlatform() const noexcept {
         return mPlatform;
     }
@@ -345,21 +336,11 @@ public:
 
     FRenderer* createRenderer() noexcept;
 
-    // Defines whether a material instance should use UBO batching or not.
-    enum class UboBatchingMode {
-        // For default, it follows the engine settings.
-        // If UBO batching is enabled on the engine and the material domain is not SURFACE, it
-        // turns on the UBO batching. Otherwise, it turns off the UBO batching.
-        DEFAULT,
-        NO_UBO_BATCHING,
-        UBO_BATCHING
-    };
-
     FMaterialInstance* createMaterialInstance(const FMaterial* material,
             const FMaterialInstance* other, const char* name) noexcept;
 
-    FMaterialInstance* createMaterialInstance(const FMaterial* material, const char* name,
-            UboBatchingMode batchingMode) noexcept;
+    FMaterialInstance* createMaterialInstance(const FMaterial* material,
+                                              const char* name) noexcept;
 
     FScene* createScene() noexcept;
     FView* createView() noexcept;
@@ -465,7 +446,6 @@ public:
 
     void prepare();
     void gc();
-    void submitFrame();
 
     using ShaderContent = utils::FixedCapacityVector<uint8_t>;
 
@@ -670,7 +650,6 @@ private:
 
     uint32_t mFlushCounter = 0;
 
-    UboManager* mUboManager = nullptr;
     RootArenaScope::Arena mPerRenderPassArena;
     HeapAllocatorArena mHeapAllocator;
 
@@ -780,7 +759,7 @@ public:
                 bool assert_texture_can_generate_mipmap = CORRECTNESS_ASSERTION_DEFAULT;
             } debug;
             struct {
-                bool disable_gpu_frame_complete_metric = true;
+                bool disable_gpu_frame_complete_metric = false;
             } frame_info;
         } engine;
         struct {

filament/src/details/Material.cpp

@@ -73,7 +73,6 @@ namespace filament {
 using namespace backend;
 using namespace filaflat;
 using namespace utils;
-using UboBatchingMode = FEngine::UboBatchingMode;
 
 struct Material::BuilderDetails {
     const void* mPayload = nullptr;
@@ -218,17 +217,16 @@ void FMaterial::terminate(FEngine& engine) {
 
 filament::DescriptorSetLayout const& FMaterial::getPerViewDescriptorSetLayout(
         Variant const variant, bool const useVsmDescriptorSetLayout) const noexcept {
-    if (mDefinition.materialDomain == MaterialDomain::SURFACE) {
-        // `variant` is only sensical for MaterialDomain::SURFACE
-        if (Variant::isValidDepthVariant(variant)) {
-            return mEngine.getPerViewDescriptorSetLayoutDepthVariant();
-        }
-        if (Variant::isSSRVariant(variant)) {
-            return mEngine.getPerViewDescriptorSetLayoutSsrVariant();
-        }
+    if (Variant::isValidDepthVariant(variant)) {
+        assert_invariant(mDefinition.materialDomain == MaterialDomain::SURFACE);
+        return mEngine.getPerViewDescriptorSetLayoutDepthVariant();
+    }
+    if (Variant::isSSRVariant(variant)) {
+        assert_invariant(mDefinition.materialDomain == MaterialDomain::SURFACE);
+        return mEngine.getPerViewDescriptorSetLayoutSsrVariant();
     }
-    // mDefinition.perViewDescriptorSetLayout{Vsm} is already resolved for MaterialDomain
     if (useVsmDescriptorSetLayout) {
+        assert_invariant(mDefinition.materialDomain == MaterialDomain::SURFACE);
         return mDefinition.perViewDescriptorSetLayoutVsm;
     }
     return mDefinition.perViewDescriptorSetLayout;
@@ -282,14 +280,14 @@ FMaterialInstance* FMaterial::createInstance(const char* name) const noexcept {
         return FMaterialInstance::duplicate(mDefaultMaterialInstance, name);
     } else {
         // but if we don't, just create an instance with all the default parameters
-        return mEngine.createMaterialInstance(this, name, UboBatchingMode::DEFAULT);
+        return mEngine.createMaterialInstance(this, name);
     }
 }
 
 FMaterialInstance* FMaterial::getDefaultInstance() noexcept {
     if (UTILS_UNLIKELY(!mDefaultMaterialInstance)) {
-        mDefaultMaterialInstance =
-                mEngine.createMaterialInstance(this, mDefinition.name.c_str(), UboBatchingMode::DEFAULT);
+        mDefaultMaterialInstance = mEngine.createMaterialInstance(this,
+                mDefinition.name.c_str());
         mDefaultMaterialInstance->setDefaultInstance(true);
     }
     return mDefaultMaterialInstance;

filament/src/details/Material.h

@@ -108,7 +108,7 @@ public:
             backend::CallbackHandler* handler,
             utils::Invocable<void(Material*)>&& callback) noexcept;
 
-    // Creates an instance of this material, specifying the batching mode.
+    // Create an instance of this material
     FMaterialInstance* createInstance(const char* name) const noexcept;
 
     bool hasParameter(const char* name) const noexcept;

filament/src/details/MaterialInstance.cpp

@@ -58,19 +58,15 @@ using namespace utils;
 namespace filament {
 
 using namespace backend;
-using UboBatchingMode = FEngine::UboBatchingMode;
 
-bool shouldEnableBatching(FEngine& engine, UboBatchingMode batchingMode, MaterialDomain domain) {
-    if (batchingMode != UboBatchingMode::DEFAULT) {
-        return batchingMode == UboBatchingMode::UBO_BATCHING;
-    }
-
-    return engine.isUboBatchingEnabled() && domain == MaterialDomain::SURFACE;
+FMaterialInstance::FMaterialInstance(FEngine& engine, FMaterial const* material,
+        const char* name) noexcept
+        : FMaterialInstance(engine, material, name,
+                  engine.features.material.enable_material_instance_uniform_batching) {
 }
 
-FMaterialInstance::FMaterialInstance(FEngine& engine, FMaterial const* material, const char* name,
-        UboBatchingMode batchingMode) noexcept
-        : mMaterial(material),
+FMaterialInstance::FMaterialInstance(FEngine& engine, FMaterial const* material,
+                      const char* name, bool useUboBatching) noexcept : mMaterial(material),
           mDescriptorSet("MaterialInstance", material->getDescriptorSetLayout()),
           mCulling(CullingMode::BACK),
           mShadowCulling(CullingMode::BACK),
@@ -80,12 +76,10 @@ FMaterialInstance::FMaterialInstance(FEngine& engine, FMaterial const* material,
           mHasScissor(false),
           mIsDoubleSided(false),
           mIsDefaultInstance(false),
-          mUseUboBatching(
-                  shouldEnableBatching(engine, batchingMode, material->getMaterialDomain())),
+          mUseUboBatching(useUboBatching),
           mTransparencyMode(TransparencyMode::DEFAULT),
           mName(name ? CString(name) : material->getName()) {
-    FILAMENT_CHECK_PRECONDITION(!mUseUboBatching || engine.isUboBatchingEnabled())
-            << "UBO batching is not enabled.";
+
     FEngine::DriverApi& driver = engine.getDriverApi();
 
     // even if the material doesn't have any parameters, we allocate a small UBO because it's
@@ -95,7 +89,6 @@ FMaterialInstance::FMaterialInstance(FEngine& engine, FMaterial const* material,
 
     if (mUseUboBatching) {
         mUboData = BufferAllocator::UNALLOCATED;
-        engine.getUboManager()->manageMaterialInstance(this);
     } else {
         mUboData = driver.createBufferObject(mUniforms.getSize(), BufferObjectBinding::UNIFORM,
                 BufferUsage::STATIC, ImmutableCString{ material->getName().c_str_safe() });
@@ -160,7 +153,7 @@ FMaterialInstance::FMaterialInstance(FEngine& engine,
           mUseUboBatching(other->mUseUboBatching),
           mScissorRect(other->mScissorRect),
           mName(name ? CString(name) : other->mName) {
-    assert_invariant(!mUseUboBatching || engine.isUboBatchingEnabled());
+
     FEngine::DriverApi& driver = engine.getDriverApi();
     FMaterial const* const material = other->getMaterial();
 
@@ -168,7 +161,6 @@ FMaterialInstance::FMaterialInstance(FEngine& engine,
 
     if (mUseUboBatching) {
         mUboData = BufferAllocator::UNALLOCATED;
-        engine.getUboManager()->manageMaterialInstance(this);
     } else {
         mUboData = driver.createBufferObject(mUniforms.getSize(), BufferObjectBinding::UNIFORM,
                 BufferUsage::DYNAMIC, ImmutableCString{ material->getName().c_str_safe() });
@@ -201,8 +193,8 @@ FMaterialInstance::FMaterialInstance(FEngine& engine,
     }
 }
 
-FMaterialInstance* FMaterialInstance::duplicate(FMaterialInstance const* other,
-        const char* name) noexcept {
+FMaterialInstance* FMaterialInstance::duplicate(
+        FMaterialInstance const* other, const char* name) noexcept {
     FMaterial const* const material = other->getMaterial();
     FEngine& engine = material->getEngine();
     return engine.createMaterialInstance(material, other, name);
@@ -213,10 +205,6 @@ FMaterialInstance::~FMaterialInstance() noexcept = default;
 void FMaterialInstance::terminate(FEngine& engine) {
     FEngine::DriverApi& driver = engine.getDriverApi();
     mDescriptorSet.terminate(driver);
-    if (mUseUboBatching) {
-        engine.getUboManager()->unmanageMaterialInstance(this);
-    }
-
     auto* ubHandle = std::get_if<Handle<HwBufferObject>>(&mUboData);
     if (ubHandle){
         driver.destroyBufferObject(*ubHandle);
@@ -250,21 +238,15 @@ void FMaterialInstance::commitStreamUniformAssociations(FEngine::DriverApi& driv
 
 void FMaterialInstance::commit(FEngine& engine) const {
     if (UTILS_LIKELY(mMaterial->getMaterialDomain() != MaterialDomain::SURFACE)) {
-        commit(engine.getDriverApi(), engine.getUboManager());
+        commit(engine.getDriverApi());
     }
 }
 
-void FMaterialInstance::commit(FEngine::DriverApi& driver, UboManager* uboManager) const {
+void FMaterialInstance::commit(FEngine::DriverApi& driver) const {
     if (mUniforms.isDirty() || mHasStreamUniformAssociations) {
         mUniforms.clean();
         if (mUseUboBatching) {
-            assert_invariant(uboManager != nullptr);
-            if (!BufferAllocator::isValid(getAllocationId())) {
-                // The allocation hasn't happened yet, return.
-                return;
-            }
-
-            uboManager->updateSlot(driver, getAllocationId(), mUniforms.toBufferDescriptor(driver));
+            // TODO: update the content by `copyToMemoryMappedBuffer`
         }
         else {
             auto* ubHandle = std::get_if<Handle<HwBufferObject>>(&mUboData);
@@ -289,10 +271,6 @@ void FMaterialInstance::commit(FEngine::DriverApi& driver, UboManager* uboManage
     // TODO: eventually we should remove this in RELEASE builds
     fixMissingSamplers();
 
-    if (mUseUboBatching && !BufferAllocator::isValid(getAllocationId())) {
-        return;
-    }
-
     // Commit descriptors if needed (e.g. when textures are updated,or the first time)
     mDescriptorSet.commit(mMaterial->getDescriptorSetLayout(), driver);
 }
@@ -435,13 +413,6 @@ const char* FMaterialInstance::getName() const noexcept {
 // ------------------------------------------------------------------------------------------------
 
 void FMaterialInstance::use(FEngine::DriverApi& driver, Variant variant) const {
-    if (!mDescriptorSet.getHandle()) {
-        return;
-    }
-
-    if (mUseUboBatching && !BufferAllocator::isValid(getAllocationId())) {
-        return;
-    }
 
     if (UTILS_UNLIKELY(mMissingSamplerDescriptors.any())) {
         std::call_once(mMissingSamplersFlag, [this] {
@@ -468,8 +439,7 @@ void FMaterialInstance::use(FEngine::DriverApi& driver, Variant variant) const {
         return;
     }
 
-    mDescriptorSet.bind(driver, DescriptorSetBindingPoints::PER_MATERIAL,
-            { { mUboOffset }, driver });
+    mDescriptorSet.bind(driver, DescriptorSetBindingPoints::PER_MATERIAL);
 }
 
 void FMaterialInstance::assignUboAllocation(
@@ -479,10 +449,8 @@ void FMaterialInstance::assignUboAllocation(
     assert_invariant(mUseUboBatching);
 
     mUboData = id;
-    mUboOffset = offset;
     if (BufferAllocator::isValid(id)) {
-        // Use dynamic offset during binding, so the offset here is always zero.
-        mDescriptorSet.setBuffer(mMaterial->getDescriptorSetLayout(), 0, ubHandle, 0,
+        mDescriptorSet.setBuffer(mMaterial->getDescriptorSetLayout(), 0, ubHandle, offset,
                 mUniforms.getSize());
     }
 }

filament/src/details/MaterialInstance.h

@@ -56,8 +56,11 @@ class FTexture;
 
 class FMaterialInstance : public MaterialInstance {
 public:
-    FMaterialInstance(FEngine& engine, FMaterial const* material, const char* name,
-            FEngine::UboBatchingMode batchingMode) noexcept;
+    FMaterialInstance(FEngine& engine, FMaterial const* material,
+                      const char* name) noexcept;
+    // Use this constructor when you need to override the ubo batching flag for an individual MI.
+    FMaterialInstance(FEngine& engine, FMaterial const* material,
+                      const char* name, bool useUboBatching) noexcept;
     FMaterialInstance(FEngine& engine, FMaterialInstance const* other, const char* name);
     FMaterialInstance(const FMaterialInstance& rhs) = delete;
     FMaterialInstance& operator=(const FMaterialInstance& rhs) = delete;
@@ -72,7 +75,7 @@ public:
     
     void commit(FEngine& engine) const;
 
-    void commit(FEngine::DriverApi& driver, UboManager* uboManager) const;
+    void commit(FEngine::DriverApi& driver) const;
 
     void use(FEngine::DriverApi& driver, Variant variant = {}) const;
 
@@ -284,7 +287,6 @@ private:
     };
 
     std::variant<BufferAllocator::AllocationId, backend::Handle<backend::HwBufferObject>> mUboData;
-    BufferAllocator::allocation_size_t mUboOffset = 0;
     tsl::robin_map<backend::descriptor_binding_t, TextureParameter> mTextureParameters;
     mutable DescriptorSet mDescriptorSet;
     UniformBuffer mUniforms;
@@ -306,7 +308,7 @@ private:
     bool mHasScissor : 1;
     bool mIsDoubleSided : 1;
     bool mIsDefaultInstance : 1;
-    const bool mUseUboBatching : 1;
+    bool mUseUboBatching : 1;
     TransparencyMode mTransparencyMode : 2;
 
     uint64_t mMaterialSortingKey = 0;

filament/src/details/Renderer.cpp

@@ -452,8 +452,6 @@ void FRenderer::endFrame() {
     mFrameInfoManager.endFrame(driver);
     mFrameSkipper.submitFrame(driver);
 
-    engine.submitFrame();
-
     driver.endFrame(mFrameId);
 
     // gives the backend a chance to execute periodic tasks
@@ -571,6 +569,7 @@ void FRenderer::renderStandaloneView(FView const* view) {
 
     if (UTILS_LIKELY(view->getScene())) {
         mPreviousRenderTargets.clear();
+        mFrameId++;
 
         // ask the engine to do what it needs to (e.g. updates light buffer, materials...)
         FEngine& engine = mEngine;
@@ -580,16 +579,15 @@ void FRenderer::renderStandaloneView(FView const* view) {
         driver.beginFrame(
                 steady_clock::now().time_since_epoch().count(),
                 mDisplayInfo.refreshRate == 0.0 ? 0 : int64_t(
-                        1'000'000'000.0 / mDisplayInfo.refreshRate), 0);
+                        1'000'000'000.0 / mDisplayInfo.refreshRate),
+                mFrameId);
 
         // because we don't have a "present" call, we use flush so the driver can submit
         // the command buffer; we do this before driver.endFrame() to mimic what would
         // happen with Renderer::beginFrame/endFrame.
         renderInternal(view, true);
 
-        engine.submitFrame();
-
-        driver.endFrame(0);
+        driver.endFrame(mFrameId);
 
         // engine.flush() has already been called by renderInternal(), but we need an extra one
         // for endFrame() above. This operation in actually not too heavy, it just kicks the

filament/src/details/Renderer.h

@@ -209,7 +209,7 @@ private:
     backend::Handle<backend::HwRenderTarget> mRenderTargetHandle;
     FSwapChain* mSwapChain = nullptr;
     size_t mCommandsHighWatermark = 0;
-    uint32_t mFrameId = 1; // id 0 is reserved for standalone views
+    uint32_t mFrameId = 0;
     FrameInfoManager mFrameInfoManager;
     backend::TextureFormat mHdrTranslucent;
     backend::TextureFormat mHdrQualityMedium;

filament/src/details/UboManager.cpp

@@ -39,7 +39,7 @@ using allocation_size_t = BufferAllocator::allocation_size_t;
 // FenceManager
 // ------------------------------------------------------------------------------------------------
 
-void UboManager::FenceManager::track(DriverApi& driver, AllocationIdContainer&& allocationIds) {
+void UboManager::FenceManager::track(DriverApi& driver, std::unordered_set<AllocationId>&& allocationIds) {
     if (allocationIds.empty()) {
         return;
     }
@@ -48,7 +48,6 @@ void UboManager::FenceManager::track(DriverApi& driver, AllocationIdContainer&&
 
 void UboManager::FenceManager::reclaimCompletedResources(DriverApi& driver,
         std::function<void(AllocationId)> const& onReclaimed) {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
     uint32_t signaledCount = 0;
     bool seenSignaledFence = false;
 
@@ -116,7 +115,8 @@ UboManager::UboManager(DriverApi& driver, allocation_size_t defaultSlotSizeInByt
     reallocate(driver, defaultTotalSizeInBytes);
 }
 
-void UboManager::beginFrame(DriverApi& driver) {
+void UboManager::beginFrame(DriverApi& driver,
+        const std::unordered_map<const FMaterial*, ResourceList<FMaterialInstance>>& materialInstances) {
     FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
     // Check finished frames and decrement GPU count accordingly.
     mFenceManager.reclaimCompletedResources(driver,
@@ -126,7 +126,7 @@ void UboManager::beginFrame(DriverApi& driver) {
     mAllocator.releaseFreeSlots();
 
     // Traverse all MIs and see which of them need slot allocation.
-    if (allocateOnDemand() == SUCCESS) {
+    if (allocateOnDemand(materialInstances) == SUCCESS) {
         // No need to grow the buffer, so we can just map the buffer for writing and return.
         mMemoryMappedBufferHandle = driver.mapBuffer(mUbHandle, 0, mUboSize, MapBufferAccessFlags::WRITE_BIT,
                 "UboManager");
@@ -135,19 +135,25 @@ void UboManager::beginFrame(DriverApi& driver) {
     }
 
     // Calculate the required size and grow the Ubo.
-    const allocation_size_t requiredSize = calculateRequiredSize();
+    const allocation_size_t requiredSize = calculateRequiredSize(materialInstances);
     reallocate(driver, requiredSize);
 
     // Allocate slots for each MI on the new Ubo.
-    allocateAllInstances();
+    allocateAllInstances(materialInstances);
 
     // Map the buffer so that we can write to it
     mMemoryMappedBufferHandle =
             driver.mapBuffer(mUbHandle, 0, mUboSize, MapBufferAccessFlags::WRITE_BIT, "UboManager");
 
     // Invalidate the migrated MIs, so that next commit() call must be triggered.
-    for (const auto* mi : mManagedInstances) {
-        mi->getUniformBuffer().invalidate();
+    for (const auto& materialInstance : materialInstances) {
+        materialInstance.second.forEach([](const FMaterialInstance* mi) {
+            if (!mi->isUsingUboBatching()) {
+                return;
+            }
+
+            mi->getUniformBuffer().invalidate();
+        });
     }
 }
 
@@ -158,17 +164,24 @@ void UboManager::finishBeginFrame(DriverApi& driver) {
     }
 }
 
-void UboManager::endFrame(DriverApi& driver) {
-    auto allocationIds =
-            FenceManager::AllocationIdContainer::with_capacity(mManagedInstances.size());
-    for (const auto* mi: mManagedInstances) {
-        const AllocationId id = mi->getAllocationId();
-        if (UTILS_UNLIKELY(!BufferAllocator::isValid(id))) {
-            continue;
-        }
+void UboManager::endFrame(DriverApi& driver,
+        const std::unordered_map<const FMaterial*, ResourceList<FMaterialInstance>>& materialInstances) {
+    BufferAllocator& allocator = mAllocator;
+    std::unordered_set<AllocationId> allocationIds;
+    for (const auto& materialInstance : materialInstances) {
+        materialInstance.second.forEach([&allocator, &allocationIds](const FMaterialInstance* mi) {
+            if (!mi->isUsingUboBatching()) {
+                return;
+            }
 
-        mAllocator.acquireGpu(id);
-        allocationIds.push_back(id);
+            const AllocationId id = mi->getAllocationId();
+            if (!BufferAllocator::isValid(id)) {
+                return;
+            }
+
+            allocator.acquireGpu(id);
+            allocationIds.insert(id);
+        });
     }
 
     mFenceManager.track(driver, std::move(allocationIds));
@@ -181,90 +194,76 @@ void UboManager::terminate(DriverApi& driver) {
 
 void UboManager::updateSlot(DriverApi& driver, AllocationId id,
         BufferDescriptor bufferDescriptor) const {
-    if (!mMemoryMappedBufferHandle) {
+    if (!mMemoryMappedBufferHandle)
         return;
-    }
 
     const allocation_size_t offset = mAllocator.getAllocationOffset(id);
     driver.copyToMemoryMappedBuffer(mMemoryMappedBufferHandle, offset, std::move(bufferDescriptor));
 }
 
-void UboManager::manageMaterialInstance(FMaterialInstance* instance) {
-    mPendingInstances.insert(instance);
+void UboManager::retireSlot(BufferAllocator::AllocationId id) {
+    if (!BufferAllocator::isValid(id))
+        return;
+    mAllocator.retire(id);
 }
 
-void UboManager::unmanageMaterialInstance(FMaterialInstance* materialInstance) {
-    AllocationId id = materialInstance->getAllocationId();
-    mPendingInstances.erase(materialInstance);
-    mManagedInstances.erase(materialInstance);
-
-    if (!BufferAllocator::isValid(id)) {
-        return;
+UboManager::AllocationResult UboManager::allocateOnDemand(
+        const std::unordered_map<const FMaterial*, ResourceList<FMaterialInstance>>&
+                materialInstances) {
+    // Collect all MIs that need allocation into two groups.
+    std::vector<FMaterialInstance*> newInstances;
+    std::vector<FMaterialInstance*> existingInstances;
+    for (const auto& [_, miList] : materialInstances) {
+        miList.forEach([&](FMaterialInstance* mi) {
+            if (!mi->isUsingUboBatching()) {
+                return;
+            }
+            if (BufferAllocator::isValid(mi->getAllocationId())) {
+                existingInstances.push_back(mi);
+            } else {
+                newInstances.push_back(mi);
+            }
+        });
     }
 
-    mAllocator.retire(id);
-    materialInstance->assignUboAllocation(mUbHandle, BufferAllocator::UNALLOCATED, 0);
-}
-
-UboManager::AllocationResult UboManager::allocateOnDemand() {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
     bool reallocationNeeded = false;
 
     // Pass 1: Allocate slots for new material instances (that don't have a slot yet).
-    for (auto* mi : mPendingInstances) {
-        mManagedInstances.insert(mi);
+    for (FMaterialInstance* mi : newInstances) {
         auto [newId, newOffset] = mAllocator.allocate(mi->getUniformBuffer().getSize());
-
-        // Even if the newId is not valid, we assign it to the MI so that the following process knows
-        // this material instance was not allocated successfully. Then we can calculate the new
-        // required UBO size properly.
         mi->assignUboAllocation(mUbHandle, newId, newOffset);
-
         if (!BufferAllocator::isValid(newId)) {
             reallocationNeeded = true;
         }
     }
-    mPendingInstances.clear();
 
     // Pass 2: Allocate slots for existing material instances that need to be orphaned.
-    for (auto* mi: mManagedInstances) {
-        if (!BufferAllocator::isValid(mi->getAllocationId())) {
-            continue;
-        }
-
-        // This instance doesn't need orphaning.
-        if (!mi->getUniformBuffer().isDirty() || !mAllocator.isLockedByGpu(mi->getAllocationId())) {
-            continue;
-        }
-
-        mAllocator.retire(mi->getAllocationId());
-
-        // If the space is already not sufficient, we don't need to give another try on allocation.
-        if (reallocationNeeded) {
-            mi->assignUboAllocation(mUbHandle, REALLOCATION_REQUIRED, 0);
-            continue;
-        }
-
-        auto [newId, newOffset] = mAllocator.allocate(mi->getUniformBuffer().getSize());
-
-        // Even if the newId is not valid, we assign it to the MI so that the following process knows
-        // this material instance was not allocated successfully. Then we can calculate the new
-        // required UBO size properly.
-        mi->assignUboAllocation(mUbHandle, newId, newOffset);
-
-        if (!BufferAllocator::isValid(newId)) {
-            reallocationNeeded = true;
+    for (FMaterialInstance* mi : existingInstances) {
+        if (mi->getUniformBuffer().isDirty() && mAllocator.isLockedByGpu(mi->getAllocationId())) {
+            mAllocator.retire(mi->getAllocationId());
+            auto [newId, newOffset] = mAllocator.allocate(mi->getUniformBuffer().getSize());
+            mi->assignUboAllocation(mUbHandle, newId, newOffset);
+            if (!BufferAllocator::isValid(newId)) {
+                reallocationNeeded = true;
+            }
         }
     }
 
     return reallocationNeeded ? REALLOCATION_REQUIRED : SUCCESS;
 }
 
-void UboManager::allocateAllInstances() {
-    for (auto* mi: mManagedInstances) {
-        auto [newId, newOffset] = mAllocator.allocate(mi->getUniformBuffer().getSize());
-        assert_invariant(BufferAllocator::isValid(newId));
-        mi->assignUboAllocation(mUbHandle, newId, newOffset);
+void UboManager::allocateAllInstances(
+        const std::unordered_map<const FMaterial*, ResourceList<FMaterialInstance>>&
+                materialInstances) {
+    for (const auto& [_, miList] : materialInstances) {
+        miList.forEach([this](FMaterialInstance* mi) {
+            if (!mi->isUsingUboBatching()) {
+                return;
+            }
+            auto [newId, newOffset] = mAllocator.allocate(mi->getUniformBuffer().getSize());
+            assert_invariant(BufferAllocator::isValid(newId));
+            mi->assignUboAllocation(mUbHandle, newId, newOffset);
+        });
     }
 }
 
@@ -289,19 +288,28 @@ void UboManager::reallocate(DriverApi& driver, allocation_size_t requiredSize) {
             BufferUsage::DYNAMIC | BufferUsage::SHARED_WRITE_BIT);
 }
 
-allocation_size_t UboManager::calculateRequiredSize() {
+allocation_size_t UboManager::calculateRequiredSize(
+        const std::unordered_map<const FMaterial*, ResourceList<FMaterialInstance>>&
+                materialInstances) {
+    BufferAllocator& allocator = mAllocator;
     allocation_size_t newBufferSize = 0;
-    for (const auto* mi: mManagedInstances) {
-        const AllocationId allocationId = mi->getAllocationId();
-        if (allocationId == BufferAllocator::REALLOCATION_REQUIRED) {
-            // For MIs whose parameters have been updated, aside from the slot it is being
-            // occupied by the GPU, we need to preserve an additional slot for it.
-            newBufferSize += 2 * mAllocator.alignUp(mi->getUniformBuffer().getSize());
-        } else {
-            newBufferSize += mAllocator.alignUp(mi->getUniformBuffer().getSize());
-        }
+    for (const auto& materialInstance: materialInstances) {
+        materialInstance.second.forEach([&newBufferSize, &allocator](const FMaterialInstance* mi) {
+            if (!mi->isUsingUboBatching()) {
+                return;
+            }
+
+            const AllocationId allocationId = mi->getAllocationId();
+            if (allocationId == BufferAllocator::REALLOCATION_REQUIRED) {
+                // For MIs whose parameters have been updated, aside from the slot it is being
+                // occupied by the GPU, we need to preserve an additional slot for it.
+                newBufferSize += 2 * allocator.alignUp(mi->getUniformBuffer().getSize());
+            } else {
+                newBufferSize += allocator.alignUp(mi->getUniformBuffer().getSize());
+            }
+        });
     }
-    return mAllocator.alignUp(newBufferSize * BUFFER_SIZE_GROWTH_MULTIPLIER);
+    return allocator.alignUp(newBufferSize * BUFFER_SIZE_GROWTH_MULTIPLIER);
 }
 
 } // namespace filament

filament/src/details/UboManager.h

@@ -17,6 +17,7 @@
 #ifndef TNT_FILAMENT_DETAILS_UBOMANAGER_H
 #define TNT_FILAMENT_DETAILS_UBOMANAGER_H
 
+#include "ResourceList.h"
 #include "backend/DriverApiForward.h"
 
 #include "details/BufferAllocator.h"
@@ -28,8 +29,6 @@
 #include <unordered_set>
 #include <vector>
 
-class UboManagerTest;
-
 namespace filament {
 
 class FMaterial;
@@ -55,7 +54,6 @@ public:
     class FenceManager {
     public:
         using AllocationId = BufferAllocator::AllocationId;
-        using AllocationIdContainer = utils::FixedCapacityVector<AllocationId>;
 
         FenceManager() = default;
         ~FenceManager() = default;
@@ -66,7 +64,7 @@ public:
 
         // Creates a new fence to track a set of allocation IDs for the current frame.
         // This marks the beginning of GPU's usage of these resources.
-        void track(backend::DriverApi& driver, AllocationIdContainer&& allocationIds);
+        void track(backend::DriverApi& driver, std::unordered_set<AllocationId>&& allocationIds);
 
 
         // Checks all tracked fences and invokes a callback for resources associated with
@@ -81,7 +79,7 @@ public:
     private:
         // Not ideal, but we need to know which slots to decrement gpuUseCount for each frame.
         using FenceAndAllocations =
-                std::pair<backend::Handle<backend::HwFence>, AllocationIdContainer>;
+                std::pair<backend::Handle<backend::HwFence>, std::unordered_set<AllocationId>>;
         std::vector<FenceAndAllocations> mFenceAllocationList;
     };
 
@@ -98,8 +96,9 @@ public:
     //    instances with modified uniforms).
     // 3. Reallocating a larger shared UBO if the current one is insufficient.
     // 4. Mapping the shared UBO into CPU-accessible memory to prepare for uniform data writes.
-    // Note that it must happen before committing all MIs.
-    void beginFrame(backend::DriverApi& driver);
+    void beginFrame(backend::DriverApi& driver,
+            const std::unordered_map<const FMaterial*, ResourceList<FMaterialInstance>>&
+                    materialInstances);
 
     // Unmap the buffer here
     void finishBeginFrame(backend::DriverApi& driver);
@@ -107,31 +106,23 @@ public:
     // Create a fence and associate it with a set of allocation ids.
     // The gpuUseCount of these allocations will be incremented, and they will be decremented
     // After the corresponding frame has been done.
-    void endFrame(backend::DriverApi& driver);
+    void endFrame(backend::DriverApi& driver,
+            const std::unordered_map<const FMaterial*, ResourceList<FMaterialInstance>>&
+                    materialInstances);
 
     void terminate(backend::DriverApi& driver);
 
     void updateSlot(backend::DriverApi& driver, BufferAllocator::AllocationId id,
             backend::BufferDescriptor bufferDescriptor) const;
 
-    // Call this to register a new material instance to UboManager.
-    void manageMaterialInstance(FMaterialInstance* instance);
-
-    // Call this when a material instance is destroyed.
-    void unmanageMaterialInstance(FMaterialInstance* materialInstance);
+    // Call this when a material instance is no longer holding a slot. e.g. it is destroyed.
+    void retireSlot(BufferAllocator::AllocationId id);
 
     // Returns the size of the actual UBO. Note that when there's allocation failed, it will be
     // reallocated to a bigger size at the next frame.
     [[nodiscard]] BufferAllocator::allocation_size_t getTotalSize() const noexcept;
 
-    // For testing
-    [[nodiscard]] backend::MemoryMappedBufferHandle getMemoryMappedBufferHandle() const noexcept {
-        return mMemoryMappedBufferHandle;
-    }
-
 private:
-    friend class ::UboManagerTest;
-
     constexpr static float BUFFER_SIZE_GROWTH_MULTIPLIER = 1.5f;
 
     enum AllocationResult {
@@ -143,19 +134,23 @@ private:
     [[nodiscard]] BufferAllocator::allocation_size_t getAllocationOffset(
             BufferAllocator::AllocationId id) const;
 
-    AllocationResult allocateOnDemand();
+    AllocationResult allocateOnDemand(
+            const std::unordered_map<const FMaterial*, ResourceList<FMaterialInstance>>&
+                    materialInstances);
 
-    void allocateAllInstances();
+    void allocateAllInstances(
+            const std::unordered_map<const FMaterial*, ResourceList<FMaterialInstance>>&
+                    materialInstances);
 
     void reallocate(backend::DriverApi& driver, BufferAllocator::allocation_size_t requiredSize);
 
-    BufferAllocator::allocation_size_t calculateRequiredSize();
+    BufferAllocator::allocation_size_t calculateRequiredSize(
+            const std::unordered_map<const FMaterial*, ResourceList<FMaterialInstance>>&
+                    materialInstances);
 
     backend::Handle<backend::HwBufferObject> mUbHandle;
     backend::MemoryMappedBufferHandle mMemoryMappedBufferHandle;
     BufferAllocator::allocation_size_t mUboSize{};
-    std::unordered_set<FMaterialInstance*> mPendingInstances;
-    std::unordered_set<FMaterialInstance*> mManagedInstances;
 
     FenceManager mFenceManager;
     BufferAllocator mAllocator;

filament/src/details/VertexBuffer.cpp

@@ -285,45 +285,53 @@ FVertexBuffer::FVertexBuffer(FEngine& engine, const Builder& builder)
 
     // calculate buffer sizes
     size_t bufferSizes[MAX_VERTEX_BUFFER_COUNT] = {};
-
-    auto shouldCreateBuffer = [this](size_t attributeIndex) {
-        const uint8_t slot = mAttributes[attributeIndex].buffer;
-        return mDeclaredAttributes[attributeIndex] && slot != Attribute::BUFFER_UNUSED &&
-                !mBufferObjects[slot];
-    };
-    auto updateBufferSize = [&bufferSizes, this](size_t attributeIndex) {
-        const uint32_t offset = mAttributes[attributeIndex].offset;
-        const uint8_t stride = mAttributes[attributeIndex].stride;
-        const uint8_t slot = mAttributes[attributeIndex].buffer;
-        const size_t end = offset + mVertexCount * stride;
-        assert_invariant(slot < MAX_VERTEX_BUFFER_COUNT);
-        bufferSizes[slot] = std::max(bufferSizes[slot], end);
-    };
-
-    if (!mBufferObjectsEnabled) {
-        #pragma nounroll
-        for (size_t i = 0, n = mAttributes.size(); i < n; ++i) {
-            if (shouldCreateBuffer(i)) {
-                updateBufferSize(i);
+    #pragma nounroll
+    for (size_t i = 0, n = mAttributes.size(); i < n; ++i) {
+        if (mDeclaredAttributes[i]) {
+            const uint32_t offset = mAttributes[i].offset;
+            const uint8_t stride = mAttributes[i].stride;
+            const uint8_t slot = mAttributes[i].buffer;
+            const size_t end = offset + mVertexCount * stride;
+            if (slot != Attribute::BUFFER_UNUSED) {
+                assert_invariant(slot < MAX_VERTEX_BUFFER_COUNT);
+                bufferSizes[slot] = std::max(bufferSizes[slot], end);
             }
         }
-    } else if (mAdvancedSkinningEnabled) {
-        // For advanced skinning mode, only relevant buffers (BONE_INDICES & BONE_WEIGHTS) are
-        // created. We manually populated the relevant attributes for those buffers above.
-        updateBufferSize(BONE_INDICES);
-        updateBufferSize(BONE_WEIGHTS);
     }
 
-    // create buffers
-    for (size_t i = 0; i < MAX_VERTEX_BUFFER_COUNT; ++i) {
-        if (bufferSizes[i] == 0 || mBufferObjects[i]) {
-            continue;
+    if (!mBufferObjectsEnabled) {
+        // If buffer objects are not enabled at the API level, then we create them internally.
+        #pragma nounroll
+        for (size_t index = 0; index < MAX_VERTEX_BUFFER_COUNT; ++index) {
+            size_t const i = mAttributes[index].buffer;
+            if (i != Attribute::BUFFER_UNUSED) {
+                assert_invariant(bufferSizes[i] > 0);
+                if (!mBufferObjects[i]) {
+                    BufferObjectHandle const bo = driver.createBufferObject(bufferSizes[i],
+                            BufferObjectBinding::VERTEX, BufferUsage::STATIC,
+                            utils::ImmutableCString{ builder.getName() });
+                    driver.setVertexBufferObject(mHandle, i, bo);
+                    mBufferObjects[i] = bo;
+                }
+            }
+        }
+    } else {
+        // in advanced skinning mode, we manage the BONE_INDICES and BONE_WEIGHTS arrays ourselves,
+        // so we have to set the corresponding buffer objects.
+        if (mAdvancedSkinningEnabled) {
+            for (auto const index : { BONE_INDICES, BONE_WEIGHTS }) {
+                size_t const i = mAttributes[index].buffer;
+                assert_invariant(i != Attribute::BUFFER_UNUSED);
+                assert_invariant(bufferSizes[i] > 0);
+                if (!mBufferObjects[i]) {
+                    BufferObjectHandle const bo = driver.createBufferObject(bufferSizes[i],
+                            BufferObjectBinding::VERTEX, BufferUsage::STATIC,
+                            utils::ImmutableCString{ builder.getName() });
+                    driver.setVertexBufferObject(mHandle, i, bo);
+                    mBufferObjects[i] = bo;
+                }
+            }
         }
-        BufferObjectHandle const bo = driver.createBufferObject(bufferSizes[i],
-                BufferObjectBinding::VERTEX, BufferUsage::STATIC,
-                utils::ImmutableCString{ builder.getName() });
-        driver.setVertexBufferObject(mHandle, i, bo);
-        mBufferObjects[i] = bo;
     }
 }
 

filament/src/ds/PostProcessDescriptorSet.cpp

@@ -39,7 +39,7 @@ void PostProcessDescriptorSet::init(FEngine& engine) noexcept {
     // create the descriptor-set layout
     mDescriptorSetLayout = filament::DescriptorSetLayout{
             engine.getDescriptorSetLayoutFactory(),
-            engine.getDriverApi(), descriptor_sets::getDepthVariantLayout() };
+            engine.getDriverApi(), descriptor_sets::getPostProcessLayout() };
 
     // create the descriptor-set from the layout
     mDescriptorSet = DescriptorSet{ "PostProcessDescriptorSet", mDescriptorSetLayout };

filament/test/CMakeLists.txt

@@ -50,17 +50,14 @@ if (TNT_DEV)
             test_BufferAllocatorStress.cpp
             test_CircularQueue.cpp
             test_FenceManager.cpp
-            test_UboManager.cpp
             filament_test_exposure.cpp
             filament_rendering_test.cpp
             filament_bimap_test.cpp
             filament_framegraph_test.cpp
-            filament_test.cpp
-            ${RESGEN_SOURCE})
+            filament_test.cpp)
 
     target_link_libraries(test_${TARGET} PRIVATE filament gtest)
     target_compile_options(test_${TARGET} PRIVATE ${COMPILER_FLAGS})
-    target_include_directories(test_${TARGET} PRIVATE ${RESOURCE_DIR})
     set_target_properties(test_${TARGET} PROPERTIES FOLDER Tests)
 
     add_executable(test_depth depth_test.cpp)

filament/test/test_UboManager.cpp

@@ -1,366 +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 <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include "MockDriver.h"
-#include "details/MaterialInstance.h"
-#include "details/UboManager.h"
-
-#include <private/backend/CommandBufferQueue.h>
-#include <private/backend/CommandStream.h>
-#include <private/backend/Driver.h>
-
-#include "filament_test_resources.h"
-
-namespace {
-using namespace filament;
-using namespace backend;
-
-using ::testing::NiceMock;
-
-using AllocationId = BufferAllocator::AllocationId;
-using allocation_size_t = BufferAllocator::allocation_size_t;
-} // anonymous namespace
-
-class UboManagerTest : public ::testing::Test {
-protected:
-    static constexpr size_t MIN_COMMAND_BUFFERS_SIZE = 1 * 1024 * 1024;
-    static constexpr size_t COMMAND_BUFFERS_SIZE = 3 * MIN_COMMAND_BUFFERS_SIZE;
-    static constexpr BufferAllocator::allocation_size_t DEFAULT_SLOT_SIZE = 64;
-    static constexpr BufferAllocator::allocation_size_t DEFAULT_TOTAL_SIZE = 1024;
-
-    UboManagerTest()
-            : mCommandBufferQueue(MIN_COMMAND_BUFFERS_SIZE, COMMAND_BUFFERS_SIZE, false),
-              mCommandStream(mMockDriver, mCommandBufferQueue.getCircularBuffer()),
-
-              mDriverApi(mCommandStream),
-              // The constructor will call reallocate, which calls createBufferObject.
-              // MockDriver's default ...S() implementation returns an incrementing handle.
-              // So, the first handle will be 1.
-              mUboManager(mDriverApi, DEFAULT_SLOT_SIZE, DEFAULT_TOTAL_SIZE),
-              mPendingInstances(mUboManager.mPendingInstances),
-              mManagedInstances(mUboManager.mManagedInstances),
-              mUbHandle(mUboManager.mUbHandle),
-              mAllocator(mUboManager.mAllocator) {
-        mEngine = Engine::Builder()
-                          .feature("material.enable_material_instance_uniform_batching", true)
-                          .backend(Backend::NOOP)
-                          .build();
-
-        mMaterial = Material::Builder()
-                            .package(FILAMENT_TEST_RESOURCES_TEST_MATERIAL_DATA,
-                                    FILAMENT_TEST_RESOURCES_TEST_MATERIAL_SIZE)
-                            .build(*mEngine);
-    }
-
-    void TearDown() override {
-        mEngine->destroy(mMaterial);
-        Engine::destroy(&mEngine);
-    }
-
-    // The engine is only for creating materials/material instances, we're not using the UboManager
-    // inside for testing.
-    Engine* mEngine = nullptr;
-    NiceMock<MockDriver> mMockDriver;
-    CommandBufferQueue mCommandBufferQueue;
-    CommandStream mCommandStream;
-    DriverApi& mDriverApi;
-    UboManager mUboManager;
-    Material const* mMaterial;
-    std::unordered_set<FMaterialInstance*>& mPendingInstances;
-    std::unordered_set<FMaterialInstance*>& mManagedInstances;
-    Handle<HwBufferObject>& mUbHandle;
-    BufferAllocator& mAllocator;
-};
-
-TEST_F(UboManagerTest, InitialState) {
-    EXPECT_EQ(mUboManager.getTotalSize(), DEFAULT_TOTAL_SIZE);
-    EXPECT_EQ(mMockDriver.nextFakeHandle, 2);
-    EXPECT_NE(mUbHandle.getId(), HandleBase::nullid);
-}
-
-TEST_F(UboManagerTest, BeginFrameWithoutReallocate) {
-    BufferAllocator::allocation_size_t originalBufferSize = mUboManager.getTotalSize();
-    auto mi1 = static_cast<FMaterialInstance*>(mMaterial->createInstance());
-    EXPECT_EQ(mi1->getAllocationId(), BufferAllocator::UNALLOCATED);
-    ASSERT_TRUE(mi1->isUsingUboBatching());
-
-    // The mi1 should be put in the pending list.
-    mUboManager.manageMaterialInstance(mi1);
-    EXPECT_TRUE(mPendingInstances.contains(mi1));
-    EXPECT_FALSE(mManagedInstances.contains(mi1));
-
-    mUboManager.beginFrame(mDriverApi);
-
-    // The mi1 should be moved to managed list after beginFrame.
-    EXPECT_FALSE(mPendingInstances.contains(mi1));
-    EXPECT_TRUE(mManagedInstances.contains(mi1));
-    // Should have allocation after beginFrame.
-    EXPECT_TRUE(BufferAllocator::isValid(mi1->getAllocationId()));
-
-    // Reallocation is not triggered under this case.
-    EXPECT_EQ(mUboManager.getTotalSize(), originalBufferSize);
-    EXPECT_NE(mUboManager.getMemoryMappedBufferHandle().getId(), HandleBase::nullid);
-
-    mUboManager.finishBeginFrame(mDriverApi);
-    EXPECT_EQ(mUboManager.getMemoryMappedBufferHandle().getId(), HandleBase::nullid);
-
-    mUboManager.endFrame(mDriverApi);
-    EXPECT_TRUE(mAllocator.isLockedByGpu(mi1->getAllocationId()));
-
-    // We're not using the UboManager inside mEngine, so we need to unmanage the material instance
-    // by ourselves.
-    mUboManager.unmanageMaterialInstance(mi1);
-    EXPECT_FALSE(mPendingInstances.contains(mi1));
-    EXPECT_FALSE(mManagedInstances.contains(mi1));
-
-    mUboManager.terminate(mDriverApi);
-    mEngine->destroy(mi1);
-}
-
-TEST_F(UboManagerTest, BeginFrameWithReallocate) {
-    const allocation_size_t originalBufferSize = mUboManager.getTotalSize();
-    const Handle<HwBufferObject> originalBufferHandle = mUbHandle;
-
-    // Create enough material instances to trigger a reallocation.
-    constexpr size_t numInstances = (DEFAULT_TOTAL_SIZE / DEFAULT_SLOT_SIZE) + 1;
-    std::vector<FMaterialInstance*> instances;
-    instances.reserve(numInstances);
-
-    for (size_t i = 0; i < numInstances; ++i) {
-        auto mi = static_cast<FMaterialInstance*>(mMaterial->createInstance());
-        instances.push_back(mi);
-        mUboManager.manageMaterialInstance(mi);
-    }
-
-    // Before beginFrame, all instances should be pending.
-    EXPECT_EQ(mPendingInstances.size(), numInstances);
-    EXPECT_TRUE(mManagedInstances.empty());
-
-    mUboManager.beginFrame(mDriverApi);
-
-    // After beginFrame, reallocation should have occurred.
-    EXPECT_NE(mUbHandle.getId(), originalBufferHandle.getId());
-    EXPECT_GT(mUboManager.getTotalSize(), originalBufferSize);
-
-    // All instances should now be managed and have valid allocations.
-    EXPECT_TRUE(mPendingInstances.empty());
-    EXPECT_EQ(mManagedInstances.size(), numInstances);
-    for (const auto* mi: instances) {
-        EXPECT_TRUE(mManagedInstances.contains(const_cast<FMaterialInstance*>(mi)));
-        EXPECT_TRUE(BufferAllocator::isValid(mi->getAllocationId()));
-    }
-
-    mUboManager.finishBeginFrame(mDriverApi);
-    mUboManager.terminate(mDriverApi);
-
-    for (auto* mi: instances) {
-        // We're not using the UboManager inside mEngine, so we need to unmanage the material instance
-        // by ourselves.
-        mUboManager.unmanageMaterialInstance(mi);
-        mEngine->destroy(mi);
-    }
-}
-
-TEST_F(UboManagerTest, RecycleSlot) {
-    auto mi1 = static_cast<FMaterialInstance*>(mMaterial->createInstance());
-    mUboManager.manageMaterialInstance(mi1);
-
-    // Frame 1: mi1 gets an allocation.
-    mUboManager.beginFrame(mDriverApi);
-    const AllocationId mi1AllocationId = mi1->getAllocationId();
-    const allocation_size_t mi1AllocationOffset =
-            mAllocator.getAllocationOffset(mi1AllocationId);
-    EXPECT_TRUE(BufferAllocator::isValid(mi1AllocationId));
-    mUboManager.finishBeginFrame(mDriverApi);
-    mUboManager.endFrame(mDriverApi); // Locks mi1's allocation.
-
-    // Now, unmanage mi1. The slot should be retired but not yet released.
-    mUboManager.unmanageMaterialInstance(mi1);
-    EXPECT_TRUE(mAllocator.isLockedByGpu(mi1AllocationId));
-
-    // Frame 2: The slot for mi1 is still locked by the GPU.
-    // We expect getFenceStatus to be called for the fence from frame 1.
-    // We'll mock it to return TIMEOUT_EXPIRED, so the resource is not reclaimed.
-    EXPECT_CALL(mMockDriver, getFenceStatus(_)).WillOnce(Return(FenceStatus::TIMEOUT_EXPIRED));
-    mUboManager.beginFrame(mDriverApi);
-    mUboManager.finishBeginFrame(mDriverApi);
-    mUboManager.endFrame(mDriverApi);
-
-    // Frame 3: Now, we'll simulate that the fence from frame 1 has signaled.
-    // The resource for mi1 should be reclaimed.
-    EXPECT_CALL(mMockDriver, getFenceStatus(_)).WillOnce(Return(FenceStatus::CONDITION_SATISFIED));
-
-    auto mi2 = static_cast<FMaterialInstance*>(mMaterial->createInstance());
-    mUboManager.manageMaterialInstance(mi2);
-
-    mUboManager.beginFrame(mDriverApi);
-
-    // mi2 should now have a valid allocation, and it should reuse the slot from mi1.
-    EXPECT_TRUE(BufferAllocator::isValid(mi2->getAllocationId()));
-    EXPECT_EQ(mAllocator.getAllocationOffset(mi2->getAllocationId()), mi1AllocationOffset);
-
-    mUboManager.finishBeginFrame(mDriverApi);
-    mUboManager.unmanageMaterialInstance(mi2);
-    mUboManager.terminate(mDriverApi);
-
-    mEngine->destroy(mi1);
-    mEngine->destroy(mi2);
-}
-
-TEST_F(UboManagerTest, OrphanSlot) {
-    auto mi1 = static_cast<FMaterialInstance*>(mMaterial->createInstance());
-    mUboManager.manageMaterialInstance(mi1);
-
-    // Frame 1: mi1 gets an allocation.
-    mUboManager.beginFrame(mDriverApi);
-    const AllocationId alloc1 = mi1->getAllocationId();
-    EXPECT_TRUE(BufferAllocator::isValid(alloc1));
-    mUboManager.finishBeginFrame(mDriverApi);
-    mUboManager.endFrame(mDriverApi); // Locks alloc1.
-
-    // Frame 2: Mark the instance as dirty and begin a new frame.
-    // This should trigger orphaning.
-    mi1->getUniformBuffer().invalidate();
-    EXPECT_CALL(mMockDriver, getFenceStatus(_)).WillOnce(Return(FenceStatus::TIMEOUT_EXPIRED));
-    mUboManager.beginFrame(mDriverApi);
-
-    const AllocationId alloc2 = mi1->getAllocationId();
-    EXPECT_TRUE(BufferAllocator::isValid(alloc2));
-    EXPECT_NE(alloc1, alloc2); // Should have a new allocation.
-
-    mUboManager.finishBeginFrame(mDriverApi);
-    mUboManager.endFrame(mDriverApi); // Locks alloc2.
-
-    // Frame 3: The fence for alloc1 should now be signaled.
-    EXPECT_CALL(mMockDriver, getFenceStatus(_))
-            .WillOnce(Return(FenceStatus::TIMEOUT_EXPIRED))      // For alloc2's fence
-            .WillOnce(Return(FenceStatus::CONDITION_SATISFIED)); // For alloc1's fence
-    mUboManager.beginFrame(mDriverApi);
-    mUboManager.finishBeginFrame(mDriverApi);
-    mUboManager.unmanageMaterialInstance(mi1);
-    mUboManager.terminate(mDriverApi);
-
-    mEngine->destroy(mi1);
-}
-
-TEST_F(UboManagerTest, DoubleManage) {
-    auto mi1 = static_cast<FMaterialInstance*>(mMaterial->createInstance());
-    mUboManager.manageMaterialInstance(mi1);
-    EXPECT_EQ(mPendingInstances.size(), 1);
-
-    // Managing the same instance again should be a no-op.
-    mUboManager.manageMaterialInstance(mi1);
-    EXPECT_EQ(mPendingInstances.size(), 1);
-
-    mUboManager.terminate(mDriverApi);
-    mEngine->destroy(mi1);
-}
-
-TEST_F(UboManagerTest, ManageAndUnmanageBeforeBeginFrame) {
-    auto mi1 = static_cast<FMaterialInstance*>(mMaterial->createInstance());
-    mUboManager.manageMaterialInstance(mi1);
-    EXPECT_TRUE(mPendingInstances.contains(mi1));
-
-    mUboManager.unmanageMaterialInstance(mi1);
-    EXPECT_FALSE(mPendingInstances.contains(mi1));
-
-    // After beginFrame, the instance should not be in any list.
-    mUboManager.beginFrame(mDriverApi);
-    EXPECT_FALSE(mPendingInstances.contains(mi1));
-    EXPECT_FALSE(mManagedInstances.contains(mi1));
-    EXPECT_EQ(mi1->getAllocationId(), BufferAllocator::UNALLOCATED);
-
-    mUboManager.terminate(mDriverApi);
-    mEngine->destroy(mi1);
-}
-
-TEST_F(UboManagerTest, UnmanageUnmanaged) {
-    auto mi1 = static_cast<FMaterialInstance*>(mMaterial->createInstance());
-
-    // Unmanaging an instance that was never managed should not cause any issues.
-    mUboManager.unmanageMaterialInstance(mi1);
-    EXPECT_FALSE(mPendingInstances.contains(mi1));
-    EXPECT_FALSE(mManagedInstances.contains(mi1));
-
-    mUboManager.terminate(mDriverApi);
-    mEngine->destroy(mi1);
-}
-
-TEST_F(UboManagerTest, AllAllocationsLockedAfterEndFrame) {
-    constexpr size_t numInstances = 5;
-    std::vector<FMaterialInstance*> instances;
-    instances.reserve(numInstances);
-
-    for (size_t i = 0; i < numInstances; ++i) {
-        auto mi = static_cast<FMaterialInstance*>(mMaterial->createInstance());
-        instances.push_back(mi);
-        mUboManager.manageMaterialInstance(mi);
-    }
-
-    mUboManager.beginFrame(mDriverApi);
-    mUboManager.finishBeginFrame(mDriverApi);
-    mUboManager.endFrame(mDriverApi);
-
-    for (const auto* mi: instances) {
-        EXPECT_TRUE(mAllocator.isLockedByGpu(mi->getAllocationId()));
-    }
-
-    mUboManager.terminate(mDriverApi);
-    for (auto* mi: instances) {
-        // We're not using the UboManager inside mEngine, so we need to unmanage the material instance
-        // by ourselves.
-        mUboManager.unmanageMaterialInstance(mi);
-        mEngine->destroy(mi);
-    }
-}
-
-TEST_F(UboManagerTest, AllAllocationsLockedAfterEndFrameWithInvalidIdInBetween) {
-    constexpr size_t numInstances = 5;
-    std::vector<FMaterialInstance*> instances;
-    instances.reserve(numInstances);
-
-    for (size_t i = 0; i < numInstances; ++i) {
-        auto mi = static_cast<FMaterialInstance*>(mMaterial->createInstance());
-        instances.push_back(mi);
-        mUboManager.manageMaterialInstance(mi);
-    }
-
-    mUboManager.beginFrame(mDriverApi);
-    mUboManager.finishBeginFrame(mDriverApi);
-
-    // It should rarely happen, but we want to make sure all other instances are locked properly.
-    instances[2]->assignUboAllocation(mUbHandle, BufferAllocator::REALLOCATION_REQUIRED, 0);
-    mUboManager.endFrame(mDriverApi);
-
-    for (const auto* mi: instances) {
-        if (BufferAllocator::isValid(mi->getAllocationId())) {
-            EXPECT_TRUE(mAllocator.isLockedByGpu(mi->getAllocationId()));
-        }
-    }
-
-    mUboManager.terminate(mDriverApi);
-    for (auto* mi: instances) {
-        // We're not using the UboManager inside mEngine, so we need to unmanage the material instance
-        // by ourselves.
-        mUboManager.unmanageMaterialInstance(mi);
-        mEngine->destroy(mi);
-    }
-}
-
-// TODO: Add more tests for the beginFrame flow

ios/CocoaPods/Filament.podspec

@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
   spec.name = "Filament"
-  spec.version = "1.68.1"
+  spec.version = "1.67.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.68.1/filament-v1.68.1-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.67.0/filament-v1.67.0-ios.tgz" }
 
   # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
   spec.pod_target_xcconfig = {