vk: record timestmps on command buffers

Timer queries are inserted into the beginning and the end of each command buffer. Refactor vk's implementation of Filament's timer queries so that they are now computed as a sum of the time taken by one or more command buffers (and not direct insertion of queries into the command stream). This is to address a potential issue where the timestamps returned between command buffers are not consistent.
2025-11-12 12:18:30 -08:00
260 changed files with 8500 additions and 21121 deletions
@@ -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)
@@ -31,7 +31,7 @@ repositories {
 }

 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.67.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.67.1'
+pod 'Filament', '~> 1.67.0'
 ```

 ## Documentation
@@ -7,12 +7,6 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).

-## v1.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.
@@ -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
@@ -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()
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.67.1
+VERSION_NAME=1.67.0

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

@@ -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"
@@ -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>
@@ -216,8 +216,6 @@ if (FILAMENT_SUPPORTS_VULKAN)
            src/vulkan/VulkanPipelineCache.h
            src/vulkan/VulkanPipelineLayoutCache.cpp
            src/vulkan/VulkanPipelineLayoutCache.h
-            src/vulkan/VulkanQueryManager.cpp
-            src/vulkan/VulkanQueryManager.h
            src/vulkan/VulkanReadPixels.cpp
            src/vulkan/VulkanReadPixels.h
            src/vulkan/VulkanSamplerCache.cpp
@@ -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 {

@@ -512,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;
@@ -546,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
@@ -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>
@@ -169,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;
@@ -192,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
@@ -48,7 +48,7 @@ struct VulkanPlatformPrivate;

 // Forward declare the fence status that will be maintained by the command
 // buffer manager.
-struct VulkanCmdFence;
+struct VulkanCmdBufferState;

 /**
 * A Platform interface that creates a Vulkan backend.
@@ -242,7 +242,7 @@ public:
     * @return              A Platform::Sync object tracking the provided fence.
     */
    virtual Platform::Sync* createSync(VkFence fence,
-            std::shared_ptr<VulkanCmdFence> fenceStatus) noexcept;
+            std::shared_ptr<VulkanCmdBufferState> fenceStatus) noexcept;

    /**
     * Destroys a sync. If called with a sync not created by this platform
@@ -434,7 +434,7 @@ public:
 protected:
    struct VulkanSync : public Platform::Sync {
        VkFence fence;
-        std::shared_ptr<VulkanCmdFence> fenceStatus;
+        std::shared_ptr<VulkanCmdBufferState> fenceStatus;
    };

    using SurfaceBundle = std::tuple<VkSurfaceKHR, VkExtent2D>;
@@ -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;
 };
@@ -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{};
 };

@@ -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) {
@@ -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);
@@ -14,7 +14,7 @@
 * limitations under the License.
 */

-#include <backend/platforms/AndroidNdk.h>
+#include "AndroidNdk.h"

 #include <android/hardware_buffer.h>

@@ -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;
@@ -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);
    }
 }

@@ -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;
 };

@@ -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(
@@ -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;

@@ -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)
@@ -61,8 +61,6 @@ public:

    MetalContext* getContext() { return mContext; }

-    using DriverBase::scheduleDestroy;
-
 private:

    friend class MetalSwapChain;
@@ -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
@@ -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
@@ -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
@@ -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 = 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
@@ -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();
 }
@@ -230,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) {
@@ -263,7 +240,7 @@ Driver* PlatformEGLAndroid::createDriver(void* sharedContext,

    mAssertNativeWindowIsValid = driverConfig.assertNativeWindowIsValid;

-    mAndroidDetails.androidFrameCallback.init();
+    mAndroidFrameCallback.init();

    return driver;
 }
@@ -287,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;
@@ -316,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,
@@ -350,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) {
@@ -374,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];
@@ -390,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;
 }

@@ -720,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);
 }

 // ---------------------------------------------------------------------------------------------
@@ -749,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);
    }
 }

@@ -29,9 +29,8 @@ using namespace bluevk;

 namespace filament::backend {

-FenceStatus VulkanCmdFence::wait(VkDevice device, uint64_t const timeout,
-    std::chrono::steady_clock::time_point const until) {
-
+FenceStatus VulkanCmdBufferState::waitOnFence(VkDevice device, uint64_t const timeout,
+        std::chrono::steady_clock::time_point const until) {
    // this lock MUST be held for READ when calling vkWaitForFences()
    std::shared_lock rl(mLock);

@@ -81,7 +80,7 @@ FenceStatus VulkanCmdFence::wait(VkDevice device, uint64_t const timeout,
    return FenceStatus::ERROR; // not supported
 }

-void VulkanCmdFence::resetFence(VkDevice device) {
+void VulkanCmdBufferState::resetFence(VkDevice device) {
    // This lock prevents vkResetFences() from being called simultaneously with vkWaitForFences(),
    // but by construction, when we're here, we know that the fence has signaled and
    // vkWaitForFences() will return shortly.
@@ -90,4 +89,35 @@ void VulkanCmdFence::resetFence(VkDevice device) {
    vkResetFences(device, 1, &mFence);
 }

+uint64_t VulkanTimerQuery::getResult() {
+    {
+        std::lock_guard<std::mutex> lock(mDurationLock);
+        if (mDuration != UNKNOWN_QUERY_RESULT) {
+            return mDuration;
+        }
+    }
+
+    VulkanCmdBufferState* startState = nullptr;
+    VulkanCmdBufferState* endState = nullptr;
+    {
+        std::shared_lock const l(mMutex);
+        startState = mBeginState.get();
+        endState = mEndState.get();
+    }
+    // Here we sum up the time taken by each command buffer that were marked by this timer query.
+    uint64_t duration = 0;
+    do {
+        uint64_t const stDuration = startState->getBufferDuration();
+        assert_invariant(stDuration != VulkanCmdBufferState::UNKNOWN_BUFFER_DURATION);
+        duration += stDuration;
+        startState = startState->getNextState().get();
+    } while (startState != endState);
+
+    {
+        std::lock_guard<std::mutex> lock(mDurationLock);
+        mDuration = duration;
+    }
+    return duration;
+}
+
 } // namespace filament::backend
@@ -27,6 +27,7 @@

 #include <chrono>
 #include <cstdint>
+#include <limits>
 #include <memory>
 #include <mutex>
 #include <shared_mutex>
@@ -35,25 +36,36 @@

 namespace filament::backend {

-// Wrapper to enable use of shared_ptr for implementing shared ownership of low-level Vulkan fences.
-struct VulkanCmdFence {
-    explicit VulkanCmdFence(VkFence fence) : mFence(fence) { }
-    ~VulkanCmdFence() = default;
+// Wrapper to enable use of shared_ptr for implementing shared ownership of Vulkan fences
+// and timer query results.
+struct VulkanCmdBufferState {
+    static uint64_t const UNKNOWN_BUFFER_DURATION = std::numeric_limits<uint64_t>::max();

-    void setStatus(VkResult const value) {
+    explicit VulkanCmdBufferState(VkFence fence)
+            : mFence(fence) {
+    }
+    ~VulkanCmdBufferState() = default;
+
+    void setStatus(VkResult const value, uint64_t duration) {
        std::lock_guard const l(mLock);
        mStatus = value;
+        mDuration = duration;
        mCond.notify_all();
    }

-    VkResult getStatus() {
+    uint64_t getBufferDuration() {
+        std::shared_lock const l(mLock);
+        return mDuration;
+    }
+
+    VkResult getFenceStatus() {
        std::shared_lock const l(mLock);
        return mStatus;
    }

    void resetFence(VkDevice device);

-    FenceStatus wait(VkDevice device, uint64_t timeout,
+    FenceStatus waitOnFence(VkDevice device, uint64_t timeout,
        std::chrono::steady_clock::time_point until);

    void cancel() {
@@ -62,6 +74,18 @@ struct VulkanCmdFence {
        mCond.notify_all();
    }

+    void setNextState(std::shared_ptr<VulkanCmdBufferState> next) {
+        mNextState = std::move(next);
+    }
+
+    std::shared_ptr<VulkanCmdBufferState>& getNextState() {
+        return mNextState;
+    }
+
+    VkFence getVkFence() const {
+        return mFence;
+    }
+
 private:
    std::shared_mutex mLock; // NOLINT(*-include-cleaner)
    std::condition_variable_any mCond;
@@ -70,38 +94,42 @@ private:
    // gets submitted, its status changes to VK_NOT_READY. Finally, when the GPU actually
    // finishes executing the command buffer, the status changes to VK_SUCCESS.
    VkResult mStatus{ VK_INCOMPLETE };
-    VkFence mFence;
+    VkFence const mFence;
+
+    uint64_t mDuration = UNKNOWN_BUFFER_DURATION;
+
+    // We assume that command buffers are serialized.  This will point to the state of the next
+    // buffer. This is necessary so that we can return total duration of multiple command buffers
+    // when a TimerQuery is requested by the front-end.
+    std::shared_ptr<VulkanCmdBufferState> mNextState;
 };

 struct VulkanFence : public HwFence, fvkmemory::ThreadSafeResource {
    VulkanFence() {}

-    void setFence(std::shared_ptr<VulkanCmdFence> fence) {
-        std::lock_guard const l(lock);
-        sharedFence = std::move(fence);
+    void setCmdBufferState(std::shared_ptr<VulkanCmdBufferState> state) {
+        std::lock_guard l(lock);
+        cmdbufState = std::move(state);
        cond.notify_all();
    }

-    std::shared_ptr<VulkanCmdFence>& getSharedFence() {
-        std::lock_guard const l(lock);
-        return sharedFence;
+    std::shared_ptr<VulkanCmdBufferState>& getCmdBufferState() {
+        std::lock_guard l(lock);
+        return cmdbufState;
    }

-    std::pair<std::shared_ptr<VulkanCmdFence>, bool>
-            wait(std::chrono::steady_clock::time_point const until) {
-        // hold a reference so that our state doesn't disappear while we wait
+    std::pair<std::shared_ptr<VulkanCmdBufferState>, bool> wait(
+            std::chrono::steady_clock::time_point const until) {
        std::unique_lock l(lock);
-        cond.wait_until(l, until, [this] {
-            return bool(sharedFence) || canceled;
-        });
-        // here mSharedFence will be null if we timed out
-        return { sharedFence, canceled };
+        cond.wait_until(l, until, [&] { return bool(cmdbufState) || canceled; });
+        // here cmdbufState will be null if we timed out
+        return { cmdbufState, canceled };
    }

    void cancel() const {
        std::lock_guard const l(lock);
-        if (sharedFence) {
-            sharedFence->cancel();
+        if (cmdbufState) {
+            cmdbufState->cancel();
        }
        canceled = true;
        cond.notify_all();
@@ -111,10 +139,10 @@ private:
    mutable std::mutex lock;
    mutable std::condition_variable cond;
    mutable bool canceled = false;
-    std::shared_ptr<VulkanCmdFence> sharedFence;
+    std::shared_ptr<VulkanCmdBufferState> cmdbufState;
 };

-struct VulkanSync : fvkmemory::ThreadSafeResource, public HwSync {
+struct VulkanSync : public HwSync, fvkmemory::ThreadSafeResource {
    struct CallbackData {
        CallbackHandler* handler;
        Platform::SyncCallback cb;
@@ -128,38 +156,50 @@ struct VulkanSync : fvkmemory::ThreadSafeResource, public HwSync {
 };

 struct VulkanTimerQuery : public HwTimerQuery, fvkmemory::ThreadSafeResource {
-    VulkanTimerQuery(uint32_t startingIndex, uint32_t stoppingIndex)
-        : mStartingQueryIndex(startingIndex),
-          mStoppingQueryIndex(stoppingIndex) {}

-    void setFence(std::shared_ptr<VulkanCmdFence> fence) noexcept {
-        std::lock_guard const lock(mFenceMutex);
-        mFence = std::move(fence);
+    static decltype(VulkanCmdBufferState::UNKNOWN_BUFFER_DURATION) const
+            UNKNOWN_QUERY_RESULT = VulkanCmdBufferState::UNKNOWN_BUFFER_DURATION;
+
+    VulkanTimerQuery() {}
+
+    void setBeginState(std::shared_ptr<VulkanCmdBufferState> state) {
+        {
+            std::lock_guard const lock(mMutex);
+            mBeginState = std::move(state);
+        }
+        {
+            std::lock_guard<std::mutex> lock(mDurationLock);
+            mDuration = UNKNOWN_QUERY_RESULT;
+        }
+
    }

-    bool isCompleted() noexcept {
-        std::lock_guard const lock(mFenceMutex);
-        // QueryValue is a synchronous call and might occur before beginTimerQuery has written
-        // anything into the command buffer, which is an error according to the validation layer
-        // that ships in the Android NDK.  Even when AVAILABILITY_BIT is set, validation seems to
-        // require that the timestamp has at least been written into a processed command buffer.
-
-        // This fence indicates that the corresponding buffer has been completed.
-        return mFence && mFence->getStatus() == VK_SUCCESS;
+    void setEndState(std::shared_ptr<VulkanCmdBufferState> state) {
+        {
+            std::lock_guard const lock(mMutex);
+            mEndState = std::move(state);
+        }
+        {
+            std::lock_guard<std::mutex> lock(mDurationLock);
+            mDuration = UNKNOWN_QUERY_RESULT;
+        }
    }

-    uint32_t getStartingQueryIndex() const { return mStartingQueryIndex; }
-
-    uint32_t getStoppingQueryIndex() const {
-        return mStoppingQueryIndex;
+    bool isComplete() {
+        std::shared_lock const lock(mMutex);
+        return mBeginState && mEndState &&
+                mBeginState->getBufferDuration() != UNKNOWN_QUERY_RESULT &&
+                mEndState->getBufferDuration() != UNKNOWN_QUERY_RESULT;
    }

+    uint64_t getResult();
+
 private:
-    uint32_t mStartingQueryIndex;
-    uint32_t mStoppingQueryIndex;
-
-    std::shared_ptr<VulkanCmdFence> mFence;
-    utils::Mutex mFenceMutex;
+    std::shared_mutex mMutex; // NOLINT(*-include-cleaner)
+    std::mutex mDurationLock;
+    std::shared_ptr<VulkanCmdBufferState> mBeginState;
+    std::shared_ptr<VulkanCmdBufferState> mEndState;
+    uint64_t mDuration = UNKNOWN_QUERY_RESULT;
 };

 } // namespace filament::backend
@@ -55,6 +55,22 @@ VkCommandBuffer createCommandBuffer(VkDevice device, VkCommandPool pool) {
    return cmdbuffer;
 }

+VkFence createFence(VkDevice device, VulkanContext const& context, VkCommandPool pool) {
+    VkFenceCreateInfo fenceCreateInfo{ .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO };
+    VkExportFenceCreateInfo exportFenceCreateInfo{
+        .sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
+    };
+
+    // Necessary to guard this. Otherwise, swiftshader would throw an error.
+    if (context.getFenceExportFlags()) {
+        exportFenceCreateInfo.handleTypes = context.getFenceExportFlags(),
+        fenceCreateInfo.pNext = &exportFenceCreateInfo;
+    }
+    VkFence fence;
+    vkCreateFence(device, &fenceCreateInfo, VKALLOC, &fence);
+    return fence;
+}
+
 } // anonymous namespace

 #if FVK_ENABLED(FVK_DEBUG_GROUP_MARKERS)
@@ -91,30 +107,21 @@ uint32_t VulkanCommandBuffer::sAgeCounter = 0;

 VulkanCommandBuffer::VulkanCommandBuffer(VulkanContext const& context, VkDevice device,
        VkQueue queue, VkCommandPool pool, VulkanSemaphoreManager* semaphoreManager,
-        bool isProtected)
-    : mContext(context),
-      mMarkerCount(0),
-      isProtected(isProtected),
-      mDevice(device),
-      mQueue(queue),
-      mSemaphoreManager(semaphoreManager),
-      mBuffer(createCommandBuffer(device, pool)),
-      mSubmission(semaphoreManager->acquire()),
-      mAge(++sAgeCounter) {
-    VkFenceCreateInfo fenceCreateInfo{.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
-    VkExportFenceCreateInfo exportFenceCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
-        .handleTypes = context.getFenceExportFlags()
-    };
-
-    // Necessary to guard this. Otherwise, swiftshader would throw an error.
-    if (context.getFenceExportFlags()) {
-        fenceCreateInfo.pNext = &exportFenceCreateInfo;
-    }
-    vkCreateFence(device, &fenceCreateInfo, VKALLOC, &mFence);
-
-    mFenceStatus = std::make_shared<VulkanCmdFence>(mFence);
-}
+        bool isProtected, uint32_t timerQueryIndex, VkQueryPool queryPool)
+        : mContext(context),
+          mMarkerCount(0),
+          isProtected(isProtected),
+          mDevice(device),
+          mQueue(queue),
+          mSemaphoreManager(semaphoreManager),
+          mBuffer(createCommandBuffer(device, pool)),
+          mSubmission(semaphoreManager->acquire()),
+          mFence(createFence(device, context, pool)),
+          mCmdbufState(std::make_shared<VulkanCmdBufferState>(mFence)),
+          mAge(++sAgeCounter),
+          mQueryBeginIndex(timerQueryIndex),
+          mQueryEndIndex(timerQueryIndex + 1),
+          mQueryPool(queryPool) {}

 VulkanCommandBuffer::~VulkanCommandBuffer() {
    vkDestroyFence(mDevice, mFence, VKALLOC);
@@ -129,12 +136,12 @@ void VulkanCommandBuffer::reset() noexcept {
    mSubmission = mSemaphoreManager->acquire();

    // reset the fence with proper host synchronization
-    mFenceStatus->resetFence(mDevice);
+    mCmdbufState->resetFence(mDevice);

    // Internally we use the VK_INCOMPLETE status to mean "not yet submitted". When this fence
    // gets, gets submitted, its status changes to VK_NOT_READY. Finally, when the GPU actually
    // finishes executing the command buffer, the status changes to VK_SUCCESS.
-    mFenceStatus = std::make_shared<VulkanCmdFence>(mFence);
+    mCmdbufState = std::make_shared<VulkanCmdBufferState>(mFence);
 }

 void VulkanCommandBuffer::pushMarker(char const* marker) noexcept {
@@ -191,6 +198,12 @@ void VulkanCommandBuffer::begin() noexcept {
        .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
    };
    vkBeginCommandBuffer(mBuffer, &binfo);
+
+    // We need to reset the queries before writing to it. (This must happen within a command buffer,
+    // but not before the queries have occurred).
+    vkCmdResetQueryPool(mBuffer, mQueryPool, mQueryBeginIndex, 2);
+    vkCmdWriteTimestamp(mBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, mQueryPool,
+            mQueryBeginIndex);
 }

 fvkmemory::resource_ptr<VulkanSemaphore> VulkanCommandBuffer::submit() {
@@ -198,6 +211,9 @@ fvkmemory::resource_ptr<VulkanSemaphore> VulkanCommandBuffer::submit() {
        popMarker();
    }

+    vkCmdWriteTimestamp(mBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, mQueryPool,
+            mQueryEndIndex);
+
    vkEndCommandBuffer(mBuffer);

    VkSemaphore submissionSemaphore = mSubmission->getVkSemaphore();
@@ -236,7 +252,7 @@ fvkmemory::resource_ptr<VulkanSemaphore> VulkanCommandBuffer::submit() {

    UTILS_UNUSED_IN_RELEASE VkResult result =
        vkQueueSubmit(mQueue, 1, &submitInfo, mFence);
-    mFenceStatus->setStatus(VK_NOT_READY);
+    mCmdbufState->setStatus(VK_NOT_READY, VulkanCmdBufferState::UNKNOWN_BUFFER_DURATION);

 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
    if (result != VK_SUCCESS) {
@@ -248,6 +264,45 @@ fvkmemory::resource_ptr<VulkanSemaphore> VulkanCommandBuffer::submit() {
    return mSubmission;
 }

+void VulkanCommandBuffer::setComplete() {
+    if (mCmdbufState->getBufferDuration() != VulkanCmdBufferState::UNKNOWN_BUFFER_DURATION) {
+        return;
+    }
+    // We always query the duration of this buffer on the GPU.  This is then used to inform timer
+    // queries from the Filament-side.  The reason for doing it this way is because the timestamp is
+    // consistent within a command buffer, but not guarranteed to be consistent outside of a command
+    // buffer. So we can only infer duration by looking at execution duration with respect to a
+    // buffer.
+    struct QueryResult {
+        uint64_t beginTime = 0;
+        uint64_t beginAvailable = 0;
+        uint64_t endTime = 0;
+        uint64_t endAvailable = 0;
+    } result;
+
+    constexpr size_t dataSize = sizeof(result);
+    constexpr VkDeviceSize stride = sizeof(uint64_t) * 2;
+    VkResult const vkresult =
+            vkGetQueryPoolResults(mDevice, mQueryPool, mQueryBeginIndex, 2, dataSize,
+                    (void*) &result, stride,
+                    VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT);
+    FILAMENT_CHECK_POSTCONDITION(vkresult == VK_SUCCESS || vkresult == VK_NOT_READY)
+            << "vkGetQueryPoolResults error=" << static_cast<int32_t>(vkresult);
+
+    uint64_t const begin = result.beginTime;
+    uint64_t const end = result.endTime;
+    uint64_t duration = end - begin;
+
+    assert_invariant(result.beginAvailable != 0 && result.endAvailable != 0);
+    if (begin > end) {
+        FVK_LOGW << "Timestamps are not monotonically increasing. begin=" << begin <<
+                " end=" << end;
+        duration = begin - end;
+    }
+
+    mCmdbufState->setStatus(VK_SUCCESS, duration);
+}
+
 CommandBufferPool::CommandBufferPool(VulkanContext const& context, VkDevice device, VkQueue queue,
        uint8_t queueFamilyIndex, VulkanSemaphoreManager* semaphoreManager, bool isProtected)
    : mDevice(device),
@@ -259,11 +314,24 @@ CommandBufferPool::CommandBufferPool(VulkanContext const& context, VkDevice devi
                (isProtected ? VK_COMMAND_POOL_CREATE_PROTECTED_BIT : 0u),
        .queueFamilyIndex = queueFamilyIndex,
    };
-    vkCreateCommandPool(device, &createInfo, VKALLOC, &mPool);
+    VkResult result = vkCreateCommandPool(device, &createInfo, VKALLOC, &mPool);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateCommandPool failed."
+                                                       << " error=" << static_cast<int32_t>(result);
+
+    // Create a timestamp pool large enough to hold a pair of queries for each command buffer.
+    VkQueryPoolCreateInfo tqpCreateInfo = {
+        .sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
+        .queryType = VK_QUERY_TYPE_TIMESTAMP,
+        .queryCount = CAPACITY *2,
+    };
+    result = vkCreateQueryPool(mDevice, &tqpCreateInfo, VKALLOC, &mQueryPool);
+
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateQueryPool failed."
+                                                       << " error=" << static_cast<int32_t>(result);

    for (size_t i = 0; i < CAPACITY; ++i) {
-        mBuffers.emplace_back(std::make_unique<VulkanCommandBuffer>(
-                context, device, queue, mPool, semaphoreManager, isProtected));
+        mBuffers.emplace_back(std::make_unique<VulkanCommandBuffer>(context, device, queue, mPool,
+                semaphoreManager, isProtected, i * 2, mQueryPool));
    }
 }

@@ -271,6 +339,7 @@ CommandBufferPool::~CommandBufferPool() {
    wait();
    gc();
    vkDestroyCommandPool(mDevice, mPool, VKALLOC);
+    vkDestroyQueryPool(mDevice, mQueryPool, VKALLOC);
 }

 VulkanCommandBuffer& CommandBufferPool::getRecording() {
@@ -414,7 +483,7 @@ void VulkanCommands::terminate() {
    mPool.reset();
    mProtectedPool.reset();
    mLastSubmit = {};
-    mLastFenceStatus = {};
+    mLastBufferState = {};
 }

 VulkanCommandBuffer& VulkanCommands::get() {
@@ -443,8 +512,7 @@ bool VulkanCommands::flush() {
    fvkmemory::resource_ptr<VulkanSemaphore> dependency;
    bool hasFlushed = false;

-    VkFence flushedFence = VK_NULL_HANDLE;
-    std::shared_ptr<VulkanCmdFence> flushedFenceStatus;
+    std::shared_ptr<VulkanCmdBufferState> flushedBufferState;

    // Note that we've ordered it so that the non-protected commands are followed by the protected
    // commands.  This assumes that the protected commands will be that one doing the rendering into
@@ -467,8 +535,7 @@ bool VulkanCommands::flush() {
                    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT);
            mLastSubmit = {};
        }
-        flushedFence = pool->getRecording().getVkFence();
-        flushedFenceStatus = pool->getRecording().getFenceStatus();
+        flushedBufferState = pool->getRecording().getState();
        dependency = pool->flush();
        hasFlushed = true;
    }
@@ -476,8 +543,11 @@ bool VulkanCommands::flush() {
    if (hasFlushed) {
        mInjectedDependency = VK_NULL_HANDLE;
        mLastSubmit = dependency;
-        mLastFence = flushedFence;
-        mLastFenceStatus = flushedFenceStatus;
+
+        if (mLastBufferState) {
+            mLastBufferState->setNextState(flushedBufferState);
+        }
+        mLastBufferState = flushedBufferState;
    }

    return true;
@@ -42,6 +42,7 @@
 namespace filament::backend {

 using namespace fvkmemory;
+struct CommandBufferPool;

 #if FVK_ENABLED(FVK_DEBUG_GROUP_MARKERS)
 class VulkanGroupMarkers {
@@ -65,7 +66,8 @@ private:
 // we're done waiting on the most recent submission of the given command buffer.
 struct VulkanCommandBuffer {
    VulkanCommandBuffer(VulkanContext const& mContext, VkDevice device, VkQueue queue,
-            VkCommandPool pool, VulkanSemaphoreManager* semaphoreManager, bool isProtected);
+            VkCommandPool pool, VulkanSemaphoreManager* semaphoreManager, bool isProtected,
+            uint32_t timerQueryIndex, VkQueryPool queryPool);

    VulkanCommandBuffer(VulkanCommandBuffer const&) = delete;
    VulkanCommandBuffer& operator=(VulkanCommandBuffer const&) = delete;
@@ -90,20 +92,14 @@ struct VulkanCommandBuffer {
    void begin() noexcept;
    fvkmemory::resource_ptr<VulkanSemaphore> submit();

-    inline void setComplete() {
-        mFenceStatus->setStatus(VK_SUCCESS);
-    }
+    void setComplete();

    VkResult getStatus() {
-        return mFenceStatus->getStatus();
+        return mCmdbufState->getFenceStatus();
    }

-    std::shared_ptr<VulkanCmdFence> getFenceStatus() const {
-        return mFenceStatus;
-    }
-
-    VkFence getVkFence() const {
-        return mFence;
+    std::shared_ptr<VulkanCmdBufferState> getState() const {
+        return mCmdbufState;
    }

    VkCommandBuffer buffer() const {
@@ -115,22 +111,31 @@ struct VulkanCommandBuffer {
    }

 private:
+    VkFence getVkFence() const {
+        return mFence;
+    }
+
    static uint32_t sAgeCounter;

    VulkanContext const& mContext;
    uint8_t mMarkerCount;
    bool const isProtected;
-    VkDevice mDevice;
-    VkQueue mQueue;
+    VkDevice const mDevice;
+    VkQueue const mQueue;
    VulkanSemaphoreManager* mSemaphoreManager;
    fvkutils::StaticVector<VkSemaphore, 2> mWaitSemaphores;
    fvkutils::StaticVector<VkPipelineStageFlags, 2> mWaitSemaphoreStages;
-    VkCommandBuffer mBuffer;
+    VkCommandBuffer const mBuffer;
    fvkmemory::resource_ptr<VulkanSemaphore> mSubmission;
-    VkFence mFence;
-    std::shared_ptr<VulkanCmdFence> mFenceStatus;
+    VkFence const mFence;
+    std::shared_ptr<VulkanCmdBufferState> mCmdbufState;
    std::vector<fvkmemory::resource_ptr<Resource>> mResources;
    uint32_t mAge;
+    uint32_t const mQueryBeginIndex;
+    uint32_t const mQueryEndIndex;
+    VkQueryPool const mQueryPool;
+
+    friend struct CommandBufferPool;
 };

 struct CommandBufferPool {
@@ -174,6 +179,8 @@ private:
    std::vector<std::unique_ptr<VulkanCommandBuffer>> mBuffers;
    int8_t mRecording;

+    VkQueryPool mQueryPool;
+
 #if FVK_ENABLED(FVK_DEBUG_GROUP_MARKERS)
    std::unique_ptr<VulkanGroupMarkers> mGroupMarkers;
 #endif
@@ -199,7 +206,7 @@ private:
 //
 // - Allows off-thread queries of command buffer status.
 //    - Exposes an "updateFences" method that transfers current fence status into atomics.
-//    - Users can examine these atomic variables (see VulkanCmdFence) to determine status.
+//    - Users can examine these atomic variables (see VulkanCmdBufferState) to determine status.
 //    - We do this because vkGetFenceStatus must be called from the rendering thread.
 //
 class VulkanCommands {
@@ -230,12 +237,8 @@ public:
        return sem;
    }

-    VkFence getMostRecentFence() {
-        return mLastFence;
-    }
-
-    std::shared_ptr<VulkanCmdFence> getMostRecentFenceStatus() {
-        return mLastFenceStatus;
+    std::shared_ptr<VulkanCmdBufferState> getMostRecentBufferState() {
+        return mLastBufferState;
    }

    // Takes a semaphore that signals when the next flush can occur. Only one injected
@@ -276,8 +279,7 @@ private:
    VkSemaphore mInjectedDependency = VK_NULL_HANDLE;
    fvkmemory::resource_ptr<VulkanSemaphore> mLastSubmit;

-    VkFence mLastFence = VK_NULL_HANDLE;
-    std::shared_ptr<VulkanCmdFence> mLastFenceStatus;
+    std::shared_ptr<VulkanCmdBufferState> mLastBufferState;

    VkPipelineStageFlags mInjectedDependencyWaitStage = 0;
 };
@@ -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
@@ -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;
@@ -231,7 +231,7 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext& context,
              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()),
@@ -241,7 +241,6 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext& context,
      mReadPixels(mPlatform->getDevice()),
      mDescriptorSetLayoutCache(mPlatform->getDevice(), &mResourceManager),
      mDescriptorSetCache(mPlatform->getDevice(), &mResourceManager),
-      mQueryManager(mPlatform->getDevice()),
      mExternalImageManager(platform, &mSamplerCache, &mYcbcrConversionCache, &mDescriptorSetCache,
              &mDescriptorSetLayoutCache),
      mIsSRGBSwapChainSupported(mPlatform->getCustomization().isSRGBSwapChainSupported),
@@ -338,8 +337,6 @@ void VulkanDriver::terminate() {
    mDefaultRenderTarget = {};
    mPipelineState = {};

-    mQueryManager.terminate();
-
    mBlitter.terminate();
    mReadPixels.terminate();

@@ -860,32 +857,33 @@ void VulkanDriver::createFenceR(Handle<HwFence> fh, utils::ImmutableCString&& ta
        cmdbuf = &mCommands.get();
    }
    // Note at this point, the fence has already been constructed via createFenceS, so we just tag
-    // it with appropriate VulkanCmdFence, which is associated with the current, recording command
+    // it with appropriate VulkanCmdBufferState, which is associated with the current, recording command
    // buffer.
    auto fence = resource_ptr<VulkanFence>::cast(&mResourceManager, fh);
-    fence->setFence(cmdbuf->getFenceStatus());
+    fence->setCmdBufferState(cmdbuf->getState());
    mResourceManager.associateHandle(fh.getId(), std::move(tag));
 }

 void VulkanDriver::createSyncR(Handle<HwSync> sh, utils::ImmutableCString&& tag) {
    auto sync = resource_ptr<VulkanSync>::cast(&mResourceManager, sh);
    VkFence fence = VK_NULL_HANDLE;
-    std::shared_ptr<VulkanCmdFence> fenceStatus;
+    std::shared_ptr<VulkanCmdBufferState> cmdbufState;
    if (mCurrentRenderPass.commandBuffer) {
        VulkanCommandBuffer* cmdBuff = mCurrentRenderPass.commandBuffer;
-        fence = cmdBuff->getVkFence();
-        fenceStatus = cmdBuff->getFenceStatus();
+        cmdbufState = cmdBuff->getState();
+        fence = cmdbufState->getVkFence();
+
        // If we're currently recording, flush so that the fence only applies
        // to commands already issued.
        mCommands.flush();
    } else {
-        fence = mCommands.getMostRecentFence();
-        fenceStatus = mCommands.getMostRecentFenceStatus();
+        cmdbufState = mCommands.getMostRecentBufferState();
+        fence = cmdbufState->getVkFence();
    }

    {
        std::lock_guard<std::mutex> guard(sync->lock);
-        sync->sync = mPlatform->createSync(fence, fenceStatus);
+        sync->sync = mPlatform->createSync(fence, cmdbufState);
    }

    for (auto& cbData : sync->conversionCallbacks) {
@@ -921,6 +919,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();
@@ -1067,9 +1073,10 @@ Handle<HwSwapChain> VulkanDriver::createSwapChainHeadlessS() noexcept {
 Handle<HwTimerQuery> VulkanDriver::createTimerQueryS() noexcept {
    // The handle must be constructed here, as a synchronous call to getTimerQueryValue might happen
    // before createTimerQueryR is executed.
-    auto query = mQueryManager.getNextQuery(&mResourceManager);
+    auto handle = mResourceManager.allocHandle<VulkanTimerQuery>();
+    auto query = resource_ptr<VulkanTimerQuery>::make(&mResourceManager, handle);
    query.inc();
-    return Handle<VulkanTimerQuery>(query.id());
+    return handle;
 }

 Handle<HwDescriptorSetLayout> VulkanDriver::createDescriptorSetLayoutS() noexcept {
@@ -1126,7 +1133,6 @@ void VulkanDriver::destroyTimerQuery(Handle<HwTimerQuery> tqh) {
        return;
    }
    auto vtq = resource_ptr<VulkanTimerQuery>::cast(&mResourceManager, tqh);
-    mQueryManager.clearQuery(vtq);
    vtq.dec();
 }

@@ -1189,7 +1195,6 @@ FenceStatus VulkanDriver::getFenceStatus(Handle<HwFence> const fh) {
 FenceStatus VulkanDriver::fenceWait(FenceHandle const fh, uint64_t const timeout) {
    // Even though this is a synchronous call, the fence handle must be (and stay) valid
    assert_invariant(fh);
-
    auto fence = resource_ptr<VulkanFence>::cast(&mResourceManager, fh);

    // we have to take into account that the STL's wait_for() actually works with
@@ -1206,14 +1211,14 @@ FenceStatus VulkanDriver::fenceWait(FenceHandle const fh, uint64_t const timeout
        until = now + nanoseconds(timeout);
    }

-    auto const [cmdfence, canceled] = fence->wait(until);
-    if (!cmdfence || canceled) {
+    auto const [cmdbufState, canceled] = fence->wait(until);
+    if (!cmdbufState || canceled) {
        return canceled ? FenceStatus::ERROR : FenceStatus::TIMEOUT_EXPIRED;
    }

-    // now we are holding a reference to our VulkanCmdFence, so we know it can't
+    // now we are holding a reference to our VulkanCmdBufferState, so we know it can't
    // disappear while we wait
-    return cmdfence->wait(mPlatform->getDevice(), timeout, until);
+    return cmdbufState->waitOnFence(mPlatform->getDevice(), timeout, until);
 }

 void VulkanDriver::getPlatformSync(Handle<HwSync> sh, CallbackHandler* handler,
@@ -1510,29 +1515,17 @@ void VulkanDriver::setupExternalImage(void* image) {

 TimerQueryResult VulkanDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint64_t* elapsedTime) {
    auto vtq = resource_ptr<VulkanTimerQuery>::cast(&mResourceManager, tqh);
-    if (!vtq->isCompleted()) {
+    if (!vtq->isComplete()) {
        return TimerQueryResult::NOT_READY;
    }
-
-    auto results = mQueryManager.getResult(vtq);
-    if (results.beginAvailable == 0 || results.endAvailable == 0) {
-        return TimerQueryResult::NOT_READY;
-    }
-
-    uint64_t const begin = results.beginTime;
-    uint64_t const end = results.endTime;
-    if (begin >= end) {
-        // TODO: queries might have ran on different command buffers.
-        FVK_LOGW << "Timestamps are not monotonically increasing. ";
-        *elapsedTime = 0;
-        return TimerQueryResult::ERROR;
-    }
+    uint64_t result = vtq->getResult();
+    assert_invariant(result != VulkanTimerQuery::UNKNOWN_QUERY_RESULT);

    // NOTE: MoltenVK currently writes system time so the following delta will always be zero.
    // However there are plans for implementing this properly. See the following GitHub ticket.
    // https://github.com/KhronosGroup/MoltenVK/issues/773
    float const period = mContext.getPhysicalDeviceLimits().timestampPeriod;
-    *elapsedTime = uint64_t(float(end - begin) * period);
+    *elapsedTime = uint64_t(float(result) * period);
    return TimerQueryResult::AVAILABLE;
 }

@@ -2291,12 +2284,14 @@ void VulkanDriver::scissor(Viewport scissorBox) {

 void VulkanDriver::beginTimerQuery(Handle<HwTimerQuery> tqh) {
    auto vtq = resource_ptr<VulkanTimerQuery>::cast(&mResourceManager, tqh);
-    mQueryManager.beginQuery(&(mCommands.get()), vtq);
+    auto cmdbuf = &mCommands.get();
+    vtq->setBeginState(cmdbuf->getState());
 }

 void VulkanDriver::endTimerQuery(Handle<HwTimerQuery> tqh) {
    auto vtq = resource_ptr<VulkanTimerQuery>::cast(&mResourceManager, tqh);
-    mQueryManager.endQuery(&(mCommands.get()), vtq);
+    auto cmdbuf = &mCommands.get();
+    vtq->setEndState(cmdbuf->getState());
 }

 void VulkanDriver::debugCommandBegin(CommandStream* cmds, bool synchronous, const char* methodName) noexcept {
@@ -25,7 +25,6 @@
 #include "VulkanHandles.h"
 #include "VulkanMemory.h"
 #include "VulkanPipelineCache.h"
-#include "VulkanQueryManager.h"
 #include "VulkanReadPixels.h"
 #include "VulkanSamplerCache.h"
 #include "VulkanSemaphoreManager.h"
@@ -48,6 +47,10 @@
 #include <utils/Allocator.h>
 #include <utils/compiler.h>

+#if defined(__ANDROID__)
+#include "AndroidNativeWindow.h"
+#endif
+
 namespace filament::backend {

 class VulkanPlatform;
@@ -155,7 +158,6 @@ private:
    VulkanReadPixels mReadPixels;
    VulkanDescriptorSetLayoutCache mDescriptorSetLayoutCache;
    VulkanDescriptorSetCache mDescriptorSetCache;
-    VulkanQueryManager mQueryManager;
    VulkanExternalImageManager mExternalImageManager;

    // This maps a VulkanSwapchain to a native swapchain. VulkanSwapchain should have a copy of the
@@ -202,6 +204,9 @@ private:
    bool const mIsSRGBSwapChainSupported;
    bool const mIsMSAASwapChainSupported;
    backend::StereoscopicType const mStereoscopicType;
+#if defined(__ANDROID__)
+    AndroidProducerThrottling mProducerThrottling;
+#endif
 };

 } // namespace filament::backend
@@ -34,41 +34,8 @@ 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,
    };
@@ -249,40 +216,15 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
        }
    }

-#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;
@@ -86,7 +86,7 @@ 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;

@@ -210,8 +210,6 @@ private:

    // Current bindings for the pipeline and descriptor sets.
    PipelineKey mBoundPipeline = {};
-
-    [[maybe_unused]] VulkanContext const& mContext;
 };

 } // namespace filament::backend
@@ -1,106 +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 "VulkanQueryManager.h"
-
-#include "VulkanAsyncHandles.h"
-#include "VulkanCommands.h"
-#include "VulkanConstants.h"
-
-#include <bluevk/BlueVK.h>
-
-namespace filament::backend {
-
-using namespace bluevk;
-
-VulkanQueryManager::VulkanQueryManager(VkDevice device) : mDevice(device) {
-    // Create a timestamp pool large enough to hold a pair of queries for each timer.
-    VkQueryPoolCreateInfo tqpCreateInfo = {
-        .sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
-        .queryType = VK_QUERY_TYPE_TIMESTAMP,
-        .queryCount = (uint32_t) mUsed.size() * 2,
-    };
-    VkResult result = vkCreateQueryPool(mDevice, &tqpCreateInfo, VKALLOC, &mPool);
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateQueryPool failed."
-                                                       << " error=" << static_cast<int32_t>(result);
-}
-
-fvkmemory::resource_ptr<VulkanTimerQuery> VulkanQueryManager::getNextQuery(
-        fvkmemory::ResourceManager* resourceManager) {
-    auto unused = ~mUsed;
-    if (unused.empty()) {
-        FVK_LOGE << "More than " << mUsed.size() << " timers are not supported.";
-        return {};
-    }
-
-    std::pair<uint32_t, uint32_t> queryIndices;
-    size_t const firstUnused = unused.firstSetBit();
-    {
-        std::unique_lock<utils::Mutex> lock(mMutex);
-        mUsed.set(firstUnused);
-        queryIndices = { firstUnused * 2, firstUnused * 2 + 1 };
-    }
-    return fvkmemory::resource_ptr<VulkanTimerQuery>::construct(resourceManager, queryIndices.first,
-            queryIndices.second);
-}
-
-void VulkanQueryManager::clearQuery(fvkmemory::resource_ptr<VulkanTimerQuery> query) {
-    std::unique_lock<utils::Mutex> lock(mMutex);
-    uint32_t const startingIndex = query->getStartingQueryIndex();
-    mUsed.unset(startingIndex / 2);
-}
-
-void VulkanQueryManager::beginQuery(VulkanCommandBuffer const* commands,
-        fvkmemory::resource_ptr<VulkanTimerQuery> query) {
-    uint32_t const index = query->getStartingQueryIndex();
-
-    auto const cmdbuffer = commands->buffer();
-    vkCmdResetQueryPool(cmdbuffer, mPool, index, 2);
-    vkCmdWriteTimestamp(cmdbuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, mPool, index);
-
-    // We stash this because getResult might come before the query is actually processed.
-    query->setFence(commands->getFenceStatus());
-}
-
-void VulkanQueryManager::endQuery(VulkanCommandBuffer const* commands,
-        fvkmemory::resource_ptr<VulkanTimerQuery> query) {
-    uint32_t const index = query->getStoppingQueryIndex();
-    vkCmdWriteTimestamp(commands->buffer(), VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, mPool, index);
-}
-
-VulkanQueryManager::QueryResult VulkanQueryManager::getResult(
-        fvkmemory::resource_ptr<VulkanTimerQuery> query) {
-    uint32_t const index = query->getStartingQueryIndex();
-    QueryResult result;
-    size_t const dataSize = sizeof(result);
-    VkDeviceSize const stride = sizeof(uint64_t) * 2;
-    VkResult vkresult =
-            vkGetQueryPoolResults(mDevice, mPool, index, 2, dataSize, (void*) &result, stride,
-                    VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT);
-    FILAMENT_CHECK_POSTCONDITION(vkresult == VK_SUCCESS || vkresult == VK_NOT_READY)
-            << "vkGetQueryPoolResults error=" << static_cast<int32_t>(vkresult);
-    if (vkresult == VK_NOT_READY) {
-        return {};
-    }
-    return result;
-}
-
-void VulkanQueryManager::terminate() noexcept {
-    vkDestroyQueryPool(mDevice, mPool, VKALLOC);
-    mPool = VK_NULL_HANDLE;
-}
-
-} // filament::backend
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2025 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TNT_FILAMENT_BACKEND_VULKANQUERYMANAGER_H
-#define TNT_FILAMENT_BACKEND_VULKANQUERYMANAGER_H
-
-#include "vulkan/memory/ResourcePointer.h"
-
-namespace filament::backend {
-
-struct VulkanCommandBuffer;
-struct VulkanTimerQuery;
-
-class VulkanQueryManager {
-public:
-    struct QueryResult {
-        uint64_t beginTime = 0;
-        uint64_t beginAvailable = 0;
-        uint64_t endTime = 0;
-        uint64_t endAvailable = 0;
-    };
-
-    VulkanQueryManager(VkDevice device);
-    ~VulkanQueryManager() = default;
-
-    // Not copy-able.
-    VulkanQueryManager(VulkanQueryManager const&) = delete;
-    VulkanQueryManager& operator=(VulkanQueryManager const&) = delete;
-
-    fvkmemory::resource_ptr<VulkanTimerQuery>
-            getNextQuery(fvkmemory::ResourceManager* mResourceManager);
-    void clearQuery(fvkmemory::resource_ptr<VulkanTimerQuery> query);
-    void beginQuery(VulkanCommandBuffer const* commands,
-            fvkmemory::resource_ptr<VulkanTimerQuery> query);
-    void endQuery(VulkanCommandBuffer const* commands,
-            fvkmemory::resource_ptr<VulkanTimerQuery> query);
-    QueryResult getResult(fvkmemory::resource_ptr<VulkanTimerQuery> query);
-
-    void terminate() noexcept;
-
-private:
-    VkDevice mDevice;
-    VkQueryPool mPool;
-    utils::bitset32 mUsed;
-    utils::Mutex mMutex;
-};
-
-} // filament::backend
-
-#endif // TNT_FILAMENT_BACKEND_VULKANQUERYMANAGER_H
@@ -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;
        }
    }

@@ -980,7 +971,7 @@ SwapChainPtr VulkanPlatform::createSwapChain(void* nativeWindow, uint64_t flags,
 }

 Platform::Sync* VulkanPlatform::createSync(VkFence fence,
-        std::shared_ptr<VulkanCmdFence> fenceStatus) noexcept {
+        std::shared_ptr<VulkanCmdBufferState> fenceStatus) noexcept {
    return new VulkanSync{.fence = fence, .fenceStatus = fenceStatus};
 }

@@ -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
@@ -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,
@@ -462,7 +407,7 @@ bool VulkanPlatformAndroid::convertSyncToFd(Platform::Sync* sync, int* fd) const
    VulkanSync& vulkanSync = static_cast<VulkanSync&>(*sync);
    assert_invariant(vulkanSync.fenceStatus);

-    if (vulkanSync.fenceStatus->getStatus() == VK_SUCCESS) {
+    if (vulkanSync.fenceStatus->getFenceStatus() == VK_SUCCESS) {
        // We've already signaled; return -1 so that operations will proceed
        // immediately. Also, signal that fence conversion was successful.
        *fd = -1;
@@ -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 {
@@ -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);
@@ -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
 };

@@ -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()
@@ -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.
@@ -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;
@@ -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.
@@ -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 {
@@ -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;
@@ -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);
@@ -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;

@@ -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;
@@ -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;
@@ -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());
    }
 }
@@ -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;
@@ -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
@@ -589,8 +587,6 @@ void FRenderer::renderStandaloneView(FView const* view) {
        // happen with Renderer::beginFrame/endFrame.
        renderInternal(view, true);

-        engine.submitFrame();
-
        driver.endFrame(mFrameId);

        // engine.flush() has already been called by renderInternal(), but we need an extra one
@@ -48,7 +48,6 @@ void UboManager::FenceManager::track(DriverApi& driver, std::unordered_set<Alloc

 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,16 +164,24 @@ void UboManager::finishBeginFrame(DriverApi& driver) {
    }
 }

-void UboManager::endFrame(DriverApi& driver) {
+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* mi : mManagedInstances) {
-        const AllocationId id = mi->getAllocationId();
-        if (UTILS_UNLIKELY(!BufferAllocator::isValid(id))) {
-            continue;
-        }
+    for (const auto& materialInstance : materialInstances) {
+        materialInstance.second.forEach([&allocator, &allocationIds](const FMaterialInstance* mi) {
+            if (!mi->isUsingUboBatching()) {
+                return;
+            }

-        mAllocator.acquireGpu(id);
-        allocationIds.insert(id);
+            const AllocationId id = mi->getAllocationId();
+            if (!BufferAllocator::isValid(id)) {
+                return;
+            }
+
+            allocator.acquireGpu(id);
+            allocationIds.insert(id);
+        });
    }

    mFenceManager.track(driver, std::move(allocationIds));
@@ -180,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);
+        });
    }
 }

@@ -288,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
@@ -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;
@@ -97,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);
@@ -106,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 {
@@ -142,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;
@@ -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;
    }
 }

@@ -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 };
@@ -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)
@@ -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
@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
  spec.name = "Filament"
-  spec.version = "1.67.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.67.1/filament-v1.67.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 = {
@@ -28,9 +28,9 @@

 namespace filament::descriptor_sets {

+backend::DescriptorSetLayout const& getPostProcessLayout() noexcept;
 backend::DescriptorSetLayout const& getDepthVariantLayout() noexcept;
 backend::DescriptorSetLayout const& getSsrVariantLayout() noexcept;
-
 backend::DescriptorSetLayout const& getPerRenderableLayout() noexcept;

 backend::DescriptorSetLayout getPerViewDescriptorSetLayout(
@@ -40,7 +40,12 @@ namespace filament::descriptor_sets {

 using namespace backend;

-// used to generate shadow-maps, structure and postfx passes
+// used for post-processing passes
+static constexpr std::initializer_list<DescriptorSetLayoutBinding> postProcessDescriptorSetLayoutList = {
+    { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FRAME_UNIFORMS },
+};
+
+// used to generate shadow-maps
 static constexpr std::initializer_list<DescriptorSetLayoutBinding> depthVariantDescriptorSetLayoutList = {
    { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FRAME_UNIFORMS },
 };
@@ -137,6 +142,10 @@ static const std::unordered_map<
        {{ SamplerType::SAMPLER_EXTERNAL, SamplerFormat::FLOAT }, DescriptorType::SAMPLER_EXTERNAL }
 };

+// used for post-processing passes
+static DescriptorSetLayout const postProcessDescriptorSetLayout{ utils::StaticString("postProcess"),
+    postProcessDescriptorSetLayoutList };
+
 // used to generate shadow-maps
 static DescriptorSetLayout const depthVariantDescriptorSetLayout{
    utils::StaticString("depthVariant"), depthVariantDescriptorSetLayoutList
@@ -154,6 +163,10 @@ static DescriptorSetLayout perRenderableDescriptorSetLayout = {
    utils::StaticString("perRenderable"), perRenderableDescriptorSetLayoutList
 };

+DescriptorSetLayout const& getPostProcessLayout() noexcept {
+    return postProcessDescriptorSetLayout;
+}
+
 DescriptorSetLayout const& getDepthVariantLayout() noexcept {
    return depthVariantDescriptorSetLayout;
 }
@@ -267,10 +280,10 @@ DescriptorSetLayout getPerViewDescriptorSetLayout(
            return layout;
        }
        case MaterialDomain::POST_PROCESS:
-            return depthVariantDescriptorSetLayout;
+            return postProcessDescriptorSetLayout;
        case MaterialDomain::COMPUTE:
            // TODO: what's the layout for compute?
-            return depthVariantDescriptorSetLayout;
+            return postProcessDescriptorSetLayout;
    }
 }

@@ -129,9 +129,9 @@ DescriptorSetLayout getPerMaterialDescriptorSet(SamplerInterfaceBlock const& sib
    DescriptorSetLayout layout;
    layout.bindings.reserve(1 + samplers.size());

-    layout.bindings.push_back(DescriptorSetLayoutBinding{ DescriptorType::UNIFORM_BUFFER,
-        ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,
-        +PerMaterialBindingPoints::MATERIAL_PARAMS, DescriptorFlags::DYNAMIC_OFFSET, 0 });
+    layout.bindings.push_back(DescriptorSetLayoutBinding { DescriptorType::UNIFORM_BUFFER,
+            ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,
+            +PerMaterialBindingPoints::MATERIAL_PARAMS, DescriptorFlags::NONE, 0 });

    for (auto const& sampler: samplers) {
        DescriptorSetLayoutBinding layoutBinding{
@@ -225,7 +225,7 @@ void MaterialDescriptorSetLayoutChunk::flatten(Flattener& f) {
    f.writeUint8(uint8_t(DescriptorType::UNIFORM_BUFFER));
    f.writeUint8(uint8_t(ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT));
    f.writeUint8(0);
-    f.writeUint8(uint8_t(DescriptorFlags::DYNAMIC_OFFSET));
+    f.writeUint8(uint8_t(DescriptorFlags::NONE));
    f.writeUint16(0);

    // all the material's sampler descriptors
@@ -281,7 +281,7 @@ static bool printParametersInfo(ostream& text, const ChunkContainer& container)
        }

        text << "    "
-                  << setw(alignment) << fieldName.c_str_safe()
+                  << setw(alignment) << fieldName.c_str()
                  << setw(shortAlignment) << toString(UniformType(fieldType))
                  << arraySizeToString(fieldSize)
                  << setw(shortAlignment) << toString(Precision(fieldPrecision))
@@ -325,7 +325,7 @@ static bool printParametersInfo(ostream& text, const ChunkContainer& container)
        }

        text << "    "
-                << setw(alignment) << fieldName.c_str_safe()
+                << setw(alignment) << fieldName.c_str()
                << setw(shortAlignment) << +fieldBinding
                << setw(shortAlignment) << toString(SamplerType(fieldType))
                << setw(shortAlignment) << toString(Precision(fieldPrecision))
@@ -364,7 +364,7 @@ static bool printConstantInfo(ostream& text, const ChunkContainer& container) {
        }

         text << "    "
-         << setw(alignment) << fieldName.c_str_safe()
+         << setw(alignment) << fieldName.c_str()
         << setw(shortAlignment) << toString(ConstantType(fieldType))
         << endl;
    }
@@ -56,9 +56,6 @@ public:
    //! Returns true if the map is full.
    bool full() const noexcept { return mSize == N; }

-    //! Clears the map entirely.
-    void clear() noexcept { mSize = 0; mHead = 0; }
-
    /**
     * Inserts a new key-value pair.
     * The key must be greater than the key of the last inserted element.
@@ -68,7 +65,7 @@ public:
     */
    UTILS_NOINLINE void insert(key_type key, mapped_type value) {
        assert(empty() || key > back().first); // assert monotonic
-        if (UTILS_LIKELY(full())) {
+        if (full()) {
            // container is full, replace the oldest element
            mStorage[mHead] = { key, value };
            mHead = (mHead + 1) % N;
@@ -302,16 +302,14 @@ vec4 evaluateLights(const MaterialInputs material) {
    return vec4(color, computeDiffuseAlpha(material.baseColor.a));
 }

-vec3 emissive(const MaterialInputs material, float alpha) {
+void addEmissive(const MaterialInputs material, inout vec4 color) {
 #if defined(MATERIAL_HAS_EMISSIVE)
    highp vec4 emissive = material.emissive;
    highp float attenuation = mix(1.0, getExposure(), emissive.w);
 #if defined(BLEND_MODE_TRANSPARENT) || defined(BLEND_MODE_FADE)
-    attenuation *= alpha;
+    attenuation *= color.a;
 #endif
-    return emissive.rgb * attenuation;
-#else
-    return vec3(0.0);
+    color.rgb += emissive.rgb * attenuation;
 #endif
 }

@@ -323,7 +321,7 @@ vec3 emissive(const MaterialInputs material, float alpha) {
 */
 vec4 evaluateMaterial(const MaterialInputs material) {
    vec4 color = evaluateLights(material);
-    color.rgb += emissive(material, color.a);
+    addEmissive(material, color);
    // kill +inf generated by strong highlights
    color.rgb = min(color.rgb, MEDIUMP_FLT_MAX);
    return color;
@@ -1,5 +1,5 @@
 ---
 Language:        Cpp
 BasedOnStyle:  Google
-PointerAlignment: Left
 ...
+
@@ -1,37 +0,0 @@
---
-Checks: >
-  abseil-*,
-  bugprone-*,
-  clang-analyzer-*,
-  cppcoreguidelines-*,
-  google-*,
-  misc-*,
-  performance-*,
-  readability-*,
-  -clang-analyzer-deadcode*,
-  -clang-analyzer-optin*,
-  -readability-identifier-length
-WarningsAsErrors: ''
-HeaderFilterRegex: ''
-FormatStyle:     none
-CheckOptions:
-  llvm-else-after-return.WarnOnConditionVariables: 'false'
-  modernize-loop-convert.MinConfidence: reasonable
-  modernize-replace-auto-ptr.IncludeStyle: llvm
-  cert-str34-c.DiagnoseSignedUnsignedCharComparisons: 'false'
-  google-readability-namespace-comments.ShortNamespaceLines: '10'
-  cert-err33-c.CheckedFunctions: '::aligned_alloc;::asctime_s;::at_quick_exit;::atexit;::bsearch;::bsearch_s;::btowc;::c16rtomb;::c32rtomb;::calloc;::clock;::cnd_broadcast;::cnd_init;::cnd_signal;::cnd_timedwait;::cnd_wait;::ctime_s;::fclose;::fflush;::fgetc;::fgetpos;::fgets;::fgetwc;::fopen;::fopen_s;::fprintf;::fprintf_s;::fputc;::fputs;::fputwc;::fputws;::fread;::freopen;::freopen_s;::fscanf;::fscanf_s;::fseek;::fsetpos;::ftell;::fwprintf;::fwprintf_s;::fwrite;::fwscanf;::fwscanf_s;::getc;::getchar;::getenv;::getenv_s;::gets_s;::getwc;::getwchar;::gmtime;::gmtime_s;::localtime;::localtime_s;::malloc;::mbrtoc16;::mbrtoc32;::mbsrtowcs;::mbsrtowcs_s;::mbstowcs;::mbstowcs_s;::memchr;::mktime;::mtx_init;::mtx_lock;::mtx_timedlock;::mtx_trylock;::mtx_unlock;::printf_s;::putc;::putwc;::raise;::realloc;::remove;::rename;::scanf;::scanf_s;::setlocale;::setvbuf;::signal;::snprintf;::snprintf_s;::sprintf;::sprintf_s;::sscanf;::sscanf_s;::strchr;::strerror_s;::strftime;::strpbrk;::strrchr;::strstr;::strtod;::strtof;::strtoimax;::strtok;::strtok_s;::strtol;::strtold;::strtoll;::strtoul;::strtoull;::strtoumax;::strxfrm;::swprintf;::swprintf_s;::swscanf;::swscanf_s;::thrd_create;::thrd_detach;::thrd_join;::thrd_sleep;::time;::timespec_get;::tmpfile;::tmpfile_s;::tmpnam;::tmpnam_s;::tss_create;::tss_get;::tss_set;::ungetc;::ungetwc;::vfprintf;::vfprintf_s;::vfscanf;::vfscanf_s;::vfwprintf;::vfwprintf_s;::vfwscanf;::vfwscanf_s;::vprintf_s;::vscanf;::vscanf_s;::vsnprintf;::vsnprintf_s;::vsprintf;::vsprintf_s;::vsscanf;::vsscanf_s;::vswprintf;::vswprintf_s;::vswscanf;::vswscanf_s;::vwprintf_s;::vwscanf;::vwscanf_s;::wcrtomb;::wcschr;::wcsftime;::wcspbrk;::wcsrchr;::wcsrtombs;::wcsrtombs_s;::wcsstr;::wcstod;::wcstof;::wcstoimax;::wcstok;::wcstok_s;::wcstol;::wcstold;::wcstoll;::wcstombs;::wcstombs_s;::wcstoul;::wcstoull;::wcstoumax;::wcsxfrm;::wctob;::wctrans;::wctype;::wmemchr;::wprintf_s;::wscanf;::wscanf_s;'
-  cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField: 'false'
-  cert-dcl16-c.NewSuffixes: 'L;LL;LU;LLU'
-  google-readability-braces-around-statements.ShortStatementLines: '1'
-  cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic: 'true'
-  google-readability-namespace-comments.SpacesBeforeComments: '2'
-  modernize-loop-convert.MaxCopySize: '16'
-  modernize-pass-by-value.IncludeStyle: llvm
-  modernize-use-nullptr.NullMacros: 'NULL'
-  llvm-qualified-auto.AddConstToQualified: 'false'
-  modernize-loop-convert.NamingStyle: CamelCase
-  llvm-else-after-return.WarnOnUnfixable: 'false'
-  google-readability-function-size.StatementThreshold: '800'
-...
-
@@ -1 +0,0 @@
-.*third_party/.*
@@ -1,32 +0,0 @@
---
-name: Bug report
-about: Create a report to help us improve
-title: "[BUG]"
-labels: ''
-assignees: ''
-
---
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**System**
-Which OS, compiler, and compiler version are you using:
-  - OS: 
-  - Compiler and version: 
-
-**To reproduce**
-Steps to reproduce the behavior:
-1. sync to commit ...
-2. cmake/bazel...
-3. make ...
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Additional context**
-Add any other context about the problem here.
@@ -1,20 +0,0 @@
---
-name: Feature request
-about: Suggest an idea for this project
-title: "[FR]"
-labels: ''
-assignees: ''
-
---
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.
@@ -1,12 +0,0 @@
-if ! bazel version; then
-  arch=$(uname -m)
-  if [ "$arch" == "aarch64" ]; then
-    arch="arm64"
-  fi
-  echo "Downloading $arch Bazel binary from GitHub releases."
-  curl -L -o $HOME/bin/bazel --create-dirs "https://github.com/bazelbuild/bazel/releases/download/8.2.0/bazel-8.2.0-linux-$arch"
-  chmod +x $HOME/bin/bazel
-else
-  # Bazel is installed for the correct architecture
-  exit 0
-fi
@@ -1,35 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-# Checkout LLVM sources
-git clone --filter=blob:none --depth=1 --branch llvmorg-19.1.6 --no-checkout https://github.com/llvm/llvm-project.git llvm-project
-cd llvm-project
-git sparse-checkout set --cone
-git checkout llvmorg-19.1.6
-git sparse-checkout set cmake llvm/cmake runtimes libcxx libcxxabi
-cd ..
-
-## Setup libc++ options
-if [ -z "$BUILD_32_BITS" ]; then
-  export BUILD_32_BITS=OFF && echo disabling 32 bit build
-fi
-
-## Build and install libc++ (Use unstable ABI for better sanitizer coverage)
-mkdir llvm-build && cd llvm-build
-cmake -GNinja                                   \
-      -DCMAKE_C_COMPILER=${CC}                  \
-      -DCMAKE_CXX_COMPILER=${CXX}               \
-      -DCMAKE_BUILD_TYPE=RelWithDebInfo         \
-      -DCMAKE_INSTALL_PREFIX=/usr               \
-      -DLIBCXX_ABI_UNSTABLE=OFF                 \
-      -DLLVM_USE_SANITIZER=${LIBCXX_SANITIZER}  \
-      -DLLVM_BUILD_32_BITS=${BUILD_32_BITS}     \
-      -DLIBCXXABI_USE_LLVM_UNWINDER=OFF         \
-      -DLLVM_INCLUDE_TESTS=OFF                  \
-      -DLIBCXX_INCLUDE_TESTS=OFF                \
-      -DLIBCXX_INCLUDE_BENCHMARKS=OFF           \
-      -DLLVM_ENABLE_RUNTIMES='libcxx;libcxxabi' \
-      ../llvm-project/runtimes/
-cmake --build . -- cxx cxxabi
-cd ..
@@ -1,37 +0,0 @@
-name: bazel
-
-on:
-  push: {}
-  pull_request: {}
-
-env:
-  CMAKE_GENERATOR: Ninja
-
-jobs:
-  build_and_test_default:
-    name: bazel.${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: mount bazel cache
-      uses: actions/cache@v4
-      env:
-        cache-name: bazel-cache
-      with:
-        path: "~/.cache/bazel"
-        key: ${{ env.cache-name }}-${{ matrix.os }}-${{ github.ref }}
-        restore-keys: |
-          ${{ env.cache-name }}-${{ matrix.os }}-main
-
-    - name: build
-      run: |
-        bazel build //:benchmark //:benchmark_main //test/...
-
-    - name: test
-      run: |
-        bazel test --test_output=all //test/...
@@ -1,49 +0,0 @@
-name: build-and-test-min-cmake
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-env:
-  CMAKE_GENERATOR: Ninja
-
-jobs:
-  job:
-    name: ${{ matrix.os }}.min-cmake
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest]
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: lukka/get-cmake@latest
-        with:
-          cmakeVersion: 3.13.0
-
-      - name: create build environment
-        run: cmake -E make_directory ${{ runner.workspace }}/_build
-
-      - name: setup cmake initial cache
-        run: touch compiler-cache.cmake
-
-      - name: configure cmake
-        env:
-          CXX: ${{ matrix.compiler }}
-        shell: bash
-        working-directory: ${{ runner.workspace }}/_build
-        run: >
-          cmake -C ${{ github.workspace }}/compiler-cache.cmake
-          $GITHUB_WORKSPACE
-          -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-          -DCMAKE_CXX_VISIBILITY_PRESET=hidden
-          -DCMAKE_VISIBILITY_INLINES_HIDDEN=ON
-
-      - name: build
-        shell: bash
-        working-directory: ${{ runner.workspace }}/_build
-        run: cmake --build .
@@ -1,54 +0,0 @@
-name: build-and-test-perfcounters
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-env:
-  CMAKE_GENERATOR: Ninja
-
-jobs:
-  job:
-    # TODO(dominic): Extend this to include compiler and set through env: CC/CXX.
-    name: ${{ matrix.os }}.${{ matrix.build_type }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest]
-        build_type: ['Release', 'Debug']
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: install libpfm
-      run: |
-        sudo apt update
-        sudo apt -y install libpfm4-dev
-
-    - name: create build environment
-      run: cmake -E make_directory ${{ runner.workspace }}/_build
-
-    - name: configure cmake
-      shell: bash
-      working-directory: ${{ runner.workspace }}/_build
-      run: >
-        cmake $GITHUB_WORKSPACE
-        -DBENCHMARK_ENABLE_LIBPFM=1
-        -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-        -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
-
-    - name: build
-      shell: bash
-      working-directory: ${{ runner.workspace }}/_build
-      run: cmake --build . --config ${{ matrix.build_type }}
-
-    # Skip testing, for now. It seems perf_event_open does not succeed on the
-    # hosting machine, very likely a permissions issue.
-    # TODO(mtrofin): Enable test.
-    # - name: test
-    #   shell: bash
-    #   working-directory: ${{ runner.workspace }}/_build
-    #   run: ctest -C ${{ matrix.build_type }} --rerun-failed --output-on-failure
-
@@ -1,151 +0,0 @@
-name: build-and-test
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-env:
-  CMAKE_GENERATOR: Ninja
-
-jobs:
-  # TODO: add 32-bit builds (g++ and clang++) for ubuntu
-  #   (requires g++-multilib and libc6:i386)
-  # TODO: add coverage build (requires lcov)
-  # TODO: add clang + libc++ builds for ubuntu
-  job:
-    name: ${{ matrix.os }}.${{ matrix.build_type }}.${{ matrix.lib }}.${{ matrix.compiler }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-24.04, ubuntu-22.04, ubuntu-24.04-arm, macos-latest]
-        build_type: ['Release', 'Debug']
-        compiler: ['g++', 'clang++']
-        lib: ['shared', 'static']
-
-    steps:
-      - name: Install dependencies (macos)
-        if: runner.os == 'macOS'
-        run: brew install ninja
-
-      - uses: actions/checkout@v4
-
-      - name: build
-        uses: threeal/cmake-action@v2.1.0
-        with:
-          build-dir: ${{ runner.workspace }}/_build
-          cxx-compiler: ${{ matrix.compiler }}
-          options: |
-            BENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-            BUILD_SHARED_LIBS=${{ matrix.lib == 'shared' }}
-            CMAKE_BUILD_TYPE=${{ matrix.build_type }}
-            CMAKE_CXX_COMPILER=${{ matrix.compiler }}
-            CMAKE_CXX_VISIBILITY_PRESET=hidden
-            CMAKE_VISIBILITY_INLINES_HIDDEN=ON
-
-      - name: test
-        shell: bash
-        working-directory: ${{ runner.workspace }}/_build
-        run: ctest -C ${{ matrix.build_type }} -VV
-
-  msvc:
-    name: ${{ matrix.os }}.${{ matrix.build_type }}.${{ matrix.lib }}.${{ matrix.msvc }}
-    runs-on: ${{ matrix.os }}
-    defaults:
-        run:
-            shell: powershell
-    strategy:
-      fail-fast: false
-      matrix:
-        msvc:
-          - VS-16-2019
-          - VS-17-2022
-        build_type:
-          - Debug
-          - Release
-        lib:
-          - shared
-          - static
-        include:
-          - msvc: VS-16-2019
-            os: windows-2019
-            generator: 'Visual Studio 16 2019'
-          - msvc: VS-17-2022
-            os: windows-2022
-            generator: 'Visual Studio 17 2022'
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: lukka/get-cmake@latest
-
-      - name: configure cmake
-        run: >
-          cmake -S . -B ${{ runner.workspace }}/_build/
-          -G "${{ matrix.generator }}"
-          -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-          -DBUILD_SHARED_LIBS=${{ matrix.lib == 'shared' }}
-
-      - name: build
-        run: cmake --build ${{ runner.workspace }}/_build/ --config ${{ matrix.build_type }}
-
-      - name: test
-        run: ctest --test-dir ${{ runner.workspace }}/_build/ -C ${{ matrix.build_type }} -VV
-
-  msys2:
-    name: ${{ matrix.os }}.${{ matrix.build_type }}.${{ matrix.lib }}.${{ matrix.msys2.msystem }}
-    runs-on: ${{ matrix.os }}
-    defaults:
-        run:
-            shell: msys2 {0}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ windows-latest ]
-        msys2:
-          - { msystem: MINGW64,    arch: x86_64,  family: GNU,  compiler: g++ }
-          - { msystem: CLANG64,    arch: x86_64,  family: LLVM, compiler: clang++ }
-          - { msystem: UCRT64,     arch: x86_64,  family: GNU,  compiler: g++ }
-        build_type:
-          - Debug
-          - Release
-        lib:
-          - shared
-          - static
-
-    steps:
-      - name: setup msys2
-        uses: msys2/setup-msys2@v2
-        with:
-          cache: false
-          msystem: ${{ matrix.msys2.msystem }}
-          update: true
-          install: >-
-            git
-            base-devel
-          pacboy: >-
-            gcc:p
-            clang:p
-            cmake:p
-            ninja:p
-
-      - uses: actions/checkout@v4
-
-      # NOTE: we can't use cmake actions here as we need to do everything in msys2 shell.
-      - name: configure cmake
-        env:
-          CXX: ${{ matrix.msys2.compiler }}
-        run: >
-          cmake -S . -B _build/
-          -GNinja
-          -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-          -DBUILD_SHARED_LIBS=${{ matrix.lib == 'shared' }}
-
-      - name: build
-        run: cmake --build _build/ --config ${{ matrix.build_type }}
-
-      - name: test
-        working-directory: _build
-        run: ctest -C ${{ matrix.build_type }} -VV
@@ -1,19 +0,0 @@
-name: clang-format-lint
-on:
-  push: {}
-  pull_request: {}
-
-env:
-  CMAKE_GENERATOR: Ninja
-
-jobs:
-  job:
-    name: check-clang-format
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - uses: DoozyX/clang-format-lint-action@v0.18.2
-      with:
-        source: './include/benchmark ./src ./test'
-        clangFormatVersion: 18
@@ -1,41 +0,0 @@
-name: clang-tidy
-
-on:
-  push: {}
-  pull_request: {}
-
-env:
-  CMAKE_GENERATOR: Ninja
-
-jobs:
-  job:
-    name: run-clang-tidy
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: install clang-tidy
-      run: sudo apt update && sudo apt -y install clang-tidy
-
-    - name: create build environment
-      run: cmake -E make_directory ${{ github.workspace }}/_build
-
-    - name: configure cmake
-      shell: bash
-      working-directory: ${{ github.workspace }}/_build
-      run: >
-        cmake $GITHUB_WORKSPACE
-        -DBENCHMARK_ENABLE_ASSEMBLY_TESTS=OFF
-        -DBENCHMARK_ENABLE_LIBPFM=OFF
-        -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-        -DCMAKE_C_COMPILER=clang
-        -DCMAKE_CXX_COMPILER=clang++
-        -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
-        -DGTEST_COMPILE_COMMANDS=OFF
-
-    - name: run
-      shell: bash
-      working-directory: ${{ github.workspace }}/_build
-      run: run-clang-tidy -config-file=$GITHUB_WORKSPACE/.clang-tidy
@@ -1,31 +0,0 @@
-name: doxygen
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-env:
-  CMAKE_GENERATOR: Ninja
-
-jobs:
-  build-and-deploy:
-    name: Build HTML documentation
-    runs-on: ubuntu-latest
-    steps:
-    - name: Fetching sources
-      uses: actions/checkout@v4
-
-    - name: Installing build dependencies
-      run: |
-        sudo apt update
-        sudo apt install doxygen gcc git
-
-    - name: Creating build directory
-      run: mkdir build
-
-    - name: Building HTML documentation with Doxygen
-      run: |
-        cmake -S . -B build -DBENCHMARK_ENABLE_TESTING:BOOL=OFF -DBENCHMARK_ENABLE_DOXYGEN:BOOL=ON -DBENCHMARK_INSTALL_DOCS:BOOL=ON
-        cmake --build build --target benchmark_doxygen
@@ -1,41 +0,0 @@
-name: python + Bazel pre-commit checks
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-env:
-  CMAKE_GENERATOR: Ninja
-
-jobs:
-  pre-commit:
-    runs-on: ubuntu-latest
-    env:
-      MYPY_CACHE_DIR: "${{ github.workspace }}/.cache/mypy"
-      RUFF_CACHE_DIR: "${{ github.workspace }}/.cache/ruff"
-      PRE_COMMIT_HOME: "${{ github.workspace }}/.cache/pre-commit"
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: 3.11
-        cache: pip
-        cache-dependency-path: pyproject.toml
-    - name: Install dependencies
-      run: python -m pip install ".[dev]"
-    - name: Cache pre-commit tools
-      uses: actions/cache@v4
-      with:
-        path: |
-          ${{ env.MYPY_CACHE_DIR }}
-          ${{ env.RUFF_CACHE_DIR }}
-          ${{ env.PRE_COMMIT_HOME }}
-        key: ${{ runner.os }}-${{ hashFiles('.pre-commit-config.yaml') }}-linter-cache
-    - name: Run pre-commit checks
-      run: pre-commit run --all-files --verbose --show-diff-on-failure
@@ -1,97 +0,0 @@
-name: sanitizer
-
-on:
-  push: {}
-  pull_request: {}
-
-env:
-  CMAKE_GENERATOR: Ninja
-  UBSAN_OPTIONS: "print_stacktrace=1"
-
-jobs:
-  job:
-    name: ${{ matrix.sanitizer }}.${{ matrix.build_type }}
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        build_type: ['Debug', 'RelWithDebInfo']
-        sanitizer: ['asan', 'ubsan', 'tsan', 'msan']
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: configure msan env
-      if: matrix.sanitizer == 'msan'
-      run: |
-        echo "EXTRA_FLAGS=-g -O2 -fno-omit-frame-pointer -fsanitize=memory -fsanitize-memory-track-origins" >> $GITHUB_ENV
-        echo "LIBCXX_SANITIZER=MemoryWithOrigins" >> $GITHUB_ENV
-
-    - name: configure ubsan env
-      if: matrix.sanitizer == 'ubsan'
-      run: |
-        echo "EXTRA_FLAGS=-g -O2 -fno-omit-frame-pointer -fsanitize=undefined -fno-sanitize-recover=all" >> $GITHUB_ENV
-        echo "LIBCXX_SANITIZER=Undefined" >> $GITHUB_ENV
-
-    - name: configure asan env
-      if: matrix.sanitizer == 'asan'
-      run: |
-        echo "EXTRA_FLAGS=-g -O2 -fno-omit-frame-pointer -fsanitize=address -fno-sanitize-recover=all" >> $GITHUB_ENV
-        echo "LIBCXX_SANITIZER=Address" >> $GITHUB_ENV
-
-    - name: configure tsan env
-      if: matrix.sanitizer == 'tsan'
-      run: |
-        echo "EXTRA_FLAGS=-g -O2 -fno-omit-frame-pointer -fsanitize=thread -fno-sanitize-recover=all" >> $GITHUB_ENV
-        echo "LIBCXX_SANITIZER=Thread" >> $GITHUB_ENV
-
-    - name: fine-tune asan options
-      # in asan we get an error from std::regex. ignore it.
-      if: matrix.sanitizer == 'asan'
-      run: |
-        echo "ASAN_OPTIONS=alloc_dealloc_mismatch=0" >> $GITHUB_ENV
-
-    - name: setup clang
-      uses: egor-tensin/setup-clang@v1
-      with:
-        version: latest
-        platform: x64
-
-    - name: configure clang
-      run: |
-        echo "CC=cc" >> $GITHUB_ENV
-        echo "CXX=c++" >> $GITHUB_ENV
-
-    - name: build libc++ (non-asan)
-      if: matrix.sanitizer != 'asan'
-      run: |
-        "${GITHUB_WORKSPACE}/.github/libcxx-setup.sh"
-        echo "EXTRA_CXX_FLAGS=-stdlib=libc++ -L${GITHUB_WORKSPACE}/llvm-build/lib -lc++abi -I${GITHUB_WORKSPACE}/llvm-build/include/c++/v1 -Isystem${GITHUB_WORKSPACE}/llvm-build/include/c++/v1 -Wl,-rpath,${GITHUB_WORKSPACE}/llvm-build/lib" >> $GITHUB_ENV
-
-    - name: create build environment
-      run: cmake -E make_directory ${{ runner.workspace }}/_build
-
-    - name: configure cmake
-      shell: bash
-      working-directory: ${{ runner.workspace }}/_build
-      run: >
-        VERBOSE=1
-        cmake -GNinja $GITHUB_WORKSPACE
-        -DBENCHMARK_ENABLE_ASSEMBLY_TESTS=OFF
-        -DBENCHMARK_ENABLE_LIBPFM=OFF
-        -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-        -DCMAKE_C_COMPILER=${{ env.CC }}
-        -DCMAKE_CXX_COMPILER=${{ env.CXX }}
-        -DCMAKE_C_FLAGS="${{ env.EXTRA_FLAGS }}"
-        -DCMAKE_CXX_FLAGS="${{ env.EXTRA_FLAGS }} ${{ env.EXTRA_CXX_FLAGS }}"
-        -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
-
-    - name: build
-      shell: bash
-      working-directory: ${{ runner.workspace }}/_build
-      run: cmake --build . --config ${{ matrix.build_type }}
-
-    - name: test
-      shell: bash
-      working-directory: ${{ runner.workspace }}/_build
-      run: ctest -C ${{ matrix.build_type }} -VV
@@ -1,33 +0,0 @@
-name: test-bindings
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-env:
-  CMAKE_GENERATOR: Ninja
-
-jobs:
-  python_bindings:
-    name: Test GBM Python ${{ matrix.python-version }} bindings on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ ubuntu-latest, macos-latest, windows-latest ]
-        python-version: [ "3.10", "3.11", "3.12", "3.13" ]
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-      - name: Install GBM Python bindings on ${{ matrix.os }}
-        run: python -m pip install .
-      - name: Run example on ${{ matrix.os }} under Python ${{ matrix.python-version }}
-        run: python bindings/python/google_benchmark/example.py
@@ -1,83 +0,0 @@
-name: Build and upload Python wheels
-
-on:
-  workflow_dispatch:
-  release:
-    types:
-      - published
-
-env:
-  CMAKE_GENERATOR: Ninja
-
-jobs:
-  build_sdist:
-    name: Build source distribution
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out repo
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Install Python 3.12
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-      - run: python -m pip install build
-      - name: Build sdist
-        run: python -m build --sdist
-      - uses: actions/upload-artifact@v4
-        with:
-          name: dist-sdist
-          path: dist/*.tar.gz
-
-  build_wheels:
-    name: Build Google Benchmark wheels on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, ubuntu-24.04-arm, macos-13, macos-14, windows-latest]
-    steps:
-      - name: Check out Google Benchmark
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - uses: actions/setup-python@v5
-        name: Install Python 3.12
-        with:
-          python-version: "3.12"
-      - run: pip install --upgrade pip uv
-
-      - name: Build wheels on ${{ matrix.os }} using cibuildwheel
-        uses: pypa/cibuildwheel@v2.23.2
-        env:
-          CIBW_BUILD: "cp310-* cp311-* cp312-*"
-          CIBW_BUILD_FRONTEND: "build[uv]"
-          CIBW_SKIP: "*-musllinux_*"
-          CIBW_ARCHS: auto64
-          CIBW_BEFORE_ALL_LINUX: bash .github/install_bazel.sh
-          # Grab the rootless Bazel installation inside the container.
-          CIBW_ENVIRONMENT_LINUX: PATH=$PATH:$HOME/bin
-          CIBW_TEST_COMMAND: python {project}/bindings/python/google_benchmark/example.py
-          # unused by Bazel, but needed explicitly by delocate on MacOS.
-          MACOSX_DEPLOYMENT_TARGET: "10.14"
-
-      - name: Upload Google Benchmark ${{ matrix.os }} wheels
-        uses: actions/upload-artifact@v4
-        with:
-          name: dist-${{ matrix.os }}
-          path: wheelhouse/*.whl
-
-  pypi_upload:
-    name: Publish google-benchmark wheels to PyPI
-    needs: [build_sdist, build_wheels]
-    runs-on: ubuntu-latest
-    permissions:
-      id-token: write
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          path: dist
-          pattern: dist-*
-          merge-multiple: true
-      - uses: pypa/gh-action-pypi-publish@release/v1
@@ -8,10 +8,8 @@
 !/cmake/*.cmake
 !/test/AssemblyTests.cmake
 *~
-*.swp
 *.pyc
 __pycache__
-.DS_Store

 # lcov
 *.lcov
@@ -46,7 +44,6 @@ rules.ninja

 # bazel output symlinks.
 bazel-*
-MODULE.bazel.lock

 # out-of-source build top-level folders.
 build/
@@ -59,10 +56,3 @@ build*/
 # Visual Studio 2015/2017 cache/options directory
 .vs/
 CMakeSettings.json
-
-# Visual Studio Code cache/options directory
-.vscode/
-
-# Python build stuff
-dist/
-*.egg-info*
@@ -1,18 +0,0 @@
-repos:
-  -   repo: https://github.com/keith/pre-commit-buildifier
-      rev: 8.0.3
-      hooks:
-      -   id: buildifier
-      -   id: buildifier-lint
-  - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.15.0
-    hooks:
-      - id: mypy
-        types_or: [ python, pyi ]
-        args: [ "--ignore-missing-imports", "--scripts-are-modules" ]
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.8
-    hooks:
-      - id: ruff
-        args: [ --fix, --exit-non-zero-on-fix ]
-      - id: ruff-format
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+
+# Install a newer CMake version
+curl -sSL https://cmake.org/files/v3.6/cmake-3.6.1-Linux-x86_64.sh -o install-cmake.sh
+chmod +x install-cmake.sh
+sudo ./install-cmake.sh --prefix=/usr/local --skip-license
+
+# Checkout LLVM sources
+git clone --depth=1 https://github.com/llvm-mirror/llvm.git llvm-source
+git clone --depth=1 https://github.com/llvm-mirror/libcxx.git llvm-source/projects/libcxx
+git clone --depth=1 https://github.com/llvm-mirror/libcxxabi.git llvm-source/projects/libcxxabi
+
+# Setup libc++ options
+if [ -z "$BUILD_32_BITS" ]; then
+  export BUILD_32_BITS=OFF && echo disabling 32 bit build
+fi
+
+# Build and install libc++ (Use unstable ABI for better sanitizer coverage)
+mkdir llvm-build && cd llvm-build
+cmake -DCMAKE_C_COMPILER=${C_COMPILER} -DCMAKE_CXX_COMPILER=${COMPILER} \
+      -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_INSTALL_PREFIX=/usr \
+      -DLIBCXX_ABI_UNSTABLE=ON \
+      -DLLVM_USE_SANITIZER=${LIBCXX_SANITIZER} \
+      -DLLVM_BUILD_32_BITS=${BUILD_32_BITS} \
+      ../llvm-source
+make cxx -j2
+sudo make install-cxxabi install-cxx
+cd ../
--- a/Show More
+++ b/Show More