test load image

2024-05-15 23:37:49 -07:00
203 changed files with 12000 additions and 2929 deletions
@@ -13,7 +13,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
      - uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
@@ -13,7 +13,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
      - name: Run build script
        run: |
          cd build/ios && printf "y" | ./build.sh continuous
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-22.04

    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
      - name: Run build script
        run: |
          cd build/linux && printf "y" | ./build.sh continuous
@@ -13,7 +13,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
      - name: Run build script
        run: |
          cd build/mac && printf "y" | ./build.sh continuous
@@ -13,7 +13,7 @@ jobs:
    name: npm-deploy
    runs-on: macos-14
    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
        with:
          ref: ${{ github.event.inputs.release_tag }}
      # Setup .npmrc file to publish to npm
@@ -18,7 +18,7 @@ jobs:
        os: [macos-14, ubuntu-22.04]

    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
      - name: Run build script
        run: |
          WORKFLOW_OS=`echo \`uname\` | sed "s/Darwin/mac/" | tr [:upper:] [:lower:]`
@@ -32,7 +32,7 @@ jobs:
    runs-on: windows-2019

    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
      - name: Run build script
        run: |
          build\windows\build-github.bat presubmit
@@ -43,7 +43,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
      - uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
@@ -57,7 +57,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
      - name: Run build script
        run: |
          cd build/ios && printf "y" | ./build.sh presubmit
@@ -70,7 +70,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
      - name: Run build script
        run: |
          cd build/web && printf "y" | ./build.sh presubmit
@@ -41,7 +41,7 @@ jobs:
          TAG=${REF##*/}
          echo "ref=${REF}" >> $GITHUB_OUTPUT
          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
@@ -76,7 +76,7 @@ jobs:
          TAG=${REF##*/}
          echo "ref=${REF}" >> $GITHUB_OUTPUT
          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
@@ -109,7 +109,7 @@ jobs:
          TAG=${REF##*/}
          echo "ref=${REF}" >> $GITHUB_OUTPUT
          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - uses: actions/setup-java@v3
@@ -163,7 +163,7 @@ jobs:
          TAG=${REF##*/}
          echo "ref=${REF}" >> $GITHUB_OUTPUT
          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
@@ -197,7 +197,7 @@ jobs:
          echo "ref=${REF}" >> $GITHUB_OUTPUT
          echo "tag=${TAG}" >> $GITHUB_OUTPUT
        shell: bash
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
@@ -13,7 +13,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
      - name: Run build script
        run: |
          cd build/web && printf "y" | ./build.sh continuous
@@ -13,7 +13,7 @@ jobs:
    runs-on: windows-2019

    steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v3.3.0
      - name: Run build script
        run: |
          build\windows\build-github.bat continuous
@@ -73,6 +73,7 @@ The following CMake options are boolean options specific to Filament:
 - `FILAMENT_SUPPORTS_VULKAN`:      Include the Vulkan backend
 - `FILAMENT_INSTALL_BACKEND_TEST`: Install the backend test library so it can be consumed on iOS
 - `FILAMENT_USE_EXTERNAL_GLES3`:   Experimental: Compile Filament against OpenGL ES 3
+- `FILAMENT_USE_SWIFTSHADER`:      Compile Filament against SwiftShader
 - `FILAMENT_SKIP_SAMPLES`:         Don't build sample apps

 To turn an option on or off:
@@ -425,7 +426,7 @@ value is the desired roughness between 0 and 1.

 ## Generating C++ documentation

-To generate the documentation you must first install `doxygen` and `graphviz`, then run the
+To generate the documentation you must first install `doxygen` and `graphviz`, then run the 
 following commands:

 ```shell
@@ -435,62 +436,32 @@ doxygen docs/doxygen/filament.doxygen

 Finally simply open `docs/html/index.html` in your web browser.

-## Software Rasterization
+## SwiftShader

-We have tested swiftshader and Mesa for software rasterization on the Vulkan/GL backends.
-
-To use this for Vulkan, please first make sure that the [Vulkan SDK](https://www.lunarg.com/vulkan-sdk/) is
-installed on your machine. If you are doing a manual installation of the SDK on Linux, you will have
-to source `setup-env.sh` in the SDK's root folder to make sure the Vulkan loader is the first lib loaded.
-
-### Swiftshader (Vulkan) [tested on macOS and Linux]
-
-First, build SwiftShader
+To try out Filament's Vulkan support with SwiftShader, first build SwiftShader and set the
+`SWIFTSHADER_LD_LIBRARY_PATH` variable to the folder that contains `libvk_swiftshader.dylib`:

 ```shell
 git clone https://github.com/google/swiftshader.git
 cd swiftshader/build
 cmake .. &&  make -j
+export SWIFTSHADER_LD_LIBRARY_PATH=`pwd`
 ```

-and then set `VK_ICD_FILENAMES` to the ICD json produced in the build. For example,
-```shell
-export VK_ICD_FILENAMES=/Users/user/swiftshader/build/Darwin/vk_swiftshader_icd.json
-```
+Next, go to your Filament repo and use the [easy build](#easy-build) script with `-t`.

-Build and run Filament as usual and specify the Vulkan backend when creating the Engine.
+## SwiftShader for CI

-### Mesa's LLVMPipe (GL) and Lavapipe (Vulkan) [tested on Linux]
-
-We will only cover steps that build Mesa from source. The official documentation of Mesa mentioned
-that in general precompiled libraries [are **not** made available](https://docs.mesa3d.org/precompiled.html).
-
-Download the repo and make sure you have the build depedencies. For example (assuming an Ubuntu/Debian distro),
-```shell
-git clone https://gitlab.freedesktop.org/mesa/mesa.git
-sudo apt-get build-dep mesa
-```
-
-To build both the GL and Vulkan rasterizers,
+Continuous testing turnaround can be quite slow if you need to build SwiftShader from scratch, so we
+provide an Ubuntu-based Docker image that has it already built. The Docker image also includes
+everything necessary for building Filament. You can fetch and run the image as follows:

 ```shell
-cd mesa
-mkdir -p out
-meson setup builddir/ -Dprefix=$(pwd)/out -Dglx=xlib -Dgallium-drivers=swrast -Dvulkan-drivers=swrast
-meson install -C builddir/
+docker pull ghcr.io/filament-assets/swiftshader
+docker run -it ghcr.io/filament-assets/swiftshader
 ```

-For GL, we need to ensure that we load the GL lib from the mesa output directory.  For example, to run
-the debug `gltf_viewer`, we would execute
-```shell
-LD_LIBRARY_PATH=/Users/user/mesa/out/lib/x86_64-linux-gnu \
-    ./out/cmake-debug/samples/gltf_viewer -a opengl
-```
+To do more with the container, see the helper script at `build/swiftshader/test.sh`.

-For Vulkan, we need to set the path to the ICD json, which tells the loader where to find the driver
-library. To run `gltf_viewer`, we would execute
-```shell
-VK_ICD_FILENAMES=/Users/user/mesa/out/share/vulkan/icd.d/lvp_icd.x86_64.json \
-    ./out/cmake-debug/samples/gltf_viewer -a vulkan
-
-```
+If you are a team member, you can update the public image to the latest SwiftShader by
+following the instructions at the top of `build/swiftshader/Dockerfile`.
@@ -21,6 +21,8 @@ project(TNT)
 # ==================================================================================================
 option(FILAMENT_USE_EXTERNAL_GLES3 "Experimental: Compile Filament against OpenGL ES 3" OFF)

+option(FILAMENT_USE_SWIFTSHADER "Compile Filament against SwiftShader" OFF)
+
 option(FILAMENT_ENABLE_LTO "Enable link-time optimizations if supported by the compiler" OFF)

 option(FILAMENT_SKIP_SAMPLES "Don't build samples" OFF)
@@ -143,6 +145,11 @@ if (LINUX)
            add_definitions(-DFILAMENT_SUPPORTS_XCB)
        endif()

+        # Default Swiftshader build does not enable the xlib extension
+        if (FILAMENT_SUPPORTS_XLIB AND FILAMENT_USE_SWIFTSHADER)
+            set(FILAMENT_SUPPORTS_XLIB OFF)
+        endif()
+
        if (FILAMENT_SUPPORTS_XLIB)
            add_definitions(-DFILAMENT_SUPPORTS_XLIB)
        endif()
@@ -320,6 +327,10 @@ if (FILAMENT_SUPPORTS_EGL_ON_LINUX)
  set(EGL TRUE)
 endif()

+if (FILAMENT_USE_SWIFTSHADER)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DFILAMENT_USE_SWIFTSHADER")
+endif()
+
 if (WIN32)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_USE_MATH_DEFINES=1")
 endif()
@@ -440,13 +451,8 @@ endif()
 if (NOT WEBGL)
    set(GC_SECTIONS "-Wl,--gc-sections")
 endif()
-
 set(B_SYMBOLIC_FUNCTIONS "-Wl,-Bsymbolic-functions")

-if (ANDROID)
-set(BINARY_ALIGNMENT "-Wl,-z,max-page-size=16384")
-endif()
-
 if (APPLE)
    set(GC_SECTIONS "-Wl,-dead_strip")
    set(B_SYMBOLIC_FUNCTIONS "")
@@ -460,7 +466,7 @@ if (APPLE)
 endif()

 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${GC_SECTIONS}")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${GC_SECTIONS} ${B_SYMBOLIC_FUNCTIONS} ${BINARY_ALIGNMENT}")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${GC_SECTIONS} ${B_SYMBOLIC_FUNCTIONS}")

 if (WEBGL_PTHREADS)
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pthread")
@@ -524,15 +530,13 @@ else()
 endif()

 # This only affects the prebuilt shader files in gltfio and samples, not filament library.
-# The value can be either "instanced", "multiview", or "none"
-set(FILAMENT_SAMPLES_STEREO_TYPE "none" CACHE STRING
+# The value can be either "instanced" or "multiview".
+set(FILAMENT_SAMPLES_STEREO_TYPE "instanced" CACHE STRING
    "Stereoscopic type that shader files in gltfio and samples are built for."
 )
 string(TOLOWER "${FILAMENT_SAMPLES_STEREO_TYPE}" FILAMENT_SAMPLES_STEREO_TYPE)
-if (NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "instanced"
-    AND NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "multiview"
-    AND NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "none")
-    message(FATAL_ERROR "Invalid stereo type: \"${FILAMENT_SAMPLES_STEREO_TYPE}\" choose either \"instanced\",  \"multiview\", or \"none\" ")
+if (NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "instanced" AND NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "multiview")
+    message(FATAL_ERROR "Invalid stereo type: \"${FILAMENT_SAMPLES_STEREO_TYPE}\" choose either \"instanced\" or \"multiview\" ")
 endif ()

 # Compiling samples for multiview implies enabling multiview feature as well.
@@ -674,6 +678,21 @@ else()
    set(IMPORT_EXECUTABLES ${FILAMENT}/${IMPORT_EXECUTABLES_DIR}/ImportExecutables-${CMAKE_BUILD_TYPE}.cmake)
 endif()

+# ==================================================================================================
+# Try to find Vulkan if the SDK is installed, otherwise fall back to the bundled version.
+# This needs to stay in our top-level CMakeLists because it sets up variables that are used by the
+# "bluevk" and "samples" targets.
+# ==================================================================================================
+
+if (FILAMENT_USE_SWIFTSHADER)
+    if (NOT FILAMENT_SUPPORTS_VULKAN)
+        message(ERROR "SwiftShader is only useful when Vulkan is enabled.")
+    endif()
+    find_library(SWIFTSHADER_VK NAMES vk_swiftshader HINTS "$ENV{SWIFTSHADER_LD_LIBRARY_PATH}")
+    message(STATUS "Found SwiftShader VK library in: ${SWIFTSHADER_VK}.")
+    add_definitions(-DFILAMENT_VKLIBRARY_PATH=\"${SWIFTSHADER_VK}\")
+endif()
+
 # ==================================================================================================
 # Common Functions
 # ==================================================================================================
@@ -735,6 +754,7 @@ add_subdirectory(${FILAMENT}/filament)
 add_subdirectory(${FILAMENT}/shaders)
 add_subdirectory(${EXTERNAL}/basisu/tnt)
 add_subdirectory(${EXTERNAL}/civetweb/tnt)
+add_subdirectory(${EXTERNAL}/hat-trie/tnt)
 add_subdirectory(${EXTERNAL}/imgui/tnt)
 add_subdirectory(${EXTERNAL}/robin-map/tnt)
 add_subdirectory(${EXTERNAL}/smol-v/tnt)
@@ -31,7 +31,7 @@ repositories {
 }

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

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

-## v1.53.1
-
-
-## v1.53.0
-
- engine: fix skinning normals with large transforms (b/342459864) [⚠️ **New Material Version**]
-
-## v1.52.3
-
-
-## v1.52.2
-
-
-## v1.52.1
-
- Add instructions for using Mesa for software rasterization
-
 ## v1.51.9


@@ -83,12 +83,12 @@ buildscript {
        'minSdk': 21,
        'targetSdk': 34,
        'compileSdk': 34,
-        'kotlin': '2.0.0',
-        'kotlin_coroutines': '1.9.0-RC',
+        'kotlin': '1.9.21',
+        'kotlin_coroutines': '1.7.3',
        'buildTools': '34.0.0',
-        'ndk': '27.0.11718014',
-        'androidx_core': '1.13.1',
-        'androidx_annotations': '1.8.0'
+        'ndk': '26.1.10909125',
+        'androidx_core': '1.12.0',
+        'androidx_annotations': '1.7.0'
    ]

    ext.deps = [
@@ -104,7 +104,7 @@ buildscript {
    ]

    dependencies {
-        classpath 'com.android.tools.build:gradle:8.4.1'
+        classpath 'com.android.tools.build:gradle:8.2.0'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin}"
    }

@@ -38,7 +38,6 @@ set(FILAMAT_INCLUDE_DIRS
 include_directories(${FILAMENT_DIR}/include)

 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${CMAKE_SOURCE_DIR}/libfilamat-jni.map")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")

 add_library(filamat-jni SHARED src/main/cpp/MaterialBuilder.cpp)
 target_include_directories(filamat-jni PRIVATE ${FILAMAT_INCLUDE_DIRS})
@@ -59,7 +59,6 @@ endif()

 set(VERSION_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/libfilament-jni.map")
 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${VERSION_SCRIPT}")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")

 add_library(filament-jni SHARED
    src/main/cpp/BufferObject.cpp
@@ -420,13 +420,6 @@ Java_com_google_android_filament_Engine_nSetPaused(JNIEnv*, jclass,
    engine->setPaused(paused);
 }

-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nUnprotected(JNIEnv*, jclass,
-        jlong nativeEngine, jboolean paused) {
-    Engine* engine = (Engine*) nativeEngine;
-    engine->unprotected();
-}
-
 // Managers...

 extern "C" JNIEXPORT jlong JNICALL
@@ -244,25 +244,13 @@ Java_com_google_android_filament_RenderableManager_nBuilderMorphing(JNIEnv*, jcl
    builder->morphing(targetCount);
 }

-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nBuilderMorphingStandard(JNIEnv*, jclass,
-        jlong nativeBuilder, jlong nativeMorphTargetBuffer) {
-    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
-    builder->morphing(morphTargetBuffer);
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nBuilderSetMorphTargetBufferAt(JNIEnv*, jclass,
        jlong nativeBuilder, int level, int primitiveIndex, jlong nativeMorphTargetBuffer,
        int offset, int count) {
    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    if (nativeMorphTargetBuffer) {
-        MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
-        builder->morphing(level, primitiveIndex, morphTargetBuffer, offset, count);
-    } else {
-        builder->morphing(level, primitiveIndex, offset, count);
-    }
+    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
+    builder->morphing(level, primitiveIndex, morphTargetBuffer, offset, count);
 }

 extern "C" JNIEXPORT void JNICALL
@@ -338,14 +326,9 @@ Java_com_google_android_filament_RenderableManager_nSetMorphTargetBufferAt(JNIEn
        jclass, jlong nativeRenderableManager, jint i, int level, jint primitiveIndex,
        jlong nativeMorphTargetBuffer, jint offset, jint count) {
    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
-    if (nativeMorphTargetBuffer) {
-        MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
-        rm->setMorphTargetBufferAt((RenderableManager::Instance) i, (uint8_t) level,
-                (size_t) primitiveIndex, morphTargetBuffer, (size_t) offset, (size_t) count);
-    } else {
-        rm->setMorphTargetBufferAt((RenderableManager::Instance) i, (uint8_t) level,
-                (size_t) primitiveIndex, (size_t) offset, (size_t) count);
-    }
+    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
+    rm->setMorphTargetBufferAt((RenderableManager::Instance) i, (uint8_t) level,
+            (size_t) primitiveIndex, morphTargetBuffer, (size_t) offset, (size_t) count);
 }

 extern "C" JNIEXPORT jint JNICALL
@@ -159,12 +159,9 @@ public class Engine {
    };

    /**
-     * The type of technique for stereoscopic rendering. (Note that the materials used will need to be
-     * compatible with the chosen technique.)
+     * The type of technique for stereoscopic rendering
     */
    public enum StereoscopicType {
-        /** No stereoscopic rendering. */
-        NONE,
        /** Stereoscopic rendering is performed using instanced rendering technique. */
        INSTANCED,
        /** Stereoscopic rendering is performed using the multiview feature from the graphics backend. */
@@ -408,7 +405,7 @@ public class Engine {
         *
         * @see View#setStereoscopicOptions
         */
-        public StereoscopicType stereoscopicType = StereoscopicType.NONE;
+        public StereoscopicType stereoscopicType = StereoscopicType.INSTANCED;

        /**
         * The number of eyes to render when stereoscopic rendering is enabled. Supported values are
@@ -1289,18 +1286,6 @@ public class Engine {
        nSetPaused(getNativeObject(), paused);
    }

-    /**
-     * Switch the command queue to unprotected mode. Protected mode can be activated via
-     * Renderer::beginFrame() using a protected SwapChain.
-
-     * @see Renderer
-     * @see SwapChain
-     */
-    public void unprotected() {
-        nUnprotected(getNativeObject());
-    }
-
-
    @UsedByReflection("TextureHelper.java")
    public long getNativeObject() {
        if (mNativeObject == 0) {
@@ -1378,7 +1363,6 @@ public class Engine {
    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 void nUnprotected(long nativeEngine);
    private static native long nGetTransformManager(long nativeEngine);
    private static native long nGetLightManager(long nativeEngine);
    private static native long nGetRenderableManager(long nativeEngine);
@@ -524,7 +524,14 @@ public class RenderableManager {
        }

        /**
-         * Controls if the renderable has legacy vertex morphing targets, zero by default.
+         * Controls if the renderable has vertex morphing targets, zero by default. This is
+         * required to enable GPU morphing.
+         *
+         * <p>Filament supports two morphing modes: standard (default) and legacy.</p>
+         *
+         * <p>For standard morphing, A {@link MorphTargetBuffer} must be created and provided via
+         * {@link RenderableManager#setMorphTargetBufferAt}. Standard morphing supports up to
+         * <code>CONFIG_MAX_MORPH_TARGET_COUNT</code> morph targets.</p>
         *
         * For legacy morphing, the attached {@link VertexBuffer} must provide data in the
         * appropriate {@link VertexBuffer.VertexAttribute} slots (<code>MORPH_POSITION_0</code> etc).
@@ -542,22 +549,6 @@ public class RenderableManager {
            return this;
        }

-        /**
-         * Controls if the renderable has vertex morphing targets, zero by default.
-         *
-         * <p>For standard morphing, A {@link MorphTargetBuffer} must be provided.
-         * Standard morphing supports up to
-         * <code>CONFIG_MAX_MORPH_TARGET_COUNT</code> morph targets.</p>
-         *
-         * <p>See also {@link RenderableManager#setMorphWeights}, which can be called on a per-frame basis
-         * to advance the animation.</p>
-         */
-        @NonNull
-        public Builder morphing(@NonNull MorphTargetBuffer morphTargetBuffer) {
-            nBuilderMorphingStandard(mNativeBuilder, morphTargetBuffer.getNativeObject());
-            return this;
-        }
-
        /**
         * Specifies the morph target buffer for a primitive.
         *
@@ -574,17 +565,6 @@ public class RenderableManager {
         * @param count number of vertices in the morph target buffer to read, must equal the geometry's count (for triangles, this should be a multiple of 3)
         */
        @NonNull
-        public Builder morphing(@IntRange(from = 0) int level,
-                                @IntRange(from = 0) int primitiveIndex,
-                                @IntRange(from = 0) int offset,
-                                @IntRange(from = 0) int count) {
-            nBuilderSetMorphTargetBufferAt(mNativeBuilder, level, primitiveIndex, 0, offset, count);
-            return this;
-        }
-
-        /** @deprecated */
-        @Deprecated
-        @NonNull
        public Builder morphing(@IntRange(from = 0) int level,
                                @IntRange(from = 0) int primitiveIndex,
                                @NonNull MorphTargetBuffer morphTargetBuffer,
@@ -595,8 +575,10 @@ public class RenderableManager {
            return this;
        }

-        /** @deprecated */
-        @Deprecated
+        /**
+         * Utility method to specify morph target buffer for a primitive.
+         * For details, see the {@link RenderableManager.Builder#morphing}.
+         */
        @NonNull
        public Builder morphing(@IntRange(from = 0) int level,
                                @IntRange(from = 0) int primitiveIndex,
@@ -705,16 +687,6 @@ public class RenderableManager {
     *
     * @see Builder#morphing
     */
-    public void setMorphTargetBufferAt(@EntityInstance int i,
-                                       @IntRange(from = 0) int level,
-                                       @IntRange(from = 0) int primitiveIndex,
-                                       @IntRange(from = 0) int offset,
-                                       @IntRange(from = 0) int count) {
-        nSetMorphTargetBufferAt(mNativeObject, i, level, primitiveIndex, 0, offset, count);
-    }
-
-    /** @deprecated */
-    @Deprecated
    public void setMorphTargetBufferAt(@EntityInstance int i,
                                       @IntRange(from = 0) int level,
                                       @IntRange(from = 0) int primitiveIndex,
@@ -725,8 +697,10 @@ public class RenderableManager {
                morphTargetBuffer.getNativeObject(), offset, count);
    }

-    /** @deprecated */
-    @Deprecated
+    /**
+     * Utility method to change morph target buffer for the given primitive.
+     * For details, see the {@link RenderableManager#setMorphTargetBufferAt}.
+     */
    public void setMorphTargetBufferAt(@EntityInstance int i,
                                       @IntRange(from = 0) int level,
                                       @IntRange(from = 0) int primitiveIndex,
@@ -1032,7 +1006,6 @@ public class RenderableManager {
    private static native int nBuilderSkinningBones(long nativeBuilder, int boneCount, Buffer bones, int remaining);
    private static native void nBuilderSkinningBuffer(long nativeBuilder, long nativeSkinningBuffer, int boneCount, int offset);
    private static native void nBuilderMorphing(long nativeBuilder, int targetCount);
-    private static native void nBuilderMorphingStandard(long nativeBuilder, long nativeMorphTargetBuffer);
    private static native void nBuilderSetMorphTargetBufferAt(long nativeBuilder, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset, int count);
    private static native void nBuilderEnableSkinningBuffers(long nativeBuilder, boolean enabled);
    private static native void nBuilderFog(long nativeBuilder, boolean enabled);
@@ -31,7 +31,6 @@ set_target_properties(iblprefilter PROPERTIES IMPORTED_LOCATION
        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libfilament-iblprefilter.a)

 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/libfilament-utils-jni.map")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")

 add_library(filament-utils-jni SHARED
        src/main/cpp/AutomationEngine.cpp
@@ -44,7 +44,6 @@ set_target_properties(uberarchive PROPERTIES IMPORTED_LOCATION
        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libuberarchive.a)

 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/libgltfio-jni.map")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")

 set(GLTFIO_SRCS
        ${GLTFIO_DIR}/include/gltfio/Animator.h
@@ -120,6 +119,7 @@ set(GLTFIO_INCLUDE_DIRS
        ../../third_party/cgltf
        ../../third_party/meshoptimizer/src
        ../../third_party/robin-map
+        ../../third_party/hat-trie
        ../../third_party/stb
        ../../libs/utils/include
        ../../libs/ktxreader/include
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.53.1
+VERSION_NAME=1.51.8

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

@@ -1,6 +1,6 @@
 #Wed Nov 17 10:40:18 PST 2021
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
@@ -44,6 +44,8 @@ function print_help {
    echo "        Exclude Vulkan support from the Android build."
    echo "    -s"
    echo "        Add iOS simulator support to the iOS build."
+    echo "    -t"
+    echo "        Enable SwiftShader support for Vulkan in desktop builds."
    echo "    -e"
    echo "        Enable EGL on Linux support for desktop builds."
    echo "    -l"
@@ -64,9 +66,6 @@ function print_help {
    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 "    -S type"
-    echo "        Enable stereoscopic rendering where type is one of [instanced|multiview]. This is only"
-    echo "        meant for building the samples."
    echo ""
    echo "Build types:"
    echo "    release"
@@ -166,6 +165,8 @@ INSTALL_COMMAND=
 VULKAN_ANDROID_OPTION="-DFILAMENT_SUPPORTS_VULKAN=ON"
 VULKAN_ANDROID_GRADLE_OPTION=""

+SWIFTSHADER_OPTION="-DFILAMENT_USE_SWIFTSHADER=OFF"
+
 EGL_ON_LINUX_OPTION="-DFILAMENT_SUPPORTS_EGL_ON_LINUX=OFF"

 MATDBG_OPTION="-DFILAMENT_ENABLE_MATDBG=OFF"
@@ -178,8 +179,6 @@ ASAN_UBSAN_OPTION=""

 BACKEND_DEBUG_FLAG_OPTION=""

-STEREOSCOPIC_OPTION=""
-
 IOS_BUILD_SIMULATOR=false
 BUILD_UNIVERSAL_LIBRARIES=false

@@ -234,12 +233,12 @@ function build_desktop_target {
            -DIMPORT_EXECUTABLES_DIR=out \
            -DCMAKE_BUILD_TYPE="$1" \
            -DCMAKE_INSTALL_PREFIX="../${lc_target}/filament" \
+            ${SWIFTSHADER_OPTION} \
            ${EGL_ON_LINUX_OPTION} \
            ${MATDBG_OPTION} \
            ${MATOPT_OPTION} \
            ${ASAN_UBSAN_OPTION} \
            ${BACKEND_DEBUG_FLAG_OPTION} \
-            ${STEREOSCOPIC_OPTION} \
            ${architectures} \
            ../..
        ln -sf "out/cmake-${lc_target}/compile_commands.json" \
@@ -374,7 +373,6 @@ function build_android_target {
            ${MATOPT_OPTION} \
            ${VULKAN_ANDROID_OPTION} \
            ${BACKEND_DEBUG_FLAG_OPTION} \
-            ${STEREOSCOPIC_OPTION} \
            ../..
        ln -sf "out/cmake-android-${lc_target}-${arch}/compile_commands.json" \
           ../../compile_commands.json
@@ -609,7 +607,7 @@ function build_ios_target {
            -DCMAKE_TOOLCHAIN_FILE=../../third_party/clang/iOS.cmake \
            ${MATDBG_OPTION} \
            ${MATOPT_OPTION} \
-            ${STEREOSCOPIC_OPTION} \
+            ${BACKEND_DEBUG_FLAG_OPTION} \
            ../..
        ln -sf "out/cmake-ios-${lc_target}-${arch}/compile_commands.json" \
           ../../compile_commands.json
@@ -796,7 +794,7 @@ function check_debug_release_build {

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

-while getopts ":hacCfgijmp:q:uvslwedk:bx:S:" opt; do
+while getopts ":hacCfgijmp:q:uvslwtedk:bx:" opt; do
    case ${opt} in
        h)
            print_help
@@ -915,6 +913,10 @@ while getopts ":hacCfgijmp:q:uvslwedk:bx:S:" opt; do
            IOS_BUILD_SIMULATOR=true
            echo "iOS simulator support enabled."
            ;;
+        t)
+            SWIFTSHADER_OPTION="-DFILAMENT_USE_SWIFTSHADER=ON"
+            echo "SwiftShader support enabled."
+            ;;
        e)
            EGL_ON_LINUX_OPTION="-DFILAMENT_SUPPORTS_EGL_ON_LINUX=ON -DFILAMENT_SKIP_SDL2=ON -DFILAMENT_SKIP_SAMPLES=ON"
            echo "EGL on Linux support enabled; skipping SDL2."
@@ -936,20 +938,6 @@ while getopts ":hacCfgijmp:q:uvslwedk:bx:S:" opt; do
            ;;
        x)  BACKEND_DEBUG_FLAG_OPTION="-DFILAMENT_BACKEND_DEBUG_FLAG=${OPTARG}"
            ;;
-        S)  case $(echo "${OPTARG}" | tr '[:upper:]' '[:lower:]') in
-                instanced)
-                    STEREOSCOPIC_OPTION="-DFILAMENT_SAMPLES_STEREO_TYPE=instanced"
-                    ;;
-                multiview)
-                    STEREOSCOPIC_OPTION="-DFILAMENT_SAMPLES_STEREO_TYPE=multiview"
-                    ;;
-                *)
-                    echo "Unknown stereoscopic type ${OPTARG}"
-                    echo "Type must be one of [instanced|multiview]"
-                    echo ""
-                    exit 1
-            esac
-            ;;
        \?)
            echo "Invalid option: -${OPTARG}" >&2
            echo ""
@@ -57,8 +57,7 @@ FILAMENT_NDK_VERSION=${FILAMENT_NDK_VERSION:-$(cat `dirname $0`/ndk.version)}

 # Install the required NDK version specifically (if not present)
 if [[ ! -d "${ANDROID_HOME}/ndk/$FILAMENT_NDK_VERSION" ]]; then
-    yes | ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager --licenses
-    ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager "ndk;$FILAMENT_NDK_VERSION"
+    ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager "ndk;$FILAMENT_NDK_VERSION" > /dev/null
 fi

 # Only build 1 64 bit target during presubmit to cut down build times during presubmit
@@ -1 +1 @@
-27.0.11718014
+26.1.10909125
@@ -0,0 +1,53 @@
+# Build the image:
+#   docker build --no-cache --tag ssfilament -f build/swiftshader/Dockerfile .
+#   docker tag ssfilament ghcr.io/filament-assets/swiftshader
+#
+# Publish the image:
+#   docker login ghcr.io --username <user> --password <token>
+#   docker push ghcr.io/filament-assets/swiftshader
+#
+# Run the image and mount the current directory:
+#   docker run -it -v `pwd`:/trees/filament -t ssfilament
+
+FROM ubuntu:focal
+WORKDIR /trees
+ARG DEBIAN_FRONTEND=noninteractive
+ENV SWIFTSHADER_LD_LIBRARY_PATH=/trees/swiftshader/build
+ENV CXXFLAGS='-fno-builtin -Wno-pass-failed'
+
+RUN apt-get update && \
+    apt-get --no-install-recommends install -y \
+	apt-transport-https \
+	apt-utils \
+	build-essential \
+	cmake \
+	ca-certificates \
+	git \
+	ninja-build \
+	python \
+	python3 \
+	xorg-dev \
+	clang-7 \
+	libc++-7-dev \
+	libc++abi-7-dev \
+	lldb
+
+# Ensure that clang is used instead of gcc.
+RUN set -eux ;\
+    update-alternatives --install /usr/bin/clang clang /usr/bin/clang-7 100 ;\
+    update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-7 100 ;\
+    update-alternatives --install /usr/bin/cc cc /usr/bin/clang 100 ;\
+    update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 100
+
+# Get patch files from the local Filament tree.
+COPY build/swiftshader/*.diff .
+
+# Clone SwiftShader, apply patches, and build it.
+RUN set -eux ;\
+	git clone https://swiftshader.googlesource.com/SwiftShader swiftshader ;\
+    cd swiftshader ;\
+	git checkout 139f5c3 ;\
+	git apply /trees/*.diff ;\
+    cd build ;\
+    cmake .. -GNinja -DCMAKE_BUILD_TYPE=Release ;\
+    ninja
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+
+from pathlib import Path
+import os
+
+spath = os.path.dirname(os.path.realpath(__file__))
+
+path = Path(spath)
+
+folder = "../../results/"
+
+images = list(path.glob(folder + '*.png'))
+
+images.sort()
+
+gallery = open(path.absolute().joinpath(folder + 'index.html'), 'w')
+
+gallery.write("""<html>
+<head>
+<script type="module" src="https://unpkg.com/img-comparison-slider@latest/dist/component/component.esm.js"></script>
+<script nomodule="" src="https://unpkg.com/img-comparison-slider@latest/dist/component/component.js"></script>
+<link rel="stylesheet" href="https://unpkg.com/img-comparison-slider@latest/dist/collection/styles/initial.css"/>
+<style>
+    h2 {
+        font-weight: normal;
+        margin-top: 150px;
+        margin-bottom: 20px;
+    }
+    a {
+        text-decoration: none;
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        color: blue;
+    }
+    a:hover {
+        font-weight: bold;
+    }
+</style>
+</head>
+<body>
+""")
+
+tag = ''
+
+for image in images:
+    group = image.stem.rstrip('0123456789')
+    before = f'https://filament-assets.github.io/golden/{group}/{image.name}'
+    after = image.name
+    gallery.write('\n')
+    gallery.write(f'<h2><a href="{image.stem}.json">{image.stem}.json</a></h2>\n')
+    gallery.write('<img-comparison-slider>\n')
+    gallery.write(f'<img slot="before" src="{before}" /> <img slot="after" src="{after}" />\n')
+    gallery.write('</img-comparison-slider>\n')
+
+gallery.write("""</body>
+</html>
+""")
@@ -0,0 +1,62 @@
+diff --git a/src/Vulkan/VkPipeline.cpp b/src/Vulkan/VkPipeline.cpp
+index 86913ec72..3b35345af 100644
+--- a/src/Vulkan/VkPipeline.cpp
+++ b/src/Vulkan/VkPipeline.cpp
+@@ -71,7 +71,56 @@ std::vector<uint32_t> preprocessSpirv(
+ 	if(optimize)
+ 	{
+ 		// Full optimization list taken from spirv-opt.
+-		opt.RegisterPerformancePasses();
+
+		// We have removed CreateRedundancyEliminationPass because it segfaults when encountering:
+		//     %389 = OpCompositeConstruct %7 %386 %387 %388 %86
+		// When inserting an entry into instruction_to_value_ (which is an unordered_map)
+		// This could perhaps be investigated further with help from asan.
+
+		using namespace spvtools;
+		opt.RegisterPass(CreateWrapOpKillPass())
+			.RegisterPass(CreateDeadBranchElimPass())
+			.RegisterPass(CreateMergeReturnPass())
+			.RegisterPass(CreateInlineExhaustivePass())
+			.RegisterPass(CreateAggressiveDCEPass())
+			.RegisterPass(CreatePrivateToLocalPass())
+			.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
+			.RegisterPass(CreateLocalSingleStoreElimPass())
+			.RegisterPass(CreateAggressiveDCEPass())
+			.RegisterPass(CreateScalarReplacementPass())
+			.RegisterPass(CreateLocalAccessChainConvertPass())
+			.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
+			.RegisterPass(CreateLocalSingleStoreElimPass())
+			.RegisterPass(CreateAggressiveDCEPass())
+			.RegisterPass(CreateLocalMultiStoreElimPass())
+			.RegisterPass(CreateAggressiveDCEPass())
+			.RegisterPass(CreateCCPPass())
+			.RegisterPass(CreateAggressiveDCEPass())
+			.RegisterPass(CreateLoopUnrollPass(true))
+			.RegisterPass(CreateDeadBranchElimPass())
+			.RegisterPass(CreateRedundancyEliminationPass()) // workaround for SEGFAULT
+			.RegisterPass(CreateCombineAccessChainsPass())
+			.RegisterPass(CreateSimplificationPass())
+			.RegisterPass(CreateScalarReplacementPass())
+			.RegisterPass(CreateLocalAccessChainConvertPass())
+			.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
+			.RegisterPass(CreateLocalSingleStoreElimPass())
+			.RegisterPass(CreateAggressiveDCEPass())
+			.RegisterPass(CreateSSARewritePass())
+			.RegisterPass(CreateAggressiveDCEPass())
+			.RegisterPass(CreateVectorDCEPass())
+			.RegisterPass(CreateDeadInsertElimPass())
+			.RegisterPass(CreateDeadBranchElimPass())
+			.RegisterPass(CreateSimplificationPass())
+			.RegisterPass(CreateIfConversionPass())
+			.RegisterPass(CreateCopyPropagateArraysPass())
+			.RegisterPass(CreateReduceLoadSizePass())
+			.RegisterPass(CreateAggressiveDCEPass())
+			.RegisterPass(CreateBlockMergePass())
+			.RegisterPass(CreateRedundancyEliminationPass()) // workaround for SEGFAULT
+			.RegisterPass(CreateDeadBranchElimPass())
+			.RegisterPass(CreateBlockMergePass())
+			.RegisterPass(CreateSimplificationPass());
+ 	}
+ 
+ 	std::vector<uint32_t> optimized;
@@ -0,0 +1,127 @@
+#!/bin/bash
+set -e
+
+function print_help {
+    local self_name=$(basename "$0")
+    echo "This script issues docker commands for testing Filament with SwiftShader."
+    echo "The usual sequence of commands is: fetch, start, build filament release, and run."
+    echo ""
+    echo "Usage:"
+    echo "    $self_name [command]"
+    echo ""
+    echo "Commands:"
+    echo "    build filament [debug | release]"
+    echo "        Use the container to build Filament."
+    echo "    build swiftshader [debug | release]"
+    echo "        Use the container to do a clean rebuild of SwiftShader."
+    echo "        (Note that the container already has SwiftShader built.)"
+    echo "    fetch"
+    echo "        Download the docker image from the central repository."
+    echo "    help"
+    echo "        Print this help message."
+    echo "    logs"
+    echo "        Print messages from the container's kernel ring buffer."
+    echo "        This is useful for diagnosing OOM issues."
+    echo "    run [lldb]"
+    echo "        Launch a test inside the container, optionally via lldb."
+    echo "    shell"
+    echo "        Interact with a bash prompt in the container."
+    echo "    start"
+    echo "        Start a container from the image."
+    echo "    stop"
+    echo "        Stop the container."
+    echo ""
+}
+
+# Change the current working directory to the Filament root.
+pushd "$(dirname "$0")/../.." > /dev/null
+
+if [[ "$1" == "build" ]] && [[ "$2" == "filament" ]]; then
+    docker exec runner filament/build.sh -t $3 gltf_viewer
+    exit $?
+fi
+
+if [[ "$1" == "build" ]] && [[ "$2" == "swiftshader" ]]; then
+    BUILD_TYPE="$3"
+    BUILD_TYPE="$(tr '[:lower:]' '[:upper:]' <<< ${BUILD_TYPE:0:1})${BUILD_TYPE:1}"
+    docker exec --workdir /trees/swiftshader runner rm -rf build
+    docker exec --workdir /trees/swiftshader runner mkdir build
+    docker exec --workdir /trees/swiftshader/build runner cmake -GNinja -DCMAKE_BUILD_TYPE="$BUILD_TYPE" ..
+    docker exec --workdir /trees/swiftshader/build runner ninja
+    exit $?
+fi
+
+if [[ "$1" == "fetch" ]]; then
+    docker pull ghcr.io/filament-assets/swiftshader:latest
+    docker tag ghcr.io/filament-assets/swiftshader:latest ssfilament
+    exit $?
+fi
+
+if [[ "$1" == "help" ]]; then
+    print_help
+    exit 0
+fi
+
+if [[ "$1" == "logs" ]]; then
+    docker exec runner dmesg --human --read-clear
+    exit $?
+fi
+
+if [[ "$1" == "run" ]] && [[ "$2" == "lldb" ]]; then
+    docker exec -i --workdir /trees/filament/results runner \
+          lldb --batch -o run -o bt -- \
+          ../out/cmake-release/samples/gltf_viewer \
+          --headless \
+          --batch ../libs/viewer/tests/basic.json \
+          --api vulkan
+    docker exec runner /trees/filament/build/swiftshader/gallery.py
+    exit $?
+fi
+
+if [[ "$1" == "run" ]]; then
+    docker exec --tty  --workdir /trees/filament/results runner \
+          /usr/bin/catchsegv \
+          ../out/cmake-release/samples/gltf_viewer \
+          --headless \
+          --batch ../libs/viewer/tests/basic.json \
+          --api vulkan
+    docker exec runner /trees/filament/build/swiftshader/gallery.py
+    exit $?
+fi
+
+if [[ "$1" == "shell" ]]; then
+    docker exec --interactive --tty runner /bin/bash
+    exit $?
+fi
+
+# Notes on options being passed to docker's run command:
+#
+# - The memory constraint seems to prevent an OOM signal in GitHub Actions.
+# - The cap / security args allow use of lldb and creation of core dumps.
+# - The privileged arg allows use of dmesg for examining OOM logs.
+#
+# Currently, a GitHub Actions VM has 2 CPUs, 7 GB RAM, and 14 GB of SSD disk space.
+#
+# Please be aware that Docker Desktop might impose additional resource constraints, and that those
+# settings can only be controlled with its GUI. We recommend at least 7 GB of memory and 2 GB swap.
+if [[ "$1" == "start" ]]; then
+    mkdir -p results
+    docker run --tty --rm --detach --privileged \
+          --memory 6.5g \
+          --name runner \
+          --cap-add=SYS_PTRACE \
+          --security-opt seccomp=unconfined \
+          --security-opt apparmor=unconfined \
+          --volume `pwd`:/trees/filament \
+          --workdir /trees \
+          ssfilament
+    exit $?
+fi
+
+if [[ "$1" == "stop" ]]; then
+    docker container rm runner --force
+    exit $?
+fi
+
+print_help
+exit 1
@@ -66,7 +66,7 @@ set(PRIVATE_HDRS
 # OpenGL / OpenGL ES Sources
 # ==================================================================================================

-if (FILAMENT_SUPPORTS_OPENGL AND NOT FILAMENT_USE_EXTERNAL_GLES3)
+if (FILAMENT_SUPPORTS_OPENGL AND NOT FILAMENT_USE_EXTERNAL_GLES3 AND NOT FILAMENT_USE_SWIFTSHADER)
    list(APPEND SRCS
            include/backend/platforms/OpenGLPlatform.h
            src/opengl/gl_headers.cpp
@@ -417,9 +417,7 @@ if (APPLE OR LINUX)
        test/test_MissingRequiredAttributes.cpp
        test/test_ReadPixels.cpp
        test/test_BufferUpdates.cpp
-        test/test_Callbacks.cpp
        test/test_MRT.cpp
-        test/test_PushConstants.cpp
        test/test_LoadImage.cpp
        test/test_StencilBuffer.cpp
        test/test_Scissor.cpp
@@ -22,7 +22,6 @@
 #include <utils/BitmaskEnum.h>
 #include <utils/unwindows.h> // Because we define ERROR in the FenceStatus enum.

-#include <backend/Platform.h>
 #include <backend/PresentCallable.h>

 #include <utils/Invocable.h>
@@ -118,7 +117,7 @@ static_assert(MAX_VERTEX_BUFFER_COUNT <= MAX_VERTEX_ATTRIBUTE_COUNT,
        "The number of buffer objects that can be attached to a VertexBuffer must be "
        "less than or equal to the maximum number of vertex attributes.");

-static constexpr size_t CONFIG_UNIFORM_BINDING_COUNT = 9;   // This is guaranteed by OpenGL ES.
+static constexpr size_t CONFIG_UNIFORM_BINDING_COUNT = 10;  // This is guaranteed by OpenGL ES.
 static constexpr size_t CONFIG_SAMPLER_BINDING_COUNT = 4;   // This is guaranteed by OpenGL ES.

 /**
@@ -1251,7 +1250,13 @@ enum class Workaround : uint16_t {
    POWER_VR_SHADER_WORKAROUNDS,
 };

-using StereoscopicType = backend::Platform::StereoscopicType;
+//! The type of technique for stereoscopic rendering
+enum class StereoscopicType : uint8_t {
+    // Stereoscopic rendering is performed using instanced rendering technique.
+    INSTANCED,
+    // Stereoscopic rendering is performed using the multiview feature from the graphics backend.
+    MULTIVIEW,
+};

 } // namespace filament::backend

@@ -41,26 +41,6 @@ public:
    struct Fence {};
    struct Stream {};

-    /**
-     * The type of technique for stereoscopic rendering. (Note that the materials used will need to
-     * be compatible with the chosen technique.)
-     */
-    enum class StereoscopicType : uint8_t {
-        /**
-         * No stereoscopic rendering
-         */
-        NONE,
-        /**
-         * Stereoscopic rendering is performed using instanced rendering technique.
-         */
-        INSTANCED,
-        /**
-         * Stereoscopic rendering is performed using the multiview feature from the graphics
-         * backend.
-         */
-        MULTIVIEW,
-    };
-
    struct DriverConfig {
        /**
         * Size of handle arena in bytes. Setting to 0 indicates default value is to be used.
@@ -91,11 +71,6 @@ public:
         * GLES 3.x backends.
         */
        bool forceGLES2Context = false;
-
-        /**
-         * Sets the technique for stereoscopic rendering.
-         */
-        StereoscopicType stereoscopicType = StereoscopicType::NONE;
    };

    Platform() noexcept;
@@ -90,13 +90,8 @@ protected:
    AcquiredImage transformAcquiredImage(AcquiredImage source) noexcept override;

 private:
-    struct InitializeJvmForPerformanceManagerIfNeeded {
-        InitializeJvmForPerformanceManagerIfNeeded();
-    };
-
    int mOSVersion;
    ExternalStreamManagerAndroid& mExternalStreamManager;
-    InitializeJvmForPerformanceManagerIfNeeded const mInitializeJvmForPerformanceManagerIfNeeded;
    utils::PerformanceHintManager mPerformanceHintManager;
    utils::PerformanceHintManager::Session mPerformanceHintSession;

@@ -23,9 +23,9 @@

 #include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
-#include <utils/Hash.h>
 #include <utils/PrivateImplementation.h>

+#include <string_view>
 #include <tuple>
 #include <unordered_set>

@@ -47,14 +47,6 @@ struct VulkanPlatformPrivate;
 class VulkanPlatform : public Platform, utils::PrivateImplementation<VulkanPlatformPrivate> {
 public:

-    struct ExtensionHashFn {
-        std::size_t operator()(utils::CString const& s) const noexcept {
-            return std::hash<std::string>{}(s.data());
-        }
-    };
-    // Utility for managing device or instance extensions during initialization.
-    using ExtensionSet = std::unordered_set<utils::CString, ExtensionHashFn>;
-
    /**
     * A collection of handles to objects and metadata that comprises a Vulkan context. The client
     * can instantiate this struct and pass to Engine::Builder::sharedContext if they wishes to
@@ -90,20 +82,6 @@ public:
        VkExtent2D extent = {0, 0};
    };

-    struct ImageSyncData {
-        static constexpr uint32_t INVALID_IMAGE_INDEX = UINT32_MAX;
-
-        // The index of the next image as returned by vkAcquireNextImage or equivalent.
-        uint32_t imageIndex = INVALID_IMAGE_INDEX;
-
-        // Semaphore to be signaled once the image is available.
-        VkSemaphore imageReadySemaphore = VK_NULL_HANDLE;
-
-        // A function called right before vkQueueSubmit. After this call, the image must be 
-        // available. This pointer can be null if imageReadySemaphore is not VK_NULL_HANDLE.
-        std::function<void(SwapChainPtr handle)> explicitImageReadyWait = nullptr;
-    };
-
    VulkanPlatform();

    ~VulkanPlatform() override;
@@ -141,12 +119,6 @@ public:
         * before recreating the swapchain. Default is true.
         */
        bool flushAndWaitOnWindowResize = true;
-
-        /**
-         * Whether the swapchain image should be transitioned to a layout suitable for
-         * presentation. Default is true.
-         */
-        bool transitionSwapChainImageLayoutForPresent = true;
    };

    /**
@@ -175,10 +147,13 @@ public:
     * corresponding VkImage will be used as the output color attachment. The client should signal
     * the `clientSignal` semaphore when the image is ready to be used by the backend.
     * @param handle         The handle returned by createSwapChain()
-     * @param outImageSyncData The synchronization data used for image readiness
+     * @param clientSignal   The semaphore that the client will signal to indicate that the backend
+     *                       may render into the image.
+     * @param index          Pointer to memory that will be filled with the index that corresponding
+     *                       to an image in the `SwapChainBundle.colors` array.
     * @return               Result of acquire
     */
-    virtual VkResult acquire(SwapChainPtr handle, ImageSyncData* outImageSyncData);
+    virtual VkResult acquire(SwapChainPtr handle, VkSemaphore clientSignal, uint32_t* index);

    /**
     * Present the image corresponding to `index` to the display. The client should wait on
@@ -217,13 +192,6 @@ public:
    virtual SwapChainPtr createSwapChain(void* nativeWindow, uint64_t flags = 0,
            VkExtent2D extent = {0, 0});

-    /**
-     * Allows implementers to provide instance extensions that they'd like to include in the
-     * instance creation.
-     * @return          A set of extensions to enable for the instance.
-     */
-    virtual ExtensionSet getRequiredInstanceExtensions() { return {}; }
-
    /**
     * Destroy the swapchain.
     * @param handle    The handle returned by createSwapChain()
@@ -268,9 +236,10 @@ public:
    VkQueue getGraphicsQueue() const noexcept;

 private:
-    static ExtensionSet getSwapchainInstanceExtensions();
-
    // Platform dependent helper methods
+    using ExtensionSet = std::unordered_set<std::string_view>;
+    static ExtensionSet getRequiredInstanceExtensions();
+
    using SurfaceBundle = std::tuple<VkSurfaceKHR, VkExtent2D>;
    static SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
            uint64_t flags) noexcept;
@@ -144,7 +144,8 @@ DECL_DRIVER_API_N(setFrameScheduledCallback,
 DECL_DRIVER_API_N(setFrameCompletedCallback,
        backend::SwapChainHandle, sch,
        backend::CallbackHandler*, handler,
-        utils::Invocable<void(void)>&&, callback)
+        backend::CallbackHandler::Callback, callback,
+        void*, user)

 DECL_DRIVER_API_N(setPresentationTime,
        int64_t, monotonic_clock_ns)
@@ -300,7 +301,7 @@ DECL_DRIVER_API_SYNCHRONOUS_0(bool, isFrameTimeSupported)
 DECL_DRIVER_API_SYNCHRONOUS_0(bool, isAutoDepthResolveSupported)
 DECL_DRIVER_API_SYNCHRONOUS_0(bool, isSRGBSwapChainSupported)
 DECL_DRIVER_API_SYNCHRONOUS_0(bool, isProtectedContentSupported)
-DECL_DRIVER_API_SYNCHRONOUS_0(bool, isStereoSupported)
+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)
@@ -501,7 +502,7 @@ DECL_DRIVER_API_N(blit,
        math::uint2, size)

 DECL_DRIVER_API_N(bindPipeline,
-        backend::PipelineState const&, state)
+        backend::PipelineState, state)

 DECL_DRIVER_API_N(bindRenderPrimitive,
        backend::RenderPrimitiveHandle, rph)
@@ -173,8 +173,8 @@ public:
                uint8_t const age = (tag & HANDLE_AGE_MASK) >> HANDLE_AGE_SHIFT;
                auto const pNode = static_cast<typename Allocator::Node*>(p);
                uint8_t const expectedAge = pNode[-1].age;
-                FILAMENT_CHECK_POSTCONDITION(expectedAge == age) <<
-                        "use-after-free of Handle with id=" << handle.getId();
+                ASSERT_POSTCONDITION(expectedAge == age,
+                        "use-after-free of Handle with id=%d", handle.getId());
            }
        }

@@ -240,8 +240,8 @@ private:
            Node* const pNode = static_cast<Node*>(p);
            uint8_t& expectedAge = pNode[-1].age;
            if (UTILS_UNLIKELY(!mUseAfterFreeCheckDisabled)) {
-                FILAMENT_CHECK_POSTCONDITION(expectedAge == age) <<
-                        "double-free of Handle of size " << size << " at " << p;
+                ASSERT_POSTCONDITION(expectedAge == age,
+                        "double-free of Handle of size %d at %p", size, p);
            }
            expectedAge = (expectedAge + 1) & 0xF; // fixme

@@ -27,8 +27,8 @@ PresentCallable::PresentCallable(PresentFn fn, void* user) noexcept
 }

 void PresentCallable::operator()(bool presentFrame) noexcept {
-    FILAMENT_CHECK_PRECONDITION(mPresentFn) << "This PresentCallable was already called. "
-                                               "PresentCallables should be called exactly once.";
+    ASSERT_PRECONDITION(mPresentFn, "This PresentCallable was already called. " \
+            "PresentCallables should be called exactly once.");
    mPresentFn(presentFrame, mUser);
    // Set mPresentFn to nullptr to denote that the callable has been called.
    mPresentFn = nullptr;
@@ -119,9 +119,9 @@ void* CircularBuffer::alloc(size_t size) noexcept {
        data = mmap(nullptr, size * 2 + BLOCK_SIZE,
                PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

-        FILAMENT_CHECK_POSTCONDITION(data) <<
-                "couldn't allocate " << (size * 2 / 1024) <<
-                " KiB of virtual address space for the command buffer";
+        ASSERT_POSTCONDITION(data,
+                "couldn't allocate %u KiB of virtual address space for the command buffer",
+                (size * 2 / 1024));

        slog.d << "WARNING: Using soft CircularBuffer (" << (size * 2 / 1024) << " KiB)"
               << io::endl;
@@ -74,6 +74,8 @@ void CommandBufferQueue::setPaused(bool paused) {

 bool CommandBufferQueue::isExitRequested() const {
    std::lock_guard<utils::Mutex> const lock(mLock);
+    ASSERT_PRECONDITION( mExitRequested == 0 || mExitRequested == EXIT_REQUESTED,
+            "mExitRequested is corrupted (value = 0x%08x)!", mExitRequested);
    return (bool)mExitRequested;
 }

@@ -106,11 +108,11 @@ void CommandBufferQueue::flush() noexcept {
    mCondition.notify_one();

    // circular buffer is too small, we corrupted the stream
-    FILAMENT_CHECK_POSTCONDITION(used <= mFreeSpace) <<
+    ASSERT_POSTCONDITION(used <= mFreeSpace,
            "Backend CommandStream overflow. Commands are corrupted and unrecoverable.\n"
            "Please increase minCommandBufferSizeMB inside the Config passed to Engine::create.\n"
-            "Space used at this time: " << used <<
-            " bytes, overflow: " << used - mFreeSpace << " bytes";
+            "Space used at this time: %u bytes, overflow: %u bytes",
+            (unsigned)used, unsigned(used - mFreeSpace));

    // wait until there is enough space in the buffer
    mFreeSpace -= used;
@@ -129,11 +131,9 @@ void CommandBufferQueue::flush() noexcept {
 #endif

        SYSTRACE_NAME("waiting: CircularBuffer::flush()");
-
-        FILAMENT_CHECK_POSTCONDITION(!mPaused) <<
+        ASSERT_POSTCONDITION(!mPaused,
                "CommandStream is full, but since the rendering thread is paused, "
-                "the buffer cannot flush and we will deadlock. Instead, abort.";
-
+                "the buffer cannot flush and we will deadlock. Instead, abort.");
        mCondition.wait(lock, [this, requiredSize]() -> bool {
            // TODO: on macOS, we need to call pumpEvents from time to time
            return mFreeSpace >= requiredSize;
@@ -149,6 +149,10 @@ std::vector<CommandBufferQueue::Range> CommandBufferQueue::waitForCommands() con
    while ((mCommandBuffersToExecute.empty() || mPaused) && !mExitRequested) {
        mCondition.wait(lock);
    }
+
+    ASSERT_PRECONDITION( mExitRequested == 0 || mExitRequested == EXIT_REQUESTED,
+            "mExitRequested is corrupted (value = 0x%08x)!", mExitRequested);
+
    return std::move(mCommandBuffersToExecute);
 }

@@ -113,9 +113,9 @@ HandleBase::HandleId HandleAllocator<P0, P1, P2>::allocateHandleSlow(size_t size

    HandleBase::HandleId id = (++mId) | HANDLE_HEAP_FLAG;

-    FILAMENT_CHECK_POSTCONDITION(mId < HANDLE_HEAP_FLAG) <<
+    ASSERT_POSTCONDITION(mId < HANDLE_HEAP_FLAG,
            "No more Handle ids available! This can happen if HandleAllocator arena has been full"
-            " for a while. Please increase FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB";
+            " for a while. Please increase FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB");

    mOverflowMap.emplace(id, p);
    lock.unlock();
@@ -29,21 +29,21 @@
        #include "backend/platforms/PlatformCocoaTouchGL.h"
    #endif
 #elif defined(__APPLE__)
-    #if defined(FILAMENT_SUPPORTS_OPENGL) && !defined(FILAMENT_USE_EXTERNAL_GLES3)
+    #if defined(FILAMENT_SUPPORTS_OPENGL) && !defined(FILAMENT_USE_EXTERNAL_GLES3) && !defined(FILAMENT_USE_SWIFTSHADER)
        #include <backend/platforms/PlatformCocoaGL.h>
    #endif
 #elif defined(__linux__)
    #if defined(FILAMENT_SUPPORTS_X11)
-        #if defined(FILAMENT_SUPPORTS_OPENGL) && !defined(FILAMENT_USE_EXTERNAL_GLES3)
+        #if defined(FILAMENT_SUPPORTS_OPENGL) && !defined(FILAMENT_USE_EXTERNAL_GLES3) && !defined(FILAMENT_USE_SWIFTSHADER)
            #include "backend/platforms/PlatformGLX.h"
        #endif
    #elif defined(FILAMENT_SUPPORTS_EGL_ON_LINUX)
-        #if defined(FILAMENT_SUPPORTS_OPENGL) && !defined(FILAMENT_USE_EXTERNAL_GLES3)
+        #if defined(FILAMENT_SUPPORTS_OPENGL) && !defined(FILAMENT_USE_EXTERNAL_GLES3) && !defined(FILAMENT_USE_SWIFTSHADER)
            #include "backend/platforms/PlatformEGLHeadless.h"
        #endif
    #endif
 #elif defined(WIN32)
-    #if defined(FILAMENT_SUPPORTS_OPENGL) && !defined(FILAMENT_USE_EXTERNAL_GLES3)
+    #if defined(FILAMENT_SUPPORTS_OPENGL) && !defined(FILAMENT_USE_EXTERNAL_GLES3) && !defined(FILAMENT_USE_SWIFTSHADER)
        #include "backend/platforms/PlatformWGL.h"
    #endif
 #elif defined(__EMSCRIPTEN__)
@@ -111,7 +111,8 @@ Platform* PlatformFactory::create(Backend* backend) noexcept {
    }
    assert_invariant(*backend == Backend::OPENGL);
    #if defined(FILAMENT_SUPPORTS_OPENGL)
-        #if defined(FILAMENT_USE_EXTERNAL_GLES3)
+        #if defined(FILAMENT_USE_EXTERNAL_GLES3) || defined(FILAMENT_USE_SWIFTSHADER)
+            // Swiftshader OpenGLES support is deprecated and incomplete
            return nullptr;
        #elif defined(__ANDROID__)
            return new PlatformEGLAndroid();
@@ -16,23 +16,13 @@

 #include "private/backend/VirtualMachineEnv.h"

-#include <utils/compiler.h>
 #include <utils/debug.h>

-#include <jni.h>
-
 namespace filament {

 JavaVM* VirtualMachineEnv::sVirtualMachine = nullptr;

-/*
- * This is typically called by filament_jni.so when it is loaded. If filament_jni.so is not used,
- * then this must be called manually -- however, this is a problem because VirtualMachineEnv.h
- * is currently private and part of backend.
- * For now, we authorize this usage, but we will need to fix it; by making a proper public
- * API for this.
- */
-UTILS_PUBLIC
+// This is called when the library is loaded. We need this to get a reference to the global VM
 UTILS_NOINLINE
 jint VirtualMachineEnv::JNI_OnLoad(JavaVM* vm) noexcept {
    JNIEnv* env = nullptr;
@@ -109,8 +109,9 @@ inline bool MTLSizeEqual(T a, T b) noexcept {
 MetalBlitter::MetalBlitter(MetalContext& context) noexcept : mContext(context) { }

 void MetalBlitter::blit(id<MTLCommandBuffer> cmdBuffer, const BlitArgs& args, const char* label) {
-    FILAMENT_CHECK_PRECONDITION(args.source.region.size.depth == args.destination.region.size.depth)
-            << "Blitting requires the source and destination regions to have the same depth.";
+
+    ASSERT_PRECONDITION(args.source.region.size.depth == args.destination.region.size.depth,
+            "Blitting requires the source and destination regions to have the same depth.");

    // Determine if the blit for color or depth are eligible to use a MTLBlitCommandEncoder.
    // blitFastPath returns true upon success.
@@ -326,8 +327,7 @@ id<MTLFunction> MetalBlitter::compileFragmentFunction(BlitFunctionKey key) const
            utils::slog.e << description << utils::io::endl;
        }
    }
-    FILAMENT_CHECK_POSTCONDITION(library && function)
-            << "Unable to compile fragment shader for MetalBlitter.";
+    ASSERT_POSTCONDITION(library && function, "Unable to compile fragment shader for MetalBlitter.");

    return function;
 }
@@ -352,8 +352,7 @@ id<MTLFunction> MetalBlitter::getBlitVertexFunction() {
            utils::slog.e << description << utils::io::endl;
        }
    }
-    FILAMENT_CHECK_POSTCONDITION(library && function)
-            << "Unable to compile vertex shader for MetalBlitter.";
+    ASSERT_POSTCONDITION(library && function, "Unable to compile vertex shader for MetalBlitter.");

    mVertexFunction = function;

@@ -65,9 +65,12 @@ private:
    const char* mName;
 };

-class TrackedMetalBuffer {
-public:
+#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 {
@@ -91,66 +94,57 @@ public:
        }
    }

-    TrackedMetalBuffer() noexcept : mBuffer(nil) {}
-    TrackedMetalBuffer(nullptr_t) noexcept : mBuffer(nil) {}
-    TrackedMetalBuffer(id<MTLBuffer> buffer, Type type) : mBuffer(buffer), mType(type) {
+#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 void setPlatform(MetalPlatform* p) { platform = p; }
+
+    static void track(id<MTLBuffer> buffer, Type type) {
        assert_invariant(type != Type::NONE);
-        if (buffer) {
-            aliveBuffers[toIndex(type)]++;
-            mType = type;
-            if (getAliveBuffers() >= EXCESS_BUFFER_COUNT) {
-                if (platform && platform->hasDebugUpdateStatFunc()) {
-                    platform->debugUpdateStat("filament.metal.excess_buffers_allocated",
-                            TrackedMetalBuffer::getAliveBuffers());
-                }
+        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];
    }

-    ~TrackedMetalBuffer() {
-        if (mBuffer) {
-            assert_invariant(mType != Type::NONE);
-            aliveBuffers[toIndex(mType)]--;
-        }
-    }
-
-    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() {
        uint64_t sum = 0;
-        for (const auto& v : aliveBuffers) {
-            sum += v;
+        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);
-        return aliveBuffers[toIndex(type)];
+        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;
    }
-    static void setPlatform(MetalPlatform* p) { platform = p; }
+#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:
-    void swap(TrackedMetalBuffer& other) noexcept {
-        std::swap(mBuffer, other.mBuffer);
-        std::swap(mType, other.mType);
-    }
-
-    id<MTLBuffer> mBuffer;
-    Type mType = Type::NONE;
-
+#if FILAMENT_METAL_BUFFER_TRACKING
+    static std::array<NSHashTable<id<MTLBuffer>>*, TypeCount> aliveBuffers;
    static MetalPlatform* platform;
-    static std::array<uint64_t, TypeCount> aliveBuffers;
+#endif
 };

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

 private:

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

@@ -275,11 +271,11 @@ public:
            // finishes executing.
            {
                ScopedAllocationTimer timer("ring");
-                mAuxBuffer = { [mDevice newBufferWithLength:mSlotSizeBytes options:mBufferOptions],
-                    TrackedMetalBuffer::Type::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);
@@ -308,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 {
@@ -319,8 +315,8 @@ public:

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

    MTLResourceOptions mBufferOptions;

@@ -22,10 +22,14 @@
 namespace filament {
 namespace backend {

-std::array<uint64_t, TrackedMetalBuffer::TypeCount> TrackedMetalBuffer::aliveBuffers = { 0 };
-MetalPlatform* TrackedMetalBuffer::platform = nullptr;
 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) {
    // If the buffer is less than 4K in size and is updated frequently, we don't use an explicit
@@ -41,11 +45,10 @@ MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType,
    // Otherwise, we allocate a private GPU buffer.
    {
        ScopedAllocationTimer timer("generic");
-        mBuffer = { [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate],
-            TrackedMetalBuffer::Type::GENERIC };
+        mBuffer = [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate];
    }
-    FILAMENT_CHECK_POSTCONDITION(mBuffer)
-            << "Could not allocate Metal buffer of size " << size << ".";
+    MetalBufferTracking::track(mBuffer, MetalBufferTracking::Type::GENERIC);
+    ASSERT_POSTCONDITION(mBuffer, "Could not allocate Metal buffer of size %zu.", size);
 }

 MetalBuffer::~MetalBuffer() {
@@ -58,9 +61,9 @@ void MetalBuffer::copyIntoBuffer(void* src, size_t size, size_t byteOffset) {
    if (size <= 0) {
        return;
    }
-    FILAMENT_CHECK_PRECONDITION(size + byteOffset <= mBufferSize)
-            << "Attempting to copy " << size << " bytes into a buffer of size " << mBufferSize
-            << " at offset " << byteOffset;
+    ASSERT_PRECONDITION(size + byteOffset <= mBufferSize,
+            "Attempting to copy %zu bytes into a buffer of size %zu at offset %zu",
+            size, mBufferSize, byteOffset);

    // Either copy into the Metal buffer or into our cpu buffer.
    if (mCpuBuffer) {
@@ -71,18 +74,18 @@ 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.
-    FILAMENT_CHECK_PRECONDITION(!(byteOffset & 0x3u)) << "byteOffset must be a multiple of 4";
+    ASSERT_PRECONDITION(!(byteOffset & 0x3u), "byteOffset must be a multiple of 4");

    // Encode a blit from the staging buffer into the private GPU buffer.
    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];
@@ -103,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;
@@ -48,10 +48,10 @@ MetalBufferPoolEntry const* MetalBufferPool::acquireBuffer(size_t numBytes) {
        buffer = [mContext.device newBufferWithLength:numBytes
                                              options:MTLResourceStorageModeShared];
    }
-    FILAMENT_CHECK_POSTCONDITION(buffer)
-            << "Could not allocate Metal staging buffer of size " << numBytes << ".";
+    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, TrackedMetalBuffer::Type::STAGING },
+        .buffer = buffer,
        .capacity = numBytes,
        .lastAccessed = mCurrentFrame,
        .referenceCount = 1
@@ -55,18 +55,6 @@ struct MetalVertexBuffer;

 constexpr static uint8_t MAX_SAMPLE_COUNT = 8;  // Metal devices support at most 8 MSAA samples

-class MetalPushConstantBuffer {
-public:
-    void setPushConstant(PushConstantVariant value, uint8_t index);
-    bool isDirty() const { return mDirty; }
-    void setBytes(id<MTLCommandEncoder> encoder, ShaderStage stage);
-    void clear();
-
-private:
-    std::vector<PushConstantVariant> mPushConstants;
-    bool mDirty = false;
-};
-
 struct MetalContext {
    explicit MetalContext(size_t metalFreedTextureListSize)
        : texturesToDestroy(metalFreedTextureListSize) {}
@@ -121,8 +109,6 @@ struct MetalContext {

    PolygonOffset currentPolygonOffset = {0.0f, 0.0f};

-    std::array<MetalPushConstantBuffer, Program::SHADER_TYPE_COUNT> currentPushConstants;
-
    MetalSamplerGroup* samplerBindings[Program::SAMPLER_BINDING_COUNT] = {};

    // Keeps track of sampler groups we've finalized for the current render pass.
@@ -113,8 +113,7 @@ id<MTLCommandBuffer> getPendingCommandBuffer(MetalContext* context) {
            }
        }
    }];
-    FILAMENT_CHECK_POSTCONDITION(context->pendingCommandBuffer)
-            << "Could not obtain command buffer.";
+    ASSERT_POSTCONDITION(context->pendingCommandBuffer, "Could not obtain command buffer.");
    return context->pendingCommandBuffer;
 }

@@ -154,68 +153,5 @@ bool isInRenderPass(MetalContext* context) {
    return context->currentRenderPassEncoder != nil;
 }

-void MetalPushConstantBuffer::setPushConstant(PushConstantVariant value, uint8_t index) {
-    if (mPushConstants.size() <= index) {
-        mPushConstants.resize(index + 1);
-        mDirty = true;
-    }
-    if (UTILS_LIKELY(mPushConstants[index] != value)) {
-        mDirty = true;
-        mPushConstants[index] = value;
-    }
-}
-
-void MetalPushConstantBuffer::setBytes(id<MTLCommandEncoder> encoder, ShaderStage stage) {
-    constexpr size_t PUSH_CONSTANT_SIZE_BYTES = 4;
-    constexpr size_t PUSH_CONSTANT_BUFFER_INDEX = 26;
-
-    static char buffer[MAX_PUSH_CONSTANT_COUNT * PUSH_CONSTANT_SIZE_BYTES];
-    assert_invariant(mPushConstants.size() <= MAX_PUSH_CONSTANT_COUNT);
-
-    size_t bufferSize = PUSH_CONSTANT_SIZE_BYTES * mPushConstants.size();
-    for (size_t i = 0; i < mPushConstants.size(); i++) {
-        const auto& constant = mPushConstants[i];
-        std::visit(
-                [i](auto arg) {
-                    if constexpr (std::is_same_v<decltype(arg), bool>) {
-                        // bool push constants are converted to uints in MSL.
-                        // We must ensure we write all the bytes for boolean values to work
-                        // correctly.
-                        uint32_t boolAsUint = arg ? 0x00000001 : 0x00000000;
-                        *(reinterpret_cast<uint32_t*>(buffer + PUSH_CONSTANT_SIZE_BYTES * i)) =
-                                boolAsUint;
-                    } else {
-                        *(decltype(arg)*)(buffer + PUSH_CONSTANT_SIZE_BYTES * i) = arg;
-                    }
-                },
-                constant);
-    }
-
-    switch (stage) {
-        case ShaderStage::VERTEX:
-            [(id<MTLRenderCommandEncoder>)encoder setVertexBytes:buffer
-                                                          length:bufferSize
-                                                         atIndex:PUSH_CONSTANT_BUFFER_INDEX];
-            break;
-        case ShaderStage::FRAGMENT:
-            [(id<MTLRenderCommandEncoder>)encoder setFragmentBytes:buffer
-                                                            length:bufferSize
-                                                           atIndex:PUSH_CONSTANT_BUFFER_INDEX];
-            break;
-        case ShaderStage::COMPUTE:
-            [(id<MTLComputeCommandEncoder>)encoder setBytes:buffer
-                                                     length:bufferSize
-                                                    atIndex:PUSH_CONSTANT_BUFFER_INDEX];
-            break;
-    }
-
-    mDirty = false;
-}
-
-void MetalPushConstantBuffer::clear() {
-    mPushConstants.clear();
-    mDirty = false;
-}
-
 } // namespace backend
 } // namespace filament
@@ -17,7 +17,6 @@
 #ifndef TNT_FILAMENT_DRIVER_METALDRIVER_H
 #define TNT_FILAMENT_DRIVER_METALDRIVER_H

-#include <backend/DriverEnums.h>
 #include "private/backend/Driver.h"
 #include "DriverBase.h"

@@ -141,7 +140,6 @@ private:
    void enumerateBoundBuffers(BufferObjectBinding bindingType,
            const std::function<void(const BufferState&, MetalBuffer*, uint32_t)>& f);

-    backend::StereoscopicType const mStereoscopicType;
 };

 } // namespace backend
@@ -102,12 +102,12 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
          mContext(new MetalContext(driverConfig.textureUseAfterFreePoolSize)),
          mHandleAllocator("Handles",
                  driverConfig.handleArenaSize,
-                  driverConfig.disableHandleUseAfterFreeCheck),
-          mStereoscopicType(driverConfig.stereoscopicType) {
+                  driverConfig.disableHandleUseAfterFreeCheck) {
    mContext->driver = this;

-    TrackedMetalBuffer::setPlatform(platform);
    ScopedAllocationTimer::setPlatform(platform);
+    MetalBufferTracking::initialize();
+    MetalBufferTracking::setPlatform(platform);

    mContext->device = mPlatform.createDevice();
    assert_invariant(mContext->device);
@@ -181,8 +181,7 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&

    CVReturn success = CVMetalTextureCacheCreate(kCFAllocatorDefault, nullptr, mContext->device,
            nullptr, &mContext->textureCache);
-    FILAMENT_CHECK_POSTCONDITION(success == kCVReturnSuccess)
-            << "Could not create Metal texture cache.";
+    ASSERT_POSTCONDITION(success == kCVReturnSuccess, "Could not create Metal texture cache.");

    if (@available(iOS 12, *)) {
        dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);
@@ -203,7 +202,7 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
 }

 MetalDriver::~MetalDriver() noexcept {
-    TrackedMetalBuffer::setPlatform(nullptr);
+    MetalBufferTracking::setPlatform(nullptr);
    ScopedAllocationTimer::setPlatform(nullptr);
    mContext->device = nil;
    mContext->emptyTexture = nil;
@@ -225,13 +224,16 @@ void MetalDriver::beginFrame(int64_t monotonic_clock_ns,
    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());
-        mPlatform.debugUpdateStat("filament.metal.alive_buffers.generic",
-                TrackedMetalBuffer::getAliveBuffers(TrackedMetalBuffer::Type::GENERIC));
-        mPlatform.debugUpdateStat("filament.metal.alive_buffers.ring",
-                TrackedMetalBuffer::getAliveBuffers(TrackedMetalBuffer::Type::RING));
-        mPlatform.debugUpdateStat("filament.metal.alive_buffers.staging",
-                TrackedMetalBuffer::getAliveBuffers(TrackedMetalBuffer::Type::STAGING));
+#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
    }
 }

@@ -241,10 +243,10 @@ void MetalDriver::setFrameScheduledCallback(
    swapChain->setFrameScheduledCallback(handler, std::move(callback));
 }

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

 void MetalDriver::execute(std::function<void(void)> const& fn) noexcept {
@@ -290,14 +292,14 @@ void MetalDriver::endFrame(uint32_t frameId) {
 }

 void MetalDriver::flush(int) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "flush must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+                        "flush must be called outside of a render pass.");
    submitPendingCommands(mContext);
 }

 void MetalDriver::finish(int) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "finish must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+            "finish must be called outside of a render pass.");
    // Wait for all frames to finish by submitting and waiting on a dummy command buffer.
    submitPendingCommands(mContext);
    id<MTLCommandBuffer> oneOffBuffer = [mContext->commandQueue commandBuffer];
@@ -358,19 +360,19 @@ void MetalDriver::importTextureR(Handle<HwTexture> th, intptr_t i,
        TextureFormat format, uint8_t samples, uint32_t width, uint32_t height,
        uint32_t depth, TextureUsage usage) {
    id<MTLTexture> metalTexture = (id<MTLTexture>) CFBridgingRelease((void*) i);
-    FILAMENT_CHECK_PRECONDITION(metalTexture.width == width)
-            << "Imported id<MTLTexture> width (" << metalTexture.width
-            << ") != Filament texture width (" << width << ")";
-    FILAMENT_CHECK_PRECONDITION(metalTexture.height == height)
-            << "Imported id<MTLTexture> height (" << metalTexture.height
-            << ") != Filament texture height (" << height << ")";
-    FILAMENT_CHECK_PRECONDITION(metalTexture.mipmapLevelCount == levels)
-            << "Imported id<MTLTexture> levels (" << metalTexture.mipmapLevelCount
-            << ") != Filament texture levels (" << levels << ")";
+    ASSERT_PRECONDITION(metalTexture.width == width,
+            "Imported id<MTLTexture> width (%d) != Filament texture width (%d)",
+            metalTexture.width, width);
+    ASSERT_PRECONDITION(metalTexture.height == height,
+            "Imported id<MTLTexture> height (%d) != Filament texture height (%d)",
+            metalTexture.height, height);
+    ASSERT_PRECONDITION(metalTexture.mipmapLevelCount == levels,
+            "Imported id<MTLTexture> levels (%d) != Filament texture levels (%d)",
+            metalTexture.mipmapLevelCount, levels);
    MTLTextureType filamentMetalType = getMetalType(target);
-    FILAMENT_CHECK_PRECONDITION(metalTexture.textureType == filamentMetalType)
-            << "Imported id<MTLTexture> type (" << metalTexture.textureType
-            << ") != Filament texture type (" << filamentMetalType << ")";
+    ASSERT_PRECONDITION(metalTexture.textureType == filamentMetalType,
+            "Imported id<MTLTexture> type (%d) != Filament texture type (%d)",
+            metalTexture.textureType, filamentMetalType);
    mContext->textures.insert(construct_handle<MetalTexture>(th, *mContext,
        target, levels, format, samples, width, height, depth, usage, metalTexture));
 }
@@ -399,8 +401,8 @@ void MetalDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
        TargetBufferFlags targetBufferFlags, uint32_t width, uint32_t height,
        uint8_t samples, uint8_t layerCount, MRT color,
        TargetBufferInfo depth, TargetBufferInfo stencil) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "createRenderTarget must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+            "createRenderTarget must be called outside of a render pass.");
    // Clamp sample count to what the device supports.
    auto& sc = mContext->sampleCountLookup;
    samples = sc[std::min(MAX_SAMPLE_COUNT, samples)];
@@ -411,33 +413,33 @@ void MetalDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
            continue;
        }
        const auto& buffer = color[i];
-        FILAMENT_CHECK_PRECONDITION(buffer.handle)
-                << "The COLOR" << i << " flag was specified, but invalid color handle provided.";
+        ASSERT_PRECONDITION(buffer.handle,
+                "The COLOR%u flag was specified, but invalid color handle provided.", i);
        auto colorTexture = handle_cast<MetalTexture>(buffer.handle);
-        FILAMENT_CHECK_PRECONDITION(colorTexture->getMtlTextureForWrite())
-                << "Color texture passed to render target has no texture allocation";
+        ASSERT_PRECONDITION(colorTexture->getMtlTextureForWrite(),
+                "Color texture passed to render target has no texture allocation");
        colorTexture->extendLodRangeTo(buffer.level);
        colorAttachments[i] = { colorTexture, color[i].level, color[i].layer };
    }

    MetalRenderTarget::Attachment depthAttachment = {};
    if (any(targetBufferFlags & TargetBufferFlags::DEPTH)) {
-        FILAMENT_CHECK_PRECONDITION(depth.handle)
-                << "The DEPTH flag was specified, but invalid depth handle provided.";
+        ASSERT_PRECONDITION(depth.handle,
+                "The DEPTH flag was specified, but invalid depth handle provided.");
        auto depthTexture = handle_cast<MetalTexture>(depth.handle);
-        FILAMENT_CHECK_PRECONDITION(depthTexture->getMtlTextureForWrite())
-                << "Depth texture passed to render target has no texture allocation.";
+        ASSERT_PRECONDITION(depthTexture->getMtlTextureForWrite(),
+                "Depth texture passed to render target has no texture allocation.");
        depthTexture->extendLodRangeTo(depth.level);
        depthAttachment = { depthTexture, depth.level, depth.layer };
    }

    MetalRenderTarget::Attachment stencilAttachment = {};
    if (any(targetBufferFlags & TargetBufferFlags::STENCIL)) {
-        FILAMENT_CHECK_PRECONDITION(stencil.handle)
-                << "The STENCIL flag was specified, but invalid stencil handle provided.";
+        ASSERT_PRECONDITION(stencil.handle,
+                "The STENCIL flag was specified, but invalid stencil handle provided.");
        auto stencilTexture = handle_cast<MetalTexture>(stencil.handle);
-        FILAMENT_CHECK_PRECONDITION(stencilTexture->getMtlTextureForWrite())
-                << "Stencil texture passed to render target has no texture allocation.";
+        ASSERT_PRECONDITION(stencilTexture->getMtlTextureForWrite(),
+                "Stencil texture passed to render target has no texture allocation.");
        stencilTexture->extendLodRangeTo(stencil.level);
        stencilAttachment = { stencilTexture, stencil.level, stencil.layer };
    }
@@ -801,15 +803,13 @@ bool MetalDriver::isProtectedContentSupported() {
    return false;
 }

-bool MetalDriver::isStereoSupported() {
-    switch (mStereoscopicType) {
-        case backend::StereoscopicType::INSTANCED:
-            return true;
-        case backend::StereoscopicType::MULTIVIEW:
-            // TODO: implement multiview feature in Metal.
-            return false;
-        case backend::StereoscopicType::NONE:
-            return false;
+bool MetalDriver::isStereoSupported(backend::StereoscopicType stereoscopicType) {
+    switch (stereoscopicType) {
+    case backend::StereoscopicType::INSTANCED:
+        return true;
+    case backend::StereoscopicType::MULTIVIEW:
+        // TODO: implement multiview feature in Metal.
+        return false;
    }
 }

@@ -882,8 +882,8 @@ void MetalDriver::updateIndexBuffer(Handle<HwIndexBuffer> ibh, BufferDescriptor&

 void MetalDriver::updateBufferObject(Handle<HwBufferObject> boh, BufferDescriptor&& data,
        uint32_t byteOffset) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "updateBufferObject must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+            "updateBufferObject must be called outside of a render pass.");
    auto* bo = handle_cast<MetalBufferObject>(boh);
    bo->updateBuffer(data.buffer, data.size, byteOffset);
    scheduleDestroy(std::move(data));
@@ -922,8 +922,8 @@ void MetalDriver::update3DImage(Handle<HwTexture> th, uint32_t level,
        uint32_t xoffset, uint32_t yoffset, uint32_t zoffset,
        uint32_t width, uint32_t height, uint32_t depth,
        PixelBufferDescriptor&& data) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "update3DImage must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+            "update3DImage must be called outside of a render pass.");
    auto tex = handle_cast<MetalTexture>(th);
    tex->loadImage(level, MTLRegionMake3D(xoffset, yoffset, zoffset, width, height, depth), data);
    scheduleDestroy(std::move(data));
@@ -939,15 +939,15 @@ void MetalDriver::setupExternalImage(void* image) {
 }

 void MetalDriver::setExternalImage(Handle<HwTexture> th, void* image) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "setExternalImage must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+            "setExternalImage must be called outside of a render pass.");
    auto texture = handle_cast<MetalTexture>(th);
    texture->externalImage.set((CVPixelBufferRef) image);
 }

 void MetalDriver::setExternalImagePlane(Handle<HwTexture> th, void* image, uint32_t plane) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "setExternalImagePlane must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+            "setExternalImagePlane must be called outside of a render pass.");
    auto texture = handle_cast<MetalTexture>(th);
    texture->externalImage.set((CVPixelBufferRef) image, plane);
 }
@@ -962,15 +962,15 @@ TimerQueryResult MetalDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint6
 }

 void MetalDriver::generateMipmaps(Handle<HwTexture> th) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "generateMipmaps must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+                        "generateMipmaps must be called outside of a render pass.");
    auto tex = handle_cast<MetalTexture>(th);
    tex->generateMipmaps();
 }

 void MetalDriver::updateSamplerGroup(Handle<HwSamplerGroup> sbh, BufferDescriptor&& data) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "updateSamplerGroup must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+            "updateSamplerGroup must be called outside of a render pass.");

    auto sb = handle_cast<MetalSamplerGroup>(sbh);
    assert_invariant(sb->size == data.size / sizeof(SamplerDescriptor));
@@ -1109,10 +1109,6 @@ void MetalDriver::beginRenderPass(Handle<HwRenderTarget> rth,
    mContext->currentPolygonOffset = {0.0f, 0.0f};

    mContext->finalizedSamplerGroups.clear();
-
-    for (auto& pc : mContext->currentPushConstants) {
-        pc.clear();
-    }
 }

 void MetalDriver::nextSubpass(int dummy) {}
@@ -1261,14 +1257,7 @@ void MetalDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
 }

 void MetalDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
-        backend::PushConstantVariant value) {
-    FILAMENT_CHECK_PRECONDITION(isInRenderPass(mContext))
-            << "setPushConstant must be called inside a render pass.";
-    assert_invariant(static_cast<size_t>(stage) < mContext->currentPushConstants.size());
-    MetalPushConstantBuffer& pushConstants =
-            mContext->currentPushConstants[static_cast<size_t>(stage)];
-    pushConstants.setPushConstant(value, index);
-}
+        backend::PushConstantVariant value) {}

 void MetalDriver::insertEventMarker(const char* string, uint32_t len) {

@@ -1320,8 +1309,8 @@ void MetalDriver::stopCapture(int) {

 void MetalDriver::readPixels(Handle<HwRenderTarget> src, uint32_t x, uint32_t y, uint32_t width,
        uint32_t height, PixelBufferDescriptor&& data) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "readPixels must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+                        "readPixels must be called outside of a render pass.");

    auto srcTarget = handle_cast<MetalRenderTarget>(src);
    // We always readPixels from the COLOR0 attachment.
@@ -1335,19 +1324,17 @@ void MetalDriver::readPixels(Handle<HwRenderTarget> src, uint32_t x, uint32_t y,
    width = std::min(static_cast<uint32_t>(srcTextureSize.width), width);

    const MTLPixelFormat format = getMetalFormat(data.format, data.type);
-    FILAMENT_CHECK_PRECONDITION(format != MTLPixelFormatInvalid)
-            << "The chosen combination of PixelDataFormat (" << (int)data.format
-            << ") and PixelDataType (" << (int)data.type
-            << ") is not supported for "
-               "readPixels.";
+    ASSERT_PRECONDITION(format != MTLPixelFormatInvalid,
+            "The chosen combination of PixelDataFormat (%d) and PixelDataType (%d) is not supported for "
+            "readPixels.", (int) data.format, (int) data.type);

    const bool formatConversionNecessary = srcTexture.pixelFormat != format;

    // TODO: MetalBlitter does not currently support format conversions to integer types.
    // The format and type must match the source pixel format exactly.
-    FILAMENT_CHECK_PRECONDITION(!formatConversionNecessary || !isMetalFormatInteger(format))
-            << "readPixels does not support integer format conversions from MTLPixelFormat ("
-            << (int)srcTexture.pixelFormat << ") to (" << (int)format << ").";
+    ASSERT_PRECONDITION(!formatConversionNecessary || !isMetalFormatInteger(format),
+            "readPixels does not support integer format conversions from MTLPixelFormat (%d) to (%d).",
+            (int) srcTexture.pixelFormat, (int) format);

    MTLTextureDescriptor* textureDescriptor =
            [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:format
@@ -1413,31 +1400,31 @@ void MetalDriver::resolve(
    assert_invariant(srcTexture);
    assert_invariant(dstTexture);

-    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder == nil)
-            << "resolve() cannot be invoked inside a render pass.";
+    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder == nil,
+            "resolve() cannot be invoked inside a render pass.");

-    FILAMENT_CHECK_PRECONDITION(
-            dstTexture->width == srcTexture->width && dstTexture->height == srcTexture->height)
-            << "invalid resolve: src and dst sizes don't match";
+    ASSERT_PRECONDITION(
+            dstTexture->width == srcTexture->width && dstTexture->height == srcTexture->height,
+            "invalid resolve: src and dst sizes don't match");

-    FILAMENT_CHECK_PRECONDITION(srcTexture->samples > 1 && dstTexture->samples == 1)
-            << "invalid resolve: src.samples=" << +srcTexture->samples
-            << ", dst.samples=" << +dstTexture->samples;
+    ASSERT_PRECONDITION(srcTexture->samples > 1 && dstTexture->samples == 1,
+            "invalid resolve: src.samples=%u, dst.samples=%u",
+            +srcTexture->samples, +dstTexture->samples);

-    FILAMENT_CHECK_PRECONDITION(srcTexture->format == dstTexture->format)
-            << "src and dst texture format don't match";
+    ASSERT_PRECONDITION(srcTexture->format == dstTexture->format,
+            "src and dst texture format don't match");

-    FILAMENT_CHECK_PRECONDITION(!isDepthFormat(srcTexture->format))
-            << "can't resolve depth formats";
+    ASSERT_PRECONDITION(!isDepthFormat(srcTexture->format),
+            "can't resolve depth formats");

-    FILAMENT_CHECK_PRECONDITION(!isStencilFormat(srcTexture->format))
-            << "can't resolve stencil formats";
+    ASSERT_PRECONDITION(!isStencilFormat(srcTexture->format),
+            "can't resolve stencil formats");

-    FILAMENT_CHECK_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST))
-            << "texture doesn't have BLIT_DST";
+    ASSERT_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST),
+            "texture doesn't have BLIT_DST");

-    FILAMENT_CHECK_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC))
-            << "texture doesn't have BLIT_SRC";
+    ASSERT_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC),
+            "texture doesn't have BLIT_SRC");

    // FIXME: on metal the blit() call below always take the slow path (using a shader)

@@ -1462,22 +1449,21 @@ void MetalDriver::blit(
    assert_invariant(srcTexture);
    assert_invariant(dstTexture);

-    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder == nil)
-            << "blit() cannot be invoked inside a render pass.";
+    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder == nil,
+            "blit() cannot be invoked inside a render pass.");

-    FILAMENT_CHECK_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST))
-            << "texture doesn't have BLIT_DST";
+    ASSERT_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST),
+            "texture doesn't have BLIT_DST");

-    FILAMENT_CHECK_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC))
-            << "texture doesn't have BLIT_SRC";
+    ASSERT_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC),
+            "texture doesn't have BLIT_SRC");

-    FILAMENT_CHECK_PRECONDITION(srcTexture->format == dstTexture->format)
-            << "src and dst texture format don't match";
+    ASSERT_PRECONDITION(srcTexture->format == dstTexture->format,
+            "src and dst texture format don't match");

-    FILAMENT_CHECK_PRECONDITION(
-            isBlitableTextureType(srcTexture->getMtlTextureForRead().textureType) &&
-            isBlitableTextureType(dstTexture->getMtlTextureForWrite().textureType))
-            << "Metal does not support blitting to/from non-2D textures.";
+    ASSERT_PRECONDITION(isBlitableTextureType(srcTexture->getMtlTextureForRead().textureType) &&
+                        isBlitableTextureType(dstTexture->getMtlTextureForWrite().textureType),
+            "Metal does not support blitting to/from non-2D textures.");

    MetalBlitter::BlitArgs args{};
    args.filter = SamplerMagFilter::NEAREST;
@@ -1515,18 +1501,18 @@ void MetalDriver::blitDEPRECATED(TargetBufferFlags buffers,
    // It is called between beginFrame and endFrame, but should never be called in the middle of
    // a render pass.

-    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder == nil)
-            << "blitDEPRECATED() cannot be invoked inside a render pass.";
+    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder == nil,
+            "blitDEPRECATED() cannot be invoked inside a render pass.");

    auto srcTarget = handle_cast<MetalRenderTarget>(src);
    auto dstTarget = handle_cast<MetalRenderTarget>(dst);

-    FILAMENT_CHECK_PRECONDITION(buffers == TargetBufferFlags::COLOR0)
-            << "blitDEPRECATED only supports COLOR0";
+    ASSERT_PRECONDITION(buffers == TargetBufferFlags::COLOR0,
+            "blitDEPRECATED only supports COLOR0");

-    FILAMENT_CHECK_PRECONDITION(
-            srcRect.left >= 0 && srcRect.bottom >= 0 && dstRect.left >= 0 && dstRect.bottom >= 0)
-            << "Source and destination rects must be positive.";
+    ASSERT_PRECONDITION(srcRect.left >= 0 && srcRect.bottom >= 0 &&
+                        dstRect.left >= 0 && dstRect.bottom >= 0,
+            "Source and destination rects must be positive.");

    auto isBlitableTextureType = [](MTLTextureType t) {
        return t == MTLTextureType2D || t == MTLTextureType2DMultisample ||
@@ -1538,10 +1524,9 @@ void MetalDriver::blitDEPRECATED(TargetBufferFlags buffers,
    MetalRenderTarget::Attachment const dstColorAttachment = dstTarget->getDrawColorAttachment(0);

    if (srcColorAttachment && dstColorAttachment) {
-        FILAMENT_CHECK_PRECONDITION(
-                isBlitableTextureType(srcColorAttachment.getTexture().textureType) &&
-                isBlitableTextureType(dstColorAttachment.getTexture().textureType))
-                << "Metal does not support blitting to/from non-2D textures.";
+        ASSERT_PRECONDITION(isBlitableTextureType(srcColorAttachment.getTexture().textureType) &&
+                            isBlitableTextureType(dstColorAttachment.getTexture().textureType),
+                           "Metal does not support blitting to/from non-2D textures.");

        MetalBlitter::BlitArgs args{};
        args.filter = filter;
@@ -1652,9 +1637,9 @@ void MetalDriver::finalizeSamplerGroup(MetalSamplerGroup* samplerGroup) {
    }
 }

-void MetalDriver::bindPipeline(PipelineState const& ps) {
-    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder != nullptr)
-            << "bindPipeline() without a valid command encoder.";
+void MetalDriver::bindPipeline(PipelineState ps) {
+    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder != nullptr,
+            "bindPipeline() without a valid command encoder.");

    MetalVertexBufferInfo const* const vbi =
            handle_cast<MetalVertexBufferInfo>(ps.vertexBufferInfo);
@@ -1826,8 +1811,8 @@ void MetalDriver::bindPipeline(PipelineState const& ps) {
 }

 void MetalDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
-    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder != nullptr)
-            << "bindRenderPrimitive() without a valid command encoder.";
+    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder != nullptr,
+            "bindRenderPrimitive() without a valid command encoder.");

    // Bind the user vertex buffers.
    MetalBuffer* vertexBuffers[MAX_VERTEX_BUFFER_COUNT] = {};
@@ -1863,8 +1848,8 @@ void MetalDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
 }

 void MetalDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
-    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder != nullptr)
-            << "draw() without a valid command encoder.";
+    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder != nullptr,
+            "draw() without a valid command encoder.");

    // Bind uniform buffers.
    MetalBuffer* uniformsToBind[Program::UNIFORM_BINDING_COUNT] = { nil };
@@ -1880,14 +1865,6 @@ void MetalDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t inst
            UNIFORM_BUFFER_BINDING_START, MetalBuffer::Stage::VERTEX | MetalBuffer::Stage::FRAGMENT,
            uniformsToBind, offsets, Program::UNIFORM_BINDING_COUNT);

-    // Update push constants.
-    for (size_t i = 0; i < Program::SHADER_TYPE_COUNT; i++) {
-        auto& pushConstants = mContext->currentPushConstants[i];
-        if (UTILS_UNLIKELY(pushConstants.isDirty())) {
-            pushConstants.setBytes(mContext->currentRenderPassEncoder, static_cast<ShaderStage>(i));
-        }
-    }
-
    auto primitive = handle_cast<MetalRenderPrimitive>(mContext->currentRenderPrimitive);

    MetalIndexBuffer* indexBuffer = primitive->indexBuffer;
@@ -1913,8 +1890,8 @@ void MetalDriver::draw(PipelineState ps, Handle<HwRenderPrimitive> rph,
 }

 void MetalDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGroupCount) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "dispatchCompute must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+            "dispatchCompute must be called outside of a render pass.");

    auto mtlProgram = handle_cast<MetalProgram>(program);

@@ -2014,15 +1991,15 @@ void MetalDriver::scissor(Viewport scissorBox) {
 }

 void MetalDriver::beginTimerQuery(Handle<HwTimerQuery> tqh) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "beginTimerQuery must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+            "beginTimerQuery must be called outside of a render pass.");
    auto* tq = handle_cast<MetalTimerQuery>(tqh);
    mContext->timerQueryImpl->beginTimeElapsedQuery(tq);
 }

 void MetalDriver::endTimerQuery(Handle<HwTimerQuery> tqh) {
-    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
-            << "endTimerQuery must be called outside of a render pass.";
+    ASSERT_PRECONDITION(!isInRenderPass(mContext),
+            "endTimerQuery must be called outside of a render pass.");
    auto* tq = handle_cast<MetalTimerQuery>(tqh);
    mContext->timerQueryImpl->endTimeElapsedQuery(tq);
 }
@@ -71,7 +71,7 @@ constexpr inline MTLIndexType getIndexType(size_t elementSize) noexcept {
    } else if (elementSize == 4) {
        return MTLIndexTypeUInt32;
    }
-    FILAMENT_CHECK_POSTCONDITION(false) << "Index element size not supported.";
+    ASSERT_POSTCONDITION(false, "Index element size not supported.");
 }

 constexpr inline MTLVertexFormat getMetalFormat(ElementType type, bool normalized) noexcept {
@@ -100,7 +100,7 @@ constexpr inline MTLVertexFormat getMetalFormat(ElementType type, bool normalize
            case ElementType::SHORT4: return MTLVertexFormatShort4Normalized;
            case ElementType::USHORT4: return MTLVertexFormatUShort4Normalized;
            default:
-                FILAMENT_CHECK_POSTCONDITION(false) << "Normalized format does not exist.";
+                ASSERT_POSTCONDITION(false, "Normalized format does not exist.");
                return MTLVertexFormatInvalid;
        }
    }
@@ -326,8 +326,7 @@ constexpr inline MTLCullMode getMetalCullMode(CullingMode cullMode) noexcept {
        case CullingMode::FRONT: return MTLCullModeFront;
        case CullingMode::BACK: return MTLCullModeBack;
        case CullingMode::FRONT_AND_BACK:
-            FILAMENT_CHECK_POSTCONDITION(false)
-                    << "FRONT_AND_BACK culling is not supported in Metal.";
+            ASSERT_POSTCONDITION(false, "FRONT_AND_BACK culling is not supported in Metal.");
    }
 }

@@ -29,7 +29,7 @@
        auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding]; \
        utils::slog.e << description << utils::io::endl;                                           \
    }                                                                                              \
-    FILAMENT_CHECK_POSTCONDITION(error == nil) << message;
+    ASSERT_POSTCONDITION(error == nil, message);

 namespace filament {
 namespace backend {
@@ -86,14 +86,14 @@ void MetalExternalImage::set(CVPixelBufferRef image) noexcept {
    }

    OSType formatType = CVPixelBufferGetPixelFormatType(image);
-    FILAMENT_CHECK_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA ||
-            formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange)
-            << "Metal external images must be in either 32BGRA or 420f format.";
+    ASSERT_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA ||
+                         formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
+            "Metal external images must be in either 32BGRA or 420f format.");

    size_t planeCount = CVPixelBufferGetPlaneCount(image);
-    FILAMENT_CHECK_POSTCONDITION(planeCount == 0 || planeCount == 2)
-            << "The Metal backend does not support images with plane counts of " << planeCount
-            << ".";
+    ASSERT_POSTCONDITION(planeCount == 0 || planeCount == 2,
+            "The Metal backend does not support images with plane counts of %d.", planeCount);
+

    if (planeCount == 0) {
        mImage = image;
@@ -138,8 +138,8 @@ void MetalExternalImage::set(CVPixelBufferRef image, size_t plane) noexcept {
    }

    const OSType formatType = CVPixelBufferGetPixelFormatType(image);
-    FILAMENT_CHECK_POSTCONDITION(formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange)
-            << "Metal planar external images must be in the 420f format.";
+    ASSERT_POSTCONDITION(formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
+            "Metal planar external images must be in the 420f format.");

    mImage = image;

@@ -191,8 +191,8 @@ CVMetalTextureRef MetalExternalImage::createTextureFromImage(CVPixelBufferRef im
    CVMetalTextureRef texture;
    CVReturn result = CVMetalTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
            mContext.textureCache, image, nullptr, format, width, height, plane, &texture);
-    FILAMENT_CHECK_POSTCONDITION(result == kCVReturnSuccess)
-            << "Could not create a CVMetalTexture from CVPixelBuffer.";
+    ASSERT_POSTCONDITION(result == kCVReturnSuccess,
+            "Could not create a CVMetalTexture from CVPixelBuffer.");

    return texture;
 }
@@ -203,8 +203,8 @@ void MetalExternalImage::shutdown(MetalContext& context) noexcept {

 void MetalExternalImage::assertWritableImage(CVPixelBufferRef image) {
    OSType formatType = CVPixelBufferGetPixelFormatType(image);
-    FILAMENT_CHECK_PRECONDITION(formatType == kCVPixelFormatType_32BGRA)
-            << "Metal SwapChain images must be in the 32BGRA format.";
+    ASSERT_PRECONDITION(formatType == kCVPixelFormatType_32BGRA,
+            "Metal SwapChain images must be in the 32BGRA format.");
 }

 void MetalExternalImage::unset() {
@@ -75,7 +75,7 @@ public:

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

    // For CAMetalLayer-backed SwapChains, presents the drawable or schedules a
    // FrameScheduledCallback.
@@ -109,7 +109,6 @@ private:
    NSUInteger headlessWidth = 0;
    NSUInteger headlessHeight = 0;
    CAMetalLayer* layer = nullptr;
-    std::shared_ptr<std::mutex> layerDrawableMutex;
    MetalExternalImage externalImage;
    SwapChainType type;

@@ -120,12 +119,13 @@ private:
    // PresentCallable object.
    struct {
        CallbackHandler* handler = nullptr;
-        std::shared_ptr<FrameScheduledCallback> callback = nullptr;
+        FrameScheduledCallback callback = {};
    } frameScheduled;

    struct {
        CallbackHandler* handler = nullptr;
-        std::shared_ptr<utils::Invocable<void(void)>> callback = nullptr;
+        CallbackHandler::Callback callback = {};
+        void* user = nullptr;
    } frameCompleted;
 };

@@ -73,7 +73,6 @@ MetalSwapChain::MetalSwapChain(MetalContext& context, CAMetalLayer* nativeWindow
    : context(context),
      depthStencilFormat(decideDepthStencilFormat(flags)),
      layer(nativeWindow),
-      layerDrawableMutex(std::make_shared<std::mutex>()),
      externalImage(context),
      type(SwapChainType::CAMETALLAYER) {

@@ -175,24 +174,14 @@ id<MTLTexture> MetalSwapChain::acquireDrawable() {
    }

    assert_invariant(isCaMetalLayer());
+    drawable = [layer nextDrawable];

-    // CAMetalLayer's drawable pool is not thread safe. Use a mutex when
-    // calling -nextDrawable, or when releasing the last known reference
-    // to any CAMetalDrawable returned from a previous -nextDrawable.
-    {
-        std::lock_guard<std::mutex> lock(*layerDrawableMutex);
-        drawable = [layer nextDrawable];
-    }
-
-    FILAMENT_CHECK_POSTCONDITION(drawable != nil) << "Could not obtain drawable.";
+    ASSERT_POSTCONDITION(drawable != nil, "Could not obtain drawable.");
    return drawable.texture;
 }

 void MetalSwapChain::releaseDrawable() {
-    if (drawable) {
-        std::lock_guard<std::mutex> lock(*layerDrawableMutex);
-        drawable = nil;
-    }
+    drawable = nil;
 }

 id<MTLTexture> MetalSwapChain::acquireDepthTexture() {
@@ -235,13 +224,14 @@ void MetalSwapChain::ensureDepthStencilTexture() {
 void MetalSwapChain::setFrameScheduledCallback(
        CallbackHandler* handler, FrameScheduledCallback&& callback) {
    frameScheduled.handler = handler;
-    frameScheduled.callback = std::make_shared<FrameScheduledCallback>(std::move(callback));
+    frameScheduled.callback = std::move(callback);
 }

-void MetalSwapChain::setFrameCompletedCallback(
-        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
+void MetalSwapChain::setFrameCompletedCallback(CallbackHandler* handler,
+        CallbackHandler::Callback callback, void* user) {
    frameCompleted.handler = handler;
-    frameCompleted.callback = std::make_shared<utils::Invocable<void(void)>>(std::move(callback));
+    frameCompleted.callback = callback;
+    frameCompleted.user = user;
 }

 void MetalSwapChain::present() {
@@ -267,11 +257,9 @@ public:
    PresentDrawableData(const PresentDrawableData&) = delete;
    PresentDrawableData& operator=(const PresentDrawableData&) = delete;

-    static PresentDrawableData* create(id<CAMetalDrawable> drawable,
-            std::shared_ptr<std::mutex> drawableMutex, MetalDriver* driver) {
-        assert_invariant(drawableMutex);
+    static PresentDrawableData* create(id<CAMetalDrawable> drawable, MetalDriver* driver) {
        assert_invariant(driver);
-        return new PresentDrawableData(drawable, drawableMutex, driver);
+        return new PresentDrawableData(drawable, driver);
    }

    static void maybePresentAndDestroyAsync(PresentDrawableData* that, bool shouldPresent) {
@@ -290,22 +278,16 @@ public:
    }

 private:
-    PresentDrawableData(id<CAMetalDrawable> drawable, std::shared_ptr<std::mutex> drawableMutex,
-            MetalDriver* driver)
-        : mDrawable(drawable), mDrawableMutex(drawableMutex), mDriver(driver) {}
+    PresentDrawableData(id<CAMetalDrawable> drawable, MetalDriver* driver)
+        : mDrawable(drawable), mDriver(driver) {}

    static void cleanupAndDestroy(PresentDrawableData *that) {
-        if (that->mDrawable) {
-            std::lock_guard<std::mutex> lock(*(that->mDrawableMutex));
-            that->mDrawable = nil;
-        }
-        that->mDrawableMutex.reset();
+        that->mDrawable = nil;
        that->mDriver = nullptr;
        delete that;
    }

    id<CAMetalDrawable> mDrawable;
-    std::shared_ptr<std::mutex> mDrawableMutex;
    MetalDriver* mDriver = nullptr;
 };

@@ -322,25 +304,25 @@ void MetalSwapChain::scheduleFrameScheduledCallback() {
    assert_invariant(drawable);

    struct Callback {
-        Callback(std::shared_ptr<FrameScheduledCallback> callback, id<CAMetalDrawable> drawable,
-                 std::shared_ptr<std::mutex> drawableMutex, MetalDriver* driver)
-            : f(callback), data(PresentDrawableData::create(drawable, drawableMutex, driver)) {}
-        std::shared_ptr<FrameScheduledCallback> f;
+        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->operator()(presentCallable);
+            c->f(presentCallable);
            delete c;
        }
    };

    // 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>(
-        frameScheduled.callback, drawable, layerDrawableMutex, context.driver);
+    __block auto callback =
+            std::make_unique<Callback>(std::move(frameScheduled.callback), drawable, context.driver);

    backend::CallbackHandler* handler = frameScheduled.handler;
    MetalDriver* driver = context.driver;
@@ -355,25 +337,13 @@ void MetalSwapChain::scheduleFrameCompletedCallback() {
        return;
    }

-    struct Callback {
-        Callback(std::shared_ptr<utils::Invocable<void(void)>> callback) : f(callback) {}
-        std::shared_ptr<utils::Invocable<void(void)>> f;
-        static void func(void* user) {
-            auto* const c = reinterpret_cast<Callback*>(user);
-            c->f->operator()();
-            delete c;
-        }
-    };
-
-    // This callback pointer will be captured by the block. Even if the completed handler is never
-    // called, the unique_ptr will still ensure we don't leak memory.
-    __block auto callback = std::make_unique<Callback>(frameCompleted.callback);
-
    CallbackHandler* handler = frameCompleted.handler;
+    void* user = frameCompleted.user;
+    CallbackHandler::Callback callback = frameCompleted.callback;
+
    MetalDriver* driver = context.driver;
    [getPendingCommandBuffer(&context) addCompletedHandler:^(id<MTLCommandBuffer> cb) {
-        Callback* user = callback.release();
-        driver->scheduleCallback(handler, user, &Callback::func);
+        driver->scheduleCallback(handler, user, callback);
    }];
 }

@@ -512,16 +482,15 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
        externalImage(context, r, g, b, a) {

    devicePixelFormat = decidePixelFormat(&context, format);
-    FILAMENT_CHECK_POSTCONDITION(devicePixelFormat != MTLPixelFormatInvalid)
-            << "Texture format not supported.";
+    ASSERT_POSTCONDITION(devicePixelFormat != MTLPixelFormatInvalid, "Texture format not supported.");

    const BOOL mipmapped = levels > 1;
    const BOOL multisampled = samples > 1;

 #if defined(IOS)
    const BOOL textureArray = target == SamplerType::SAMPLER_2D_ARRAY;
-    FILAMENT_CHECK_PRECONDITION(!textureArray || !multisampled)
-            << "iOS does not support multisampled texture arrays.";
+    ASSERT_PRECONDITION(!textureArray || !multisampled,
+            "iOS does not support multisampled texture arrays.");
 #endif

    const auto get2DTextureType = [](SamplerType target, bool isMultisampled) {
@@ -556,14 +525,12 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
            descriptor.usage = getMetalTextureUsage(usage);
            descriptor.storageMode = MTLStorageModePrivate;
            texture = [context.device newTextureWithDescriptor:descriptor];
-            FILAMENT_CHECK_POSTCONDITION(texture != nil)
-                    << "Could not create Metal texture. Out of memory?";
+            ASSERT_POSTCONDITION(texture != nil, "Could not create Metal texture. Out of memory?");
            break;
        case SamplerType::SAMPLER_CUBEMAP:
        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
-            FILAMENT_CHECK_POSTCONDITION(!multisampled)
-                    << "Multisampled cubemap faces not supported.";
-            FILAMENT_CHECK_POSTCONDITION(width == height) << "Cubemap faces must be square.";
+            ASSERT_POSTCONDITION(!multisampled, "Multisampled cubemap faces not supported.");
+            ASSERT_POSTCONDITION(width == height, "Cubemap faces must be square.");
            descriptor = [MTLTextureDescriptor textureCubeDescriptorWithPixelFormat:devicePixelFormat
                                                                               size:width
                                                                          mipmapped:mipmapped];
@@ -572,8 +539,7 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
            descriptor.usage = getMetalTextureUsage(usage);
            descriptor.storageMode = MTLStorageModePrivate;
            texture = [context.device newTextureWithDescriptor:descriptor];
-            FILAMENT_CHECK_POSTCONDITION(texture != nil)
-                    << "Could not create Metal texture. Out of memory?";
+            ASSERT_POSTCONDITION(texture != nil, "Could not create Metal texture. Out of memory?");
            break;
        case SamplerType::SAMPLER_3D:
            descriptor = [MTLTextureDescriptor new];
@@ -586,8 +552,7 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
            descriptor.usage = getMetalTextureUsage(usage);
            descriptor.storageMode = MTLStorageModePrivate;
            texture = [context.device newTextureWithDescriptor:descriptor];
-            FILAMENT_CHECK_POSTCONDITION(texture != nil)
-                    << "Could not create Metal texture. Out of memory?";
+            ASSERT_POSTCONDITION(texture != nil, "Could not create Metal texture. Out of memory?");
            break;
        case SamplerType::SAMPLER_EXTERNAL:
            // If we're using external textures (CVPixelBufferRefs), we don't need to make any
@@ -789,9 +754,9 @@ void MetalTexture::loadSlice(uint32_t level, MTLRegion region, uint32_t byteOffs
        PixelBufferDescriptor const& data) noexcept {
    const PixelBufferShape shape = PixelBufferShape::compute(data, format, region.size, byteOffset);

-    FILAMENT_CHECK_PRECONDITION(data.size >= shape.totalBytes)
-            << "Expected buffer size of at least " << shape.totalBytes
-            << " but received PixelBufferDescriptor with size " << data.size << ".";
+    ASSERT_PRECONDITION(data.size >= shape.totalBytes,
+            "Expected buffer size of at least %d but "
+            "received PixelBufferDescriptor with size %d.", shape.totalBytes, data.size);

    // Earlier versions of iOS don't have the maxBufferLength query, but 256 MB is a safe bet.
    NSUInteger deviceMaxBufferLength = 256 * 1024 * 1024;   // 256 MB
@@ -824,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
@@ -1012,9 +977,9 @@ MetalRenderTarget::MetalRenderTarget(MetalContext* context, uint32_t width, uint
        }
        color[i] = colorAttachments[i];

-        FILAMENT_CHECK_PRECONDITION(color[i].getSampleCount() <= samples)
-                << "MetalRenderTarget was initialized with a MSAA COLOR" << i
-                << " texture, but sample count is " << samples << ".";
+        ASSERT_PRECONDITION(color[i].getSampleCount() <= samples,
+                "MetalRenderTarget was initialized with a MSAA COLOR%d texture, but sample count is %d.",
+                i, samples);

        auto t = color[i].metalTexture;
        const auto twidth = std::max(1u, t->width >> color[i].level);
@@ -1037,10 +1002,9 @@ MetalRenderTarget::MetalRenderTarget(MetalContext* context, uint32_t width, uint
    if (depthAttachment) {
        depth = depthAttachment;

-        FILAMENT_CHECK_PRECONDITION(depth.getSampleCount() <= samples)
-                << "MetalRenderTarget was initialized with a MSAA DEPTH texture, but sample count "
-                   "is "
-                << samples << ".";
+        ASSERT_PRECONDITION(depth.getSampleCount() <= samples,
+                "MetalRenderTarget was initialized with a MSAA DEPTH texture, but sample count is %d.",
+                samples);

        auto t = depth.metalTexture;
        const auto twidth = std::max(1u, t->width >> depth.level);
@@ -1063,10 +1027,9 @@ MetalRenderTarget::MetalRenderTarget(MetalContext* context, uint32_t width, uint
    if (stencilAttachment) {
        stencil = stencilAttachment;

-        FILAMENT_CHECK_PRECONDITION(stencil.getSampleCount() <= samples)
-                << "MetalRenderTarget was initialized with a MSAA STENCIL texture, but sample "
-                   "count is "
-                << samples << ".";
+        ASSERT_PRECONDITION(stencil.getSampleCount() <= samples,
+                "MetalRenderTarget was initialized with a MSAA STENCIL texture, but sample count is %d.",
+                samples);

        auto t = stencil.metalTexture;
        const auto twidth = std::max(1u, t->width >> stencil.level);
@@ -43,8 +43,7 @@ inline bool operator==(const SamplerParams& lhs, const SamplerParams& rhs) {
 //   ------------------------------------------------------
 //   0           Zero buffer (placeholder vertex buffer)  1
 //   1-16        Filament vertex buffers                 16   limited by MAX_VERTEX_BUFFER_COUNT
-//   17-25       Uniform buffers                          9   Program::UNIFORM_BINDING_COUNT
-//   26          Push constants                           1
+//   17-26       Uniform buffers                         10   Program::UNIFORM_BINDING_COUNT
 //   27-30       Sampler groups (argument buffers)        4   Program::SAMPLER_BINDING_COUNT
 //
 //   Total                                               31
@@ -54,8 +53,7 @@ inline bool operator==(const SamplerParams& lhs, const SamplerParams& rhs) {
 //   Bindings    Buffer name                          Count
 //   ------------------------------------------------------
 //   0-3         SSBO buffers                             4   MAX_SSBO_COUNT
-//   17-25       Uniform buffers                          9   Program::UNIFORM_BINDING_COUNT
-//   26          Push constants                           1
+//   17-26       Uniform buffers                         10   Program::UNIFORM_BINDING_COUNT
 //   27-30       Sampler groups (argument buffers)        4   Program::SAMPLER_BINDING_COUNT
 //
 //   Total                                               18
@@ -90,17 +90,11 @@ id<MTLRenderPipelineState> PipelineStateCreator::operator()(id<MTLDevice> device
    NSError* error = nullptr;
    id<MTLRenderPipelineState> pipeline = [device newRenderPipelineStateWithDescriptor:descriptor
                                                                                 error:&error];
-    if (UTILS_UNLIKELY(pipeline == nil)) {
-        NSString *errorMessage =
-            [NSString stringWithFormat:@"Could not create Metal pipeline state: %@",
-                error ? error.localizedDescription : @"unknown error"];
-        auto description = [errorMessage cStringUsingEncoding:NSUTF8StringEncoding];
+    if (error) {
+        auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
        utils::slog.e << description << utils::io::endl;
-        [[NSException exceptionWithName:@"MetalRenderPipelineFailure"
-                                 reason:errorMessage
-                               userInfo:nil] raise];
    }
-    FILAMENT_CHECK_POSTCONDITION(error == nil) << "Could not create Metal pipeline state.";
+    ASSERT_POSTCONDITION(error == nil, "Could not create Metal pipeline state.");

    return pipeline;
 }
@@ -59,7 +59,7 @@ void NoopDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
 }

 void NoopDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
+        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {

 }

@@ -182,7 +182,7 @@ bool NoopDriver::isProtectedContentSupported() {
    return false;
 }

-bool NoopDriver::isStereoSupported() {
+bool NoopDriver::isStereoSupported(backend::StereoscopicType) {
    return false;
 }

@@ -359,7 +359,7 @@ void NoopDriver::blit(
        math::uint2 size) {
 }

-void NoopDriver::bindPipeline(PipelineState const& pipelineState) {
+void NoopDriver::bindPipeline(PipelineState pipelineState) {
 }

 void NoopDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
@@ -66,8 +66,7 @@ bool OpenGLContext::queryOpenGLVersion(GLint* major, GLint* minor) noexcept {
 OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
        Platform::DriverConfig const& driverConfig) noexcept
        : mPlatform(platform),
-          mSamplerMap(32),
-          mDriverConfig(driverConfig) {
+          mSamplerMap(32) {

    state.vao.p = &mDefaultVAO;

@@ -367,8 +366,7 @@ void OpenGLContext::setDefaultState() noexcept {
    }
 #endif

-    if (ext.EXT_clip_cull_distance
-            && mDriverConfig.stereoscopicType == StereoscopicType::INSTANCED) {
+    if (ext.EXT_clip_cull_distance) {
        glEnable(GL_CLIP_DISTANCE0);
        glEnable(GL_CLIP_DISTANCE1);
    }
@@ -511,8 +511,6 @@ private:
    mutable tsl::robin_map<SamplerParams, GLuint,
            SamplerParams::Hasher, SamplerParams::EqualTo> mSamplerMap;

-    Platform::DriverConfig const mDriverConfig;
-
    void bindFramebufferResolved(GLenum target, GLuint buffer) noexcept;

    const std::array<std::tuple<bool const&, char const*, char const*>, sizeof(bugs)> mBugDatabase{{
@@ -241,15 +241,7 @@ OpenGLDriver::~OpenGLDriver() noexcept { // NOLINT(modernize-use-equals-default)
 }

 Dispatcher OpenGLDriver::getDispatcher() const noexcept {
-    auto dispatcher = ConcreteDispatcher<OpenGLDriver>::make();
-    if (mContext.isES2()) {
-        dispatcher.draw2_ = +[](Driver& driver, CommandBase* base, intptr_t* next){
-            using Cmd = COMMAND_TYPE(draw2);
-            OpenGLDriver& concreteDriver = static_cast<OpenGLDriver&>(driver);
-            Cmd::execute(&OpenGLDriver::draw2GLES2, concreteDriver, base, next);
-        };
-    }
-    return dispatcher;
+    return ConcreteDispatcher<OpenGLDriver>::make();
 }

 // ------------------------------------------------------------------------------------------------
@@ -932,18 +924,16 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
 }

 void OpenGLDriver::updateVertexArrayObject(GLRenderPrimitive* rp, GLVertexBuffer const* vb) {
-    // NOTE: this is called often and must be as efficient as possible.
+    // NOTE: this is called from draw() and must be as efficient as possible.

    auto& gl = mContext;

-#ifndef NDEBUG
    if (UTILS_LIKELY(gl.ext.OES_vertex_array_object)) {
        // The VAO for the given render primitive must already be bound.
        GLint vaoBinding;
        glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &vaoBinding);
        assert_invariant(vaoBinding == (GLint)rp->gl.vao[gl.contextIndex]);
    }
-#endif

    if (UTILS_LIKELY(rp->gl.vertexBufferVersion == vb->bufferObjectsVersion &&
                     rp->gl.stateVersion == gl.state.age)) {
@@ -959,7 +949,7 @@ void OpenGLDriver::updateVertexArrayObject(GLRenderPrimitive* rp, GLVertexBuffer
            // if a buffer is defined it must not be invalid.
            assert_invariant(vb->gl.buffers[bi]);

-            // if we're on ES2, the user shouldn't use FLAG_INTEGER_TARGET
+            // if w're on ES2, the user shouldn't use FLAG_INTEGER_TARGET
            assert_invariant(!(gl.isES2() && (attribute.flags & Attribute::FLAG_INTEGER_TARGET)));

            gl.bindBuffer(GL_ARRAY_BUFFER, vb->gl.buffers[bi]);
@@ -1494,8 +1484,9 @@ void OpenGLDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,

 #if !defined(__EMSCRIPTEN__)
    // note: in practice this should never happen on Android
-    FILAMENT_CHECK_POSTCONDITION(sc->swapChain) << "createSwapChain(" << nativeWindow << ", "
-                                                << flags << ") failed. See logs for details.";
+    ASSERT_POSTCONDITION(sc->swapChain,
+            "createSwapChain(%p, 0x%lx) failed. See logs for details.",
+            nativeWindow, flags);
 #endif

    // See if we need the emulated rec709 output conversion
@@ -1514,9 +1505,9 @@ void OpenGLDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch,

 #if !defined(__EMSCRIPTEN__)
    // note: in practice this should never happen on Android
-    FILAMENT_CHECK_POSTCONDITION(sc->swapChain)
-            << "createSwapChainHeadless(" << width << ", " << height << ", " << flags
-            << ") failed. See logs for details.";
+    ASSERT_POSTCONDITION(sc->swapChain,
+            "createSwapChainHeadless(%u, %u, 0x%lx) failed. See logs for details.",
+            width, height, flags);
 #endif

    // See if we need the emulated rec709 output conversion
@@ -2049,19 +2040,19 @@ bool OpenGLDriver::isProtectedContentSupported() {
    return mPlatform.isProtectedContextSupported();
 }

-bool OpenGLDriver::isStereoSupported() {
+bool OpenGLDriver::isStereoSupported(backend::StereoscopicType stereoscopicType) {
    // Instanced-stereo requires instancing and EXT_clip_cull_distance.
    // Multiview-stereo requires ES 3.0 and OVR_multiview2.
    if (UTILS_UNLIKELY(mContext.isES2())) {
        return false;
    }
-    switch (mDriverConfig.stereoscopicType) {
-        case backend::StereoscopicType::INSTANCED:
-            return mContext.ext.EXT_clip_cull_distance;
-        case backend::StereoscopicType::MULTIVIEW:
-            return mContext.ext.OVR_multiview2;
-        case backend::StereoscopicType::NONE:
-            return false;
+    switch (stereoscopicType) {
+    case backend::StereoscopicType::INSTANCED:
+        return mContext.ext.EXT_clip_cull_distance;
+    case backend::StereoscopicType::MULTIVIEW:
+        return mContext.ext.OVR_multiview2;
+    default:
+        return false;
    }
 }

@@ -3468,7 +3459,7 @@ void OpenGLDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
 }

 void OpenGLDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
+        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
    DEBUG_MARKER()
 }

@@ -3605,11 +3596,13 @@ void OpenGLDriver::resolve(
    assert_invariant(s);
    assert_invariant(d);

-    FILAMENT_CHECK_PRECONDITION(d->width == s->width && d->height == s->height)
-            << "invalid resolve: src and dst sizes don't match";
+    ASSERT_PRECONDITION(
+            d->width == s->width && d->height == s->height,
+            "invalid resolve: src and dst sizes don't match");

-    FILAMENT_CHECK_PRECONDITION(s->samples > 1 && d->samples == 1)
-            << "invalid resolve: src.samples=" << +s->samples << ", dst.samples=" << +d->samples;
+    ASSERT_PRECONDITION(s->samples > 1 && d->samples == 1,
+            "invalid resolve: src.samples=%u, dst.samples=%u",
+            +s->samples, +d->samples);

    blit(   dst, dstLevel, dstLayer, {},
            src, srcLevel, srcLayer, {},
@@ -3765,12 +3758,12 @@ void OpenGLDriver::blitDEPRECATED(TargetBufferFlags buffers,
    UTILS_UNUSED_IN_RELEASE auto& gl = mContext;
    assert_invariant(!gl.isES2());

-    FILAMENT_CHECK_PRECONDITION(buffers == TargetBufferFlags::COLOR0)
-            << "blitDEPRECATED only supports COLOR0";
+    ASSERT_PRECONDITION(buffers == TargetBufferFlags::COLOR0,
+            "blitDEPRECATED only supports COLOR0");

-    FILAMENT_CHECK_PRECONDITION(
-            srcRect.left >= 0 && srcRect.bottom >= 0 && dstRect.left >= 0 && dstRect.bottom >= 0)
-            << "Source and destination rects must be positive.";
+    ASSERT_PRECONDITION(srcRect.left >= 0 && srcRect.bottom >= 0 &&
+                        dstRect.left >= 0 && dstRect.bottom >= 0,
+            "Source and destination rects must be positive.");

 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2

@@ -3844,7 +3837,7 @@ void OpenGLDriver::updateTextureLodRange(GLTexture* texture, int8_t targetLevel)
 #endif
 }

-void OpenGLDriver::bindPipeline(PipelineState const& state) {
+void OpenGLDriver::bindPipeline(PipelineState state) {
    DEBUG_MARKER()
    auto& gl = mContext;
    setRasterState(state.rasterState);
@@ -3882,35 +3875,20 @@ void OpenGLDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
        return;
    }

+    if (UTILS_LIKELY(instanceCount <= 1)) {
+        glDrawElements(GLenum(rp->type), (GLsizei)indexCount, rp->gl.getIndicesType(),
+                reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize));
+    } else {
+        assert_invariant(!mContext.isES2());
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
-    assert_invariant(!mContext.isES2());
-    glDrawElementsInstanced(GLenum(rp->type), (GLsizei)indexCount,
-            rp->gl.getIndicesType(),
-            reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize),
-            (GLsizei)instanceCount);
+        glDrawElementsInstanced(GLenum(rp->type), (GLsizei)indexCount,
+                rp->gl.getIndicesType(),
+                reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize),
+                (GLsizei)instanceCount);
 #endif
-
-#if FILAMENT_ENABLE_MATDBG
-    CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
-#else
-    CHECK_GL_ERROR(utils::slog.e)
-#endif
-}
-
-void OpenGLDriver::draw2GLES2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
-    GLRenderPrimitive const* const rp = mBoundRenderPrimitive;
-    if (UTILS_UNLIKELY(!rp || !mValidProgram)) {
-        return;
    }

-    assert_invariant(mContext.isES2());
-    assert_invariant(instanceCount == 1);
-
-    glDrawElements(GLenum(rp->type), (GLsizei)indexCount, rp->gl.getIndicesType(),
-            reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize));
-
-
-#if FILAMENT_ENABLE_MATDBG
+#ifdef FILAMENT_ENABLE_MATDBG
    CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
 #else
    CHECK_GL_ERROR(utils::slog.e)
@@ -3929,11 +3907,7 @@ void OpenGLDriver::draw(PipelineState state, Handle<HwRenderPrimitive> rph,
    state.vertexBufferInfo = rp->vbih;
    bindPipeline(state);
    bindRenderPrimitive(rph);
-    if (UTILS_UNLIKELY(mContext.isES2())) {
-        draw2GLES2(indexOffset, indexCount, instanceCount);
-    } else {
-        draw2(indexOffset, indexCount, instanceCount);
-    }
+    draw2(indexOffset, indexCount, instanceCount);
 }

 void OpenGLDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGroupCount) {
@@ -3960,7 +3934,7 @@ void OpenGLDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGr
    glDispatchCompute(workGroupCount.x, workGroupCount.y, workGroupCount.z);
 #endif // BACKEND_OPENGL_LEVEL_GLES31

-#if FILAMENT_ENABLE_MATDBG
+#ifdef FILAMENT_ENABLE_MATDBG
    CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
 #else
    CHECK_GL_ERROR(utils::slog.e)
@@ -336,8 +336,6 @@ private:

    void setScissor(Viewport const& scissor) noexcept;

-    void draw2GLES2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount);
-
    // ES2 only. Uniform buffer emulation binding points
    GLuint mLastAssignedEmulatedUboId = 0;

@@ -111,8 +111,8 @@ bool CocoaExternalImage::set(CVPixelBufferRef image) noexcept {
    }

    OSType formatType = CVPixelBufferGetPixelFormatType(image);
-    FILAMENT_CHECK_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA)
-            << "macOS external images must be 32BGRA format.";
+    ASSERT_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA,
+            "macOS external images must be 32BGRA format.");

    // The pixel buffer must be locked whenever we do rendering with it. We'll unlock it before
    // releasing.
@@ -135,14 +135,13 @@ bool CocoaTouchExternalImage::set(CVPixelBufferRef image) noexcept {
    }

    OSType formatType = CVPixelBufferGetPixelFormatType(image);
-    FILAMENT_CHECK_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA ||
-            formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange)
-            << "iOS external images must be in either 32BGRA or 420f format.";
+    ASSERT_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA ||
+                         formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
+            "iOS external images must be in either 32BGRA or 420f format.");

    size_t planeCount = CVPixelBufferGetPlaneCount(image);
-    FILAMENT_CHECK_POSTCONDITION(planeCount == 0 || planeCount == 2)
-            << "The OpenGL backend does not support images with plane counts of " << planeCount
-            << ".";
+    ASSERT_POSTCONDITION(planeCount == 0 || planeCount == 2,
+            "The OpenGL backend does not support images with plane counts of %d.", planeCount);

    // The pixel buffer must be locked whenever we do rendering with it. We'll unlock it before
    // releasing.
@@ -162,7 +162,7 @@ Driver* PlatformCocoaGL::createDriver(void* sharedContext, const Platform::Drive
    pImpl->mGLContext = nsOpenGLContext;

    int result = bluegl::bind();
-    FILAMENT_CHECK_POSTCONDITION(!result) << "Unable to load OpenGL entry points.";
+    ASSERT_POSTCONDITION(!result, "Unable to load OpenGL entry points.");

    UTILS_UNUSED_IN_RELEASE CVReturn success = CVOpenGLTextureCacheCreate(kCFAllocatorDefault, nullptr,
            [pImpl->mGLContext CGLContextObj], [pImpl->mGLContext.pixelFormat CGLPixelFormatObj], nullptr,
@@ -61,7 +61,7 @@ Driver* PlatformCocoaTouchGL::createDriver(void* const sharedGLContext, const Pl
    EAGLSharegroup* sharegroup = (__bridge EAGLSharegroup*) sharedGLContext;

    EAGLContext *context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES3 sharegroup:sharegroup];
-    FILAMENT_CHECK_POSTCONDITION(context) << "Unable to create OpenGL ES context.";
+    ASSERT_POSTCONDITION(context, "Unable to create OpenGL ES context.");

    [EAGLContext setCurrentContext:context];

@@ -103,7 +103,7 @@ void PlatformCocoaTouchGL::createContext(bool shared) {
    EAGLContext* const context = [[EAGLContext alloc]
                                  initWithAPI:kEAGLRenderingAPIOpenGLES3
                                   sharegroup:sharegroup];
-    FILAMENT_CHECK_POSTCONDITION(context) << "Unable to create extra OpenGL ES context.";
+    ASSERT_POSTCONDITION(context, "Unable to create extra OpenGL ES context.");
    [EAGLContext setCurrentContext:context];
    pImpl->mAdditionalContexts.push_back(context);
 }
@@ -180,8 +180,7 @@ bool PlatformCocoaTouchGL::makeCurrent(ContextType type, SwapChain* drawSwapChai
        glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldFramebuffer);
        glBindFramebuffer(GL_FRAMEBUFFER, pImpl->mDefaultFramebuffer);
        GLenum const status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-        FILAMENT_CHECK_POSTCONDITION(status == GL_FRAMEBUFFER_COMPLETE)
-                << "Incomplete framebuffer.";
+        ASSERT_POSTCONDITION(status == GL_FRAMEBUFFER_COMPLETE, "Incomplete framebuffer.");
        glBindFramebuffer(GL_FRAMEBUFFER, oldFramebuffer);
    }
    return true;
@@ -19,8 +19,6 @@
 #include <backend/platforms/PlatformEGL.h>
 #include <backend/platforms/PlatformEGLAndroid.h>

-#include <private/backend/VirtualMachineEnv.h>
-
 #include "opengl/GLUtils.h"
 #include "ExternalStreamManagerAndroid.h"

@@ -84,23 +82,9 @@ using EGLStream = Platform::Stream;

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

-PlatformEGLAndroid::InitializeJvmForPerformanceManagerIfNeeded::InitializeJvmForPerformanceManagerIfNeeded() {
-    // PerformanceHintManager() needs the calling thread to be a Java thread; so we need
-    // to attach this thread to the JVM before we initialize PerformanceHintManager.
-    // This should be done in PerformanceHintManager(), but libutils doesn't have access to
-    // VirtualMachineEnv.
-    if (PerformanceHintManager::isSupported()) {
-        (void)VirtualMachineEnv::get().getEnvironment();
-    }
-}
-
-// ---------------------------------------------------------------------------------------------
-
 PlatformEGLAndroid::PlatformEGLAndroid() noexcept
        : PlatformEGL(),
-          mExternalStreamManager(ExternalStreamManagerAndroid::create()),
-          mInitializeJvmForPerformanceManagerIfNeeded(),
-          mPerformanceHintManager() {
+          mExternalStreamManager(ExternalStreamManagerAndroid::create()) {

    char scratch[PROP_VALUE_MAX + 1];
    int length = __system_property_get("ro.build.version.release", scratch);
@@ -226,7 +226,7 @@ Driver* PlatformGLX::createDriver(void* const sharedGLContext,
    g_glx.setCurrentContext(mGLXDisplay, mDummySurface, mDummySurface, mGLXContext);

    int result = bluegl::bind();
-    FILAMENT_CHECK_POSTCONDITION(!result) << "Unable to load OpenGL entry points.";
+    ASSERT_POSTCONDITION(!result, "Unable to load OpenGL entry points.");

    return OpenGLPlatform::createDefaultDriver(this, sharedGLContext, driverConfig);
 }
@@ -154,7 +154,7 @@ Driver* PlatformWGL::createDriver(void* const sharedGLContext,
    }

    result = bluegl::bind();
-    FILAMENT_CHECK_POSTCONDITION(!result) << "Unable to load OpenGL entry points.";
+    ASSERT_POSTCONDITION(!result, "Unable to load OpenGL entry points.");

    return OpenGLPlatform::createDefaultDriver(this, sharedGLContext, driverConfig);

@@ -37,7 +37,7 @@ inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
        VulkanAttachment src, VulkanAttachment dst,
        const VkOffset3D srcRect[2], const VkOffset3D dstRect[2]) {
    if constexpr (FVK_ENABLED(FVK_DEBUG_BLITTER)) {
-        FVK_LOGD << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
+        utils::slog.d << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                      << " layout=" << src.getLayout()
                      << " to=" << dst.texture->getVkImage() << ",level=" << (int) dst.level
                      << " layout=" << dst.getLayout() << utils::io::endl;
@@ -76,7 +76,7 @@ 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)) {
-        FVK_LOGD << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
+        utils::slog.d << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                      << " layout=" << src.getLayout()
                      << " to=" << dst.texture->getVkImage() << ",level=" << (int) dst.level
                      << " layout=" << dst.getLayout() << utils::io::endl;
@@ -178,7 +178,7 @@ VulkanCommandBuffer& VulkanCommands::get() {
    // presenting the swap chain or waiting on a fence.
    while (mAvailableBufferCount == 0) {
 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
-        FVK_LOGI << "VulkanCommands has stalled. "
+        slog.i << "VulkanCommands has stalled. "
               << "If this occurs frequently, consider increasing VK_MAX_COMMAND_BUFFERS."
               << io::endl;
 #endif
@@ -289,7 +289,7 @@ bool VulkanCommands::flush() {
    };

 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
-    FVK_LOGI << "Submitting cmdbuffer=" << cmdbuffer
+    slog.i << "Submitting cmdbuffer=" << cmdbuffer
           << " wait=(" << signals[0] << ", " << signals[1] << ") "
           << " signal=" << renderingFinished
           << " fence=" << currentbuf->fence->fence
@@ -305,7 +305,7 @@ bool VulkanCommands::flush() {

 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
    if (result != VK_SUCCESS) {
-        FVK_LOGD << "Failed command buffer submission result: " << result << utils::io::endl;
+        utils::slog.d << "Failed command buffer submission result: " << result << utils::io::endl;
    }
 #endif
    assert_invariant(result == VK_SUCCESS);
@@ -320,7 +320,7 @@ VkSemaphore VulkanCommands::acquireFinishedSignal() {
    VkSemaphore semaphore = mSubmissionSignal;
    mSubmissionSignal = VK_NULL_HANDLE;
 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
-    FVK_LOGI << "Acquiring " << semaphore << " (e.g. for vkQueuePresentKHR)" << io::endl;
+    slog.i << "Acquiring " << semaphore << " (e.g. for vkQueuePresentKHR)" << io::endl;
 #endif
    return semaphore;
 }
@@ -329,7 +329,7 @@ void VulkanCommands::injectDependency(VkSemaphore next) {
    assert_invariant(mInjectedSignal == VK_NULL_HANDLE);
    mInjectedSignal = next;
 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
-    FVK_LOGI << "Injecting " << next << " (e.g. due to vkAcquireNextImageKHR)" << io::endl;
+    slog.i << "Injecting " << next << " (e.g. due to vkAcquireNextImageKHR)" << io::endl;
 #endif
 }

@@ -398,7 +398,7 @@ void VulkanCommands::pushGroupMarker(char const* str, VulkanGroupMarkers::Timest
    // If the timestamp is not 0, then we are carrying over a marker across buffer submits.
    // If it is 0, then this is a normal marker push and we should just print debug line as usual.
    if (timestamp.time_since_epoch().count() == 0.0) {
-        FVK_LOGD << "----> " << str << utils::io::endl;
+        utils::slog.d << "----> " << str << utils::io::endl;
    }
 #endif

@@ -436,7 +436,7 @@ void VulkanCommands::popGroupMarker() {
        auto const [marker, startTime] = mGroupMarkers->pop();
        auto const endTime = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> diff = endTime - startTime;
-        FVK_LOGD << "<---- " << marker << " elapsed: " << (diff.count() * 1000) << " ms"
+        utils::slog.d << "<---- " << marker << " elapsed: " << (diff.count() * 1000) << " ms"
                      << utils::io::endl;
 #else
        mGroupMarkers->pop();
@@ -17,8 +17,6 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANCONSTANTS_H
 #define TNT_FILAMENT_BACKEND_VULKANCONSTANTS_H

-#include <utils/Log.h>
-
 #include <stdint.h>

 // In debug builds, we enable validation layers and set up a debug callback.
@@ -72,11 +70,6 @@
 // the currently active resources.
 #define FVK_DEBUG_RESOURCE_LEAK           0x00010000

-// Set this to enable logging "only" to one output stream. This is useful in the case where we want
-// to debug with print statements and want ordered logging (e.g slog.i and slog.e will not appear in
-// order of calls).
-#define FVK_DEBUG_FORCE_LOG_TO_I          0x00020000
-
 // Useful default combinations
 #define FVK_DEBUG_EVERYTHING              0xFFFFFFFF
 #define FVK_DEBUG_PERFORMANCE     \
@@ -140,18 +133,6 @@ static_assert(FVK_ENABLED(FVK_DEBUG_VALIDATION));
 #define FVK_HANDLE_ARENA_SIZE_IN_MB 8
 #endif

-#if FVK_ENABLED(FVK_DEBUG_FORCE_LOG_TO_I)
-    #define FVK_LOGI (utils::slog.i)
-    #define FVK_LOGD FVK_LOGI
-    #define FVK_LOGE FVK_LOGI
-    #define FVK_LOGW FVK_LOGI
-#else
-    #define FVK_LOGE (utils::slog.e)
-    #define FVK_LOGW (utils::slog.w)
-    #define FVK_LOGD (utils::slog.d)
-    #define FVK_LOGI (utils::slog.i)
-#endif
-
 // All vkCreate* functions take an optional allocator. For now we select the default allocator by
 // passing in a null pointer, and we highlight the argument by using the VKALLOC constant.
 constexpr struct VkAllocationCallbacks* VKALLOC = nullptr;
@@ -86,7 +86,7 @@ VulkanTimestamps::VulkanTimestamps(VkDevice device) : mDevice(device) {
    std::unique_lock<utils::Mutex> lock(mMutex);
    tqpCreateInfo.queryCount = mUsed.size() * 2;
    VkResult result = vkCreateQueryPool(mDevice, &tqpCreateInfo, VKALLOC, &mPool);
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateQueryPool error.";
+    ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateQueryPool error.");
    mUsed.reset();
 }

@@ -100,7 +100,7 @@ std::tuple<uint32_t, uint32_t> VulkanTimestamps::getNextQuery() {
 	    return std::make_tuple(timerIndex * 2, timerIndex * 2 + 1);
        }
    }
-    FVK_LOGE << "More than " << maxTimers << " timers are not supported." << utils::io::endl;
+    utils::slog.e << "More than " << maxTimers << " timers are not supported." << utils::io::endl;
    return std::make_tuple(0, 1);
 }

@@ -134,8 +134,8 @@ VulkanTimestamps::QueryResult VulkanTimestamps::getResult(VulkanTimerQuery const
    VkResult vkresult =
            vkGetQueryPoolResults(mDevice, mPool, index, 2, dataSize, (void*) result.data(),
                    stride, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT);
-    FILAMENT_CHECK_POSTCONDITION(vkresult == VK_SUCCESS || vkresult == VK_NOT_READY)
-            << "vkGetQueryPoolResults error: " << static_cast<int32_t>(vkresult);
+    ASSERT_POSTCONDITION(vkresult == VK_SUCCESS || vkresult == VK_NOT_READY,
+            "vkGetQueryPoolResults error: %d", static_cast<int32_t>(vkresult));
    if (vkresult == VK_NOT_READY) {
        return {0, 0, 0, 0};
    }
@@ -120,32 +120,22 @@ public:
    }

    inline bool isImageCubeArraySupported() const noexcept {
-        return mPhysicalDeviceFeatures.imageCubeArray == VK_TRUE;
+        return mPhysicalDeviceFeatures.imageCubeArray;
    }

    inline bool isDebugMarkersSupported() const noexcept {
        return mDebugMarkersSupported;
    }
-
    inline bool isDebugUtilsSupported() const noexcept {
        return mDebugUtilsSupported;
    }

-    inline bool isMultiviewEnabled() const noexcept {
-        return mMultiviewEnabled;
-    }
-
-    inline bool isClipDistanceSupported() const noexcept {
-        return mPhysicalDeviceFeatures.shaderClipDistance == VK_TRUE;
-    }
-
 private:
    VkPhysicalDeviceMemoryProperties mMemoryProperties = {};
    VkPhysicalDeviceProperties mPhysicalDeviceProperties = {};
    VkPhysicalDeviceFeatures mPhysicalDeviceFeatures = {};
    bool mDebugMarkersSupported = false;
    bool mDebugUtilsSupported = false;
-    bool mMultiviewEnabled = false;

    VkFormatList mDepthStencilFormats;
    VkFormatList mBlittableDepthStencilFormats;
@@ -115,15 +115,15 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallback(VkDebugReportFlagsEXT flags,
        VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location,
        int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData) {
    if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
-        FVK_LOGE << "VULKAN ERROR: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
+        utils::slog.e << "VULKAN ERROR: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
    } else {
        // TODO: emit best practices warnings about aggressive pipeline barriers.
        if (strstr(pMessage, "ALL_GRAPHICS_BIT") || strstr(pMessage, "ALL_COMMANDS_BIT")) {
            return VK_FALSE;
        }
-        FVK_LOGW << "VULKAN WARNING: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
+        utils::slog.w << "VULKAN WARNING: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
    }
-    FVK_LOGE << utils::io::endl;
+    utils::slog.e << utils::io::endl;
    return VK_FALSE;
 }
 #endif // FVK_EANBLED(FVK_DEBUG_VALIDATION)
@@ -133,18 +133,18 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugUtilsCallback(VkDebugUtilsMessageSeverityFla
        VkDebugUtilsMessageTypeFlagsEXT types, const VkDebugUtilsMessengerCallbackDataEXT* cbdata,
        void* pUserData) {
    if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
-        FVK_LOGE << "VULKAN ERROR: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
-                 << utils::io::endl;
+        utils::slog.e << "VULKAN ERROR: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
+                      << utils::io::endl;
    } else {
        // TODO: emit best practices warnings about aggressive pipeline barriers.
        if (strstr(cbdata->pMessage, "ALL_GRAPHICS_BIT")
                || strstr(cbdata->pMessage, "ALL_COMMANDS_BIT")) {
            return VK_FALSE;
        }
-        FVK_LOGW << "VULKAN WARNING: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
-                 << utils::io::endl;
+        utils::slog.w << "VULKAN WARNING: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
+                      << utils::io::endl;
    }
-    FVK_LOGE << utils::io::endl;
+    utils::slog.e << utils::io::endl;
    return VK_FALSE;
 }
 #endif // FVK_EANBLED(FVK_DEBUG_DEBUG_UTILS)
@@ -173,8 +173,7 @@ DebugUtils::DebugUtils(VkInstance instance, VkDevice device, VulkanContext const
        };
        VkResult result = vkCreateDebugUtilsMessengerEXT(instance, &createInfo,
                VKALLOC, &mDebugMessenger);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-                << "Unable to create Vulkan debug messenger.";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS, "Unable to create Vulkan debug messenger.");
    }
 #endif // FVK_EANBLED(FVK_DEBUG_VALIDATION)
 }
@@ -229,8 +228,7 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
      mBlitter(mPlatform->getPhysicalDevice(), &mCommands),
      mReadPixels(mPlatform->getDevice()),
      mDescriptorSetManager(mPlatform->getDevice(), &mResourceAllocator),
-      mIsSRGBSwapChainSupported(mPlatform->getCustomization().isSRGBSwapChainSupported),
-      mStereoscopicType(driverConfig.stereoscopicType) {
+      mIsSRGBSwapChainSupported(mPlatform->getCustomization().isSRGBSwapChainSupported) {

 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
    DebugUtils::mSingleton =
@@ -248,8 +246,7 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
        };
        VkResult result = createDebugReportCallback(mPlatform->getInstance(), &cbinfo, VKALLOC,
                &mDebugCallback);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-                << "Unable to create Vulkan debug callback.";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS, "Unable to create Vulkan debug callback.");
    }
 #endif

@@ -292,7 +289,7 @@ Driver* VulkanDriver::create(VulkanPlatform* platform, VulkanContext const& cont
    //    VulkanRenderTarget            : 312       few
    // -- less than or equal to 312 bytes

-    FVK_LOGD
+    utils::slog.d
           << "\nVulkanSwapChain: " << sizeof(VulkanSwapChain)
           << "\nVulkanBufferObject: " << sizeof(VulkanBufferObject)
           << "\nVulkanVertexBuffer: " << sizeof(VulkanVertexBuffer)
@@ -325,10 +322,6 @@ ShaderModel VulkanDriver::getShaderModel() const noexcept {
 }

 void VulkanDriver::terminate() {
-    // Flush and wait here to make sure all queued commands are executed and resources that are tied
-    // to those commands are no longer referenced.
-    finish(0);
-
    delete mEmptyBufferObject;
    delete mEmptyTexture;

@@ -397,10 +390,7 @@ void VulkanDriver::collectGarbage() {
 }
 void VulkanDriver::beginFrame(int64_t monotonic_clock_ns,
        int64_t refreshIntervalNs, uint32_t frameId) {
-    FVK_SYSTRACE_CONTEXT();
-    FVK_SYSTRACE_START("beginFrame");
    // Do nothing.
-    FVK_SYSTRACE_END();
 }

 void VulkanDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
@@ -408,7 +398,7 @@ void VulkanDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
 }

 void VulkanDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
+        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
 }

 void VulkanDriver::setPresentationTime(int64_t monotonic_clock_ns) {
@@ -660,8 +650,8 @@ void VulkanDriver::createFenceR(Handle<HwFence> fh, int) {

 void VulkanDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow, uint64_t flags) {
    if ((flags & backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0 && !isSRGBSwapChainSupported()) {
-        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it"
-                 << utils::io::endl;
+        utils::slog.w << "sRGB swapchain requested, but Platform does not support it"
+                      << utils::io::endl;
        flags = flags | ~(backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE);
    }
    auto swapChain = mResourceAllocator.construct<VulkanSwapChain>(sch, mPlatform, mContext,
@@ -672,7 +662,7 @@ void VulkanDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
 void VulkanDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch, uint32_t width,
        uint32_t height, uint64_t flags) {
    if ((flags & backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0 && !isSRGBSwapChainSupported()) {
-        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it"
+        utils::slog.w << "sRGB swapchain requested, but Platform does not support it"
                      << utils::io::endl;
        flags = flags | ~(backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE);
    }
@@ -909,14 +899,13 @@ bool VulkanDriver::isProtectedContentSupported() {
    return false;
 }

-bool VulkanDriver::isStereoSupported() {
-    switch (mStereoscopicType) {
-        case backend::StereoscopicType::INSTANCED:
-            return mContext.isClipDistanceSupported();
-        case backend::StereoscopicType::MULTIVIEW:
-            return mContext.isMultiviewEnabled();
-        case backend::StereoscopicType::NONE:
-            return false;
+bool VulkanDriver::isStereoSupported(backend::StereoscopicType stereoscopicType) {
+    switch (stereoscopicType) {
+    case backend::StereoscopicType::INSTANCED:
+        return true;
+    case backend::StereoscopicType::MULTIVIEW:
+        // TODO: implement multiview feature in Vulkan.
+        return false;
    }
 }

@@ -1099,8 +1088,7 @@ TimerQueryResult VulkanDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint
        return TimerQueryResult::NOT_READY;
    }

-    FILAMENT_CHECK_POSTCONDITION(timestamp1 >= timestamp0)
-            << "Timestamps are not monotonically increasing.";
+    ASSERT_POSTCONDITION(timestamp1 >= timestamp0, "Timestamps are not monotonically increasing.");

    // NOTE: MoltenVK currently writes system time so the following delta will always be zero.
    // However there are plans for implementing this properly. See the following GitHub ticket.
@@ -1505,8 +1493,8 @@ void VulkanDriver::endRenderPass(int) {
 }

 void VulkanDriver::nextSubpass(int) {
-    FILAMENT_CHECK_PRECONDITION(mCurrentRenderPass.currentSubpass == 0)
-            << "Only two subpasses are currently supported.";
+    ASSERT_PRECONDITION(mCurrentRenderPass.currentSubpass == 0,
+            "Only two subpasses are currently supported.");

    VulkanRenderTarget* renderTarget = mCurrentRenderPass.renderTarget;
    assert_invariant(renderTarget);
@@ -1646,36 +1634,36 @@ void VulkanDriver::resolve(
    FVK_SYSTRACE_CONTEXT();
    FVK_SYSTRACE_START("resolve");

-    FILAMENT_CHECK_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE)
-            << "resolve() cannot be invoked inside a render pass.";
+    ASSERT_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE,
+            "resolve() cannot be invoked inside a render pass.");

    auto* const srcTexture = mResourceAllocator.handle_cast<VulkanTexture*>(src);
    auto* const dstTexture = mResourceAllocator.handle_cast<VulkanTexture*>(dst);
    assert_invariant(srcTexture);
    assert_invariant(dstTexture);

-    FILAMENT_CHECK_PRECONDITION(
-            dstTexture->width == srcTexture->width && dstTexture->height == srcTexture->height)
-            << "invalid resolve: src and dst sizes don't match";
+    ASSERT_PRECONDITION(
+            dstTexture->width == srcTexture->width && dstTexture->height == srcTexture->height,
+            "invalid resolve: src and dst sizes don't match");

-    FILAMENT_CHECK_PRECONDITION(srcTexture->samples > 1 && dstTexture->samples == 1)
-            << "invalid resolve: src.samples=" << +srcTexture->samples
-            << ", dst.samples=" << +dstTexture->samples;
+    ASSERT_PRECONDITION(srcTexture->samples > 1 && dstTexture->samples == 1,
+            "invalid resolve: src.samples=%u, dst.samples=%u",
+            +srcTexture->samples, +dstTexture->samples);

-    FILAMENT_CHECK_PRECONDITION(srcTexture->format == dstTexture->format)
-            << "src and dst texture format don't match";
+    ASSERT_PRECONDITION(srcTexture->format == dstTexture->format,
+            "src and dst texture format don't match");

-    FILAMENT_CHECK_PRECONDITION(!isDepthFormat(srcTexture->format))
-            << "can't resolve depth formats";
+    ASSERT_PRECONDITION(!isDepthFormat(srcTexture->format),
+            "can't resolve depth formats");

-    FILAMENT_CHECK_PRECONDITION(!isStencilFormat(srcTexture->format))
-            << "can't resolve stencil formats";
+    ASSERT_PRECONDITION(!isStencilFormat(srcTexture->format),
+            "can't resolve stencil formats");

-    FILAMENT_CHECK_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST))
-            << "texture doesn't have BLIT_DST";
+    ASSERT_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST),
+            "texture doesn't have BLIT_DST");

-    FILAMENT_CHECK_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC))
-            << "texture doesn't have BLIT_SRC";
+    ASSERT_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC),
+            "texture doesn't have BLIT_SRC");

    mBlitter.resolve(
            { .texture = dstTexture, .level = dstLevel, .layer = dstLayer },
@@ -1691,20 +1679,20 @@ void VulkanDriver::blit(
    FVK_SYSTRACE_CONTEXT();
    FVK_SYSTRACE_START("blit");

-    FILAMENT_CHECK_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE)
-            << "blit() cannot be invoked inside a render pass.";
+    ASSERT_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE,
+            "blit() cannot be invoked inside a render pass.");

    auto* const srcTexture = mResourceAllocator.handle_cast<VulkanTexture*>(src);
    auto* const dstTexture = mResourceAllocator.handle_cast<VulkanTexture*>(dst);

-    FILAMENT_CHECK_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST))
-            << "texture doesn't have BLIT_DST";
+    ASSERT_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST),
+            "texture doesn't have BLIT_DST");

-    FILAMENT_CHECK_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC))
-            << "texture doesn't have BLIT_SRC";
+    ASSERT_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC),
+            "texture doesn't have BLIT_SRC");

-    FILAMENT_CHECK_PRECONDITION(srcTexture->format == dstTexture->format)
-            << "src and dst texture format don't match";
+    ASSERT_PRECONDITION(srcTexture->format == dstTexture->format,
+            "src and dst texture format don't match");

    // The Y inversion below makes it so that Vk matches GL and Metal.

@@ -1736,15 +1724,15 @@ void VulkanDriver::blitDEPRECATED(TargetBufferFlags buffers,

    // Note: blitDEPRECATED is only used for Renderer::copyFrame()

-    FILAMENT_CHECK_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE)
-            << "blitDEPRECATED() cannot be invoked inside a render pass.";
+    ASSERT_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE,
+            "blitDEPRECATED() cannot be invoked inside a render pass.");

-    FILAMENT_CHECK_PRECONDITION(buffers == TargetBufferFlags::COLOR0)
-            << "blitDEPRECATED only supports COLOR0";
+    ASSERT_PRECONDITION(buffers == TargetBufferFlags::COLOR0,
+            "blitDEPRECATED only supports COLOR0");

-    FILAMENT_CHECK_PRECONDITION(
-            srcRect.left >= 0 && srcRect.bottom >= 0 && dstRect.left >= 0 && dstRect.bottom >= 0)
-            << "Source and destination rects must be positive.";
+    ASSERT_PRECONDITION(srcRect.left >= 0 && srcRect.bottom >= 0 &&
+                        dstRect.left >= 0 && dstRect.bottom >= 0,
+            "Source and destination rects must be positive.");

    VulkanRenderTarget* dstTarget = mResourceAllocator.handle_cast<VulkanRenderTarget*>(dst);
    VulkanRenderTarget* srcTarget = mResourceAllocator.handle_cast<VulkanRenderTarget*>(src);
@@ -1775,7 +1763,7 @@ void VulkanDriver::blitDEPRECATED(TargetBufferFlags buffers,
    FVK_SYSTRACE_END();
 }

-void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {
+void VulkanDriver::bindPipeline(PipelineState pipelineState) {
    FVK_SYSTRACE_CONTEXT();
    FVK_SYSTRACE_START("draw");

@@ -1862,9 +1850,9 @@ void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {
        // 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) && FVK_ENABLED_DEBUG_SAMPLER_NAME
-            FVK_LOGW << "Uninitialized texture bound to '" << bindingToName[binding] << "'";
-            FVK_LOGW << " in material '" << program->name.c_str() << "'";
-            FVK_LOGW << " at binding point " << +binding << utils::io::endl;
+            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;
 #endif
            texture = mEmptyTexture;
        }
@@ -1885,12 +1873,6 @@ void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {

    mPipelineCache.bindLayout(pipelineLayout);
    mPipelineCache.bindPipeline(commands);
-
-    // Since we don't statically define scissor as part of the pipeline, we need to call scissor at
-    // least once. Context: VUID-vkCmdDrawIndexed-None-07832.
-    auto const& extent = rt->getExtent();
-    scissor({0, 0, extent.width, extent.height});
-
    FVK_SYSTRACE_END();
 }

@@ -1981,7 +1963,7 @@ void VulkanDriver::scissor(Viewport scissorBox) {

    const VulkanRenderTarget* rt = mCurrentRenderPass.renderTarget;
    rt->transformClientRectToPlatform(&scissor);
-    vkCmdSetScissor(cmdbuffer, 0, 1, &scissor);
+    mPipelineCache.bindScissor(cmdbuffer, scissor);
 }

 void VulkanDriver::beginTimerQuery(Handle<HwTimerQuery> tqh) {
@@ -2014,7 +1996,7 @@ void VulkanDriver::debugCommandBegin(CommandStream* cmds, bool synchronous, cons
        assert_invariant(inRenderPass);
        inRenderPass = false;
    } else if (inRenderPass && OUTSIDE_COMMANDS.find(command) != OUTSIDE_COMMANDS.end()) {
-        FVK_LOGE << command.data() << " issued inside a render pass." << utils::io::endl;
+        utils::slog.e << command.data() << " issued inside a render pass." << utils::io::endl;
    }
 #endif
 }
@@ -28,7 +28,6 @@
 #include "VulkanSamplerCache.h"
 #include "VulkanStagePool.h"
 #include "VulkanUtility.h"
-#include "backend/DriverEnums.h"
 #include "caching/VulkanDescriptorSetManager.h"
 #include "caching/VulkanPipelineLayoutCache.h"

@@ -167,10 +166,10 @@ private:
        VkPipelineLayout pipelineLayout;
    };
    BoundPipeline mBoundPipeline = {};
+
    RenderPassFboBundle mRenderPassFboInfo;

    bool const mIsSRGBSwapChainSupported;
-    backend::StereoscopicType const mStereoscopicType;
 };

 } // namespace filament::backend
@@ -64,8 +64,8 @@ VulkanFboCache::VulkanFboCache(VkDevice device)
    : mDevice(device) {}

 VulkanFboCache::~VulkanFboCache() {
-    FILAMENT_CHECK_POSTCONDITION(mFramebufferCache.empty() && mRenderPassCache.empty())
-            << "Please explicitly call terminate() while the VkDevice is still alive.";
+    ASSERT_POSTCONDITION(mFramebufferCache.empty() && mRenderPassCache.empty(),
+            "Please explicitly call terminate() while the VkDevice is still alive.");
 }

 VkFramebuffer VulkanFboCache::getFramebuffer(FboKey config) noexcept {
@@ -95,7 +95,7 @@ VkFramebuffer VulkanFboCache::getFramebuffer(FboKey config) noexcept {
    }

    #if FVK_ENABLED(FVK_DEBUG_FBO_CACHE)
-    FVK_LOGD << "Creating framebuffer " << config.width << "x" << config.height << " "
+    utils::slog.d << "Creating framebuffer " << config.width << "x" << config.height << " "
        << "for render pass " << config.renderPass << ", "
        << "samples = " << int(config.samples) << ", "
        << "depth = " << (config.depth ? 1 : 0) << ", "
@@ -115,7 +115,7 @@ VkFramebuffer VulkanFboCache::getFramebuffer(FboKey config) noexcept {
    mRenderPassRefCount[info.renderPass]++;
    VkFramebuffer framebuffer;
    VkResult error = vkCreateFramebuffer(mDevice, &info, VKALLOC, &framebuffer);
-    FILAMENT_CHECK_POSTCONDITION(!error) << "Unable to create framebuffer.";
+    ASSERT_POSTCONDITION(!error, "Unable to create framebuffer.");
    mFramebufferCache[config] = {framebuffer, mCurrentTime};
    return framebuffer;
 }
@@ -306,11 +306,11 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
    // Finally, create the VkRenderPass.
    VkRenderPass renderPass;
    VkResult error = vkCreateRenderPass(mDevice, &renderPassInfo, VKALLOC, &renderPass);
-    FILAMENT_CHECK_POSTCONDITION(!error) << "Unable to create render pass.";
+    ASSERT_POSTCONDITION(!error, "Unable to create render pass.");
    mRenderPassCache[config] = {renderPass, mCurrentTime};

    #if FVK_ENABLED(FVK_DEBUG_FBO_CACHE)
-    FVK_LOGD << "Created render pass " << renderPass << " with "
+    utils::slog.d << "Created render pass " << renderPass << " with "
        << "samples = " << int(config.samples) << ", "
        << "depth = " << (hasDepth ? 1 : 0) << ", "
        << "colorAttachmentCount[0] = " << subpasses[0].colorAttachmentCount
@@ -237,7 +237,7 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
            .pCode = data,
        };
        VkResult result = vkCreateShaderModule(mDevice, &moduleInfo, VKALLOC, &module);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to create shader module.";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS, "Unable to create shader module.");

 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
        std::string name{ builder.getName().c_str(), builder.getName().size() };
@@ -292,8 +292,8 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
    }

 #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
-    FVK_LOGD << "Created VulkanProgram " << builder << ", shaders = (" << modules[0]
-             << ", " << modules[1] << ")" << utils::io::endl;
+    utils::slog.d << "Created VulkanProgram " << builder << ", shaders = (" << modules[0]
+                  << ", " << modules[1] << ")" << utils::io::endl;
 #endif
 }

@@ -79,6 +79,10 @@ void VulkanPipelineCache::bindPipeline(VulkanCommandBuffer* commands) {
    commands->setPipeline(cacheEntry->handle);
 }

+void VulkanPipelineCache::bindScissor(VkCommandBuffer cmdbuffer, VkRect2D scissor) noexcept {
+    vkCmdSetScissor(cmdbuffer, 0, 1, &scissor);
+}
+
 VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() noexcept {
    assert_invariant(mPipelineRequirements.shaders[0] && "Vertex shader is not bound.");
    assert_invariant(mPipelineRequirements.layout && "No pipeline layout specified");
@@ -230,15 +234,14 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
    PipelineCacheEntry cacheEntry = {};

    #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
-        FVK_LOGD << "vkCreateGraphicsPipelines with shaders = ("
-                 << shaderStages[0].module << ", " << shaderStages[1].module << ")"
-                 << utils::io::endl;
+        utils::slog.d << "vkCreateGraphicsPipelines with shaders = ("
+                << shaderStages[0].module << ", " << shaderStages[1].module << ")" << utils::io::endl;
    #endif
    VkResult error = vkCreateGraphicsPipelines(mDevice, VK_NULL_HANDLE, 1, &pipelineCreateInfo,
            VKALLOC, &cacheEntry.handle);
    assert_invariant(error == VK_SUCCESS);
    if (error != VK_SUCCESS) {
-        FVK_LOGE << "vkCreateGraphicsPipelines error " << error << utils::io::endl;
+        utils::slog.e << "vkCreateGraphicsPipelines error " << error << utils::io::endl;
        return nullptr;
    }

@@ -253,7 +256,7 @@ void VulkanPipelineCache::bindProgram(VulkanProgram* program) noexcept {
 #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
    if (mPipelineRequirements.shaders[0] == VK_NULL_HANDLE ||
            mPipelineRequirements.shaders[1] == VK_NULL_HANDLE) {
-        FVK_LOGE << "Binding missing shader: " << program->name.c_str() << utils::io::endl;
+        utils::slog.e << "Binding missing shader: " << program->name.c_str() << utils::io::endl;
    }
 #endif
 }
@@ -303,6 +306,7 @@ void VulkanPipelineCache::gc() noexcept {
    // 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 = {};
+    mCurrentScissor = {};

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

@@ -120,6 +120,9 @@ public:
    // Creates a new pipeline if necessary and binds it using vkCmdBindPipeline.
    void bindPipeline(VulkanCommandBuffer* commands);

+    // Sets up a new scissor rectangle if it has been dirtied.
+    void bindScissor(VkCommandBuffer cmdbuffer, VkRect2D scissor) noexcept;
+
    // Each of the following methods are fast and do not make Vulkan calls.
    void bindProgram(VulkanProgram* program) noexcept;
    void bindRasterState(const RasterState& rasterState) noexcept;
@@ -260,6 +263,9 @@ private:

    // Current bindings for the pipeline and descriptor sets.
    PipelineKey mBoundPipeline = {};
+
+    // Current state for scissoring.
+    VkRect2D mCurrentScissor = {};
 };

 } // namespace filament::backend
@@ -71,8 +71,8 @@ void TaskHandler::shutdown() {
    }
    mHasTaskCondition.notify_one();
    mThread.join();
-    FILAMENT_CHECK_POSTCONDITION(mTaskQueue.empty())
-            << "ReadPixels handler has tasks in the queue after shutdown";
+    ASSERT_POSTCONDITION(mTaskQueue.empty(),
+            "ReadPixels handler has tasks in the queue after shutdown");
 }

 void TaskHandler::loop() {
@@ -167,9 +167,9 @@ void VulkanReadPixels::run(VulkanRenderTarget* srcTarget, uint32_t const x, uint
    vkCreateImage(device, &imageInfo, VKALLOC, &stagingImage);

 #if FVK_ENABLED(FVK_DEBUG_READ_PIXELS)
-    FVK_LOGD << "readPixels created image=" << stagingImage
-             << " to copy from image=" << srcTexture->getVkImage()
-             << " src-layout=" << srcTexture->getLayout(0, 0) << utils::io::endl;
+    utils::slog.d << "readPixels created image=" << stagingImage
+                  << " to copy from image=" << srcTexture->getVkImage()
+                  << " src-layout=" << srcTexture->getLayout(0, 0) << utils::io::endl;
 #endif

    VkMemoryRequirements memReqs;
@@ -185,13 +185,13 @@ void VulkanReadPixels::run(VulkanRenderTarget* srcTarget, uint32_t const x, uint
    if (memoryTypeIndex >= VK_MAX_MEMORY_TYPES) {
        memoryTypeIndex = selectMemoryFunc(memReqs.memoryTypeBits,
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
-        FVK_LOGW
+        utils::slog.w
                << "readPixels is slow because VK_MEMORY_PROPERTY_HOST_CACHED_BIT is not available"
                << utils::io::endl;
    }

-    FILAMENT_CHECK_POSTCONDITION(memoryTypeIndex < VK_MAX_MEMORY_TYPES)
-            << "VulkanReadPixels: unable to find a memory type that meets requirements.";
+    ASSERT_POSTCONDITION(memoryTypeIndex < VK_MAX_MEMORY_TYPES,
+            "VulkanReadPixels: unable to find a memory type that meets requirements.");

    VkMemoryAllocateInfo const allocInfo = {
            .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
@@ -303,7 +303,7 @@ void VulkanReadPixels::run(VulkanRenderTarget* srcTarget, uint32_t const x, uint
        VkResult status = vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX);
        // Fence hasn't been reached. Try waiting again.
        if (status != VK_SUCCESS) {
-            FVK_LOGE << "Failed to wait for readPixels fence" << utils::io::endl;
+            utils::slog.e << "Failed to wait for readPixels fence=" << status << utils::io::endl;
            return;
        }

@@ -321,7 +321,7 @@ void VulkanReadPixels::run(VulkanRenderTarget* srcTarget, uint32_t const x, uint
                    getComponentCount(srcFormat), srcPixels,
                    static_cast<int>(subResourceLayout.rowPitch), static_cast<int>(width),
                    static_cast<int>(height), swizzle)) {
-            FVK_LOGE << "Unsupported PixelDataFormat or PixelDataType" << utils::io::endl;
+            utils::slog.e << "Unsupported PixelDataFormat or PixelDataType" << utils::io::endl;
        }

        vkUnmapMemory(device, stagingMemory);
@@ -111,11 +111,11 @@ private:
 #if DEBUG_RESOURCE_LEAKS
 public:
    void print() {
-        FVK_LOGD << "Resource Allocator state (debug only)" << utils::io::endl;
+        utils::slog.d << "Resource Allocator state (debug only)" << utils::io::endl;
        for (size_t i = 0; i < RESOURCE_TYPE_COUNT; i++) {
-            FVK_LOGD << "[" << i << "]=" << mDebugOnlyResourceCount[i] << utils::io::endl;
+            utils::slog.d << "[" << i << "]=" << mDebugOnlyResourceCount[i] << utils::io::endl;
        }
-        FVK_LOGD << "+++++++++++++++++++++++++++++++++++++" << utils::io::endl;
+        utils::slog.d << "+++++++++++++++++++++++++++++++++++++" << utils::io::endl;
    }
 private:
    utils::FixedCapacityVector<size_t> mDebugOnlyResourceCount;
@@ -122,7 +122,7 @@ VkSampler VulkanSamplerCache::getSampler(SamplerParams params) noexcept {
    };
    VkSampler sampler;
    VkResult error = vkCreateSampler(mDevice, &samplerInfo, VKALLOC, &sampler);
-    FILAMENT_CHECK_POSTCONDITION(!error) << "Unable to create sampler.";
+    ASSERT_POSTCONDITION(!error, "Unable to create sampler.");
    mCache.insert({params, sampler});
    return sampler;
 }
@@ -61,7 +61,7 @@ VulkanStage const* VulkanStagePool::acquireStage(uint32_t numBytes) {

 #if FVK_ENABLED(FVK_DEBUG_ALLOCATION)
    if (result != VK_SUCCESS) {
-        FVK_LOGE << "Allocation error: " << result << utils::io::endl;
+        utils::slog.e << "Allocation error: " << result << utils::io::endl;
    }
 #endif

@@ -35,12 +35,27 @@ VulkanSwapChain::VulkanSwapChain(VulkanPlatform* platform, VulkanContext const&
      mStagePool(stagePool),
      mHeadless(extent.width != 0 && extent.height != 0 && !nativeWindow),
      mFlushAndWaitOnResize(platform->getCustomization().flushAndWaitOnWindowResize),
-      mTransitionSwapChainImageLayoutForPresent(
-            platform->getCustomization().transitionSwapChainImageLayoutForPresent),
+      mCurrentImageReadyIndex(0),
      mAcquired(false),
      mIsFirstRenderPass(true) {
    swapChain = mPlatform->createSwapChain(nativeWindow, flags, extent);
-    FILAMENT_CHECK_POSTCONDITION(swapChain) << "Unable to create swapchain";
+    ASSERT_POSTCONDITION(swapChain, "Unable to create swapchain");
+
+    VkSemaphoreCreateInfo const createInfo = {
+            .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
+    };
+
+    // No need to wait on this semaphore before drawing when in Headless mode.
+    if (mHeadless) {
+		// Set all sempahores to VK_NULL_HANDLE
+		memset(mImageReady, 0, sizeof(mImageReady[0]) * IMAGE_READY_SEMAPHORE_COUNT);
+	} else {
+		for (uint32_t i = 0; i < IMAGE_READY_SEMAPHORE_COUNT; ++i) {
+			VkResult result =
+					vkCreateSemaphore(mPlatform->getDevice(), &createInfo, nullptr, mImageReady + i);
+			ASSERT_POSTCONDITION(result == VK_SUCCESS, "Failed to create semaphore");
+		}
+    }

    update();
 }
@@ -52,6 +67,11 @@ VulkanSwapChain::~VulkanSwapChain() {
    mCommands->wait();

    mPlatform->destroy(swapChain);
+	for (uint32_t i = 0; i < IMAGE_READY_SEMAPHORE_COUNT; ++i) {
+		if (mImageReady[i] != VK_NULL_HANDLE) {
+			vkDestroySemaphore(mPlatform->getDevice(), mImageReady[i], VKALLOC);
+		}
+	}
 }

 void VulkanSwapChain::update() {
@@ -74,7 +94,7 @@ void VulkanSwapChain::update() {
 }

 void VulkanSwapChain::present() {
-    if (!mHeadless && mTransitionSwapChainImageLayoutForPresent) {
+    if (!mHeadless) {
        VkCommandBuffer const cmdbuf = mCommands->get().buffer();
        VkImageSubresourceRange const subresources{
                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
@@ -85,21 +105,16 @@ void VulkanSwapChain::present() {
        };
        mColors[mCurrentSwapIndex]->transitionLayout(cmdbuf, subresources, VulkanLayout::PRESENT);
    }
-
    mCommands->flush();
-    
-    // call the image ready wait function
-    if (mExplicitImageReadyWait != nullptr) {
-        mExplicitImageReadyWait(swapChain);
-    }

-    // We only present if it is not headless. No-op for headless.
+    // We only present if it is not headless.  No-op for headless (but note that we still need the
+    // flush() in the above line).
    if (!mHeadless) {
        VkSemaphore const finishedDrawing = mCommands->acquireFinishedSignal();
        VkResult const result = mPlatform->present(swapChain, mCurrentSwapIndex, finishedDrawing);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR ||
-                result == VK_ERROR_OUT_OF_DATE_KHR)
-                << "Cannot present in swapchain.";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR ||
+                                     result == VK_ERROR_OUT_OF_DATE_KHR,
+                "Cannot present in swapchain.");
    }

    // We presented the last acquired buffer.
@@ -123,14 +138,13 @@ void VulkanSwapChain::acquire(bool& resized) {
        update();
    }

-    VulkanPlatform::ImageSyncData imageSyncData;
-    VkResult const result = mPlatform->acquire(swapChain, &imageSyncData);
-    mCurrentSwapIndex = imageSyncData.imageIndex;
-    mExplicitImageReadyWait = imageSyncData.explicitImageReadyWait;
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR) 
-        << "Cannot acquire in swapchain.";
-    if (imageSyncData.imageReadySemaphore != VK_NULL_HANDLE) {
-        mCommands->injectDependency(imageSyncData.imageReadySemaphore);
+	mCurrentImageReadyIndex = (mCurrentImageReadyIndex + 1) % IMAGE_READY_SEMAPHORE_COUNT;
+	const VkSemaphore imageReady = mImageReady[mCurrentImageReadyIndex];
+    VkResult const result = mPlatform->acquire(swapChain, imageReady, &mCurrentSwapIndex);
+    ASSERT_POSTCONDITION(result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR,
+            "Cannot acquire in swapchain.");
+    if (imageReady != VK_NULL_HANDLE) {
+        mCommands->injectDependency(imageReady);
    }
    mAcquired = true;
 }
@@ -50,10 +50,7 @@ struct VulkanSwapChain : public HwSwapChain, VulkanResource {
    void acquire(bool& reized);

    inline VulkanTexture* getCurrentColor() const noexcept {
-        uint32_t const imageIndex = mCurrentSwapIndex;
-        FILAMENT_CHECK_PRECONDITION(
-            imageIndex != VulkanPlatform::ImageSyncData::INVALID_IMAGE_INDEX);
-        return mColors[imageIndex].get();
+        return mColors[mCurrentSwapIndex].get();
    }

    inline VulkanTexture* getDepth() const noexcept {
@@ -83,15 +80,15 @@ private:
    VulkanStagePool& mStagePool;
    bool const mHeadless;
    bool const mFlushAndWaitOnResize;
-    bool const mTransitionSwapChainImageLayoutForPresent;

    // We create VulkanTextures based on VkImages. VulkanTexture has facilities for doing layout
    // transitions, which are useful here.
    utils::FixedCapacityVector<std::unique_ptr<VulkanTexture>> mColors;
    std::unique_ptr<VulkanTexture> mDepth;
    VkExtent2D mExtent;
+    VkSemaphore mImageReady[IMAGE_READY_SEMAPHORE_COUNT];
+	uint32_t mCurrentImageReadyIndex;
    uint32_t mCurrentSwapIndex;
-    std::function<void(Platform::SwapChain* handle)> mExplicitImageReadyWait = nullptr;
    bool mAcquired;
    bool mIsFirstRenderPass;
 };
@@ -113,7 +113,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        VkFormatProperties props;
        vkGetPhysicalDeviceFormatProperties(physicalDevice, mVkFormat, &props);
        if (!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
-            FVK_LOGW << "Texture usage is SAMPLEABLE but format " << mVkFormat << " is not "
+            utils::slog.w << "Texture usage is SAMPLEABLE but format " << mVkFormat << " is not "
                    "sampleable with optimal tiling." << utils::io::endl;
        }
 #endif
@@ -163,7 +163,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,

    VkResult error = vkCreateImage(mDevice, &imageInfo, VKALLOC, &mTextureImage);
    if (error || FVK_ENABLED(FVK_DEBUG_TEXTURE)) {
-        FVK_LOGD << "vkCreateImage: "
+        utils::slog.d << "vkCreateImage: "
            << "image = " << mTextureImage << ", "
            << "result = " << error << ", "
            << "handle = " << utils::io::hex << mTextureImage << utils::io::dec << ", "
@@ -177,7 +177,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
            << "target = " << static_cast<int>(target) <<", "
            << "format = " << mVkFormat << utils::io::endl;
    }
-    FILAMENT_CHECK_POSTCONDITION(!error) << "Unable to create image.";
+    ASSERT_POSTCONDITION(!error, "Unable to create image.");

    // Allocate memory for the VkImage and bind it.
    VkMemoryRequirements memReqs = {};
@@ -186,8 +186,8 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
    uint32_t memoryTypeIndex
            = context.selectMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);

-    FILAMENT_CHECK_POSTCONDITION(memoryTypeIndex < VK_MAX_MEMORY_TYPES)
-            << "VulkanTexture: unable to find a memory type that meets requirements.";
+    ASSERT_POSTCONDITION(memoryTypeIndex < VK_MAX_MEMORY_TYPES,
+            "VulkanTexture: unable to find a memory type that meets requirements.");

    VkMemoryAllocateInfo allocInfo = {
        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
@@ -195,9 +195,9 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        .memoryTypeIndex = memoryTypeIndex,
    };
    error = vkAllocateMemory(mDevice, &allocInfo, nullptr, &mTextureImageMemory);
-    FILAMENT_CHECK_POSTCONDITION(!error) << "Unable to allocate image memory.";
+    ASSERT_POSTCONDITION(!error, "Unable to allocate image memory.");
    error = vkBindImageMemory(mDevice, mTextureImage, mTextureImageMemory, 0);
-    FILAMENT_CHECK_POSTCONDITION(!error) << "Unable to bind image.";
+    ASSERT_POSTCONDITION(!error, "Unable to bind image.");

    uint32_t layerCount = 0;
    if (target == SamplerType::SAMPLER_CUBEMAP) {
@@ -450,7 +450,7 @@ void VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, const VkImageSubres
    }

 #if FVK_ENABLED(FVK_DEBUG_LAYOUT_TRANSITION)
-    FVK_LOGD << "transition texture=" << mTextureImage
+    utils::slog.d << "transition texture=" << mTextureImage
                  << " (" << range.baseArrayLayer
                  << "," << range.baseMipLevel << ")"
                  << " count=(" << range.layerCount
@@ -539,7 +539,7 @@ void VulkanTexture::print() const {
                layer < (mPrimaryViewRange.baseArrayLayer + mPrimaryViewRange.layerCount) &&
                level >= mPrimaryViewRange.baseMipLevel &&
                level < (mPrimaryViewRange.baseMipLevel + mPrimaryViewRange.levelCount);
-            FVK_LOGD << "[" << mTextureImage << "]: (" << layer << "," << level
+            utils::slog.d << "[" << mTextureImage << "]: (" << layer << "," << level
                          << ")=" << getLayout(layer, level)
                          << " primary=" << primary
                          << utils::io::endl;
@@ -548,7 +548,7 @@ void VulkanTexture::print() const {

    for (auto view: mCachedImageViews) {
        auto& range = view.first.range;
-        FVK_LOGD << "[" << mTextureImage << ", imageView=" << view.second << "]=>"
+        utils::slog.d << "[" << mTextureImage << ", imageView=" << view.second << "]=>"
                      << " (" << range.baseArrayLayer << "," << range.baseMipLevel << ")"
                      << " count=(" << range.layerCount << "," << range.levelCount << ")"
                      << " aspect=" << range.aspectMask << " viewType=" << view.first.type
@@ -51,7 +51,7 @@ VkFormat getVkFormat(ElementType type, bool normalized, bool integer) {
            case ElementType::SHORT4: return VK_FORMAT_R16G16B16A16_SNORM;
            case ElementType::USHORT4: return VK_FORMAT_R16G16B16A16_UNORM;
            default:
-                FILAMENT_CHECK_POSTCONDITION(false) << "Normalized format does not exist.";
+                ASSERT_POSTCONDITION(false, "Normalized format does not exist.");
                return VK_FORMAT_UNDEFINED;
        }
    }
@@ -56,13 +56,13 @@ uint8_t reduceSampleCount(uint8_t sampleCount, VkSampleCountFlags mask);
 // considered, but because the "variadic" part of the vk methods (i.e. the inputs) are before the
 // non-variadic parts, this breaks the template type matching logic. Hence, we use a macro approach
 // here.
-#define EXPAND_ENUM(...)                                                          \
-    uint32_t size = 0;                                                            \
-    VkResult result = func(__VA_ARGS__, nullptr);                                 \
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "enumerate size error"; \
-    utils::FixedCapacityVector<OutType> ret(size);                                \
-    result = func(__VA_ARGS__, ret.data());                                       \
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "enumerate error";      \
+#define EXPAND_ENUM(...)\
+    uint32_t size = 0;\
+    VkResult result = func(__VA_ARGS__, nullptr);\
+    ASSERT_POSTCONDITION(result == VK_SUCCESS, "enumerate size error");\
+    utils::FixedCapacityVector<OutType> ret(size);\
+    result = func(__VA_ARGS__, ret.data());\
+    ASSERT_POSTCONDITION(result == VK_SUCCESS, "enumerate error");\
    return std::move(ret);

 #define EXPAND_ENUM_NO_ARGS() EXPAND_ENUM(&size)
@@ -170,9 +170,9 @@ public:
        };
        VkDescriptorSet vkSet;
        UTILS_UNUSED VkResult result = vkAllocateDescriptorSets(mDevice, &allocInfo, &vkSet);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-                << "Failed to allocate descriptor set code=" << result << " size=" << mSize
-                << " capacity=" << mCapacity << " count=" << "%s";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS,
+                "Failed to allocate descriptor set code=%d size=%d capacity=%d count=%s", result,
+                mSize, mCapacity);
        mSize++;
        return createSet(layout->bitmask, vkSet);
    }
@@ -16,8 +16,6 @@

 #include "backend/platforms/VulkanPlatform.h"

-#include <backend/DriverEnums.h>
-
 #include "vulkan/platform/VulkanPlatformSwapChainImpl.h"
 #include "vulkan/VulkanConstants.h"
 #include "vulkan/VulkanDriver.h"
@@ -46,11 +44,7 @@ namespace {

 constexpr uint32_t const INVALID_VK_INDEX = 0xFFFFFFFF;

-using ExtensionSet = VulkanPlatform::ExtensionSet;
-
-inline bool setContains(ExtensionSet const& set, utils::CString const& extension) {
-    return set.find(extension) != set.end();
-};
+typedef std::unordered_set<std::string_view> ExtensionSet;

 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
 // These strings need to be allocated outside a function stack
@@ -86,7 +80,7 @@ FixedCapacityVector<const char*> getEnabledLayers() {

 void printDeviceInfo(VkInstance instance, VkPhysicalDevice device) {
    // Print some driver or MoltenVK information if it is available.
-    if (vkGetPhysicalDeviceProperties2) {
+    if (vkGetPhysicalDeviceProperties2KHR) {
        VkPhysicalDeviceDriverProperties driverProperties = {
                .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
        };
@@ -94,8 +88,8 @@ void printDeviceInfo(VkInstance instance, VkPhysicalDevice device) {
                .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
                .pNext = &driverProperties,
        };
-        vkGetPhysicalDeviceProperties2(device, &physicalDeviceProperties2);
-        FVK_LOGI << "Vulkan device driver: " << driverProperties.driverName << " "
+        vkGetPhysicalDeviceProperties2KHR(device, &physicalDeviceProperties2);
+        utils::slog.i << "Vulkan device driver: " << driverProperties.driverName << " "
                      << driverProperties.driverInfo << utils::io::endl;
    }

@@ -128,7 +122,7 @@ void printDeviceInfo(VkInstance instance, VkPhysicalDevice device) {
    const FixedCapacityVector<VkPhysicalDevice> physicalDevices
            = filament::backend::enumerate(vkEnumeratePhysicalDevices, instance);

-    FVK_LOGI << "Selected physical device '" << deviceProperties.deviceName << "' from "
+    utils::slog.i << "Selected physical device '" << deviceProperties.deviceName << "' from "
                  << physicalDevices.size() << " physical devices. "
                  << "(vendor " << utils::io::hex << vendorID << ", "
                  << "device " << deviceID << ", "
@@ -142,55 +136,50 @@ void printDepthFormats(VkPhysicalDevice device) {
    // Note that Vulkan is more constrained than OpenGL ES 3.1 in this area.
    const VkFormatFeatureFlags required = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
                                              | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
-    FVK_LOGI << "Sampleable depth formats: ";
+    utils::slog.i << "Sampleable depth formats: ";
    for (VkFormat format : ALL_VK_FORMATS) {
        VkFormatProperties props;
        vkGetPhysicalDeviceFormatProperties(device, format, &props);
        if ((props.optimalTilingFeatures & required) == required) {
-            FVK_LOGI << format << " ";
+            utils::slog.i << format << " ";
        }
    }
-    FVK_LOGI << utils::io::endl;
+    utils::slog.i << utils::io::endl;
 }
 #endif

-ExtensionSet getInstanceExtensions(ExtensionSet const& externallyRequiredExts = {}) {
-    ExtensionSet const TARGET_EXTS = {
-        // Request all cross-platform extensions.
-        VK_KHR_SURFACE_EXTENSION_NAME,
-        VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
+ExtensionSet getInstanceExtensions() {
+    std::string_view const TARGET_EXTS[] = {
+            // Request all cross-platform extensions.
+            VK_KHR_SURFACE_EXTENSION_NAME,
+            VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,

-    // Request these if available.
+            // Request these if available.
 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
-        VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
+            VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
 #endif
-        VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,
+            VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,

 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
-        VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
+            VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
 #endif
    };
    ExtensionSet exts;
-    FixedCapacityVector<VkExtensionProperties> const availableExts =
-            filament::backend::enumerate(vkEnumerateInstanceExtensionProperties,
+    FixedCapacityVector<VkExtensionProperties> const availableExts
+            = filament::backend::enumerate(vkEnumerateInstanceExtensionProperties,
                    static_cast<char const*>(nullptr) /* pLayerName */);
    for (auto const& extProps: availableExts) {
-        utils::CString name { extProps.extensionName };
-
-        // To workaround an Adreno bug where the extension name could be of 0 length.
-        if (name.size() == 0) {
-            continue;
-        }
-
-        if (setContains(TARGET_EXTS, name) || setContains(externallyRequiredExts, name)) {
-            exts.insert(name);
+        for (auto const& targetExt: TARGET_EXTS) {
+            if (targetExt == extProps.extensionName) {
+                exts.insert(targetExt);
+            }
        }
    }
    return exts;
 }

 ExtensionSet getDeviceExtensions(VkPhysicalDevice device) {
-    ExtensionSet const TARGET_EXTS = {
+    std::string_view const TARGET_EXTS[] = {
 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
            VK_EXT_DEBUG_MARKER_EXTENSION_NAME,
 #endif
@@ -198,7 +187,6 @@ ExtensionSet getDeviceExtensions(VkPhysicalDevice device) {
            VK_KHR_MAINTENANCE1_EXTENSION_NAME,
            VK_KHR_MAINTENANCE2_EXTENSION_NAME,
            VK_KHR_MAINTENANCE3_EXTENSION_NAME,
-            VK_KHR_MULTIVIEW_EXTENSION_NAME,
    };
    ExtensionSet exts;
    // Identify supported physical device extensions
@@ -206,15 +194,10 @@ ExtensionSet getDeviceExtensions(VkPhysicalDevice device) {
            = filament::backend::enumerate(vkEnumerateDeviceExtensionProperties, device,
                    static_cast<const char*>(nullptr) /* pLayerName */);
    for (auto const& extension: extensions) {
-        utils::CString name { extension.extensionName };
-
-        // To workaround an Adreno bug where the extension name could be of 0 length.
-        if (name.size() == 0) {
-            continue;
-        }
-
-        if (setContains(TARGET_EXTS, name)) {
-            exts.insert(name);
+        for (auto const& targetExt: TARGET_EXTS) {
+            if (targetExt == extension.extensionName) {
+                exts.insert(targetExt);
+            }
        }
    }
    return exts;
@@ -242,11 +225,11 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
        instanceCreateInfo.ppEnabledLayerNames = enabledLayers.data();
    } else {
 #if defined(__ANDROID__)
-        FVK_LOGD << "Validation layers are not available; did you set jniLibs in your "
-                 << "gradle file?" << utils::io::endl;
+        utils::slog.d << "Validation layers are not available; did you set jniLibs in your "
+                      << "gradle file?" << utils::io::endl;
 #else
-        FVK_LOGD << "Validation layer not available; did you install the Vulkan SDK?\n"
-                 << "Please ensure that VK_LAYER_PATH is set correctly." << utils::io::endl;
+        utils::slog.d << "Validation layer not available; did you install the Vulkan SDK?\n"
+                      << "Please ensure that VK_LAYER_PATH is set correctly." << utils::io::endl;
 #endif // __ANDROID__

    }
@@ -262,7 +245,7 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
        ppEnabledExtensions[enabledExtensionCount++] = VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME;
    }
    // Request platform-specific extensions.
-    for (auto const& requiredExt: requiredExts) {
+    for (auto const requiredExt: requiredExts) {
        assert_invariant(enabledExtensionCount < MAX_INSTANCE_EXTENSION_COUNT);
        ppEnabledExtensions[enabledExtensionCount++] = requiredExt.data();
    }
@@ -277,7 +260,7 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
    instanceCreateInfo.pApplicationInfo = &appInfo;
    instanceCreateInfo.enabledExtensionCount = enabledExtensionCount;
    instanceCreateInfo.ppEnabledExtensionNames = ppEnabledExtensions;
-    if (setContains(requiredExts, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)) {
+    if (requiredExts.find(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) != requiredExts.end()) {
        instanceCreateInfo.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
    }

@@ -294,14 +277,14 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
    }

    VkResult result = vkCreateInstance(&instanceCreateInfo, VKALLOC, &instance);
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "Unable to create Vulkan instance. Result=" << result;
+    ASSERT_POSTCONDITION(result == VK_SUCCESS, "Unable to create Vulkan instance. Result=%d",
+            result);
    return instance;
 }

 VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
-        VkPhysicalDeviceFeatures const& features, uint32_t graphicsQueueFamilyIndex,
-        ExtensionSet const& deviceExtensions) {
+        const VkPhysicalDeviceFeatures& features, uint32_t graphicsQueueFamilyIndex,
+        const ExtensionSet& deviceExtensions) {
    VkDevice device;
    VkDeviceQueueCreateInfo deviceQueueCreateInfo[1] = {};
    const float queuePriority[] = {1.0f};
@@ -309,9 +292,9 @@ VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
    FixedCapacityVector<const char*> requestExtensions;
    requestExtensions.reserve(deviceExtensions.size() + 1);

-    // TODO: We don't really need this if we only ever expect headless swapchains.
+    // TODO:We don't really need this if we only ever expect headless swapchains.
    requestExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
-    for (auto const& ext: deviceExtensions) {
+    for (auto ext: deviceExtensions) {
        requestExtensions.push_back(ext.data());
    }
    deviceQueueCreateInfo->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
@@ -328,41 +311,24 @@ VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
            .samplerAnisotropy = features.samplerAnisotropy,
            .textureCompressionETC2 = features.textureCompressionETC2,
            .textureCompressionBC = features.textureCompressionBC,
-            .shaderClipDistance = features.shaderClipDistance,
    };

    deviceCreateInfo.pEnabledFeatures = &enabledFeatures;
    deviceCreateInfo.enabledExtensionCount = (uint32_t) requestExtensions.size();
    deviceCreateInfo.ppEnabledExtensionNames = requestExtensions.data();

-    void* pNext = nullptr;
    VkPhysicalDevicePortabilitySubsetFeaturesKHR portability = {
            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR,
            .pNext = nullptr,
            .imageViewFormatSwizzle = VK_TRUE,
            .mutableComparisonSamplers = VK_TRUE,
    };
-    if (setContains(deviceExtensions, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)) {
-        portability.pNext = pNext;
-        pNext = &portability;
+    if (deviceExtensions.find(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) != deviceExtensions.end()) {
+        deviceCreateInfo.pNext = &portability;
    }

-    VkPhysicalDeviceMultiviewFeaturesKHR multiview = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR,
-            .pNext = nullptr,
-            .multiview = VK_TRUE,
-            .multiviewGeometryShader = VK_FALSE,
-            .multiviewTessellationShader = VK_FALSE
-    };
-    if (setContains(deviceExtensions, VK_KHR_MULTIVIEW_EXTENSION_NAME)) {
-        multiview.pNext = pNext;
-        pNext = &multiview;
-    }
-
-    deviceCreateInfo.pNext = pNext;
-
    VkResult result = vkCreateDevice(physicalDevice, &deviceCreateInfo, VKALLOC, &device);
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateDevice error=" << result << ".";
+    ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateDevice error.");

    return device;
 }
@@ -376,16 +342,16 @@ std::tuple<ExtensionSet, ExtensionSet> pruneExtensions(VkPhysicalDevice device,

 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
    // debugUtils and debugMarkers extensions are used mutually exclusively.
-    if (setContains(newInstExts, VK_EXT_DEBUG_UTILS_EXTENSION_NAME) &&
-            setContains(newInstExts, VK_EXT_DEBUG_MARKER_EXTENSION_NAME)) {
+    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

 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
    // debugMarker must also request debugReport the instance extension. So check if that's present.
-    if (setContains(newInstExts, VK_EXT_DEBUG_MARKER_EXTENSION_NAME) &&
-            !setContains(newInstExts, VK_EXT_DEBUG_MARKER_EXTENSION_NAME)) {
+    if (newDeviceExts.find(VK_EXT_DEBUG_MARKER_EXTENSION_NAME) != newDeviceExts.end()
+            && newInstExts.find(VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == newInstExts.end()) {
        newDeviceExts.erase(VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
    }
 #endif
@@ -435,8 +401,8 @@ inline int deviceTypeOrder(VkPhysicalDeviceType deviceType) {
        case VK_PHYSICAL_DEVICE_TYPE_OTHER:
            return 1;
        default:
-            FVK_LOGW << "deviceTypeOrder: Unexpected deviceType: " << deviceType
-                     << utils::io::endl;
+            utils::slog.w << "deviceTypeOrder: Unexpected deviceType: " << deviceType
+                          << utils::io::endl;
            return -1;
    }
 }
@@ -496,9 +462,9 @@ VkPhysicalDevice selectPhysicalDevice(VkInstance instance,
        deviceList[deviceInd].name = targetDeviceProperties.deviceName;
    }

-    FILAMENT_CHECK_PRECONDITION(gpuPreference.index < static_cast<int32_t>(deviceList.size()))
-            << "Provided GPU index=" << gpuPreference.index
-            << " >= the number of GPUs=" << static_cast<int32_t>(deviceList.size());
+    ASSERT_PRECONDITION(gpuPreference.index < static_cast<int32_t>(deviceList.size()),
+            "Provided GPU index=%d >= the number of GPUs=%d", gpuPreference.index,
+            static_cast<int32_t>(deviceList.size()));

    // Sort the found devices
    std::sort(deviceList.begin(), deviceList.end(),
@@ -526,7 +492,7 @@ VkPhysicalDevice selectPhysicalDevice(VkInstance instance,
                return deviceTypeOrder(a.deviceType) < deviceTypeOrder(b.deviceType);
            });
    auto device = deviceList.back().device;
-    FILAMENT_CHECK_POSTCONDITION(device != VK_NULL_HANDLE) << "Unable to find suitable device.";
+    ASSERT_POSTCONDITION(device != VK_NULL_HANDLE, "Unable to find suitable device.");
    return device;
 }

@@ -591,7 +557,6 @@ struct VulkanPlatformPrivate {
    std::unordered_set<SwapChainPtr> mHeadlessSwapChains;

    bool mSharedContext = false;
-    bool mForceXCBSwapchain = false;
 };

 void VulkanPlatform::terminate() {
@@ -615,21 +580,21 @@ void VulkanPlatform::terminate() {
 Driver* VulkanPlatform::createDriver(void* sharedContext,
        const Platform::DriverConfig& driverConfig) noexcept {
    // Load Vulkan entry points.
-    FILAMENT_CHECK_POSTCONDITION(bluevk::initialize()) << "BlueVK is unable to load entry points.";
+    ASSERT_POSTCONDITION(bluevk::initialize(), "BlueVK is unable to load entry points.");

    if (sharedContext) {
        VulkanSharedContext const* scontext = (VulkanSharedContext const*) sharedContext;
        // All fields of VulkanSharedContext should be present.
-        FILAMENT_CHECK_PRECONDITION(scontext->instance != VK_NULL_HANDLE)
-                << "Client needs to provide VkInstance";
-        FILAMENT_CHECK_PRECONDITION(scontext->physicalDevice != VK_NULL_HANDLE)
-                << "Client needs to provide VkPhysicalDevice";
-        FILAMENT_CHECK_PRECONDITION(scontext->logicalDevice != VK_NULL_HANDLE)
-                << "Client needs to provide VkDevice";
-        FILAMENT_CHECK_PRECONDITION(scontext->graphicsQueueFamilyIndex != INVALID_VK_INDEX)
-                << "Client needs to provide graphics queue family index";
-        FILAMENT_CHECK_PRECONDITION(scontext->graphicsQueueIndex != INVALID_VK_INDEX)
-                << "Client needs to provide graphics queue index";
+        ASSERT_PRECONDITION(scontext->instance != VK_NULL_HANDLE,
+                "Client needs to provide VkInstance");
+        ASSERT_PRECONDITION(scontext->physicalDevice != VK_NULL_HANDLE,
+                "Client needs to provide VkPhysicalDevice");
+        ASSERT_PRECONDITION(scontext->logicalDevice != VK_NULL_HANDLE,
+                "Client needs to provide VkDevice");
+        ASSERT_PRECONDITION(scontext->graphicsQueueFamilyIndex != INVALID_VK_INDEX,
+                "Client needs to provide graphics queue family index");
+        ASSERT_PRECONDITION(scontext->graphicsQueueIndex != INVALID_VK_INDEX,
+                "Client needs to provide graphics queue index");

        mImpl->mInstance = scontext->instance;
        mImpl->mPhysicalDevice = scontext->physicalDevice;
@@ -645,25 +610,7 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
    ExtensionSet instExts;
    // If using a shared context, we do not assume any extensions.
    if (!mImpl->mSharedContext) {
-        // This constains instance extensions that are required for the platform, which includes
-        // swapchain surface extensions.
-        auto const& swapchainExts = getSwapchainInstanceExtensions();
-        instExts = getInstanceExtensions(swapchainExts);
-
-#if defined(FILAMENT_SUPPORTS_XCB) && defined(FILAMENT_SUPPORTS_XLIB)
-        // For the special case where we're on linux and both xcb and xlib are "required", then we
-        // check if the set of supported extensions contain both of them.  If only xcb is supported,
-        // we force XCB surface creation.  This workaround is needed for the default swiftshader
-        // build where only XCB is available.
-        if (setContains(swapchainExts, VK_KHR_XCB_SURFACE_EXTENSION_NAME) &&
-                setContains(swapchainExts, VK_KHR_XLIB_SURFACE_EXTENSION_NAME)) {
-            // Assume only XCB is left, then we force the XCB path in the swapchain creation.
-            mImpl->mForceXCBSwapchain = !setContains(instExts, VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
-            assert_invariant(!mImpl->mForceXCBSwapchain ||
-                             setContains(instExts, VK_KHR_XCB_SURFACE_EXTENSION_NAME));
-        }
-#endif
-
+        instExts = getInstanceExtensions();
        instExts.merge(getRequiredInstanceExtensions());
    }

@@ -675,8 +622,8 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,

    VulkanPlatform::Customization::GPUPreference const pref = getCustomization().gpu;
    bool const hasGPUPreference = pref.index >= 0 || !pref.deviceName.empty();
-    FILAMENT_CHECK_PRECONDITION(!(hasGPUPreference && sharedContext))
-            << "Cannot both share context and indicate GPU preference";
+    ASSERT_PRECONDITION(!(hasGPUPreference && sharedContext),
+            "Cannot both share context and indicate GPU preference");

    mImpl->mPhysicalDevice = mImpl->mPhysicalDevice == VK_NULL_HANDLE
                                     ? selectPhysicalDevice(mImpl->mInstance, pref)
@@ -697,12 +644,6 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
                      : mImpl->mGraphicsQueueFamilyIndex;
    assert_invariant(mImpl->mGraphicsQueueFamilyIndex != INVALID_VK_INDEX);

-    // Only enable shaderClipDistance if we are doing instanced stereoscopic rendering.
-    if (context.mPhysicalDeviceFeatures.shaderClipDistance == VK_TRUE
-            && driverConfig.stereoscopicType != StereoscopicType::INSTANCED) {
-        context.mPhysicalDeviceFeatures.shaderClipDistance = VK_FALSE;
-    }
-
    // At this point, we should have a family index that points to a family that has > 0 queues for
    // graphics. In which case, we will allocate one queue for all of Filament (and assumes at least
    // one has been allocated by the client if context was shared). If the index of the target queue
@@ -718,10 +659,6 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
                = pruneExtensions(mImpl->mPhysicalDevice, instExts, deviceExts);
        instExts = prunedInstExts;
        deviceExts = prunedDeviceExts;
-
-        if (driverConfig.stereoscopicType != StereoscopicType::MULTIVIEW) {
-            deviceExts.erase(VK_KHR_MULTIVIEW_EXTENSION_NAME);
-        }
    }

    mImpl->mDevice
@@ -735,14 +672,15 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
    assert_invariant(mImpl->mGraphicsQueue != VK_NULL_HANDLE);

    // Store the extension support in the context
-    context.mDebugUtilsSupported = setContains(instExts, VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
-    context.mDebugMarkersSupported = setContains(deviceExts, VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
-    context.mMultiviewEnabled = setContains(deviceExts, VK_KHR_MULTIVIEW_EXTENSION_NAME);
+    context.mDebugUtilsSupported
+            = instExts.find(VK_EXT_DEBUG_UTILS_EXTENSION_NAME) != instExts.end();
+    context.mDebugMarkersSupported
+            = deviceExts.find(VK_EXT_DEBUG_MARKER_EXTENSION_NAME) != deviceExts.end();

 #ifdef NDEBUG
    // If we are in release build, we should not have turned on debug extensions
-    FILAMENT_CHECK_POSTCONDITION(!context.mDebugUtilsSupported && !context.mDebugMarkersSupported)
-            << "Debug utils should not be enabled in release build.";
+    ASSERT_POSTCONDITION(!context.mDebugUtilsSupported && !context.mDebugMarkersSupported,
+            "Debug utils should not be enabled in release build.");
 #endif

    context.mDepthStencilFormats = findAttachmentDepthStencilFormats(mImpl->mPhysicalDevice);
@@ -772,8 +710,8 @@ VulkanPlatform::SwapChainBundle VulkanPlatform::getSwapChainBundle(SwapChainPtr
    SWAPCHAIN_RET_FUNC(getSwapChainBundle, handle, )
 }

-VkResult VulkanPlatform::acquire(SwapChainPtr handle, ImageSyncData* outImageSyncData) {
-    SWAPCHAIN_RET_FUNC(acquire, handle, outImageSyncData)
+VkResult VulkanPlatform::acquire(SwapChainPtr handle, VkSemaphore clientSignal, uint32_t* index) {
+    SWAPCHAIN_RET_FUNC(acquire, handle, clientSignal, index)
 }

 VkResult VulkanPlatform::present(SwapChainPtr handle, uint32_t index,
@@ -810,10 +748,6 @@ SwapChainPtr VulkanPlatform::createSwapChain(void* nativeWindow, uint64_t flags,
        return swapchain;
    }

-    if (mImpl->mForceXCBSwapchain) {
-        flags |= SWAP_CHAIN_CONFIG_ENABLE_XCB;
-    }
-
    auto [surface, fallbackExtent] = createVkSurfaceKHR(nativeWindow, mImpl->mInstance, flags);
    // The VulkanPlatformSurfaceSwapChain now `owns` the surface.
    VulkanPlatformSurfaceSwapChain* swapchain = new VulkanPlatformSurfaceSwapChain(mImpl->mContext,
@@ -46,7 +46,7 @@
            uint32_t height;
        } wl;
    }// anonymous namespace
-#elif defined(LINUX_OR_FREEBSD) && defined(FILAMENT_SUPPORTS_X11)
+#elif LINUX_OR_FREEBSD && defined(FILAMENT_SUPPORTS_X11)
    // TODO: we should allow for headless on Linux explicitly. Right now this is the headless path
    // (with no FILAMENT_SUPPORTS_XCB or FILAMENT_SUPPORTS_XLIB).
    #include <dlfcn.h>
@@ -86,23 +86,22 @@ using namespace bluevk;

 namespace filament::backend {

-VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() {
-    VulkanPlatform::ExtensionSet const ret = {
-#if defined(__ANDROID__)
-        VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
-#elif defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
-        VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
-#elif defined(LINUX_OR_FREEBSD) && defined(FILAMENT_SUPPORTS_X11)
-    #if defined(FILAMENT_SUPPORTS_XCB)
-        VK_KHR_XCB_SURFACE_EXTENSION_NAME,
+VulkanPlatform::ExtensionSet VulkanPlatform::getRequiredInstanceExtensions() {
+    VulkanPlatform::ExtensionSet ret;
+    #if defined(__ANDROID__)
+        ret.insert("VK_KHR_android_surface");
+    #elif defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
+        ret.insert("VK_KHR_wayland_surface");
+    #elif LINUX_OR_FREEBSD && defined(FILAMENT_SUPPORTS_X11)
+        #if defined(FILAMENT_SUPPORTS_XCB)
+            ret.insert("VK_KHR_xcb_surface");
+        #endif
+        #if defined(FILAMENT_SUPPORTS_XLIB)
+            ret.insert("VK_KHR_xlib_surface");
+        #endif
+    #elif defined(WIN32)
+        ret.insert("VK_KHR_win32_surface");
    #endif
-    #if defined(FILAMENT_SUPPORTS_XLIB)
-        VK_KHR_XLIB_SURFACE_EXTENSION_NAME,
-    #endif
-#elif defined(WIN32)
-        VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
-#endif
-    };
    return ret;
 }

@@ -123,7 +122,7 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
        };
        VkResult const result = vkCreateAndroidSurfaceKHR(instance, &createInfo, VKALLOC,
                (VkSurfaceKHR*) &surface);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateAndroidSurfaceKHR error.";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateAndroidSurfaceKHR error.");
    #elif defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
        wl* ptrval = reinterpret_cast<wl*>(nativeWindow);
        extent.width = ptrval->width;
@@ -138,20 +137,24 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
        };
        VkResult const result = vkCreateWaylandSurfaceKHR(instance, &createInfo, VKALLOC,
                (VkSurfaceKHR*) &surface);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateWaylandSurfaceKHR error.";
-    #elif defined(LINUX_OR_FREEBSD) && defined(FILAMENT_SUPPORTS_X11)
+        ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateWaylandSurfaceKHR error.");
+    #elif LINUX_OR_FREEBSD && defined(FILAMENT_SUPPORTS_X11)
        if (g_x11_vk.library == nullptr) {
            g_x11_vk.library = dlopen(LIBRARY_X11, RTLD_LOCAL | RTLD_NOW);
-            FILAMENT_CHECK_PRECONDITION(g_x11_vk.library) << "Unable to open X11 library.";
+            ASSERT_PRECONDITION(g_x11_vk.library, "Unable to open X11 library.");
            #if defined(FILAMENT_SUPPORTS_XCB)
                g_x11_vk.xcbConnect = (XCB_CONNECT) dlsym(g_x11_vk.library, "xcb_connect");
                int screen;
                g_x11_vk.connection = g_x11_vk.xcbConnect(nullptr, &screen);
+                ASSERT_POSTCONDITION(vkCreateXcbSurfaceKHR,
+                        "Unable to load vkCreateXcbSurfaceKHR function.");
            #endif
            #if defined(FILAMENT_SUPPORTS_XLIB)
                g_x11_vk.openDisplay = (X11_OPEN_DISPLAY) dlsym(g_x11_vk.library, "XOpenDisplay");
                g_x11_vk.display = g_x11_vk.openDisplay(NULL);
-                FILAMENT_CHECK_PRECONDITION(g_x11_vk.display) << "Unable to open X11 display.";
+                ASSERT_PRECONDITION(g_x11_vk.display, "Unable to open X11 display.");
+                ASSERT_POSTCONDITION(vkCreateXlibSurfaceKHR,
+                        "Unable to load vkCreateXlibSurfaceKHR function.");
            #endif
        }
        #if defined(FILAMENT_SUPPORTS_XCB) || defined(FILAMENT_SUPPORTS_XLIB)
@@ -164,9 +167,6 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
                useXcb = true;
            #endif
            if (useXcb) {
-                FILAMENT_CHECK_POSTCONDITION(vkCreateXcbSurfaceKHR)
-                        << "Unable to load vkCreateXcbSurfaceKHR function.";
-
                VkXcbSurfaceCreateInfoKHR const createInfo = {
                        .sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
                        .connection = g_x11_vk.connection,
@@ -174,15 +174,11 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
                };
                VkResult const result = vkCreateXcbSurfaceKHR(instance, &createInfo, VKALLOC,
                        (VkSurfaceKHR*) &surface);
-                FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-                        << "vkCreateXcbSurfaceKHR error.";
+                ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateXcbSurfaceKHR error.");
            }
        #endif
        #if defined(FILAMENT_SUPPORTS_XLIB)
            if (!useXcb) {
-                FILAMENT_CHECK_POSTCONDITION(vkCreateXlibSurfaceKHR)
-                        << "Unable to load vkCreateXlibSurfaceKHR function.";
-
                VkXlibSurfaceCreateInfoKHR const createInfo = {
                        .sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
                        .dpy = g_x11_vk.display,
@@ -190,8 +186,7 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
                };
                VkResult const result = vkCreateXlibSurfaceKHR(instance, &createInfo, VKALLOC,
                        (VkSurfaceKHR*) &surface);
-                FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-                        << "vkCreateXlibSurfaceKHR error.";
+                ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateXlibSurfaceKHR error.");
            }
        #endif
    #elif defined(WIN32)
@@ -202,7 +197,7 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
        };
        VkResult const result = vkCreateWin32SurfaceKHR(instance, &createInfo, nullptr,
                (VkSurfaceKHR*) &surface);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateWin32SurfaceKHR error.";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateWin32SurfaceKHR error.");
    #endif
    return std::make_tuple(surface, extent);
 }
@@ -52,14 +52,13 @@ using namespace bluevk;

 namespace filament::backend {

-VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() {
-    ExtensionSet const ret = {
+VulkanPlatform::ExtensionSet VulkanPlatform::getRequiredInstanceExtensions() {
+    ExtensionSet ret;
    #if defined(__APPLE__)
-        VK_MVK_MACOS_SURFACE_EXTENSION_NAME,  // TODO: replace with VK_EXT_metal_surface
-    #elif defined(IOS) && defined(METAL_AVAILABLE)
-        VK_MVK_IOS_SURFACE_EXTENSION_NAME,
+        ret.insert("VK_MVK_macos_surface"); // TODO: replace with VK_EXT_metal_surface
+    #elif defined(IOS)
+        ret.insert("VK_MVK_ios_surface");
    #endif
-    };
    return ret;
 }

@@ -68,22 +67,20 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
    VkSurfaceKHR surface;
    #if defined(__APPLE__)
        NSView* nsview = (__bridge NSView*) nativeWindow;
-        FILAMENT_CHECK_POSTCONDITION(nsview) << "Unable to obtain Metal-backed NSView.";
+        ASSERT_POSTCONDITION(nsview, "Unable to obtain Metal-backed NSView.");

        // Create the VkSurface.
-        FILAMENT_CHECK_POSTCONDITION(vkCreateMacOSSurfaceMVK)
-                << "Unable to load vkCreateMacOSSurfaceMVK.";
+        ASSERT_POSTCONDITION(vkCreateMacOSSurfaceMVK, "Unable to load vkCreateMacOSSurfaceMVK.");
        VkMacOSSurfaceCreateInfoMVK createInfo = {};
        createInfo.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
        createInfo.pView = (__bridge void*) nsview;
        VkResult result = vkCreateMacOSSurfaceMVK((VkInstance) instance, &createInfo, VKALLOC,
                (VkSurfaceKHR*) &surface);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateMacOSSurfaceMVK error.";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateMacOSSurfaceMVK error.");
    #elif defined(IOS) && defined(METAL_AVAILABLE)
        CAMetalLayer* metalLayer = (CAMetalLayer*) nativeWindow;
        // Create the VkSurface.
-        FILAMENT_CHECK_POSTCONDITION(vkCreateIOSSurfaceMVK)
-                << "Unable to load vkCreateIOSSurfaceMVK function.";
+        ASSERT_POSTCONDITION(vkCreateIOSSurfaceMVK, "Unable to load vkCreateIOSSurfaceMVK function.");
        VkIOSSurfaceCreateInfoMVK createInfo = {};
        createInfo.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
        createInfo.pNext = NULL;
@@ -91,7 +88,7 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
        createInfo.pView = metalLayer;
        VkResult result = vkCreateIOSSurfaceMVK((VkInstance) instance, &createInfo, VKALLOC,
                (VkSurfaceKHR*) &surface);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateIOSSurfaceMVK error.";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateIOSSurfaceMVK error.");
    #endif
    return std::make_tuple(surface, VkExtent2D {});
 }
@@ -50,8 +50,8 @@ std::tuple<VkImage, VkDeviceMemory> createImageAndMemory(VulkanContext const& co
    };
    VkImage image;
    VkResult result = vkCreateImage(device, &imageInfo, VKALLOC, &image);
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "Unable to create image: " << static_cast<int32_t>(result);
+    ASSERT_POSTCONDITION(result == VK_SUCCESS,
+            "Unable to create image: ", static_cast<int32_t>(result));

    // Allocate memory for the VkImage and bind it.
    VkDeviceMemory imageMemory;
@@ -61,8 +61,8 @@ std::tuple<VkImage, VkDeviceMemory> createImageAndMemory(VulkanContext const& co
    uint32_t memoryTypeIndex
            = context.selectMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);

-    FILAMENT_CHECK_POSTCONDITION(memoryTypeIndex < VK_MAX_MEMORY_TYPES)
-            << "VulkanPlatformSwapChainImpl: unable to find a memory type that meets requirements.";
+    ASSERT_POSTCONDITION(memoryTypeIndex < VK_MAX_MEMORY_TYPES,
+            "VulkanPlatformSwapChainImpl: unable to find a memory type that meets requirements.");

    VkMemoryAllocateInfo allocInfo = {
            .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
@@ -70,9 +70,9 @@ std::tuple<VkImage, VkDeviceMemory> createImageAndMemory(VulkanContext const& co
            .memoryTypeIndex = memoryTypeIndex,
    };
    result = vkAllocateMemory(device, &allocInfo, nullptr, &imageMemory);
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to allocate image memory.";
+    ASSERT_POSTCONDITION(result == VK_SUCCESS, "Unable to allocate image memory.");
    result = vkBindImageMemory(device, image, imageMemory, 0);
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to bind image.";
+    ASSERT_POSTCONDITION(result == VK_SUCCESS, "Unable to bind image.");
    return std::tuple(image, imageMemory);
 }

@@ -133,7 +133,6 @@ VulkanPlatformSurfaceSwapChain::VulkanPlatformSurfaceSwapChain(VulkanContext con
 VulkanPlatformSurfaceSwapChain::~VulkanPlatformSurfaceSwapChain() {
    vkDestroySwapchainKHR(mDevice, mSwapchain, VKALLOC);
    vkDestroySurfaceKHR(mInstance, mSurface, VKALLOC);
-    destroy();
 }

 VkResult VulkanPlatformSurfaceSwapChain::create() {
@@ -154,7 +153,7 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
    // the number of images, though there may be limits related to the total amount of memory used
    // by presentable images."
    if (maxImageCount != 0 && desiredImageCount > maxImageCount) {
-        FVK_LOGE << "Swap chain does not support " << desiredImageCount << " images."
+        utils::slog.e << "Swap chain does not support " << desiredImageCount << " images."
                      << utils::io::endl;
        desiredImageCount = caps.minImageCount;
    }
@@ -179,8 +178,8 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
            break;
        }
    }
-    FILAMENT_CHECK_POSTCONDITION(surfaceFormat.format != VK_FORMAT_UNDEFINED)
-            << "Cannot find suitable swapchain format";
+    ASSERT_POSTCONDITION(surfaceFormat.format != VK_FORMAT_UNDEFINED,
+            "Cannot find suitable swapchain format");

    // Verify that our chosen present mode is supported. In practice all devices support the FIFO
    // mode, but we check for it anyway for completeness.  (and to avoid validation warnings)
@@ -194,8 +193,8 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
            break;
        }
    }
-    FILAMENT_CHECK_POSTCONDITION(foundSuitablePresentMode)
-            << "Desired present mode is not supported by this device.";
+    ASSERT_POSTCONDITION(foundSuitablePresentMode,
+            "Desired present mode is not supported by this device.");

    // Create the low-level swap chain.
    if (caps.currentExtent.width == VULKAN_UNDEFINED_EXTENT
@@ -238,8 +237,8 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
            .oldSwapchain = mSwapchain,
    };
    VkResult result = vkCreateSwapchainKHR(mDevice, &createInfo, VKALLOC, &mSwapchain);
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkGetPhysicalDeviceSurfaceFormatsKHR error: " << static_cast<int32_t>(result);
+    ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkGetPhysicalDeviceSurfaceFormatsKHR error: %d",
+            static_cast<int32_t>(result));

    mSwapChainBundle.colors = enumerate(vkGetSwapchainImagesKHR, mDevice, mSwapchain);
    mSwapChainBundle.colorFormat = surfaceFormat.format;
@@ -247,7 +246,7 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
            selectDepthFormat(mContext.getAttachmentDepthStencilFormats(), mHasStencil);
    mSwapChainBundle.depth = createImage(mSwapChainBundle.extent, mSwapChainBundle.depthFormat);

-    FVK_LOGI << "vkCreateSwapchain"
+    slog.i << "vkCreateSwapchain"
           << ": " << mSwapChainBundle.extent.width << "x" << mSwapChainBundle.extent.height << ", "
           << surfaceFormat.format << ", " << surfaceFormat.colorSpace << ", "
           << "swapchain-size=" << mSwapChainBundle.colors.size() << ", "
@@ -255,29 +254,19 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
           << "depth=" << mSwapChainBundle.depthFormat
           << io::endl;

-    VkSemaphoreCreateInfo const semaphoreCreateInfo = {
-            .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
-    };
-
-    for (uint32_t i = 0; i < IMAGE_READY_SEMAPHORE_COUNT; ++i) {
-        VkResult result = vkCreateSemaphore(mDevice, &semaphoreCreateInfo, nullptr,
-                mImageReady + i);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Failed to create semaphore";
-    }
-
    return result;
 }

-VkResult VulkanPlatformSurfaceSwapChain::acquire(VulkanPlatform::ImageSyncData* outImageSyncData) {
-    mCurrentImageReadyIndex = (mCurrentImageReadyIndex + 1) % IMAGE_READY_SEMAPHORE_COUNT;
-    outImageSyncData->imageReadySemaphore = mImageReady[mCurrentImageReadyIndex];
-    VkResult result = vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX,
-            outImageSyncData->imageReadySemaphore, VK_NULL_HANDLE, &outImageSyncData->imageIndex);
+VkResult VulkanPlatformSurfaceSwapChain::acquire(VkSemaphore clientSignal, uint32_t* index) {
+    // This immediately retrieves the index of the next available presentable image, and
+    // asynchronously requests the GPU to trigger the "imageAvailable" semaphore.
+    VkResult result = vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX, clientSignal,
+            VK_NULL_HANDLE, index);

    // Users should be notified of a suboptimal surface, but it should not cause a cascade of
    // log messages or a loop of re-creations.
    if (result == VK_SUBOPTIMAL_KHR && !mSuboptimal) {
-        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain." << io::endl;
+        slog.w << "Vulkan Driver: Suboptimal swap chain." << io::endl;
        mSuboptimal = true;
    }
    return result;
@@ -299,7 +288,7 @@ VkResult VulkanPlatformSurfaceSwapChain::present(uint32_t index, VkSemaphore fin
    // On Android Q and above, a suboptimal surface is always reported after screen rotation:
    // https://android-developers.googleblog.com/2020/02/handling-device-orientation-efficiently.html
    if (result == VK_SUBOPTIMAL_KHR && !mSuboptimal) {
-        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain." << utils::io::endl;
+        utils::slog.w << "Vulkan Driver: Suboptimal swap chain." << utils::io::endl;
        mSuboptimal = true;
    }
    return result;
@@ -323,17 +312,6 @@ VkResult VulkanPlatformSurfaceSwapChain::recreate() {
    return create();
 }

-void VulkanPlatformSurfaceSwapChain::destroy() {
-    VulkanPlatformSwapChainImpl::destroy();
-
-    for (uint32_t i = 0; i < IMAGE_READY_SEMAPHORE_COUNT; ++i) {
-        if (mImageReady[i] != VK_NULL_HANDLE) {
-            vkDestroySemaphore(mDevice, mImageReady[i], VKALLOC);
-            mImageReady[i] = VK_NULL_HANDLE;
-        }
-    }
-}
-
 VulkanPlatformHeadlessSwapChain::VulkanPlatformHeadlessSwapChain(VulkanContext const& context,
        VkDevice device, VkQueue queue, VkExtent2D extent, uint64_t flags)
    : VulkanPlatformSwapChainImpl(context, device, queue),
@@ -365,8 +343,8 @@ VkResult VulkanPlatformHeadlessSwapChain::present(uint32_t index, VkSemaphore fi
    return VK_SUCCESS;
 }

-VkResult VulkanPlatformHeadlessSwapChain::acquire(VulkanPlatform::ImageSyncData* outImageSyncData) {
-    outImageSyncData->imageIndex = mCurrentIndex;
+VkResult VulkanPlatformHeadlessSwapChain::acquire(VkSemaphore clientSignal, uint32_t* index) {
+    *index = mCurrentIndex;
    mCurrentIndex = (mCurrentIndex + 1) % HEADLESS_SWAPCHAIN_SIZE;
    return VK_SUCCESS;
 }
@@ -42,7 +42,7 @@ struct VulkanPlatformSwapChainImpl : public Platform::SwapChain {
    ~VulkanPlatformSwapChainImpl();

    // Non-virtual override-able method
-    VkResult acquire(VulkanPlatform::ImageSyncData* outImageSyncData) {
+    VkResult acquire(VkSemaphore clientSignal, uint32_t* index) {
        PANIC_PRECONDITION("Should not be called");
        return VK_ERROR_UNKNOWN;
    }
@@ -86,7 +86,7 @@ struct VulkanPlatformSurfaceSwapChain : public VulkanPlatformSwapChainImpl {
    ~VulkanPlatformSurfaceSwapChain();

    // Non-virtual override
-    VkResult acquire(VulkanPlatform::ImageSyncData* outImageSyncData);
+    VkResult acquire(VkSemaphore clientSignal, uint32_t* index);

    // Non-virtual override
    VkResult present(uint32_t index, VkSemaphore finished);
@@ -97,13 +97,7 @@ struct VulkanPlatformSurfaceSwapChain : public VulkanPlatformSwapChainImpl {
    // Non-virtual override-able method
    bool hasResized();

-protected:
-    // Non-virtual override-able method
-    void destroy();
-
 private:
-    static constexpr int IMAGE_READY_SEMAPHORE_COUNT = FVK_MAX_COMMAND_BUFFERS;
-    
    VkResult create();

    VkInstance mInstance;
@@ -112,8 +106,6 @@ private:
    VkSurfaceKHR mSurface;
    VkSwapchainKHR mSwapchain = VK_NULL_HANDLE;
    VkExtent2D const mFallbackExtent;
-    VkSemaphore mImageReady[IMAGE_READY_SEMAPHORE_COUNT];
-    uint32_t mCurrentImageReadyIndex;

    bool mUsesRGB = false;
    bool mHasStencil = false;
@@ -129,7 +121,7 @@ struct VulkanPlatformHeadlessSwapChain : public VulkanPlatformSwapChainImpl {
    ~VulkanPlatformHeadlessSwapChain();

    // Non-virtual override
-    VkResult acquire(VulkanPlatform::ImageSyncData* outImageSyncData);
+    VkResult acquire(VkSemaphore clientSignal, uint32_t* index);

    // Non-virtual override
    VkResult present(uint32_t index, VkSemaphore finished);
@@ -25,7 +25,6 @@
 #include <unordered_map>
 #include <variant>
 #include <vector>
-#include <cstring>

 namespace filament::backend {

@@ -22,11 +22,14 @@
 #include <spirv_glsl.hpp>
 #include <spirv_msl.hpp>

+#include <spirv-tools/libspirv.hpp>
+
 #include "../src/GLSLPostProcessor.h"

 #include "builtinResource.h"

 #include <utils/FixedCapacityVector.h>
+#include <utils/Log.h>

 #include <iostream>
 #include <utility>
@@ -36,6 +39,7 @@ namespace test {

 using namespace glslang;
 using namespace spirv_cross;
+using namespace spvtools;

 using namespace filament::backend;

@@ -128,6 +132,8 @@ ShaderGenerator::Blob ShaderGenerator::transpileShader(

    bool ok = tShader.parse(&DefaultTBuiltInResource, version, false, msg);

+    utils::slog.e <<"-----------" << shaderCString << utils::io::endl;
+
    if (!ok) {
        std::cerr << "ERROR: Unable to parse " <<
            (stage == ShaderStage::VERTEX ? "vertex" : "fragment") << " shader:" << std::endl;
@@ -146,6 +152,13 @@ ShaderGenerator::Blob ShaderGenerator::transpileShader(

    GlslangToSpv(*program.getIntermediate(language), spirv);

+    SpirvTools const tools(SPV_ENV_UNIVERSAL_1_3);
+    std::string disassembly;
+    bool rr = tools.Disassemble(spirv, &disassembly);
+
+    utils::slog.e <<"dissambly=" << rr << "\n" <<
+        disassembly << utils::io::endl;
+
    std::string result;

    assert_invariant(backend == Backend::OPENGL ||
@@ -1,122 +0,0 @@
-/*
- * Copyright (C) 2024 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "BackendTest.h"
-
-using namespace filament;
-using namespace filament::backend;
-
-namespace test {
-
-TEST_F(BackendTest, FrameScheduledCallback) {
-    auto& api = getDriverApi();
-
-    // Create a SwapChain.
-    // In order for the frameScheduledCallback to be called, this must be a real SwapChain (not
-    // headless) so we obtain a drawable.
-    auto swapChain = createSwapChain();
-
-    Handle<HwRenderTarget> renderTarget = api.createDefaultRenderTarget();
-
-    int callbackCountA = 0;
-    api.setFrameScheduledCallback(swapChain, nullptr, [&callbackCountA](PresentCallable callable) {
-        callable();
-        callbackCountA++;
-    });
-
-    // Render the first frame.
-    api.makeCurrent(swapChain, swapChain);
-    api.beginFrame(0, 0, 0);
-    api.beginRenderPass(renderTarget, {});
-    api.endRenderPass(0);
-    api.commit(swapChain);
-    api.endFrame(0);
-
-    // Render the next frame. The same callback should be called.
-    api.makeCurrent(swapChain, swapChain);
-    api.beginFrame(0, 0, 0);
-    api.beginRenderPass(renderTarget, {});
-    api.endRenderPass(0);
-    api.commit(swapChain);
-    api.endFrame(0);
-
-    // Now switch out the callback.
-    int callbackCountB = 0;
-    api.setFrameScheduledCallback(swapChain, nullptr, [&callbackCountB](PresentCallable callable) {
-        callable();
-        callbackCountB++;
-    });
-
-    // Render one final frame.
-    api.makeCurrent(swapChain, swapChain);
-    api.beginFrame(0, 0, 0);
-    api.beginRenderPass(renderTarget, {});
-    api.endRenderPass(0);
-    api.commit(swapChain);
-    api.endFrame(0);
-
-    api.finish();
-
-    executeCommands();
-    getDriver().purge();
-
-    EXPECT_EQ(callbackCountA, 2);
-    EXPECT_EQ(callbackCountB, 1);
-}
-
-TEST_F(BackendTest, FrameCompletedCallback) {
-    auto& api = getDriverApi();
-
-    // Create a SwapChain.
-    auto swapChain = api.createSwapChainHeadless(256, 256, 0);
-
-    int callbackCountA = 0;
-    api.setFrameCompletedCallback(swapChain, nullptr,
-            [&callbackCountA]() { callbackCountA++; });
-
-    // Render the first frame.
-    api.makeCurrent(swapChain, swapChain);
-    api.beginFrame(0, 0, 0);
-    api.commit(swapChain);
-    api.endFrame(0);
-
-    // Render the next frame. The same callback should be called.
-    api.makeCurrent(swapChain, swapChain);
-    api.beginFrame(0, 0, 0);
-    api.commit(swapChain);
-    api.endFrame(0);
-
-    // Now switch out the callback.
-    int callbackCountB = 0;
-    api.setFrameCompletedCallback(swapChain, nullptr,
-            [&callbackCountB]() { callbackCountB++; });
-
-    // Render one final frame.
-    api.makeCurrent(swapChain, swapChain);
-    api.beginFrame(0, 0, 0);
-    api.commit(swapChain);
-    api.endFrame(0);
-
-    api.finish();
-
-    executeCommands();
-    getDriver().purge();
-
-    EXPECT_EQ(callbackCountA, 2);
-    EXPECT_EQ(callbackCountB, 1);
-}
-
-} // namespace test
--- a/Show More
+++ b/Show More