Release Filament 1.51.8

backend tests were broken by a change in TargetBufferInfo
- a field was added, which broke the layout of the structure. We fix it by adding constructors which will handle the old and new way of initializing this structure. - one of the test needed a hash update - OpenGLContext wrongly asserted when trying to unbind texture 0
2024-05-13 20:53:36 +00:00 · 2024-05-10 14:39:22 -07:00 · 2024-05-10 13:00:00 -07:00 · 2024-05-10 11:25:34 -07:00 · 2024-05-10 11:14:41 -07:00 · 2024-05-10 10:23:32 -07:00
207 changed files with 6562 additions and 2761 deletions
@@ -71,6 +71,10 @@ set(FILAMENT_METAL_HANDLE_ARENA_SIZE_IN_MB "8" CACHE STRING
    "Size of the Metal handle arena, default 8."
 )

+set(FILAMENT_BACKEND_DEBUG_FLAG "" CACHE STRING
+    "A debug flag meant for enabling/disabling backend debugging paths"
+)
+
 # Enable exceptions by default in spirv-cross.
 set(SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS OFF)

@@ -169,15 +173,6 @@ if (NOT ANDROID AND NOT WEBGL AND NOT IOS AND NOT FILAMENT_LINUX_IS_MOBILE)
    set(IS_HOST_PLATFORM TRUE)
 endif()

-if (IOS)
-    # Remove the headerpad_max_install_names linker flag on iOS. It causes warnings when linking
-    # executables with bitcode.
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_C_LINK_FLAGS ${CMAKE_C_LINK_FLAGS})
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_CXX_LINK_FLAGS ${CMAKE_CXX_LINK_FLAGS})
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS})
-endif()
-
 if (WIN32)
    # Link statically against c/c++ lib to avoid missing redistriburable such as
    # "VCRUNTIME140.dll not found. Try reinstalling the app.", but give users
@@ -389,8 +384,9 @@ endif()
 if (NOT MSVC AND NOT IOS)
    # Omitting stack frame pointers prevents the generation of readable stack traces in crash reports on iOS
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer")
+endif()

-    # These aren't compatible with -fembed-bitcode (and seem to have no effect on Apple platforms anyway)
+if (NOT MSVC)
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffunction-sections -fdata-sections")
 endif()

@@ -548,6 +544,12 @@ if (FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "multiview")
    set(FILAMENT_ENABLE_MULTIVIEW ON)
 endif ()

+# Define backend flag for debug only
+if (CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT FILAMENT_BACKEND_DEBUG_FLAG STREQUAL "")
+    add_definitions(-DFILAMENT_BACKEND_DEBUG_FLAG=${FILAMENT_BACKEND_DEBUG_FLAG})
+    unset(FILAMENT_BACKEND_DEBUG_FLAG)
+endif()
+
 # ==================================================================================================
 # Material compilation flags
 # ==================================================================================================
@@ -819,6 +821,9 @@ if (IS_HOST_PLATFORM)
    add_subdirectory(${TOOLS}/glslminifier)
    add_subdirectory(${TOOLS}/matc)
    add_subdirectory(${TOOLS}/matinfo)
+    if (NOT WIN32)  # matedit not yet supported on Windows
+        add_subdirectory(${TOOLS}/matedit)
+    endif()
    add_subdirectory(${TOOLS}/mipgen)
    add_subdirectory(${TOOLS}/normal-blending)
    add_subdirectory(${TOOLS}/resgen)
@@ -31,7 +31,7 @@ repositories {
 }

 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.51.3'
+    implementation 'com.google.android.filament:filament-android:1.51.8'
 }
 ```

@@ -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.51.3'
+pod 'Filament', '~> 1.51.8'
 ```

 ### Snapshots
@@ -7,6 +7,31 @@ 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.51.9
+
+
+## v1.51.8
+
+- filagui: Fix regression which broke WebGL
+- Add a new Engine::Config setting to control preferred shader language
+- Add `getEyeIndex` vertex API
+- ios: Remove bitcode from iOS builds
+
+## v1.51.7
+
+- Add new matedit tool
+- filagui: Support rendering `GL_TEXTURE_EXTERNAL_OES` textures.
+- `setFrameScheduledCallback` now takes a `utils::Invocable`.
+- engine: Add `isPaused()`
+
+## v1.51.6
+
+- Add new matedit tool
+- filagui: Support rendering `GL_TEXTURE_EXTERNAL_OES` textures.
+
+## v1.51.5
+
+
 ## v1.51.4


@@ -342,6 +342,21 @@ Java_com_google_android_filament_Engine_nIsValidMaterial(JNIEnv*, jclass,
    return (jboolean)engine->isValid((Material*)nativeMaterial);
 }

+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_Engine_nIsValidMaterialInstance(JNIEnv*, jclass,
+        jlong nativeEngine, jlong nativeMaterial, jlong nativeMaterialInstance) {
+    Engine* engine = (Engine *)nativeEngine;
+    return (jboolean)engine->isValid((Material*)nativeMaterial,
+            (MaterialInstance*)nativeMaterialInstance);
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+        Java_com_google_android_filament_Engine_nIsValidExpensiveMaterialInstance(JNIEnv*, jclass,
+        jlong nativeEngine, jlong nativeMaterialInstance) {
+    Engine* engine = (Engine *)nativeEngine;
+    return (jboolean)engine->isValidExpensive((MaterialInstance*)nativeMaterialInstance);
+}
+
 extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nIsValidSkybox(JNIEnv*, jclass,
        jlong nativeEngine, jlong nativeSkybox) {
@@ -391,6 +406,13 @@ Java_com_google_android_filament_Engine_nFlush(JNIEnv*, jclass,
    engine->flush();
 }

+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_Engine_nIsPaused(JNIEnv*, jclass,
+        jlong nativeEngine) {
+    Engine* engine = (Engine*) nativeEngine;
+    return (jboolean)engine->isPaused();
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_Engine_nSetPaused(JNIEnv*, jclass,
        jlong nativeEngine, jboolean paused) {
@@ -495,7 +517,9 @@ extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBu
        jlong textureUseAfterFreePoolSize, jboolean disableParallelShaderCompile,
        jint stereoscopicType, jlong stereoscopicEyeCount,
        jlong resourceAllocatorCacheSizeMB, jlong resourceAllocatorCacheMaxAge,
-        jboolean disableHandleUseAfterFreeCheck) {
+        jboolean disableHandleUseAfterFreeCheck,
+        jint preferredShaderLanguage,
+        jboolean forceGLES2Context) {
    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
    Engine::Config config = {
            .commandBufferSizeMB = (uint32_t) commandBufferSizeMB,
@@ -511,6 +535,8 @@ extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBu
            .resourceAllocatorCacheSizeMB = (uint32_t) resourceAllocatorCacheSizeMB,
            .resourceAllocatorCacheMaxAge = (uint8_t) resourceAllocatorCacheMaxAge,
            .disableHandleUseAfterFreeCheck = (bool) disableHandleUseAfterFreeCheck,
+            .preferredShaderLanguage = (Engine::Config::ShaderLanguage) preferredShaderLanguage,
+            .forceGLES2Context = (bool) forceGLES2Context,
    };
    builder->config(&config);
 }
@@ -49,6 +49,12 @@ Java_com_google_android_filament_View_nSetCamera(JNIEnv*, jclass,
    view->setCamera(camera);
 }

+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_View_nHasCamera(JNIEnv*, jclass, jlong nativeView) {
+    View* view = (View*) nativeView;
+    return (jboolean)view->hasCamera();
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetColorGrading(JNIEnv*, jclass,
        jlong nativeView, jlong nativeColorGrading) {
@@ -225,7 +225,9 @@ public class Engine {
                    config.textureUseAfterFreePoolSize, config.disableParallelShaderCompile,
                    config.stereoscopicType.ordinal(), config.stereoscopicEyeCount,
                    config.resourceAllocatorCacheSizeMB, config.resourceAllocatorCacheMaxAge,
-                    config.disableHandleUseAfterFreeCheck);
+                    config.disableHandleUseAfterFreeCheck,
+                    config.preferredShaderLanguage.ordinal(),
+                    config.forceGLES2Context);
            return this;
        }

@@ -428,6 +430,35 @@ public class Engine {
         * Disable backend handles use-after-free checks.
         */
        public boolean disableHandleUseAfterFreeCheck = false;
+
+        /*
+         * Sets a preferred shader language for Filament to use.
+         *
+         * The Metal backend supports two shader languages: MSL (Metal Shading Language) and
+         * METAL_LIBRARY (precompiled .metallib). This option controls which shader language is
+         * used when materials contain both.
+         *
+         * By default, when preferredShaderLanguage is unset, Filament will prefer METAL_LIBRARY
+         * shaders if present within a material, falling back to MSL. Setting
+         * preferredShaderLanguage to ShaderLanguage::MSL will instead instruct Filament to check
+         * for the presence of MSL in a material first, falling back to METAL_LIBRARY if MSL is not
+         * present.
+         *
+         * When using a non-Metal backend, setting this has no effect.
+         */
+        public enum ShaderLanguage {
+            DEFAULT,
+            MSL,
+            METAL_LIBRARY,
+        };
+        public ShaderLanguage preferredShaderLanguage = ShaderLanguage.DEFAULT;
+
+        /*
+         * When the OpenGL ES backend is used, setting this value to true will force a GLES2.0
+         * context if supported by the Platform, or if not, will have the backend pretend
+         * it's a GLES2 context. Ignored on other backends.
+         */
+        public boolean forceGLES2Context = false;
    }

    private Engine(long nativeEngine, Config config) {
@@ -849,6 +880,24 @@ public class Engine {
        return nIsValidMaterial(getNativeObject(), object.getNativeObject());
    }

+    /**
+     * Returns whether the object is valid.
+     * @param object Object to check for validity
+     * @return returns true if the specified object is valid.
+     */
+    public boolean isValidMaterialInstance(@NonNull Material ma, MaterialInstance mi) {
+        return nIsValidMaterialInstance(getNativeObject(), ma.getNativeObject(), mi.getNativeObject());
+    }
+
+    /**
+     * Returns whether the object is valid.
+     * @param object Object to check for validity
+     * @return returns true if the specified object is valid.
+     */
+    public boolean isValidExpensiveMaterialInstance(@NonNull MaterialInstance object) {
+        return nIsValidExpensiveMaterialInstance(getNativeObject(), object.getNativeObject());
+    }
+
    /**
     * Returns whether the object is valid.
     * @param object Object to check for validity
@@ -1209,6 +1258,17 @@ public class Engine {
        nFlush(getNativeObject());
    }

+    /**
+     * Get paused state of rendering thread.
+     *
+     * <p>Warning: This is an experimental API.
+     *
+     * @see #setPaused
+     */
+    public boolean isPaused() {
+        return nIsPaused(getNativeObject());
+    }
+
    /**
     * Pause or resume the rendering thread.
     *
@@ -1291,6 +1351,8 @@ public class Engine {
    private static native boolean nIsValidSkinningBuffer(long nativeEngine, long nativeSkinningBuffer);
    private static native boolean nIsValidIndirectLight(long nativeEngine, long nativeIndirectLight);
    private static native boolean nIsValidMaterial(long nativeEngine, long nativeMaterial);
+    private static native boolean nIsValidMaterialInstance(long nativeEngine, long nativeMaterial, long nativeMaterialInstance);
+    private static native boolean nIsValidExpensiveMaterialInstance(long nativeEngine, long nativeMaterialInstance);
    private static native boolean nIsValidSkybox(long nativeEngine, long nativeSkybox);
    private static native boolean nIsValidColorGrading(long nativeEngine, long nativeColorGrading);
    private static native boolean nIsValidTexture(long nativeEngine, long nativeTexture);
@@ -1299,6 +1361,7 @@ public class Engine {
    private static native void nDestroyEntity(long nativeEngine, int entity);
    private static native void nFlushAndWait(long nativeEngine);
    private static native void nFlush(long nativeEngine);
+    private static native boolean nIsPaused(long nativeEngine);
    private static native void nSetPaused(long nativeEngine, boolean paused);
    private static native long nGetTransformManager(long nativeEngine);
    private static native long nGetLightManager(long nativeEngine);
@@ -1321,7 +1384,9 @@ public class Engine {
            long textureUseAfterFreePoolSize, boolean disableParallelShaderCompile,
            int stereoscopicType, long stereoscopicEyeCount,
            long resourceAllocatorCacheSizeMB, long resourceAllocatorCacheMaxAge,
-            boolean disableHandleUseAfterFreeCheck);
+            boolean disableHandleUseAfterFreeCheck,
+            int preferredShaderLanguage,
+            boolean forceGLES2Context);
    private static native void nSetBuilderFeatureLevel(long nativeBuilder, int ordinal);
    private static native void nSetBuilderSharedContext(long nativeBuilder, long sharedContext);
    private static native void nSetBuilderPaused(long nativeBuilder, boolean paused);
@@ -241,6 +241,15 @@ public class View {
        nSetCamera(getNativeObject(), camera == null ? 0 : camera.getNativeObject());
    }

+    /**
+     * Query whether a camera is set.
+     * @return true if a camera is set, false otherwise
+     * @see #setCamera
+     */
+    public boolean hasCamera() {
+        return nHasCamera(getNativeObject());
+    }
+
    /**
     * Gets this View's associated Camera, or null if none has been assigned.
     *
@@ -1238,6 +1247,7 @@ public class View {
    private static native void nSetName(long nativeView, String name);
    private static native void nSetScene(long nativeView, long nativeScene);
    private static native void nSetCamera(long nativeView, long nativeCamera);
+    private static native boolean nHasCamera(long nativeView);
    private static native void nSetViewport(long nativeView, int left, int bottom, int width, int height);
    private static native void nSetVisibleLayers(long nativeView, int select, int value);
    private static native void nSetShadowingEnabled(long nativeView, boolean enabled);
@@ -86,7 +86,10 @@ set(GLTFIO_SRCS
        ${GLTFIO_DIR}/src/Wireframe.cpp
        ${GLTFIO_DIR}/src/Wireframe.h
        ${GLTFIO_DIR}/src/downcast.h
+        ${GLTFIO_DIR}/src/extended/AssetLoaderExtended.cpp
        ${GLTFIO_DIR}/src/extended/AssetLoaderExtended.h
+        ${GLTFIO_DIR}/src/extended/ResourceLoaderExtended.cpp
+        ${GLTFIO_DIR}/src/extended/ResourceLoaderExtended.h
        ${GLTFIO_DIR}/src/extended/TangentsJobExtended.cpp
        ${GLTFIO_DIR}/src/extended/TangentsJobExtended.h
        ${GLTFIO_DIR}/src/extended/TangentSpaceMeshWrapper.cpp
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.51.3
+VERSION_NAME=1.51.8

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

@@ -321,7 +321,7 @@ class MainActivity : Activity() {
            var flags = uiHelper.swapChainFlags
            if (engine.activeFeatureLevel == Engine.FeatureLevel.FEATURE_LEVEL_0) {
                if (SwapChain.isSRGBSwapChainSupported(engine)) {
-                    flags = flags or SwapChain.CONFIG_SRGB_COLORSPACE
+                    flags = flags or SwapChainFlags.CONFIG_SRGB_COLORSPACE
                }
            }

@@ -61,6 +61,11 @@ function print_help {
    echo "    -b"
    echo "        Enable Address and Undefined Behavior Sanitizers (asan/ubsan) for debugging."
    echo "        This is only for the desktop build."
+    echo "    -x value"
+    echo "        Define a preprocessor flag FILAMENT_BACKEND_DEBUG_FLAG with [value]. This is useful for"
+    echo "        enabling debug paths in the backend from the build script. For example, make a"
+    echo "        systrace-enabled build without directly changing #defines. Remember to add -f when"
+    echo "        changing this option."
    echo ""
    echo "Build types:"
    echo "    release"
@@ -172,6 +177,8 @@ MATOPT_GRADLE_OPTION=""

 ASAN_UBSAN_OPTION=""

+BACKEND_DEBUG_FLAG_OPTION=""
+
 IOS_BUILD_SIMULATOR=false
 BUILD_UNIVERSAL_LIBRARIES=false

@@ -231,6 +238,7 @@ function build_desktop_target {
            ${MATDBG_OPTION} \
            ${MATOPT_OPTION} \
            ${ASAN_UBSAN_OPTION} \
+            ${BACKEND_DEBUG_FLAG_OPTION} \
            ${architectures} \
            ../..
        ln -sf "out/cmake-${lc_target}/compile_commands.json" \
@@ -289,6 +297,7 @@ function build_webgl_with_target {
            -DCMAKE_BUILD_TYPE="$1" \
            -DCMAKE_INSTALL_PREFIX="../webgl-${lc_target}/filament" \
            -DWEBGL=1 \
+            ${BACKEND_DEBUG_FLAG_OPTION} \
            ../..
        ln -sf "out/cmake-webgl-${lc_target}/compile_commands.json" \
           ../../compile_commands.json
@@ -363,6 +372,7 @@ function build_android_target {
            ${MATDBG_OPTION} \
            ${MATOPT_OPTION} \
            ${VULKAN_ANDROID_OPTION} \
+            ${BACKEND_DEBUG_FLAG_OPTION} \
            ../..
        ln -sf "out/cmake-android-${lc_target}-${arch}/compile_commands.json" \
           ../../compile_commands.json
@@ -597,6 +607,7 @@ function build_ios_target {
            -DCMAKE_TOOLCHAIN_FILE=../../third_party/clang/iOS.cmake \
            ${MATDBG_OPTION} \
            ${MATOPT_OPTION} \
+            ${BACKEND_DEBUG_FLAG_OPTION} \
            ../..
        ln -sf "out/cmake-ios-${lc_target}-${arch}/compile_commands.json" \
           ../../compile_commands.json
@@ -730,6 +741,13 @@ function validate_build_command {
            exit 1
        fi
    fi
+
+    # Make sure FILAMENT_BACKEND_DEBUG_FLAG is only meant for debug builds
+    if [[ "${ISSUE_DEBUG_BUILD}" != "true" ]] && [[ ! -z "${BACKEND_DEBUG_FLAG_OPTION}" ]]; then
+        echo "Error: cannot specify FILAMENT_BACKEND_DEBUG_FLAG in non-debug build"
+        exit 1
+    fi
+
    set -e
 }

@@ -776,7 +794,7 @@ function check_debug_release_build {

 pushd "$(dirname "$0")" > /dev/null

-while getopts ":hacCfgijmp:q:uvslwtedk:b" opt; do
+while getopts ":hacCfgijmp:q:uvslwtedk:bx:" opt; do
    case ${opt} in
        h)
            print_help
@@ -840,7 +858,7 @@ while getopts ":hacCfgijmp:q:uvslwtedk:b" opt; do
                        echo "Platform must be one of [desktop|android|ios|webgl|all]"
                        echo ""
                        exit 1
-                    ;;    
+                    ;;
                esac
            done
            ;;
@@ -918,6 +936,8 @@ while getopts ":hacCfgijmp:q:uvslwtedk:b" opt; do
        b)  ASAN_UBSAN_OPTION="-DFILAMENT_ENABLE_ASAN_UBSAN=ON"
            echo "Enabled ASAN/UBSAN"
            ;;
+        x)  BACKEND_DEBUG_FLAG_OPTION="-DFILAMENT_BACKEND_DEBUG_FLAG=${OPTARG}"
+            ;;
        \?)
            echo "Invalid option: -${OPTARG}" >&2
            echo ""
@@ -476,7 +476,7 @@ Energy conservation is one of the key components of a good BRDF for physically b
 <p>


-For the specular term, \(f_m\) is a mirror BRDF that can be modeled with the Fresnel law, noted \(F\) in the Cook-Torrance approximation of the microfacet model integration:
+For the specular term, \(f_r\) is a mirror BRDF that can be modeled with the Fresnel law, noted \(F\) in the Cook-Torrance approximation of the microfacet model integration:

 </p><p>

@@ -857,7 +857,7 @@ The full GLSL implementation of the standard model is shown in <a href="#listing
 <span class="line">    <span class="hljs-comment">// perceptually linear roughness to roughness (see parameterization)</span></span>
 <span class="line">    <span class="hljs-type">float</span> roughness = perceptualRoughness * perceptualRoughness;</span>
 <span class="line"></span>
-<span class="line">    <span class="hljs-type">float</span> D = D_GGX(NoH, a);</span>
+<span class="line">    <span class="hljs-type">float</span> D = D_GGX(NoH, roughness);</span>
 <span class="line">    <span class="hljs-type">vec3</span>  F = F_Schlick(LoH, f0);</span>
 <span class="line">    <span class="hljs-type">float</span> V = V_SmithGGXCorrelated(NoV, NoL, roughness);</span>
 <span class="line"></span>
@@ -2425,6 +2425,7 @@ The following APIs are only available from the vertex block:
 **getWorldFromModelMatrix()**        | float4x4 |  Matrix that converts from model (object) space to world space
 **getWorldFromModelNormalMatrix()**  | float3x3 |  Matrix that converts normals from model (object) space to world space
 **getVertexIndex()**                 | int      |  Index of the current vertex
+**getEyeIndex()**                    | int      |  Index of the eye being rendered, starting at 0

 ### Fragment only

@@ -43,7 +43,7 @@ filament-viewer::part(canvas) {
 </p>

 </main>
-<script src="https://unpkg.com/filament@1.44.0/filament.js"></script>
+<script src="https://unpkg.com/filament@1.51.6/filament.js"></script>
 <script src="https://unpkg.com/gltumble"></script>
 <script src="filament-viewer.js" type="module"></script>
 </body>
@@ -163,6 +163,7 @@ set(PRIVATE_HDRS
        src/ResourceList.h
        src/ShadowMap.h
        src/ShadowMapManager.h
+        src/SharedHandle.h
        src/TypedUniformBuffer.h
        src/UniformBuffer.h
        src/components/CameraManager.h
@@ -214,6 +215,7 @@ set(PRIVATE_HDRS
 set(MATERIAL_SRCS
        src/materials/antiAliasing/fxaa.mat
        src/materials/antiAliasing/taa.mat
+        src/materials/blitDepth.mat
        src/materials/blitLow.mat
        src/materials/blitArray.mat
        src/materials/bloom/bloomDownsample.mat
@@ -478,6 +478,10 @@ if (APPLE)
       # linker from removing "unused" symbols.
       target_link_libraries(backend_test_mac PRIVATE -force_load backend_test)
       set_target_properties(backend_test_mac PROPERTIES FOLDER Tests)
+
+       # This is needed after XCode 15.3
+       set_target_properties(backend_test_mac PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
+       set_target_properties(backend_test_mac PROPERTIES INSTALL_RPATH /usr/local/lib)
    endif()
 endif()

@@ -24,12 +24,14 @@

 #include <backend/PresentCallable.h>

+#include <utils/Invocable.h>
 #include <utils/ostream.h>

 #include <math/vec4.h>

 #include <array>        // FIXME: STL headers are not allowed in public headers
 #include <type_traits>  // FIXME: STL headers are not allowed in public headers
+#include <variant>      // FIXME: STL headers are not allowed in public headers

 #include <stddef.h>
 #include <stdint.h>
@@ -90,12 +92,15 @@ static constexpr uint64_t SWAP_CHAIN_HAS_STENCIL_BUFFER         = SWAP_CHAIN_CON
 */
 static constexpr uint64_t SWAP_CHAIN_CONFIG_PROTECTED_CONTENT   = 0x40;

-
 static constexpr size_t MAX_VERTEX_ATTRIBUTE_COUNT  = 16;   // This is guaranteed by OpenGL ES.
 static constexpr size_t MAX_SAMPLER_COUNT           = 62;   // Maximum needed at feature level 3.
 static constexpr size_t MAX_VERTEX_BUFFER_COUNT     = 16;   // Max number of bound buffer objects.
 static constexpr size_t MAX_SSBO_COUNT              = 4;    // This is guaranteed by OpenGL ES.

+static constexpr size_t MAX_PUSH_CONSTANT_COUNT     = 32;   // Vulkan 1.1 spec allows for 128-byte
+                                                            // of push constant (we assume 4-byte
+                                                            // types).
+
 // Per feature level caps
 // Use (int)FeatureLevel to index this array
 static constexpr struct {
@@ -158,14 +163,16 @@ static constexpr const char* backendToString(Backend backend) {
 }

 /**
- * Defines the shader language. Similar to the above backend enum, but the OpenGL backend can select
- * between two shader languages: ESSL 1.0 and ESSL 3.0.
+ * Defines the shader language. Similar to the above backend enum, with some differences:
+ * - The OpenGL backend can select between two shader languages: ESSL 1.0 and ESSL 3.0.
+ * - The Metal backend can prefer precompiled Metal libraries, while falling back to MSL.
 */
 enum class ShaderLanguage {
    ESSL1 = 0,
    ESSL3 = 1,
    SPIRV = 2,
    MSL = 3,
+    METAL_LIBRARY = 4,
 };

 static constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguage) {
@@ -178,6 +185,8 @@ static constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguag
            return "SPIR-V";
        case ShaderLanguage::MSL:
            return "MSL";
+        case ShaderLanguage::METAL_LIBRARY:
+            return "Metal precompiled library";
    }
 }

@@ -327,7 +336,7 @@ enum class UniformType : uint8_t {
 /**
 * Supported constant parameter types
 */
- enum class ConstantType : uint8_t {
+enum class ConstantType : uint8_t {
  INT,
  FLOAT,
  BOOL
@@ -682,7 +691,7 @@ enum class TextureUsage : uint16_t {
    SUBPASS_INPUT       = 0x0020,            //!< Texture can be used as a subpass input
    BLIT_SRC            = 0x0040,            //!< Texture can be used the source of a blit()
    BLIT_DST            = 0x0080,            //!< Texture can be used the destination of a blit()
-    PROTECTED           = 0x0100,            //!< Texture can be used the destination of a blit()
+    PROTECTED           = 0x0100,            //!< Texture can be used for protected content
    DEFAULT             = UPLOADABLE | SAMPLEABLE   //!< Default texture usage
 };

@@ -1214,13 +1223,15 @@ struct StencilState {
    uint8_t padding = 0;
 };

+using PushConstantVariant = std::variant<int32_t, float, bool>;
+
 static_assert(sizeof(StencilState::StencilOperations) == 5u,
        "StencilOperations size not what was intended");

 static_assert(sizeof(StencilState) == 12u,
        "StencilState size not what was intended");

-using FrameScheduledCallback = void(*)(PresentCallable callable, void* user);
+using FrameScheduledCallback = utils::Invocable<void(backend::PresentCallable)>;

 enum class Workaround : uint16_t {
    // The EASU pass must split because shader compiler flattens early-exit branch
@@ -1237,9 +1248,6 @@ enum class Workaround : uint16_t {
    DISABLE_BLIT_INTO_TEXTURE_ARRAY,
    // Multiple workarounds needed for PowerVR GPUs
    POWER_VR_SHADER_WORKAROUNDS,
-    // The driver has some threads pinned, and we can't easily know on which core, it can hurt
-    // performance more if we end-up pinned on the same one.
-    DISABLE_THREAD_AFFINITY
 };

 //! The type of technique for stereoscopic rendering
@@ -75,6 +75,19 @@ protected:
    HandleBase(HandleBase const& rhs) noexcept = default;
    HandleBase& operator=(HandleBase const& rhs) noexcept = default;

+    HandleBase(HandleBase&& rhs) noexcept
+            : object(rhs.object) {
+        rhs.object = nullid;
+    }
+
+    HandleBase& operator=(HandleBase&& rhs) noexcept {
+        if (this != &rhs) {
+            object = rhs.object;
+            rhs.object = nullid;
+        }
+        return *this;
+    }
+
 private:
    HandleId object;
 };
@@ -89,8 +102,10 @@ struct Handle : public HandleBase {
    Handle() noexcept = default;

    Handle(Handle const& rhs) noexcept = default;
+    Handle(Handle&& rhs) noexcept = default;

    Handle& operator=(Handle const& rhs) noexcept = default;
+    Handle& operator=(Handle&& rhs) noexcept = default;

    explicit Handle(HandleId id) noexcept : HandleBase(id) { }

@@ -65,6 +65,12 @@ public:
         * Disable backend handles use-after-free checks.
         */
        bool disableHandleUseAfterFreeCheck = false;
+
+        /**
+         * Force GLES2 context if supported, or pretend the context is ES2. Only meaningful on
+         * GLES 3.x backends.
+         */
+        bool forceGLES2Context = false;
    };

    Platform() noexcept;
@@ -48,7 +48,7 @@ namespace filament::backend {
 * and optional user data:
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- * swapChain->setFrameScheduledCallback(myFrameScheduledCallback, nullptr);
+ * swapChain->setFrameScheduledCallback(nullptr, myFrameScheduledCallback);
 * if (renderer->beginFrame(swapChain)) {
 *     renderer->render(view);
 *     renderer->endFrame();
@@ -58,8 +58,6 @@ namespace filament::backend {
 * @remark Only Filament's Metal backend supports PresentCallables and frame callbacks. Other
 * backends ignore the callback (which will never be called) and proceed normally.
 *
- * @remark The SwapChain::FrameScheduledCallback is called on an arbitrary thread.
- *
 * Applications *must* call each PresentCallable they receive. Each PresentCallable represents a
 * frame that is waiting to be presented. If an application fails to call a PresentCallable, a
 * memory leak could occur. To "cancel" the presentation of a frame, pass false to the
@@ -84,6 +84,9 @@ public:
    // null terminating character.
    Program& shader(ShaderStage shader, void const* data, size_t size);

+    // sets the language of the shader sources provided with shader() (defaults to ESSL3)
+    Program& shaderLanguage(ShaderLanguage shaderLanguage);
+
    // Note: This is only needed for GLES3.0 backends, because the layout(binding=) syntax is
    //       not permitted in glsl. The backend needs a way to associate a uniform block
    //       to a binding point.
@@ -114,6 +117,14 @@ public:
    Program& specializationConstants(
            utils::FixedCapacityVector<SpecializationConstant> specConstants) noexcept;

+    struct PushConstant {
+        utils::CString name;
+        ConstantType type;
+    };
+
+    Program& pushConstants(ShaderStage stage,
+            utils::FixedCapacityVector<PushConstant> constants) noexcept;
+
    Program& cacheId(uint64_t cacheId) noexcept;

    Program& multiview(bool multiview) noexcept;
@@ -136,6 +147,8 @@ public:
    utils::CString const& getName() const noexcept { return mName; }
    utils::CString& getName() noexcept { return mName; }

+    auto const& getShaderLanguage() const { return mShaderLanguage; }
+
    utils::FixedCapacityVector<SpecializationConstant> const& getSpecializationConstants() const noexcept {
        return mSpecializationConstants;
    }
@@ -143,6 +156,15 @@ public:
        return mSpecializationConstants;
    }

+    utils::FixedCapacityVector<PushConstant> const& getPushConstants(
+            ShaderStage stage) const noexcept {
+        return mPushConstants[static_cast<uint8_t>(stage)];
+    }
+
+    utils::FixedCapacityVector<PushConstant>& getPushConstants(ShaderStage stage) noexcept {
+        return mPushConstants[static_cast<uint8_t>(stage)];
+    }
+
    uint64_t getCacheId() const noexcept { return mCacheId; }

    bool isMultiview() const noexcept { return mMultiview; }
@@ -155,10 +177,12 @@ private:
    UniformBlockInfo mUniformBlocks = {};
    SamplerGroupInfo mSamplerGroups = {};
    ShaderSource mShadersSource;
+    ShaderLanguage mShaderLanguage = ShaderLanguage::ESSL3;
    utils::CString mName;
    uint64_t mCacheId{};
    utils::Invocable<utils::io::ostream&(utils::io::ostream& out)> mLogger;
    utils::FixedCapacityVector<SpecializationConstant> mSpecializationConstants;
+    std::array<utils::FixedCapacityVector<PushConstant>, SHADER_TYPE_COUNT> mPushConstants;
    utils::FixedCapacityVector<std::pair<utils::CString, uint8_t>> mAttributes;
    std::array<UniformInfo, Program::UNIFORM_BINDING_COUNT> mBindingUniformInfo;
    CompilerPriorityQueue mPriorityQueue = CompilerPriorityQueue::HIGH;
@@ -29,17 +29,36 @@ namespace filament::backend {
 //! \privatesection

 struct TargetBufferInfo {
+    // note: the parameters of this constructor are not in the order of this structure's fields
+    TargetBufferInfo(Handle<HwTexture> handle, uint8_t level, uint16_t layer, uint8_t baseViewIndex) noexcept
+        : handle(handle), baseViewIndex(baseViewIndex), level(level), layer(layer) {
+    }
+
+    TargetBufferInfo(Handle<HwTexture> handle, uint8_t level, uint16_t layer) noexcept
+            : handle(handle), level(level), layer(layer) {
+    }
+
+    TargetBufferInfo(Handle<HwTexture> handle, uint8_t level) noexcept
+            : handle(handle), level(level) {
+    }
+
+    TargetBufferInfo(Handle<HwTexture> handle) noexcept // NOLINT(*-explicit-constructor)
+            : handle(handle) {
+    }
+
+    TargetBufferInfo() noexcept = default;
+
    // texture to be used as render target
    Handle<HwTexture> handle;

-    // starting layer index for multiview. This value is only used when the `layerCount` for the
+    // Starting layer index for multiview. This value is only used when the `layerCount` for the
    // render target is greater than 1.
    uint8_t baseViewIndex = 0;

    // level to be used
    uint8_t level = 0;

-    // for cubemaps and 3D textures. See TextureCubemapFace for the face->layer mapping
+    // For cubemaps and 3D textures. See TextureCubemapFace for the face->layer mapping
    uint16_t layer = 0;
 };

@@ -64,7 +83,7 @@ public:

    MRT() noexcept = default;

-    MRT(TargetBufferInfo const& color) noexcept // NOLINT(hicpp-explicit-conversions)
+    MRT(TargetBufferInfo const& color) noexcept // NOLINT(hicpp-explicit-conversions, *-explicit-constructor)
            : mInfos{ color } {
    }

@@ -84,7 +103,7 @@ public:

    // this is here for backward compatibility
    MRT(Handle<HwTexture> handle, uint8_t level, uint16_t layer) noexcept
-            : mInfos{{ handle, 0, level, layer }} {
+            : mInfos{{ handle, level, layer, 0 }} {
    }
 };

@@ -140,6 +140,23 @@ public:
     */
    virtual uint32_t getDefaultFramebufferObject() noexcept;

+    /**
+     * Called by the backend when a frame starts.
+     * @param steady_clock_ns vsync time point on the monotonic clock
+     * @param refreshIntervalNs refresh interval in nanosecond
+     * @param frameId a frame id
+     */
+    virtual void beginFrame(
+            int64_t monotonic_clock_ns,
+            int64_t refreshIntervalNs,
+            uint32_t frameId) noexcept;
+
+    /**
+     * Called by the backend when a frame ends.
+     * @param frameId the frame id used in beginFrame
+     */
+    virtual void endFrame(
+            uint32_t frameId) noexcept;

    /**
     * Type of contexts available
@@ -191,6 +208,12 @@ public:
            utils::Invocable<void()> preContextChange,
            utils::Invocable<void(size_t index)> postContextChange) noexcept;

+    /**
+     * Called by the backend just before calling commit()
+     * @see commit()
+     */
+    virtual void preCommit() noexcept;
+
    /**
     * Called by the driver once the current frame finishes drawing. Typically, this should present
     * the drawSwapChain. This is for example where `eglMakeCurrent()` would be called.
@@ -22,6 +22,10 @@
 #include <backend/platforms/OpenGLPlatform.h>
 #include <backend/platforms/PlatformEGL.h>

+#include <utils/android/PerformanceHintManager.h>
+
+#include <chrono>
+
 #include <stddef.h>
 #include <stdint.h>

@@ -58,6 +62,13 @@ protected:

    void terminate() noexcept override;

+    void beginFrame(
+            int64_t monotonic_clock_ns,
+            int64_t refreshIntervalNs,
+            uint32_t frameId) noexcept override;
+
+    void preCommit() noexcept override;
+
    /**
     * Set the presentation time using `eglPresentationTimeANDROID`
     * @param presentationTimeInNanosecond
@@ -81,6 +92,11 @@ protected:
 private:
    int mOSVersion;
    ExternalStreamManagerAndroid& mExternalStreamManager;
+    utils::PerformanceHintManager mPerformanceHintManager;
+    utils::PerformanceHintManager::Session mPerformanceHintSession;
+
+    using clock = std::chrono::high_resolution_clock;
+    clock::time_point mStartTimeOfActualWork;
 };

 } // namespace filament::backend
@@ -82,6 +82,7 @@ public:
    void requestExit();

    // suspend or unsuspend the queue.
+    bool isPaused() const noexcept;
    void setPaused(bool paused);

    bool isExitRequested() const;
@@ -133,12 +133,13 @@ DECL_DRIVER_API_0(tick)

 DECL_DRIVER_API_N(beginFrame,
        int64_t, monotonic_clock_ns,
+        int64_t, refreshIntervalNs,
        uint32_t, frameId)

 DECL_DRIVER_API_N(setFrameScheduledCallback,
        backend::SwapChainHandle, sch,
-        backend::FrameScheduledCallback, callback,
-        void*, user)
+        backend::CallbackHandler*, handler,
+        backend::FrameScheduledCallback&&, callback)

 DECL_DRIVER_API_N(setFrameCompletedCallback,
        backend::SwapChainHandle, sch,
@@ -303,6 +304,7 @@ DECL_DRIVER_API_SYNCHRONOUS_0(bool, isProtectedContentSupported)
 DECL_DRIVER_API_SYNCHRONOUS_N(bool, isStereoSupported, backend::StereoscopicType, stereoscopicType)
 DECL_DRIVER_API_SYNCHRONOUS_0(bool, isParallelShaderCompileSupported)
 DECL_DRIVER_API_SYNCHRONOUS_0(bool, isDepthStencilResolveSupported)
+DECL_DRIVER_API_SYNCHRONOUS_N(bool, isDepthStencilBlitSupported, backend::TextureFormat, format)
 DECL_DRIVER_API_SYNCHRONOUS_0(bool, isProtectedTexturesSupported)
 DECL_DRIVER_API_SYNCHRONOUS_0(uint8_t, getMaxDrawBuffers)
 DECL_DRIVER_API_SYNCHRONOUS_0(size_t, getMaxUniformBufferSize)
@@ -432,6 +434,11 @@ DECL_DRIVER_API_N(bindSamplers,
        uint32_t, index,
        backend::SamplerGroupHandle, sbh)

+DECL_DRIVER_API_N(setPushConstant,
+        backend::ShaderStage, stage,
+        uint8_t, index,
+        backend::PushConstantVariant, value)
+
 DECL_DRIVER_API_N(insertEventMarker,
        const char*, string,
        uint32_t, len = 0)
@@ -57,6 +57,11 @@ void CommandBufferQueue::requestExit() {
    mCondition.notify_one();
 }

+bool CommandBufferQueue::isPaused() const noexcept {
+    std::lock_guard<utils::Mutex> const lock(mLock);
+    return mPaused;
+}
+
 void CommandBufferQueue::setPaused(bool paused) {
    std::lock_guard<utils::Mutex> const lock(mLock);
    if (paused) {
@@ -21,7 +21,7 @@ namespace filament::backend {
 using namespace utils;

 // We want these in the .cpp file, so they're not inlined (not worth it)
-Program::Program() noexcept { // NOLINT(modernize-use-equals-default)
+Program::Program() noexcept {  // NOLINT(modernize-use-equals-default)
 }

 Program::Program(Program&& rhs) noexcept = default;
@@ -47,6 +47,11 @@ Program& Program::shader(ShaderStage shader, void const* data, size_t size) {
    return *this;
 }

+Program& Program::shaderLanguage(ShaderLanguage shaderLanguage) {
+    mShaderLanguage = shaderLanguage;
+    return *this;
+}
+
 Program& Program::uniformBlockBindings(
        FixedCapacityVector<std::pair<utils::CString, uint8_t>> const& uniformBlockBindings) noexcept {
    for (auto const& item : uniformBlockBindings) {
@@ -86,6 +91,12 @@ Program& Program::specializationConstants(
    return *this;
 }

+Program& Program::pushConstants(ShaderStage stage,
+        utils::FixedCapacityVector<PushConstant> constants) noexcept {
+    mPushConstants[static_cast<uint8_t>(stage)] = std::move(constants);
+    return *this;
+}
+
 Program& Program::cacheId(uint64_t cacheId) noexcept {
    mCacheId = cacheId;
    return *this;
@@ -18,6 +18,7 @@
 #define TNT_FILAMENT_DRIVER_METALBUFFER_H

 #include "MetalContext.h"
+#include "MetalPlatform.h"

 #include <backend/DriverEnums.h>

@@ -28,47 +29,122 @@
 #include <utility>
 #include <memory>
 #include <atomic>
+#include <chrono>

 namespace filament::backend {

-class TrackedMetalBuffer {
+class ScopedAllocationTimer {
 public:
-    TrackedMetalBuffer() noexcept : mBuffer(nil) {}
-    TrackedMetalBuffer(id<MTLBuffer> buffer) noexcept : mBuffer(buffer) {
-        if (buffer) {
-            aliveBuffers++;
-        }
-    }
-    ~TrackedMetalBuffer() {
-        if (mBuffer) {
-            aliveBuffers--;
+    ScopedAllocationTimer(const char* name) : mBeginning(clock_t::now()), mName(name) {}
+    ~ScopedAllocationTimer() {
+        using namespace std::literals::chrono_literals;
+        static constexpr std::chrono::seconds LONG_TIME_THRESHOLD = 10s;
+
+        auto end = clock_t::now();
+        std::chrono::duration<double, std::micro> allocationTimeMicroseconds = end - mBeginning;
+
+        if (UTILS_UNLIKELY(allocationTimeMicroseconds > LONG_TIME_THRESHOLD)) {
+            if (platform && platform->hasDebugUpdateStatFunc()) {
+                char buffer[64];
+                snprintf(buffer, sizeof(buffer), "filament.metal.long_buffer_allocation_time.%s",
+                        mName);
+                platform->debugUpdateStat(
+                        buffer, static_cast<uint64_t>(allocationTimeMicroseconds.count()));
+            }
        }
    }

-    TrackedMetalBuffer(TrackedMetalBuffer&&) = delete;
-    TrackedMetalBuffer(TrackedMetalBuffer const&) = delete;
-    TrackedMetalBuffer& operator=(TrackedMetalBuffer const&) = delete;
-
-    TrackedMetalBuffer& operator=(TrackedMetalBuffer&& rhs) noexcept {
-        swap(rhs);
-        return *this;
-    }
-
-    id<MTLBuffer> get() const noexcept { return mBuffer; }
-    operator bool() const noexcept { return bool(mBuffer); }
-
-    static uint64_t getAliveBuffers() { return aliveBuffers; }
+    static void setPlatform(MetalPlatform* p) { platform = p; }

 private:
-    void swap(TrackedMetalBuffer& other) noexcept {
-        id<MTLBuffer> temp = mBuffer;
-        mBuffer = other.mBuffer;
-        other.mBuffer = temp;
+    typedef std::chrono::steady_clock clock_t;
+
+    static MetalPlatform* platform;
+
+    std::chrono::time_point<clock_t> mBeginning;
+    const char* mName;
+};
+
+#ifndef FILAMENT_METAL_BUFFER_TRACKING
+#define FILAMENT_METAL_BUFFER_TRACKING 0
+#endif
+
+class MetalBufferTracking {
+public:
+    static constexpr size_t EXCESS_BUFFER_COUNT = 30000;
+
+    enum class Type {
+        NONE = 0,
+        GENERIC = 1,
+        RING = 2,
+        STAGING = 3,
+    };
+    static constexpr size_t TypeCount = 3;
+
+    static constexpr auto toIndex(Type t) {
+        assert_invariant(t != Type::NONE);
+        switch (t) {
+            case Type::NONE:
+            case Type::GENERIC:
+                return 0;
+            case Type::RING:
+                return 1;
+            case Type::STAGING:
+                return 2;
+        }
    }

-    id<MTLBuffer> mBuffer;
+#if FILAMENT_METAL_BUFFER_TRACKING
+    static void initialize() {
+        static dispatch_once_t onceToken;
+        dispatch_once(&onceToken, ^{
+            for (size_t i = 0; i < TypeCount; i++) {
+                aliveBuffers[i] = [NSHashTable weakObjectsHashTable];
+            }
+        });
+    }

-    static std::atomic<uint64_t> aliveBuffers;
+    static void setPlatform(MetalPlatform* p) { platform = p; }
+
+    static void track(id<MTLBuffer> buffer, Type type) {
+        assert_invariant(type != Type::NONE);
+        if (UTILS_UNLIKELY(getAliveBuffers() >= EXCESS_BUFFER_COUNT)) {
+            if (platform && platform->hasDebugUpdateStatFunc()) {
+                platform->debugUpdateStat("filament.metal.excess_buffers_allocated",
+                        MetalBufferTracking::getAliveBuffers());
+            }
+        }
+        [aliveBuffers[toIndex(type)] addObject:buffer];
+    }
+
+    static uint64_t getAliveBuffers() {
+        uint64_t sum = 0;
+        for (size_t i = 1; i < TypeCount; i++) {
+            sum += getAliveBuffers(static_cast<Type>(i));
+        }
+        return sum;
+    }
+
+    static uint64_t getAliveBuffers(Type type) {
+        assert_invariant(type != Type::NONE);
+        NSHashTable* hashTable = aliveBuffers[toIndex(type)];
+        // Caution! We can't simply use hashTable.count here, which is inaccurate.
+        // See http://cocoamine.net/blog/2013/12/13/nsmaptable-and-zeroing-weak-references/
+        return hashTable.objectEnumerator.allObjects.count;
+    }
+#else
+    static void initialize() {}
+    static void setPlatform(MetalPlatform* p) {}
+    static id<MTLBuffer> track(id<MTLBuffer> buffer, Type type) { return buffer; }
+    static uint64_t getAliveBuffers() { return 0; }
+    static uint64_t getAliveBuffers(Type type) { return 0; }
+#endif
+
+private:
+#if FILAMENT_METAL_BUFFER_TRACKING
+    static std::array<NSHashTable<id<MTLBuffer>>*, TypeCount> aliveBuffers;
+    static MetalPlatform* platform;
+#endif
 };

 class MetalBuffer {
@@ -122,7 +198,7 @@ public:

 private:

-    TrackedMetalBuffer mBuffer;
+    id<MTLBuffer> mBuffer;
    size_t mBufferSize = 0;
    void* mCpuBuffer = nullptr;
    MetalContext& mContext;
@@ -171,7 +247,11 @@ public:
          mBufferOptions(options),
          mSlotSizeBytes(computeSlotSize(layout)),
          mSlotCount(slotCount) {
-        mBuffer = [device newBufferWithLength:mSlotSizeBytes * mSlotCount options:mBufferOptions];
+        {
+            ScopedAllocationTimer timer("ring");
+            mBuffer = [device newBufferWithLength:mSlotSizeBytes * mSlotCount options:mBufferOptions];
+        }
+        MetalBufferTracking::track(mBuffer, MetalBufferTracking::Type::RING);
        assert_invariant(mBuffer);
    }

@@ -189,9 +269,13 @@ public:
            // If we already have an aux buffer, it will get freed here, unless it has been retained
            // by a MTLCommandBuffer. In that case, it will be freed when the command buffer
            // finishes executing.
-            mAuxBuffer = [mDevice newBufferWithLength:mSlotSizeBytes options:mBufferOptions];
+            {
+                ScopedAllocationTimer timer("ring");
+                mAuxBuffer = [mDevice newBufferWithLength:mSlotSizeBytes options:mBufferOptions];
+            }
+            MetalBufferTracking::track(mAuxBuffer, MetalBufferTracking::Type::RING);
            assert_invariant(mAuxBuffer);
-            return {mAuxBuffer.get(), 0};
+            return { mAuxBuffer, 0 };
        }
        mCurrentSlot = (mCurrentSlot + 1) % mSlotCount;
        mOccupiedSlots->fetch_add(1, std::memory_order_relaxed);
@@ -220,9 +304,9 @@ public:
     */
    std::pair<id<MTLBuffer>, NSUInteger> getCurrentAllocation() const {
        if (UTILS_UNLIKELY(mAuxBuffer)) {
-            return { mAuxBuffer.get(), 0 };
+            return { mAuxBuffer, 0 };
        }
-        return { mBuffer.get(), mCurrentSlot * mSlotSizeBytes };
+        return { mBuffer, mCurrentSlot * mSlotSizeBytes };
    }

    bool canAccomodateLayout(MTLSizeAndAlign layout) const {
@@ -231,8 +315,8 @@ public:

 private:
    id<MTLDevice> mDevice;
-    TrackedMetalBuffer mBuffer;
-    TrackedMetalBuffer mAuxBuffer;
+    id<MTLBuffer> mBuffer;
+    id<MTLBuffer> mAuxBuffer;

    MTLResourceOptions mBufferOptions;

@@ -22,7 +22,13 @@
 namespace filament {
 namespace backend {

-std::atomic<uint64_t> TrackedMetalBuffer::aliveBuffers = 0;
+MetalPlatform* ScopedAllocationTimer::platform = nullptr;
+
+#if FILAMENT_METAL_BUFFER_TRACKING
+std::array<NSHashTable<id<MTLBuffer>>*, MetalBufferTracking::TypeCount>
+        MetalBufferTracking::aliveBuffers;
+MetalPlatform* MetalBufferTracking::platform = nullptr;
+#endif

 MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType, BufferUsage usage,
        size_t size, bool forceGpuBuffer) : mBufferSize(size), mContext(context) {
@@ -37,7 +43,11 @@ MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType,
    }

    // Otherwise, we allocate a private GPU buffer.
-    mBuffer = [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate];
+    {
+        ScopedAllocationTimer timer("generic");
+        mBuffer = [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate];
+    }
+    MetalBufferTracking::track(mBuffer, MetalBufferTracking::Type::GENERIC);
    ASSERT_POSTCONDITION(mBuffer, "Could not allocate Metal buffer of size %zu.", size);
 }

@@ -64,7 +74,7 @@ void MetalBuffer::copyIntoBuffer(void* src, size_t size, size_t byteOffset) {
    // Acquire a staging buffer to hold the contents of this update.
    MetalBufferPool* bufferPool = mContext.bufferPool;
    const MetalBufferPoolEntry* const staging = bufferPool->acquireBuffer(size);
-    memcpy(staging->buffer.get().contents, src, size);
+    memcpy(staging->buffer.contents, src, size);

    // The blit below requires that byteOffset be a multiple of 4.
    ASSERT_PRECONDITION(!(byteOffset & 0x3u), "byteOffset must be a multiple of 4");
@@ -73,9 +83,9 @@ void MetalBuffer::copyIntoBuffer(void* src, size_t size, size_t byteOffset) {
    id<MTLCommandBuffer> cmdBuffer = getPendingCommandBuffer(&mContext);
    id<MTLBlitCommandEncoder> blitEncoder = [cmdBuffer blitCommandEncoder];
    blitEncoder.label = @"Buffer upload blit";
-    [blitEncoder copyFromBuffer:staging->buffer.get()
+    [blitEncoder copyFromBuffer:staging->buffer
                   sourceOffset:0
-                       toBuffer:mBuffer.get()
+                       toBuffer:mBuffer
              destinationOffset:byteOffset
                           size:size];
    [blitEncoder endEncoding];
@@ -96,7 +106,7 @@ id<MTLBuffer> MetalBuffer::getGpuBufferForDraw(id<MTLCommandBuffer> cmdBuffer) n
        return nil;
    }
    assert_invariant(mBuffer);
-    return mBuffer.get();
+    return mBuffer;
 }

 void MetalBuffer::bindBuffers(id<MTLCommandBuffer> cmdBuffer, id<MTLCommandEncoder> encoder,
@@ -32,7 +32,7 @@ struct MetalContext;

 // Immutable POD representing a shared CPU-GPU buffer.
 struct MetalBufferPoolEntry {
-    TrackedMetalBuffer buffer;
+    id<MTLBuffer> buffer;
    size_t capacity;
    mutable uint64_t lastAccessed;
    mutable uint32_t referenceCount;
@@ -42,8 +42,13 @@ MetalBufferPoolEntry const* MetalBufferPool::acquireBuffer(size_t numBytes) {
    }

    // We were not able to find a sufficiently large stage, so create a new one.
-    id<MTLBuffer> buffer = [mContext.device newBufferWithLength:numBytes
-                                                        options:MTLResourceStorageModeShared];
+    id<MTLBuffer> buffer = nil;
+    {
+        ScopedAllocationTimer timer("staging");
+        buffer = [mContext.device newBufferWithLength:numBytes
+                                              options:MTLResourceStorageModeShared];
+    }
+    MetalBufferTracking::track(buffer, MetalBufferTracking::Type::STAGING);
    ASSERT_POSTCONDITION(buffer, "Could not allocate Metal staging buffer of size %zu.", numBytes);
    MetalBufferPoolEntry* stage = new MetalBufferPoolEntry {
        .buffer = buffer,
@@ -105,6 +105,10 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
                  driverConfig.disableHandleUseAfterFreeCheck) {
    mContext->driver = this;

+    ScopedAllocationTimer::setPlatform(platform);
+    MetalBufferTracking::initialize();
+    MetalBufferTracking::setPlatform(platform);
+
    mContext->device = mPlatform.createDevice();
    assert_invariant(mContext->device);

@@ -198,6 +202,8 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
 }

 MetalDriver::~MetalDriver() noexcept {
+    MetalBufferTracking::setPlatform(nullptr);
+    ScopedAllocationTimer::setPlatform(nullptr);
    mContext->device = nil;
    mContext->emptyTexture = nil;
    CFRelease(mContext->textureCache);
@@ -212,19 +218,29 @@ void MetalDriver::tick(int) {
    executeTickOps();
 }

-void MetalDriver::beginFrame(int64_t monotonic_clock_ns, uint32_t frameId) {
+void MetalDriver::beginFrame(int64_t monotonic_clock_ns,
+        int64_t refreshIntervalNs, uint32_t frameId) {
 #if defined(FILAMENT_METAL_PROFILING)
    os_signpost_interval_begin(mContext->log, mContext->signpostId, "Frame encoding", "%{public}d", frameId);
 #endif
    if (mPlatform.hasDebugUpdateStatFunc()) {
-        mPlatform.debugUpdateStat("filament.metal.alive_buffers", TrackedMetalBuffer::getAliveBuffers());
+#if FILAMENT_METAL_BUFFER_TRACKING
+        const uint64_t generic = MetalBufferTracking::getAliveBuffers(MetalBufferTracking::Type::GENERIC);
+        const uint64_t ring = MetalBufferTracking::getAliveBuffers(MetalBufferTracking::Type::RING);
+        const uint64_t staging = MetalBufferTracking::getAliveBuffers(MetalBufferTracking::Type::STAGING);
+        const uint64_t total = generic + ring + staging;
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers", total);
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers.generic", generic);
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers.ring", ring);
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers.staging", staging);
+#endif
    }
 }

-void MetalDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
-        FrameScheduledCallback callback, void* user) {
+void MetalDriver::setFrameScheduledCallback(
+        Handle<HwSwapChain> sch, CallbackHandler* handler, FrameScheduledCallback&& callback) {
    auto* swapChain = handle_cast<MetalSwapChain>(sch);
-    swapChain->setFrameScheduledCallback(callback, user);
+    swapChain->setFrameScheduledCallback(handler, std::move(callback));
 }

 void MetalDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
@@ -805,6 +821,10 @@ bool MetalDriver::isDepthStencilResolveSupported() {
    return false;
 }

+bool MetalDriver::isDepthStencilBlitSupported(TextureFormat format) {
+    return true;
+}
+
 bool MetalDriver::isProtectedTexturesSupported() {
    return false;
 }
@@ -1236,6 +1256,9 @@ void MetalDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
    mContext->samplerBindings[index] = sb;
 }

+void MetalDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
+        backend::PushConstantVariant value) {}
+
 void MetalDriver::insertEventMarker(const char* string, uint32_t len) {

 }
@@ -31,6 +31,8 @@

 #include "private/backend/SamplerGroup.h"

+#include <backend/DriverEnums.h>
+
 #include <utils/bitset.h>
 #include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
@@ -71,9 +73,9 @@ public:

    void releaseDrawable();

-    void setFrameScheduledCallback(FrameScheduledCallback callback, void* user);
-    void setFrameCompletedCallback(CallbackHandler* handler,
-            CallbackHandler::Callback callback, void* user);
+    void setFrameScheduledCallback(CallbackHandler* handler, FrameScheduledCallback&& callback);
+    void setFrameCompletedCallback(
+            CallbackHandler* handler, CallbackHandler::Callback callback, void* user);

    // For CAMetalLayer-backed SwapChains, presents the drawable or schedules a
    // FrameScheduledCallback.
@@ -110,14 +112,15 @@ private:
    MetalExternalImage externalImage;
    SwapChainType type;

-    // These two fields store a callback and user data to notify the client that a frame is ready
-    // for presentation.
-    // If frameScheduledCallback is nullptr, then the Metal backend automatically calls
-    // presentDrawable when the frame is committed.
-    // Otherwise, the Metal backend will not automatically present the frame. Instead, clients bear
-    // the responsibility of presenting the frame by calling the PresentCallable object.
-    FrameScheduledCallback frameScheduledCallback = nullptr;
-    void* frameScheduledUserData = nullptr;
+    // These fields store a callback to notify the client that a frame is ready for presentation. If
+    // !frameScheduled.callback, then the Metal backend automatically calls presentDrawable when the
+    // frame is committed. Otherwise, the Metal backend will not automatically present the frame.
+    // Instead, clients bear the responsibility of presenting the frame by calling the
+    // PresentCallable object.
+    struct {
+        CallbackHandler* handler = nullptr;
+        FrameScheduledCallback callback = {};
+    } frameScheduled;

    struct {
        CallbackHandler* handler = nullptr;
@@ -221,9 +221,10 @@ void MetalSwapChain::ensureDepthStencilTexture() {
    depthStencilTexture = [context.device newTextureWithDescriptor:descriptor];
 }

-void MetalSwapChain::setFrameScheduledCallback(FrameScheduledCallback callback, void* user) {
-    frameScheduledCallback = callback;
-    frameScheduledUserData = user;
+void MetalSwapChain::setFrameScheduledCallback(
+        CallbackHandler* handler, FrameScheduledCallback&& callback) {
+    frameScheduled.handler = handler;
+    frameScheduled.callback = std::move(callback);
 }

 void MetalSwapChain::setFrameCompletedCallback(CallbackHandler* handler,
@@ -238,7 +239,7 @@ void MetalSwapChain::present() {
        scheduleFrameCompletedCallback();
    }
    if (drawable) {
-        if (frameScheduledCallback) {
+        if (frameScheduled.callback) {
            scheduleFrameScheduledCallback();
        } else  {
            [getPendingCommandBuffer(&context) presentDrawable:drawable];
@@ -296,21 +297,38 @@ void presentDrawable(bool presentFrame, void* user) {
 }

 void MetalSwapChain::scheduleFrameScheduledCallback() {
-    if (!frameScheduledCallback) {
+    if (!frameScheduled.callback) {
        return;
    }

    assert_invariant(drawable);

-    // Destroy this by calling maybePresentAndDestroyAsync() later.
-    auto* presentData = PresentDrawableData::create(drawable, context.driver);
+    struct Callback {
+        Callback(FrameScheduledCallback&& callback, id<CAMetalDrawable> drawable,
+                MetalDriver* driver)
+            : f(std::move(callback)), data(PresentDrawableData::create(drawable, driver)) {}
+        FrameScheduledCallback f;
+        // PresentDrawableData* is destroyed by maybePresentAndDestroyAsync() later.
+        std::unique_ptr<PresentDrawableData> data;
+        static void func(void* user) {
+            auto* const c = reinterpret_cast<Callback*>(user);
+            PresentDrawableData* presentDrawableData = c->data.release();
+            PresentCallable presentCallable(presentDrawable, presentDrawableData);
+            c->f(presentCallable);
+            delete c;
+        }
+    };

-    FrameScheduledCallback userCallback = frameScheduledCallback;
-    void* userData = frameScheduledUserData;
+    // This callback pointer will be captured by the block. Even if the scheduled handler is never
+    // called, the unique_ptr will still ensure we don't leak memory.
+    __block auto callback =
+            std::make_unique<Callback>(std::move(frameScheduled.callback), drawable, context.driver);

+    backend::CallbackHandler* handler = frameScheduled.handler;
+    MetalDriver* driver = context.driver;
    [getPendingCommandBuffer(&context) addScheduledHandler:^(id<MTLCommandBuffer> cb) {
-        PresentCallable callable(presentDrawable, static_cast<void*>(presentData));
-        userCallback(callable, userData);
+        Callback* user = callback.release();
+        driver->scheduleCallback(handler, user, &Callback::func);
    }];
 }

@@ -771,13 +789,13 @@ void MetalTexture::loadWithCopyBuffer(uint32_t level, uint32_t slice, MTLRegion
        PixelBufferDescriptor const& data, const PixelBufferShape& shape) {
    const size_t stagingBufferSize = shape.totalBytes;
    auto entry = context.bufferPool->acquireBuffer(stagingBufferSize);
-    memcpy(entry->buffer.get().contents,
+    memcpy(entry->buffer.contents,
            static_cast<uint8_t*>(data.buffer) + shape.sourceOffset,
            stagingBufferSize);
    id<MTLCommandBuffer> blitCommandBuffer = getPendingCommandBuffer(&context);
    id<MTLBlitCommandEncoder> blitCommandEncoder = [blitCommandBuffer blitCommandEncoder];
    blitCommandEncoder.label = @"Texture upload buffer blit";
-    [blitCommandEncoder copyFromBuffer:entry->buffer.get()
+    [blitCommandEncoder copyFromBuffer:entry->buffer
                          sourceOffset:0
                     sourceBytesPerRow:shape.bytesPerRow
                   sourceBytesPerImage:shape.bytesPerSlice
@@ -106,26 +106,41 @@ bool MetalShaderCompiler::isParallelShaderCompileSupported() const noexcept {
            continue;
        }

-        assert_invariant(source[source.size() - 1] == '\0');
-
-        // the shader string is null terminated and the length includes the null character
-        NSString* objcSource = [[NSString alloc] initWithBytes:source.data()
-                                                        length:source.size() - 1
-                                                      encoding:NSUTF8StringEncoding];
-
-        // By default, Metal uses the most recent language version.
-        MTLCompileOptions* options = [MTLCompileOptions new];
-
-        // Disable Fast Math optimizations.
-        // This ensures that operations adhere to IEEE standards for floating-point arithmetic,
-        // which is crucial for half precision floats in scenarios where fast math optimizations
-        // lead to inaccuracies, such as in handling special values like NaN or Infinity.
-        options.fastMathEnabled = NO;
-
        NSError* error = nil;
-        id<MTLLibrary> library = [device newLibraryWithSource:objcSource
-                                                      options:options
-                                                        error:&error];
+        id<MTLLibrary> library = nil;
+        switch (program.getShaderLanguage()) {
+            case ShaderLanguage::MSL: {
+                // By default, Metal uses the most recent language version.
+                MTLCompileOptions* options = [MTLCompileOptions new];
+
+                // Disable Fast Math optimizations.
+                // This ensures that operations adhere to IEEE standards for floating-point
+                // arithmetic, which is crucial for half precision floats in scenarios where fast
+                // math optimizations lead to inaccuracies, such as in handling special values like
+                // NaN or Infinity.
+                options.fastMathEnabled = NO;
+
+                assert_invariant(source[source.size() - 1] == '\0');
+                // the shader string is null terminated and the length includes the null character
+                NSString* objcSource = [[NSString alloc] initWithBytes:source.data()
+                                                                length:source.size() - 1
+                                                              encoding:NSUTF8StringEncoding];
+                library = [device newLibraryWithSource:objcSource options:options error:&error];
+                break;
+            }
+            case ShaderLanguage::METAL_LIBRARY: {
+                dispatch_data_t data = dispatch_data_create(source.data(), source.size(),
+                        dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
+                        DISPATCH_DATA_DESTRUCTOR_DEFAULT);
+                library = [device newLibraryWithData:data error:&error];
+                break;
+            }
+            case ShaderLanguage::ESSL1:
+            case ShaderLanguage::ESSL3:
+            case ShaderLanguage::SPIRV:
+                break;
+        }
+
        if (library == nil) {
            NSString* errorMessage = @"unknown error";
            if (error) {
@@ -154,6 +169,23 @@ bool MetalShaderCompiler::isParallelShaderCompileSupported() const noexcept {
        id<MTLFunction> function = [library newFunctionWithName:@"main0"
                                                 constantValues:constants
                                                          error:&error];
+        if (function == nil) {
+            // If the library loads but functions within it fail to load, it usually means the
+            // GPU backend crashed. (This can happen if it's a Metallib shader that was compiled
+            // with a minimum iOS version that's newer than this device.)
+            NSString* errorMessage = @"unknown error";
+            if (error) {
+                auto description =
+                        [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
+                utils::slog.w << description << utils::io::endl;
+                errorMessage = error.localizedDescription;
+            }
+            PANIC_LOG("Failed to load main0 in Metal program.");
+            NSString* programName =
+                [NSString stringWithFormat:@"%s::main0", program.getName().c_str_safe()];
+            return MetalFunctionBundle::error(errorMessage, programName);
+        }
+
        if (!program.getName().empty()) {
            function.label = @(program.getName().c_str());
        }
@@ -49,11 +49,12 @@ void NoopDriver::terminate() {
 void NoopDriver::tick(int) {
 }

-void NoopDriver::beginFrame(int64_t monotonic_clock_ns, uint32_t frameId) {
+void NoopDriver::beginFrame(int64_t monotonic_clock_ns,
+        int64_t refreshIntervalNs, uint32_t frameId) {
 }

 void NoopDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
-        FrameScheduledCallback callback, void* user) {
+        CallbackHandler* handler, FrameScheduledCallback&& callback) {

 }

@@ -193,6 +194,10 @@ bool NoopDriver::isDepthStencilResolveSupported() {
    return true;
 }

+bool NoopDriver::isDepthStencilBlitSupported(TextureFormat format) {
+    return true;
+}
+
 bool NoopDriver::isProtectedTexturesSupported() {
    return true;
 }
@@ -307,6 +312,10 @@ void NoopDriver::unbindBuffer(BufferObjectBinding bindingType, uint32_t index) {
 void NoopDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
 }

+void NoopDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
+        backend::PushConstantVariant value) {
+}
+
 void NoopDriver::insertEventMarker(char const* string, uint32_t len) {
 }

@@ -30,7 +30,7 @@ namespace filament::backend {
 struct GLTexture : public HwTexture {
    using HwTexture::HwTexture;
    struct GL {
-        GL() noexcept : imported(false), sidecarSamples(1), reserved(0) {}
+        GL() noexcept : imported(false), sidecarSamples(1), reserved1(0) {}
        GLuint id = 0;          // texture or renderbuffer id
        GLenum target = 0;
        GLenum internalFormat = 0;
@@ -40,10 +40,10 @@ struct GLTexture : public HwTexture {
        GLfloat anisotropy = 1.0;
        int8_t baseLevel = 127;
        int8_t maxLevel = -1;
-        uint8_t targetIndex = 0;    // optimization: index corresponding to target
+        uint8_t reserved0 = 0;
        bool imported           : 1;
        uint8_t sidecarSamples  : 4;
-        uint8_t reserved        : 3;
+        uint8_t reserved1       : 3;
    } gl;

    OpenGLPlatform::ExternalTexture* externalTexture = nullptr;
@@ -63,7 +63,8 @@ bool OpenGLContext::queryOpenGLVersion(GLint* major, GLint* minor) noexcept {
 #endif
 }

-OpenGLContext::OpenGLContext(OpenGLPlatform& platform) noexcept
+OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
+        Platform::DriverConfig const& driverConfig) noexcept
        : mPlatform(platform),
          mSamplerMap(32) {

@@ -85,6 +86,13 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform) noexcept

    queryOpenGLVersion(&state.major, &state.minor);

+    #if defined(BACKEND_OPENGL_VERSION_GLES)
+    if (UTILS_UNLIKELY(driverConfig.forceGLES2Context)) {
+        state.major = 2;
+        state.minor = 0;
+    }
+    #endif
+
    OpenGLContext::initExtensions(&ext, state.major, state.minor);

    OpenGLContext::initProcs(&procs, ext, state.major, state.minor);
@@ -253,6 +261,12 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform) noexcept
 }

 OpenGLContext::~OpenGLContext() noexcept {
+    // note: this is called from the main thread. Can't do any GL calls.
+    delete mTimerQueryFactory;
+}
+
+void OpenGLContext::terminate() noexcept {
+    // note: this is called from the backend thread
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
    if (!isES2()) {
        for (auto& item: mSamplerMap) {
@@ -262,7 +276,6 @@ OpenGLContext::~OpenGLContext() noexcept {
        mSamplerMap.clear();
    }
 #endif
-    delete mTimerQueryFactory;
 }

 void OpenGLContext::destroyWithContext(
@@ -526,8 +539,6 @@ void OpenGLContext::initBugs(Bugs* bugs, Extensions const& exts,
            bugs->delay_fbo_destruction = true;
            // PowerVR seems to have no problem with this (which is good for us)
            bugs->allow_read_only_ancillary_feedback_loop = true;
-            // PowerVR has a shader compiler thread pinned on the last core
-            bugs->disable_thread_affinity = true;
        } else if (strstr(renderer, "Apple")) {
            // Apple GPU
        } else if (strstr(renderer, "Tegra") ||
@@ -878,19 +889,32 @@ default_case:
    }
 }

-void OpenGLContext::unbindTexture(GLenum target, GLuint texture_id) noexcept {
+void OpenGLContext::unbindTexture(
+        UTILS_UNUSED_IN_RELEASE GLenum target, GLuint texture_id) noexcept {
    // unbind this texture from all the units it might be bound to
    // no need unbind the texture from FBOs because we're not tracking that state (and there is
    // no need to).
-    const size_t index = getIndexForTextureTarget(target);
-    UTILS_NOUNROLL
-    for (GLuint unit = 0; unit < MAX_TEXTURE_UNIT_COUNT; unit++) {
-        if (state.textures.units[unit].targets[index].texture_id == texture_id) {
-            bindTexture(unit, target, (GLuint)0, index);
+    // Never attempt to unbind texture 0. This could happen with external textures w/ streaming if
+    // never populated.
+    if (texture_id) {
+        UTILS_NOUNROLL
+        for (GLuint unit = 0; unit < MAX_TEXTURE_UNIT_COUNT; unit++) {
+            if (state.textures.units[unit].id == texture_id) {
+                // if this texture is bound, it should be at the same target
+                assert_invariant(state.textures.units[unit].target == target);
+                unbindTextureUnit(unit);
+            }
        }
    }
 }

+void OpenGLContext::unbindTextureUnit(GLuint unit) noexcept {
+    update_state(state.textures.units[unit].id, 0u, [&]() {
+        activeTexture(unit);
+        glBindTexture(state.textures.units[unit].target, 0u);
+    });
+}
+
 void OpenGLContext::unbindSampler(GLuint sampler) noexcept {
    // unbind this sampler from all the units it might be bound to
    UTILS_NOUNROLL  // clang generates >800B of code!!!
@@ -91,9 +91,13 @@ public:

    static bool queryOpenGLVersion(GLint* major, GLint* minor) noexcept;

-    explicit OpenGLContext(OpenGLPlatform& platform) noexcept;
+    explicit OpenGLContext(OpenGLPlatform& platform,
+            Platform::DriverConfig const& driverConfig) noexcept;
+
    ~OpenGLContext() noexcept final;

+    void terminate() noexcept;
+
    // TimerQueryInterface ------------------------------------------------------------------------

    // note: OpenGLContext being final ensures (clang) these are not called through the vtable
@@ -134,7 +138,6 @@ public:
 #endif
    }

-    constexpr static inline size_t getIndexForTextureTarget(GLuint target) noexcept;
    constexpr        inline size_t getIndexForCap(GLenum cap) noexcept;
    constexpr static inline size_t getIndexForBufferTarget(GLenum target) noexcept;

@@ -146,10 +149,10 @@ public:

          void pixelStore(GLenum, GLint) noexcept;
    inline void activeTexture(GLuint unit) noexcept;
-    inline void bindTexture(GLuint unit, GLuint target, GLuint texId, size_t targetIndex) noexcept;
    inline void bindTexture(GLuint unit, GLuint target, GLuint texId) noexcept;

           void unbindTexture(GLenum target, GLuint id) noexcept;
+           void unbindTextureUnit(GLuint unit) noexcept;
    inline void bindVertexArray(RenderPrimitive const* p) noexcept;
    inline void bindSampler(GLuint unit, GLuint sampler) noexcept;
           void unbindSampler(GLuint sampler) noexcept;
@@ -308,10 +311,6 @@ public:
        // a glFinish. So we must delay the destruction until we know the GPU is finished.
        bool delay_fbo_destruction;

-        // The driver has some threads pinned, and we can't easily know on which core, it can hurt
-        // performance more if we end-up pinned on the same one.
-        bool disable_thread_affinity;
-
        // Force feature level 0. Typically used for low end ES3 devices with significant driver
        // bugs or performance issues.
        bool force_feature_level0;
@@ -323,8 +322,14 @@ public:

    // function to handle state changes we don't control
    void updateTexImage(GLenum target, GLuint id) noexcept {
-        const size_t index = getIndexForTextureTarget(target);
-        state.textures.units[state.textures.active].targets[index].texture_id = id;
+        assert_invariant(target == GL_TEXTURE_EXTERNAL_OES);
+        // if another target is bound to this texture unit, unbind that texture
+        if (UTILS_UNLIKELY(state.textures.units[state.textures.active].target != target)) {
+            glBindTexture(state.textures.units[state.textures.active].target, 0);
+            state.textures.units[state.textures.active].target = GL_TEXTURE_EXTERNAL_OES;
+        }
+        // the texture is already bound to `target`, we just update our internal state
+        state.textures.units[state.textures.active].id = id;
    }
    void resetProgram() noexcept { state.program.use = 0; }

@@ -427,9 +432,8 @@ public:
            GLuint active = 0;      // zero-based
            struct {
                GLuint sampler = 0;
-                struct {
-                    GLuint texture_id = 0;
-                } targets[7];  // this must match getIndexForTextureTarget()
+                GLuint target = 0;
+                GLuint id = 0;
            } units[MAX_TEXTURE_UNIT_COUNT];
        } textures;

@@ -552,9 +556,6 @@ private:
            {   bugs.delay_fbo_destruction,
                    "delay_fbo_destruction",
                    ""},
-            {   bugs.disable_thread_affinity,
-                    "disable_thread_affinity",
-                    ""},
            {   bugs.force_feature_level0,
                    "force_feature_level0",
                    ""},
@@ -602,31 +603,10 @@ private:
    }

    void setDefaultState() noexcept;
-
-    static constexpr const size_t TEXTURE_TARGET_COUNT =
-            sizeof(state.textures.units[0].targets) / sizeof(state.textures.units[0].targets[0]);
-
 };

 // ------------------------------------------------------------------------------------------------

-constexpr size_t OpenGLContext::getIndexForTextureTarget(GLuint target) noexcept {
-    // this must match state.textures[].targets[]
-    switch (target) {
-        case GL_TEXTURE_2D:                     return 0;
-        case GL_TEXTURE_2D_ARRAY:               return 1;
-        case GL_TEXTURE_CUBE_MAP:               return 2;
-#if defined(BACKEND_OPENGL_LEVEL_GLES31)
-        case GL_TEXTURE_2D_MULTISAMPLE:         return 3;
-#endif
-        case GL_TEXTURE_EXTERNAL_OES:           return 4;
-        case GL_TEXTURE_3D:                     return 5;
-        case GL_TEXTURE_CUBE_MAP_ARRAY:         return 6;
-        default:
-            return 0;
-    }
-}
-
 constexpr size_t OpenGLContext::getIndexForCap(GLenum cap) noexcept { //NOLINT
    size_t index = 0;
    switch (cap) {
@@ -774,19 +754,17 @@ void OpenGLContext::bindBufferRange(GLenum target, GLuint index, GLuint buffer,
 #endif
 }

-void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId, size_t targetIndex) noexcept {
-    assert_invariant(targetIndex == getIndexForTextureTarget(target));
-    assert_invariant(targetIndex < TEXTURE_TARGET_COUNT);
-    update_state(state.textures.units[unit].targets[targetIndex].texture_id, texId, [&]() {
+void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId) noexcept {
+    update_state(state.textures.units[unit].target, target, [&]() {
+        activeTexture(unit);
+        glBindTexture(state.textures.units[unit].target, 0);
+    });
+    update_state(state.textures.units[unit].id, texId, [&]() {
        activeTexture(unit);
        glBindTexture(target, texId);
    }, target == GL_TEXTURE_EXTERNAL_OES);
 }

-void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId) noexcept {
-    bindTexture(unit, target, texId, getIndexForTextureTarget(target));
-}
-
 void OpenGLContext::useProgram(GLuint program) noexcept {
    update_state(state.program.use, program, [&]() {
        glUseProgram(program);
@@ -173,6 +173,10 @@ Driver* OpenGLDriver::create(OpenGLPlatform* const platform,
        PANIC_LOG("OpenGL ES 2.0 minimum needed (current %d.%d)", major, minor);
        goto cleanup;
    }
+    if (UTILS_UNLIKELY(driverConfig.forceGLES2Context)) {
+        major = 2;
+        minor = 0;
+    }
 #else
    // we require GL 4.1 headers and minimum version
    if (UTILS_UNLIKELY(!((major == 4 && minor >= 1) || major > 4))) {
@@ -203,12 +207,13 @@ OpenGLDriver::DebugMarker::~DebugMarker() noexcept {

 OpenGLDriver::OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfig& driverConfig) noexcept
        : mPlatform(*platform),
-          mContext(mPlatform),
+          mContext(mPlatform, driverConfig),
          mShaderCompilerService(*this),
          mHandleAllocator("Handles",
                  driverConfig.handleArenaSize,
                  driverConfig.disableHandleUseAfterFreeCheck),
-          mDriverConfig(driverConfig) {
+          mDriverConfig(driverConfig),
+          mCurrentPushConstants(new(std::nothrow) PushConstantBundle{}) {

    std::fill(mSamplerBindings.begin(), mSamplerBindings.end(), nullptr);

@@ -232,6 +237,7 @@ OpenGLDriver::OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfi
 }

 OpenGLDriver::~OpenGLDriver() noexcept { // NOLINT(modernize-use-equals-default)
+    // this is called from the main thread. Can't call GL.
 }

 Dispatcher OpenGLDriver::getDispatcher() const noexcept {
@@ -264,6 +270,11 @@ void OpenGLDriver::terminate() {
    assert_invariant(mGpuCommandCompleteOps.empty());
 #endif

+    delete mCurrentPushConstants;
+    mCurrentPushConstants = nullptr;
+
+    mContext.terminate();
+
    mPlatform.terminate();
 }

@@ -282,9 +293,42 @@ void OpenGLDriver::bindSampler(GLuint unit, GLuint sampler) noexcept {
    mContext.bindSampler(unit, sampler);
 }

+void OpenGLDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
+        backend::PushConstantVariant value) {
+    assert_invariant(stage == ShaderStage::VERTEX || stage == ShaderStage::FRAGMENT);
+    utils::Slice<std::pair<GLint, ConstantType>> constants;
+    if (stage == ShaderStage::VERTEX) {
+        constants = mCurrentPushConstants->vertexConstants;
+    } else if (stage == ShaderStage::FRAGMENT) {
+        constants = mCurrentPushConstants->fragmentConstants;
+    }
+
+    assert_invariant(index < constants.size());
+    auto const& [location, type] = constants[index];
+
+    // This push constant wasn't found in the shader. It's ok to return without error-ing here.
+    if (location < 0) {
+        return;
+    }
+
+    if (std::holds_alternative<bool>(value)) {
+        assert_invariant(type == ConstantType::BOOL);
+        bool const bval = std::get<bool>(value);
+        glUniform1i(location, bval ? 1 : 0);
+    } else if (std::holds_alternative<float>(value)) {
+        assert_invariant(type == ConstantType::FLOAT);
+        float const fval = std::get<float>(value);
+        glUniform1f(location, fval);
+    } else {
+        assert_invariant(type == ConstantType::INT);
+        int const ival = std::get<int>(value);
+        glUniform1i(location, ival);
+    }
+}
+
 void OpenGLDriver::bindTexture(GLuint unit, GLTexture const* t) noexcept {
    assert_invariant(t != nullptr);
-    mContext.bindTexture(unit, t->gl.target, t->gl.id, t->gl.targetIndex);
+    mContext.bindTexture(unit, t->gl.target, t->gl.id);
 }

 bool OpenGLDriver::useProgram(OpenGLProgram* p) noexcept {
@@ -746,7 +790,6 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
            if (t->externalTexture) {
                t->gl.target = t->externalTexture->target;
                t->gl.id = t->externalTexture->id;
-                t->gl.targetIndex = (uint8_t)OpenGLContext::getIndexForTextureTarget(t->gl.target);
                // internalFormat actually depends on the external image, but it doesn't matter
                // because it's not used anywhere for anything important.
                t->gl.internalFormat = internalFormat;
@@ -758,30 +801,23 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint

            t->gl.internalFormat = internalFormat;

-            // We DO NOT update targetIndex at function exit to take advantage of the fact that
-            // getIndexForTextureTarget() is constexpr -- so all of this disappears at compile time.
            switch (target) {
                case SamplerType::SAMPLER_EXTERNAL:
                    // we can't be here -- doesn't matter what we do
                case SamplerType::SAMPLER_2D:
                    t->gl.target = GL_TEXTURE_2D;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D);
                    break;
                case SamplerType::SAMPLER_3D:
                    t->gl.target = GL_TEXTURE_3D;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_3D);
                    break;
                case SamplerType::SAMPLER_2D_ARRAY:
                    t->gl.target = GL_TEXTURE_2D_ARRAY;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_ARRAY);
                    break;
                case SamplerType::SAMPLER_CUBEMAP:
                    t->gl.target = GL_TEXTURE_CUBE_MAP;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP);
                    break;
                case SamplerType::SAMPLER_CUBEMAP_ARRAY:
                    t->gl.target = GL_TEXTURE_CUBE_MAP_ARRAY;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP_ARRAY);
                    break;
            }

@@ -792,8 +828,6 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
                if (gl.features.multisample_texture) {
                    // multi-sample texture on GL 3.2 / GLES 3.1 and above
                    t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
-                    t->gl.targetIndex = (uint8_t)
-                            OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_MULTISAMPLE);
                } else {
                    // Turn off multi-sampling for that texture. It's just not supported.
                }
@@ -852,32 +886,24 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
    t->gl.internalFormat = getInternalFormat(format);
    assert_invariant(t->gl.internalFormat);

-    // We DO NOT update targetIndex at function exit to take advantage of the fact that
-    // getIndexForTextureTarget() is constexpr -- so all of this disappears at compile time.
    switch (target) {
        case SamplerType::SAMPLER_EXTERNAL:
            t->gl.target = GL_TEXTURE_EXTERNAL_OES;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_EXTERNAL_OES);
            break;
        case SamplerType::SAMPLER_2D:
            t->gl.target = GL_TEXTURE_2D;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D);
            break;
        case SamplerType::SAMPLER_3D:
            t->gl.target = GL_TEXTURE_3D;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_3D);
            break;
        case SamplerType::SAMPLER_2D_ARRAY:
            t->gl.target = GL_TEXTURE_2D_ARRAY;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_ARRAY);
            break;
        case SamplerType::SAMPLER_CUBEMAP:
            t->gl.target = GL_TEXTURE_CUBE_MAP;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP);
            break;
        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
            t->gl.target = GL_TEXTURE_CUBE_MAP_ARRAY;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP_ARRAY);
            break;
    }

@@ -888,7 +914,6 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
        if (gl.features.multisample_texture) {
            // multi-sample texture on GL 3.2 / GLES 3.1 and above
            t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_MULTISAMPLE);
        } else {
            // Turn off multi-sampling for that texture. It's just not supported.
        }
@@ -1778,7 +1803,6 @@ void OpenGLDriver::updateStreams(DriverApi* driver) {
                        // the target and id can be reset each time
                        t->gl.target = t->externalTexture->target;
                        t->gl.id = t->externalTexture->id;
-                        t->gl.targetIndex = (uint8_t)OpenGLContext::getIndexForTextureTarget(t->gl.target);
                        bindTexture(OpenGLContext::DUMMY_TEXTURE_BINDING, t);
                    }
                }
@@ -2040,6 +2064,10 @@ bool OpenGLDriver::isDepthStencilResolveSupported() {
    return true;
 }

+bool OpenGLDriver::isDepthStencilBlitSupported(TextureFormat format) {
+    return true;
+}
+
 bool OpenGLDriver::isProtectedTexturesSupported() {
    return getContext().ext.EXT_protected_textures;
 }
@@ -2056,8 +2084,6 @@ bool OpenGLDriver::isWorkaroundNeeded(Workaround workaround) {
            return mContext.bugs.disable_blit_into_texture_array;
        case Workaround::POWER_VR_SHADER_WORKAROUNDS:
            return mContext.bugs.powervr_shader_workarounds;
-        case Workaround::DISABLE_THREAD_AFFINITY:
-            return mContext.bugs.disable_thread_affinity;
        default:
            return false;
    }
@@ -2666,7 +2692,6 @@ void OpenGLDriver::setExternalImage(Handle<HwTexture> th, void* image) {
        // the target and id can be reset each time
        t->gl.target = t->externalTexture->target;
        t->gl.id = t->externalTexture->id;
-        t->gl.targetIndex = (uint8_t)OpenGLContext::getIndexForTextureTarget(t->gl.target);
        bindTexture(OpenGLContext::DUMMY_TEXTURE_BINDING, t);
    }
 }
@@ -3398,17 +3423,21 @@ void OpenGLDriver::executeGpuCommandsCompleteOps() noexcept {

 void OpenGLDriver::tick(int) {
    DEBUG_MARKER()
+#ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
    executeGpuCommandsCompleteOps();
+#endif
    executeEveryNowAndThenOps();
    getShaderCompilerService().tick();
 }

 void OpenGLDriver::beginFrame(
        UTILS_UNUSED int64_t monotonic_clock_ns,
+        UTILS_UNUSED int64_t refreshIntervalNs,
        UTILS_UNUSED uint32_t frameId) {
    DEBUG_MARKER()
    auto& gl = mContext;
    insertEventMarker("beginFrame");
+    mPlatform.beginFrame(monotonic_clock_ns, refreshIntervalNs, frameId);
    if (UTILS_UNLIKELY(!mTexturesWithStreamsAttached.empty())) {
        OpenGLPlatform& platform = mPlatform;
        for (GLTexture const* t : mTexturesWithStreamsAttached) {
@@ -3417,7 +3446,7 @@ void OpenGLDriver::beginFrame(
                assert_invariant(t->hwStream->stream);
                platform.updateTexImage(t->hwStream->stream,
                        &static_cast<GLStream*>(t->hwStream)->user_thread.timestamp); // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
-                // NOTE: We assume that updateTexImage() binds the texture on our behalf
+                // NOTE: We assume that OpenGLPlatform::updateTexImage() binds the texture on our behalf
                gl.updateTexImage(GL_TEXTURE_EXTERNAL_OES, t->gl.id);
            }
        }
@@ -3425,7 +3454,7 @@ void OpenGLDriver::beginFrame(
 }

 void OpenGLDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
-        FrameScheduledCallback callback, void* user) {
+        CallbackHandler* handler, FrameScheduledCallback&& callback) {
    DEBUG_MARKER()
 }

@@ -3456,6 +3485,7 @@ void OpenGLDriver::endFrame(UTILS_UNUSED uint32_t frameId) {
 #endif
    //SYSTRACE_NAME("glFinish");
    //glFinish();
+    mPlatform.endFrame(frameId);
    insertEventMarker("endFrame");
 }

@@ -3667,7 +3697,7 @@ void OpenGLDriver::blit(
        case SamplerType::SAMPLER_EXTERNAL:
            break;
    }
-    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)

    gl.bindFramebuffer(GL_READ_FRAMEBUFFER, fbo[1]);
    switch (s->target) {
@@ -3693,7 +3723,7 @@ void OpenGLDriver::blit(
        case SamplerType::SAMPLER_EXTERNAL:
            break;
    }
-    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)

    gl.disable(GL_SCISSOR_TEST);
    glBlitFramebuffer(
@@ -3815,6 +3845,7 @@ void OpenGLDriver::bindPipeline(PipelineState state) {
    gl.polygonOffset(state.polygonOffset.slope, state.polygonOffset.constant);
    OpenGLProgram* const p = handle_cast<OpenGLProgram*>(state.program);
    mValidProgram = useProgram(p);
+    (*mCurrentPushConstants) = p->getPushConstants();
 }

 void OpenGLDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
@@ -66,9 +66,9 @@ namespace filament::backend {
 class OpenGLPlatform;
 class PixelBufferDescriptor;
 struct TargetBufferInfo;
-
 class OpenGLProgram;
 class TimerQueryFactoryInterface;
+struct PushConstantBundle;

 class OpenGLDriver final : public DriverBase {
    inline explicit OpenGLDriver(OpenGLPlatform* platform,
@@ -375,6 +375,8 @@ private:
    // for ES2 sRGB support
    GLSwapChain* mCurrentDrawSwapChain = nullptr;
    bool mRec709OutputColorspace = false;
+
+    PushConstantBundle* mCurrentPushConstants = nullptr;
 };

 // ------------------------------------------------------------------------------------------------
@@ -55,6 +55,16 @@ uint32_t OpenGLPlatform::getDefaultFramebufferObject() noexcept {
    return 0;
 }

+void OpenGLPlatform::beginFrame(int64_t monotonic_clock_ns, int64_t refreshIntervalNs,
+        uint32_t frameId) noexcept {
+}
+
+void OpenGLPlatform::endFrame(uint32_t frameId) noexcept {
+}
+
+void OpenGLPlatform::preCommit() noexcept {
+}
+
 OpenGLPlatform::ContextType OpenGLPlatform::getCurrentContextType() const noexcept {
    return ContextType::UNPROTECTED;
 }
@@ -46,6 +46,8 @@ struct OpenGLProgram::LazyInitializationData {
    Program::UniformBlockInfo uniformBlockInfo;
    Program::SamplerGroupInfo samplerGroupInfo;
    std::array<Program::UniformInfo, Program::UNIFORM_BINDING_COUNT> bindingUniformInfo;
+    utils::FixedCapacityVector<Program::PushConstant> vertexPushConstants;
+    utils::FixedCapacityVector<Program::PushConstant> fragmentPushConstants;
 };


@@ -53,7 +55,6 @@ OpenGLProgram::OpenGLProgram() noexcept = default;

 OpenGLProgram::OpenGLProgram(OpenGLDriver& gld, Program&& program) noexcept
        : HwProgram(std::move(program.getName())) {
-
    auto* const lazyInitializationData = new(std::nothrow) LazyInitializationData();
    lazyInitializationData->samplerGroupInfo = std::move(program.getSamplerGroupInfo());
    if (UTILS_UNLIKELY(gld.getContext().isES2())) {
@@ -61,6 +62,8 @@ OpenGLProgram::OpenGLProgram(OpenGLDriver& gld, Program&& program) noexcept
    } else {
        lazyInitializationData->uniformBlockInfo = std::move(program.getUniformBlockBindings());
    }
+    lazyInitializationData->vertexPushConstants = std::move(program.getPushConstants(ShaderStage::VERTEX));
+    lazyInitializationData->fragmentPushConstants = std::move(program.getPushConstants(ShaderStage::FRAGMENT));

    ShaderCompilerService& compiler = gld.getShaderCompilerService();
    mToken = compiler.createProgram(name, std::move(program));
@@ -203,6 +206,21 @@ void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint progra
        }
    }
    mUsedBindingsCount = usedBindingCount;
+
+    auto& vertexConstants = lazyInitializationData.vertexPushConstants;
+    auto& fragmentConstants = lazyInitializationData.fragmentPushConstants;
+
+    size_t const totalConstantCount = vertexConstants.size() + fragmentConstants.size();
+    if (totalConstantCount > 0) {
+        mPushConstants.reserve(totalConstantCount);
+        mPushConstantFragmentStageOffset = vertexConstants.size();
+        auto const transformAndAdd = [&](Program::PushConstant const& constant) {
+            GLint const loc = glGetUniformLocation(program, constant.name.c_str());
+            mPushConstants.push_back({loc, constant.type});
+        };
+        std::for_each(vertexConstants.cbegin(), vertexConstants.cend(), transformAndAdd);
+        std::for_each(fragmentConstants.cbegin(), fragmentConstants.cend(), transformAndAdd);
+    }
 }

 void OpenGLProgram::updateSamplers(OpenGLDriver* const gld) const noexcept {
@@ -27,6 +27,7 @@

 #include <utils/compiler.h>
 #include <utils/FixedCapacityVector.h>
+#include <utils/Slice.h>

 #include <array>
 #include <limits>
@@ -38,6 +39,11 @@ namespace filament::backend {

 class OpenGLDriver;

+struct PushConstantBundle {
+    utils::Slice<std::pair<GLint, ConstantType>> vertexConstants;
+    utils::Slice<std::pair<GLint, ConstantType>> fragmentConstants;
+};
+
 class OpenGLProgram : public HwProgram {
 public:

@@ -78,6 +84,14 @@ public:
        GLuint program = 0;
    } gl;                                               // 4 bytes

+    PushConstantBundle getPushConstants() {
+        auto fragBegin = mPushConstants.begin() + mPushConstantFragmentStageOffset;
+        return {
+            .vertexConstants = utils::Slice(mPushConstants.begin(), fragBegin),
+            .fragmentConstants = utils::Slice(fragBegin, mPushConstants.end()),
+        };
+    }
+
 private:
    // keep these away from of other class attributes
    struct LazyInitializationData;
@@ -95,11 +109,14 @@ private:
    ShaderCompilerService::program_token_t mToken{};    // 16 bytes

    uint8_t mUsedBindingsCount = 0u;                    // 1 byte
-    UTILS_UNUSED uint8_t padding[3] = {};               // 3 bytes
+    UTILS_UNUSED uint8_t padding[2] = {};               // 2 byte

+    // Push constant array offset for fragment stage constants.
+    uint8_t mPushConstantFragmentStageOffset = 0u;      // 1 byte

    // only needed for ES2
-    GLint mRec709Location = -1; // 4 bytes
+    GLint mRec709Location = -1;                         // 4 bytes
+
    using LocationInfo = utils::FixedCapacityVector<GLint>;
    struct UniformsRecord {
        Program::UniformInfo uniforms;
@@ -107,11 +124,15 @@ private:
        mutable GLuint id = 0;
        mutable uint16_t age = std::numeric_limits<uint16_t>::max();
    };
-    UniformsRecord const* mUniformsRecords = nullptr;
+    UniformsRecord const* mUniformsRecords = nullptr;               // 8 bytes
+
+    // Note that this can be replaced with a raw pointer and an uint8_t (for size) to reduce the
+    // size of the container to 9 bytes if there is a need in the future.
+    utils::FixedCapacityVector<std::pair<GLint, ConstantType>> mPushConstants;// 16 bytes
 };

 // if OpenGLProgram is larger tha 64 bytes, it'll fall in a larger Handle bucket.
-static_assert(sizeof(OpenGLProgram) <= 64); // currently 48 bytes
+static_assert(sizeof(OpenGLProgram) <= 64); // currently 64 bytes

 } // namespace filament::backend

@@ -174,7 +174,7 @@ Driver* PlatformEGL::createDriver(void* sharedContext, const Platform::DriverCon
    };

 #ifdef __ANDROID__
-    bool requestES2Context = false;
+    bool requestES2Context = driverConfig.forceGLES2Context;
    char property[PROP_VALUE_MAX];
    int const length = __system_property_get("debug.filament.es2", property);
    if (length > 0) {
@@ -25,6 +25,8 @@
 #include <android/api-level.h>
 #include <android/hardware_buffer.h>

+#include <utils/android/PerformanceHintManager.h>
+
 #include <utils/compiler.h>
 #include <utils/ostream.h>
 #include <utils/Log.h>
@@ -36,8 +38,11 @@

 #include <jni.h>

+#include <chrono>
 #include <new>

+#include <unistd.h>
+
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -112,8 +117,38 @@ void PlatformEGLAndroid::terminate() noexcept {
    PlatformEGL::terminate();
 }

+void PlatformEGLAndroid::beginFrame(
+        int64_t monotonic_clock_ns,
+        int64_t refreshIntervalNs,
+        uint32_t frameId) noexcept {
+    if (mPerformanceHintSession.isValid()) {
+        if (refreshIntervalNs <= 0) {
+            // we're not provided with a target time, assume 16.67ms
+            refreshIntervalNs = 16'666'667;
+        }
+        mStartTimeOfActualWork = clock::time_point(std::chrono::nanoseconds(monotonic_clock_ns));
+        mPerformanceHintSession.updateTargetWorkDuration(refreshIntervalNs);
+    }
+    PlatformEGL::beginFrame(monotonic_clock_ns, refreshIntervalNs, frameId);
+}
+
+void backend::PlatformEGLAndroid::preCommit() noexcept {
+    if (mPerformanceHintSession.isValid()) {
+        auto const actualWorkDuration = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                clock::now() - mStartTimeOfActualWork);
+        mPerformanceHintSession.reportActualWorkDuration(actualWorkDuration.count());
+    }
+    PlatformEGL::preCommit();
+}
+
 Driver* PlatformEGLAndroid::createDriver(void* sharedContext,
        const Platform::DriverConfig& driverConfig) noexcept {
+
+    // the refresh rate default value doesn't matter, we change it later
+    int32_t const tid = gettid();
+    mPerformanceHintSession = PerformanceHintManager::Session{
+            mPerformanceHintManager, &tid, 1, 16'666'667 };
+
    Driver* driver = PlatformEGL::createDriver(sharedContext, driverConfig);
    auto extensions = GLUtils::split(eglQueryString(mEGLDisplay, EGL_EXTENSIONS));

@@ -410,6 +410,7 @@ io::ostream& operator<<(io::ostream& out, const RasterState& rs) {
 io::ostream& operator<<(io::ostream& out, const TargetBufferInfo& tbi) {
    return out << "TargetBufferInfo{"
    << "handle=" << tbi.handle
+    << ", baseViewIndex=" << tbi.baseViewIndex
    << ", level=" << tbi.level
    << ", layer=" << tbi.layer << "}";
 }
@@ -26,21 +26,16 @@

 #include <smolv.h>

-#include "generated/vkshaders/vkshaders.h"
-
 using namespace bluevk;
 using namespace utils;

 namespace filament::backend {

-using ImgUtil = VulkanImageUtility;
-
 namespace {

 inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect, VkFilter filter,
        VulkanAttachment src, VulkanAttachment dst,
        const VkOffset3D srcRect[2], const VkOffset3D dstRect[2]) {
-
    if constexpr (FVK_ENABLED(FVK_DEBUG_BLITTER)) {
        utils::slog.d << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                      << " layout=" << src.getLayout()
@@ -48,21 +43,8 @@ inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
                      << " layout=" << dst.getLayout() << utils::io::endl;
    }

-    const VkImageSubresourceRange srcRange = {
-            .aspectMask = aspect,
-            .baseMipLevel = src.level,
-            .levelCount = 1,
-            .baseArrayLayer = src.layer,
-            .layerCount = 1,
-    };
-
-    const VkImageSubresourceRange dstRange = {
-            .aspectMask = aspect,
-            .baseMipLevel = dst.level,
-            .levelCount = 1,
-            .baseArrayLayer = dst.layer,
-            .layerCount = 1,
-    };
+    VkImageSubresourceRange const srcRange = src.getSubresourceRange();
+    VkImageSubresourceRange const dstRange = dst.getSubresourceRange();

    VulkanLayout oldSrcLayout = src.getLayout();
    VulkanLayout oldDstLayout = dst.getLayout();
@@ -77,15 +59,15 @@ inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
            .dstOffsets = { dstRect[0], dstRect[1] },
    }};
    vkCmdBlitImage(cmdbuffer,
-            src.getImage(), ImgUtil::getVkLayout(VulkanLayout::TRANSFER_SRC),
-            dst.getImage(), ImgUtil::getVkLayout(VulkanLayout::TRANSFER_DST),
+            src.getImage(), imgutil::getVkLayout(VulkanLayout::TRANSFER_SRC),
+            dst.getImage(), imgutil::getVkLayout(VulkanLayout::TRANSFER_DST),
            1, blitRegions, filter);

    if (oldSrcLayout == VulkanLayout::UNDEFINED) {
-        oldSrcLayout = ImgUtil::getDefaultLayout(src.texture->usage);
+        oldSrcLayout = imgutil::getDefaultLayout(src.texture->usage);
    }
    if (oldDstLayout == VulkanLayout::UNDEFINED) {
-        oldDstLayout = ImgUtil::getDefaultLayout(dst.texture->usage);
+        oldDstLayout = imgutil::getDefaultLayout(dst.texture->usage);
    }
    src.texture->transitionLayout(cmdbuffer, srcRange, oldSrcLayout);
    dst.texture->transitionLayout(cmdbuffer, dstRange, oldDstLayout);
@@ -93,7 +75,6 @@ inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,

 inline void resolveFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
        VulkanAttachment src, VulkanAttachment dst) {
-
    if constexpr (FVK_ENABLED(FVK_DEBUG_BLITTER)) {
        utils::slog.d << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                      << " layout=" << src.getLayout()
@@ -101,21 +82,8 @@ inline void resolveFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspe
                      << " layout=" << dst.getLayout() << utils::io::endl;
    }

-    const VkImageSubresourceRange srcRange = {
-            .aspectMask = aspect,
-            .baseMipLevel = src.level,
-            .levelCount = 1,
-            .baseArrayLayer = src.layer,
-            .layerCount = 1,
-    };
-
-    const VkImageSubresourceRange dstRange = {
-            .aspectMask = aspect,
-            .baseMipLevel = dst.level,
-            .levelCount = 1,
-            .baseArrayLayer = dst.layer,
-            .layerCount = 1,
-    };
+    VkImageSubresourceRange const srcRange = src.getSubresourceRange();
+    VkImageSubresourceRange const dstRange = dst.getSubresourceRange();

    VulkanLayout oldSrcLayout = src.getLayout();
    VulkanLayout oldDstLayout = dst.getLayout();
@@ -133,15 +101,15 @@ inline void resolveFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspe
            .extent = { src.getExtent2D().width, src.getExtent2D().height, 1 },
    }};
    vkCmdResolveImage(cmdbuffer,
-            src.getImage(), ImgUtil::getVkLayout(VulkanLayout::TRANSFER_SRC),
-            dst.getImage(), ImgUtil::getVkLayout(VulkanLayout::TRANSFER_DST),
+            src.getImage(), imgutil::getVkLayout(VulkanLayout::TRANSFER_SRC),
+            dst.getImage(), imgutil::getVkLayout(VulkanLayout::TRANSFER_DST),
            1, resolveRegions);

    if (oldSrcLayout == VulkanLayout::UNDEFINED) {
-        oldSrcLayout = ImgUtil::getDefaultLayout(src.texture->usage);
+        oldSrcLayout = imgutil::getDefaultLayout(src.texture->usage);
    }
    if (oldDstLayout == VulkanLayout::UNDEFINED) {
-        oldDstLayout = ImgUtil::getDefaultLayout(dst.texture->usage);
+        oldDstLayout = imgutil::getDefaultLayout(dst.texture->usage);
    }
    src.texture->transitionLayout(cmdbuffer, srcRange, oldSrcLayout);
    dst.texture->transitionLayout(cmdbuffer, dstRange, oldDstLayout);
@@ -27,8 +27,8 @@ VulkanBuffer::VulkanBuffer(VmaAllocator allocator, VulkanStagePool& stagePool,
        VkBufferUsageFlags usage, uint32_t numBytes)
    : mAllocator(allocator),
      mStagePool(stagePool),
-      mUsage(usage) {
-
+      mUsage(usage),
+      mUpdatedBytes(0) {
    // for now make sure that only 1 bit is set in usage
    // (because loadFromCpu() assumes that somewhat)
    assert_invariant(usage && !(usage & (usage - 1)));
@@ -49,8 +49,7 @@ VulkanBuffer::~VulkanBuffer() {
 }

 void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint32_t byteOffset,
-        uint32_t numBytes) const {
-    assert_invariant(byteOffset == 0);
+        uint32_t numBytes) {
    VulkanStage const* stage = mStagePool.acquireStage(numBytes);
    void* mapped;
    vmaMapMemory(mAllocator, stage->memory, &mapped);
@@ -58,15 +57,51 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
    vmaUnmapMemory(mAllocator, stage->memory);
    vmaFlushAllocation(mAllocator, stage->memory, byteOffset, numBytes);

-    VkBufferCopy region{ .size = numBytes };
+    // If there was a previous update, then we need to make sure the following write is properly
+    // synced with the previous read.
+    if (mUpdatedBytes > 0) {
+        VkAccessFlags srcAccess = 0;
+        VkPipelineStageFlags srcStage = 0;
+        if (mUsage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
+            srcAccess = VK_ACCESS_SHADER_READ_BIT;
+            srcStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+        } else if (mUsage & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) {
+            srcAccess = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
+            srcStage = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
+        } else if (mUsage & VK_BUFFER_USAGE_INDEX_BUFFER_BIT) {
+            srcAccess = VK_ACCESS_INDEX_READ_BIT;
+            srcStage = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
+        }
+
+        VkBufferMemoryBarrier barrier{
+            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+            .srcAccessMask = srcAccess,
+            .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .buffer = mGpuBuffer,
+            .size = mUpdatedBytes,
+        };
+        vkCmdPipelineBarrier(cmdbuf, srcStage, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1,
+                &barrier, 0, nullptr);
+    }
+
+    VkBufferCopy region {
+            .srcOffset = 0,
+            .dstOffset = byteOffset,
+            .size = numBytes,
+    };
    vkCmdCopyBuffer(cmdbuf, stage->buffer, mGpuBuffer, 1, &region);

+    mUpdatedBytes = numBytes;
+
    // Firstly, ensure that the copy finishes before the next draw call.
    // Secondly, in case the user decides to upload another chunk (without ever using the first one)
    // we need to ensure that this upload completes first (hence
    // dstStageMask=VK_PIPELINE_STAGE_TRANSFER_BIT).
    VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
+
    if (mUsage & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) {
        dstAccessMask |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
        dstStageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
@@ -75,26 +110,24 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
        dstStageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
    } else if (mUsage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
        dstAccessMask |= VK_ACCESS_UNIFORM_READ_BIT;
-        // NOTE: ideally dstStageMask would include VERTEX_SHADER_BIT | FRAGMENT_SHADER_BIT, but
-        // this seems to be insufficient on Mali devices. To work around this we are using a more
-        // aggressive ALL_GRAPHICS_BIT barrier.
-        dstStageMask |= VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
+        dstStageMask |=
+                (VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
    } else if (mUsage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) {
        // TODO: implement me
    }

    VkBufferMemoryBarrier barrier{
-	    .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-	    .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-	    .dstAccessMask = dstAccessMask,
-	    .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-	    .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-	    .buffer = mGpuBuffer,
-	    .size = VK_WHOLE_SIZE,
+        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+        .dstAccessMask = dstAccessMask,
+        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .buffer = mGpuBuffer,
+        .size = VK_WHOLE_SIZE,
    };

    vkCmdPipelineBarrier(cmdbuf, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageMask, 0, 0, nullptr, 1,
-	    &barrier, 0, nullptr);
+            &barrier, 0, nullptr);
 }

 } // namespace filament::backend
@@ -30,7 +30,7 @@ public:
            uint32_t numBytes);
    ~VulkanBuffer();
    void loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint32_t byteOffset,
-            uint32_t numBytes) const;
+            uint32_t numBytes);
    VkBuffer getGpuBuffer() const {
        return mGpuBuffer;
    }
@@ -42,6 +42,7 @@ private:
    VmaAllocation mGpuMemory = VK_NULL_HANDLE;
    VkBuffer mGpuBuffer = VK_NULL_HANDLE;
    VkBufferUsageFlags mUsage = {};
+    uint32_t mUpdatedBytes = 0;
 };

 } // namespace filament::backend
@@ -47,7 +47,8 @@ VulkanCmdFence::VulkanCmdFence(VkFence ifence)

 VulkanCommandBuffer::VulkanCommandBuffer(VulkanResourceAllocator* allocator, VkDevice device,
        VkCommandPool pool)
-    : mResourceManager(allocator) {
+    : mResourceManager(allocator),
+      mPipeline(VK_NULL_HANDLE) {
    // Create the low-level command buffer.
    const VkCommandBufferAllocateInfo allocateInfo{
            .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
@@ -89,6 +89,15 @@ struct VulkanCommandBuffer {
    inline void reset() {
        fence.reset();
        mResourceManager.clear();
+        mPipeline = VK_NULL_HANDLE;
+    }
+
+    inline void setPipeline(VkPipeline pipeline) {
+        mPipeline = pipeline;
+    }
+
+    inline VkPipeline pipeline() const {
+        return mPipeline;
    }

    inline VkCommandBuffer buffer() const {
@@ -103,6 +112,7 @@ struct VulkanCommandBuffer {
 private:
    VulkanAcquireOnlyResourceManager mResourceManager;
    VkCommandBuffer mBuffer;
+    VkPipeline mPipeline;
 };

 // Allows classes to be notified after a new command buffer has been activated.
@@ -47,7 +47,7 @@
 // granualarity of a renderpass. You can enable this along with FVK_DEBUG_DEBUG_UTILS to take
 // advantage of vkCmdBegin/EndDebugUtilsLabelEXT. You can also just enable this with
 // FVK_DEBUG_PRINT_GROUP_MARKERS to print the current marker to stdout.
-#define FVK_DEBUG_GROUP_MARKERS 0x00000002
+#define FVK_DEBUG_GROUP_MARKERS           0x00000002

 #define FVK_DEBUG_TEXTURE                 0x00000004
 #define FVK_DEBUG_LAYOUT_TRANSITION       0x00000008
@@ -75,18 +75,14 @@
 #define FVK_DEBUG_PERFORMANCE     \
    FVK_DEBUG_SYSTRACE

-#define FVK_DEBUG_CORRECTNESS     \
-    FVK_DEBUG_VALIDATION |        \
-    FVK_DEBUG_SHADER_MODULE |     \
-    FVK_DEBUG_TEXTURE |           \
-    FVK_DEBUG_LAYOUT_TRANSITION
-
-#define FVK_DEBUG_RENDER_PASSES   \
-    FVK_DEBUG_GROUP_MARKERS |     \
-    FVK_DEBUG_PRINT_GROUP_MARKERS
+#if defined(FILAMENT_BACKEND_DEBUG_FLAG)
+#define FVK_DEBUG_FORWARDED_FLAG (FILAMENT_BACKEND_DEBUG_FLAG & FVK_DEBUG_EVERYTHING)
+#else
+#define FVK_DEBUG_FORWARDED_FLAG 0
+#endif

 #ifndef NDEBUG
-#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE)
+#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE | FVK_DEBUG_FORWARDED_FLAG)
 #else
 #define FVK_DEBUG_FLAGS 0
 #endif
@@ -112,7 +108,7 @@ static_assert(FVK_ENABLED(FVK_DEBUG_VALIDATION));
 // end dependcy checks

 // Shorthand for combination of enabled debug flags
-#if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS) || FVK_ENABLED(FVK_DEBUG_TEXTURE)
+#if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS) && FVK_ENABLED(FVK_DEBUG_TEXTURE)
 #define FVK_ENABLED_DEBUG_SAMPLER_NAME 1
 #else
 #define FVK_ENABLED_DEBUG_SAMPLER_NAME 0
@@ -57,15 +57,19 @@ VkExtent2D VulkanAttachment::getExtent2D() const {
    return { std::max(1u, texture->width >> level), std::max(1u, texture->height >> level) };
 }

-VkImageView VulkanAttachment::getImageView(VkImageAspectFlags aspect) {
+VkImageView VulkanAttachment::getImageView() {
    assert_invariant(texture);
-    return texture->getAttachmentView(getSubresourceRange(aspect));
+    return texture->getAttachmentView(getSubresourceRange());
 }

-VkImageSubresourceRange VulkanAttachment::getSubresourceRange(VkImageAspectFlags aspect) const {
+bool VulkanAttachment::isDepth() const {
+    return texture->getImageAspect() & VK_IMAGE_ASPECT_DEPTH_BIT;
+}
+
+VkImageSubresourceRange VulkanAttachment::getSubresourceRange() const {
    assert_invariant(texture);
    return {
-            .aspectMask = aspect,
+            .aspectMask = texture->getImageAspect(),
            .baseMipLevel = uint32_t(level),
            .levelCount = 1,
            .baseArrayLayer = uint32_t(layer),
@@ -44,13 +44,15 @@ struct VulkanAttachment {
    VulkanTexture* texture = nullptr;
    uint8_t level = 0;
    uint16_t layer = 0;
+
+    bool isDepth() const;
    VkImage getImage() const;
    VkFormat getFormat() const;
    VulkanLayout getLayout() const;
    VkExtent2D getExtent2D() const;
-    VkImageView getImageView(VkImageAspectFlags aspect);
+    VkImageView getImageView();
    // TODO: maybe embed aspect into the attachment or texture itself.
-    VkImageSubresourceRange getSubresourceRange(VkImageAspectFlags aspect) const;
+    VkImageSubresourceRange getSubresourceRange() const;
 };

 class VulkanTimestamps {
@@ -101,8 +103,12 @@ public:
        return (uint32_t) VK_MAX_MEMORY_TYPES;
    }

-    inline VkFormatList const& getAttachmentDepthFormats() const {
-        return mDepthFormats;
+    inline VkFormatList const& getAttachmentDepthStencilFormats() const {
+        return mDepthStencilFormats;
+    }
+
+    inline VkFormatList const& getBlittableDepthStencilFormats() const {
+        return mBlittableDepthStencilFormats;
    }

    inline VkPhysicalDeviceLimits const& getPhysicalDeviceLimits() const noexcept {
@@ -131,7 +137,8 @@ private:
    bool mDebugMarkersSupported = false;
    bool mDebugUtilsSupported = false;

-    VkFormatList mDepthFormats;
+    VkFormatList mDepthStencilFormats;
+    VkFormatList mBlittableDepthStencilFormats;

    // For convenience so that VulkanPlatform can initialize the private fields.
    friend class VulkanPlatform;
@@ -14,7 +14,7 @@
 * limitations under the License.
 */

-#include "vulkan/VulkanDriver.h"
+#include "VulkanDriver.h"

 #include "CommandStreamDispatcher.h"
 #include "DataReshaper.h"
@@ -22,7 +22,6 @@
 #include "VulkanCommands.h"
 #include "VulkanDriverFactory.h"
 #include "VulkanHandles.h"
-#include "VulkanImageUtility.h"
 #include "VulkanMemory.h"
 #include "VulkanTexture.h"

@@ -102,6 +101,15 @@ VulkanTexture* createEmptyTexture(VkDevice device, VkPhysicalDevice physicalDevi
    return emptyTexture;
 }

+VulkanBufferObject* createEmptyBufferObject(VmaAllocator allocator, VulkanStagePool& stagePool,
+        VulkanCommands* commands) {
+    VulkanBufferObject* obj =
+            new VulkanBufferObject(allocator, stagePool, 1, BufferObjectBinding::UNIFORM);
+    uint8_t byte = 0;
+    obj->buffer.loadFromCpu(commands->get().buffer(), &byte, 0, 1);
+    return obj;
+}
+
 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
 VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallback(VkDebugReportFlagsEXT flags,
        VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location,
@@ -197,8 +205,6 @@ void DebugUtils::setName(VkObjectType type, uint64_t handle, char const* name) {
 }
 #endif // FVK_EANBLED(FVK_DEBUG_DEBUG_UTILS)

-using ImgUtil = VulkanImageUtility;
-
 Dispatcher VulkanDriver::getDispatcher() const noexcept {
    return ConcreteDispatcher<VulkanDriver>::make();
 }
@@ -214,12 +220,14 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
      mThreadSafeResourceManager(&mResourceAllocator),
      mCommands(mPlatform->getDevice(), mPlatform->getGraphicsQueue(),
              mPlatform->getGraphicsQueueFamilyIndex(), &mContext, &mResourceAllocator),
-      mPipelineCache(&mResourceAllocator),
+      mPipelineLayoutCache(mPlatform->getDevice(), &mResourceAllocator),
+      mPipelineCache(mPlatform->getDevice(), mAllocator),
      mStagePool(mAllocator, &mCommands),
      mFramebufferCache(mPlatform->getDevice()),
      mSamplerCache(mPlatform->getDevice()),
      mBlitter(mPlatform->getPhysicalDevice(), &mCommands),
      mReadPixels(mPlatform->getDevice()),
+      mDescriptorSetManager(mPlatform->getDevice(), &mResourceAllocator),
      mIsSRGBSwapChainSupported(mPlatform->getCustomization().isSRGBSwapChainSupported) {

 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
@@ -243,13 +251,17 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
 #endif

    mTimestamps = std::make_unique<VulkanTimestamps>(mPlatform->getDevice());
-    mCommands.setObserver(&mPipelineCache);
-    mPipelineCache.setDevice(mPlatform->getDevice(), mAllocator);

    mEmptyTexture = createEmptyTexture(mPlatform->getDevice(), mPlatform->getPhysicalDevice(),
            mContext, mAllocator, &mCommands, mStagePool);
+    mEmptyBufferObject = createEmptyBufferObject(mAllocator, mStagePool, &mCommands);

-    mPipelineCache.setDummyTexture(mEmptyTexture->getPrimaryImageView());
+    mDescriptorSetManager.setPlaceHolders(mSamplerCache.getSampler({}), mEmptyTexture,
+            mEmptyBufferObject);
+
+    mGetPipelineFunction = [this](VulkanDescriptorSetLayoutList const& layouts, VulkanProgram* program) {
+        return mPipelineLayoutCache.getLayout(layouts, program);
+    };
 }

 VulkanDriver::~VulkanDriver() noexcept = default;
@@ -310,13 +322,14 @@ ShaderModel VulkanDriver::getShaderModel() const noexcept {
 }

 void VulkanDriver::terminate() {
+    delete mEmptyBufferObject;
+    delete mEmptyTexture;
+
    // Command buffers should come first since it might have commands depending on resources that
    // are about to be destroyed.
    mCommands.terminate();

-    delete mEmptyTexture;
    mResourceManager.clear();
-
    mTimestamps.reset();

    mBlitter.terminate();
@@ -329,6 +342,12 @@ void VulkanDriver::terminate() {
    mPipelineCache.terminate();
    mFramebufferCache.reset();
    mSamplerCache.terminate();
+    mDescriptorSetManager.terminate();
+    mPipelineLayoutCache.terminate();
+
+#if FVK_ENABLED(FVK_DEBUG_RESOURCE_LEAK)
+    mResourceAllocator.print();
+#endif

    vmaDestroyAllocator(mAllocator);

@@ -360,6 +379,8 @@ void VulkanDriver::collectGarbage() {
    mCommands.gc();
    mStagePool.gc();
    mFramebufferCache.gc();
+    mPipelineCache.gc();
+    mDescriptorSetManager.gc();

 #if FVK_ENABLED(FVK_DEBUG_RESOURCE_LEAK)
    mResourceAllocator.print();
@@ -367,12 +388,13 @@ void VulkanDriver::collectGarbage() {

    FVK_SYSTRACE_END();
 }
-void VulkanDriver::beginFrame(int64_t monotonic_clock_ns, uint32_t frameId) {
+void VulkanDriver::beginFrame(int64_t monotonic_clock_ns,
+        int64_t refreshIntervalNs, uint32_t frameId) {
    // Do nothing.
 }

 void VulkanDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
-        FrameScheduledCallback callback, void* user) {
+        CallbackHandler* handler, FrameScheduledCallback&& callback) {
 }

 void VulkanDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
@@ -489,9 +511,6 @@ void VulkanDriver::destroyBufferObject(Handle<HwBufferObject> boh) {
        return;
    }
    auto bufferObject = mResourceAllocator.handle_cast<VulkanBufferObject*>(boh);
-    if (bufferObject->bindingType == BufferObjectBinding::UNIFORM) {
-        mPipelineCache.unbindUniformBuffer(bufferObject->buffer.getGpuBuffer());
-    }
    mResourceManager.release(bufferObject);
 }

@@ -542,6 +561,7 @@ void VulkanDriver::destroyProgram(Handle<HwProgram> ph) {
        return;
    }
    auto vkprogram = mResourceAllocator.handle_cast<VulkanProgram*>(ph);
+    mDescriptorSetManager.clearProgram(vkprogram);
    mResourceManager.release(vkprogram);
 }

@@ -898,6 +918,11 @@ bool VulkanDriver::isDepthStencilResolveSupported() {
    return false;
 }

+bool VulkanDriver::isDepthStencilBlitSupported(TextureFormat format) {
+    auto const& formats = mContext.getBlittableDepthStencilFormats();
+    return std::find(formats.begin(), formats.end(), getVkFormat(format)) != formats.end();
+}
+
 bool VulkanDriver::isProtectedTexturesSupported() {
    return false;
 }
@@ -1211,12 +1236,7 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
        }
    }

-    VulkanLayout const currentDepthLayout = depth.getLayout();
-    VulkanLayout const renderPassDepthLayout = VulkanLayout::DEPTH_ATTACHMENT;
-    // We need to keep the final layout as an attachment because the implicit transition does not
-    // have any barrier guarrantees, meaning that if we want to sample from the output in the next
-    // pass, then we'd have a race-condition/validation error.
-    VulkanLayout const finalDepthLayout = renderPassDepthLayout;
+    VulkanLayout currentDepthLayout = depth.getLayout();

    TargetBufferFlags clearVal = params.flags.clear;
    TargetBufferFlags discardEndVal = params.flags.discardEnd;
@@ -1225,16 +1245,20 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
            discardEndVal &= ~TargetBufferFlags::DEPTH;
            clearVal &= ~TargetBufferFlags::DEPTH;
        }
-        auto const attachmentSubresourceRange = depth.getSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT);
-        depth.texture->setLayout(attachmentSubresourceRange, VulkanLayout::DEPTH_ATTACHMENT);
+        // If the depth attachment texture was previously sampled, then we need to manually
+        // transition it to an attachment. This is necessary to also set up a barrier between the
+        // previous read and the potentially coming write.
+        if (currentDepthLayout == VulkanLayout::DEPTH_SAMPLER) {
+            depth.texture->transitionLayout(cmdbuffer, depth.getSubresourceRange(),
+                    VulkanLayout::DEPTH_ATTACHMENT);
+            currentDepthLayout = VulkanLayout::DEPTH_ATTACHMENT;
+        }
    }

    // Create the VkRenderPass or fetch it from cache.
    VulkanFboCache::RenderPassKey rpkey = {
        .initialColorLayoutMask = 0,
        .initialDepthLayout = currentDepthLayout,
-        .renderPassDepthLayout = renderPassDepthLayout,
-        .finalDepthLayout = finalDepthLayout,
        .depthFormat = depth.getFormat(),
        .clear = clearVal,
        .discardStart = discardStart,
@@ -1251,9 +1275,9 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
                rpkey.needsResolveMask |= (1 << i);
            }
            if (info.texture->getPrimaryImageLayout() != VulkanLayout::COLOR_ATTACHMENT) {
-                ((VulkanTexture*) info.texture)->transitionLayout(cmdbuffer,
-                        info.getSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT),
-                        VulkanLayout::COLOR_ATTACHMENT);
+                ((VulkanTexture*) info.texture)
+                        ->transitionLayout(cmdbuffer, info.getSubresourceRange(),
+                                VulkanLayout::COLOR_ATTACHMENT);
            }
        } else {
            rpkey.colorFormat[i] = VK_FORMAT_UNDEFINED;
@@ -1271,27 +1295,42 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
        .layers = 1,
        .samples = rpkey.samples,
    };
+    auto& renderPassAttachments = mRenderPassFboInfo.attachments;
    for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; i++) {
        if (!rt->getColor(i).texture) {
            fbkey.color[i] = VK_NULL_HANDLE;
            fbkey.resolve[i] = VK_NULL_HANDLE;
        } else if (fbkey.samples == 1) {
-            fbkey.color[i] = rt->getColor(i).getImageView(VK_IMAGE_ASPECT_COLOR_BIT);
+            auto& colorAttachment = rt->getColor(i);
+            renderPassAttachments.insert(colorAttachment);
+            fbkey.color[i] = colorAttachment.getImageView();
            fbkey.resolve[i] = VK_NULL_HANDLE;
            assert_invariant(fbkey.color[i]);
        } else {
-            fbkey.color[i] = rt->getMsaaColor(i).getImageView(VK_IMAGE_ASPECT_COLOR_BIT);
-            VulkanTexture* texture = (VulkanTexture*) rt->getColor(i).texture;
+            auto& msaaColorAttachment = rt->getMsaaColor(i);
+            renderPassAttachments.insert(msaaColorAttachment);
+
+            auto& colorAttachment = rt->getColor(i);
+            fbkey.color[i] = msaaColorAttachment.getImageView();
+
+            VulkanTexture* texture = colorAttachment.texture;
            if (texture->samples == 1) {
-                fbkey.resolve[i] = rt->getColor(i).getImageView(VK_IMAGE_ASPECT_COLOR_BIT);
+                mRenderPassFboInfo.hasColorResolve = true;
+
+                renderPassAttachments.insert(colorAttachment);
+                fbkey.resolve[i] = colorAttachment.getImageView();
                assert_invariant(fbkey.resolve[i]);
            }
            assert_invariant(fbkey.color[i]);
        }
    }
    if (depth.texture) {
-        fbkey.depth = depth.getImageView(VK_IMAGE_ASPECT_DEPTH_BIT);
+        fbkey.depth = depth.getImageView();
        assert_invariant(fbkey.depth);
+        renderPassAttachments.insert(depth);
+
+        UTILS_UNUSED_IN_RELEASE bool const depthDiscardEnd =
+                any(rpkey.discardEnd & TargetBufferFlags::DEPTH);

        // Vulkan 1.1 does not support multisampled depth resolve, so let's check here
        // and assert if this is requested. (c.f. isAutoDepthResolveSupported)
@@ -1300,7 +1339,7 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
        // - If the RT is MS then all SS attachments are auto resolved if not discarded.
        assert_invariant(!(rt->getSamples() > 1 &&
                rt->getDepth().texture->samples == 1 &&
-                !any(rpkey.discardEnd & TargetBufferFlags::DEPTH)));
+                !depthDiscardEnd));
    }
    VkFramebuffer vkfb = mFramebufferCache.getFramebuffer(fbkey);

@@ -1313,16 +1352,10 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
    }
 #endif

-    // The current command buffer now owns a reference to the render target and its attachments.
-    // Note that we must acquire parent textures, not sidecars.
+    // The current command buffer now has references to the render target and its attachments.
    commands.acquire(rt);
-    if (depth.texture) {
-        commands.acquire((VulkanTexture*) depth.texture);
-    }
-    for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; i++) {
-        if (rt->getColor(i).texture) {
-            commands.acquire(rt->getColor(i).texture);
-        }
+    for (auto const& attachment: renderPassAttachments) {
+        commands.acquire(attachment.texture);
    }

    // Populate the structures required for vkCmdBeginRenderPass.
@@ -1408,33 +1441,52 @@ void VulkanDriver::endRenderPass(int) {
    // issue several of them when considering MRT. This would be very complex to set up and would
    // require more state tracking, so we've chosen to use a memory barrier for simplicity and
    // correctness.
-
-    // NOTE: ideally dstStageMask would merely be VERTEX_SHADER_BIT | FRAGMENT_SHADER_BIT, but this
-    // seems to be insufficient on Mali devices. To work around this we are adding a more aggressive
-    // TOP_OF_PIPE barrier.
    if (!rt->isSwapChain()) {
-        VkMemoryBarrier barrier{
-                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
-                .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-                .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
-        };
-        VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-        if (rt->hasDepth()) {
-            barrier.srcAccessMask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-            srcStageMask |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
+        for (auto const& attachment: mRenderPassFboInfo.attachments) {
+            bool const isDepth = attachment.isDepth();
+            VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+
+            // This is a workaround around a validation issue (might not be an actual driver issue).
+            if (mRenderPassFboInfo.hasColorResolve && !isDepth) {
+                srcStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
+            }
+
+            VkPipelineStageFlags dstStageMask =
+                    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+            VkAccessFlags srcAccess = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+            VkAccessFlags dstAccess = VK_ACCESS_SHADER_READ_BIT;
+            VulkanLayout layout = VulkanFboCache::FINAL_COLOR_ATTACHMENT_LAYOUT;
+            if (isDepth) {
+                srcAccess = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+                dstAccess = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+                srcStageMask = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
+                dstStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+                layout =  VulkanFboCache::FINAL_DEPTH_ATTACHMENT_LAYOUT;
+            }
+
+            auto const vkLayout = imgutil::getVkLayout(layout);
+            auto const& range = attachment.getSubresourceRange();
+            VkImageMemoryBarrier barrier = {
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = srcAccess,
+                .dstAccessMask = dstAccess,
+                .oldLayout = vkLayout,
+                .newLayout = vkLayout,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .image = attachment.getImage(),
+                .subresourceRange = range,
+            };
+
+            attachment.texture->setLayout(range, layout);
+            vkCmdPipelineBarrier(cmdbuffer, srcStageMask, dstStageMask, 0, 0, nullptr, 0, nullptr,
+                    1, &barrier);
        }
-        vkCmdPipelineBarrier(cmdbuffer, srcStageMask,
-                VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT | // <== For Mali
-                VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-                0, 1, &barrier, 0, nullptr, 0, nullptr);
    }

-    if (mCurrentRenderPass.currentSubpass > 0) {
-        for (uint32_t i = 0; i < VulkanPipelineCache::INPUT_ATTACHMENT_COUNT; i++) {
-            mPipelineCache.bindInputAttachment(i, {});
-        }
-        mCurrentRenderPass.currentSubpass = 0;
-    }
+    mRenderPassFboInfo.clear();
+    mDescriptorSetManager.clearState();
    mCurrentRenderPass.renderTarget = nullptr;
    mCurrentRenderPass.renderPass = VK_NULL_HANDLE;
    FVK_SYSTRACE_END();
@@ -1453,15 +1505,9 @@ void VulkanDriver::nextSubpass(int) {
    mPipelineCache.bindRenderPass(mCurrentRenderPass.renderPass,
            ++mCurrentRenderPass.currentSubpass);

-    for (uint32_t i = 0; i < VulkanPipelineCache::INPUT_ATTACHMENT_COUNT; i++) {
-        if ((1 << i) & mCurrentRenderPass.params.subpassMask) {
-            VulkanAttachment subpassInput = renderTarget->getColor(i);
-            VkDescriptorImageInfo info = {
-                .imageView = subpassInput.getImageView(VK_IMAGE_ASPECT_COLOR_BIT),
-                .imageLayout = ImgUtil::getVkLayout(subpassInput.getLayout()),
-            };
-            mPipelineCache.bindInputAttachment(i, info);
-        }
+    if (mCurrentRenderPass.params.subpassMask & 0x1) {
+        VulkanAttachment subpassInput = renderTarget->getColor(0);
+        mDescriptorSetManager.updateInputAttachment({}, subpassInput);
    }
 }

@@ -1501,25 +1547,24 @@ void VulkanDriver::commit(Handle<HwSwapChain> sch) {

 void VulkanDriver::bindUniformBuffer(uint32_t index, Handle<HwBufferObject> boh) {
    auto* bo = mResourceAllocator.handle_cast<VulkanBufferObject*>(boh);
-    const VkDeviceSize offset = 0;
-    const VkDeviceSize size = VK_WHOLE_SIZE;
-    mPipelineCache.bindUniformBufferObject((uint32_t) index, bo, offset, size);
+    VkDeviceSize const offset = 0;
+    VkDeviceSize const size = VK_WHOLE_SIZE;
+    mDescriptorSetManager.updateBuffer({}, (uint32_t) index, bo, offset, size);
 }

 void VulkanDriver::bindBufferRange(BufferObjectBinding bindingType, uint32_t index,
        Handle<HwBufferObject> boh, uint32_t offset, uint32_t size) {

-    assert_invariant(bindingType == BufferObjectBinding::SHADER_STORAGE ||
-                     bindingType == BufferObjectBinding::UNIFORM);
+    assert_invariant(bindingType == BufferObjectBinding::UNIFORM);

    // TODO: implement BufferObjectBinding::SHADER_STORAGE case

    auto* bo = mResourceAllocator.handle_cast<VulkanBufferObject*>(boh);
-    mPipelineCache.bindUniformBufferObject((uint32_t)index, bo, offset, size);
+    mDescriptorSetManager.updateBuffer({}, (uint32_t) index, bo, offset, size);
 }

 void VulkanDriver::unbindBuffer(BufferObjectBinding bindingType, uint32_t index) {
-    // TODO: implement unbindBuffer()
+    mDescriptorSetManager.clearBuffer((uint32_t) index);
 }

 void VulkanDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
@@ -1527,6 +1572,14 @@ void VulkanDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
    mSamplerBindings[index] = hwsb;
 }

+void VulkanDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
+        backend::PushConstantVariant value) {
+    assert_invariant(mBoundPipeline.program && "Expect a program when writing to push constants");
+    VulkanCommands* commands = &mCommands;
+    mBoundPipeline.program->writePushConstant(commands, mBoundPipeline.pipelineLayout, stage, index,
+            value);
+}
+
 void VulkanDriver::insertEventMarker(char const* string, uint32_t len) {
 #if FVK_ENABLED(FVK_DEBUG_GROUP_MARKERS)
    mCommands.insertEventMarker(string, len);
@@ -1767,21 +1820,14 @@ void VulkanDriver::bindPipeline(PipelineState pipelineState) {
    // where "SamplerBinding" is the integer in the GLSL, and SamplerGroupBinding is the abstract
    // Filament concept used to form groups of samplers.

-    VkDescriptorImageInfo samplerInfo[VulkanPipelineCache::SAMPLER_BINDING_COUNT] = {};
-    VulkanTexture* samplerTextures[VulkanPipelineCache::SAMPLER_BINDING_COUNT] = {nullptr};
-
    auto const& bindingToSamplerIndex = program->getBindingToSamplerIndex();
-    UsageFlags usage = program->getUsage();
-
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
    auto const& bindingToName = program->getBindingToName();
 #endif

    for (auto binding: program->getBindings()) {
        uint16_t const indexPair = bindingToSamplerIndex[binding];
-
        if (indexPair == 0xffff) {
-            usage = VulkanPipelineCache::disableUsageFlags(binding, usage);
            continue;
        }

@@ -1790,24 +1836,20 @@ void VulkanDriver::bindPipeline(PipelineState pipelineState) {

        VulkanSamplerGroup* vksb = mSamplerBindings[samplerGroupInd];
        if (!vksb) {
-            usage = VulkanPipelineCache::disableUsageFlags(binding, usage);
            continue;
        }
        SamplerDescriptor const* boundSampler = ((SamplerDescriptor*) vksb->sb->data()) + samplerInd;

        if (UTILS_UNLIKELY(!boundSampler->t)) {
-            usage = VulkanPipelineCache::disableUsageFlags(binding, usage);
            continue;
        }
-
        VulkanTexture* texture = mResourceAllocator.handle_cast<VulkanTexture*>(boundSampler->t);
-        VkImageViewType const expectedType = texture->getViewType();

        // TODO: can this uninitialized check be checked in a higher layer?
        // This fallback path is very flaky because the dummy texture might not have
        // matching characteristics. (e.g. if the missing texture is a 3D texture)
        if (UTILS_UNLIKELY(texture->getPrimaryImageLayout() == VulkanLayout::UNDEFINED)) {
-#if FVK_ENABLED(FVK_DEBUG_TEXTURE)
+#if FVK_ENABLED(FVK_DEBUG_TEXTURE) && FVK_ENABLED_DEBUG_SAMPLER_NAME
            utils::slog.w << "Uninitialized texture bound to '" << bindingToName[binding] << "'";
            utils::slog.w << " in material '" << program->name.c_str() << "'";
            utils::slog.w << " at binding point " << +binding << utils::io::endl;
@@ -1815,43 +1857,22 @@ void VulkanDriver::bindPipeline(PipelineState pipelineState) {
            texture = mEmptyTexture;
        }

-        SamplerParams const& samplerParams = boundSampler->s;
-        VkSampler const vksampler = mSamplerCache.getSampler(samplerParams);
-
+        VkSampler const vksampler = mSamplerCache.getSampler(boundSampler->s);
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
        VulkanDriver::DebugUtils::setName(VK_OBJECT_TYPE_SAMPLER,
                reinterpret_cast<uint64_t>(vksampler), bindingToName[binding].c_str());
 #endif
-
-        VkImageView imageView = VK_NULL_HANDLE;
-        VkImageSubresourceRange const range = texture->getPrimaryViewRange();
-        if (any(texture->usage & TextureUsage::DEPTH_ATTACHMENT) &&
-                expectedType == VK_IMAGE_VIEW_TYPE_2D) {
-            // If the sampler is part of a mipmapped depth texture, where one of the level *can* be
-            // an attachment, then the sampler for this texture has the same view properties as a
-            // view for an attachment. Therefore, we can use getAttachmentView to get a
-            // corresponding VkImageView.
-            imageView = texture->getAttachmentView(range);
-        } else {
-            imageView = texture->getViewForType(range, expectedType);
-        }
-
-        samplerInfo[binding] = {
-            .sampler = vksampler,
-            .imageView = imageView,
-            .imageLayout = ImgUtil::getVkLayout(texture->getPrimaryImageLayout())
-        };
-        samplerTextures[binding] = texture;
+        mDescriptorSetManager.updateSampler({}, binding, texture, vksampler);
    }

-    mPipelineCache.bindSamplers(samplerInfo, samplerTextures, usage);
+    auto const pipelineLayout = mDescriptorSetManager.bind(commands, program, mGetPipelineFunction);
+    mBoundPipeline = {
+        .program = program,
+        .pipelineLayout = pipelineLayout,
+    };

-    // Bind a new pipeline if the pipeline state changed.
-    // If allocation failed, skip the draw call and bail. We do not emit an error since the
-    // validation layer will already do so.
-    if (!mPipelineCache.bindPipeline(commands)) {
-        return;
-    }
+    mPipelineCache.bindLayout(pipelineLayout);
+    mPipelineCache.bindPipeline(commands);
    FVK_SYSTRACE_END();
 }

@@ -1891,12 +1912,8 @@ void VulkanDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
    VulkanCommandBuffer& commands = mCommands.get();
    VkCommandBuffer cmdbuffer = commands.buffer();

-    // Bind new descriptor sets if they need to change.
-    // If descriptor set allocation failed, skip the draw call and bail. No need to emit an error
-    // message since the validation layers already do so.
-    if (!mPipelineCache.bindDescriptors(cmdbuffer)) {
-        return;
-    }
+    // Bind "dynamic" UBOs if they need to change.
+    mDescriptorSetManager.dynamicBind(&commands, {});

    // Finally, make the actual draw call. TODO: support subranges
    const uint32_t firstIndex = indexOffset;
@@ -28,6 +28,8 @@
 #include "VulkanSamplerCache.h"
 #include "VulkanStagePool.h"
 #include "VulkanUtility.h"
+#include "caching/VulkanDescriptorSetManager.h"
+#include "caching/VulkanPipelineLayoutCache.h"

 #include "DriverBase.h"
 #include "private/backend/Driver.h"
@@ -40,6 +42,25 @@ namespace filament::backend {
 class VulkanPlatform;
 struct VulkanSamplerGroup;

+// The maximum number of attachments for any renderpass (color + resolve + depth)
+constexpr uint8_t MAX_RENDERTARGET_ATTACHMENT_TEXTURES =
+        MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT * 2 + 1;
+
+// We need to store information about a render pass to enable better barriers at the end of a
+// renderpass.
+struct RenderPassFboBundle {
+    using AttachmentArray =
+            CappedArray<VulkanAttachment, MAX_RENDERTARGET_ATTACHMENT_TEXTURES>;
+
+    AttachmentArray attachments;
+    bool hasColorResolve = false;
+
+    void clear() {
+        attachments.clear();
+        hasColorResolve = false;
+    }
+};
+
 class VulkanDriver final : public DriverBase {
 public:
    static Driver* create(VulkanPlatform* platform, VulkanContext const& context,
@@ -70,6 +91,8 @@ public:
 #endif // FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)

 private:
+    static constexpr uint8_t MAX_SAMPLER_BINDING_COUNT = Program::SAMPLER_BINDING_COUNT;
+
    void debugCommandBegin(CommandStream* cmds, bool synchronous,
            const char* methodName) noexcept override;

@@ -106,7 +129,9 @@ private:
    VulkanPlatform* mPlatform = nullptr;
    std::unique_ptr<VulkanTimestamps> mTimestamps;

+    // Placeholder resources
    VulkanTexture* mEmptyTexture;
+    VulkanBufferObject* mEmptyBufferObject;

    VulkanSwapChain* mCurrentSwapChain = nullptr;
    VulkanRenderTarget* mDefaultRenderTarget = nullptr;
@@ -123,13 +148,26 @@ private:
    VulkanThreadSafeResourceManager mThreadSafeResourceManager;

    VulkanCommands mCommands;
+    VulkanPipelineLayoutCache mPipelineLayoutCache;
    VulkanPipelineCache mPipelineCache;
    VulkanStagePool mStagePool;
    VulkanFboCache mFramebufferCache;
    VulkanSamplerCache mSamplerCache;
    VulkanBlitter mBlitter;
-    VulkanSamplerGroup* mSamplerBindings[VulkanPipelineCache::SAMPLER_BINDING_COUNT] = {};
+    VulkanSamplerGroup* mSamplerBindings[MAX_SAMPLER_BINDING_COUNT] = {};
    VulkanReadPixels mReadPixels;
+    VulkanDescriptorSetManager mDescriptorSetManager;
+
+    VulkanDescriptorSetManager::GetPipelineLayoutFunction mGetPipelineFunction;
+
+    // This is necessary for us to write to push constants after binding a pipeline.
+    struct BoundPipeline {
+        VulkanProgram* program;
+        VkPipelineLayout pipelineLayout;
+    };
+    BoundPipeline mBoundPipeline = {};
+
+    RenderPassFboBundle mRenderPassFboInfo;

    bool const mIsSRGBSwapChainSupported;
 };
@@ -29,14 +29,10 @@ using namespace bluevk;

 namespace filament::backend {

-using ImgUtil = VulkanImageUtility;
-
 bool VulkanFboCache::RenderPassEq::operator()(const RenderPassKey& k1,
        const RenderPassKey& k2) const {
    if (k1.initialColorLayoutMask != k2.initialColorLayoutMask) return false;
    if (k1.initialDepthLayout != k2.initialDepthLayout) return false;
-    if (k1.renderPassDepthLayout != k2.renderPassDepthLayout) return false;
-    if (k1.finalDepthLayout != k2.finalDepthLayout) return false;
    for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; i++) {
        if (k1.colorFormat[i] != k2.colorFormat[i]) return false;
    }
@@ -197,7 +193,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
        if (config.colorFormat[i] == VK_FORMAT_UNDEFINED) {
            continue;
        }
-        const VkImageLayout subpassLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT);
+        const VkImageLayout subpassLayout = imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT);
        uint32_t index;

        if (!hasSubpasses) {
@@ -243,9 +239,9 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
            .stencilLoadOp = kDontCare,
            .stencilStoreOp = kDisableStore,
            .initialLayout = ((!discard && config.initialColorLayoutMask & (1 << i)) || clear)
-                                     ? ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT)
-                                     : ImgUtil::getVkLayout(VulkanLayout::UNDEFINED),
-            .finalLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
+                                     ? imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT)
+                                     : imgutil::getVkLayout(VulkanLayout::UNDEFINED),
+            .finalLayout = imgutil::getVkLayout(FINAL_COLOR_ATTACHMENT_LAYOUT),
        };
    }

@@ -272,7 +268,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {

        pResolveAttachment->attachment = attachmentIndex;
        pResolveAttachment->layout
-                = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT_RESOLVE);
+                = imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT_RESOLVE);
        ++pResolveAttachment;

        attachments[attachmentIndex++] = {
@@ -282,8 +278,8 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
            .storeOp = kEnableStore,
            .stencilLoadOp = kDontCare,
            .stencilStoreOp = kDisableStore,
-            .initialLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
-            .finalLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
+            .initialLayout = imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
+            .finalLayout = imgutil::getVkLayout(FINAL_COLOR_ATTACHMENT_LAYOUT),
        };
    }

@@ -292,7 +288,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
        const bool clear = any(config.clear & TargetBufferFlags::DEPTH);
        const bool discardStart = any(config.discardStart & TargetBufferFlags::DEPTH);
        const bool discardEnd = any(config.discardEnd & TargetBufferFlags::DEPTH);
-        depthAttachmentRef.layout = ImgUtil::getVkLayout(config.renderPassDepthLayout);
+        depthAttachmentRef.layout = imgutil::getVkLayout(VulkanLayout::DEPTH_ATTACHMENT);
        depthAttachmentRef.attachment = attachmentIndex;
        attachments[attachmentIndex++] = {
            .format = config.depthFormat,
@@ -301,8 +297,8 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
            .storeOp = discardEnd ? kDisableStore : kEnableStore,
            .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
            .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
-            .initialLayout = ImgUtil::getVkLayout(config.initialDepthLayout),
-            .finalLayout = ImgUtil::getVkLayout(config.finalDepthLayout),
+            .initialLayout = imgutil::getVkLayout(config.initialDepthLayout),
+            .finalLayout = imgutil::getVkLayout(FINAL_DEPTH_ATTACHMENT_LAYOUT),
        };
    }
    renderPassInfo.attachmentCount = attachmentIndex;
@@ -35,24 +35,25 @@ namespace filament::backend {
 //
 class VulkanFboCache {
 public:
+    constexpr static VulkanLayout FINAL_COLOR_ATTACHMENT_LAYOUT = VulkanLayout::COLOR_ATTACHMENT;
+    constexpr static VulkanLayout FINAL_RESOLVE_ATTACHMENT_LAYOUT = VulkanLayout::COLOR_ATTACHMENT;
+    constexpr static VulkanLayout FINAL_DEPTH_ATTACHMENT_LAYOUT = VulkanLayout::DEPTH_ATTACHMENT;
+
    // RenderPassKey is a small POD representing the immutable state that is used to construct
    // a VkRenderPass. It is hashed and used as a lookup key.
-    // TODO: This struct can be reduced in size by using a subset of formats instead of VkFormat
-    //       and removing the "finalDepthLayout" field.
    struct alignas(8) RenderPassKey {
        // For each target, we need to know three image layouts: the layout BEFORE the pass, the
        // layout DURING the pass, and the layout AFTER the pass. Here are the rules:
        // - For depth, we explicitly specify all three layouts.
        // - Color targets have their initial image layout specified with a bitmask.
        // - For each color target, the pre-existing layout is either UNDEFINED (0) or GENERAL (1).
-        // - The render pass and final images layout for color buffers is always GENERAL.
+        // - The render pass and final images layout for color buffers is always
+        //   VulkanLayout::COLOR_ATTACHMENT.
        uint8_t initialColorLayoutMask;

        // Note that if VulkanLayout grows beyond 16, we'd need to up this.
-        VulkanLayout initialDepthLayout : 4;
-        VulkanLayout renderPassDepthLayout : 4;
-        VulkanLayout finalDepthLayout : 4;
-        uint8_t padding0 : 4;
+        VulkanLayout initialDepthLayout : 8;
+        uint8_t padding0;
        uint8_t padding1;

        VkFormat colorFormat[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT]; // 32 bytes
@@ -63,7 +64,7 @@ public:
        uint8_t samples; // 1 byte
        uint8_t needsResolveMask; // 1 byte
        uint8_t subpassMask; // 1 byte
-        bool padding2; // 1 byte
+        uint8_t padding2; // 1 byte
    };
    struct RenderPassVal {
        VkRenderPass handle;
@@ -65,21 +65,6 @@ static constexpr Bitmask fromStageFlags(ShaderStageFlags2 flags, uint8_t binding
    return ret;
 }

-UsageFlags getUsageFlags(uint16_t binding, ShaderStageFlags flags, UsageFlags src) {
-    // NOTE: if you modify this function, you also need to modify getShaderStageFlags.
-    assert_invariant(binding < MAX_SAMPLER_COUNT);
-    if (any(flags & ShaderStageFlags::VERTEX)) {
-        src.set(binding);
-    }
-    if (any(flags & ShaderStageFlags::FRAGMENT)) {
-        src.set(MAX_SAMPLER_COUNT + binding);
-    }
-    // TODO: add support for compute by extending SHADER_MODULE_COUNT and ensuring UsageFlags
-    // has 186 bits (MAX_SAMPLER_COUNT * 3)
-    // assert_invariant(!any(flags & ~(ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT)));
-    return src;
-}
-
 constexpr decltype(VulkanProgram::MAX_SHADER_MODULES) MAX_SHADER_MODULES =
        VulkanProgram::MAX_SHADER_MODULES;

@@ -120,12 +105,89 @@ void addDescriptors(Bitmask mask,
    }
 }

+inline VkDescriptorSetLayout createDescriptorSetLayout(VkDevice device,
+        VkDescriptorSetLayoutCreateInfo const& info) {
+    VkDescriptorSetLayout layout;
+    vkCreateDescriptorSetLayout(device, &info, VKALLOC, &layout);
+    return layout;
+}
+
+inline VkShaderStageFlags getVkStage(backend::ShaderStage stage) {
+    switch(stage) {
+        case backend::ShaderStage::VERTEX:
+            return VK_SHADER_STAGE_VERTEX_BIT;
+        case backend::ShaderStage::FRAGMENT:
+            return VK_SHADER_STAGE_FRAGMENT_BIT;
+        case backend::ShaderStage::COMPUTE:
+            PANIC_POSTCONDITION("Unsupported stage");
+    }
+}
+
 } // anonymous namespace

+
+VulkanDescriptorSetLayout::VulkanDescriptorSetLayout(VkDevice device,
+        VkDescriptorSetLayoutCreateInfo const& info, Bitmask const& bitmask)
+    : VulkanResource(VulkanResourceType::DESCRIPTOR_SET_LAYOUT),
+      mDevice(device),
+      vklayout(createDescriptorSetLayout(device, info)),
+      bitmask(bitmask),
+      bindings(getBindings(bitmask)),
+      count(Count::fromLayoutBitmask(bitmask)) {}
+
+VulkanDescriptorSetLayout::~VulkanDescriptorSetLayout() {
+    vkDestroyDescriptorSetLayout(mDevice, vklayout, VKALLOC);
+}
+
+PushConstantDescription::PushConstantDescription(backend::Program const& program) noexcept {
+    mRangeCount = 0;
+    for (auto stage : { ShaderStage::VERTEX, ShaderStage::FRAGMENT, ShaderStage::COMPUTE }) {
+        auto const& constants = program.getPushConstants(stage);
+        if (constants.empty()) {
+            continue;
+        }
+
+        // We store the type of the constant for type-checking when writing.
+        auto& types = mTypes[(uint8_t) stage];
+        types.reserve(constants.size());
+        std::for_each(constants.cbegin(), constants.cend(), [&types] (Program::PushConstant t) {
+            types.push_back(t.type);
+        });
+
+        mRanges[mRangeCount++] = {
+            .stageFlags = getVkStage(stage),
+            .offset = 0,
+            .size = (uint32_t) constants.size() * ENTRY_SIZE,
+        };
+    }
+}
+
+void PushConstantDescription::write(VulkanCommands* commands, VkPipelineLayout layout,
+        backend::ShaderStage stage, uint8_t index, backend::PushConstantVariant const& value) {
+    VulkanCommandBuffer* cmdbuf = &(commands->get());
+    uint32_t binaryValue = 0;
+    UTILS_UNUSED_IN_RELEASE auto const& types = mTypes[(uint8_t) stage];
+    if (std::holds_alternative<bool>(value)) {
+        assert_invariant(types[index] == ConstantType::BOOL);
+        bool const bval = std::get<bool>(value);
+        binaryValue = static_cast<uint32_t const>(bval ? VK_TRUE : VK_FALSE);
+    } else if (std::holds_alternative<float>(value)) {
+        assert_invariant(types[index] == ConstantType::FLOAT);
+        float const fval = std::get<float>(value);
+        binaryValue = *reinterpret_cast<uint32_t const*>(&fval);
+    } else {
+        assert_invariant(types[index] == ConstantType::INT);
+        int const ival = std::get<int>(value);
+        binaryValue = *reinterpret_cast<uint32_t const*>(&ival);
+    }
+    vkCmdPushConstants(cmdbuf->buffer(), layout, getVkStage(stage), index * ENTRY_SIZE, ENTRY_SIZE,
+            &binaryValue);
+}
+
 VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
    : HwProgram(builder.getName()),
      VulkanResource(VulkanResourceType::PROGRAM),
-      mInfo(new PipelineInfo()),
+      mInfo(new(std::nothrow) PipelineInfo(builder)),
      mDevice(device) {

    constexpr uint8_t UBO_MODULE_OFFSET = (sizeof(UniformBufferBitmask) * 8) / MAX_SHADER_MODULES;
@@ -214,7 +276,6 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
    auto& groupInfo = builder.getSamplerGroupInfo();
    auto& bindingToSamplerIndex = mInfo->bindingToSamplerIndex;
    auto& bindings = mInfo->bindings;
-    auto& usage = mInfo->usage;
    for (uint8_t groupInd = 0; groupInd < Program::SAMPLER_BINDING_COUNT; groupInd++) {
        auto const& group = groupInfo[groupInd];
        auto const& samplers = group.samplers;
@@ -223,7 +284,6 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
            bindingToSamplerIndex[binding] = (groupInd << 8) | (0xff & i);
            assert_invariant(bindings.find(binding) == bindings.end());
            bindings.insert(binding);
-            usage = getUsageFlags(binding, group.stageFlags, usage);

 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
            bindingToName[binding] = samplers[i].name.c_str();
@@ -280,13 +340,13 @@ VulkanRenderTarget::VulkanRenderTarget(VkDevice device, VkPhysicalDevice physica

    // Constrain the sample count according to both kinds of sample count masks obtained from
    // VkPhysicalDeviceProperties. This is consistent with the VulkanTexture constructor.
-    const auto& limits = context.getPhysicalDeviceLimits();
+    auto const& limits = context.getPhysicalDeviceLimits();
    mSamples = samples = reduceSampleCount(samples, limits.framebufferDepthSampleCounts &
            limits.framebufferColorSampleCounts);

    // Create sidecar MSAA textures for color attachments if they don't already exist.
    for (int index = 0; index < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; index++) {
-        const VulkanAttachment& spec = color[index];
+        VulkanAttachment const& spec = color[index];
        VulkanTexture* texture = (VulkanTexture*) spec.texture;
        if (texture && texture->samples == 1) {
            auto msTexture = texture->getSidecar();
@@ -349,19 +409,19 @@ VkExtent2D VulkanRenderTarget::getExtent() const {
    return {width, height};
 }

-VulkanAttachment VulkanRenderTarget::getColor(int target) const {
+VulkanAttachment& VulkanRenderTarget::getColor(int target) {
    return mColor[target];
 }

-VulkanAttachment VulkanRenderTarget::getMsaaColor(int target) const {
+VulkanAttachment& VulkanRenderTarget::getMsaaColor(int target) {
    return mMsaaAttachments[target];
 }

-VulkanAttachment VulkanRenderTarget::getDepth() const {
+VulkanAttachment& VulkanRenderTarget::getDepth() {
    return mDepth;
 }

-VulkanAttachment VulkanRenderTarget::getMsaaDepth() const {
+VulkanAttachment& VulkanRenderTarget::getMsaaDepth() {
    return mMsaaDepthAttachment;
 }

@@ -26,10 +26,10 @@
 #include "VulkanTexture.h"
 #include "VulkanUtility.h"

-#include "private/backend/SamplerGroup.h"
-#include "utils/FixedCapacityVector.h"
-#include "vulkan/vulkan_core.h"
+#include <private/backend/SamplerGroup.h>
+#include <backend/Program.h>

+#include <utils/FixedCapacityVector.h>
 #include <utils/Mutex.h>
 #include <utils/StructureOfArrays.h>

@@ -99,13 +99,12 @@ struct VulkanDescriptorSetLayout : public VulkanResource {

    static_assert(sizeof(Bitmask) % 8 == 0);

-    explicit VulkanDescriptorSetLayout(VkDescriptorSetLayout layout, Bitmask const& bitmask)
-        : VulkanResource(VulkanResourceType::DESCRIPTOR_SET_LAYOUT),
-          vklayout(layout),
-          bitmask(bitmask),
-          bindings(getBindings(bitmask)),
-          count(Count::fromLayoutBitmask(bitmask)) {}
+    explicit VulkanDescriptorSetLayout(VkDevice device, VkDescriptorSetLayoutCreateInfo const& info,
+            Bitmask const& bitmask);

+    ~VulkanDescriptorSetLayout();
+
+    VkDevice const mDevice;
    VkDescriptorSetLayout const vklayout;
    Bitmask const bitmask;

@@ -181,6 +180,28 @@ private:
 using VulkanDescriptorSetList = std::array<Handle<VulkanDescriptorSet>,
        VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;

+using PushConstantNameArray = utils::FixedCapacityVector<char const*>;
+using PushConstantNameByStage = std::array<PushConstantNameArray, Program::SHADER_TYPE_COUNT>;
+
+struct PushConstantDescription {
+
+    explicit PushConstantDescription(backend::Program const& program) noexcept;
+
+    VkPushConstantRange const* getVkRanges() const noexcept { return mRanges; }
+
+    uint32_t getVkRangeCount() const noexcept { return mRangeCount; }
+
+    void write(VulkanCommands* commands, VkPipelineLayout layout, backend::ShaderStage stage,
+            uint8_t index, backend::PushConstantVariant const& value);
+
+private:
+    static constexpr uint32_t ENTRY_SIZE = sizeof(uint32_t);
+
+    utils::FixedCapacityVector<backend::ConstantType> mTypes[Program::SHADER_TYPE_COUNT];
+    VkPushConstantRange mRanges[Program::SHADER_TYPE_COUNT];
+    uint32_t mRangeCount;
+};
+
 struct VulkanProgram : public HwProgram, VulkanResource {

    using BindingList = CappedArray<uint16_t, MAX_SAMPLER_COUNT>;
@@ -199,10 +220,6 @@ struct VulkanProgram : public HwProgram, VulkanResource {
        return mInfo->bindingToSamplerIndex;
    }

-    inline UsageFlags getUsage() const {
-        return mInfo->usage;
-    }
-
    // Get a list of the sampler binding indices so that we don't have to loop through all possible
    // samplers.
    inline BindingList const& getBindings() const { return mInfo->bindings; }
@@ -217,6 +234,19 @@ struct VulkanProgram : public HwProgram, VulkanResource {
            VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;
    inline LayoutDescriptionList const& getLayoutDescriptionList() const { return mInfo->layouts; }

+    inline uint32_t getPushConstantRangeCount() const {
+        return mInfo->pushConstantDescription.getVkRangeCount();
+    }
+
+    inline VkPushConstantRange const* getPushConstantRanges() const {
+        return mInfo->pushConstantDescription.getVkRanges();
+    }
+
+    inline void writePushConstant(VulkanCommands* commands, VkPipelineLayout layout,
+            backend::ShaderStage stage, uint8_t index, backend::PushConstantVariant const& value) {
+        mInfo->pushConstantDescription.write(commands, layout, stage, index, value);
+    }
+
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
    inline utils::FixedCapacityVector<std::string> const& getBindingToName() const {
        return mInfo->bindingToName;
@@ -229,17 +259,14 @@ struct VulkanProgram : public HwProgram, VulkanResource {

 private:
    struct PipelineInfo {
-        PipelineInfo()
-            : bindingToSamplerIndex(MAX_SAMPLER_COUNT, 0xffff)
+        explicit PipelineInfo(backend::Program const& program) noexcept
+            : bindingToSamplerIndex(MAX_SAMPLER_COUNT, 0xffff),
+              pushConstantDescription(program)
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
            , bindingToName(MAX_SAMPLER_COUNT, "")
 #endif
            {}

-        // This bitset maps to each of the sampler in the sampler groups associated with this
-        // program, and whether each sampler is used in which shader (i.e. vert, frag, compute).
-        UsageFlags usage;
-
        BindingList bindings;

        // We store the samplerGroupIndex as the top 8-bit and the index within each group as the lower 8-bit.
@@ -250,6 +277,8 @@ private:
        // descset::DescriptorSetLayout layout;
        LayoutDescriptionList layouts;

+        PushConstantDescription pushConstantDescription;
+
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
        // We store the sampler name mapped from binding index (only for debug purposes).
        utils::FixedCapacityVector<std::string> bindingToName;
@@ -283,10 +312,11 @@ struct VulkanRenderTarget : private HwRenderTarget, VulkanResource {
    void transformClientRectToPlatform(VkRect2D* bounds) const;
    void transformClientRectToPlatform(VkViewport* bounds) const;
    VkExtent2D getExtent() const;
-    VulkanAttachment getColor(int target) const;
-    VulkanAttachment getMsaaColor(int target) const;
-    VulkanAttachment getDepth() const;
-    VulkanAttachment getMsaaDepth() const;
+    // We return references in the following methods to avoid a copy.
+    VulkanAttachment& getColor(int target);
+    VulkanAttachment& getMsaaColor(int target);
+    VulkanAttachment& getDepth();
+    VulkanAttachment& getMsaaDepth();
    uint8_t getColorTargetCount(const VulkanRenderPass& pass) const;
    uint8_t getSamples() const { return mSamples; }
    bool hasDepth() const { return mDepth.texture; }
@@ -26,38 +26,10 @@

 using namespace bluevk;

-namespace filament::backend {
+namespace filament::backend::imgutil {

 namespace {

-inline VkImageLayout getVkImageLayout(VulkanLayout layout) {
-    switch (layout) {
-        case VulkanLayout::UNDEFINED:
-            return VK_IMAGE_LAYOUT_UNDEFINED;
-        case VulkanLayout::READ_WRITE:
-            return VK_IMAGE_LAYOUT_GENERAL;
-        case VulkanLayout::READ_ONLY:
-            return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-        case VulkanLayout::TRANSFER_SRC:
-            return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-        case VulkanLayout::TRANSFER_DST:
-            return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-        case VulkanLayout::DEPTH_ATTACHMENT:
-            return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-        case VulkanLayout::DEPTH_SAMPLER:
-            return VK_IMAGE_LAYOUT_GENERAL;
-        case VulkanLayout::PRESENT:
-            return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
-        // Filament sometimes samples from one miplevel while writing to another level in the same
-        // texture (e.g. bloom does this). Moreover we'd like to avoid lots of expensive layout
-        // transitions. So, keep it simple and use GENERAL for all color-attachable textures.
-        case VulkanLayout::COLOR_ATTACHMENT:
-            return VK_IMAGE_LAYOUT_GENERAL;
-        case VulkanLayout::COLOR_ATTACHMENT_RESOLVE:
-            return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-    }
-}
-
 inline std::tuple<VkAccessFlags, VkAccessFlags, VkPipelineStageFlags, VkPipelineStageFlags,
        VkImageLayout, VkImageLayout>
 getVkTransition(const VulkanLayoutTransition& transition) {
@@ -70,11 +42,11 @@ getVkTransition(const VulkanLayoutTransition& transition) {
            srcStage = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
            break;
        case VulkanLayout::COLOR_ATTACHMENT:
-            srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT
-                            | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
-                            | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-            srcStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
-                       | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+            srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
+                            VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
+                            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+            srcStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+                       VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
            break;
        case VulkanLayout::READ_WRITE:
            srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
@@ -154,27 +126,12 @@ getVkTransition(const VulkanLayoutTransition& transition) {
    }

    return std::make_tuple(srcAccessMask, dstAccessMask, srcStage, dstStage,
-            getVkImageLayout(transition.oldLayout), getVkImageLayout(transition.newLayout));
+            getVkLayout(transition.oldLayout), getVkLayout(transition.newLayout));
 }

 }// anonymous namespace

-VkImageViewType VulkanImageUtility::getViewType(SamplerType target) {
-    switch (target) {
-        case SamplerType::SAMPLER_CUBEMAP:
-            return VK_IMAGE_VIEW_TYPE_CUBE;
-        case SamplerType::SAMPLER_2D_ARRAY:
-            return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
-        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
-            return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
-        case SamplerType::SAMPLER_3D:
-            return VK_IMAGE_VIEW_TYPE_3D;
-        default:
-            return VK_IMAGE_VIEW_TYPE_2D;
-    }
-}
-
-void VulkanImageUtility::transitionLayout(VkCommandBuffer cmdbuffer,
+void transitionLayout(VkCommandBuffer cmdbuffer,
        VulkanLayoutTransition transition) {
    if (transition.oldLayout == transition.newLayout) {
        return;
@@ -197,10 +154,6 @@ void VulkanImageUtility::transitionLayout(VkCommandBuffer cmdbuffer,
    vkCmdPipelineBarrier(cmdbuffer, srcStage, dstStage, 0, 0, nullptr, 0, nullptr, 1, &barrier);
 }

-VkImageLayout VulkanImageUtility::getVkLayout(VulkanLayout layout) {
-    return getVkImageLayout(layout);
-}
-
 }// namespace filament::backend

 bool operator<(const VkImageSubresourceRange& a, const VkImageSubresourceRange& b) {
@@ -217,12 +170,12 @@ bool operator<(const VkImageSubresourceRange& a, const VkImageSubresourceRange&
    return false;
 }

-#if FVK_ENABLED(FVK_DEBUG_LAYOUT_TRANSITION | FVK_DEBUG_TEXTURE)
+#if FVK_ENABLED(FVK_DEBUG_LAYOUT_TRANSITION) || FVK_ENABLED(FVK_DEBUG_TEXTURE)
 #define CASE(VALUE)                                                                                \
    case filament::backend::VulkanLayout::VALUE: {                                                 \
        out << #VALUE;                                                                             \
        out << " ["                                                                                \
-            << filament::backend::VulkanImageUtility::getVkLayout(                                 \
+            << filament::backend::imgutil::getVkLayout(                                            \
                       filament::backend::VulkanLayout::VALUE)                                     \
            << "]";                                                                                \
        break;                                                                                     \
@@ -59,44 +59,85 @@ struct VulkanLayoutTransition {
    VkImageSubresourceRange subresources;
 };

-class VulkanImageUtility {
-public:
-    static VkImageViewType getViewType(SamplerType target);
+namespace imgutil {

-    inline static VulkanLayout getDefaultLayout(TextureUsage usage) {
-        if (any(usage & TextureUsage::DEPTH_ATTACHMENT)) {
-            if (any(usage & TextureUsage::SAMPLEABLE)) {
-                return VulkanLayout::DEPTH_SAMPLER;
-            } else {
-                return VulkanLayout::DEPTH_ATTACHMENT;
-            }
-        }
+inline VkImageViewType getViewType(SamplerType target) {
+    switch (target) {
+        case SamplerType::SAMPLER_CUBEMAP:
+            return VK_IMAGE_VIEW_TYPE_CUBE;
+        case SamplerType::SAMPLER_2D_ARRAY:
+            return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
+            return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
+        case SamplerType::SAMPLER_3D:
+            return VK_IMAGE_VIEW_TYPE_3D;
+        default:
+            return VK_IMAGE_VIEW_TYPE_2D;
+    }
+}

-        if (any(usage & TextureUsage::COLOR_ATTACHMENT)) {
-            return VulkanLayout::COLOR_ATTACHMENT;
+inline VulkanLayout getDefaultLayout(TextureUsage usage) {
+    if (any(usage & TextureUsage::DEPTH_ATTACHMENT)) {
+        if (any(usage & TextureUsage::SAMPLEABLE)) {
+            return VulkanLayout::DEPTH_SAMPLER;
+        } else {
+            return VulkanLayout::DEPTH_ATTACHMENT;
        }
-        // Finally, the layout for an immutable texture is optimal read-only.        
-        return VulkanLayout::READ_ONLY;
    }

-    inline static VulkanLayout getDefaultLayout(VkImageUsageFlags vkusage) {
-        TextureUsage usage {};
-        if (vkusage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
-            usage = usage | TextureUsage::DEPTH_ATTACHMENT;
-        }
-        if (vkusage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
-            usage = usage | TextureUsage::COLOR_ATTACHMENT;
-        }
-        if (vkusage & VK_IMAGE_USAGE_SAMPLED_BIT) {
-            usage = usage | TextureUsage::SAMPLEABLE;
-        }
-        return getDefaultLayout(usage);
+    if (any(usage & TextureUsage::COLOR_ATTACHMENT)) {
+        return VulkanLayout::COLOR_ATTACHMENT;
    }
+    // Finally, the layout for an immutable texture is optimal read-only.
+    return VulkanLayout::READ_ONLY;
+}

-    static VkImageLayout getVkLayout(VulkanLayout layout);
-    
-    static void transitionLayout(VkCommandBuffer cmdbuffer, VulkanLayoutTransition transition);
-};
+inline VulkanLayout getDefaultLayout(VkImageUsageFlags vkusage) {
+    TextureUsage usage{};
+    if (vkusage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
+        usage = usage | TextureUsage::DEPTH_ATTACHMENT;
+    }
+    if (vkusage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
+        usage = usage | TextureUsage::COLOR_ATTACHMENT;
+    }
+    if (vkusage & VK_IMAGE_USAGE_SAMPLED_BIT) {
+        usage = usage | TextureUsage::SAMPLEABLE;
+    }
+    return getDefaultLayout(usage);
+}
+
+constexpr inline VkImageLayout getVkLayout(VulkanLayout layout) {
+    switch (layout) {
+        case VulkanLayout::UNDEFINED:
+            return VK_IMAGE_LAYOUT_UNDEFINED;
+        case VulkanLayout::READ_WRITE:
+            return VK_IMAGE_LAYOUT_GENERAL;
+        case VulkanLayout::READ_ONLY:
+            return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+        case VulkanLayout::TRANSFER_SRC:
+            return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+        case VulkanLayout::TRANSFER_DST:
+            return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+        case VulkanLayout::DEPTH_ATTACHMENT:
+            return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+        case VulkanLayout::DEPTH_SAMPLER:
+            return VK_IMAGE_LAYOUT_GENERAL;
+        case VulkanLayout::PRESENT:
+            return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+        // Filament sometimes samples from one miplevel while writing to another level in the
+        // same texture (e.g. bloom does this). Moreover we'd like to avoid lots of expensive
+        // layout transitions. So, keep it simple and use GENERAL for all color-attachable
+        // textures.
+        case VulkanLayout::COLOR_ATTACHMENT:
+            return VK_IMAGE_LAYOUT_GENERAL;
+        case VulkanLayout::COLOR_ATTACHMENT_RESOLVE:
+            return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+    }
+}
+
+void transitionLayout(VkCommandBuffer cmdbuffer, VulkanLayoutTransition transition);
+
+} // namespace imgutil

 } // namespace filament::backend

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

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

 #include <utils/Log.h>
 #include <utils/Panic.h>
@@ -34,46 +35,9 @@ using namespace bluevk;

 namespace filament::backend {

-static VkShaderStageFlags getShaderStageFlags(UsageFlags key, uint16_t binding) {
-    // NOTE: if you modify this function, you also need to modify getUsageFlags.
-    assert_invariant(binding < MAX_SAMPLER_COUNT);
-    VkShaderStageFlags flags = 0;
-    if (key.test(binding)) {
-        flags |= VK_SHADER_STAGE_VERTEX_BIT;
-    }
-    if (key.test(MAX_SAMPLER_COUNT + binding)) {
-        flags |= VK_SHADER_STAGE_FRAGMENT_BIT;
-    }
-    return flags;
-}
-
-UsageFlags VulkanPipelineCache::disableUsageFlags(uint16_t binding, UsageFlags src) {
-    src.unset(binding);
-    src.unset(MAX_SAMPLER_COUNT + binding);
-    return src;
-}
-
-VulkanPipelineCache::VulkanPipelineCache(VulkanResourceAllocator* allocator)
-    : mResourceAllocator(allocator),
-      mPipelineBoundResources(allocator) {
-    mDummyBufferWriteInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    mDummyBufferWriteInfo.pNext = nullptr;
-    mDummyBufferWriteInfo.dstArrayElement = 0;
-    mDummyBufferWriteInfo.descriptorCount = 1;
-    mDummyBufferWriteInfo.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-    mDummyBufferWriteInfo.pImageInfo = nullptr;
-    mDummyBufferWriteInfo.pBufferInfo = &mDummyBufferInfo;
-    mDummyBufferWriteInfo.pTexelBufferView = nullptr;
-
-    mDummyTargetInfo.imageLayout = VulkanImageUtility::getVkLayout(VulkanLayout::READ_ONLY);
-    mDummyTargetWriteInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    mDummyTargetWriteInfo.pNext = nullptr;
-    mDummyTargetWriteInfo.dstArrayElement = 0;
-    mDummyTargetWriteInfo.descriptorCount = 1;
-    mDummyTargetWriteInfo.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
-    mDummyTargetWriteInfo.pImageInfo = &mDummyTargetInfo;
-    mDummyTargetWriteInfo.pBufferInfo = nullptr;
-    mDummyTargetWriteInfo.pTexelBufferView = nullptr;
+VulkanPipelineCache::VulkanPipelineCache(VkDevice device, VmaAllocator allocator)
+    : mDevice(device),
+      mAllocator(allocator) {
 }

 VulkanPipelineCache::~VulkanPipelineCache() {
@@ -81,244 +45,47 @@ VulkanPipelineCache::~VulkanPipelineCache() {
    // be explicit about teardown order of various components.
 }

-void VulkanPipelineCache::setDevice(VkDevice device, VmaAllocator allocator) {
-    assert_invariant(mDevice == VK_NULL_HANDLE);
-    mDevice = device;
-    mAllocator = allocator;
-    mDescriptorPool = createDescriptorPool(mDescriptorPoolSize);
-
-    // Formulate some dummy objects and dummy descriptor info used only for clearing out unused
-    // bindings. This is especially crucial after a texture has been destroyed. Since core Vulkan
-    // does not allow specifying VK_NULL_HANDLE without the robustness2 extension, we would need to
-    // change the pipeline layout more frequently if we wanted to get rid of these dummy objects.
-
-    VkBufferCreateInfo bufferInfo {
-        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-        .size = 16,
-        .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
-    };
-    VmaAllocationCreateInfo allocInfo { .usage = VMA_MEMORY_USAGE_GPU_ONLY };
-    vmaCreateBuffer(mAllocator, &bufferInfo, &allocInfo, &mDummyBuffer, &mDummyMemory, nullptr);
-
-    mDummyBufferInfo.buffer = mDummyBuffer;
-    mDummyBufferInfo.range = bufferInfo.size;
+void VulkanPipelineCache::bindLayout(VkPipelineLayout layout) noexcept {
+    mPipelineRequirements.layout = layout;
 }

-bool VulkanPipelineCache::bindDescriptors(VkCommandBuffer cmdbuffer) noexcept {
-    DescriptorMap::iterator descriptorIter = mDescriptorSets.find(mDescriptorRequirements);
-
-    // Check if the required descriptors are already bound. If so, there's no need to do anything.
-    if (DescEqual equals; UTILS_LIKELY(equals(mBoundDescriptor, mDescriptorRequirements))) {
-
-        // If the pipeline state during an app's first draw call happens to match the default state
-        // vector of the cache, then the cache is uninitialized and we should not return early.
-        if (UTILS_LIKELY(!mDescriptorSets.empty())) {
-
-            // Since the descriptors are already bound, they should be found in the cache.
-            assert_invariant(descriptorIter != mDescriptorSets.end());
-
-            // Update the LRU "time stamp" (really a count of cmd buf submissions) before returning.
-            descriptorIter.value().lastUsed = mCurrentTime;
-            return true;
-        }
-    }
-
+VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::getOrCreatePipeline() noexcept {
    // If a cached object exists, re-use it, otherwise create a new one.
-    DescriptorCacheEntry* cacheEntry = UTILS_LIKELY(descriptorIter != mDescriptorSets.end()) ?
-            &descriptorIter.value() : createDescriptorSets();
-
-    // If a descriptor set overflow occurred, allow higher levels to handle it gracefully.
-    assert_invariant(cacheEntry != nullptr);
-    if (UTILS_UNLIKELY(cacheEntry == nullptr)) {
-        return false;
+    if (PipelineMap::iterator pipelineIter = mPipelines.find(mPipelineRequirements);
+            pipelineIter != mPipelines.end()) {
+        auto& pipeline = pipelineIter.value();
+        pipeline.lastUsed = mCurrentTime;
+        return &pipeline;
    }
-
-    cacheEntry->lastUsed = mCurrentTime;
-    mBoundDescriptor = mDescriptorRequirements;
-    // This passes the currently "bound" uniform buffer objects to pipeline that will be used in the
-    // draw call.
-    auto resourceEntry = mDescriptorResources.find(cacheEntry->id);
-    if (resourceEntry == mDescriptorResources.end()) {
-        mDescriptorResources[cacheEntry->id]
-                = std::make_unique<VulkanAcquireOnlyResourceManager>(mResourceAllocator);
-        resourceEntry = mDescriptorResources.find(cacheEntry->id);
-    }
-    resourceEntry->second->acquireAll(&mPipelineBoundResources);
-
-    vkCmdBindDescriptorSets(cmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
-            getOrCreatePipelineLayout()->handle, 0, VulkanPipelineCache::DESCRIPTOR_TYPE_COUNT,
-            cacheEntry->handles.data(), 0, nullptr);
-
-    return true;
+    auto ret = createPipeline();
+    ret->lastUsed = mCurrentTime;
+    return ret;
 }

-bool VulkanPipelineCache::bindPipeline(VulkanCommandBuffer* commands) noexcept {
+void VulkanPipelineCache::bindPipeline(VulkanCommandBuffer* commands) {
    VkCommandBuffer const cmdbuffer = commands->buffer();

-    PipelineMap::iterator pipelineIter = mPipelines.find(mPipelineRequirements);
-
+    PipelineCacheEntry* cacheEntry = getOrCreatePipeline();
    // Check if the required pipeline is already bound.
-    if (PipelineEqual equals; UTILS_LIKELY(equals(mBoundPipeline, mPipelineRequirements))) {
-        assert_invariant(pipelineIter != mPipelines.end());
-        pipelineIter.value().lastUsed = mCurrentTime;
-        return true;
+    if (cacheEntry->handle == commands->pipeline()) {
+        return;
    }

-    // If a cached object exists, re-use it, otherwise create a new one.
-    PipelineCacheEntry* cacheEntry = UTILS_LIKELY(pipelineIter != mPipelines.end()) ?
-            &pipelineIter.value() : createPipeline();
-
    // If an error occurred, allow higher levels to handle it gracefully.
-    assert_invariant(cacheEntry != nullptr);
-    if (UTILS_UNLIKELY(cacheEntry == nullptr)) {
-        return false;
-    }
-
-    cacheEntry->lastUsed = mCurrentTime;
-    getOrCreatePipelineLayout()->lastUsed = mCurrentTime;
+    assert_invariant(cacheEntry != nullptr && "Failed to create/find pipeline");

    mBoundPipeline = mPipelineRequirements;
-
    vkCmdBindPipeline(cmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, cacheEntry->handle);
-    return true;
+    commands->setPipeline(cacheEntry->handle);
 }

 void VulkanPipelineCache::bindScissor(VkCommandBuffer cmdbuffer, VkRect2D scissor) noexcept {
-    if (UTILS_UNLIKELY(!equivalent(mCurrentScissor, scissor))) {
-        mCurrentScissor = scissor;
-        vkCmdSetScissor(cmdbuffer, 0, 1, &scissor);
-    }
-}
-
-VulkanPipelineCache::DescriptorCacheEntry* VulkanPipelineCache::createDescriptorSets() noexcept {
-    PipelineLayoutCacheEntry* layoutCacheEntry = getOrCreatePipelineLayout();
-
-    DescriptorCacheEntry descriptorCacheEntry = {
-        .pipelineLayout = mPipelineRequirements.layout,
-        .id = mDescriptorCacheEntryCount++,
-    };
-
-    // Each of the arenas for this particular layout are guaranteed to have the same size. Check
-    // the first arena to see if any descriptor sets are available that can be re-claimed. If not,
-    // create brand new ones (one for each type). They will be added to the arena later, after they
-    // are no longer used. This occurs during the cleanup phase during command buffer submission.
-    auto& descriptorSetArenas = layoutCacheEntry->descriptorSetArenas;
-    if (descriptorSetArenas[0].empty()) {
-
-        // If allocating a new descriptor set from the pool would cause it to overflow, then
-        // recreate the pool. The number of descriptor sets that have already been allocated from
-        // the pool is the sum of the "active" descriptor sets (mDescriptorSets) and the "dormant"
-        // descriptor sets (mDescriptorArenasCount).
-        //
-        // NOTE: technically both sides of the inequality below should be multiplied by
-        // DESCRIPTOR_TYPE_COUNT to get the true number of descriptor sets.
-        if (mDescriptorSets.size() + mDescriptorArenasCount + 1 > mDescriptorPoolSize) {
-            growDescriptorPool();
-        }
-
-        VkDescriptorSetAllocateInfo allocInfo = {};
-        allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
-        allocInfo.descriptorPool = mDescriptorPool;
-        allocInfo.descriptorSetCount = DESCRIPTOR_TYPE_COUNT;
-        allocInfo.pSetLayouts = layoutCacheEntry->descriptorSetLayouts.data();
-        VkResult error = vkAllocateDescriptorSets(mDevice, &allocInfo,
-                descriptorCacheEntry.handles.data());
-        assert_invariant(error == VK_SUCCESS);
-        if (error != VK_SUCCESS) {
-            return nullptr;
-        }
-    } else {
-        for (uint32_t i = 0; i < DESCRIPTOR_TYPE_COUNT; ++i) {
-            descriptorCacheEntry.handles[i] = descriptorSetArenas[i].back();
-            descriptorSetArenas[i].pop_back();
-        }
-        assert_invariant(mDescriptorArenasCount > 0);
-        mDescriptorArenasCount--;
-    }
-
-    // Rewrite every binding in the new descriptor sets.
-    VkDescriptorBufferInfo descriptorBuffers[UBUFFER_BINDING_COUNT];
-    VkDescriptorImageInfo descriptorSamplers[SAMPLER_BINDING_COUNT];
-    VkDescriptorImageInfo descriptorInputAttachments[INPUT_ATTACHMENT_COUNT];
-    VkWriteDescriptorSet descriptorWrites[UBUFFER_BINDING_COUNT + SAMPLER_BINDING_COUNT +
-            INPUT_ATTACHMENT_COUNT];
-    uint32_t nwrites = 0;
-    VkWriteDescriptorSet* writes = descriptorWrites;
-    nwrites = 0;
-    for (uint32_t binding = 0; binding < UBUFFER_BINDING_COUNT; binding++) {
-        VkWriteDescriptorSet& writeInfo = writes[nwrites++];
-        if (mDescriptorRequirements.uniformBuffers[binding]) {
-            VkDescriptorBufferInfo& bufferInfo = descriptorBuffers[binding];
-            bufferInfo.buffer = mDescriptorRequirements.uniformBuffers[binding];
-            bufferInfo.offset = mDescriptorRequirements.uniformBufferOffsets[binding];
-            bufferInfo.range = mDescriptorRequirements.uniformBufferSizes[binding];
-
-            // We store size with 32 bits, so our "WHOLE" sentinel is different from Vk.
-            if (bufferInfo.range == WHOLE_SIZE) {
-                bufferInfo.range = VK_WHOLE_SIZE;
-            }
-
-            writeInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-            writeInfo.pNext = nullptr;
-            writeInfo.dstArrayElement = 0;
-            writeInfo.descriptorCount = 1;
-            writeInfo.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-            writeInfo.pImageInfo = nullptr;
-            writeInfo.pBufferInfo = &bufferInfo;
-            writeInfo.pTexelBufferView = nullptr;
-        } else {
-            writeInfo = mDummyBufferWriteInfo;
-            assert_invariant(mDummyBufferWriteInfo.pBufferInfo->buffer);
-        }
-        assert_invariant(writeInfo.pBufferInfo->buffer);
-        writeInfo.dstSet = descriptorCacheEntry.handles[0];
-        writeInfo.dstBinding = binding;
-    }
-    for (uint32_t binding = 0; binding < SAMPLER_BINDING_COUNT; binding++) {
-        if (mDescriptorRequirements.samplers[binding].sampler) {
-            VkWriteDescriptorSet& writeInfo = writes[nwrites++];
-            VkDescriptorImageInfo& imageInfo = descriptorSamplers[binding];
-            imageInfo = mDescriptorRequirements.samplers[binding];
-            writeInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-            writeInfo.pNext = nullptr;
-            writeInfo.dstArrayElement = 0;
-            writeInfo.descriptorCount = 1;
-            writeInfo.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-            writeInfo.pImageInfo = &imageInfo;
-            writeInfo.pBufferInfo = nullptr;
-            writeInfo.pTexelBufferView = nullptr;
-            writeInfo.dstSet = descriptorCacheEntry.handles[1];
-            writeInfo.dstBinding = binding;
-        }
-    }
-    for (uint32_t binding = 0; binding < INPUT_ATTACHMENT_COUNT; binding++) {
-        if (mDescriptorRequirements.inputAttachments[binding].imageView) {
-            VkWriteDescriptorSet& writeInfo = writes[nwrites++];
-            VkDescriptorImageInfo& imageInfo = descriptorInputAttachments[binding];
-            imageInfo = mDescriptorRequirements.inputAttachments[binding];
-            writeInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-            writeInfo.pNext = nullptr;
-            writeInfo.dstArrayElement = 0;
-            writeInfo.descriptorCount = 1;
-            writeInfo.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
-            writeInfo.pImageInfo = &imageInfo;
-            writeInfo.pBufferInfo = nullptr;
-            writeInfo.pTexelBufferView = nullptr;
-            writeInfo.dstSet = descriptorCacheEntry.handles[2];
-            writeInfo.dstBinding = binding;
-        }
-    }
-
-    vkUpdateDescriptorSets(mDevice, nwrites, writes, 0, nullptr);
-
-    return &mDescriptorSets.emplace(mDescriptorRequirements, descriptorCacheEntry).first.value();
+    vkCmdSetScissor(cmdbuffer, 0, 1, &scissor);
 }

 VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() noexcept {
    assert_invariant(mPipelineRequirements.shaders[0] && "Vertex shader is not bound.");
-
-    PipelineLayoutCacheEntry* layout = getOrCreatePipelineLayout();
-    assert_invariant(layout);
+    assert_invariant(mPipelineRequirements.layout && "No pipeline layout specified");

    VkPipelineShaderStageCreateInfo shaderStages[SHADER_MODULE_COUNT];
    shaderStages[0] = VkPipelineShaderStageCreateInfo{};
@@ -387,7 +154,7 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n

    VkGraphicsPipelineCreateInfo pipelineCreateInfo = {};
    pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
-    pipelineCreateInfo.layout = layout->handle;
+    pipelineCreateInfo.layout = mPipelineRequirements.layout;
    pipelineCreateInfo.renderPass = mPipelineRequirements.renderPass;
    pipelineCreateInfo.subpass = mPipelineRequirements.subpassIndex;
    pipelineCreateInfo.stageCount = hasFragmentShader ? SHADER_MODULE_COUNT : 1;
@@ -481,68 +248,6 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
    return &mPipelines.emplace(mPipelineRequirements, cacheEntry).first.value();
 }

-VulkanPipelineCache::PipelineLayoutCacheEntry* VulkanPipelineCache::getOrCreatePipelineLayout() noexcept {
-    auto iter = mPipelineLayouts.find(mPipelineRequirements.layout);
-    if (UTILS_LIKELY(iter != mPipelineLayouts.end())) {
-        return &iter.value();
-    }
-
-    PipelineLayoutCacheEntry cacheEntry = {};
-
-    VkDescriptorSetLayoutBinding binding = {};
-    binding.descriptorCount = 1; // NOTE: We never use arrays-of-blocks.
-    binding.stageFlags = VK_SHADER_STAGE_ALL_GRAPHICS; // NOTE: This is potentially non-optimal.
-
-    // First create the descriptor set layout for UBO's.
-    VkDescriptorSetLayoutBinding ubindings[UBUFFER_BINDING_COUNT];
-    binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-    for (uint32_t i = 0; i < UBUFFER_BINDING_COUNT; i++) {
-        binding.binding = i;
-        ubindings[i] = binding;
-    }
-    VkDescriptorSetLayoutCreateInfo dlinfo = {};
-    dlinfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
-    dlinfo.bindingCount = UBUFFER_BINDING_COUNT;
-    dlinfo.pBindings = ubindings;
-    vkCreateDescriptorSetLayout(mDevice, &dlinfo, VKALLOC, &cacheEntry.descriptorSetLayouts[0]);
-
-    // Next create the descriptor set layout for samplers.
-    VkDescriptorSetLayoutBinding sbindings[SAMPLER_BINDING_COUNT];
-    binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-    for (uint32_t i = 0; i < SAMPLER_BINDING_COUNT; i++) {
-        binding.stageFlags = getShaderStageFlags(mPipelineRequirements.layout, i);
-        binding.binding = i;
-        sbindings[i] = binding;
-    }
-    dlinfo.bindingCount = SAMPLER_BINDING_COUNT;
-    dlinfo.pBindings = sbindings;
-    vkCreateDescriptorSetLayout(mDevice, &dlinfo, VKALLOC, &cacheEntry.descriptorSetLayouts[1]);
-
-    // Next create the descriptor set layout for input attachments.
-    VkDescriptorSetLayoutBinding tbindings[INPUT_ATTACHMENT_COUNT];
-    binding.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
-    binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
-    for (uint32_t i = 0; i < INPUT_ATTACHMENT_COUNT; i++) {
-        binding.binding = i;
-        tbindings[i] = binding;
-    }
-    dlinfo.bindingCount = INPUT_ATTACHMENT_COUNT;
-    dlinfo.pBindings = tbindings;
-    vkCreateDescriptorSetLayout(mDevice, &dlinfo, VKALLOC, &cacheEntry.descriptorSetLayouts[2]);
-
-    // Create VkPipelineLayout based on how to resources are bounded.
-    VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {};
-    pPipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
-    pPipelineLayoutCreateInfo.setLayoutCount = cacheEntry.descriptorSetLayouts.size();
-    pPipelineLayoutCreateInfo.pSetLayouts = cacheEntry.descriptorSetLayouts.data();
-    VkResult result = vkCreatePipelineLayout(mDevice, &pPipelineLayoutCreateInfo, VKALLOC,
-            &cacheEntry.handle);
-    if (UTILS_UNLIKELY(result != VK_SUCCESS)) {
-        return nullptr;
-    }
-    return &mPipelineLayouts.emplace(mPipelineRequirements.layout, cacheEntry).first.value();
-}
-
 void VulkanPipelineCache::bindProgram(VulkanProgram* program) noexcept {
    mPipelineRequirements.shaders[0] = program->getVertexShader();
    mPipelineRequirements.shaders[1] = program->getFragmentShader();
@@ -583,97 +288,15 @@ void VulkanPipelineCache::bindVertexArray(VkVertexInputAttributeDescription cons
    }
 }

-VulkanPipelineCache::UniformBufferBinding VulkanPipelineCache::getUniformBufferBinding(
-        uint32_t bindingIndex) const noexcept {
-    auto& key = mDescriptorRequirements;
-    return {
-        key.uniformBuffers[bindingIndex],
-        key.uniformBufferOffsets[bindingIndex],
-        key.uniformBufferSizes[bindingIndex],
-    };
-}
-
-void VulkanPipelineCache::unbindUniformBuffer(VkBuffer uniformBuffer) noexcept {
-    auto& key = mDescriptorRequirements;
-    for (uint32_t bindingIndex = 0u; bindingIndex < UBUFFER_BINDING_COUNT; ++bindingIndex) {
-        if (key.uniformBuffers[bindingIndex] == uniformBuffer) {
-            key.uniformBuffers[bindingIndex] = {};
-            key.uniformBufferSizes[bindingIndex] = {};
-            key.uniformBufferOffsets[bindingIndex] = {};
-        }
-    }
-}
-
-void VulkanPipelineCache::unbindImageView(VkImageView imageView) noexcept {
-    for (auto& sampler : mDescriptorRequirements.samplers) {
-        if (sampler.imageView == imageView) {
-            sampler = {};
-        }
-    }
-    for (auto& target : mDescriptorRequirements.inputAttachments) {
-        if (target.imageView == imageView) {
-            target = {};
-        }
-    }
-}
-
-void VulkanPipelineCache::bindUniformBufferObject(uint32_t bindingIndex,
-        VulkanBufferObject* bufferObject, VkDeviceSize offset, VkDeviceSize size) noexcept {
-    VkBuffer buffer = bufferObject->buffer.getGpuBuffer();
-
-    ASSERT_POSTCONDITION(bindingIndex < UBUFFER_BINDING_COUNT,
-            "Uniform bindings overflow: index = %d, capacity = %d.", bindingIndex,
-            UBUFFER_BINDING_COUNT);
-    auto& key = mDescriptorRequirements;
-    key.uniformBuffers[bindingIndex] = buffer;
-
-    if (size == VK_WHOLE_SIZE) {
-        size = WHOLE_SIZE;
-    }
-
-    assert_invariant(offset <= 0xffffffffu);
-    assert_invariant(size <= 0xffffffffu);
-
-    key.uniformBufferOffsets[bindingIndex] = offset;
-    key.uniformBufferSizes[bindingIndex] = size;
-
-    mPipelineBoundResources.acquire(bufferObject);
-}
-
-void VulkanPipelineCache::bindSamplers(VkDescriptorImageInfo samplers[SAMPLER_BINDING_COUNT],
-        VulkanTexture* textures[SAMPLER_BINDING_COUNT], UsageFlags flags) noexcept {
-    for (uint32_t bindingIndex = 0; bindingIndex < SAMPLER_BINDING_COUNT; bindingIndex++) {
-        mDescriptorRequirements.samplers[bindingIndex] = samplers[bindingIndex];
-        if (textures[bindingIndex]) {
-            mPipelineBoundResources.acquire(textures[bindingIndex]);
-        }
-    }
-    mPipelineRequirements.layout = flags;
-}
-
-void VulkanPipelineCache::bindInputAttachment(uint32_t bindingIndex,
-        VkDescriptorImageInfo targetInfo) noexcept {
-    ASSERT_POSTCONDITION(bindingIndex < INPUT_ATTACHMENT_COUNT,
-            "Input attachment bindings overflow: index = %d, capacity = %d.",
-            bindingIndex, INPUT_ATTACHMENT_COUNT);
-    mDescriptorRequirements.inputAttachments[bindingIndex] = targetInfo;
-}
-
 void VulkanPipelineCache::terminate() noexcept {
-    // Symmetric to createLayoutsAndDescriptors.
-    destroyLayoutsAndDescriptors();
    for (auto& iter : mPipelines) {
        vkDestroyPipeline(mDevice, iter.second.handle, VKALLOC);
    }
-    mPipelineBoundResources.clear();
    mPipelines.clear();
    mBoundPipeline = {};
-    vmaDestroyBuffer(mAllocator, mDummyBuffer, mDummyMemory);
-    mDummyBuffer = VK_NULL_HANDLE;
-    mDummyMemory = VK_NULL_HANDLE;
 }

-void VulkanPipelineCache::onCommandBuffer(const VulkanCommandBuffer& commands) {
+void VulkanPipelineCache::gc() noexcept {
    // The timestamp associated with a given cache entry represents "time" as a count of flush
    // events since the cache was constructed. If any cache entry was most recently used over
    // FVK_MAX_PIPELINE_AGE flush events in the past, then we can be sure that it is no longer
@@ -683,194 +306,22 @@ void VulkanPipelineCache::onCommandBuffer(const VulkanCommandBuffer& commands) {
    // The Vulkan spec says: "When a command buffer begins recording, all state in that command
    // buffer is undefined." Therefore, we need to clear all bindings at this time.
    mBoundPipeline = {};
-    mBoundDescriptor = {};
    mCurrentScissor = {};

    // NOTE: Due to robin_map restrictions, we cannot use auto or range-based loops.

-    // Check if any bundles in the cache are no longer in use by any command buffer. Descriptors
-    // from unused bundles are moved back to their respective arenas.
-    using ConstDescIterator = decltype(mDescriptorSets)::const_iterator;
-    for (ConstDescIterator iter = mDescriptorSets.begin(); iter != mDescriptorSets.end();) {
-        const DescriptorCacheEntry& cacheEntry = iter.value();
-        if (cacheEntry.lastUsed + FVK_MAX_PIPELINE_AGE < mCurrentTime) {
-            auto& arenas = mPipelineLayouts[cacheEntry.pipelineLayout].descriptorSetArenas;
-            for (uint32_t i = 0; i < DESCRIPTOR_TYPE_COUNT; ++i) {
-                arenas[i].push_back(cacheEntry.handles[i]);
-            }
-            ++mDescriptorArenasCount;
-            mDescriptorResources.erase(cacheEntry.id);
-            iter = mDescriptorSets.erase(iter);
-        } else {
-            ++iter;
-        }
-    }
-
    // Evict any pipelines that have not been used in a while.
    // Any pipeline older than FVK_MAX_COMMAND_BUFFERS can be safely destroyed.
-    using ConstPipeIterator = decltype(mPipelines)::const_iterator;
-    for (ConstPipeIterator iter = mPipelines.begin(); iter != mPipelines.end();) {
-        const PipelineCacheEntry& cacheEntry = iter.value();
-        if (cacheEntry.lastUsed + FVK_MAX_PIPELINE_AGE < mCurrentTime) {
-            vkDestroyPipeline(mDevice, iter->second.handle, VKALLOC);
-            iter = mPipelines.erase(iter);
-        } else {
-            ++iter;
-        }
-    }
-
-    // Evict any layouts that have not been used in a while.
-    using ConstLayoutIterator = decltype(mPipelineLayouts)::const_iterator;
-    for (ConstLayoutIterator iter = mPipelineLayouts.begin(); iter != mPipelineLayouts.end();) {
-        const PipelineLayoutCacheEntry& cacheEntry = iter.value();
-        if (cacheEntry.lastUsed + FVK_MAX_PIPELINE_AGE < mCurrentTime) {
-            vkDestroyPipelineLayout(mDevice, iter->second.handle, VKALLOC);
-            for (auto setLayout : iter->second.descriptorSetLayouts) {
-                #if FVK_ENABLED(FVK_DEBUG_PIPELINE_CACHE)
-                PipelineLayoutKey key = iter.key();
-                for (auto& pair : mDescriptorSets) {
-                    assert_invariant(pair.second.pipelineLayout != key);
-                }
-                #endif
-                vkDestroyDescriptorSetLayout(mDevice, setLayout, VKALLOC);
-            }
-            auto& arenas = iter->second.descriptorSetArenas;
-            assert_invariant(mDescriptorArenasCount >= arenas[0].size());
-            mDescriptorArenasCount -= arenas[0].size();
-            for (auto& arena : arenas) {
-                vkFreeDescriptorSets(mDevice, mDescriptorPool, arena.size(), arena.data());
-            }
-            iter = mPipelineLayouts.erase(iter);
-        } else {
-            ++iter;
-        }
-    }
-
-    // If there are no descriptors from any extinct pool that are still in use, we can safely
-    // destroy the extinct pools, which implicitly frees their associated descriptor sets.
-    bool canPurgeExtinctPools = true;
-    for (auto& bundle : mExtinctDescriptorBundles) {
-        if (bundle.lastUsed + FVK_MAX_PIPELINE_AGE >= mCurrentTime) {
-            canPurgeExtinctPools = false;
-            break;
-        }
-    }
-    if (canPurgeExtinctPools) {
-        for (VkDescriptorPool pool : mExtinctDescriptorPools) {
-            vkDestroyDescriptorPool(mDevice, pool, VKALLOC);
-        }
-        mExtinctDescriptorPools.clear();
-
-        for (auto const& entry : mExtinctDescriptorBundles) {
-            mDescriptorResources.erase(entry.id);
-        }
-        mExtinctDescriptorBundles.clear();
-    }
-}
-
-VkDescriptorPool VulkanPipelineCache::createDescriptorPool(uint32_t size) const {
-    VkDescriptorPoolSize poolSizes[DESCRIPTOR_TYPE_COUNT] = {};
-    VkDescriptorPoolCreateInfo poolInfo {
-        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
-        .maxSets = size * DESCRIPTOR_TYPE_COUNT,
-        .poolSizeCount = DESCRIPTOR_TYPE_COUNT,
-        .pPoolSizes = poolSizes
-    };
-    poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-    poolSizes[0].descriptorCount = poolInfo.maxSets * UBUFFER_BINDING_COUNT;
-    poolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-    poolSizes[1].descriptorCount = poolInfo.maxSets * SAMPLER_BINDING_COUNT;
-    poolSizes[2].type = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
-    poolSizes[2].descriptorCount = poolInfo.maxSets * INPUT_ATTACHMENT_COUNT;
-
-    VkDescriptorPool pool;
-    const UTILS_UNUSED VkResult result = vkCreateDescriptorPool(mDevice, &poolInfo, VKALLOC, &pool);
-    assert_invariant(result == VK_SUCCESS);
-    return pool;
-}
-
-void VulkanPipelineCache::destroyLayoutsAndDescriptors() noexcept {
-    // Our current descriptor set strategy can cause the # of descriptor sets to explode in certain
-    // situations, so it's interesting to report the number that get stuffed into the cache.
-    #if FVK_ENABLED(FVK_DEBUG_PIPELINE_CACHE)
-    utils::slog.d << "Destroying " << mDescriptorSets.size() << " bundles of descriptor sets."
-            << utils::io::endl;
-    #endif
-
-    mDescriptorSets.clear();
-
-    // Our current layout bundle strategy can cause the # of layout bundles to explode in certain
-    // situations, so it's interesting to report the number that get stuffed into the cache.
-    #if FVK_ENABLED(FVK_DEBUG_PIPELINE_CACHE)
-    utils::slog.d << "Destroying " << mPipelineLayouts.size() << " pipeline layouts."
-                  << utils::io::endl;
-    #endif
-
-    for (auto& iter : mPipelineLayouts) {
-        vkDestroyPipelineLayout(mDevice, iter.second.handle, VKALLOC);
-        for (auto setLayout : iter.second.descriptorSetLayouts) {
-            vkDestroyDescriptorSetLayout(mDevice, setLayout, VKALLOC);
-        }
-        // There is no need to free descriptor sets individually since destroying the VkDescriptorPool
-        // implicitly frees them.
-    }
-    mPipelineLayouts.clear();
-    vkDestroyDescriptorPool(mDevice, mDescriptorPool, VKALLOC);
-    mDescriptorPool = VK_NULL_HANDLE;
-
-    for (VkDescriptorPool pool : mExtinctDescriptorPools) {
-        vkDestroyDescriptorPool(mDevice, pool, VKALLOC);
-    }
-    mExtinctDescriptorPools.clear();
-    mExtinctDescriptorBundles.clear();
-
-    // Both mDescriptorSets and mExtinctDescriptorBundles have been cleared, so it's safe to call
-    // clear() on mDescriptorResources.
-    mDescriptorResources.clear();
-
-    mBoundDescriptor = {};
-}
-
-void VulkanPipelineCache::growDescriptorPool() noexcept {
-    // We need to destroy the old VkDescriptorPool, but we can't do so immediately because many
-    // of its descriptors are still in use. So, stash it in an "extinct" list.
-    mExtinctDescriptorPools.push_back(mDescriptorPool);
-
-    // Create the new VkDescriptorPool, twice as big as the old one.
-    mDescriptorPoolSize *= 2;
-    mDescriptorPool = createDescriptorPool(mDescriptorPoolSize);
-
-    // Clear out all unused descriptor sets in the arena so they don't get reclaimed. There is no
-    // need to free them individually since the old VkDescriptorPool will be destroyed.
-    for (auto iter = mPipelineLayouts.begin(); iter != mPipelineLayouts.end(); ++iter) {
-        for (auto& arena : iter.value().descriptorSetArenas) {
-            arena.clear();
-        }
-    }
-    mDescriptorArenasCount = 0;
-
-    // Move all in-use descriptors from the primary cache into an "extinct" list, so that they will
-    // later be destroyed rather than reclaimed.
-    using DescIterator = decltype(mDescriptorSets)::iterator;
-    for (DescIterator iter = mDescriptorSets.begin(); iter != mDescriptorSets.end(); ++iter) {
-        mExtinctDescriptorBundles.push_back(iter.value());
-    }
-    mDescriptorSets.clear();
-}
-
-size_t VulkanPipelineCache::PipelineLayoutKeyHashFn::operator()(
-        const PipelineLayoutKey& key) const {
-    std::hash<uint64_t> hasher;
-    auto h0 = hasher(key.getBitsAt(0));
-    auto h1 = hasher(key.getBitsAt(1));
-    return h0 ^ (h1 << 1);
-}
-
-bool VulkanPipelineCache::PipelineLayoutKeyEqual::operator()(const PipelineLayoutKey& k1,
-        const PipelineLayoutKey& k2) const {
-    return k1 == k2;
+   using ConstPipeIterator = decltype(mPipelines)::const_iterator;
+   for (ConstPipeIterator iter = mPipelines.begin(); iter != mPipelines.end();) {
+       const PipelineCacheEntry& cacheEntry = iter.value();
+       if (cacheEntry.lastUsed + FVK_MAX_PIPELINE_AGE < mCurrentTime) {
+           vkDestroyPipeline(mDevice, iter->second.handle, VKALLOC);
+           iter = mPipelines.erase(iter);
+       } else {
+           ++iter;
+       }
+   }
 }

 bool VulkanPipelineCache::PipelineEqual::operator()(const PipelineKey& k1,
@@ -878,31 +329,6 @@ bool VulkanPipelineCache::PipelineEqual::operator()(const PipelineKey& k1,
    return 0 == memcmp((const void*) &k1, (const void*) &k2, sizeof(k1));
 }

-bool VulkanPipelineCache::DescEqual::operator()(const DescriptorKey& k1,
-        const DescriptorKey& k2) const {
-    for (uint32_t i = 0; i < UBUFFER_BINDING_COUNT; i++) {
-        if (k1.uniformBuffers[i] != k2.uniformBuffers[i] ||
-            k1.uniformBufferOffsets[i] != k2.uniformBufferOffsets[i] ||
-            k1.uniformBufferSizes[i] != k2.uniformBufferSizes[i]) {
-            return false;
-        }
-    }
-    for (uint32_t i = 0; i < SAMPLER_BINDING_COUNT; i++) {
-        if (k1.samplers[i].sampler != k2.samplers[i].sampler ||
-            k1.samplers[i].imageView != k2.samplers[i].imageView ||
-            k1.samplers[i].imageLayout != k2.samplers[i].imageLayout) {
-            return false;
-        }
-    }
-    for (uint32_t i = 0; i < INPUT_ATTACHMENT_COUNT; i++) {
-        if (k1.inputAttachments[i].imageView != k2.inputAttachments[i].imageView ||
-            k1.inputAttachments[i].imageLayout != k2.inputAttachments[i].imageLayout) {
-            return false;
-        }
-    }
-    return true;
-}
-
 } // namespace filament::backend

 #pragma clang diagnostic pop
@@ -17,6 +17,11 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANPIPELINECACHE_H
 #define TNT_FILAMENT_BACKEND_VULKANPIPELINECACHE_H

+#include "VulkanCommands.h"
+#include "VulkanMemory.h"
+#include "VulkanResources.h"
+#include "VulkanUtility.h"
+
 #include <backend/DriverEnums.h>
 #include <backend/TargetBufferInfo.h>

@@ -34,12 +39,6 @@
 #include <vector>
 #include <unordered_map>

-#include "VulkanCommands.h"
-
-VK_DEFINE_HANDLE(VmaAllocator)
-VK_DEFINE_HANDLE(VmaAllocation)
-VK_DEFINE_HANDLE(VmaPool)
-
 namespace filament::backend {

 struct VulkanProgram;
@@ -56,32 +55,14 @@ class VulkanResourceAllocator;
 // - Assumes that viewport and scissor should be dynamic. (not baked into VkPipeline)
 // - Assumes that uniform buffers should be visible across all shader stages.
 //
-class VulkanPipelineCache : public CommandBufferObserver {
+class VulkanPipelineCache {
 public:
    VulkanPipelineCache(VulkanPipelineCache const&) = delete;
    VulkanPipelineCache& operator=(VulkanPipelineCache const&) = delete;

-    static constexpr uint32_t UBUFFER_BINDING_COUNT = Program::UNIFORM_BINDING_COUNT;
-    static constexpr uint32_t SAMPLER_BINDING_COUNT = MAX_SAMPLER_COUNT;
-
-    // We assume only one possible input attachment between two subpasses. See also the subpasses
-    // definition in VulkanFboCache.
-    static constexpr uint32_t INPUT_ATTACHMENT_COUNT = 1;
-
    static constexpr uint32_t SHADER_MODULE_COUNT = 2;
    static constexpr uint32_t VERTEX_ATTRIBUTE_COUNT = MAX_VERTEX_ATTRIBUTE_COUNT;

-    // Three descriptor set layouts: uniforms, combined image samplers, and input attachments.
-    static constexpr uint32_t DESCRIPTOR_TYPE_COUNT = 3;
-    static constexpr uint32_t INITIAL_DESCRIPTOR_SET_POOL_SIZE = 512;
-
-    // The VertexArray POD is an array of buffer targets and an array of attributes that refer to
-    // those targets. It does not include any references to actual buffers, so you can think of it
-    // as a vertex assembler configuration. For simplicity it contains fixed-size arrays and does
-    // not store sizes; all unused entries are simply zeroed out.
-    struct VertexArray {
-    };
-
    // The ProgramBundle contains weak references to the compiled vertex and fragment shaders.
    struct ProgramBundle {
        VkShaderModule vertex;
@@ -89,8 +70,6 @@ public:
        VkSpecializationInfo* specializationInfos = nullptr;
    };

-    static UsageFlags disableUsageFlags(uint16_t binding, UsageFlags src);
-
    #pragma clang diagnostic push
    #pragma clang diagnostic warning "-Wpadded"

@@ -133,17 +112,13 @@ public:

    // Upon construction, the pipeCache initializes some internal state but does not make any Vulkan
    // calls. On destruction it will free any cached Vulkan objects that haven't already been freed.
-    VulkanPipelineCache(VulkanResourceAllocator* allocator);
+    VulkanPipelineCache(VkDevice device, VmaAllocator allocator);
    ~VulkanPipelineCache();
-    void setDevice(VkDevice device, VmaAllocator allocator);

-    // Creates new descriptor sets if necessary and binds them using vkCmdBindDescriptorSets.
-    // Returns false if descriptor set allocation fails.
-    bool bindDescriptors(VkCommandBuffer cmdbuffer) noexcept;
+    void bindLayout(VkPipelineLayout layout) noexcept;

    // Creates a new pipeline if necessary and binds it using vkCmdBindPipeline.
-    // Returns false if an error occurred.
-    bool bindPipeline(VulkanCommandBuffer* commands) noexcept;
+    void bindPipeline(VulkanCommandBuffer* commands);

    // Sets up a new scissor rectangle if it has been dirtied.
    void bindScissor(VkCommandBuffer cmdbuffer, VkRect2D scissor) noexcept;
@@ -153,42 +128,13 @@ public:
    void bindRasterState(const RasterState& rasterState) noexcept;
    void bindRenderPass(VkRenderPass renderPass, int subpassIndex) noexcept;
    void bindPrimitiveTopology(VkPrimitiveTopology topology) noexcept;
-    void bindUniformBufferObject(uint32_t bindingIndex, VulkanBufferObject* bufferObject,
-            VkDeviceSize offset = 0, VkDeviceSize size = VK_WHOLE_SIZE) noexcept;
-    void bindSamplers(VkDescriptorImageInfo samplers[SAMPLER_BINDING_COUNT],
-            VulkanTexture* textures[SAMPLER_BINDING_COUNT], UsageFlags flags) noexcept;
-    void bindInputAttachment(uint32_t bindingIndex, VkDescriptorImageInfo imageInfo) noexcept;
+
    void bindVertexArray(VkVertexInputAttributeDescription const* attribDesc,
            VkVertexInputBindingDescription const* bufferDesc, uint8_t count);

-    // Gets the current UBO at the given slot, useful for push / pop.
-    UniformBufferBinding getUniformBufferBinding(uint32_t bindingIndex) const noexcept;
-
-    // Checks if the given uniform is bound to any slot, and if so binds "null" to that slot.
-    // Also invalidates all cached descriptors that refer to the given buffer.
-    // This is only necessary when the client knows that the UBO is about to be destroyed.
-    void unbindUniformBuffer(VkBuffer uniformBuffer) noexcept;
-
-    // Checks if an image view is bound to any sampler, and if so resets that particular slot.
-    // Also invalidates all cached descriptors that refer to the given image view.
-    // This is only necessary when the client knows that a texture is about to be destroyed.
-    void unbindImageView(VkImageView imageView) noexcept;
-
-    // NOTE: In theory we should proffer "unbindSampler" but in practice we never destroy samplers.
-
    // Destroys all managed Vulkan objects. This should be called before changing the VkDevice.
    void terminate() noexcept;

-    // vkCmdBindPipeline and vkCmdBindDescriptorSets establish bindings to a specific command
-    // buffer; they are not global to the device. Therefore we need to be notified when a
-    // new command buffer becomes active.
-    void onCommandBuffer(const VulkanCommandBuffer& cmdbuffer) override;
-
-    // Injects a dummy texture that can be used to clear out old descriptor sets.
-    void setDummyTexture(VkImageView imageView) {
-        mDummyTargetInfo.imageView = imageView;
-    }
-
    static VkPrimitiveTopology getPrimitiveTopology(PrimitiveType pt) noexcept {
        switch (pt) {
            case PrimitiveType::POINTS:
@@ -204,22 +150,9 @@ public:
        }
    }

+    void gc() noexcept;
+
 private:
-    // PIPELINE LAYOUT CACHE KEY
-    // -------------------------
-
-    using PipelineLayoutKey = utils::bitset128;
-
-    static_assert(PipelineLayoutKey::BIT_COUNT >= 2 * MAX_SAMPLER_COUNT);
-
-    struct PipelineLayoutKeyHashFn {
-        size_t operator()(const PipelineLayoutKey& key) const;
-    };
-
-    struct PipelineLayoutKeyEqual {
-        bool operator()(const PipelineLayoutKey& k1, const PipelineLayoutKey& k2) const;
-    };
-
    // PIPELINE CACHE KEY
    // ------------------

@@ -272,10 +205,10 @@ private:
        VertexInputBindingDescription vertexBuffers[VERTEX_ATTRIBUTE_COUNT];      //  128 : 156
        RasterState rasterState;                                                  //  16  : 284
        uint32_t padding;                                                         //  4   : 300
-        PipelineLayoutKey layout;                                                 // 16   : 304
+        VkPipelineLayout layout;                                                  //  8   : 304
    };

-    static_assert(sizeof(PipelineKey) == 320, "PipelineKey must not have implicit padding.");
+    static_assert(sizeof(PipelineKey) == 312, "PipelineKey must not have implicit padding.");

    using PipelineHashFn = utils::hash::MurmurHashFn<PipelineKey>;

@@ -283,52 +216,6 @@ private:
        bool operator()(const PipelineKey& k1, const PipelineKey& k2) const;
    };

-    // DESCRIPTOR SET CACHE KEY
-    // ------------------------
-
-    // Equivalent to VkDescriptorImageInfo but with explicit padding.
-    struct DescriptorImageInfo {
-        DescriptorImageInfo& operator=(const VkDescriptorImageInfo& that) {
-            sampler = that.sampler;
-            imageView = that.imageView;
-            imageLayout = that.imageLayout;
-            padding = 0;
-            return *this;
-        }
-        operator VkDescriptorImageInfo() const { return { sampler, imageView, imageLayout }; }
-
-        // TODO: replace the 64-bit sampler handle with `uint32_t samplerParams` and remove the
-        // padding field. This is possible if we have access to the VulkanSamplerCache.
-        VkSampler sampler;
-
-        VkImageView imageView;
-        VkImageLayout imageLayout;
-        uint32_t padding;
-    };
-
-    // We store size with 32 bits, so our "WHOLE" sentinel is different from Vk.
-    static const uint32_t WHOLE_SIZE = 0xffffffffu;
-
-    // Represents all the Vulkan state that comprises a bound descriptor set.
-    struct DescriptorKey {
-        VkBuffer uniformBuffers[UBUFFER_BINDING_COUNT];               //   80     0
-        DescriptorImageInfo samplers[SAMPLER_BINDING_COUNT];          // 1488    80
-        DescriptorImageInfo inputAttachments[INPUT_ATTACHMENT_COUNT]; //   24  1568
-        uint32_t uniformBufferOffsets[UBUFFER_BINDING_COUNT];         //   40  1592
-        uint32_t uniformBufferSizes[UBUFFER_BINDING_COUNT];           //   40  1632
-    };
-    static_assert(offsetof(DescriptorKey, samplers)              == 80);
-    static_assert(offsetof(DescriptorKey, inputAttachments)      == 1568);
-    static_assert(offsetof(DescriptorKey, uniformBufferOffsets)  == 1592);
-    static_assert(offsetof(DescriptorKey, uniformBufferSizes)    == 1632);
-    static_assert(sizeof(DescriptorKey) == 1672, "DescriptorKey must not have implicit padding.");
-
-    using DescHashFn = utils::hash::MurmurHashFn<DescriptorKey>;
-
-    struct DescEqual {
-        bool operator()(const DescriptorKey& k1, const DescriptorKey& k2) const;
-    };
-
    #pragma clang diagnostic pop

    // CACHE ENTRY STRUCTS
@@ -341,16 +228,6 @@ private:
    using Timestamp = uint64_t;
    Timestamp mCurrentTime = 0;

-    // The descriptor set cache entry is a group of descriptor sets that are bound simultaneously.
-    struct DescriptorCacheEntry {
-        std::array<VkDescriptorSet, DESCRIPTOR_TYPE_COUNT> handles;
-        Timestamp lastUsed;
-        PipelineLayoutKey pipelineLayout;
-        uint32_t id;
-    };
-    uint32_t mDescriptorCacheEntryCount = 0;
-
-
    struct PipelineCacheEntry {
        VkPipeline handle;
        Timestamp lastUsed;
@@ -359,98 +236,36 @@ private:
    struct PipelineLayoutCacheEntry {
        VkPipelineLayout handle;
        Timestamp lastUsed;
-
-        std::array<VkDescriptorSetLayout, DESCRIPTOR_TYPE_COUNT> descriptorSetLayouts;
-
-        // Each pipeline layout has 3 arenas of unused descriptors (one for each binding type).
-        //
-        // The difference between the "arenas" and the "pool" are as follows.
-        //
-        // - The "pool" is a single, centralized factory for all descriptors (VkDescriptorPool).
-        //
-        // - Each "arena" is a set of unused (but alive) descriptors that can only be used with a
-        //   specific pipeline layout and a specific binding type. We manually manage each arena.
-        //   The arenas are created in an empty state, and they are gradually populated as new
-        //   descriptors are reclaimed over time.  This is quite different from the pool, which is
-        //   given a fixed size when it is constructed.
-        //
-        std::array<std::vector<VkDescriptorSet>, DESCRIPTOR_TYPE_COUNT> descriptorSetArenas;
    };

    // CACHE CONTAINERS
    // ----------------

-    using PipelineLayoutMap = tsl::robin_map<PipelineLayoutKey , PipelineLayoutCacheEntry,
-            PipelineLayoutKeyHashFn, PipelineLayoutKeyEqual>;
    using PipelineMap = tsl::robin_map<PipelineKey, PipelineCacheEntry,
            PipelineHashFn, PipelineEqual>;
-    using DescriptorMap
-            = tsl::robin_map<DescriptorKey, DescriptorCacheEntry, DescHashFn, DescEqual>;
-    using DescriptorResourceMap
-            = std::unordered_map<uint32_t, std::unique_ptr<VulkanAcquireOnlyResourceManager>>;

-    PipelineLayoutMap mPipelineLayouts;
+private:
+
+    PipelineCacheEntry* getOrCreatePipeline() noexcept;
+
    PipelineMap mPipelines;
-    DescriptorMap mDescriptorSets;
-    DescriptorResourceMap mDescriptorResources;

    // These helpers all return unstable pointers that should not be stored.
-    DescriptorCacheEntry* createDescriptorSets() noexcept;
    PipelineCacheEntry* createPipeline() noexcept;
    PipelineLayoutCacheEntry* getOrCreatePipelineLayout() noexcept;

-    // Misc helper methods.
-    void destroyLayoutsAndDescriptors() noexcept;
-    VkDescriptorPool createDescriptorPool(uint32_t size) const;
-    void growDescriptorPool() noexcept;
-
    // Immutable state.
    VkDevice mDevice = VK_NULL_HANDLE;
    VmaAllocator mAllocator = VK_NULL_HANDLE;

    // Current requirements for the pipeline layout, pipeline, and descriptor sets.
    PipelineKey mPipelineRequirements = {};
-    DescriptorKey mDescriptorRequirements = {};

    // Current bindings for the pipeline and descriptor sets.
    PipelineKey mBoundPipeline = {};
-    DescriptorKey mBoundDescriptor = {};

    // Current state for scissoring.
    VkRect2D mCurrentScissor = {};
-
-    // The descriptor set pool starts out with a decent number of descriptor sets.  The cache can
-    // grow the pool by re-creating it with a larger size.  See growDescriptorPool().
-    VkDescriptorPool mDescriptorPool;
-
-    // This describes the number of descriptor sets in mDescriptorPool. Note that this needs to be
-    // multiplied by DESCRIPTOR_TYPE_COUNT to get the actual number of descriptor sets. Also note
-    // that the number of low-level "descriptors" (not descriptor *sets*) is actually much more than
-    // this size. It can be computed only by factoring in UBUFFER_BINDING_COUNT etc.
-    uint32_t mDescriptorPoolSize = INITIAL_DESCRIPTOR_SET_POOL_SIZE;
-
-    // To get the actual number of descriptor sets that have been allocated from the pool,
-    // take the sum of mDescriptorArenasCount (these are inactive descriptor sets) and the
-    // number of entries in the mDescriptorPool map (active descriptor sets). Multiply the result by
-    // DESCRIPTOR_TYPE_COUNT.
-    uint32_t mDescriptorArenasCount = 0;
-
-    // After a growth event (i.e. when the VkDescriptorPool is replaced with a bigger version), all
-    // currently used descriptors are moved into the "extinct" sets so that they can be safely
-    // destroyed a few frames later.
-    std::list<VkDescriptorPool> mExtinctDescriptorPools;
-    std::list<DescriptorCacheEntry> mExtinctDescriptorBundles;
-
-    VkDescriptorBufferInfo mDummyBufferInfo = {};
-    VkWriteDescriptorSet mDummyBufferWriteInfo = {};
-    VkDescriptorImageInfo mDummyTargetInfo = {};
-    VkWriteDescriptorSet mDummyTargetWriteInfo = {};
-
-    VkBuffer mDummyBuffer;
-    VmaAllocation mDummyMemory;
-
-    VulkanResourceAllocator* mResourceAllocator;
-    VulkanAcquireOnlyResourceManager mPipelineBoundResources;
 };

 } // namespace filament::backend
@@ -28,7 +28,6 @@ using namespace bluevk;

 namespace filament::backend {

-using ImgUtil = VulkanImageUtility;
 using TaskHandler = VulkanReadPixels::TaskHandler;
 using WorkloadFunc = TaskHandler::WorkloadFunc;
 using OnCompleteFunc = TaskHandler::OnCompleteFunc;
@@ -118,7 +117,7 @@ void VulkanReadPixels::terminate() noexcept {
 VulkanReadPixels::VulkanReadPixels(VkDevice device)
    : mDevice(device) {}

-void VulkanReadPixels::run(VulkanRenderTarget const* srcTarget, uint32_t const x, uint32_t const y,
+void VulkanReadPixels::run(VulkanRenderTarget* srcTarget, uint32_t const x, uint32_t const y,
        uint32_t const width, uint32_t const height, uint32_t const graphicsQueueFamilyIndex,
        PixelBufferDescriptor&& pbd, SelecteMemoryFunction const& selectMemoryFunc,
        OnReadCompleteFunction const& readCompleteFunc) {
@@ -218,7 +217,7 @@ void VulkanReadPixels::run(VulkanRenderTarget const* srcTarget, uint32_t const x
    };
    vkBeginCommandBuffer(cmdbuffer, &binfo);

-    ImgUtil::transitionLayout(cmdbuffer, {
+    imgutil::transitionLayout(cmdbuffer, {
        .image = stagingImage,
        .oldLayout = VulkanLayout::UNDEFINED,
        .newLayout = VulkanLayout::TRANSFER_DST,
@@ -232,8 +231,7 @@ void VulkanReadPixels::run(VulkanRenderTarget const* srcTarget, uint32_t const x
    });

    VulkanAttachment const srcAttachment = srcTarget->getColor(0);
-    const VkImageSubresourceRange srcRange
-            = srcAttachment.getSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT);
+    VkImageSubresourceRange const srcRange = srcAttachment.getSubresourceRange();
    srcTexture->transitionLayout(cmdbuffer, srcRange, VulkanLayout::TRANSFER_SRC);

    VkImageCopy const imageCopyRegion = {
@@ -266,8 +264,8 @@ void VulkanReadPixels::run(VulkanRenderTarget const* srcTarget, uint32_t const x
            imageCopyRegion.srcOffset.y + imageCopyRegion.extent.height <= srcExtent.height);

    vkCmdCopyImage(cmdbuffer, srcAttachment.getImage(),
-            ImgUtil::getVkLayout(VulkanLayout::TRANSFER_SRC), stagingImage,
-            ImgUtil::getVkLayout(VulkanLayout::TRANSFER_DST), 1, &imageCopyRegion);
+            imgutil::getVkLayout(VulkanLayout::TRANSFER_SRC), stagingImage,
+            imgutil::getVkLayout(VulkanLayout::TRANSFER_DST), 1, &imageCopyRegion);

    // Restore the source image layout.
    srcTexture->transitionLayout(cmdbuffer, srcRange, VulkanLayout::COLOR_ATTACHMENT);
@@ -26,9 +26,7 @@
 #include <functional>
 #include <mutex>
 #include <queue>
-#include <set>
 #include <thread>
-#include <vector>

 namespace filament::backend {

@@ -74,8 +72,8 @@ public:

    void terminate() noexcept;

-    void run(VulkanRenderTarget const* srcTarget, uint32_t x, uint32_t y, uint32_t width,
-            uint32_t height, uint32_t graphicsQueueFamilyIndex, PixelBufferDescriptor&& pbd,
+    void run(VulkanRenderTarget* srcTarget, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
+            uint32_t graphicsQueueFamilyIndex, PixelBufferDescriptor&& pbd,
            SelecteMemoryFunction const& selectMemoryFunc,
            OnReadCompleteFunction const& readCompleteFunc);

@@ -51,8 +51,8 @@ namespace filament::backend {
 class VulkanResourceAllocator {
 public:
    using AllocatorImpl = HandleAllocatorVK;
-    VulkanResourceAllocator(size_t arenaSize,  bool disableUseAfterFreeCheck)
-        : mHandleAllocatorImpl("Handles", arenaSize,  disableUseAfterFreeCheck)
+    VulkanResourceAllocator(size_t arenaSize, bool disableUseAfterFreeCheck)
+        : mHandleAllocatorImpl("Handles", arenaSize, disableUseAfterFreeCheck)
 #if DEBUG_RESOURCE_LEAKS
        , mDebugOnlyResourceCount(RESOURCE_TYPE_COUNT) {
        std::memset(mDebugOnlyResourceCount.data(), 0, sizeof(size_t) * RESOURCE_TYPE_COUNT);
@@ -17,6 +17,7 @@
 #include "VulkanStagePool.h"

 #include "VulkanConstants.h"
+#include "VulkanImageUtility.h"
 #include "VulkanMemory.h"
 #include "VulkanUtility.h"

@@ -118,7 +119,7 @@ VulkanStageImage const* VulkanStagePool::acquireImage(PixelDataFormat format, Pi
    // VK_IMAGE_LAYOUT_PREINITIALIZED or VK_IMAGE_LAYOUT_GENERAL layout. Calling
    // vkGetImageSubresourceLayout for a linear image returns a subresource layout mapping that is
    // valid for either of those image layouts."
-    VulkanImageUtility::transitionLayout(cmdbuffer, {
+    imgutil::transitionLayout(cmdbuffer, {
            .image = image->image,
            .oldLayout = VulkanLayout::UNDEFINED,
            .newLayout = VulkanLayout::READ_WRITE, // (= VK_IMAGE_LAYOUT_GENERAL)
@@ -28,7 +28,6 @@ using namespace bluevk;

 namespace filament::backend {

-using ImgUtil = VulkanImageUtility;
 VulkanTexture::VulkanTexture(VkDevice device, VmaAllocator allocator, VulkanCommands* commands,
        VkImage image, VkFormat format, uint8_t samples, uint32_t width, uint32_t height,
        TextureUsage tusage, VulkanStagePool& stagePool, bool heapAllocated)
@@ -37,7 +36,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VmaAllocator allocator, VulkanComm
      VulkanResource(
              heapAllocated ? VulkanResourceType::HEAP_ALLOCATED : VulkanResourceType::TEXTURE),
      mVkFormat(format),
-      mViewType(ImgUtil::getViewType(target)),
+      mViewType(imgutil::getViewType(target)),
      mSwizzle({}),
      mTextureImage(image),
      mFullViewRange{
@@ -62,7 +61,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
      VulkanResource(
              heapAllocated ? VulkanResourceType::HEAP_ALLOCATED : VulkanResourceType::TEXTURE),
      mVkFormat(backend::getVkFormat(tformat)),
-      mViewType(ImgUtil::getViewType(target)),
+      mViewType(imgutil::getViewType(target)),
      mSwizzle(swizzle),
      mStagePool(stagePool),
      mDevice(device),
@@ -236,7 +235,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        VulkanCommandBuffer& commands = mCommands->get();
        VkCommandBuffer const cmdbuf = commands.buffer();
        commands.acquire(this);
-        transitionLayout(cmdbuf, mFullViewRange, ImgUtil::getDefaultLayout(imageInfo.usage));
+        transitionLayout(cmdbuf, mFullViewRange, imgutil::getDefaultLayout(imageInfo.usage));
    }
 }

@@ -327,10 +326,10 @@ void VulkanTexture::updateImage(const PixelBufferDescriptor& data, uint32_t widt

    VulkanLayout const newLayout = VulkanLayout::TRANSFER_DST;
    VulkanLayout nextLayout = getLayout(transitionRange.baseArrayLayer, miplevel);
-    VkImageLayout const newVkLayout = ImgUtil::getVkLayout(newLayout);
+    VkImageLayout const newVkLayout = imgutil::getVkLayout(newLayout);

    if (nextLayout == VulkanLayout::UNDEFINED) {
-        nextLayout = ImgUtil::getDefaultLayout(this->usage);
+        nextLayout = imgutil::getDefaultLayout(this->usage);
    }

    transitionLayout(cmdbuf, transitionRange, newLayout);
@@ -374,8 +373,8 @@ void VulkanTexture::updateImageWithBlit(const PixelBufferDescriptor& hostData, u
    VulkanLayout const oldLayout = getLayout(layer, miplevel);
    transitionLayout(cmdbuf, range, newLayout);

-    vkCmdBlitImage(cmdbuf, stage->image, ImgUtil::getVkLayout(VulkanLayout::TRANSFER_SRC),
-            mTextureImage, ImgUtil::getVkLayout(newLayout), 1, blitRegions, VK_FILTER_NEAREST);
+    vkCmdBlitImage(cmdbuf, stage->image, imgutil::getVkLayout(VulkanLayout::TRANSFER_SRC),
+            mTextureImage, imgutil::getVkLayout(newLayout), 1, blitRegions, VK_FILTER_NEAREST);

    transitionLayout(cmdbuf, range, oldLayout);
 }
@@ -467,7 +466,7 @@ void VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, const VkImageSubres
        for (uint32_t i = firstLayer; i < lastLayer; ++i) {
            for (uint32_t j = firstLevel; j < lastLevel; ++j) {
                VulkanLayout const layout = getLayout(i, j);
-                ImgUtil::transitionLayout(cmdbuf, {
+                imgutil::transitionLayout(cmdbuf, {
                        .image = mTextureImage,
                        .oldLayout = layout,
                        .newLayout = newLayout,
@@ -482,7 +481,7 @@ void VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, const VkImageSubres
            }
        }
    } else {
-        ImgUtil::transitionLayout(cmdbuf, {
+        imgutil::transitionLayout(cmdbuf, {
            .image = mTextureImage,
            .oldLayout = oldLayout,
            .newLayout = newLayout,
@@ -655,6 +655,4 @@ uint8_t reduceSampleCount(uint8_t sampleCount, VkSampleCountFlags mask) {
    return mostSignificantBit((sampleCount - 1) & mask);
 }

-_BitCountHelper _BitCountHelper::BitCounter = {};
-
 } // namespace filament::backend
@@ -90,12 +90,321 @@ utils::FixedCapacityVector<OutType> enumerate(
 #undef EXPAND_ENUM_NO_ARGS
 #undef EXPAND_ENUM_ARGS

-// Used across pipeline related classes.
-using UsageFlags = utils::bitset128;
-
 // Useful shorthands
 using VkFormatList = utils::FixedCapacityVector<VkFormat>;

+// Copied from
+//   https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkFormat.html
+constexpr VkFormat ALL_VK_FORMATS[] = {
+        VK_FORMAT_UNDEFINED,
+        VK_FORMAT_R4G4_UNORM_PACK8,
+        VK_FORMAT_R4G4B4A4_UNORM_PACK16,
+        VK_FORMAT_B4G4R4A4_UNORM_PACK16,
+        VK_FORMAT_R5G6B5_UNORM_PACK16,
+        VK_FORMAT_B5G6R5_UNORM_PACK16,
+        VK_FORMAT_R5G5B5A1_UNORM_PACK16,
+        VK_FORMAT_B5G5R5A1_UNORM_PACK16,
+        VK_FORMAT_A1R5G5B5_UNORM_PACK16,
+        VK_FORMAT_R8_UNORM,
+        VK_FORMAT_R8_SNORM,
+        VK_FORMAT_R8_USCALED,
+        VK_FORMAT_R8_SSCALED,
+        VK_FORMAT_R8_UINT,
+        VK_FORMAT_R8_SINT,
+        VK_FORMAT_R8_SRGB,
+        VK_FORMAT_R8G8_UNORM,
+        VK_FORMAT_R8G8_SNORM,
+        VK_FORMAT_R8G8_USCALED,
+        VK_FORMAT_R8G8_SSCALED,
+        VK_FORMAT_R8G8_UINT,
+        VK_FORMAT_R8G8_SINT,
+        VK_FORMAT_R8G8_SRGB,
+        VK_FORMAT_R8G8B8_UNORM,
+        VK_FORMAT_R8G8B8_SNORM,
+        VK_FORMAT_R8G8B8_USCALED,
+        VK_FORMAT_R8G8B8_SSCALED,
+        VK_FORMAT_R8G8B8_UINT,
+        VK_FORMAT_R8G8B8_SINT,
+        VK_FORMAT_R8G8B8_SRGB,
+        VK_FORMAT_B8G8R8_UNORM,
+        VK_FORMAT_B8G8R8_SNORM,
+        VK_FORMAT_B8G8R8_USCALED,
+        VK_FORMAT_B8G8R8_SSCALED,
+        VK_FORMAT_B8G8R8_UINT,
+        VK_FORMAT_B8G8R8_SINT,
+        VK_FORMAT_B8G8R8_SRGB,
+        VK_FORMAT_R8G8B8A8_UNORM,
+        VK_FORMAT_R8G8B8A8_SNORM,
+        VK_FORMAT_R8G8B8A8_USCALED,
+        VK_FORMAT_R8G8B8A8_SSCALED,
+        VK_FORMAT_R8G8B8A8_UINT,
+        VK_FORMAT_R8G8B8A8_SINT,
+        VK_FORMAT_R8G8B8A8_SRGB,
+        VK_FORMAT_B8G8R8A8_UNORM,
+        VK_FORMAT_B8G8R8A8_SNORM,
+        VK_FORMAT_B8G8R8A8_USCALED,
+        VK_FORMAT_B8G8R8A8_SSCALED,
+        VK_FORMAT_B8G8R8A8_UINT,
+        VK_FORMAT_B8G8R8A8_SINT,
+        VK_FORMAT_B8G8R8A8_SRGB,
+        VK_FORMAT_A8B8G8R8_UNORM_PACK32,
+        VK_FORMAT_A8B8G8R8_SNORM_PACK32,
+        VK_FORMAT_A8B8G8R8_USCALED_PACK32,
+        VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
+        VK_FORMAT_A8B8G8R8_UINT_PACK32,
+        VK_FORMAT_A8B8G8R8_SINT_PACK32,
+        VK_FORMAT_A8B8G8R8_SRGB_PACK32,
+        VK_FORMAT_A2R10G10B10_UNORM_PACK32,
+        VK_FORMAT_A2R10G10B10_SNORM_PACK32,
+        VK_FORMAT_A2R10G10B10_USCALED_PACK32,
+        VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
+        VK_FORMAT_A2R10G10B10_UINT_PACK32,
+        VK_FORMAT_A2R10G10B10_SINT_PACK32,
+        VK_FORMAT_A2B10G10R10_UNORM_PACK32,
+        VK_FORMAT_A2B10G10R10_SNORM_PACK32,
+        VK_FORMAT_A2B10G10R10_USCALED_PACK32,
+        VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
+        VK_FORMAT_A2B10G10R10_UINT_PACK32,
+        VK_FORMAT_A2B10G10R10_SINT_PACK32,
+        VK_FORMAT_R16_UNORM,
+        VK_FORMAT_R16_SNORM,
+        VK_FORMAT_R16_USCALED,
+        VK_FORMAT_R16_SSCALED,
+        VK_FORMAT_R16_UINT,
+        VK_FORMAT_R16_SINT,
+        VK_FORMAT_R16_SFLOAT,
+        VK_FORMAT_R16G16_UNORM,
+        VK_FORMAT_R16G16_SNORM,
+        VK_FORMAT_R16G16_USCALED,
+        VK_FORMAT_R16G16_SSCALED,
+        VK_FORMAT_R16G16_UINT,
+        VK_FORMAT_R16G16_SINT,
+        VK_FORMAT_R16G16_SFLOAT,
+        VK_FORMAT_R16G16B16_UNORM,
+        VK_FORMAT_R16G16B16_SNORM,
+        VK_FORMAT_R16G16B16_USCALED,
+        VK_FORMAT_R16G16B16_SSCALED,
+        VK_FORMAT_R16G16B16_UINT,
+        VK_FORMAT_R16G16B16_SINT,
+        VK_FORMAT_R16G16B16_SFLOAT,
+        VK_FORMAT_R16G16B16A16_UNORM,
+        VK_FORMAT_R16G16B16A16_SNORM,
+        VK_FORMAT_R16G16B16A16_USCALED,
+        VK_FORMAT_R16G16B16A16_SSCALED,
+        VK_FORMAT_R16G16B16A16_UINT,
+        VK_FORMAT_R16G16B16A16_SINT,
+        VK_FORMAT_R16G16B16A16_SFLOAT,
+        VK_FORMAT_R32_UINT,
+        VK_FORMAT_R32_SINT,
+        VK_FORMAT_R32_SFLOAT,
+        VK_FORMAT_R32G32_UINT,
+        VK_FORMAT_R32G32_SINT,
+        VK_FORMAT_R32G32_SFLOAT,
+        VK_FORMAT_R32G32B32_UINT,
+        VK_FORMAT_R32G32B32_SINT,
+        VK_FORMAT_R32G32B32_SFLOAT,
+        VK_FORMAT_R32G32B32A32_UINT,
+        VK_FORMAT_R32G32B32A32_SINT,
+        VK_FORMAT_R32G32B32A32_SFLOAT,
+        VK_FORMAT_R64_UINT,
+        VK_FORMAT_R64_SINT,
+        VK_FORMAT_R64_SFLOAT,
+        VK_FORMAT_R64G64_UINT,
+        VK_FORMAT_R64G64_SINT,
+        VK_FORMAT_R64G64_SFLOAT,
+        VK_FORMAT_R64G64B64_UINT,
+        VK_FORMAT_R64G64B64_SINT,
+        VK_FORMAT_R64G64B64_SFLOAT,
+        VK_FORMAT_R64G64B64A64_UINT,
+        VK_FORMAT_R64G64B64A64_SINT,
+        VK_FORMAT_R64G64B64A64_SFLOAT,
+        VK_FORMAT_B10G11R11_UFLOAT_PACK32,
+        VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
+        VK_FORMAT_D16_UNORM,
+        VK_FORMAT_X8_D24_UNORM_PACK32,
+        VK_FORMAT_D32_SFLOAT,
+        VK_FORMAT_S8_UINT,
+        VK_FORMAT_D16_UNORM_S8_UINT,
+        VK_FORMAT_D24_UNORM_S8_UINT,
+        VK_FORMAT_D32_SFLOAT_S8_UINT,
+        VK_FORMAT_BC1_RGB_UNORM_BLOCK,
+        VK_FORMAT_BC1_RGB_SRGB_BLOCK,
+        VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
+        VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
+        VK_FORMAT_BC2_UNORM_BLOCK,
+        VK_FORMAT_BC2_SRGB_BLOCK,
+        VK_FORMAT_BC3_UNORM_BLOCK,
+        VK_FORMAT_BC3_SRGB_BLOCK,
+        VK_FORMAT_BC4_UNORM_BLOCK,
+        VK_FORMAT_BC4_SNORM_BLOCK,
+        VK_FORMAT_BC5_UNORM_BLOCK,
+        VK_FORMAT_BC5_SNORM_BLOCK,
+        VK_FORMAT_BC6H_UFLOAT_BLOCK,
+        VK_FORMAT_BC6H_SFLOAT_BLOCK,
+        VK_FORMAT_BC7_UNORM_BLOCK,
+        VK_FORMAT_BC7_SRGB_BLOCK,
+        VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
+        VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
+        VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
+        VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
+        VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
+        VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
+        VK_FORMAT_EAC_R11_UNORM_BLOCK,
+        VK_FORMAT_EAC_R11_SNORM_BLOCK,
+        VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
+        VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
+        VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
+        VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
+        VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
+        VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
+        VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
+        VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
+        VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
+        VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
+        VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
+        VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
+        VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
+        VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
+        VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
+        VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
+        VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
+        VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
+        VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
+        VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
+        VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
+        VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
+        VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
+        VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
+        VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
+        VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
+        VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
+        VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
+        VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
+        VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
+        VK_FORMAT_G8B8G8R8_422_UNORM,
+        VK_FORMAT_B8G8R8G8_422_UNORM,
+        VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
+        VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
+        VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
+        VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
+        VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
+        VK_FORMAT_R10X6_UNORM_PACK16,
+        VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
+        VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
+        VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
+        VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
+        VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
+        VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
+        VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
+        VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
+        VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
+        VK_FORMAT_R12X4_UNORM_PACK16,
+        VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
+        VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
+        VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
+        VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
+        VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
+        VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
+        VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
+        VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
+        VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
+        VK_FORMAT_G16B16G16R16_422_UNORM,
+        VK_FORMAT_B16G16R16G16_422_UNORM,
+        VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
+        VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
+        VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
+        VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
+        VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
+        VK_FORMAT_G8_B8R8_2PLANE_444_UNORM,
+        VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16,
+        VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16,
+        VK_FORMAT_G16_B16R16_2PLANE_444_UNORM,
+        VK_FORMAT_A4R4G4B4_UNORM_PACK16,
+        VK_FORMAT_A4B4G4R4_UNORM_PACK16,
+        VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK,
+        VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK,
+        VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG,
+        VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG,
+        VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG,
+        VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG,
+        VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG,
+        VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
+        VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
+        VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG,
+// Not supported (yet) by bluevk
+//        VK_FORMAT_R16G16_SFIXED5_NV,
+//        VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR,
+//        VK_FORMAT_A8_UNORM_KHR,
+//        VK_FORMAT_A8_UNORM,
+        VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT,
+        VK_FORMAT_G8B8G8R8_422_UNORM_KHR,
+        VK_FORMAT_B8G8R8G8_422_UNORM_KHR,
+        VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR,
+        VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR,
+        VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR,
+        VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR,
+        VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR,
+        VK_FORMAT_R10X6_UNORM_PACK16_KHR,
+        VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR,
+        VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR,
+        VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR,
+        VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR,
+        VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR,
+        VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR,
+        VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR,
+        VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR,
+        VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR,
+        VK_FORMAT_R12X4_UNORM_PACK16_KHR,
+        VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR,
+        VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR,
+        VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR,
+        VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR,
+        VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR,
+        VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR,
+        VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR,
+        VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR,
+        VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR,
+        VK_FORMAT_G16B16G16R16_422_UNORM_KHR,
+        VK_FORMAT_B16G16R16G16_422_UNORM_KHR,
+        VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR,
+        VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR,
+        VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR,
+        VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR,
+        VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR,
+        VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT,
+        VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT,
+        VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT,
+        VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT,
+        VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT,
+        VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT,
+        VK_FORMAT_R16G16_S10_5_NV,
+};
+
 // An Array that will be fixed capacity, but the "size" (as in user added elements) is variable.
 // Note that this class is movable.
 template<typename T, uint16_t CAPACITY>
@@ -281,6 +590,7 @@ struct DescriptorSetLayout {

 } // namespace descset

+namespace {
 // Use constexpr to statically generate a bit count table for 8-bit numbers.
 struct _BitCountHelper {
    constexpr _BitCountHelper() : data{} {
@@ -303,14 +613,15 @@ struct _BitCountHelper {
        return count;
    }

-    static _BitCountHelper BitCounter;
 private:
    uint8_t data[256];
 };
+} // namespace anonymous

 template<typename MaskType>
 inline uint8_t countBits(MaskType num) {
-    return _BitCountHelper::BitCounter.count(num);
+    static _BitCountHelper BitCounter = {};
+    return BitCounter.count(num);
 }

 // This is useful for counting the total number of descriptors for both vertex and fragment stages.
@@ -42,8 +42,6 @@ constexpr uint8_t MAX_INPUT_ATTACHMENT_BINDING = 1;
 constexpr uint8_t MAX_BINDINGS =
        MAX_SAMPLER_BINDING + MAX_UBO_BINDING + MAX_INPUT_ATTACHMENT_BINDING;

-using ImgUtil = VulkanImageUtility;
-
 using Bitmask = VulkanDescriptorSetLayout::Bitmask;
 using DescriptorCount = VulkanDescriptorSetLayout::Count;
 using UBOMap = std::array<std::pair<VkDescriptorBufferInfo, VulkanBufferObject*>, MAX_UBO_BINDING>;
@@ -80,7 +78,8 @@ public:
          mCount(count),
          mCapacity(capacity),
          mSize(0),
-          mUnusedCount(0) {
+          mUnusedCount(0),
+          mDisableRecycling(false) {
        DescriptorCount const actual = mCount * capacity;
        VkDescriptorPoolSize sizes[4];
        uint8_t npools = 0;
@@ -111,7 +110,7 @@ public:
        VkDescriptorPoolCreateInfo info{
            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
            .pNext = nullptr,
-            .flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
+            .flags = 0,
            .maxSets = capacity,
            .poolSizeCount = npools,
            .pPoolSizes = sizes,
@@ -123,9 +122,19 @@ public:
    DescriptorPool& operator=(DescriptorPool const&) = delete;

    ~DescriptorPool() {
+        // Note that these have to manually destroyed because they were not explicitly ref-counted.
+        for (auto const& [mask, sets]: mUnused) {
+            for (auto set: sets) {
+                mAllocator->destruct<VulkanDescriptorSet>(set);
+            }
+        }
        vkDestroyDescriptorPool(mDevice, mPool, VKALLOC);
    }

+    void disableRecycling() noexcept {
+        mDisableRecycling = true;
+    }
+
    uint16_t const& capacity() {
        return mCapacity;
    }
@@ -172,6 +181,9 @@ private:
    Handle<VulkanDescriptorSet> createSet(Bitmask const& layoutMask, VkDescriptorSet vkSet) {
        return mAllocator->initHandle<VulkanDescriptorSet>(mAllocator, vkSet,
                [this, layoutMask, vkSet]() {
+                    if (mDisableRecycling) {
+                        return;
+                    }
                    // We are recycling - release the set back into the pool. Note that the
                    // vk handle has not changed, but we need to change the backend handle to allow
                    // for proper refcounting of resources referenced in this set.
@@ -200,6 +212,8 @@ private:
    using UnusedSetMap = std::unordered_map<Bitmask, std::vector<Handle<VulkanDescriptorSet>>,
            BitmaskHashFn, BitmaskEqual>;
    UnusedSetMap mUnused;
+
+    bool mDisableRecycling;
 };

 // This is an ever-expanding pool of sets where it
@@ -244,6 +258,12 @@ public:
        return ret;
    }

+    void disableRecycling() noexcept {
+        for (auto& pool: mPools) {
+            pool->disableRecycling();
+        }
+    }
+
 private:
    VkDevice mDevice;
    VulkanResourceAllocator* mAllocator;
@@ -267,21 +287,19 @@ public:

    ~LayoutCache() {
        for (auto [key, layout]: mLayouts) {
-            auto layoutPtr = mAllocator->handle_cast<VulkanDescriptorSetLayout*>(layout);
-            vkDestroyDescriptorSetLayout(mDevice, layoutPtr->vklayout, VKALLOC);
+            mAllocator->destruct<VulkanDescriptorSetLayout>(layout);
        }
        mLayouts.clear();
    }

    void destroyLayout(Handle<VulkanDescriptorSetLayout> handle) {
-        auto layoutPtr = mAllocator->handle_cast<VulkanDescriptorSetLayout*>(handle);
        for (auto [key, layout]: mLayouts) {
            if (layout == handle) {
                mLayouts.erase(key);
                break;
            }
        }
-        vkDestroyDescriptorSetLayout(mDevice, layoutPtr->vklayout, VKALLOC);
+        mAllocator->destruct<VulkanDescriptorSetLayout>(handle);
    }

    Handle<VulkanDescriptorSetLayout> getLayout(descset::DescriptorSetLayout const& layout) {
@@ -339,10 +357,8 @@ public:
                .bindingCount = count,
                .pBindings = toBind,
        };
-
-        VkDescriptorSetLayout outLayout;
-        vkCreateDescriptorSetLayout(mDevice, &dlinfo, VKALLOC, &outLayout);
-        return (mLayouts[key] = mAllocator->initHandle<VulkanDescriptorSetLayout>(outLayout, key));
+        return (mLayouts[key] =
+                        mAllocator->initHandle<VulkanDescriptorSetLayout>(mDevice, dlinfo, key));
    }

 private:
@@ -416,7 +432,7 @@ struct SamplerKey {
                ret.sampler[count] = info.sampler;
                ret.imageView[count] = info.imageView;
                ret.imageLayout[count] = info.imageLayout;
-            }// else keep them as VK_NULL_HANDLEs.
+            } // else keep them as VK_NULL_HANDLEs.
            count++;
        }
        return ret;
@@ -431,16 +447,16 @@ struct SamplerKey {
 struct InputAttachmentKey {
    // This count should be fixed.
    uint8_t count;
-    uint8_t padding[7];
-    VkImageView view = VK_NULL_HANDLE;
+    uint8_t padding[3];
    VkImageLayout imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+    VkImageView view = VK_NULL_HANDLE;

    static inline InputAttachmentKey key(VkDescriptorImageInfo const& info,
            VulkanDescriptorSetLayout* layout) {
        return {
                .count = (uint8_t) layout->count.inputAttachment,
-                .view = info.imageView,
                .imageLayout = info.imageLayout,
+                .view = info.imageView,
        };
    }

@@ -627,29 +643,40 @@ class DescriptorSetCache {
 public:
    DescriptorSetCache(VkDevice device, VulkanResourceAllocator* allocator)
        : mAllocator(allocator),
-          mDescriptorPool(device, allocator),
-          mUBOCache(allocator),
-          mSamplerCache(allocator),
-          mInputAttachmentCache(allocator) {}
+          mDescriptorPool(std::make_unique<DescriptorInfinitePool>(device, allocator)),
+          mUBOCache(std::make_unique<LRUDescriptorSetCache<UBOKey>>(allocator)),
+          mSamplerCache(std::make_unique<LRUDescriptorSetCache<SamplerKey>>(allocator)),
+          mInputAttachmentCache(
+                  std::make_unique<LRUDescriptorSetCache<InputAttachmentKey>>(allocator)) {}

    template<typename Key>
    inline std::pair<VulkanDescriptorSet*, bool> get(Key const& key,
            VulkanDescriptorSetLayout* layout) {
        if constexpr (std::is_same_v<Key, UBOKey>) {
-            return get(key, mUBOCache, layout);
+            return get(key, *mUBOCache, layout);
        } else if constexpr (std::is_same_v<Key, SamplerKey>) {
-            return get(key, mSamplerCache, layout);
+            return get(key, *mSamplerCache, layout);
        } else if constexpr (std::is_same_v<Key, InputAttachmentKey>) {
-            return get(key, mInputAttachmentCache, layout);
+            return get(key, *mInputAttachmentCache, layout);
        }
        PANIC_POSTCONDITION("Unexpected key type");
    }

+    ~DescriptorSetCache() {
+        // This will prevent the descriptor sets recycling when we destroy descriptor set caches.
+        mDescriptorPool->disableRecycling();
+
+        mInputAttachmentCache.reset();
+        mSamplerCache.reset();
+        mUBOCache.reset();
+        mDescriptorPool.reset();
+    }
+
    // gc() should be called at the end of everyframe
    void gc() {
-        mUBOCache.gc();
-        mSamplerCache.gc();
-        mInputAttachmentCache.gc();
+        mUBOCache->gc();
+        mSamplerCache->gc();
+        mInputAttachmentCache->gc();
    }

 private:
@@ -660,16 +687,18 @@ private:
            return {set, true};
        }
        auto set = mAllocator->handle_cast<VulkanDescriptorSet*>(
-            mDescriptorPool.obtainSet(layout));
+            mDescriptorPool->obtainSet(layout));
        cache.put(key, set);
        return {set, false};
    }

    VulkanResourceAllocator* mAllocator;
-    DescriptorInfinitePool mDescriptorPool;
-    LRUDescriptorSetCache<UBOKey> mUBOCache;
-    LRUDescriptorSetCache<SamplerKey> mSamplerCache;
-    LRUDescriptorSetCache<InputAttachmentKey> mInputAttachmentCache;
+
+    // We need to heap-allocate so that the destruction can be strictly ordered.
+    std::unique_ptr<DescriptorInfinitePool> mDescriptorPool;
+    std::unique_ptr<LRUDescriptorSetCache<UBOKey>> mUBOCache;
+    std::unique_ptr<LRUDescriptorSetCache<SamplerKey>> mSamplerCache;
+    std::unique_ptr<LRUDescriptorSetCache<InputAttachmentKey>> mInputAttachmentCache;
 };

 } // anonymous namespace
@@ -746,25 +775,38 @@ public:
            mLayoutStash[program] = layouts;
        }

+        VulkanDescriptorSetLayoutList outLayouts = layouts;
        DescriptorSetVkHandles vkDescSets = initDescSetHandles();
        VkWriteDescriptorSet descriptorWrites[MAX_BINDINGS];
        uint32_t nwrites = 0;

+        // Use placeholders when necessary
        for (uint8_t i = 0; i < VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT; ++i) {
-            auto handle = layouts[i];
-            if (!handle) {
-                assert_invariant(i == INPUT_ATTACHMENT_SET_ID
-                                 && "Unexpectedly absent descriptor set layout");
+            if (!layouts[i]) {
+                if (i == INPUT_ATTACHMENT_SET_ID ||
+                        (i == SAMPLER_SET_ID && !layouts[INPUT_ATTACHMENT_SET_ID])) {
+                    continue;
+                }
+                outLayouts[i] = getPlaceHolderLayout(i);
+            } else {
+                outLayouts[i] = layouts[i];
+                auto p = mAllocator->handle_cast<VulkanDescriptorSetLayout*>(layouts[i]);
+                if (!((i == UBO_SET_ID && p->bitmask.ubo)
+                        || (i == SAMPLER_SET_ID && p->bitmask.sampler)
+                        || (i == INPUT_ATTACHMENT_SET_ID && p->bitmask.inputAttachment
+                                && mInputAttachment.first.texture))) {
+                    outLayouts[i] = getPlaceHolderLayout(i);
+                }
+            }
+        }
+
+        for (uint8_t i = 0; i < VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT; ++i) {
+            if (!outLayouts[i]) {
                continue;
            }
            VulkanDescriptorSetLayout* layout
-                    = mAllocator->handle_cast<VulkanDescriptorSetLayout*>(handle);
-            if (!((i == UBO_SET_ID && layout->bitmask.ubo)
-                        || (i == SAMPLER_SET_ID && layout->bitmask.sampler)
-                        || (i == INPUT_ATTACHMENT_SET_ID && layout->bitmask.inputAttachment
-                                && mInputAttachment.first.texture))) {
-                continue;
-            }
+                    = mAllocator->handle_cast<VulkanDescriptorSetLayout*>(outLayouts[i]);
+            bool const usePlaceholder = layouts[i] != outLayouts[i];

            auto const& [set, cached] = getSet(i, layout);
            VkDescriptorSet const vkSet = set->vkSet;
@@ -773,7 +815,8 @@ public:

            // Note that we still need to bind the set, but 'cached' means that we found a set with
            // the exact same content already written, and we would just bind that one instead.
-            if (cached) {
+            // We also don't need to write to the placeholder set.
+            if (cached || usePlaceholder) {
                continue;
            }

@@ -836,7 +879,7 @@ public:
            vkUpdateDescriptorSets(mDevice, nwrites, descriptorWrites, 0, nullptr);
        }

-        VkPipelineLayout const pipelineLayout = getPipelineLayoutFn(layouts);
+        VkPipelineLayout const pipelineLayout = getPipelineLayoutFn(outLayouts, program);
        VkCommandBuffer const cmdbuffer = commands->buffer();

        BoundState state{};
@@ -918,6 +961,10 @@ public:
        FVK_SYSTRACE_END();
    }

+    void clearProgram(VulkanProgram* program) noexcept {
+        mLayoutStash.erase(program);
+    }
+
    Handle<VulkanDescriptorSetLayout> createLayout(
            descset::DescriptorSetLayout const& description) {
        return mLayoutCache.getLayout(description);
@@ -961,15 +1008,15 @@ public:
        } else {
            info.imageView = texture->getViewForType(range, expectedType);
        }
-        info.imageLayout = ImgUtil::getVkLayout(texture->getPrimaryImageLayout());
+        info.imageLayout = imgutil::getVkLayout(texture->getPrimaryImageLayout());
        mSamplerMap[binding] = {info, texture};
        mResources.acquire(texture);
    }

    void updateInputAttachment(Handle<VulkanDescriptorSet>, VulkanAttachment attachment) noexcept {
        VkDescriptorImageInfo info = {
-                .imageView = attachment.getImageView(VK_IMAGE_ASPECT_COLOR_BIT),
-                .imageLayout = ImgUtil::getVkLayout(attachment.getLayout()),
+                .imageView = attachment.getImageView(),
+                .imageLayout = imgutil::getVkLayout(attachment.getLayout()),
        };
        mInputAttachment = {attachment, info};
        mResources.acquire(attachment.texture);
@@ -993,7 +1040,7 @@ public:
        mPlaceHolderImageInfo = {
                .sampler = sampler,
                .imageView = texture->getPrimaryImageView(),
-                .imageLayout = ImgUtil::getVkLayout(texture->getPrimaryImageLayout()),
+                .imageLayout = imgutil::getVkLayout(texture->getPrimaryImageLayout()),
        };
    }

@@ -1031,25 +1078,62 @@ private:
        }
    }

+    inline Handle<VulkanDescriptorSetLayout> getPlaceHolderLayout(uint8_t setID) {
+        if (mPlaceholderLayout[setID]) {
+            return mPlaceholderLayout[setID];
+        }
+        descset::DescriptorSetLayout inputLayout {
+                .bindings = {{}},
+        };
+        switch (setID) {
+            case UBO_SET_ID:
+                inputLayout.bindings[0] = {
+                        .type = descset::DescriptorType::UNIFORM_BUFFER,
+                        .stageFlags = descset::ShaderStageFlags2::VERTEX,
+                        .binding = 0,
+                        .flags = descset::DescriptorFlags::NONE,
+                        .count = 0,
+                };
+                break;
+            case SAMPLER_SET_ID:
+                inputLayout.bindings[0] = {
+                        .type = descset::DescriptorType::SAMPLER,
+                        .stageFlags = descset::ShaderStageFlags2::FRAGMENT,
+                        .binding = 0,
+                        .flags = descset::DescriptorFlags::NONE,
+                        .count = 0,
+                };
+                break;
+            case INPUT_ATTACHMENT_SET_ID:
+                inputLayout.bindings[0] = {
+                        .type = descset::DescriptorType::INPUT_ATTACHMENT,
+                        .stageFlags = descset::ShaderStageFlags2::FRAGMENT,
+                        .binding = 0,
+                        .flags = descset::DescriptorFlags::NONE,
+                        .count = 0,
+                };
+                break;
+            default:
+                PANIC_POSTCONDITION("Unexpected set id=%d", setID);
+        }
+        mPlaceholderLayout[setID] = mLayoutCache.getLayout(inputLayout);
+        return mPlaceholderLayout[setID];
+    }
+
    VkDevice mDevice;
    VulkanResourceAllocator* mAllocator;
    LayoutCache mLayoutCache;
    DescriptorSetCache mDescriptorSetCache;
-
    bool mHaveDynamicUbos;
-
    UBOMap mUboMap;
    SamplerMap mSamplerMap;
    std::pair<VulkanAttachment, VkDescriptorImageInfo> mInputAttachment;
-
    VulkanResourceManager mResources;
-
    VkDescriptorBufferInfo mPlaceHolderBufferInfo;
    VkDescriptorImageInfo mPlaceHolderImageInfo;
-
    std::unordered_map<VulkanProgram*, VulkanDescriptorSetLayoutList> mLayoutStash;
-
    BoundState mBoundState;
+    VulkanDescriptorSetLayoutList mPlaceholderLayout = {};
 };

 VulkanDescriptorSetManager::VulkanDescriptorSetManager(VkDevice device,
@@ -1077,6 +1161,10 @@ void VulkanDescriptorSetManager::dynamicBind(VulkanCommandBuffer* commands,
    mImpl->dynamicBind(commands, uboLayout);
 }

+void VulkanDescriptorSetManager::clearProgram(VulkanProgram* program) noexcept {
+    mImpl->clearProgram(program);
+}
+
 Handle<VulkanDescriptorSetLayout> VulkanDescriptorSetManager::createLayout(
        descset::DescriptorSetLayout const& layout) {
    return mImpl->createLayout(layout);
@@ -45,8 +45,8 @@ class VulkanDescriptorSetManager {
 public:
    static constexpr uint8_t UNIQUE_DESCRIPTOR_SET_COUNT =
            VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT;
-    using GetPipelineLayoutFunction =
-            std::function<VkPipelineLayout(VulkanDescriptorSetLayoutList const&)>;
+    using GetPipelineLayoutFunction = std::function<VkPipelineLayout(
+            VulkanDescriptorSetLayoutList const&, VulkanProgram* program)>;

    VulkanDescriptorSetManager(VkDevice device, VulkanResourceAllocator* resourceAllocator);

@@ -69,6 +69,10 @@ public:
    // proper dynamic binding when Filament-side descriptor changes are completed.
    void dynamicBind(VulkanCommandBuffer* commands, Handle<VulkanDescriptorSetLayout> uboLayout);

+    // TODO: Obsolete after [GDSR].
+    // Since we use program pointer as cache key, we need to clear the cache when it's freed.
+    void clearProgram(VulkanProgram* program) noexcept;
+
    Handle<VulkanDescriptorSetLayout> createLayout(descset::DescriptorSetLayout const& layout);

    void destroyLayout(Handle<VulkanDescriptorSetLayout> layout);
@@ -104,3 +108,4 @@ private:
 }// namespace filament::backend

 #endif// TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETMANAGER_H
+
@@ -21,13 +21,34 @@
 namespace filament::backend {

 VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
-        VulkanDescriptorSetLayoutList const& descriptorSetLayouts) {
-    PipelineLayoutKey key = {VK_NULL_HANDLE};
+        VulkanDescriptorSetLayoutList const& descriptorSetLayouts, VulkanProgram* program) {
+    PipelineLayoutKey key = {};
    uint8_t descSetLayoutCount = 0;
-    for (auto layoutHandle : descriptorSetLayouts) {
+    for (auto layoutHandle: descriptorSetLayouts) {
        if (layoutHandle) {
            auto layout = mAllocator->handle_cast<VulkanDescriptorSetLayout*>(layoutHandle);
-            key[descSetLayoutCount++] = layout->vklayout;
+            key.descSetLayouts[descSetLayoutCount++] = layout->vklayout;
+        }
+    }
+
+    // build the push constant layout key
+    uint32_t pushConstantRangeCount = program->getPushConstantRangeCount();
+    auto const& pushCostantRanges = program->getPushConstantRanges();    
+    if (pushConstantRangeCount > 0) {
+        assert_invariant(pushConstantRangeCount <= Program::SHADER_TYPE_COUNT);
+        for (uint8_t i = 0; i < pushConstantRangeCount; ++i) {
+            auto const& range = pushCostantRanges[i];
+            auto& pushConstant = key.pushConstant[i];
+            if (range.stageFlags &  VK_SHADER_STAGE_VERTEX_BIT) {
+                pushConstant.stage = static_cast<uint8_t>(ShaderStage::VERTEX);
+            }
+            if (range.stageFlags &  VK_SHADER_STAGE_FRAGMENT_BIT) {
+                pushConstant.stage = static_cast<uint8_t>(ShaderStage::FRAGMENT);
+            }
+            if (range.stageFlags &  VK_SHADER_STAGE_COMPUTE_BIT) {
+                pushConstant.stage = static_cast<uint8_t>(ShaderStage::COMPUTE);
+            }
+            pushConstant.size = range.size;
        }
    }

@@ -42,9 +63,11 @@ VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
        .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
        .pNext = nullptr,
        .setLayoutCount = (uint32_t) descSetLayoutCount,
-        .pSetLayouts = key.data(),
-        .pushConstantRangeCount = 0,
+        .pSetLayouts = key.descSetLayouts.data(),
+        .pushConstantRangeCount = pushConstantRangeCount,
+        .pPushConstantRanges = pushCostantRanges,
    };
+
    VkPipelineLayout layout;
    vkCreatePipelineLayout(mDevice, &info, VKALLOC, &layout);

@@ -55,4 +78,10 @@ VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
    return layout;
 }

+void VulkanPipelineLayoutCache::terminate() noexcept {
+    for (auto const& [key, entry]: mPipelineLayouts) {
+        vkDestroyPipelineLayout(mDevice, entry.handle, VKALLOC);
+    }
+}
+
 }// namespace filament::backend
@@ -33,13 +33,31 @@ public:
          mAllocator(allocator),
          mTimestamp(0) {}

-    using PipelineLayoutKey = std::array<VkDescriptorSetLayout,
-            VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;
+    void terminate() noexcept;
+
+    struct PushConstantKey {
+        uint8_t stage;// We have one set of push constant per shader stage (fragment, vertex, etc).
+        uint8_t size;
+        // Note that there is also an offset parameter for push constants, but
+        // we always assume our update range will have the offset 0.
+    };
+
+    struct PipelineLayoutKey {
+        using DescriptorSetLayoutArray = std::array<VkDescriptorSetLayout,
+                VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;
+        DescriptorSetLayoutArray descSetLayouts = {};                   // 8 * 3
+        PushConstantKey pushConstant[Program::SHADER_TYPE_COUNT] = {};  // 2 * 3
+        uint16_t padding = 0;
+    };
+    static_assert(sizeof(PipelineLayoutKey) == 32);

    VulkanPipelineLayoutCache(VulkanPipelineLayoutCache const&) = delete;
    VulkanPipelineLayoutCache& operator=(VulkanPipelineLayoutCache const&) = delete;

-    VkPipelineLayout getLayout(VulkanDescriptorSetLayoutList const& descriptorSetLayouts);
+    // A pipeline layout depends on the descriptor set layout and the push constant ranges, which
+    // are described in the program.
+    VkPipelineLayout getLayout(VulkanDescriptorSetLayoutList const& descriptorSetLayouts,
+            VulkanProgram* program);

 private:
    using Timestamp = uint64_t;
@@ -137,18 +137,14 @@ void printDepthFormats(VkPhysicalDevice device) {
    const VkFormatFeatureFlags required = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
                                              | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
    utils::slog.i << "Sampleable depth formats: ";
-    for (VkFormat format = (VkFormat) 1;;) {
+    for (VkFormat format : ALL_VK_FORMATS) {
        VkFormatProperties props;
        vkGetPhysicalDeviceFormatProperties(device, format, &props);
        if ((props.optimalTilingFeatures & required) == required) {
            utils::slog.i << format << " ";
        }
-        if (format == VK_FORMAT_ASTC_12x12_SRGB_BLOCK) {
-            utils::slog.i << utils::io::endl;
-            break;
-        }
-        format = (VkFormat) (1 + (int) format);
    }
+    utils::slog.i << utils::io::endl;
 }
 #endif

@@ -257,6 +253,7 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
    // Create the Vulkan instance.
    VkApplicationInfo appInfo = {};
    appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+    appInfo.pEngineName = "Filament";
    appInfo.apiVersion
            = VK_MAKE_API_VERSION(0, FVK_REQUIRED_VERSION_MAJOR, FVK_REQUIRED_VERSION_MINOR, 0);
    instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
@@ -343,13 +340,13 @@ std::tuple<ExtensionSet, ExtensionSet> pruneExtensions(VkPhysicalDevice device,
    ExtensionSet newInstExts = instExts;
    ExtensionSet newDeviceExts = deviceExts;

-#if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)    
+#if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
    // debugUtils and debugMarkers extensions are used mutually exclusively.
    if (newInstExts.find(VK_EXT_DEBUG_UTILS_EXTENSION_NAME) != newInstExts.end()
            && newDeviceExts.find(VK_EXT_DEBUG_MARKER_EXTENSION_NAME) != newDeviceExts.end()) {
        newDeviceExts.erase(VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
    }
-#endif    
+#endif

 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
    // debugMarker must also request debugReport the instance extension. So check if that's present.
@@ -404,7 +401,7 @@ inline int deviceTypeOrder(VkPhysicalDeviceType deviceType) {
        case VK_PHYSICAL_DEVICE_TYPE_OTHER:
            return 1;
        default:
-            utils::slog.w << "devcieTypeOrder: Unexpected deviceType: " << deviceType
+            utils::slog.w << "deviceTypeOrder: Unexpected deviceType: " << deviceType
                          << utils::io::endl;
            return -1;
    }
@@ -499,7 +496,7 @@ VkPhysicalDevice selectPhysicalDevice(VkInstance instance,
    return device;
 }

-VkFormatList findAttachmentDepthFormats(VkPhysicalDevice device) {
+VkFormatList findAttachmentDepthStencilFormats(VkPhysicalDevice device) {
    VkFormatFeatureFlags const features = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;

    // The ordering here indicates the preference of choosing depth+stencil format.
@@ -523,6 +520,24 @@ VkFormatList findAttachmentDepthFormats(VkPhysicalDevice device) {
    return ret;
 }

+VkFormatList findBlittableDepthStencilFormats(VkPhysicalDevice device) {
+    std::vector<VkFormat> selectedFormats;
+    VkFormatFeatureFlags const required = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT |
+            VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
+    for (VkFormat format : ALL_VK_FORMATS) {
+        if (isVkDepthFormat(format)) {
+            VkFormatProperties props;
+            vkGetPhysicalDeviceFormatProperties(device, format, &props);
+            if ((props.optimalTilingFeatures & required) == required) {
+                selectedFormats.push_back(format);
+            }
+        }
+    }
+    VkFormatList ret(selectedFormats.size());
+    std::copy(selectedFormats.begin(), selectedFormats.end(), ret.begin());
+    return ret;
+}
+
 }// anonymous namespace

 using SwapChainPtr = VulkanPlatform::SwapChainPtr;
@@ -668,9 +683,11 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
            "Debug utils should not be enabled in release build.");
 #endif

-    context.mDepthFormats = findAttachmentDepthFormats(mImpl->mPhysicalDevice);
+    context.mDepthStencilFormats = findAttachmentDepthStencilFormats(mImpl->mPhysicalDevice);
+    context.mBlittableDepthStencilFormats =
+            findBlittableDepthStencilFormats(mImpl->mPhysicalDevice);

-    assert_invariant(context.mDepthFormats.size() > 0);
+    assert_invariant(context.mDepthStencilFormats.size() > 0);

 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
    printDepthFormats(mImpl->mPhysicalDevice);
@@ -243,7 +243,7 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
    mSwapChainBundle.colors = enumerate(vkGetSwapchainImagesKHR, mDevice, mSwapchain);
    mSwapChainBundle.colorFormat = surfaceFormat.format;
    mSwapChainBundle.depthFormat =
-            selectDepthFormat(mContext.getAttachmentDepthFormats(), mHasStencil);
+            selectDepthFormat(mContext.getAttachmentDepthStencilFormats(), mHasStencil);
    mSwapChainBundle.depth = createImage(mSwapChainBundle.extent, mSwapChainBundle.depthFormat);

    slog.i << "vkCreateSwapchain"
@@ -330,7 +330,7 @@ VulkanPlatformHeadlessSwapChain::VulkanPlatformHeadlessSwapChain(VulkanContext c

    bool const hasStencil = (flags & backend::SWAP_CHAIN_HAS_STENCIL_BUFFER) != 0;
    mSwapChainBundle.depthFormat =
-            selectDepthFormat(mContext.getAttachmentDepthFormats(), hasStencil);
+            selectDepthFormat(mContext.getAttachmentDepthStencilFormats(), hasStencil);
    mSwapChainBundle.depth = createImage(extent, mSwapChainBundle.depthFormat);
 }

@@ -183,7 +183,7 @@ std::tuple<uint32_t,uint32_t, uint32_t> getProgramBindings(Program::ShaderBlob c
    constexpr uint32_t IATTACHMENT = 2;
    uint32_t ubo = 0, sampler = 0, inputAttachment = 0;

-    for (auto const [target, setId]: targetToSet) {
+    for (auto const& [target, setId]: targetToSet) {
        uint32_t const binding = targetToBinding[target];
        assert_invariant(binding < 32);
        switch(setId) {
@@ -79,6 +79,20 @@ ShaderGenerator::ShaderGenerator(std::string vertex, std::string fragment,
          mVertexBlob(transpileShader(ShaderStage::VERTEX, std::move(vertex), backend, isMobile, sib)),
          mFragmentBlob(transpileShader(ShaderStage::FRAGMENT, std::move(fragment), backend,
                  isMobile, sib)) {
+    switch (backend) {
+        case Backend::OPENGL:
+            mShaderLanguage = filament::backend::ShaderLanguage::ESSL3;
+            break;
+        case Backend::VULKAN:
+            mShaderLanguage = filament::backend::ShaderLanguage::SPIRV;
+            break;
+        case Backend::METAL:
+            mShaderLanguage = filament::backend::ShaderLanguage::MSL;
+            break;
+        case Backend::NOOP:
+            mShaderLanguage = filament::backend::ShaderLanguage::ESSL3;
+            break;
+    }
 }

 ShaderGenerator::Blob ShaderGenerator::transpileShader(
@@ -160,6 +174,7 @@ ShaderGenerator::Blob ShaderGenerator::transpileShader(

 Program ShaderGenerator::getProgram(filament::backend::DriverApi&) noexcept {
    Program program;
+    program.shaderLanguage(mShaderLanguage);
    program.shader(ShaderStage::VERTEX, mVertexBlob.data(), mVertexBlob.size());
    program.shader(ShaderStage::FRAGMENT, mFragmentBlob.data(), mFragmentBlob.size());
    return program;
@@ -60,6 +60,7 @@ private:
    Blob mFragmentBlob;
    std::string mCompiledVertexShader;
    std::string mCompiledFragmentShader;
+    filament::backend::ShaderLanguage mShaderLanguage;

 };

@@ -238,13 +238,13 @@ TEST_F(BackendTest, ColorMagnify) {
            {0, 0, kSrcTexWidth >> srcLevel, kSrcTexHeight >> srcLevel}, SamplerMagFilter::LINEAR);

    // Push through an empty frame to allow the texture to upload and the blit to execute.
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);
    api.commit(swapChain);
    api.endFrame(0);

    // Grab a screenshot.
    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "ColorMagnify.png" };
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);
    dumpScreenshot(api, dstRenderTargets[0], &params);
    api.commit(swapChain);
    api.endFrame(0);
@@ -402,7 +402,7 @@ TEST_F(BackendTest, ColorResolve) {
    });

    // FIXME: on Metal this triangle is not drawn. Can't understand why.
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);
        api.beginRenderPass(srcRenderTarget, params);
            api.bindUniformBuffer(0, ubuffer);
            api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
@@ -484,13 +484,13 @@ TEST_F(BackendTest, Blit2DTextureArray) {
            {0, 0, kSrcTexWidth >> srcLevel, kSrcTexHeight >> srcLevel}, SamplerMagFilter::LINEAR);

    // Push through an empty frame to allow the texture to upload and the blit to execute.
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);
    api.commit(swapChain);
    api.endFrame(0);

    // Grab a screenshot.
    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "Blit2DTextureArray.png" };
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);
    dumpScreenshot(api, dstRenderTarget, &params);
    api.commit(swapChain);
    api.endFrame(0);
@@ -574,13 +574,13 @@ TEST_F(BackendTest, BlitRegion) {
            SamplerMagFilter::LINEAR);

    // Push through an empty frame to allow the texture to upload and the blit to execute.
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);
    api.commit(swapChain);
    api.endFrame(0);

    // Grab a screenshot.
    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "BlitRegion.png" };
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);
    dumpScreenshot(api, dstRenderTarget, &params);
    api.commit(swapChain);
    api.endFrame(0);
@@ -655,7 +655,7 @@ TEST_F(BackendTest, BlitRegionToSwapChain) {
        .height = kDstTexHeight - 10,
    };

-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);

    api.blitDEPRECATED(TargetBufferFlags::COLOR0, dstRenderTarget,
            dstRect, srcRenderTargets[srcLevel],
@@ -143,7 +143,7 @@ TEST_F(BackendTest, VertexBufferUpdate) {
        }

        getDriverApi().makeCurrent(swapChain, swapChain);
-        getDriverApi().beginFrame(0, 0);
+        getDriverApi().beginFrame(0, 0, 0);

        // Draw 10 triangles, updating the vertex buffer / index buffer each time.
        size_t triangleIndex = 0;
@@ -58,6 +58,7 @@ kernel void main0() {}
    }

    Program program;
+    program.shaderLanguage(ShaderLanguage::ESSL3);
    program.shader(ShaderStage::COMPUTE, shader.data(), shader.size() + 1);

    Handle<HwProgram> ph = driver.createProgram(std::move(program));
@@ -144,6 +145,7 @@ kernel void main0(device Output_data& output_data [[buffer(0)]],
    driver.updateBufferObject(input_data, { data.data(), size }, 0);

    Program program;
+    program.shaderLanguage(ShaderLanguage::ESSL3);
    program.shader(ShaderStage::COMPUTE, shader.data(), shader.size() + 1);
    Handle<HwProgram> ph = driver.createProgram(std::move(program));

@@ -200,7 +200,7 @@ TEST_F(BackendTest, FeedbackLoops) {
            auto ubuffer = api.createBufferObject(sizeof(MaterialParams),
                    BufferObjectBinding::UNIFORM, BufferUsage::STATIC);
            api.makeCurrent(swapChain, swapChain);
-            api.beginFrame(0, 0);
+            api.beginFrame(0, 0, 0);
            api.bindSamplers(0, sgroup);
            api.bindUniformBuffer(0, ubuffer);

@@ -265,7 +265,7 @@ TEST_F(BackendTest, FeedbackLoops) {
        for (auto rt : renderTargets)  api.destroyRenderTarget(rt);
    }

-    const uint32_t expected = 0xe93a4a07;
+    const uint32_t expected = 0x70695aa1;
    printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", sPixelHashResult, expected);
    EXPECT_TRUE(sPixelHashResult == expected);
 }
@@ -414,7 +414,7 @@ TEST_F(BackendTest, UpdateImageSRGB) {

    api.update3DImage(texture, 0, 0, 0, 0, 512, 512, 1, std::move(descriptor));

-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);

    // Update samplers.
    SamplerGroup samplers(1);
@@ -486,7 +486,7 @@ TEST_F(BackendTest, UpdateImageMipLevel) {
    PixelBufferDescriptor descriptor = checkerboardPixelBuffer(pixelFormat, pixelType, 512);
    api.update3DImage(texture, /* level*/ 1, 0, 0, 0, 512, 512, 1, std::move(descriptor));

-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);

    // Update samplers.
    SamplerGroup samplers(1);
@@ -570,7 +570,7 @@ TEST_F(BackendTest, UpdateImage3D) {

    api.update3DImage(texture, 0, 0, 0, 0, 512, 512, 4, std::move(descriptor));

-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);

    // Update samplers.
    SamplerGroup samplers(1);
@@ -127,7 +127,7 @@ TEST_F(BackendTest, MRT) {
        getDriverApi().startCapture(0);

        getDriverApi().makeCurrent(swapChain, swapChain);
-        getDriverApi().beginFrame(0, 0);
+        getDriverApi().beginFrame(0, 0, 0);

        // Draw a triangle.
        getDriverApi().beginRenderPass(renderTarget, params);
@@ -143,7 +143,7 @@ TEST_F(BackendTest, SetMinMaxLevel) {

        TrianglePrimitive triangle(api);

-        api.beginFrame(0, 0);
+        api.beginFrame(0, 0, 0);

        // We set the base mip to 1, and the max mip to 3
        // Level 0: 128x128 (red)
@@ -100,7 +100,7 @@ TEST_F(BackendTest, MissingRequiredAttributes) {
        getDriverApi().startCapture(0);

        getDriverApi().makeCurrent(swapChain, swapChain);
-        getDriverApi().beginFrame(0, 0);
+        getDriverApi().beginFrame(0, 0, 0);

        // Render a triangle.
        getDriverApi().beginRenderPass(defaultRenderTarget, params);
@@ -295,7 +295,7 @@ TEST_F(ReadPixelsTest, ReadPixels) {
        params.viewport.width = t.getRenderTargetSize();

        getDriverApi().makeCurrent(swapChain, swapChain);
-        getDriverApi().beginFrame(0, 0);
+        getDriverApi().beginFrame(0, 0, 0);

        // Render a white triangle over blue.
        getDriverApi().beginRenderPass(renderTarget, params);
@@ -434,7 +434,7 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
        }

        getDriverApi().makeCurrent(swapChain, swapChain);
-        getDriverApi().beginFrame(0, 0);
+        getDriverApi().beginFrame(0, 0, 0);

        // Render some content, just so we don't read back uninitialized data.
        getDriverApi().beginRenderPass(renderTarget, params);
@@ -109,7 +109,7 @@ TEST_F(BackendTest, RenderExternalImageWithoutSet) {

    getDriverApi().startCapture(0);
    getDriverApi().makeCurrent(swapChain, swapChain);
-    getDriverApi().beginFrame(0, 0);
+    getDriverApi().beginFrame(0, 0, 0);

    SamplerGroup samplers(1);
    samplers.setSampler(0, { texture, {} });
@@ -231,7 +231,7 @@ TEST_F(BackendTest, RenderExternalImage) {

    getDriverApi().startCapture(0);
    getDriverApi().makeCurrent(swapChain, swapChain);
-    getDriverApi().beginFrame(0, 0);
+    getDriverApi().beginFrame(0, 0, 0);

    SamplerGroup samplers(1);
    samplers.setSampler(0, { texture, {} });
@@ -136,7 +136,7 @@ TEST_F(BackendTest, ScissorViewportRegion) {
        ps.rasterState.depthWrite = false;

        api.makeCurrent(swapChain, swapChain);
-        api.beginFrame(0, 0);
+        api.beginFrame(0, 0, 0);

        api.beginRenderPass(srcRenderTarget, params);
        api.scissor(scissor);
@@ -227,7 +227,7 @@ TEST_F(BackendTest, ScissorViewportEdgeCases) {
        ps.rasterState.depthWrite = false;

        api.makeCurrent(swapChain, swapChain);
-        api.beginFrame(0, 0);
+        api.beginFrame(0, 0, 0);

        api.beginRenderPass(renderTarget, params);
        api.scissor(scissor);
@@ -110,7 +110,7 @@ public:
        ps.stencilState.front.stencilOpDepthStencilPass = StencilOperation::INCR;

        api.makeCurrent(swapChain, swapChain);
-        api.beginFrame(0, 0);
+        api.beginFrame(0, 0, 0);

        api.beginRenderPass(renderTarget, params);
        api.draw(ps, smallTriangle.getRenderPrimitive(), 0, 3, 1);
@@ -237,7 +237,7 @@ TEST_F(BasicStencilBufferTest, StencilBufferMSAA) {
    ps.stencilState.front.stencilOpDepthStencilPass = StencilOperation::INCR;

    api.makeCurrent(swapChain, swapChain);
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);

    api.beginRenderPass(renderTarget0, params);
    api.draw(ps, smallTriangle.getRenderPrimitive(), 0, 3, 1);
@@ -340,6 +340,35 @@ public:
         * Disable backend handles use-after-free checks.
         */
        bool disableHandleUseAfterFreeCheck = false;
+
+        /*
+         * Sets a preferred shader language for Filament to use.
+         *
+         * The Metal backend supports two shader languages: MSL (Metal Shading Language) and
+         * METAL_LIBRARY (precompiled .metallib). This option controls which shader language is
+         * used when materials contain both.
+         *
+         * By default, when preferredShaderLanguage is unset, Filament will prefer METAL_LIBRARY
+         * shaders if present within a material, falling back to MSL. Setting
+         * preferredShaderLanguage to ShaderLanguage::MSL will instead instruct Filament to check
+         * for the presence of MSL in a material first, falling back to METAL_LIBRARY if MSL is not
+         * present.
+         *
+         * When using a non-Metal backend, setting this has no effect.
+         */
+        enum class ShaderLanguage {
+            DEFAULT = 0,
+            MSL = 1,
+            METAL_LIBRARY = 2,
+        };
+        ShaderLanguage preferredShaderLanguage = ShaderLanguage::DEFAULT;
+
+        /*
+         * When the OpenGL ES backend is used, setting this value to true will force a GLES2.0
+         * context if supported by the Platform, or if not, will have the backend pretend
+         * it's a GLES2 context. Ignored on other backends.
+         */
+        bool forceGLES2Context = false;
    };


@@ -800,24 +829,51 @@ public:
    bool destroy(const InstanceBuffer* UTILS_NULLABLE p);   //!< Destroys an InstanceBuffer object.
    void destroy(utils::Entity e);    //!< Destroys all filament-known components from this entity

-    bool isValid(const BufferObject* UTILS_NULLABLE p);        //!< Tells whether a BufferObject object is valid
-    bool isValid(const VertexBuffer* UTILS_NULLABLE p);        //!< Tells whether an VertexBuffer object is valid
-    bool isValid(const Fence* UTILS_NULLABLE p);               //!< Tells whether a Fence object is valid
-    bool isValid(const IndexBuffer* UTILS_NULLABLE p);         //!< Tells whether an IndexBuffer object is valid
-    bool isValid(const SkinningBuffer* UTILS_NULLABLE p);      //!< Tells whether a SkinningBuffer object is valid
-    bool isValid(const MorphTargetBuffer* UTILS_NULLABLE p);   //!< Tells whether a MorphTargetBuffer object is valid
-    bool isValid(const IndirectLight* UTILS_NULLABLE p);       //!< Tells whether an IndirectLight object is valid
-    bool isValid(const Material* UTILS_NULLABLE p);            //!< Tells whether an IndirectLight object is valid
-    bool isValid(const Renderer* UTILS_NULLABLE p);            //!< Tells whether a Renderer object is valid
-    bool isValid(const Scene* UTILS_NULLABLE p);               //!< Tells whether a Scene object is valid
-    bool isValid(const Skybox* UTILS_NULLABLE p);              //!< Tells whether a SkyBox object is valid
-    bool isValid(const ColorGrading* UTILS_NULLABLE p);        //!< Tells whether a ColorGrading object is valid
-    bool isValid(const SwapChain* UTILS_NULLABLE p);           //!< Tells whether a SwapChain object is valid
-    bool isValid(const Stream* UTILS_NULLABLE p);              //!< Tells whether a Stream object is valid
-    bool isValid(const Texture* UTILS_NULLABLE p);             //!< Tells whether a Texture object is valid
-    bool isValid(const RenderTarget* UTILS_NULLABLE p);        //!< Tells whether a RenderTarget object is valid
-    bool isValid(const View* UTILS_NULLABLE p);                //!< Tells whether a View object is valid
-    bool isValid(const InstanceBuffer* UTILS_NULLABLE p);      //!< Tells whether an InstanceBuffer object is valid
+    /** Tells whether a BufferObject object is valid */
+    bool isValid(const BufferObject* UTILS_NULLABLE p) const;
+    /** Tells whether an VertexBuffer object is valid */
+    bool isValid(const VertexBuffer* UTILS_NULLABLE p) const;
+    /** Tells whether a Fence object is valid */
+    bool isValid(const Fence* UTILS_NULLABLE p) const;
+    /** Tells whether an IndexBuffer object is valid */
+    bool isValid(const IndexBuffer* UTILS_NULLABLE p) const;
+    /** Tells whether a SkinningBuffer object is valid */
+    bool isValid(const SkinningBuffer* UTILS_NULLABLE p) const;
+    /** Tells whether a MorphTargetBuffer object is valid */
+    bool isValid(const MorphTargetBuffer* UTILS_NULLABLE p) const;
+    /** Tells whether an IndirectLight object is valid */
+    bool isValid(const IndirectLight* UTILS_NULLABLE p) const;
+    /** Tells whether an Material object is valid */
+    bool isValid(const Material* UTILS_NULLABLE p) const;
+    /** Tells whether an MaterialInstance object is valid. Use this if you already know
+     * which Material this MaterialInstance belongs to. DO NOT USE getMaterial(), this would
+     * defeat the purpose of validating the MaterialInstance.
+     */
+    bool isValid(const Material* UTILS_NONNULL m, const MaterialInstance* UTILS_NULLABLE p) const;
+    /** Tells whether an MaterialInstance object is valid. Use this if the Material the
+     * MaterialInstance belongs to is not known. This method can be expensive.
+     */
+    bool isValidExpensive(const MaterialInstance* UTILS_NULLABLE p) const;
+    /** Tells whether a Renderer object is valid */
+    bool isValid(const Renderer* UTILS_NULLABLE p) const;
+    /** Tells whether a Scene object is valid */
+    bool isValid(const Scene* UTILS_NULLABLE p) const;
+    /** Tells whether a SkyBox object is valid */
+    bool isValid(const Skybox* UTILS_NULLABLE p) const;
+    /** Tells whether a ColorGrading object is valid */
+    bool isValid(const ColorGrading* UTILS_NULLABLE p) const;
+    /** Tells whether a SwapChain object is valid */
+    bool isValid(const SwapChain* UTILS_NULLABLE p) const;
+    /** Tells whether a Stream object is valid */
+    bool isValid(const Stream* UTILS_NULLABLE p) const;
+    /** Tells whether a Texture object is valid */
+    bool isValid(const Texture* UTILS_NULLABLE p) const;
+    /** Tells whether a RenderTarget object is valid */
+    bool isValid(const RenderTarget* UTILS_NULLABLE p) const;
+    /** Tells whether a View object is valid */
+    bool isValid(const View* UTILS_NULLABLE p) const;
+    /** Tells whether an InstanceBuffer object is valid */
+    bool isValid(const InstanceBuffer* UTILS_NULLABLE p) const;

    /**
     * Kicks the hardware thread (e.g. the OpenGL, Vulkan or Metal thread) and blocks until
@@ -840,6 +896,15 @@ public:
      */
    void flush();

+    /**
+     * Get paused state of rendering thread.
+     *
+     * <p>Warning: This is an experimental API.
+     *
+     * @see setPaused
+     */
+    bool isPaused() const noexcept;
+
    /**
     * Pause or resume rendering thread.
     *
@@ -21,6 +21,7 @@

 #include <backend/CallbackHandler.h>
 #include <backend/DriverEnums.h>
+#include <backend/PresentCallable.h>

 #include <utils/compiler.h>
 #include <utils/Invocable.h>
@@ -264,13 +265,22 @@ public:
     * backend.
     *
     * A FrameScheduledCallback can be set on an individual SwapChain through
-     * SwapChain::setFrameScheduledCallback. If the callback is set, then the SwapChain will *not*
-     * automatically schedule itself for presentation. Instead, the application must call the
-     * PresentCallable passed to the FrameScheduledCallback.
+     * SwapChain::setFrameScheduledCallback. If the callback is set for a given frame, then the
+     * SwapChain will *not* automatically schedule itself for presentation. Instead, the application
+     * must call the PresentCallable passed to the FrameScheduledCallback.
     *
-     * There may be only one FrameScheduledCallback set per SwapChain. A call to
-     * SwapChain::setFrameScheduledCallback will overwrite any previous FrameScheduledCallbacks set
-     * on the same SwapChain.
+     * Each SwapChain can have only one FrameScheduledCallback set per frame. If
+     * setFrameScheduledCallback is called multiple times on the same SwapChain before
+     * Renderer::endFrame(), the most recent call effectively overwrites any previously set
+     * callback. This allows the callback to be updated as needed before the frame has finished
+     * encoding.
+     *
+     * The "last" callback set by setFrameScheduledCallback gets "latched" when Renderer::endFrame()
+     * is executed. At this point, the state of the callback is fixed and is the one used for the
+     * frame that was just encoded. Subsequent changes to the callback using
+     * setFrameScheduledCallback after endFrame() apply to the next frame.
+     *
+     * Use \c setFrameScheduledCallback() (with default arguments) to unset the callback.
     *
     * If your application delays the call to the PresentCallable by, for example, calling it on a
     * separate thread, you must ensure all PresentCallables have been called before shutting down
@@ -278,28 +288,26 @@ public:
     * Engine::shutdown. This is necessary to ensure the Filament Engine has had a chance to clean
     * up all memory related to frame presentation.
     *
-     * @param callback    A callback, or nullptr to unset.
-     * @param user        An optional pointer to user data passed to the callback function.
+     * @param handler     Handler to dispatch the callback or nullptr for the default handler.
+     * @param callback    Callback called when the frame is scheduled.
     *
     * @remark Only Filament's Metal backend supports PresentCallables and frame callbacks. Other
     * backends ignore the callback (which will never be called) and proceed normally.
     *
-     * @remark The SwapChain::FrameScheduledCallback is called on an arbitrary thread.
-     *
+     * @see CallbackHandler
     * @see PresentCallable
     */
-    void setFrameScheduledCallback(FrameScheduledCallback UTILS_NULLABLE callback,
-            void* UTILS_NULLABLE user = nullptr);
+    void setFrameScheduledCallback(backend::CallbackHandler* UTILS_NULLABLE handler = nullptr,
+            FrameScheduledCallback&& callback = {});

    /**
-     * Returns the SwapChain::FrameScheduledCallback that was previously set with
-     * SwapChain::setFrameScheduledCallback, or nullptr if one is not set.
+     * Returns whether or not this SwapChain currently has a FrameScheduledCallback set.
     *
-     * @return the previously-set FrameScheduledCallback, or nullptr
+     * @return true, if the last call to setFrameScheduledCallback set a callback
     *
     * @see SwapChain::setFrameCompletedCallback
     */
-    UTILS_NULLABLE FrameScheduledCallback getFrameScheduledCallback() const noexcept;
+    bool isFrameScheduledCallbackSet() const noexcept;

    /**
     * FrameCompletedCallback is a callback function that notifies an application when a frame's
@@ -189,6 +189,13 @@ public:
     */
    void setCamera(Camera* UTILS_NONNULL camera) noexcept;

+    /**
+     * Returns whether a Camera is set.
+     * @return true if a camera is set.
+     * @see setCamera()
+     */
+    bool hasCamera() const noexcept;
+
    /**
     * Returns the Camera currently associated with this View.
     * @return A reference to the Camera associated to this View.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Sungun Park	6fc16bdcda	Release Filament 1.51.8	2024-05-13 20:53:36 +00:00
Mathias Agopian	4f021583f1	backend tests were broken by a change in TargetBufferInfo - a field was added, which broke the layout of the structure. We fix it by adding constructors which will handle the old and new way of initializing this structure. - one of the test needed a hash update - OpenGLContext wrongly asserted when trying to unbind texture 0	2024-05-10 14:39:22 -07:00
Powei Feng	ef15a29c0c	vk: fix missing lib for backend test	2024-05-10 13:00:00 -07:00
Benjamin Doherty	a0472d3c9f	Rename Metal log message	2024-05-10 11:25:34 -07:00
Ben Doherty	54a800a25d	Metal: implement more accurate buffer tracking (#7839 )	2024-05-10 11:14:41 -07:00
Powei Feng	7f8fbe586c	gl: push constant small clean-up (#7841 )	2024-05-10 10:23:32 -07:00
Powei Feng	6f2c45c76d	Add push constants (#7817 ) - Push constants is a small set of bytes that can be recorded directly on the command buffer. - Implemented it for the vulkan/gl backend.	2024-05-09 16:14:03 -07:00
Ryan	ad60008b6a	ryanmyers: Improve logging for Metallib function lookup failures (#7836 ) If a .metallib was compiled with a target iOS version that's newer than the current device, loading the .metallib may succeed, but finding main0 (or any other function in it) will fail. Currently, this causes a crash due to an assert. Logging the error and returning MetalFunctionBundle::error() makes the crash slightly easier to diagnose. (Note that in practice, this will probably be a useless "Compiler encountered an internal error" message -- the GPU backend is crashing, and the Metal stub library sees XPC_ERROR_CONNECTION_INTERRUPTED. It retries up to 3 times (crashing each time) and then gives up.)	2024-05-09 10:49:41 -07:00
Mathias Agopian	d87f9b621b	add a simple tranformmanager unit test this was to test issue #7827	2024-05-09 09:00:41 -07:00
Ben Doherty	1b38cda0d5	Add preferredShaderLanguage Java bindings (#7835 )	2024-05-08 14:42:40 -07:00
Ben Doherty	a1dea7b1fa	Metal: log slow buffer allocation times (#7834 )	2024-05-08 14:39:53 -07:00
Mathias Agopian	744708b5ca	remove the single <sstream> usage we have the STL's stream headers can bring in a lot of code, we don't use them.	2024-05-07 16:23:31 -07:00
Benjamin Doherty	e901837317	Log excess buffer allocations for Metal	2024-05-07 15:39:48 -07:00
Powei Feng	17f71c9b81	Release Filament 1.51.7	2024-05-07 14:35:42 -07:00
Mathias AgopianandPowei Feng	b056c126fe	Add an Engine debug setting to force GLES 2.0 (#7829 ) * Add an Engine debug setting to force GLES 2.0 This setting is only meaningful on GLES backends, it's otherwise ignored. When set to true, the backend will try to force a ES2 context if supported. If not supported by the platform, the backend will pretend it's a ES2 context. This setting is currently only taken into account by the EGL platform. * Update filament/backend/include/backend/Platform.h Co-authored-by: Powei Feng <powei@google.com> --------- Co-authored-by: Powei Feng <powei@google.com>	2024-05-07 09:53:31 -07:00
Sungun Park	6ac36d1aab	Fix a shader error (#7828 ) gl_ViewID_OVR is of uint type. Explicitly convert it to int to fix the error.	2024-05-06 21:03:04 +00:00
Ben Doherty	a1752b363c	Add preferredShaderLanguage option to Engine::Config (#7816 )	2024-05-06 12:12:38 -07:00
Levente Koncz	e855f4aafb	Fix mixed up FBO targets in status check code inside OpenGLDriver::blit()	2024-05-06 09:17:15 -07:00
Ben Doherty	1c693e24cf	Metal: track types of buffers (#7796 )	2024-05-03 14:32:01 -07:00
Ben Doherty	af92a1f21b	Add getEyeIndex vertex API (#7822 )	2024-05-03 14:22:24 -07:00
Powei Feng	10ff1ee3e4	Update filament to 1.51.6 for public pages (#7821 ) Updated both /viewer and /remote	2024-05-03 20:49:53 +00:00
Vladyslav PopovychandVladyslav	5449f46350	Remove bitcode from iOS builds (#7802 ) Co-authored-by: Vladyslav <vlad@arthouse.ar>	2024-05-03 12:25:00 -07:00
Mathias Agopian	2967888d26	repair instanced stereo in debug builds (#7819 ) - it was broken by a wrong assertion - also auto instancing + stereo instancing was always broken, but this makes it work	2024-05-03 09:36:09 -07:00
Powei Feng	afe81d6889	vk: Use offset when uploading buffer data (#7818 )	2024-05-02 11:17:32 -07:00
Mathias AgopianandBen Doherty	95134883d6	add the `-a` option to skinning and morphing samples (#7815 ) * add the `-a` option to skinning and morphing samples * Update samples/skinningtest.cpp Co-authored-by: Ben Doherty <bendoherty@google.com> * Update samples/helloskinningbuffer_morebones.cpp Co-authored-by: Ben Doherty <bendoherty@google.com> * Update samples/hellomorphing.cpp Co-authored-by: Ben Doherty <bendoherty@google.com> * Update samples/helloskinningbuffer.cpp Co-authored-by: Ben Doherty <bendoherty@google.com> --------- Co-authored-by: Ben Doherty <bendoherty@google.com>	2024-05-01 15:24:01 -07:00
Mathias Agopian	600c122761	fix ES2 support - make sure we can build with ES2 headers only - make sure to not use ES3 features when in ES2 mode (post processing was accidentally creating an R8 texture, which is not supported)	2024-05-01 13:29:58 -07:00
Mathias Agopian	1cf5335964	Skybox doesn't need a commit() method The material parameter changes are committed automatically in Engine::prepare(), no need to do it explicitly for SkyBox.	2024-05-01 10:11:39 -07:00
Eliza Velasquez	4ac4ffd8d6	filagui: Split uiBlit material into two Unfortunately, the external uniform was not optimized out as expected. The only option is to split it into its own independent material.	2024-04-30 14:14:23 -07:00
Eliza Velasquez	6c40721695	Fix broken ImGui on web I was unfortunately naive about the way that Filament handled external textures on non-GLES platforms. This fix restricts the changes to Android (which is the only place this change is required in the first place). Long story short, the change broke WebGL. Desktop seems to be unaffected.	2024-04-30 14:14:23 -07:00
Benjamin Doherty	56fa078376	Release Filament 1.51.6	2024-04-29 16:49:28 -07:00
Ben Doherty	883507a26f	Remove spirv-opt size optimizations for MSL (#7495 )	2024-04-29 16:47:05 -07:00
Powei Feng	d697d42c4a	vk: finer-grain barrier at renderpass end (#7808 ) - At the end of a renderpass we use a more fine-grained barrier for each of the attachments in the render target - Make sure that buffer update are barrier'd from previous reads - Remove previous Mali workaround barriers. Seems to be fine without them on pixels + Mali.	2024-04-29 11:32:04 -07:00
Ben Doherty	e7feee7d5b	Switch setFrameScheduledCallback to use utils::Invocable (#7792 )	2024-04-29 10:18:28 -07:00
Powei Feng	4c75e6e9a2	gltfio: enable extended implementation (#7776 ) This change will enable proper flat-shading and MikkTSpace. Caveats: - Only for disk-local glTF resources - iOS, Web, Android do not work as of now Fixes #6358, #7444	2024-04-27 00:28:08 +00:00
Mathias Agopian	8ab8525359	fix a missing ubo upload in bloom set-up	2024-04-26 16:49:39 -07:00
Powei Feng	65c794881f	vk: various clean up (#7805 ) - use namespace for ImageUtility - use FILAMENT_BACKEND_DEBUG_FLAG - remove unused usage flag type - add const list of VKFormat for iteration - fix sampler name debug	2024-04-26 22:26:16 +00:00
Powei Feng	08d6d57ad0	vk: simplify VulkanAttachment (#7801 )	2024-04-26 21:48:15 +00:00
Mathias Agopian	254cf15f0e	a couple of significant improvements to instancing The main goal of this change is to avoid having to select the "per renderable" UBO at execution time. Instead we want the PrimitiveInfo structure to already know which UBO will be used. Concretely, this means that this determination must be done when the RenderPass is created. When automatic instancing is used, the RenderPass creates a temporary UBO to store the instance info. This UBO's life-time is dictated by both the life-time of the RenderPass and the Executors that where created from it. For this reason we introduce SharedHandle<> to correctly account for the owner's lifetime. This fixes a potential bugs where that handle could have been destroyed and used later; in practice this bug didn't happen however. A couple other changes: - RenderPass has a bunch of fields that were actually temporary, so we removed those. - The canonical "per-renderable" UBO was owned by View but accessed through Scene. This was confusing, it's now accessed through View.	2024-04-26 14:15:00 -07:00
Mathias Agopian	22d99bac3d	simplify generateCommands() It's been a while that generateCommands() can only generate either the depth or color pass but not both at once; we can simplify/de-dup the code by leveraging that.	2024-04-26 14:15:00 -07:00
Mathias Agopian	420f06bef3	implement 16 and 8 bits clz, ctz and popcount This is needed for utils::bitset8 and bitset16.	2024-04-26 14:13:48 -07:00
Powei Feng	bf8bcef35c	Add option to define a backend debug flag (#7798 ) To allow easy enabling/disabling of debug options like vulkan validation, android systrace, debug printing, and others, we introduce an option to add a preprocessor flag so that a backend can (optionally) use it to manage debug options.	2024-04-25 23:42:55 +00:00
Eliza Velasquez	bfab9f9c32	engine: Add isPaused()	2024-04-25 16:11:14 -07:00
Powei Feng	c8335fade7	vk: Fix unsupported depth blitting (#7789 ) * vk: Fix unsupported depth blitting On certain hardware (pixel 4 for example), blitting of depth texture is not supported as an "optimalTilingFeature". In these cases, we'd would need to do a shader-based blit. We - Add the shader blit in PostProcessingManager - Add a driver API to check for support for blitting depthStencil attachments. - Fix some debugging ifdefs in vk backend. The validation fixed is: `[ VUID-vkCmdBlitImage-dstImage-02000 ] Object 0: handle = 0xb400007c300701d0, type = VK_OBJECT_TYPE_COMMAND_BUFFER; Object 1: handle = 0xf2039b0000000771, type = VK_OBJECT_TYPE_IMAGE; \| MessageID = 0x86bc2a78 \| In vkCmdBlitImage, VkFormatFeatureFlags (0x1c601) does not support required feature VK_FORMAT_FEATURE_2_BLIT_DST_BIT for format 126 used by VkImage 0xf2039b0000000771[] with tiling VK_IMAGE_TILING_OPTIMAL. The Vulkan spec states: The format features of dstImage must contain VK_FORMAT_FEATURE_BLIT_DST_BIT`	2024-04-24 18:27:57 +00:00
Mathias Agopian	99eac62b4e	give proper move semantics to Handle<>	2024-04-23 15:38:29 -07:00
Mathias Agopian	6146d071ba	StructureOfArray::push_back(&&) didn't do a move	2024-04-23 15:38:29 -07:00
Mathias Agopian	d26c972f5b	add missing includes in RenerableManager	2024-04-23 15:38:29 -07:00
Mathias Agopian	93dc218b83	fix PerShadowMapUniform includes	2024-04-23 15:38:29 -07:00
Ben Doherty	b56379dc0f	Add license information to matedit (#7790 )	2024-04-23 14:05:53 -06:00
Mathias Agopian	e4442a5eb2	optimize the inner rendering loop This largely undoes a change I did recently where PrimitiveInfo has a FRenderPrimitive* to save some space and keep a command at 64 bytes. This wasn't a good idea because the inner rendering loop shouldn't to any dereference in the common case. This change reorganises PrimitiveInfo such that it stores all the data necessary to render a primitive in the common case. The less common cases are when hybrid instancing, morphing or skinning are used; in those cases, a dereference into the renderable SOA is needed. PrimitiveInfo currently has 16 bytes free, which we keep for futur use.	2024-04-23 10:22:33 -07:00
Ben Doherty	490e8cf0d0	Add option to preserve text shaders (#7786 )	2024-04-23 10:38:23 -06:00
Mathias Agopian	0d25f79421	gl: simplify how we track bound textures In opengl it's possible to bind several textures to the same texture unit as long as they're a different target. Until now we were tracking that state. In practice it's not very useful to bind several textures to the same unit (it is a little bit when updating texture data, but not when rendering). With the coming change to a descriptor set API, it is better to have a 1-to-1 mapping between bound textures and texture units. So with this change, only a single texture can be bound to a texture unit. If another texture in bound to the same unit with a different target, we first unbind the texture from the current target. There is less state to track, and it allows us to "unbind a texture unit" (whereas before we'd have to iterate through all the possible targets for that unit and unbind all of them).	2024-04-22 16:03:24 -07:00
Mathias Agopian	d0586743f6	add ADPF support for backend thread	2024-04-22 15:09:08 -07:00
Mathias Agopian	14a99cbc63	add the target refresh interval to the backend beginFrame	2024-04-22 15:09:08 -07:00
Benjamin Doherty	808b51c1cf	matedit: fix use-after-free	2024-04-22 16:06:39 -06:00
Sungun Park	315726678e	Release Filament 1.51.5	2024-04-22 20:47:55 +00:00
Ben Doherty	bac8e58ee7	Support backends with multiple shader languages and precompiled Metal libraries (#7769 )	2024-04-21 21:59:22 -04:00
Mathias AgopianandBen Doherty	ec31a516f7	don't rely on FMaterialInstance having a default ctor (#7781 ) * don't rely on FMaterialInstance having a default ctor FMaterialInstance needed a default ctor because it is a field of FMaterial but cannot be initialized before FMaterial itself is initialized. So we had a defautl ctor and we'd finish the initialization later. Conceptually the default material instance should have been new'ed and a pointer to it stored instead. That's basically what we do now, but to avoid the extra allocation, we in-place new and delete the default material instance into an aligned_storage inside FMaterial. * Update filament/src/details/Material.h Co-authored-by: Ben Doherty <bendoherty@google.com> --------- Co-authored-by: Ben Doherty <bendoherty@google.com>	2024-04-19 21:38:30 +00:00
Mathias Agopian	7a3b762b53	cleanup details/Material.h Should Fix #7774	2024-04-19 12:08:03 -07:00
Eliza Velasquez	67268cb76d	filagui: Use material constants in uiBlit	2024-04-18 13:46:46 -07:00
Eliza Velasquez	0b34dc6608	filagui: Add support for external textures We have an instance of a client trying to render a GL_TEXTURE_EXTERNAL_OES texture with filagui, which currently fails.	2024-04-18 13:46:46 -07:00
Ben Doherty	afe292986e	Introduce new matedit tool (#7759 )	2024-04-18 12:18:29 -04:00
Mathias Agopian	83acf0f9de	fix hello triangle build	2024-04-18 00:38:26 -07:00
Mathias Agopian	69d9c8b72c	fix a GL backend crash when shutting down the gl backend did some of its cleanup in the its destructor, including calling into OpenGL, however, the destructor is called from the main thread, not the GL thread, so these calls would be no-ops at best, and crashes in the worst case.	2024-04-16 15:08:45 -07:00
Mathias AgopianandPowei Feng	3bffd90357	don't crash if we don't have a Camera set on View (#7766 ) * don't crash if we don't have a Camera set on View - also add a method to query if a camera was set * Update android/filament-android/src/main/java/com/google/android/filament/View.java Co-authored-by: Powei Feng <powei@google.com> --------- Co-authored-by: Powei Feng <powei@google.com>	2024-04-16 21:09:21 +00:00
Mathias AgopianandPowei Feng	b21dfd5ea2	add a couple way of validating MaterialInstances (#7754 ) * add a couple way of validating MaterialInstances BUGS=[333907416] * Update filament/include/filament/Engine.h Co-authored-by: Powei Feng <powei@google.com> * Update filament/include/filament/Engine.h Co-authored-by: Powei Feng <powei@google.com> --------- Co-authored-by: Powei Feng <powei@google.com>	2024-04-16 12:12:20 -07:00
Mathias Agopian	8af2d7512d	cleanup and small improvements to JobSystem - add missing includes - wake-up one or several threads based on the number of jobs available	2024-04-16 12:11:15 -07:00
Mathias Agopian	785592293c	don't use thread affinity for the thread-pool using thread affinity naively on big.little architectures is very flaky, for now it's better to simplify and not use it at all, let the kernel figure things out. BUGS=[333582569]	2024-04-16 12:11:15 -07:00
Maximilien Dagois	613b1fc246	Fixed a comment	2024-04-16 12:10:49 -07:00
Powei Feng	c8098a4c15	gltfio: add Asset/Resource extended implementations (#7678 ) * gltfio: add Asset/Resource extended implementations - Add gltfio/src/extended to implement an alternate loader for primitives. This is largely based on the implementation in AssetLoader/ResourceLoader - Able to correctly produce flat shading from gltf that only have vertex positions and indices. - This is not hooked into current code and should have no practical effect on gltfio.	2024-04-16 17:46:48 +00:00
Powei Feng	d8eee061e8	vk: Fix clang-18 compiler warning (#7764 ) Fixes #7762	2024-04-16 17:14:57 +00:00
Powei Feng	0ebe888344	Fix broken dynamic resolution (#7763 ) Previous PR #7758 accidentally removed the setting of 'resolution' for shaders other than 'blitLow'. This PR undoes that.	2024-04-16 09:52:43 -07:00
Powei Feng	c20496a461	Remove unused parameter in blitLow (#7758 )	2024-04-15 16:19:54 -07:00
tomnomgoogleuk	8955a61df3	Set VkApplicationInfo.pEngineName to Filament (#7756 ) Setting the pEngineName helps with the collection of metrics and is generally good practice.	2024-04-15 19:42:36 +00:00
Powei Feng	9e0e3262c3	Release Filament 1.51.4	2024-04-15 11:05:12 -07:00
Mathias Agopian	d3d5281488	cleanup the Material constructor We move some large blocks of code out of line.	2024-04-15 10:27:07 -07:00
Mathias Agopian	075f3d0869	fix another ibl-prefilter bug introduced recently The top and bottom faces were swapped in the reflection map. FIXES=[333421281]	2024-04-15 10:25:52 -07:00
Mathias Agopian	3ca9b9cd0f	don't use thread affinity for the backend thread Originally we did this because we wanted to run on a big core on android. However setting the thread affinity in this way is fragile, we are not guaranteed to be on a big core, and we don't even know if some thread is pinned to that core already; which was the case with some GL drivers. This can also cause scheduling problems with other threads. We just remove this logic entirely for now, and we'll figure out something better later to run on a big core. Fixes #7748 BUGS=[333949404]	2024-04-12 15:55:56 -07:00
Mathias Agopian	eb33ce35ef	make the Systrace class public BUGS=[331834298]	2024-04-12 14:44:48 -07:00
Ben Doherty	cddd22da28	Introduce a new precompiled Metal material chunk type (#7749 ) This change introduces a new chunk type to material files for precompiled Metal libraries. Previously, SPIR-V was the only binary type, so there's also a couple of refactor commits present here. Nothing is changed in Filament or matc yet. BUGS=[333547148]	2024-04-12 00:42:10 -04:00
Powei Feng	05ce5ead8d	vk: Use new descriptor set caching (#7735 ) - Use new descriptor set and layout caching - Remove descriptor set related code in VulkanPipelineCache - fix leaks for descriptor sets/layouts FIXES=248594812,325157400	2024-04-09 23:29:27 +00:00