new LinearAllocatorWithFallback

LinearAllocatorWithFallback is a linear allocator that can fall back to the heap allocator. We use it for the high level command buffer to avoid crashing when running out of memory. FIXES=[277115740]
Rework RenderPass to improve allocations and API
2024-02-21 14:52:04 -08:00 · 2024-02-21 14:51:57 -08:00 · 2024-02-21 14:51:51 -08:00 · 2024-02-21 14:51:44 -08:00 · 2024-02-21 14:51:36 -08:00
374 changed files with 6342 additions and 17512 deletions
@@ -129,7 +129,7 @@ jobs:
      - name: Sign sample-gltf-viewer
        run: |
          echo "${APK_KEYSTORE_BASE64}" > filament.jks.base64
-          base64 --decode -i filament.jks.base64 > filament.jks
+          base64 --decode filament.jks.base64 > filament.jks
          BUILD_TOOLS_VERSION=$(ls ${ANDROID_HOME}/build-tools | sort -V | tail -n 1)
          APKSIGNER=${ANDROID_HOME}/build-tools/${BUILD_TOOLS_VERSION}/apksigner
          IN_FILE="out/sample-gltf-viewer-release.apk"
@@ -205,7 +205,7 @@ jobs:
          TAG: ${{ steps.git_ref.outputs.tag }}
        run: |
          build\windows\build-github.bat release
-          move out\filament-windows.tgz out\filament-%TAG%-windows.tgz
+          move out\filament-windows.tgz out\filament-$Env:TAG-windows.tgz
        shell: cmd
      - uses: actions/github-script@v6
        env:
@@ -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)
@@ -43,8 +45,6 @@ option(FILAMENT_ENABLE_TSAN "Enable Thread Sanitizer" OFF)

 option(FILAMENT_ENABLE_FEATURE_LEVEL_0 "Enable Feature Level 0" ON)

-option(FILAMENT_ENABLE_MULTIVIEW "Enable multiview for Filament" OFF)
-
 set(FILAMENT_NDK_VERSION "" CACHE STRING
    "Android NDK version or version prefix to be used when building for Android."
 )
@@ -69,10 +69,6 @@ set(FILAMENT_METAL_HANDLE_ARENA_SIZE_IN_MB "8" CACHE STRING
    "Size of the Metal handle arena, default 8."
 )

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

@@ -143,6 +139,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()
@@ -166,6 +167,15 @@ if (NOT ANDROID AND NOT WEBGL AND NOT IOS AND NOT FILAMENT_LINUX_IS_MOBILE)
    set(IS_HOST_PLATFORM TRUE)
 endif()

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

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

@@ -440,13 +453,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 +468,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")
@@ -523,29 +531,6 @@ else()
    option(FILAMENT_DISABLE_MATOPT "Disable material optimizations" ON)
 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
-    "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\" ")
-endif ()
-
-# Compiling samples for multiview implies enabling multiview feature as well.
-if (FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "multiview")
-    set(FILAMENT_ENABLE_MULTIVIEW ON)
-endif ()
-
-# Define backend flag for debug only
-if (CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT FILAMENT_BACKEND_DEBUG_FLAG STREQUAL "")
-    add_definitions(-DFILAMENT_BACKEND_DEBUG_FLAG=${FILAMENT_BACKEND_DEBUG_FLAG})
-    unset(FILAMENT_BACKEND_DEBUG_FLAG)
-endif()
-
 # ==================================================================================================
 # Material compilation flags
 # ==================================================================================================
@@ -674,6 +659,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
 # ==================================================================================================
@@ -802,9 +802,6 @@ if (IS_HOST_PLATFORM)
    add_subdirectory(${TOOLS}/glslminifier)
    add_subdirectory(${TOOLS}/matc)
    add_subdirectory(${TOOLS}/matinfo)
-    if (NOT WIN32)  # matedit not yet supported on Windows
-        add_subdirectory(${TOOLS}/matedit)
-    endif()
    add_subdirectory(${TOOLS}/mipgen)
    add_subdirectory(${TOOLS}/normal-blending)
    add_subdirectory(${TOOLS}/resgen)
@@ -31,7 +31,7 @@ repositories {
 }

 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.52.1'
+    implementation 'com.google.android.filament:filament-android:1.50.2'
 }
 ```

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

 ### Snapshots
@@ -7,68 +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.52.1
-
- Add instructions for using Mesa for software rasterization
-
-## v1.51.9
-
-
-## v1.51.8
-
- filagui: Fix regression which broke WebGL
- Add a new Engine::Config setting to control preferred shader language
- Add `getEyeIndex` vertex API
- ios: Remove bitcode from iOS builds
-
-## v1.51.7
-
- Add new matedit tool
- filagui: Support rendering `GL_TEXTURE_EXTERNAL_OES` textures.
- `setFrameScheduledCallback` now takes a `utils::Invocable`.
- engine: Add `isPaused()`
-
-## v1.51.6
-
- Add new matedit tool
- filagui: Support rendering `GL_TEXTURE_EXTERNAL_OES` textures.
-
-## v1.51.5
-
-
-## v1.51.4
-
-
-## v1.51.3
-
-
-## v1.51.2
-
- engine: Add experimental APIs `Engine::builder::paused()` and `Engine::setPaused()`
-
-## v1.51.1
-
-
-## v1.51.0
-
- materials: add support for post-lighting mix factor (b/328498606) [⚠️ **New Material Version**]
-
-## v1.50.6
-
- Add new API `SwapChain::getFrameScheduledCallback`
- vulkan: fixed validation error VUID-vkAcquireNextImageKHR-semaphore-01779
- opengl: Add support for protected content swapchains and contexts
-
-## v1.50.5
-
- android: NDK 26.1.10909125 is used by default
- android: Minimum API level on Android is now API 21 instead of API 19. This allows the use of OpenGL ES 3.1
- rendering: New PBR Neutral tone mapper, designed to preserve materials color appearance
- android: Change default frameRateOptions.interval to 1.0
-
-## v1.50.4
-
-
 ## v1.50.3


@@ -80,7 +80,7 @@ buildscript {

    ext.versions = [
        'jdk': 17,
-        'minSdk': 21,
+        'minSdk': 19,
        'targetSdk': 34,
        'compileSdk': 34,
        'kotlin': '1.9.21',
@@ -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
@@ -342,21 +342,6 @@ Java_com_google_android_filament_Engine_nIsValidMaterial(JNIEnv*, jclass,
    return (jboolean)engine->isValid((Material*)nativeMaterial);
 }

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

-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsPaused(JNIEnv*, jclass,
-        jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jboolean)engine->isPaused();
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Engine_nSetPaused(JNIEnv*, jclass,
-        jlong nativeEngine, jboolean paused) {
-    Engine* engine = (Engine*) nativeEngine;
-    engine->setPaused(paused);
-}
-
 // Managers...

 extern "C" JNIEXPORT jlong JNICALL
@@ -513,13 +484,8 @@ extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBu
 extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBuilderConfig(JNIEnv*,
        jclass, jlong nativeBuilder, jlong commandBufferSizeMB, jlong perRenderPassArenaSizeMB,
        jlong driverHandleArenaSizeMB, jlong minCommandBufferSizeMB, jlong perFrameCommandsSizeMB,
-        jlong jobSystemThreadCount,
-        jlong textureUseAfterFreePoolSize, jboolean disableParallelShaderCompile,
-        jint stereoscopicType, jlong stereoscopicEyeCount,
-        jlong resourceAllocatorCacheSizeMB, jlong resourceAllocatorCacheMaxAge,
-        jboolean disableHandleUseAfterFreeCheck,
-        jint preferredShaderLanguage,
-        jboolean forceGLES2Context) {
+        jlong jobSystemThreadCount, jlong stereoscopicEyeCount,
+        jlong resourceAllocatorCacheSizeMB, jlong resourceAllocatorCacheMaxAge) {
    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
    Engine::Config config = {
            .commandBufferSizeMB = (uint32_t) commandBufferSizeMB,
@@ -528,15 +494,9 @@ extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBu
            .minCommandBufferSizeMB = (uint32_t) minCommandBufferSizeMB,
            .perFrameCommandsSizeMB = (uint32_t) perFrameCommandsSizeMB,
            .jobSystemThreadCount = (uint32_t) jobSystemThreadCount,
-            .textureUseAfterFreePoolSize = (uint32_t) textureUseAfterFreePoolSize,
-            .disableParallelShaderCompile = (bool) disableParallelShaderCompile,
-            .stereoscopicType = (Engine::StereoscopicType) stereoscopicType,
            .stereoscopicEyeCount = (uint8_t) stereoscopicEyeCount,
            .resourceAllocatorCacheSizeMB = (uint32_t) resourceAllocatorCacheSizeMB,
            .resourceAllocatorCacheMaxAge = (uint8_t) resourceAllocatorCacheMaxAge,
-            .disableHandleUseAfterFreeCheck = (bool) disableHandleUseAfterFreeCheck,
-            .preferredShaderLanguage = (Engine::Config::ShaderLanguage) preferredShaderLanguage,
-            .forceGLES2Context = (bool) forceGLES2Context,
    };
    builder->config(&config);
 }
@@ -553,12 +513,6 @@ extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBu
    builder->sharedContext((void*) sharedContext);
 }

-extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBuilderPaused(
-        JNIEnv*, jclass, jlong nativeBuilder, jboolean paused) {
-    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
-    builder->paused((bool) paused);
-}
-
 extern "C" JNIEXPORT jlong JNICALL
 Java_com_google_android_filament_Engine_nBuilderBuild(JNIEnv*, jclass, jlong nativeBuilder) {
    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
@@ -104,14 +104,6 @@ Java_com_google_android_filament_RenderableManager_nBuilderGeometry__JIIJJIIII(J
            (size_t) count);
 }

-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nBuilderGeometryType(JNIEnv*, jclass,
-        jlong nativeBuilder, int type) {
-    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    builder->geometryType((RenderableManager::Builder::GeometryType)type);
-}
-
 extern "C"
 JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nBuilderMaterial(JNIEnv*, jclass,
@@ -244,25 +236,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 +318,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
@@ -34,15 +34,7 @@ Java_com_google_android_filament_SwapChain_nSetFrameCompletedCallback(JNIEnv* en
 }

 extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_SwapChain_nIsSRGBSwapChainSupported(
-        JNIEnv *, jclass, jlong nativeEngine) {
+Java_com_google_android_filament_SwapChain_nIsSRGBSwapChainSupported(JNIEnv *, jclass, jlong nativeEngine) {
    Engine* engine = (Engine*) nativeEngine;
-    return (jboolean)SwapChain::isSRGBSwapChainSupported(*engine);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_SwapChain_nIsProtectedContentSupported(
-        JNIEnv *, jclass, jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jboolean)SwapChain::isProtectedContentSupported(*engine);
+    return (bool)SwapChain::isSRGBSwapChainSupported(*engine);
 }
@@ -47,11 +47,6 @@ Java_com_google_android_filament_ToneMapper_nCreateFilmicToneMapper(JNIEnv*, jcl
    return (jlong) new FilmicToneMapper();
 }

-extern "C" JNIEXPORT jlong JNICALL
-Java_com_google_android_filament_ToneMapper_nCreatePBRNeutralToneMapper(JNIEnv*, jclass) {
-    return (jlong) new PBRNeutralToneMapper();
-}
-
 extern "C" JNIEXPORT jlong JNICALL
 Java_com_google_android_filament_ToneMapper_nCreateAgxToneMapper(JNIEnv*, jclass, jint look) {
    return (jlong) new AgxToneMapper(AgxToneMapper::AgxLook(look));
@@ -49,12 +49,6 @@ Java_com_google_android_filament_View_nSetCamera(JNIEnv*, jclass,
    view->setCamera(camera);
 }

-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_View_nHasCamera(JNIEnv*, jclass, jlong nativeView) {
-    View* view = (View*) nativeView;
-    return (jboolean)view->hasCamera();
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetColorGrading(JNIEnv*, jclass,
        jlong nativeView, jlong nativeColorGrading) {
@@ -158,19 +158,6 @@ public class Engine {
        FEATURE_LEVEL_3,
    };

-    /**
-     * The type of technique for stereoscopic rendering. (Note that the materials used will need to be
-     * compatible with the chosen technique.)
-     */
-    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. */
-        MULTIVIEW,
-    };
-
    /**
     * Constructs <code>Engine</code> objects using a builder pattern.
     */
@@ -224,13 +211,8 @@ public class Engine {
            nSetBuilderConfig(mNativeBuilder, config.commandBufferSizeMB,
                    config.perRenderPassArenaSizeMB, config.driverHandleArenaSizeMB,
                    config.minCommandBufferSizeMB, config.perFrameCommandsSizeMB,
-                    config.jobSystemThreadCount,
-                    config.textureUseAfterFreePoolSize, config.disableParallelShaderCompile,
-                    config.stereoscopicType.ordinal(), config.stereoscopicEyeCount,
-                    config.resourceAllocatorCacheSizeMB, config.resourceAllocatorCacheMaxAge,
-                    config.disableHandleUseAfterFreeCheck,
-                    config.preferredShaderLanguage.ordinal(),
-                    config.forceGLES2Context);
+                    config.jobSystemThreadCount, config.stereoscopicEyeCount,
+                    config.resourceAllocatorCacheSizeMB, config.resourceAllocatorCacheMaxAge);
            return this;
        }

@@ -245,20 +227,6 @@ public class Engine {
            return this;
        }

-        /**
-         * Sets the initial paused state of the rendering thread.
-         *
-         * <p>Warning: This is an experimental API. See {@link Engine#setPaused(boolean)} for
-         * caveats.
-         *
-         * @param paused Whether to start the rendering thread paused.
-         * @return A reference to this Builder for chaining calls.
-         */
-        public Builder paused(boolean paused) {
-            nSetBuilderPaused(mNativeBuilder, paused);
-            return this;
-        }
-
        /**
         * Creates an instance of Engine
         *
@@ -381,35 +349,6 @@ public class Engine {
         */
        public long jobSystemThreadCount = 0;

-        /**
-         * Number of most-recently destroyed textures to track for use-after-free.
-         *
-         * This will cause the backend to throw an exception when a texture is freed but still bound
-         * to a SamplerGroup and used in a draw call. 0 disables completely.
-         *
-         * Currently only respected by the Metal backend.
-         */
-        public long textureUseAfterFreePoolSize = 0;
-
-        /**
-         * Set to `true` to forcibly disable parallel shader compilation in the backend.
-         * Currently only honored by the GL backend.
-         */
-        public boolean disableParallelShaderCompile = false;
-
-        /**
-         * The type of technique for stereoscopic rendering.
-         *
-         * This setting determines the algorithm used when stereoscopic rendering is enabled. This
-         * decision applies to the entire Engine for the lifetime of the Engine. E.g., multiple
-         * Views created from the Engine must use the same stereoscopic type.
-         *
-         * Each view can enable stereoscopic rendering via the StereoscopicOptions::enable flag.
-         *
-         * @see View#setStereoscopicOptions
-         */
-        public StereoscopicType stereoscopicType = StereoscopicType.NONE;
-
        /**
         * The number of eyes to render when stereoscopic rendering is enabled. Supported values are
         * between 1 and Engine#getMaxStereoscopicEyes() (inclusive).
@@ -420,48 +359,16 @@ public class Engine {
        public long stereoscopicEyeCount = 2;

        /*
-         * @Deprecated This value is no longer used.
+         * Size in MiB of the frame graph texture cache. This should be adjusted based on the
+         * size of used render targets (typically the screen).
         */
        public long resourceAllocatorCacheSizeMB = 64;

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

    private Engine(long nativeEngine, Config config) {
@@ -708,7 +615,7 @@ public class Engine {
     */
    @NonNull
    public SwapChain createSwapChain(@NonNull Object surface) {
-        return createSwapChain(surface, SwapChainFlags.CONFIG_DEFAULT);
+        return createSwapChain(surface, SwapChain.CONFIG_DEFAULT);
    }

    /**
@@ -716,15 +623,15 @@ public class Engine {
     *
     * @param surface on Android, <b>must be</b> an instance of {@link android.view.Surface}
     *
-     * @param flags configuration flags, see {@link SwapChainFlags}
+     * @param flags configuration flags, see {@link SwapChain}
     *
     * @return a newly created {@link SwapChain} object
     *
     * @exception IllegalStateException can be thrown if the SwapChain couldn't be created
     *
-     * @see SwapChainFlags#CONFIG_DEFAULT
-     * @see SwapChainFlags#CONFIG_TRANSPARENT
-     * @see SwapChainFlags#CONFIG_READABLE
+     * @see SwapChain#CONFIG_DEFAULT
+     * @see SwapChain#CONFIG_TRANSPARENT
+     * @see SwapChain#CONFIG_READABLE
     *
     */
    @NonNull
@@ -742,22 +649,21 @@ public class Engine {
     *
     * @param width  width of the rendering buffer
     * @param height height of the rendering buffer
-     * @param flags  configuration flags, see {@link SwapChainFlags}
+     * @param flags  configuration flags, see {@link SwapChain}
     *
     * @return a newly created {@link SwapChain} object
     *
     * @exception IllegalStateException can be thrown if the SwapChain couldn't be created
     *
-     * @see SwapChainFlags#CONFIG_DEFAULT
-     * @see SwapChainFlags#CONFIG_TRANSPARENT
-     * @see SwapChainFlags#CONFIG_READABLE
+     * @see SwapChain#CONFIG_DEFAULT
+     * @see SwapChain#CONFIG_TRANSPARENT
+     * @see SwapChain#CONFIG_READABLE
     *
     */
    @NonNull
    public SwapChain createSwapChain(int width, int height, long flags) {
        if (width >= 0 && height >= 0) {
-            long nativeSwapChain =
-                nCreateSwapChainHeadless(getNativeObject(), width, height, flags);
+            long nativeSwapChain = nCreateSwapChainHeadless(getNativeObject(), width, height, flags);
            if (nativeSwapChain == 0) throw new IllegalStateException("Couldn't create SwapChain");
            return new SwapChain(nativeSwapChain, null);
        }
@@ -769,12 +675,11 @@ public class Engine {
     *
     * @param surface a properly initialized {@link NativeSurface}
     *
-     * @param flags configuration flags, see {@link SwapChainFlags}
+     * @param flags configuration flags, see {@link SwapChain}
     *
     * @return a newly created {@link SwapChain} object
     *
-     * @exception IllegalStateException can be thrown if the {@link SwapChainFlags} couldn't be
-     *            created
+     * @exception IllegalStateException can be thrown if the {@link SwapChain} couldn't be created
     */
    @NonNull
    public SwapChain createSwapChainFromNativeSurface(@NonNull NativeSurface surface, long flags) {
@@ -883,24 +788,6 @@ public class Engine {
        return nIsValidMaterial(getNativeObject(), object.getNativeObject());
    }

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

-    /**
-     * Get paused state of rendering thread.
-     *
-     * <p>Warning: This is an experimental API.
-     *
-     * @see #setPaused
-     */
-    public boolean isPaused() {
-        return nIsPaused(getNativeObject());
-    }
-
-    /**
-     * Pause or resume the rendering thread.
-     *
-     * <p>Warning: This is an experimental API. In particular, note the following caveats.
-     *
-     * <ul><li>
-     * Buffer callbacks will never be called as long as the rendering thread is paused.
-     * Do not rely on a buffer callback to unpause the thread.
-     * </li><li>
-     * While the rendering thread is paused, rendering commands will continue to be queued until the
-     * buffer limit is reached. When the limit is reached, the program will abort.
-     * </li></ul>
-     */
-    public void setPaused(boolean paused) {
-        nSetPaused(getNativeObject(), paused);
-    }

    @UsedByReflection("TextureHelper.java")
    public long getNativeObject() {
@@ -1354,8 +1214,6 @@ public class Engine {
    private static native boolean nIsValidSkinningBuffer(long nativeEngine, long nativeSkinningBuffer);
    private static native boolean nIsValidIndirectLight(long nativeEngine, long nativeIndirectLight);
    private static native boolean nIsValidMaterial(long nativeEngine, long nativeMaterial);
-    private static native boolean nIsValidMaterialInstance(long nativeEngine, long nativeMaterial, long nativeMaterialInstance);
-    private static native boolean nIsValidExpensiveMaterialInstance(long nativeEngine, long nativeMaterialInstance);
    private static native boolean nIsValidSkybox(long nativeEngine, long nativeSkybox);
    private static native boolean nIsValidColorGrading(long nativeEngine, long nativeColorGrading);
    private static native boolean nIsValidTexture(long nativeEngine, long nativeTexture);
@@ -1364,8 +1222,6 @@ public class Engine {
    private static native void nDestroyEntity(long nativeEngine, int entity);
    private static native void nFlushAndWait(long nativeEngine);
    private static native void nFlush(long nativeEngine);
-    private static native boolean nIsPaused(long nativeEngine);
-    private static native void nSetPaused(long nativeEngine, boolean paused);
    private static native long nGetTransformManager(long nativeEngine);
    private static native long nGetLightManager(long nativeEngine);
    private static native long nGetRenderableManager(long nativeEngine);
@@ -1384,14 +1240,9 @@ public class Engine {
    private static native void nSetBuilderConfig(long nativeBuilder, long commandBufferSizeMB,
            long perRenderPassArenaSizeMB, long driverHandleArenaSizeMB,
            long minCommandBufferSizeMB, long perFrameCommandsSizeMB, long jobSystemThreadCount,
-            long textureUseAfterFreePoolSize, boolean disableParallelShaderCompile,
-            int stereoscopicType, long stereoscopicEyeCount,
-            long resourceAllocatorCacheSizeMB, long resourceAllocatorCacheMaxAge,
-            boolean disableHandleUseAfterFreeCheck,
-            int preferredShaderLanguage,
-            boolean forceGLES2Context);
+            long stereoscopicEyeCount,
+            long resourceAllocatorCacheSizeMB, long resourceAllocatorCacheMaxAge);
    private static native void nSetBuilderFeatureLevel(long nativeBuilder, int ordinal);
    private static native void nSetBuilderSharedContext(long nativeBuilder, long sharedContext);
-    private static native void nSetBuilderPaused(long nativeBuilder, boolean paused);
    private static native long nBuilderBuild(long nativeBuilder);
 }
@@ -175,32 +175,6 @@ public class RenderableManager {
            return this;
        }

-        /**
-         * Type of geometry for a Renderable
-         */
-        public enum GeometryType {
-            /** dynamic gemoetry has no restriction */
-            DYNAMIC,
-            /** bounds and world space transform are immutable */
-            STATIC_BOUNDS,
-            /** skinning/morphing not allowed and Vertex/IndexBuffer immutables */
-            STATIC
-        }
-
-        /**
-         * Specify whether this renderable has static bounds. In this context his means that
-         * the renderable's bounding box cannot change and that the renderable's transform is
-         * assumed immutable. Changing the renderable's transform via the TransformManager
-         * can lead to corrupted graphics. Note that skinning and morphing are not forbidden.
-         * Disabled by default.
-         * @param enable whether this renderable has static bounds. false by default.
-         */
-        @NonNull
-        public Builder geometryType(GeometryType type) {
-            nBuilderGeometryType(mNativeBuilder, type.ordinal());
-            return this;
-        }
-
        /**
         * Binds a material instance to the specified primitive.
         *
@@ -524,7 +498,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 +523,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 +539,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 +549,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 +661,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 +671,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,
@@ -1016,7 +964,6 @@ public class RenderableManager {
    private static native void nBuilderGeometry(long nativeBuilder, int index, int value, long nativeVertexBuffer, long nativeIndexBuffer);
    private static native void nBuilderGeometry(long nativeBuilder, int index, int value, long nativeVertexBuffer, long nativeIndexBuffer, int offset, int count);
    private static native void nBuilderGeometry(long nativeBuilder, int index, int value, long nativeVertexBuffer, long nativeIndexBuffer, int offset, int minIndex, int maxIndex, int count);
-    private static native void nBuilderGeometryType(long nativeBuilder, int type);
    private static native void nBuilderMaterial(long nativeBuilder, int index, long nativeMaterialInstance);
    private static native void nBuilderBlendOrder(long nativeBuilder, int index, int blendOrder);
    private static native void nBuilderGlobalBlendOrderEnabled(long nativeBuilder, int index, boolean enabled);
@@ -1032,7 +979,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);
@@ -101,7 +101,7 @@ public class Renderer {
        /**
         * Desired frame interval in unit of 1 / DisplayInfo.refreshRate.
         */
-        public float interval = 1.0f;
+        public float interval = 1.0f / 60.0f;

        /**
         * Additional headroom for the GPU as a ratio of the targetFrameTime.
@@ -68,30 +68,77 @@ public class SwapChain {
    private final Object mSurface;
    private long mNativeObject;

+    public static final long CONFIG_DEFAULT = 0x0;
+
+    /**
+     * This flag indicates that the <code>SwapChain</code> must be allocated with an
+     * alpha-channel.
+     */
+    public static final long CONFIG_TRANSPARENT = 0x1;
+
+    /**
+     * This flag indicates that the <code>SwapChain</code> may be used as a source surface
+     * for reading back render results.  This config must be set when creating
+     * any <code>SwapChain</code>  that will be used as the source for a blit operation.
+     *
+     * @see Renderer#copyFrame
+     */
+    public static final long CONFIG_READABLE = 0x2;
+
+    /**
+     * Indicates that the native X11 window is an XCB window rather than an XLIB window.
+     * This is ignored on non-Linux platforms and in builds that support only one X11 API.
+     */
+    public static final long CONFIG_ENABLE_XCB = 0x4;
+
+    /**
+     * Indicates that the SwapChain must automatically perform linear to sRGB encoding.
+     *
+     * This flag is ignored if isSRGBSwapChainSupported() is false.
+     *
+     * When using this flag, post-processing should be disabled.
+     *
+     * @see SwapChain#isSRGBSwapChainSupported
+     * @see View#setPostProcessingEnabled
+     */
+    public static final long CONFIG_SRGB_COLORSPACE = 0x10;
+
+    /**
+     * Indicates that this SwapChain should allocate a stencil buffer in addition to a depth buffer.
+     *
+     * This flag is necessary when using View::setStencilBufferEnabled and rendering directly into
+     * the SwapChain (when post-processing is disabled).
+     *
+     * The specific format of the stencil buffer depends on platform support. The following pixel
+     * formats are tried, in order of preference:
+     *
+     * Depth only (without CONFIG_HAS_STENCIL_BUFFER):
+     * - DEPTH32F
+     * - DEPTH24
+     *
+     * Depth + stencil (with CONFIG_HAS_STENCIL_BUFFER):
+     * - DEPTH32F_STENCIL8
+     * - DEPTH24F_STENCIL8
+     *
+     * Note that enabling the stencil buffer may hinder depth precision and should only be used if
+     * necessary.
+     *
+     * @see View#setStencilBufferEnabled
+     * @see View#setPostProcessingEnabled
+     */
+    public static final long CONFIG_HAS_STENCIL_BUFFER = 0x20;
+
    SwapChain(long nativeSwapChain, Object surface) {
        mNativeObject = nativeSwapChain;
        mSurface = surface;
    }

    /**
-     * Return whether createSwapChain supports the CONFIG_PROTECTED_CONTENT flag.
+     * Return whether createSwapChain supports the SWAP_CHAIN_CONFIG_SRGB_COLORSPACE flag.
     * The default implementation returns false.
     *
     * @param engine A reference to the filament Engine
-     * @return true if CONFIG_PROTECTED_CONTENT is supported, false otherwise.
-     * @see SwapChainFlags#CONFIG_PROTECTED_CONTENT
-     */
-    public static boolean isProtectedContentSupported(@NonNull Engine engine) {
-        return nIsProtectedContentSupported(engine.getNativeObject());
-    }
-
-    /**
-     * Return whether createSwapChain supports the CONFIG_SRGB_COLORSPACE flag.
-     * The default implementation returns false.
-     *
-     * @param engine A reference to the filament Engine
-     * @return true if CONFIG_SRGB_COLORSPACE is supported, false otherwise.
-     * @see SwapChainFlags#CONFIG_SRGB_COLORSPACE
+     * @return true if SWAP_CHAIN_CONFIG_SRGB_COLORSPACE is supported, false otherwise.
     */
    public static boolean isSRGBSwapChainSupported(@NonNull Engine engine) {
        return nIsSRGBSwapChainSupported(engine.getNativeObject());
@@ -139,5 +186,4 @@ public class SwapChain {

    private static native void nSetFrameCompletedCallback(long nativeSwapChain, Object handler, Runnable callback);
    private static native boolean nIsSRGBSwapChainSupported(long nativeEngine);
-    private static native boolean nIsProtectedContentSupported(long nativeEngine);
 }
@@ -1,97 +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.
- */
-
-package com.google.android.filament;
-
-// Note: SwapChainFlags is kept separate from SwapChain so that UiHelper does not need to depend
-// on SwapChain. This allows clients to use UiHelper without requiring all of Filament's Java
-// classes.
-
-/**
- * Flags that a <code>SwapChain</code> can be created with to control behavior.
- *
- * @see Engine#createSwapChain
- * @see Engine#createSwapChainFromNativeSurface
- */
-public final class SwapChainFlags {
-
-    public static final long CONFIG_DEFAULT = 0x0;
-
-    /**
-     * This flag indicates that the <code>SwapChain</code> must be allocated with an
-     * alpha-channel.
-     */
-    public static final long CONFIG_TRANSPARENT = 0x1;
-
-    /**
-     * This flag indicates that the <code>SwapChain</code> may be used as a source surface
-     * for reading back render results.  This config must be set when creating
-     * any <code>SwapChain</code>  that will be used as the source for a blit operation.
-     *
-     * @see Renderer#copyFrame
-     */
-    public static final long CONFIG_READABLE = 0x2;
-
-    /**
-     * Indicates that the native X11 window is an XCB window rather than an XLIB window.
-     * This is ignored on non-Linux platforms and in builds that support only one X11 API.
-     */
-    public static final long CONFIG_ENABLE_XCB = 0x4;
-
-    /**
-     * Indicates that the SwapChain must automatically perform linear to sRGB encoding.
-     *
-     * This flag is ignored if isSRGBSwapChainSupported() is false.
-     *
-     * When using this flag, post-processing should be disabled.
-     *
-     * @see SwapChain#isSRGBSwapChainSupported
-     * @see View#setPostProcessingEnabled
-     */
-    public static final long CONFIG_SRGB_COLORSPACE = 0x10;
-
-    /**
-     * Indicates that this SwapChain should allocate a stencil buffer in addition to a depth buffer.
-     *
-     * This flag is necessary when using View::setStencilBufferEnabled and rendering directly into
-     * the SwapChain (when post-processing is disabled).
-     *
-     * The specific format of the stencil buffer depends on platform support. The following pixel
-     * formats are tried, in order of preference:
-     *
-     * Depth only (without CONFIG_HAS_STENCIL_BUFFER):
-     * - DEPTH32F
-     * - DEPTH24
-     *
-     * Depth + stencil (with CONFIG_HAS_STENCIL_BUFFER):
-     * - DEPTH32F_STENCIL8
-     * - DEPTH24F_STENCIL8
-     *
-     * Note that enabling the stencil buffer may hinder depth precision and should only be used if
-     * necessary.
-     *
-     * @see View#setStencilBufferEnabled
-     * @see View#setPostProcessingEnabled
-     */
-    public static final long CONFIG_HAS_STENCIL_BUFFER = 0x20;
-
-    /**
-     * The SwapChain contains protected content. Only supported when isProtectedContentSupported()
-     * is true.
-     */
-    public static final long CONFIG_PROTECTED_CONTENT   = 0x40;
-}
-
@@ -16,14 +16,12 @@ package com.google.android.filament;
 * <li>Configurable tone mapping operators</li>
 * <ul>
 *   <li>GenericToneMapper</li>
- *   <li>AgXToneMapper</li>
 * </ul>
 * <li>Fixed-aesthetic tone mapping operators</li>
 * <ul>
 *   <li>ACESToneMapper</li>
 *   <li>ACESLegacyToneMapper</li>
 *   <li>FilmicToneMapper</li>
- *   <li>PBRNeutralToneMapper</li>
 * </ul>
 * <li>Debug/validation tone mapping operators</li>
 * <ul>
@@ -102,21 +100,11 @@ public class ToneMapper {
        }
    }

-    /**
-     * Khronos PBR Neutral tone mapping operator. This tone mapper was designed
-     * to preserve the appearance of materials across lighting conditions while
-     * avoiding artifacts in the highlights in high dynamic range conditions.
-     */
-    public static class PBRNeutralToneMapper extends ToneMapper {
-        public PBRNeutralToneMapper() {
-            super(nCreatePBRNeutralToneMapper());
-        }
-    }
-
    /**
     * AgX tone mapping operator.
     */
    public static class Agx extends ToneMapper {
+
        public enum AgxLook {
            /**
             * Base contrast with no look applied
@@ -245,7 +233,6 @@ public class ToneMapper {
    private static native long nCreateACESToneMapper();
    private static native long nCreateACESLegacyToneMapper();
    private static native long nCreateFilmicToneMapper();
-    private static native long nCreatePBRNeutralToneMapper();
    private static native long nCreateAgxToneMapper(int look);
    private static native long nCreateGenericToneMapper(
            float contrast, float midGrayIn, float midGrayOut, float hdrMax);
@@ -241,15 +241,6 @@ public class View {
        nSetCamera(getNativeObject(), camera == null ? 0 : camera.getNativeObject());
    }

-    /**
-     * Query whether a camera is set.
-     * @return true if a camera is set, false otherwise
-     * @see #setCamera
-     */
-    public boolean hasCamera() {
-        return nHasCamera(getNativeObject());
-    }
-
    /**
     * Gets this View's associated Camera, or null if none has been assigned.
     *
@@ -1247,7 +1238,6 @@ public class View {
    private static native void nSetName(long nativeView, String name);
    private static native void nSetScene(long nativeView, long nativeScene);
    private static native void nSetCamera(long nativeView, long nativeCamera);
-    private static native boolean nHasCamera(long nativeView);
    private static native void nSetViewport(long nativeView, int left, int bottom, int width, int height);
    private static native void nSetVisibleLayers(long nativeView, int select, int value);
    private static native void nSetShadowingEnabled(long nativeView, boolean enabled);
@@ -27,7 +27,7 @@ import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.TextureView;

-import com.google.android.filament.SwapChainFlags;
+import com.google.android.filament.SwapChain;

 /**
 * UiHelper is a simple class that can manage either a SurfaceView, TextureView, or a SurfaceHolder
@@ -538,7 +538,7 @@ public class UiHelper {
     * the options set on this UiHelper.
     */
    public long getSwapChainFlags() {
-        return isOpaque() ? SwapChainFlags.CONFIG_DEFAULT : SwapChainFlags.CONFIG_TRANSPARENT;
+        return isOpaque() ? SwapChain.CONFIG_DEFAULT : SwapChain.CONFIG_TRANSPARENT;
    }

    /**
@@ -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
@@ -82,20 +81,9 @@ set(GLTFIO_SRCS
        ${GLTFIO_DIR}/src/TangentsJob.cpp
        ${GLTFIO_DIR}/src/TangentsJob.h
        ${GLTFIO_DIR}/src/UbershaderProvider.cpp
-        ${GLTFIO_DIR}/src/Utility.cpp
-        ${GLTFIO_DIR}/src/Utility.h
        ${GLTFIO_DIR}/src/Wireframe.cpp
        ${GLTFIO_DIR}/src/Wireframe.h
        ${GLTFIO_DIR}/src/downcast.h
-        ${GLTFIO_DIR}/src/extended/AssetLoaderExtended.cpp
-        ${GLTFIO_DIR}/src/extended/AssetLoaderExtended.h
-        ${GLTFIO_DIR}/src/extended/ResourceLoaderExtended.cpp
-        ${GLTFIO_DIR}/src/extended/ResourceLoaderExtended.h
-        ${GLTFIO_DIR}/src/extended/TangentsJobExtended.cpp
-        ${GLTFIO_DIR}/src/extended/TangentsJobExtended.h
-        ${GLTFIO_DIR}/src/extended/TangentSpaceMeshWrapper.cpp
-        ${GLTFIO_DIR}/src/extended/TangentSpaceMeshWrapper.h
-

        src/main/cpp/Animator.cpp
        src/main/cpp/AssetLoader.cpp
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.52.1
+VERSION_NAME=1.50.2

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

@@ -30,7 +30,7 @@ android {
    compileSdkVersion versions.compileSdk
    defaultConfig {
        applicationId "com.google.android.filament.gltf"
-        minSdkVersion versions.minSdk
+        minSdkVersion 19
        targetSdkVersion versions.targetSdk
    }

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

@@ -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"
@@ -59,14 +61,6 @@ function print_help {
    echo "    -b"
    echo "        Enable Address and Undefined Behavior Sanitizers (asan/ubsan) for debugging."
    echo "        This is only for the desktop build."
-    echo "    -x value"
-    echo "        Define a preprocessor flag FILAMENT_BACKEND_DEBUG_FLAG with [value]. This is useful for"
-    echo "        enabling debug paths in the backend from the build script. For example, make a"
-    echo "        systrace-enabled build without directly changing #defines. Remember to add -f when"
-    echo "        changing this option."
-    echo "    -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 +160,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"
@@ -176,10 +172,6 @@ MATOPT_GRADLE_OPTION=""

 ASAN_UBSAN_OPTION=""

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

@@ -234,12 +226,11 @@ 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" \
@@ -298,7 +289,6 @@ function build_webgl_with_target {
            -DCMAKE_BUILD_TYPE="$1" \
            -DCMAKE_INSTALL_PREFIX="../webgl-${lc_target}/filament" \
            -DWEBGL=1 \
-            ${BACKEND_DEBUG_FLAG_OPTION} \
            ../..
        ln -sf "out/cmake-webgl-${lc_target}/compile_commands.json" \
           ../../compile_commands.json
@@ -373,8 +363,6 @@ function build_android_target {
            ${MATDBG_OPTION} \
            ${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
@@ -528,7 +516,7 @@ function build_android {
            if [[ "${BUILD_ANDROID_SAMPLES}" == "true" ]]; then
                for sample in ${ANDROID_SAMPLES}; do
                    echo "Installing out/${sample}-debug.apk"
-                    cp samples/${sample}/build/outputs/apk/debug/${sample}-debug.apk \
+                    cp samples/${sample}/build/outputs/apk/debug/${sample}-debug-unsigned.apk \
                        ../out/${sample}-debug.apk
                done
            fi
@@ -609,7 +597,6 @@ function build_ios_target {
            -DCMAKE_TOOLCHAIN_FILE=../../third_party/clang/iOS.cmake \
            ${MATDBG_OPTION} \
            ${MATOPT_OPTION} \
-            ${STEREOSCOPIC_OPTION} \
            ../..
        ln -sf "out/cmake-ios-${lc_target}-${arch}/compile_commands.json" \
           ../../compile_commands.json
@@ -743,13 +730,6 @@ function validate_build_command {
            exit 1
        fi
    fi
-
-    # Make sure FILAMENT_BACKEND_DEBUG_FLAG is only meant for debug builds
-    if [[ "${ISSUE_DEBUG_BUILD}" != "true" ]] && [[ ! -z "${BACKEND_DEBUG_FLAG_OPTION}" ]]; then
-        echo "Error: cannot specify FILAMENT_BACKEND_DEBUG_FLAG in non-debug build"
-        exit 1
-    fi
-
    set -e
 }

@@ -796,7 +776,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:b" opt; do
    case ${opt} in
        h)
            print_help
@@ -860,7 +840,7 @@ while getopts ":hacCfgijmp:q:uvslwedk:bx:S:" opt; do
                        echo "Platform must be one of [desktop|android|ios|webgl|all]"
                        echo ""
                        exit 1
-                    ;;
+                    ;;    
                esac
            done
            ;;
@@ -915,6 +895,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."
@@ -934,22 +918,6 @@ while getopts ":hacCfgijmp:q:uvslwedk:bx:S:" opt; do
        b)  ASAN_UBSAN_OPTION="-DFILAMENT_ENABLE_ASAN_UBSAN=ON"
            echo "Enabled ASAN/UBSAN"
            ;;
-        x)  BACKEND_DEBUG_FLAG_OPTION="-DFILAMENT_BACKEND_DEBUG_FLAG=${OPTARG}"
-            ;;
-        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 ""
@@ -1 +1 @@
-26.1.10909125
+25.1.8937393
@@ -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
@@ -21,7 +21,7 @@ set(CMAKE_SYSTEM_NAME Linux)
 set(CMAKE_SYSTEM_VERSION 1)

 # android
-set(API_LEVEL 21)
+set(API_LEVEL 19)

 # architecture
 set(ARCH armv7a-linux-androideabi)
@@ -21,7 +21,7 @@ set(CMAKE_SYSTEM_NAME Linux)
 set(CMAKE_SYSTEM_VERSION 1)

 # android
-set(API_LEVEL 21)
+set(API_LEVEL 19)

 # architecture
 set(ARCH i686-linux-android)
@@ -476,7 +476,7 @@ Energy conservation is one of the key components of a good BRDF for physically b
 <p>


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

 </p><p>

@@ -857,7 +857,7 @@ The full GLSL implementation of the standard model is shown in <a href="#listing
 <span class="line">    <span class="hljs-comment">// perceptually linear roughness to roughness (see parameterization)</span></span>
 <span class="line">    <span class="hljs-type">float</span> roughness = perceptualRoughness * perceptualRoughness;</span>
 <span class="line"></span>
-<span class="line">    <span class="hljs-type">float</span> D = D_GGX(NoH, roughness);</span>
+<span class="line">    <span class="hljs-type">float</span> D = D_GGX(NoH, a);</span>
 <span class="line">    <span class="hljs-type">vec3</span>  F = F_Schlick(LoH, f0);</span>
 <span class="line">    <span class="hljs-type">float</span> V = V_SmithGGXCorrelated(NoV, NoL, roughness);</span>
 <span class="line"></span>
@@ -1397,7 +1397,7 @@ Type
 :    `string`

 Value
-:     Any of `opaque`, `transparent`, `fade`, `add`, `masked`, `multiply`, `screen`, `custom`. Defaults to `opaque`.
+:     Any of `opaque`, `transparent`, `fade`, `add`, `masked`, `multiply`, `screen`. Defaults to `opaque`.

 Description
 :     Defines how/if the rendered object is blended with the content of the render target.
@@ -1420,7 +1420,6 @@ Description
      of the material's output defines whether a fragment is discarded or not. Additionally,
      ALPHA_TO_COVERAGE is enabled for non-translucent views. See the maskThreshold section for more
      information.
-    - **Custom**: blending is enabled. But the blending function is user specified. See `blendFunction`.

 !!! Note
    When `blending` is set to `masked`, alpha to coverage is automatically enabled for the material.
@@ -1433,36 +1432,6 @@ material {
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-### Blending and transparency: blendFunction
-
-Type
-:    `object`
-
-Fields
-:     `srcRGB`, `srcA`, `dstRGB`, `dstA`
-
-Description
-:       - *srcRGB*: source function applied to the RGB channels
-        - *srcA*: source function applied to the alpha channel
-        - *srcRGB*: destination function applied to the RGB channels
-        - *srcRGB*: destination function applied to the alpha channel
-        The values possible for each functions are one of `zero`, `one`, `srcColor`, `oneMinusSrcColor`,
-               `dstColor`, `oneMinusDstColor`, `srcAlpha`, `oneMinusSrcAlpha`, `dstAlpha`,
-               `oneMinusDstAlpha`, `srcAlphaSaturate`
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JSON
-material {
-    blending : custom,
-    blendFunction :
-    {
-        srcRGB: one,
-        srcA: one,
-        dstRGB: oneMinusSrcColor,
-        dstA: oneMinusSrcAlpha
-    }
- }
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 ### Blending and transparency: postLightingBlending

 Type
@@ -2425,7 +2394,6 @@ The following APIs are only available from the vertex block:
 **getWorldFromModelMatrix()**        | float4x4 |  Matrix that converts from model (object) space to world space
 **getWorldFromModelNormalMatrix()**  | float3x3 |  Matrix that converts normals from model (object) space to world space
 **getVertexIndex()**                 | int      |  Index of the current vertex
-**getEyeIndex()**                    | int      |  Index of the eye being rendered, starting at 0

 ### Fragment only

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

 </main>
-<script src="https://unpkg.com/filament@1.51.6/filament.js"></script>
+<script src="https://unpkg.com/filament@1.44.0/filament.js"></script>
 <script src="https://unpkg.com/gltumble"></script>
 <script src="filament-viewer.js" type="module"></script>
 </body>
@@ -66,7 +66,6 @@ set(SRCS
        src/Froxelizer.cpp
        src/Frustum.cpp
        src/HwRenderPrimitiveFactory.cpp
-        src/HwVertexBufferInfoFactory.cpp
        src/IndexBuffer.cpp
        src/IndirectLight.cpp
        src/InstanceBuffer.cpp
@@ -138,7 +137,6 @@ set(SRCS

 set(PRIVATE_HDRS
        src/Allocators.h
-        src/Bimap.h
        src/BufferPoolAllocator.h
        src/ColorSpaceUtils.h
        src/Culler.h
@@ -149,7 +147,6 @@ set(PRIVATE_HDRS
        src/FrameSkipper.h
        src/Froxelizer.h
        src/HwRenderPrimitiveFactory.h
-        src/HwVertexBufferInfoFactory.h
        src/Intersections.h
        src/MaterialParser.h
        src/PerViewUniforms.h
@@ -163,7 +160,6 @@ set(PRIVATE_HDRS
        src/ResourceList.h
        src/ShadowMap.h
        src/ShadowMapManager.h
-        src/SharedHandle.h
        src/TypedUniformBuffer.h
        src/UniformBuffer.h
        src/components/CameraManager.h
@@ -215,9 +211,7 @@ set(PRIVATE_HDRS
 set(MATERIAL_SRCS
        src/materials/antiAliasing/fxaa.mat
        src/materials/antiAliasing/taa.mat
-        src/materials/blitDepth.mat
        src/materials/blitLow.mat
-        src/materials/blitArray.mat
        src/materials/bloom/bloomDownsample.mat
        src/materials/bloom/bloomDownsample2x.mat
        src/materials/bloom/bloomDownsample9.mat
@@ -254,13 +248,8 @@ set(MATERIAL_SRCS
 )

 set(MATERIAL_FL0_SRCS
-        src/materials/defaultMaterial.mat
-        src/materials/skybox.mat
-)
-
-set(MATERIAL_MULTIVIEW_SRCS
-        src/materials/defaultMaterial.mat
-        src/materials/skybox.mat
+        src/materials/defaultMaterial0.mat
+        src/materials/skybox0.mat
 )

 # Embed the binary resource blob for materials.
@@ -292,11 +281,6 @@ if (FILAMENT_ENABLE_FEATURE_LEVEL_0)
    add_definitions(-DFILAMENT_ENABLE_FEATURE_LEVEL_0)
 endif()

-# Whether to include MULTIVIEW materials.
-if (FILAMENT_ENABLE_MULTIVIEW)
-    add_definitions(-DFILAMENT_ENABLE_MULTIVIEW)
-endif()
-
 # ==================================================================================================
 # Definitions
 # ==================================================================================================
@@ -327,43 +311,34 @@ foreach (mat_src ${MATERIAL_SRCS})
    get_filename_component(localname "${mat_src}" NAME_WE)
    get_filename_component(fullname "${mat_src}" ABSOLUTE)
    set(output_path "${MATERIAL_DIR}/${localname}.filamat")
+
    add_custom_command(
            OUTPUT ${output_path}
            COMMAND matc ${MATC_BASE_FLAGS} -o ${output_path} ${fullname}
            MAIN_DEPENDENCY ${fullname}
            DEPENDS matc
-            COMMENT "Compiling material ${fullname} to ${output_path}"
+            COMMENT "Compiling material ${mat_src} to ${output_path}"
    )
    list(APPEND MATERIAL_BINS ${output_path})
-
-    list(FIND MATERIAL_FL0_SRCS ${mat_src} index)
-    if (${index} GREATER -1 AND FILAMENT_ENABLE_FEATURE_LEVEL_0)
-        string(REGEX REPLACE "[.]filamat$" "_fl0.filamat" output_path_fl0 ${output_path})
-        add_custom_command(
-                OUTPUT ${output_path_fl0}
-                COMMAND matc ${MATC_BASE_FLAGS} -PfeatureLevel=0 -o ${output_path_fl0} ${fullname}
-                MAIN_DEPENDENCY ${fullname}
-                DEPENDS matc
-                COMMENT "Compiling material ${fullname} to ${output_path_fl0}"
-        )
-        list(APPEND MATERIAL_BINS ${output_path_fl0})
-    endif ()
-
-    list(FIND MATERIAL_MULTIVIEW_SRCS ${mat_src} index)
-    if (${index} GREATER -1 AND FILAMENT_ENABLE_MULTIVIEW)
-        string(REGEX REPLACE "[.]filamat$" "_multiview.filamat" output_path_multiview ${output_path})
-        add_custom_command(
-                OUTPUT ${output_path_multiview}
-                COMMAND matc ${MATC_BASE_FLAGS} -PstereoscopicType=multiview -o ${output_path_multiview} ${fullname}
-                MAIN_DEPENDENCY ${fullname}
-                DEPENDS matc
-                COMMENT "Compiling material ${fullname} to ${output_path_multiview}"
-        )
-        list(APPEND MATERIAL_BINS ${output_path_multiview})
-    endif ()
-
 endforeach()

+if (FILAMENT_ENABLE_FEATURE_LEVEL_0)
+    foreach (mat_src ${MATERIAL_FL0_SRCS})
+        get_filename_component(localname "${mat_src}" NAME_WE)
+        get_filename_component(fullname "${mat_src}" ABSOLUTE)
+        set(output_path "${MATERIAL_DIR}/${localname}.filamat")
+
+        add_custom_command(
+                OUTPUT ${output_path}
+                COMMAND matc ${MATC_BASE_FLAGS} -o ${output_path} ${fullname}
+                MAIN_DEPENDENCY ${fullname}
+                DEPENDS matc
+                COMMENT "Compiling material ${mat_src} to ${output_path}"
+        )
+        list(APPEND MATERIAL_BINS ${output_path})
+    endforeach ()
+endif ()
+
 # Additional dependencies on included files for materials

 add_custom_command(
@@ -66,13 +66,11 @@ 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
            src/opengl/gl_headers.h
-            src/opengl/GLBufferObject.h
-            src/opengl/GLTexture.h
            src/opengl/GLUtils.cpp
            src/opengl/GLUtils.h
            src/opengl/OpenGLBlobCache.cpp
@@ -168,10 +166,6 @@ endif()
 if (FILAMENT_SUPPORTS_VULKAN)
    list(APPEND SRCS
            include/backend/platforms/VulkanPlatform.h
-            src/vulkan/caching/VulkanDescriptorSetManager.cpp
-            src/vulkan/caching/VulkanDescriptorSetManager.h
-            src/vulkan/caching/VulkanPipelineLayoutCache.cpp
-            src/vulkan/caching/VulkanPipelineLayoutCache.h
            src/vulkan/platform/VulkanPlatform.cpp
            src/vulkan/platform/VulkanPlatformSwapChainImpl.cpp
            src/vulkan/platform/VulkanPlatformSwapChainImpl.h
@@ -417,9 +411,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
@@ -480,10 +472,6 @@ if (APPLE)
       # linker from removing "unused" symbols.
       target_link_libraries(backend_test_mac PRIVATE -force_load backend_test)
       set_target_properties(backend_test_mac PROPERTIES FOLDER Tests)
-
-       # This is needed after XCode 15.3
-       set_target_properties(backend_test_mac PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
-       set_target_properties(backend_test_mac PROPERTIES INSTALL_RPATH /usr/local/lib)
    endif()
 endif()

@@ -22,17 +22,14 @@
 #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>
 #include <utils/ostream.h>

 #include <math/vec4.h>

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

 #include <stddef.h>
 #include <stdint.h>
@@ -84,24 +81,14 @@ static constexpr uint64_t SWAP_CHAIN_CONFIG_SRGB_COLORSPACE     = 0x10;
 /**
 * Indicates that the SwapChain should also contain a stencil component.
 */
-static constexpr uint64_t SWAP_CHAIN_CONFIG_HAS_STENCIL_BUFFER  = 0x20;
-static constexpr uint64_t SWAP_CHAIN_HAS_STENCIL_BUFFER         = SWAP_CHAIN_CONFIG_HAS_STENCIL_BUFFER;
+static constexpr uint64_t SWAP_CHAIN_HAS_STENCIL_BUFFER         = 0x20;

-/**
- * The SwapChain contains protected content. Currently only supported by OpenGLPlatform and
- * only when OpenGLPlatform::isProtectedContextSupported() is true.
- */
-static constexpr uint64_t SWAP_CHAIN_CONFIG_PROTECTED_CONTENT   = 0x40;

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

-static constexpr size_t MAX_PUSH_CONSTANT_COUNT     = 32;   // Vulkan 1.1 spec allows for 128-byte
-                                                            // of push constant (we assume 4-byte
-                                                            // types).
-
 // Per feature level caps
 // Use (int)FeatureLevel to index this array
 static constexpr struct {
@@ -118,7 +105,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.

 /**
@@ -142,12 +129,6 @@ enum class Backend : uint8_t {
    NOOP = 4,     //!< Selects the no-op driver for testing purposes.
 };

-enum class TimerQueryResult : int8_t {
-    ERROR = -1,     // an error occurred, result won't be available
-    NOT_READY = 0,  // result to ready yet
-    AVAILABLE = 1,  // result is available
-};
-
 static constexpr const char* backendToString(Backend backend) {
    switch (backend) {
        case Backend::NOOP:
@@ -164,16 +145,14 @@ static constexpr const char* backendToString(Backend backend) {
 }

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

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

@@ -337,7 +314,7 @@ enum class UniformType : uint8_t {
 /**
 * Supported constant parameter types
 */
-enum class ConstantType : uint8_t {
+ enum class ConstantType : uint8_t {
  INT,
  FLOAT,
  BOOL
@@ -682,17 +659,16 @@ enum class TextureFormat : uint16_t {
 };

 //! Bitmask describing the intended Texture Usage
-enum class TextureUsage : uint16_t {
-    NONE                = 0x0000,
-    COLOR_ATTACHMENT    = 0x0001,            //!< Texture can be used as a color attachment
-    DEPTH_ATTACHMENT    = 0x0002,            //!< Texture can be used as a depth attachment
-    STENCIL_ATTACHMENT  = 0x0004,            //!< Texture can be used as a stencil attachment
-    UPLOADABLE          = 0x0008,            //!< Data can be uploaded into this texture (default)
-    SAMPLEABLE          = 0x0010,            //!< Texture can be sampled (default)
-    SUBPASS_INPUT       = 0x0020,            //!< Texture can be used as a subpass input
-    BLIT_SRC            = 0x0040,            //!< Texture can be used the source of a blit()
-    BLIT_DST            = 0x0080,            //!< Texture can be used the destination of a blit()
-    PROTECTED           = 0x0100,            //!< Texture can be used for protected content
+enum class TextureUsage : uint8_t {
+    NONE                = 0x00,
+    COLOR_ATTACHMENT    = 0x01,                     //!< Texture can be used as a color attachment
+    DEPTH_ATTACHMENT    = 0x02,                     //!< Texture can be used as a depth attachment
+    STENCIL_ATTACHMENT  = 0x04,                     //!< Texture can be used as a stencil attachment
+    UPLOADABLE          = 0x08,                     //!< Data can be uploaded into this texture (default)
+    SAMPLEABLE          = 0x10,                     //!< Texture can be sampled (default)
+    SUBPASS_INPUT       = 0x20,                     //!< Texture can be used as a subpass input
+    BLIT_SRC            = 0x40,                     //!< Texture can be used the source of a blit()
+    BLIT_DST            = 0x80,                     //!< Texture can be used the destination of a blit()
    DEFAULT             = UPLOADABLE | SAMPLEABLE   //!< Default texture usage
 };

@@ -1196,27 +1172,11 @@ struct StencilState {

    //! Stencil operations for front-facing polygons
    StencilOperations front = {
-            .stencilFunc = StencilFunction::A,
-            .stencilOpStencilFail = StencilOperation::KEEP,
-            .padding0 = 0,
-            .stencilOpDepthFail = StencilOperation::KEEP,
-            .stencilOpDepthStencilPass = StencilOperation::KEEP,
-            .padding1 = 0,
-            .ref = 0,
-            .readMask = 0xff,
-            .writeMask = 0xff };
+            .stencilFunc = StencilFunction::A, .ref = 0, .readMask = 0xff, .writeMask = 0xff };

    //! Stencil operations for back-facing polygons
    StencilOperations back  = {
-            .stencilFunc = StencilFunction::A,
-            .stencilOpStencilFail = StencilOperation::KEEP,
-            .padding0 = 0,
-            .stencilOpDepthFail = StencilOperation::KEEP,
-            .stencilOpDepthStencilPass = StencilOperation::KEEP,
-            .padding1 = 0,
-            .ref = 0,
-            .readMask = 0xff,
-            .writeMask = 0xff };
+            .stencilFunc = StencilFunction::A, .ref = 0, .readMask = 0xff, .writeMask = 0xff };

    //! Whether stencil-buffer writes are enabled
    bool stencilWrite = false;
@@ -1224,15 +1184,13 @@ struct StencilState {
    uint8_t padding = 0;
 };

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

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

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

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

-using StereoscopicType = backend::Platform::StereoscopicType;
-
 } // namespace filament::backend

 template<> struct utils::EnableBitMaskOperators<filament::backend::ShaderStageFlags>
@@ -39,7 +39,6 @@ struct HwStream;
 struct HwSwapChain;
 struct HwTexture;
 struct HwTimerQuery;
-struct HwVertexBufferInfo;
 struct HwVertexBuffer;

 /*
@@ -63,6 +62,14 @@ public:
    // clear the handle, this doesn't free associated resources
    void clear() noexcept { object = nullid; }

+    // compare handles
+    bool operator==(const HandleBase& rhs) const noexcept { return object == rhs.object; }
+    bool operator!=(const HandleBase& rhs) const noexcept { return object != rhs.object; }
+    bool operator<(const HandleBase& rhs) const noexcept { return object < rhs.object; }
+    bool operator<=(const HandleBase& rhs) const noexcept { return object <= rhs.object; }
+    bool operator>(const HandleBase& rhs) const noexcept { return object > rhs.object; }
+    bool operator>=(const HandleBase& rhs) const noexcept { return object >= rhs.object; }
+
    // get this handle's handleId
    HandleId getId() const noexcept { return object; }

@@ -75,19 +82,6 @@ protected:
    HandleBase(HandleBase const& rhs) noexcept = default;
    HandleBase& operator=(HandleBase const& rhs) noexcept = default;

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

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

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

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

-    // compare handles of the same type
-    bool operator==(const Handle& rhs) const noexcept { return getId() == rhs.getId(); }
-    bool operator!=(const Handle& rhs) const noexcept { return getId() != rhs.getId(); }
-    bool operator<(const Handle& rhs) const noexcept { return getId() < rhs.getId(); }
-    bool operator<=(const Handle& rhs) const noexcept { return getId() <= rhs.getId(); }
-    bool operator>(const Handle& rhs) const noexcept { return getId() > rhs.getId(); }
-    bool operator>=(const Handle& rhs) const noexcept { return getId() >= rhs.getId(); }
-
    // type-safe Handle cast
    template<typename B, typename = std::enable_if_t<std::is_base_of<T, B>::value> >
    Handle(Handle<B> const& base) noexcept : HandleBase(base) { } // NOLINT(hicpp-explicit-conversions,google-explicit-constructor)
@@ -130,19 +114,18 @@ private:

 // Types used by the command stream
 // (we use this renaming because the macro-system doesn't deal well with "<" and ">")
-using BufferObjectHandle     = Handle<HwBufferObject>;
-using FenceHandle            = Handle<HwFence>;
-using IndexBufferHandle      = Handle<HwIndexBuffer>;
-using ProgramHandle          = Handle<HwProgram>;
-using RenderPrimitiveHandle  = Handle<HwRenderPrimitive>;
-using RenderTargetHandle     = Handle<HwRenderTarget>;
-using SamplerGroupHandle     = Handle<HwSamplerGroup>;
-using StreamHandle           = Handle<HwStream>;
-using SwapChainHandle        = Handle<HwSwapChain>;
-using TextureHandle          = Handle<HwTexture>;
-using TimerQueryHandle       = Handle<HwTimerQuery>;
-using VertexBufferHandle     = Handle<HwVertexBuffer>;
-using VertexBufferInfoHandle = Handle<HwVertexBufferInfo>;
+using BufferObjectHandle    = Handle<HwBufferObject>;
+using FenceHandle           = Handle<HwFence>;
+using IndexBufferHandle     = Handle<HwIndexBuffer>;
+using ProgramHandle         = Handle<HwProgram>;
+using RenderPrimitiveHandle = Handle<HwRenderPrimitive>;
+using RenderTargetHandle    = Handle<HwRenderTarget>;
+using SamplerGroupHandle    = Handle<HwSamplerGroup>;
+using StreamHandle          = Handle<HwStream>;
+using SwapChainHandle       = Handle<HwSwapChain>;
+using TextureHandle         = Handle<HwTexture>;
+using TimerQueryHandle      = Handle<HwTimerQuery>;
+using VertexBufferHandle    = Handle<HwVertexBuffer>;

 } // namespace filament::backend

@@ -29,13 +29,11 @@ namespace filament::backend {
 //! \privatesection

 struct PipelineState {
-    Handle<HwProgram> program;                                              //  4
-    Handle<HwVertexBufferInfo> vertexBufferInfo;                            //  4
-    RasterState rasterState;                                                //  4
-    StencilState stencilState;                                              // 12
-    PolygonOffset polygonOffset;                                            //  8
-    PrimitiveType primitiveType = PrimitiveType::TRIANGLES;                 //  1
-    uint8_t padding[3] = {};                                                //  3
+    Handle<HwProgram> program;
+    RasterState rasterState;
+    StencilState stencilState;
+    PolygonOffset polygonOffset;
+    Viewport scissor{ 0, 0, (uint32_t)INT32_MAX, (uint32_t)INT32_MAX };
 };

 } // namespace filament::backend
@@ -23,7 +23,6 @@
 #include <utils/Invocable.h>

 #include <stddef.h>
-#include <stdint.h>

 namespace filament::backend {

@@ -41,26 +40,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.
@@ -77,25 +56,9 @@ public:

        /**
         * Set to `true` to forcibly disable parallel shader compilation in the backend.
-         * Currently only honored by the GL and Metal backends.
+         * Currently only honored by the GL backend.
         */
        bool disableParallelShaderCompile = false;
-
-        /**
-         * Disable backend handles use-after-free checks.
-         */
-        bool disableHandleUseAfterFreeCheck = false;
-
-        /**
-         * Force GLES2 context if supported, or pretend the context is ES2. Only meaningful on
-         * GLES 3.x backends.
-         */
-        bool forceGLES2Context = false;
-
-        /**
-         * Sets the technique for stereoscopic rendering.
-         */
-        StereoscopicType stereoscopicType = StereoscopicType::NONE;
    };

    Platform() noexcept;
@@ -225,40 +188,9 @@ public:
    size_t retrieveBlob(const void* UTILS_NONNULL key, size_t keySize,
            void* UTILS_NONNULL value, size_t valueSize);

-    using DebugUpdateStatFunc = utils::Invocable<void(const char* UTILS_NONNULL key, uint64_t value)>;
-
-    /**
-     * Sets the callback function that the backend can use to update backend-specific statistics
-     * to aid with debugging. This callback is guaranteed to be called on the Filament driver
-     * thread.
-     *
-     * @param debugUpdateStat   an Invocable that updates debug statistics
-     */
-    void setDebugUpdateStatFunc(DebugUpdateStatFunc&& debugUpdateStat) noexcept;
-
-    /**
-     * @return true if debugUpdateStat is valid.
-     */
-    bool hasDebugUpdateStatFunc() const noexcept;
-
-    /**
-     * To track backend-specific statistics, the backend implementation can call the
-     * application-provided callback function debugUpdateStatFunc to associate or update a value
-     * with a given key. It is possible for this function to be called multiple times with the
-     * same key, in which case newer values should overwrite older values.
-     *
-     * This function is guaranteed to be called only on a single thread, the Filament driver
-     * thread.
-     *
-     * @param key          a null-terminated C-string with the key of the debug statistic
-     * @param value        the updated value of key
-     */
-    void debugUpdateStat(const char* UTILS_NONNULL key, uint64_t value);
-
 private:
    InsertBlobFunc mInsertBlob;
    RetrieveBlobFunc mRetrieveBlob;
-    DebugUpdateStatFunc mDebugUpdateStat;
 };

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

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

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

-    Program& multiview(bool multiview) noexcept;
-
    ShaderSource const& getShadersSource() const noexcept { return mShadersSource; }
    ShaderSource& getShadersSource() noexcept { return mShadersSource; }

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

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

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

-    bool isMultiview() const noexcept { return mMultiview; }
-
    CompilerPriorityQueue getPriorityQueue() const noexcept { return mPriorityQueue; }

 private:
@@ -177,20 +151,13 @@ private:
    UniformBlockInfo mUniformBlocks = {};
    SamplerGroupInfo mSamplerGroups = {};
    ShaderSource mShadersSource;
-    ShaderLanguage mShaderLanguage = ShaderLanguage::ESSL3;
    utils::CString mName;
    uint64_t mCacheId{};
    utils::Invocable<utils::io::ostream&(utils::io::ostream& out)> mLogger;
    utils::FixedCapacityVector<SpecializationConstant> mSpecializationConstants;
-    std::array<utils::FixedCapacityVector<PushConstant>, SHADER_TYPE_COUNT> mPushConstants;
    utils::FixedCapacityVector<std::pair<utils::CString, uint8_t>> mAttributes;
    std::array<UniformInfo, Program::UNIFORM_BINDING_COUNT> mBindingUniformInfo;
    CompilerPriorityQueue mPriorityQueue = CompilerPriorityQueue::HIGH;
-    // Indicates the current engine was initialized with multiview stereo, and the variant for this
-    // program contains STE flag. This will be referred later for the OpenGL shader compiler to
-    // determine whether shader code replacement for the num_views should be performed.
-    // This variable could be promoted as a more generic variable later if other similar needs occur.
-    bool mMultiview = false;
 };

 } // namespace filament::backend
@@ -29,36 +29,13 @@ namespace filament::backend {
 //! \privatesection

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

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

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

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

    MRT() noexcept = default;

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

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

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

@@ -22,9 +22,7 @@
 #include <backend/Platform.h>

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

-#include <stddef.h>
 #include <stdint.h>

 namespace filament::backend {
@@ -64,22 +62,6 @@ public:
     */
    virtual void terminate() noexcept = 0;

-    /**
-     * Return whether createSwapChain supports the SWAP_CHAIN_CONFIG_SRGB_COLORSPACE flag.
-     * The default implementation returns false.
-     *
-     * @return true if SWAP_CHAIN_CONFIG_SRGB_COLORSPACE is supported, false otherwise.
-     */
-    virtual bool isSRGBSwapChainSupported() const noexcept;
-
-    /**
-     * Return whether protected contexts are supported by this backend.
-     * If protected context are supported, the SWAP_CHAIN_CONFIG_PROTECTED_CONTENT flag can be
-     * used when creating a SwapChain.
-     * The default implementation returns false.
-     */
-    virtual bool isProtectedContextSupported() const noexcept;
-
    /**
     * Called by the driver to create a SwapChain for this driver.
     *
@@ -89,9 +71,17 @@ public:
     * @return              The driver's SwapChain object.
     *
     */
-    virtual SwapChain* UTILS_NULLABLE createSwapChain(
+    virtual SwapChain* UTILS_NONNULL createSwapChain(
            void* UTILS_NULLABLE nativeWindow, uint64_t flags) noexcept = 0;

+    /**
+     * Return whether createSwapChain supports the SWAP_CHAIN_CONFIG_SRGB_COLORSPACE flag.
+     * The default implementation returns false.
+     *
+     * @return true if SWAP_CHAIN_CONFIG_SRGB_COLORSPACE is supported, false otherwise.
+     */
+    virtual bool isSRGBSwapChainSupported() const noexcept;
+
    /**
     * Called by the driver create a headless SwapChain.
     *
@@ -125,94 +115,21 @@ public:
     */
    virtual TargetBufferFlags getPreservedFlags(SwapChain* UTILS_NONNULL swapChain) noexcept;

-    /**
-     * Returns true if the swapchain is protected
-     */
-    virtual bool isSwapChainProtected(Platform::SwapChain* UTILS_NONNULL swapChain) noexcept;
-
    /**
     * Called by the driver to establish the default FBO. The default implementation returns 0.
-     *
-     * This method can be called either on the regular or protected OpenGL contexts and can return
-     * a different or identical name, since these names exist in different namespaces.
-     *
-     * @return a GLuint casted to a uint32_t that is an OpenGL framebuffer object.
+      * @return a GLuint casted to a uint32_t that is an OpenGL framebuffer object.
     */
-    virtual uint32_t getDefaultFramebufferObject() noexcept;
-
-    /**
-     * Called by the backend when a frame starts.
-     * @param steady_clock_ns vsync time point on the monotonic clock
-     * @param refreshIntervalNs refresh interval in nanosecond
-     * @param frameId a frame id
-     */
-    virtual void beginFrame(
-            int64_t monotonic_clock_ns,
-            int64_t refreshIntervalNs,
-            uint32_t frameId) noexcept;
-
-    /**
-     * Called by the backend when a frame ends.
-     * @param frameId the frame id used in beginFrame
-     */
-    virtual void endFrame(
-            uint32_t frameId) noexcept;
-
-    /**
-     * Type of contexts available
-     */
-    enum class ContextType {
-        NONE,           //!< No current context
-        UNPROTECTED,    //!< current context is unprotected
-        PROTECTED       //!< current context supports protected content
-    };
-
-    /**
-     * Returns the type of the context currently in use. This value is updated by makeCurrent()
-     * and therefore can be cached between calls. ContextType::PROTECTED can only be returned
-     * if isProtectedContextSupported() is true.
-     * @return ContextType
-     */
-    virtual ContextType getCurrentContextType() const noexcept;
-
-    /**
-     * Binds the requested context to the current thread and drawSwapChain to the default FBO
-     * returned by getDefaultFramebufferObject().
-     *
-     * @param type type of context to bind to the current thread.
-     * @param drawSwapChain SwapChain to draw to. It must be bound to the default FBO.
-     * @param readSwapChain SwapChain to read from (for operation like `glBlitFramebuffer`)
-     * @return true on success, false on error.
-     */
-    virtual bool makeCurrent(ContextType type,
-            SwapChain* UTILS_NONNULL drawSwapChain,
-            SwapChain* UTILS_NONNULL readSwapChain) noexcept = 0;
+    virtual uint32_t createDefaultRenderTarget() noexcept;

    /**
     * Called by the driver to make the OpenGL context active on the calling thread and bind
-     * the drawSwapChain to the default FBO returned by getDefaultFramebufferObject().
-     * The context used is either the default context or the protected context. When a context
-     * change is necessary, the preContextChange and postContextChange callbacks are called,
-     * before and after the context change respectively. postContextChange is given the index
-     * of the new context (0 for default and 1 for protected).
-     * The default implementation just calls makeCurrent(getCurrentContextType(), SwapChain*, SwapChain*).
-     *
+     * the drawSwapChain to the default render target (FBO) created with createDefaultRenderTarget.
     * @param drawSwapChain SwapChain to draw to. It must be bound to the default FBO.
     * @param readSwapChain SwapChain to read from (for operation like `glBlitFramebuffer`)
-     * @param preContextChange called before the context changes
-     * @param postContextChange called after the context changes
     */
    virtual void makeCurrent(
            SwapChain* UTILS_NONNULL drawSwapChain,
-            SwapChain* UTILS_NONNULL readSwapChain,
-            utils::Invocable<void()> preContextChange,
-            utils::Invocable<void(size_t index)> postContextChange) noexcept;
-
-    /**
-     * Called by the backend just before calling commit()
-     * @see commit()
-     */
-    virtual void preCommit() noexcept;
+            SwapChain* UTILS_NONNULL readSwapChain) noexcept = 0;

    /**
     * Called by the driver once the current frame finishes drawing. Typically, this should present
@@ -57,7 +57,7 @@ protected:
    SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
+    void makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
    void commit(SwapChain* swapChain) noexcept override;
    OpenGLPlatform::ExternalTexture* createExternalImageTexture() noexcept override;
    void destroyExternalImage(ExternalTexture* texture) noexcept override;
@@ -45,7 +45,7 @@ public:

    void terminate() noexcept override;

-    uint32_t getDefaultFramebufferObject() noexcept override;
+    uint32_t createDefaultRenderTarget() noexcept override;

    bool isExtraContextSupported() const noexcept override;
    void createContext(bool shared) override;
@@ -53,7 +53,7 @@ public:
    SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
+    void makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
    void commit(SwapChain* swapChain) noexcept override;

    OpenGLPlatform::ExternalTexture* createExternalImageTexture() noexcept override;
@@ -25,8 +25,6 @@
 #include <EGL/eglext.h>
 #include <EGL/eglplatform.h>

-#include <utils/Invocable.h>
-
 #include <initializer_list>
 #include <utility>
 #include <vector>
@@ -43,11 +41,15 @@ class PlatformEGL : public OpenGLPlatform {
 public:

    PlatformEGL() noexcept;
+    bool isExtraContextSupported() const noexcept override;
+    void createContext(bool shared) override;
+    void releaseContext() noexcept override;

    // Return true if we're on an OpenGL platform (as opposed to OpenGL ES). false by default.
    virtual bool isOpenGL() const noexcept;

 protected:
+
    // --------------------------------------------------------------------------------------------
    // Helper for EGL configs and attributes parameters

@@ -87,30 +89,13 @@ protected:
    // --------------------------------------------------------------------------------------------
    // OpenGLPlatform Interface

-    bool isExtraContextSupported() const noexcept override;
-    void createContext(bool shared) override;
-    void releaseContext() noexcept override;
-
    void terminate() noexcept override;

-    bool isProtectedContextSupported() const noexcept override;
-
    bool isSRGBSwapChainSupported() const noexcept override;
    SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool isSwapChainProtected(SwapChain* swapChain) noexcept override;
-
-    ContextType getCurrentContextType() const noexcept override;
-
-    bool makeCurrent(ContextType type,
-            SwapChain* drawSwapChain,
-            SwapChain* readSwapChain) noexcept override;
-
-    void makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain,
-            utils::Invocable<void()> preContextChange,
-            utils::Invocable<void(size_t index)> postContextChange) noexcept override;
-
+    void makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
    void commit(SwapChain* swapChain) noexcept override;

    bool canCreateFence() noexcept override;
@@ -137,27 +122,16 @@ protected:
    static void clearGlError() noexcept;

    /**
-     * Always use this instead of eglMakeCurrent(), as it tracks some state.
+     * Always use this instead of eglMakeCurrent().
     */
-
-    EGLContext getContextForType(ContextType type) const noexcept;
-
-    // makes the draw and read surface current without changing the current context
-    EGLBoolean makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) noexcept {
-        return egl.makeCurrent(drawSurface, readSurface);
-    }
-
-    // makes context current and set draw and read surfaces to EGL_NO_SURFACE
-    EGLBoolean makeCurrent(EGLContext context) noexcept {
-        return egl.makeCurrent(context, mEGLDummySurface, mEGLDummySurface);
-    }
+    EGLBoolean makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) noexcept;

    // TODO: this should probably use getters instead.
    EGLDisplay mEGLDisplay = EGL_NO_DISPLAY;
    EGLContext mEGLContext = EGL_NO_CONTEXT;
-    EGLContext mEGLContextProtected = EGL_NO_CONTEXT;
+    EGLSurface mCurrentDrawSurface = EGL_NO_SURFACE;
+    EGLSurface mCurrentReadSurface = EGL_NO_SURFACE;
    EGLSurface mEGLDummySurface = EGL_NO_SURFACE;
-    ContextType mCurrentContextType = ContextType::NONE;
    // mEGLConfig is valid only if ext.egl.KHR_no_config_context is false
    EGLConfig mEGLConfig = EGL_NO_CONFIG_KHR;
    Config mContextAttribs;
@@ -174,38 +148,13 @@ protected:
            bool KHR_gl_colorspace = false;
            bool KHR_no_config_context = false;
            bool KHR_surfaceless_context = false;
-            bool EXT_protected_content = false;
        } egl;
    } ext;

-    struct SwapChainEGL : public Platform::SwapChain {
-        EGLSurface sur = EGL_NO_SURFACE;
-        Config attribs{};
-        EGLNativeWindowType nativeWindow{};
-        EGLConfig config{};
-        uint64_t flags{};
-    };
-
    void initializeGlExtensions() noexcept;

 protected:
    EGLConfig findSwapChainConfig(uint64_t flags, bool window, bool pbuffer) const;
-
-private:
-    class EGL {
-        EGLDisplay& mEGLDisplay;
-        EGLSurface mCurrentDrawSurface = EGL_NO_SURFACE;
-        EGLSurface mCurrentReadSurface = EGL_NO_SURFACE;
-        EGLContext mCurrentContext = EGL_NO_CONTEXT;
-    public:
-        explicit EGL(EGLDisplay& dpy) : mEGLDisplay(dpy) {}
-        EGLBoolean makeCurrent(EGLContext context,
-                EGLSurface drawSurface, EGLSurface readSurface) noexcept;
-
-        EGLBoolean makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) noexcept {
-            return makeCurrent(mCurrentContext, drawSurface, readSurface);
-        }
-    } egl{ mEGLDisplay };
 };

 } // namespace filament::backend
@@ -22,10 +22,6 @@
 #include <backend/platforms/OpenGLPlatform.h>
 #include <backend/platforms/PlatformEGL.h>

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

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

    void terminate() noexcept override;

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

 } // namespace filament::backend
@@ -51,7 +51,7 @@ protected:
    SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
+    void makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
    void commit(SwapChain* swapChain) noexcept override;

 private:
@@ -53,7 +53,7 @@ protected:
    SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
+    void makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
    void commit(SwapChain* swapChain) noexcept override;

 protected:
@@ -46,7 +46,7 @@ protected:
    SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
+    void makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
    void commit(SwapChain* swapChain) noexcept override;
 };

@@ -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
@@ -200,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()
@@ -251,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;
@@ -50,13 +50,12 @@ class CommandBufferQueue {
    size_t mFreeSpace = 0;
    size_t mHighWatermark = 0;
    uint32_t mExitRequested = 0;
-    bool mPaused = false;

    static constexpr uint32_t EXIT_REQUESTED = 0x31415926;

 public:
    // requiredSize: guaranteed available space after flush()
-    CommandBufferQueue(size_t requiredSize, size_t bufferSize, bool paused);
+    CommandBufferQueue(size_t requiredSize, size_t bufferSize);
    ~CommandBufferQueue();

    CircularBuffer& getCircularBuffer() noexcept { return mCircularBuffer; }
@@ -81,10 +80,6 @@ public:
    // returns from waitForCommands() immediately.
    void requestExit();

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

@@ -134,7 +134,7 @@ struct CommandType<void (Driver::*)(ARGS...)> {

    public:
        template<typename M, typename D>
-        static inline void execute(M&& method, D&& driver, CommandBase* base, intptr_t* next) {
+        static inline void execute(M&& method, D&& driver, CommandBase* base, intptr_t* next) noexcept {
            Command* self = static_cast<Command*>(base);
            *next = align(sizeof(Command));
 #if DEBUG_COMMAND_STREAM
@@ -168,7 +168,7 @@ struct CommandType<void (Driver::*)(ARGS...)> {

 class CustomCommand : public CommandBase {
    std::function<void()> mCommand;
-    static void execute(Driver&, CommandBase* base, intptr_t* next);
+    static void execute(Driver&, CommandBase* base, intptr_t* next) noexcept;
 public:
    inline CustomCommand(CustomCommand&& rhs) = default;
    inline explicit CustomCommand(std::function<void()> cmd)
@@ -76,7 +76,7 @@ public:
    // the fn function will execute a batch of driver commands
    // this gives the driver a chance to wrap their execution in a meaningful manner
    // the default implementation simply calls fn
-    virtual void execute(std::function<void(void)> const& fn);
+    virtual void execute(std::function<void(void)> const& fn) noexcept;

    // This is called on debug build, or when enabled manually on the backend thread side.
    virtual void debugCommandBegin(CommandStream* cmds,
@@ -133,18 +133,18 @@ DECL_DRIVER_API_0(tick)

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

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

 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)
@@ -167,14 +167,11 @@ DECL_DRIVER_API_0(resetState)
 * -----------------------
 */

-DECL_DRIVER_API_R_N(backend::VertexBufferInfoHandle, createVertexBufferInfo,
+DECL_DRIVER_API_R_N(backend::VertexBufferHandle, createVertexBuffer,
        uint8_t, bufferCount,
        uint8_t, attributeCount,
-        backend::AttributeArray, attributes)
-
-DECL_DRIVER_API_R_N(backend::VertexBufferHandle, createVertexBuffer,
        uint32_t, vertexCount,
-        backend::VertexBufferInfoHandle, vbih)
+        backend::AttributeArray, attributes)

 DECL_DRIVER_API_R_N(backend::IndexBufferHandle, createIndexBuffer,
        backend::ElementType, elementType,
@@ -227,7 +224,11 @@ DECL_DRIVER_API_R_N(backend::SamplerGroupHandle, createSamplerGroup,
 DECL_DRIVER_API_R_N(backend::RenderPrimitiveHandle, createRenderPrimitive,
        backend::VertexBufferHandle, vbh,
        backend::IndexBufferHandle, ibh,
-        backend::PrimitiveType, pt)
+        backend::PrimitiveType, pt,
+        uint32_t, offset,
+        uint32_t, minIndex,
+        uint32_t, maxIndex,
+        uint32_t, count)

 DECL_DRIVER_API_R_N(backend::ProgramHandle, createProgram,
        backend::Program&&, program)
@@ -239,7 +240,6 @@ DECL_DRIVER_API_R_N(backend::RenderTargetHandle, createRenderTarget,
        uint32_t, width,
        uint32_t, height,
        uint8_t, samples,
-        uint8_t, layerCount,
        backend::MRT, color,
        backend::TargetBufferInfo, depth,
        backend::TargetBufferInfo, stencil)
@@ -264,7 +264,6 @@ DECL_DRIVER_API_R_0(backend::TimerQueryHandle, createTimerQuery)
 */

 DECL_DRIVER_API_N(destroyVertexBuffer,    backend::VertexBufferHandle, vbh)
-DECL_DRIVER_API_N(destroyVertexBufferInfo,backend::VertexBufferInfoHandle, vbih)
 DECL_DRIVER_API_N(destroyIndexBuffer,     backend::IndexBufferHandle, ibh)
 DECL_DRIVER_API_N(destroyBufferObject,    backend::BufferObjectHandle, ibh)
 DECL_DRIVER_API_N(destroyRenderPrimitive, backend::RenderPrimitiveHandle, rph)
@@ -299,17 +298,14 @@ DECL_DRIVER_API_SYNCHRONOUS_0(bool, isFrameBufferFetchMultiSampleSupported)
 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_0(bool, isParallelShaderCompileSupported)
 DECL_DRIVER_API_SYNCHRONOUS_0(bool, isDepthStencilResolveSupported)
-DECL_DRIVER_API_SYNCHRONOUS_N(bool, isDepthStencilBlitSupported, backend::TextureFormat, format)
-DECL_DRIVER_API_SYNCHRONOUS_0(bool, isProtectedTexturesSupported)
 DECL_DRIVER_API_SYNCHRONOUS_0(uint8_t, getMaxDrawBuffers)
 DECL_DRIVER_API_SYNCHRONOUS_0(size_t, getMaxUniformBufferSize)
 DECL_DRIVER_API_SYNCHRONOUS_0(math::float2, getClipSpaceParams)
 DECL_DRIVER_API_SYNCHRONOUS_N(void, setupExternalImage, void*, image)
-DECL_DRIVER_API_SYNCHRONOUS_N(backend::TimerQueryResult, getTimerQueryValue, backend::TimerQueryHandle, query, uint64_t*, elapsedTime)
+DECL_DRIVER_API_SYNCHRONOUS_N(bool, getTimerQueryValue, backend::TimerQueryHandle, query, uint64_t*, elapsedTime)
 DECL_DRIVER_API_SYNCHRONOUS_N(bool, isWorkaroundNeeded, backend::Workaround, workaround)
 DECL_DRIVER_API_SYNCHRONOUS_0(backend::FeatureLevel, getFeatureLevel)

@@ -433,11 +429,6 @@ DECL_DRIVER_API_N(bindSamplers,
        uint32_t, index,
        backend::SamplerGroupHandle, sbh)

-DECL_DRIVER_API_N(setPushConstant,
-        backend::ShaderStage, stage,
-        uint8_t, index,
-        backend::PushConstantVariant, value)
-
 DECL_DRIVER_API_N(insertEventMarker,
        const char*, string,
        uint32_t, len = 0)
@@ -500,32 +491,15 @@ DECL_DRIVER_API_N(blit,
        math::uint2, srcOrigin,
        math::uint2, size)

-DECL_DRIVER_API_N(bindPipeline,
-        backend::PipelineState const&, state)
-
-DECL_DRIVER_API_N(bindRenderPrimitive,
-        backend::RenderPrimitiveHandle, rph)
-
-DECL_DRIVER_API_N(draw2,
-        uint32_t, indexOffset,
-        uint32_t, indexCount,
-        uint32_t, instanceCount)
-
 DECL_DRIVER_API_N(draw,
        backend::PipelineState, state,
        backend::RenderPrimitiveHandle, rph,
-        uint32_t, indexOffset,
-        uint32_t, indexCount,
        uint32_t, instanceCount)

-
 DECL_DRIVER_API_N(dispatchCompute,
        backend::ProgramHandle, program,
        math::uint3, workGroupCount)

-DECL_DRIVER_API_N(scissor,
-        Viewport, scissor)
-

 #pragma clang diagnostic pop

@@ -24,32 +24,36 @@
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/ostream.h>
-#include <utils/Panic.h>

 #include <tsl/robin_map.h>

-#include <cstddef>
 #include <exception>
 #include <type_traits>
 #include <unordered_map>
-#include <utility>

 #include <stddef.h>
 #include <stdint.h>

-#define HandleAllocatorGL  HandleAllocator<32,  64, 136>    // ~4520 / pool / MiB
-#define HandleAllocatorVK  HandleAllocator<64, 160, 312>    // ~1820 / pool / MiB
-#define HandleAllocatorMTL HandleAllocator<32,  48, 552>    // ~1660 / pool / MiB
+#if !defined(NDEBUG) && UTILS_HAS_RTTI
+#   define HANDLE_TYPE_SAFETY 1
+#else
+#   define HANDLE_TYPE_SAFETY 0
+#endif
+
+#define HandleAllocatorGL  HandleAllocator<16, 64, 208>
+#define HandleAllocatorVK  HandleAllocator<16, 64, 880>
+#define HandleAllocatorMTL HandleAllocator<16, 64, 584>

 namespace filament::backend {

 /*
 * A utility class to efficiently allocate and manage Handle<>
 */
-template<size_t P0, size_t P1, size_t P2>
+template <size_t P0, size_t P1, size_t P2>
 class HandleAllocator {
 public:
-    HandleAllocator(const char* name, size_t size, bool disableUseAfterFreeCheck) noexcept;
+
+    HandleAllocator(const char* name, size_t size) noexcept;
    HandleAllocator(HandleAllocator const& rhs) = delete;
    HandleAllocator& operator=(HandleAllocator const& rhs) = delete;
    ~HandleAllocator();
@@ -65,10 +69,15 @@ public:
     *
     */
    template<typename D, typename ... ARGS>
-    Handle<D> allocateAndConstruct(ARGS&& ... args) {
-        Handle<D> h{ allocateHandle<D>() };
+    Handle<D> allocateAndConstruct(ARGS&& ... args) noexcept {
+        Handle<D> h{ allocateHandle<sizeof(D)>() };
        D* addr = handle_cast<D*>(h);
        new(addr) D(std::forward<ARGS>(args)...);
+#if HANDLE_TYPE_SAFETY
+        mLock.lock();
+        mHandleTypeId[addr] = typeid(D).name();
+        mLock.unlock();
+#endif
        return h;
    }

@@ -84,7 +93,13 @@ public:
     */
    template<typename D>
    Handle<D> allocate() noexcept {
-        Handle<D> h{ allocateHandle<D>() };
+        Handle<D> h{ allocateHandle<sizeof(D)>() };
+#if HANDLE_TYPE_SAFETY
+        D* addr = handle_cast<D*>(h);
+        mLock.lock();
+        mHandleTypeId[addr] = typeid(D).name();
+        mLock.unlock();
+#endif
        return h;
    }

@@ -97,14 +112,21 @@ public:
     */
    template<typename D, typename B, typename ... ARGS>
    typename std::enable_if_t<std::is_base_of_v<B, D>, D>*
-    destroyAndConstruct(Handle<B> const& handle, ARGS&& ... args) {
+    destroyAndConstruct(Handle<B> const& handle, ARGS&& ... args) noexcept {
        assert_invariant(handle);
        D* addr = handle_cast<D*>(const_cast<Handle<B>&>(handle));
        assert_invariant(addr);
+
        // currently we implement construct<> with dtor+ctor, we could use operator= also
        // but all our dtors are trivial, ~D() is actually a noop.
        addr->~D();
        new(addr) D(std::forward<ARGS>(args)...);
+
+#if HANDLE_TYPE_SAFETY
+        mLock.lock();
+        mHandleTypeId[addr] = typeid(D).name();
+        mLock.unlock();
+#endif
        return addr;
    }

@@ -121,6 +143,12 @@ public:
        D* addr = handle_cast<D*>(const_cast<Handle<B>&>(handle));
        assert_invariant(addr);
        new(addr) D(std::forward<ARGS>(args)...);
+
+#if HANDLE_TYPE_SAFETY
+        mLock.lock();
+        mHandleTypeId[addr] = typeid(D).name();
+        mLock.unlock();
+#endif
        return addr;
    }

@@ -136,8 +164,19 @@ public:
    void deallocate(Handle<B>& handle, D const* p) noexcept {
        // allow to destroy the nullptr, similarly to operator delete
        if (p) {
+#if HANDLE_TYPE_SAFETY
+            mLock.lock();
+            auto typeId = mHandleTypeId[p];
+            mHandleTypeId.erase(p);
+            mLock.unlock();
+            if (UTILS_UNLIKELY(typeId != typeid(D).name())) {
+                utils::slog.e << "Destroying handle " << handle.getId() << ", type " << typeid(D).name()
+                       << ", but handle's actual type is " << typeId << utils::io::endl;
+                std::terminate();
+            }
+#endif
            p->~D();
-            deallocateHandle<D>(handle.getId());
+            deallocateHandle<sizeof(D)>(handle.getId());
        }
    }

@@ -163,21 +202,9 @@ public:
    inline typename std::enable_if_t<
            std::is_pointer_v<Dp> &&
            std::is_base_of_v<B, typename std::remove_pointer_t<Dp>>, Dp>
-    handle_cast(Handle<B>& handle) {
+    handle_cast(Handle<B>& handle) noexcept {
        assert_invariant(handle);
-        auto [p, tag] = handleToPointer(handle.getId());
-
-        if (isPoolHandle(handle.getId())) {
-            // check for use after free
-            if (UTILS_UNLIKELY(!mUseAfterFreeCheckDisabled)) {
-                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;
-                ASSERT_POSTCONDITION(expectedAge == age,
-                        "use-after-free of Handle with id=%d", handle.getId());
-            }
-        }
-
+        void* const p = handleToPointer(handle.getId());
        return static_cast<Dp>(p);
    }

@@ -185,66 +212,36 @@ public:
    inline typename std::enable_if_t<
            std::is_pointer_v<Dp> &&
            std::is_base_of_v<B, typename std::remove_pointer_t<Dp>>, Dp>
-    handle_cast(Handle<B> const& handle) {
+    handle_cast(Handle<B> const& handle) noexcept {
        return handle_cast<Dp>(const_cast<Handle<B>&>(handle));
    }

+
 private:

-    template<typename D>
-    static constexpr size_t getBucketSize() noexcept {
-        if constexpr (sizeof(D) <= P0) { return P0; }
-        if constexpr (sizeof(D) <= P1) { return P1; }
-        static_assert(sizeof(D) <= P2);
-        return P2;
-    }
-
+    // template <int P0, int P1, int P2>
    class Allocator {
        friend class HandleAllocator;
-        static constexpr size_t MIN_ALIGNMENT = alignof(std::max_align_t);
-        struct Node { uint8_t age; };
-        // Note: using the `extra` parameter of PoolAllocator<>, even with a 1-byte structure,
-        // generally increases all pool allocations by 8-bytes because of alignment restrictions.
-        template<size_t SIZE>
-        using Pool = utils::PoolAllocator<SIZE, MIN_ALIGNMENT, sizeof(Node)>;
-        Pool<P0> mPool0;
-        Pool<P1> mPool1;
-        Pool<P2> mPool2;
+        utils::PoolAllocator<P0, 16>   mPool0;
+        utils::PoolAllocator<P1, 16>   mPool1;
+        utils::PoolAllocator<P2, 16>   mPool2;
        UTILS_UNUSED_IN_RELEASE const utils::AreaPolicy::HeapArea& mArea;
-        bool mUseAfterFreeCheckDisabled;
    public:
-        explicit Allocator(const utils::AreaPolicy::HeapArea& area, bool disableUseAfterFreeCheck);
-
-        static constexpr size_t getAlignment() noexcept { return MIN_ALIGNMENT; }
+        static constexpr size_t MIN_ALIGNMENT_SHIFT = 4;
+        explicit Allocator(const utils::AreaPolicy::HeapArea& area);

        // this is in fact always called with a constexpr size argument
-        [[nodiscard]] inline void* alloc(size_t size, size_t, size_t, uint8_t* outAge) noexcept {
+        [[nodiscard]] inline void* alloc(size_t size, size_t, size_t extra = 0) noexcept {
            void* p = nullptr;
-            if      (size <= mPool0.getSize()) p = mPool0.alloc(size);
-            else if (size <= mPool1.getSize()) p = mPool1.alloc(size);
-            else if (size <= mPool2.getSize()) p = mPool2.alloc(size);
-            if (UTILS_LIKELY(p)) {
-                Node const* const pNode = static_cast<Node const*>(p);
-                // we are guaranteed to have at least sizeof<Node> bytes of extra storage before
-                // the allocation address.
-                *outAge = pNode[-1].age;
-            }
+                 if (size <= mPool0.getSize()) p = mPool0.alloc(size, 16, extra);
+            else if (size <= mPool1.getSize()) p = mPool1.alloc(size, 16, extra);
+            else if (size <= mPool2.getSize()) p = mPool2.alloc(size, 16, extra);
            return p;
        }

        // this is in fact always called with a constexpr size argument
-        inline void free(void* p, size_t size, uint8_t age) noexcept {
+        inline void free(void* p, size_t size) noexcept {
            assert_invariant(p >= mArea.begin() && (char*)p + size <= (char*)mArea.end());
-
-            // check for double-free
-            Node* const pNode = static_cast<Node*>(p);
-            uint8_t& expectedAge = pNode[-1].age;
-            if (UTILS_UNLIKELY(!mUseAfterFreeCheckDisabled)) {
-                ASSERT_POSTCONDITION(expectedAge == age,
-                        "double-free of Handle of size %d at %p", size, p);
-            }
-            expectedAge = (expectedAge + 1) & 0xF; // fixme
-
            if (size <= mPool0.getSize()) { mPool0.free(p); return; }
            if (size <= mPool1.getSize()) { mPool1.free(p); return; }
            if (size <= mPool2.getSize()) { mPool2.free(p); return; }
@@ -266,16 +263,24 @@ private:
    // allocateHandle()/deallocateHandle() selects the pool to use at compile-time based on the
    // allocation size this is always inlined, because all these do is to call
    // allocateHandleInPool()/deallocateHandleFromPool() with the right pool size.
-    template<typename D>
+    template<size_t SIZE>
    HandleBase::HandleId allocateHandle() noexcept {
-        constexpr size_t BUCKET_SIZE = getBucketSize<D>();
-        return allocateHandleInPool<BUCKET_SIZE>();
+        if constexpr (SIZE <= P0) { return allocateHandleInPool<P0>(); }
+        if constexpr (SIZE <= P1) { return allocateHandleInPool<P1>(); }
+        static_assert(SIZE <= P2);
+        return allocateHandleInPool<P2>();
    }

-    template<typename D>
+    template<size_t SIZE>
    void deallocateHandle(HandleBase::HandleId id) noexcept {
-        constexpr size_t BUCKET_SIZE = getBucketSize<D>();
-        deallocateHandleFromPool<BUCKET_SIZE>(id);
+        if constexpr (SIZE <= P0) {
+            deallocateHandleFromPool<P0>(id);
+        } else if constexpr (SIZE <= P1) {
+            deallocateHandleFromPool<P1>(id);
+        } else {
+            static_assert(SIZE <= P2);
+            deallocateHandleFromPool<P2>(id);
+        }
    }

    // allocateHandleInPool()/deallocateHandleFromPool() is NOT inlined, which will cause three
@@ -284,11 +289,9 @@ private:
    template<size_t SIZE>
    UTILS_NOINLINE
    HandleBase::HandleId allocateHandleInPool() noexcept {
-        uint8_t age;
-        void* p = mHandleArena.alloc(SIZE, alignof(std::max_align_t), 0, &age);
+        void* p = mHandleArena.alloc(SIZE);
        if (UTILS_LIKELY(p)) {
-            uint32_t const tag = (uint32_t(age) << HANDLE_AGE_SHIFT) & HANDLE_AGE_MASK;
-            return arenaPointerToHandle(p, tag);
+            return pointerToHandle(p);
        } else {
            return allocateHandleSlow(SIZE);
        }
@@ -298,51 +301,42 @@ private:
    UTILS_NOINLINE
    void deallocateHandleFromPool(HandleBase::HandleId id) noexcept {
        if (UTILS_LIKELY(isPoolHandle(id))) {
-            auto [p, tag] = handleToPointer(id);
-            uint8_t const age = (tag & HANDLE_AGE_MASK) >> HANDLE_AGE_SHIFT;
-            mHandleArena.free(p, SIZE, age);
+            void* p = handleToPointer(id);
+            mHandleArena.free(p, SIZE);
        } else {
            deallocateHandleSlow(id, SIZE);
        }
    }

-    // we handle a 4 bits age per address
-    static constexpr uint32_t HANDLE_HEAP_FLAG      = 0x80000000u;      // pool vs heap handle
-    static constexpr uint32_t HANDLE_AGE_MASK       = 0x78000000u;      // handle's age
-    static constexpr uint32_t HANDLE_INDEX_MASK     = 0x07FFFFFFu;      // handle index
-    static constexpr uint32_t HANDLE_TAG_MASK       = HANDLE_AGE_MASK;
-    static constexpr uint32_t HANDLE_AGE_SHIFT      = 27;
+    static constexpr uint32_t HEAP_HANDLE_FLAG = 0x80000000u;

    static bool isPoolHandle(HandleBase::HandleId id) noexcept {
-        return (id & HANDLE_HEAP_FLAG) == 0u;
+        return (id & HEAP_HANDLE_FLAG) == 0u;
    }

-    HandleBase::HandleId allocateHandleSlow(size_t size);
+    HandleBase::HandleId allocateHandleSlow(size_t size) noexcept;
    void deallocateHandleSlow(HandleBase::HandleId id, size_t size) noexcept;

    // We inline this because it's just 4 instructions in the fast case
-    inline std::pair<void*, uint32_t> handleToPointer(HandleBase::HandleId id) const noexcept {
+    inline void* handleToPointer(HandleBase::HandleId id) const noexcept {
        // note: the null handle will end-up returning nullptr b/c it'll be handled as
        // a non-pool handle.
        if (UTILS_LIKELY(isPoolHandle(id))) {
            char* const base = (char*)mHandleArena.getArea().begin();
-            uint32_t const tag = id & HANDLE_TAG_MASK;
-            size_t const offset = (id & HANDLE_INDEX_MASK) * Allocator::getAlignment();
-            return { static_cast<void*>(base + offset), tag };
+            size_t offset = id << Allocator::MIN_ALIGNMENT_SHIFT;
+            return static_cast<void*>(base + offset);
        }
-        return { handleToPointerSlow(id), 0 };
+        return handleToPointerSlow(id);
    }

    void* handleToPointerSlow(HandleBase::HandleId id) const noexcept;

    // We inline this because it's just 3 instructions
-    inline HandleBase::HandleId arenaPointerToHandle(void* p, uint32_t tag) const noexcept {
+    inline HandleBase::HandleId pointerToHandle(void* p) const noexcept {
        char* const base = (char*)mHandleArena.getArea().begin();
-        size_t const offset = (char*)p - base;
-        assert_invariant((offset % Allocator::getAlignment()) == 0);
-        auto id = HandleBase::HandleId(offset / Allocator::getAlignment());
-        id |= tag & HANDLE_TAG_MASK;
-        assert_invariant((id & HANDLE_HEAP_FLAG) == 0);
+        size_t offset = (char*)p - base;
+        auto id = HandleBase::HandleId(offset >> Allocator::MIN_ALIGNMENT_SHIFT);
+        assert_invariant((id & HEAP_HANDLE_FLAG) == 0);
        return id;
    }

@@ -352,7 +346,9 @@ private:
    mutable utils::Mutex mLock;
    tsl::robin_map<HandleBase::HandleId, void*> mOverflowMap;
    HandleBase::HandleId mId = 0;
-    bool mUseAfterFreeCheckDisabled = false;
+#if HANDLE_TYPE_SAFETY
+    mutable std::unordered_map<const void*, const char*> mHandleTypeId;
+#endif
 };

 } // namespace filament::backend
@@ -39,11 +39,10 @@ using namespace utils;

 namespace filament::backend {

-CommandBufferQueue::CommandBufferQueue(size_t requiredSize, size_t bufferSize, bool paused)
+CommandBufferQueue::CommandBufferQueue(size_t requiredSize, size_t bufferSize)
        : mRequiredSize((requiredSize + (CircularBuffer::getBlockSize() - 1u)) & ~(CircularBuffer::getBlockSize() -1u)),
          mCircularBuffer(bufferSize),
-          mFreeSpace(mCircularBuffer.size()),
-          mPaused(paused) {
+          mFreeSpace(mCircularBuffer.size()) {
    assert_invariant(mCircularBuffer.size() > requiredSize);
 }

@@ -57,21 +56,6 @@ void CommandBufferQueue::requestExit() {
    mCondition.notify_one();
 }

-bool CommandBufferQueue::isPaused() const noexcept {
-    std::lock_guard<utils::Mutex> const lock(mLock);
-    return mPaused;
-}
-
-void CommandBufferQueue::setPaused(bool paused) {
-    std::lock_guard<utils::Mutex> const lock(mLock);
-    if (paused) {
-        mPaused = true;
-    } else {
-        mPaused = false;
-        mCondition.notify_one();
-    }
-}
-
 bool CommandBufferQueue::isExitRequested() const {
    std::lock_guard<utils::Mutex> const lock(mLock);
    ASSERT_PRECONDITION( mExitRequested == 0 || mExitRequested == EXIT_REQUESTED,
@@ -131,9 +115,6 @@ void CommandBufferQueue::flush() noexcept {
 #endif

        SYSTRACE_NAME("waiting: CircularBuffer::flush()");
-        ASSERT_POSTCONDITION(!mPaused,
-                "CommandStream is full, but since the rendering thread is paused, "
-                "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;
@@ -146,7 +127,7 @@ std::vector<CommandBufferQueue::Range> CommandBufferQueue::waitForCommands() con
        return std::move(mCommandBuffersToExecute);
    }
    std::unique_lock<utils::Mutex> lock(mLock);
-    while ((mCommandBuffersToExecute.empty() || mPaused) && !mExitRequested) {
+    while (mCommandBuffersToExecute.empty() && !mExitRequested) {
        mCondition.wait(lock);
    }

@@ -149,7 +149,7 @@ void CommandType<void (Driver::*)(ARGS...)>::Command<METHOD>::log() noexcept  {

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

-void CustomCommand::execute(Driver&, CommandBase* base, intptr_t* next) {
+void CustomCommand::execute(Driver&, CommandBase* base, intptr_t* next) noexcept {
    *next = CustomCommand::align(sizeof(CustomCommand));
    static_cast<CustomCommand*>(base)->mCommand();
    static_cast<CustomCommand*>(base)->~CustomCommand();
@@ -214,7 +214,7 @@ size_t Driver::getElementTypeSize(ElementType type) noexcept {

 Driver::~Driver() noexcept = default;

-void Driver::execute(std::function<void(void)> const& fn) {
+void Driver::execute(std::function<void(void)> const& fn) noexcept {
    fn();
 }

@@ -49,25 +49,21 @@ struct AcquiredImage;
 struct HwBase {
 };

-
-struct HwVertexBufferInfo : public HwBase {
+struct HwVertexBuffer : public HwBase {
+    AttributeArray attributes{};          // 8 * MAX_VERTEX_ATTRIBUTE_COUNT
+    uint32_t vertexCount{};               //   4
    uint8_t bufferCount{};                //   1
    uint8_t attributeCount{};             //   1
-    bool padding[2]{};                    //   2
-    HwVertexBufferInfo() noexcept = default;
-    HwVertexBufferInfo(uint8_t bufferCount, uint8_t attributeCount) noexcept
-            : bufferCount(bufferCount),
-              attributeCount(attributeCount) {
-    }
-};
+    bool padding{};                       //   1
+    uint8_t bufferObjectsVersion{};       //   1 -> total struct is 136 bytes

-struct HwVertexBuffer : public HwBase {
-    uint32_t vertexCount{};               //   4
-    uint8_t bufferObjectsVersion{0xff};   //   1
-    bool padding[3]{};                    //   2
    HwVertexBuffer() noexcept = default;
-    explicit HwVertexBuffer(uint32_t vertextCount) noexcept
-            : vertexCount(vertextCount) {
+    HwVertexBuffer(uint8_t bufferCount, uint8_t attributeCount, uint32_t elementCount,
+            AttributeArray const& attributes) noexcept
+            : attributes(attributes),
+              vertexCount(elementCount),
+              bufferCount(bufferCount),
+              attributeCount(attributeCount) {
    }
 };

@@ -92,6 +88,11 @@ struct HwIndexBuffer : public HwBase {
 };

 struct HwRenderPrimitive : public HwBase {
+    uint32_t offset{};
+    uint32_t minIndex{};
+    uint32_t maxIndex{};
+    uint32_t count{};
+    uint32_t maxVertexCount{};
    PrimitiveType type = PrimitiveType::TRIANGLES;
 };

@@ -113,9 +114,7 @@ struct HwTexture : public HwBase {
    uint8_t levels : 4;  // This allows up to 15 levels (max texture size of 32768 x 32768)
    uint8_t samples : 4; // Sample count per pixel (should always be a power of 2)
    TextureFormat format{};
-    uint8_t reserved0 = 0;
    TextureUsage usage{};
-    uint16_t reserved1 = 0;
    HwStream* hwStream = nullptr;

    HwTexture() noexcept : levels{}, samples{} {}
@@ -16,22 +16,9 @@

 #include "private/backend/HandleAllocator.h"

-#include <backend/Handle.h>
-
-#include <utils/Allocator.h>
-#include <utils/Log.h>
 #include <utils/Panic.h>
-#include <utils/compiler.h>
-#include <utils/debug.h>
-#include <utils/ostream.h>
-
-#include <algorithm>
-#include <exception>
-#include <limits>
-#include <mutex>

 #include <stdlib.h>
-#include <string.h>

 namespace filament::backend {

@@ -39,47 +26,23 @@ using namespace utils;

 template <size_t P0, size_t P1, size_t P2>
 UTILS_NOINLINE
-HandleAllocator<P0, P1, P2>::Allocator::Allocator(AreaPolicy::HeapArea const& area,
-        bool disableUseAfterFreeCheck)
-        : mArea(area),
-          mUseAfterFreeCheckDisabled(disableUseAfterFreeCheck) {
-
-    // The largest handle this allocator can generate currently depends on the architecture's
-    // min alignment, typically 8 or 16 bytes.
-    // e.g. On Android armv8, the alignment is 16 bytes, so for a 1 MiB heap, the largest handle
-    //      index will be 65536. Note that this is not the same as the number of handles (which
-    //      will always be less).
-    // Because our maximum representable handle currently is 0x07FFFFFF, the maximum no-nonsensical
-    // heap size is 2 GiB, which amounts to 7.6 millions handles per pool (in the GL case).
-    size_t const maxHeapSize = std::min(area.size(), HANDLE_INDEX_MASK * getAlignment());
-
-    if (UTILS_UNLIKELY(maxHeapSize != area.size())) {
-        slog.w << "HandleAllocator heap size reduced to "
-               << maxHeapSize << " from " << area.size() << io::endl;
-    }
-
-    // make sure we start with a clean arena. This is needed to ensure that all blocks start
-    // with an age of 0.
-    memset(area.data(), 0, maxHeapSize);
-
-    // size the different pools so that they can all contain the same number of handles
-    size_t const count = maxHeapSize / (P0 + P1 + P2);
-    char* const p0 = static_cast<char*>(area.begin());
-    char* const p1 = p0 + count * P0;
-    char* const p2 = p1 + count * P1;
-
-    mPool0 = Pool<P0>(p0, count * P0);
-    mPool1 = Pool<P1>(p1, count * P1);
-    mPool2 = Pool<P2>(p2, count * P2);
+HandleAllocator<P0, P1, P2>::Allocator::Allocator(AreaPolicy::HeapArea const& area)
+        : mArea(area) {
+    // TODO: we probably need a better way to set the size of these pools
+    const size_t unit = area.size() / 32;
+    const size_t offsetPool1 =      unit;
+    const size_t offsetPool2 = 16 * unit;
+    char* const p = (char*)area.begin();
+    mPool0 = PoolAllocator< P0, 16>(p, p + offsetPool1);
+    mPool1 = PoolAllocator< P1, 16>(p + offsetPool1, p + offsetPool2);
+    mPool2 = PoolAllocator< P2, 16>(p + offsetPool2, area.end());
 }

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

 template <size_t P0, size_t P1, size_t P2>
-HandleAllocator<P0, P1, P2>::HandleAllocator(const char* name, size_t size,
-        bool disableUseAfterFreeCheck) noexcept
-    : mHandleArena(name, size, disableUseAfterFreeCheck),
-      mUseAfterFreeCheckDisabled(disableUseAfterFreeCheck) {
+HandleAllocator<P0, P1, P2>::HandleAllocator(const char* name, size_t size) noexcept
+    : mHandleArena(name, size) {
 }

 template <size_t P0, size_t P1, size_t P2>
@@ -107,20 +70,14 @@ void* HandleAllocator<P0, P1, P2>::handleToPointerSlow(HandleBase::HandleId id)
 }

 template <size_t P0, size_t P1, size_t P2>
-HandleBase::HandleId HandleAllocator<P0, P1, P2>::allocateHandleSlow(size_t size) {
+HandleBase::HandleId HandleAllocator<P0, P1, P2>::allocateHandleSlow(size_t size) noexcept {
    void* p = ::malloc(size);
    std::unique_lock lock(mLock);
-
-    HandleBase::HandleId id = (++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");
-
+    HandleBase::HandleId id = (++mId) | HEAP_HANDLE_FLAG;
    mOverflowMap.emplace(id, p);
    lock.unlock();

-    if (UTILS_UNLIKELY(id == (HANDLE_HEAP_FLAG | 1u))) { // meaning id was zero
+    if (UTILS_UNLIKELY(id == (HEAP_HANDLE_FLAG|1u))) { // meaning id was zero
        PANIC_LOG("HandleAllocator arena is full, using slower system heap. Please increase "
                  "the appropriate constant (e.g. FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB).");
    }
@@ -129,7 +86,7 @@ HandleBase::HandleId HandleAllocator<P0, P1, P2>::allocateHandleSlow(size_t size

 template <size_t P0, size_t P1, size_t P2>
 void HandleAllocator<P0, P1, P2>::deallocateHandleSlow(HandleBase::HandleId id, size_t) noexcept {
-    assert_invariant(id & HANDLE_HEAP_FLAG);
+    assert_invariant(id & HEAP_HANDLE_FLAG);
    void* p = nullptr;
    auto& overflowMap = mOverflowMap;

@@ -53,18 +53,4 @@ size_t Platform::retrieveBlob(void const* key, size_t keySize, void* value, size
    return 0;
 }

-void Platform::setDebugUpdateStatFunc(DebugUpdateStatFunc&& debugUpdateStat) noexcept {
-    mDebugUpdateStat = std::move(debugUpdateStat);
-}
-
-bool Platform::hasDebugUpdateStatFunc() const noexcept {
-    return bool(mDebugUpdateStat);
-}
-
-void Platform::debugUpdateStat(const char* key, uint64_t value) {
-    if (mDebugUpdateStat) {
-        mDebugUpdateStat(key, value);
-    }
-}
-
 } // namespace filament::backend
@@ -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();
@@ -21,7 +21,7 @@ namespace filament::backend {
 using namespace utils;

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

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

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

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

-Program& Program::multiview(bool multiview) noexcept {
-    mMultiview = multiview;
-    return *this;
-}
-
 io::ostream& operator<<(io::ostream& out, const Program& builder) {
    out << "Program{";
    builder.mLogger(out);
@@ -18,7 +18,7 @@
 #define TNT_FILAMENT_DRIVER_METALBUFFER_H

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

 #include <backend/DriverEnums.h>

@@ -28,131 +28,9 @@

 #include <utility>
 #include <memory>
-#include <atomic>
-#include <chrono>

 namespace filament::backend {

-class ScopedAllocationTimer {
-public:
-    ScopedAllocationTimer(const char* name) : mBeginning(clock_t::now()), mName(name) {}
-    ~ScopedAllocationTimer() {
-        using namespace std::literals::chrono_literals;
-        static constexpr std::chrono::seconds LONG_TIME_THRESHOLD = 10s;
-
-        auto end = clock_t::now();
-        std::chrono::duration<double, std::micro> allocationTimeMicroseconds = end - mBeginning;
-
-        if (UTILS_UNLIKELY(allocationTimeMicroseconds > LONG_TIME_THRESHOLD)) {
-            if (platform && platform->hasDebugUpdateStatFunc()) {
-                char buffer[64];
-                snprintf(buffer, sizeof(buffer), "filament.metal.long_buffer_allocation_time.%s",
-                        mName);
-                platform->debugUpdateStat(
-                        buffer, static_cast<uint64_t>(allocationTimeMicroseconds.count()));
-            }
-        }
-    }
-
-    static void setPlatform(MetalPlatform* p) { platform = p; }
-
-private:
-    typedef std::chrono::steady_clock clock_t;
-
-    static MetalPlatform* platform;
-
-    std::chrono::time_point<clock_t> mBeginning;
-    const char* mName;
-};
-
-class TrackedMetalBuffer {
-public:
-
-    static constexpr size_t EXCESS_BUFFER_COUNT = 30000;
-
-    enum class Type {
-        NONE = 0,
-        GENERIC = 1,
-        RING = 2,
-        STAGING = 3,
-    };
-    static constexpr size_t TypeCount = 3;
-
-    static constexpr auto toIndex(Type t) {
-        assert_invariant(t != Type::NONE);
-        switch (t) {
-            case Type::NONE:
-            case Type::GENERIC:
-                return 0;
-            case Type::RING:
-                return 1;
-            case Type::STAGING:
-                return 2;
-        }
-    }
-
-    TrackedMetalBuffer() noexcept : mBuffer(nil) {}
-    TrackedMetalBuffer(nullptr_t) noexcept : mBuffer(nil) {}
-    TrackedMetalBuffer(id<MTLBuffer> buffer, Type type) : mBuffer(buffer), mType(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());
-                }
-            }
-        }
-    }
-
-    ~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;
-        }
-        return sum;
-    }
-
-    static uint64_t getAliveBuffers(Type type) {
-        assert_invariant(type != Type::NONE);
-        return aliveBuffers[toIndex(type)];
-    }
-    static void setPlatform(MetalPlatform* p) { platform = p; }
-
-private:
-    void swap(TrackedMetalBuffer& other) noexcept {
-        std::swap(mBuffer, other.mBuffer);
-        std::swap(mType, other.mType);
-    }
-
-    id<MTLBuffer> mBuffer;
-    Type mType = Type::NONE;
-
-    static MetalPlatform* platform;
-    static std::array<uint64_t, TypeCount> aliveBuffers;
-};
-
 class MetalBuffer {
 public:

@@ -204,7 +82,7 @@ public:

 private:

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

@@ -273,13 +149,9 @@ public:
            // If we already have an aux buffer, it will get freed here, unless it has been retained
            // by a MTLCommandBuffer. In that case, it will be freed when the command buffer
            // finishes executing.
-            {
-                ScopedAllocationTimer timer("ring");
-                mAuxBuffer = { [mDevice newBufferWithLength:mSlotSizeBytes options:mBufferOptions],
-                    TrackedMetalBuffer::Type::RING };
-            }
+            mAuxBuffer = [mDevice newBufferWithLength:mSlotSizeBytes options:mBufferOptions];
            assert_invariant(mAuxBuffer);
-            return { mAuxBuffer.get(), 0 };
+            return {mAuxBuffer, 0};
        }
        mCurrentSlot = (mCurrentSlot + 1) % mSlotCount;
        mOccupiedSlots->fetch_add(1, std::memory_order_relaxed);
@@ -308,9 +180,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 +191,8 @@ public:

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

    MTLResourceOptions mBufferOptions;

@@ -15,17 +15,12 @@
 */

 #include "MetalBuffer.h"
-#include "MetalBufferPool.h"

 #include "MetalContext.h"

 namespace filament {
 namespace backend {

-std::array<uint64_t, TrackedMetalBuffer::TypeCount> TrackedMetalBuffer::aliveBuffers = { 0 };
-MetalPlatform* TrackedMetalBuffer::platform = nullptr;
-MetalPlatform* ScopedAllocationTimer::platform = nullptr;
-
 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
@@ -39,11 +34,7 @@ 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];
    ASSERT_POSTCONDITION(mBuffer, "Could not allocate Metal buffer of size %zu.", size);
 }

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

    // The blit below requires that byteOffset be a multiple of 4.
    ASSERT_PRECONDITION(!(byteOffset & 0x3u), "byteOffset must be a multiple of 4");
@@ -79,9 +70,9 @@ void MetalBuffer::copyIntoBuffer(void* src, size_t size, size_t byteOffset) {
    id<MTLCommandBuffer> cmdBuffer = getPendingCommandBuffer(&mContext);
    id<MTLBlitCommandEncoder> blitEncoder = [cmdBuffer blitCommandEncoder];
    blitEncoder.label = @"Buffer upload blit";
-    [blitEncoder copyFromBuffer:staging->buffer.get()
+    [blitEncoder copyFromBuffer:staging->buffer
                   sourceOffset:0
-                       toBuffer:mBuffer.get()
+                       toBuffer:mBuffer
              destinationOffset:byteOffset
                           size:size];
    [blitEncoder endEncoding];
@@ -102,7 +93,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,
@@ -19,8 +19,6 @@

 #include <Metal/Metal.h>

-#include "MetalBuffer.h"
-
 #include <map>
 #include <mutex>
 #include <unordered_set>
@@ -32,7 +30,7 @@ struct MetalContext;

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

    // We were not able to find a sufficiently large stage, so create a new one.
-    id<MTLBuffer> buffer = nil;
-    {
-        ScopedAllocationTimer timer("staging");
-        buffer = [mContext.device newBufferWithLength:numBytes
-                                              options:MTLResourceStorageModeShared];
-    }
+    id<MTLBuffer> buffer = [mContext.device newBufferWithLength:numBytes
+                                                        options:MTLResourceStorageModeShared];
    ASSERT_POSTCONDITION(buffer, "Could not allocate Metal staging buffer of size %zu.", numBytes);
-    MetalBufferPoolEntry* stage = new MetalBufferPoolEntry {
-        .buffer = { buffer, TrackedMetalBuffer::Type::STAGING },
+    MetalBufferPoolEntry* stage = new MetalBufferPoolEntry({
+        .buffer = buffer,
        .capacity = numBytes,
        .lastAccessed = mCurrentFrame,
        .referenceCount = 1
-    };
+    });
    mUsedStages.insert(stage);

    return stage;
@@ -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) {}
@@ -111,7 +99,6 @@ struct MetalContext {
    std::array<BufferState, MAX_SSBO_COUNT> ssboState;
    CullModeStateTracker cullModeState;
    WindingStateTracker windingState;
-    Handle<HwRenderPrimitive> currentRenderPrimitive;

    // State caches.
    DepthStencilStateCache depthStencilStateCache;
@@ -121,8 +108,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.
@@ -153,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"

@@ -134,14 +133,16 @@ private:
        mHandleAllocator.deallocate(handle, p);
    }

-    inline void setRenderPrimitiveBuffer(Handle<HwRenderPrimitive> rph, PrimitiveType pt,
+    inline void setRenderPrimitiveBuffer(Handle<HwRenderPrimitive> rph,
            Handle<HwVertexBuffer> vbh, Handle<HwIndexBuffer> ibh);

+    inline void setRenderPrimitiveRange(Handle<HwRenderPrimitive> rph, PrimitiveType pt,
+            uint32_t offset, uint32_t minIndex, uint32_t maxIndex, uint32_t count);
+
    void finalizeSamplerGroup(MetalSamplerGroup* sg);
    void enumerateBoundBuffers(BufferObjectBinding bindingType,
            const std::function<void(const BufferState&, MetalBuffer*, uint32_t)>& f);

-    backend::StereoscopicType const mStereoscopicType;
 };

 } // namespace backend
@@ -20,7 +20,6 @@
 #include "metal/MetalDriver.h"

 #include "MetalBlitter.h"
-#include "MetalBufferPool.h"
 #include "MetalContext.h"
 #include "MetalDriverFactory.h"
 #include "MetalEnums.h"
@@ -37,7 +36,6 @@

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

 #include <algorithm>

@@ -45,42 +43,6 @@ namespace filament {
 namespace backend {

 Driver* MetalDriverFactory::create(MetalPlatform* const platform, const Platform::DriverConfig& driverConfig) {
-#if 0
-    // this is useful for development, but too verbose even for debug builds
-    // For reference on a 64-bits machine in Release mode:
-    //    MetalTimerQuery              :  16       few
-    //    HwStream                     :  24       few
-    //    MetalRenderPrimitive         :  24       many
-    //    MetalVertexBuffer            :  32       moderate
-    // -- less than or equal 32 bytes
-    //    MetalIndexBuffer             :  40       moderate
-    //    MetalFence                   :  48       few
-    //    MetalBufferObject            :  48       many
-    // -- less than or equal 48 bytes
-    //    MetalSamplerGroup            : 112       few
-    //    MetalProgram                 : 152       moderate
-    //    MetalTexture                 : 152       moderate
-    //    MetalSwapChain               : 184       few
-    //    MetalRenderTarget            : 272       few
-    //    MetalVertexBufferInfo        : 552       moderate
-    // -- less than or equal to 552 bytes
-
-    utils::slog.d
-           << "\nMetalSwapChain: " << sizeof(MetalSwapChain)
-           << "\nMetalBufferObject: " << sizeof(MetalBufferObject)
-           << "\nMetalVertexBuffer: " << sizeof(MetalVertexBuffer)
-           << "\nMetalVertexBufferInfo: " << sizeof(MetalVertexBufferInfo)
-           << "\nMetalIndexBuffer: " << sizeof(MetalIndexBuffer)
-           << "\nMetalSamplerGroup: " << sizeof(MetalSamplerGroup)
-           << "\nMetalRenderPrimitive: " << sizeof(MetalRenderPrimitive)
-           << "\nMetalTexture: " << sizeof(MetalTexture)
-           << "\nMetalTimerQuery: " << sizeof(MetalTimerQuery)
-           << "\nHwStream: " << sizeof(HwStream)
-           << "\nMetalRenderTarget: " << sizeof(MetalRenderTarget)
-           << "\nMetalFence: " << sizeof(MetalFence)
-           << "\nMetalProgram: " << sizeof(MetalProgram)
-           << utils::io::endl;
-#endif
    return MetalDriver::create(platform, driverConfig);
 }

@@ -100,15 +62,9 @@ Dispatcher MetalDriver::getDispatcher() const noexcept {
 MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig& driverConfig) noexcept
        : mPlatform(*platform),
          mContext(new MetalContext(driverConfig.textureUseAfterFreePoolSize)),
-          mHandleAllocator("Handles",
-                  driverConfig.handleArenaSize,
-                  driverConfig.disableHandleUseAfterFreeCheck),
-          mStereoscopicType(driverConfig.stereoscopicType) {
+          mHandleAllocator("Handles", driverConfig.handleArenaSize) {
    mContext->driver = this;

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

@@ -188,10 +144,7 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
        mContext->eventListener = [[MTLSharedEventListener alloc] initWithDispatchQueue:queue];
    }

-    const MetalShaderCompiler::Mode compilerMode = driverConfig.disableParallelShaderCompile
-            ? MetalShaderCompiler::Mode::SYNCHRONOUS
-            : MetalShaderCompiler::Mode::ASYNCHRONOUS;
-    mContext->shaderCompiler = new MetalShaderCompiler(mContext->device, *this, compilerMode);
+    mContext->shaderCompiler = new MetalShaderCompiler(mContext->device, *this);
    mContext->shaderCompiler->init();

 #if defined(FILAMENT_METAL_PROFILING)
@@ -202,8 +155,6 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
 }

 MetalDriver::~MetalDriver() noexcept {
-    TrackedMetalBuffer::setPlatform(nullptr);
-    ScopedAllocationTimer::setPlatform(nullptr);
    mContext->device = nil;
    mContext->emptyTexture = nil;
    CFRelease(mContext->textureCache);
@@ -218,32 +169,22 @@ void MetalDriver::tick(int) {
    executeTickOps();
 }

-void MetalDriver::beginFrame(int64_t monotonic_clock_ns,
-        int64_t refreshIntervalNs, uint32_t frameId) {
+void MetalDriver::beginFrame(int64_t monotonic_clock_ns, uint32_t frameId) {
 #if defined(FILAMENT_METAL_PROFILING)
    os_signpost_interval_begin(mContext->log, mContext->signpostId, "Frame encoding", "%{public}d", frameId);
 #endif
-    if (mPlatform.hasDebugUpdateStatFunc()) {
-        mPlatform.debugUpdateStat("filament.metal.alive_buffers", TrackedMetalBuffer::getAliveBuffers());
-        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));
-    }
 }

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

-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 {
@@ -304,16 +245,10 @@ void MetalDriver::finish(int) {
    [oneOffBuffer waitUntilCompleted];
 }

-void MetalDriver::createVertexBufferInfoR(Handle<HwVertexBufferInfo> vbih, uint8_t bufferCount,
-        uint8_t attributeCount, AttributeArray attributes) {
-    construct_handle<MetalVertexBufferInfo>(vbih, *mContext,
-            bufferCount, attributeCount, attributes);
-}
-
-void MetalDriver::createVertexBufferR(Handle<HwVertexBuffer> vbh,
-        uint32_t vertexCount, Handle<HwVertexBufferInfo> vbih) {
-    MetalVertexBufferInfo const* const vbi = handle_cast<const MetalVertexBufferInfo>(vbih);
-    construct_handle<MetalVertexBuffer>(vbh, *mContext, vertexCount, vbi->bufferCount, vbih);
+void MetalDriver::createVertexBufferR(Handle<HwVertexBuffer> vbh, uint8_t bufferCount,
+        uint8_t attributeCount, uint32_t vertexCount, AttributeArray attributes) {
+    construct_handle<MetalVertexBuffer>(vbh, *mContext, bufferCount,
+            attributeCount, vertexCount, attributes);
 }

 void MetalDriver::createIndexBufferR(Handle<HwIndexBuffer> ibh, ElementType elementType,
@@ -381,9 +316,11 @@ void MetalDriver::createSamplerGroupR(

 void MetalDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph,
        Handle<HwVertexBuffer> vbh, Handle<HwIndexBuffer> ibh,
-        PrimitiveType pt) {
+        PrimitiveType pt, uint32_t offset,
+        uint32_t minIndex, uint32_t maxIndex, uint32_t count) {
    construct_handle<MetalRenderPrimitive>(rph);
-    MetalDriver::setRenderPrimitiveBuffer(rph, pt, vbh, ibh);
+    MetalDriver::setRenderPrimitiveBuffer(rph, vbh, ibh);
+    MetalDriver::setRenderPrimitiveRange(rph, pt, offset, minIndex, maxIndex, count);
 }

 void MetalDriver::createProgramR(Handle<HwProgram> rph, Program&& program) {
@@ -396,7 +333,7 @@ void MetalDriver::createDefaultRenderTargetR(Handle<HwRenderTarget> rth, int dum

 void MetalDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
        TargetBufferFlags targetBufferFlags, uint32_t width, uint32_t height,
-        uint8_t samples, uint8_t layerCount, MRT color,
+        uint8_t samples, MRT color,
        TargetBufferInfo depth, TargetBufferInfo stencil) {
    ASSERT_PRECONDITION(!isInRenderPass(mContext),
            "createRenderTarget must be called outside of a render pass.");
@@ -469,10 +406,6 @@ void MetalDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {
    // nothing to do, timer query was constructed in createTimerQueryS
 }

-Handle<HwVertexBufferInfo> MetalDriver::createVertexBufferInfoS() noexcept {
-    return alloc_handle<MetalVertexBufferInfo>();
-}
-
 Handle<HwVertexBuffer> MetalDriver::createVertexBufferS() noexcept {
    return alloc_handle<MetalVertexBuffer>();
 }
@@ -537,12 +470,6 @@ Handle<HwTimerQuery> MetalDriver::createTimerQueryS() noexcept {
    return alloc_and_construct_handle<MetalTimerQuery, HwTimerQuery>();
 }

-void MetalDriver::destroyVertexBufferInfo(Handle<HwVertexBufferInfo> vbih) {
-    if (vbih) {
-        destruct_handle<MetalVertexBufferInfo>(vbih);
-    }
-}
-
 void MetalDriver::destroyVertexBuffer(Handle<HwVertexBuffer> vbh) {
    if (vbh) {
        destruct_handle<MetalVertexBuffer>(vbh);
@@ -795,36 +722,15 @@ bool MetalDriver::isSRGBSwapChainSupported() {
    return false;
 }

-bool MetalDriver::isProtectedContentSupported() {
-    // the SWAP_CHAIN_CONFIG_PROTECTED_CONTENT flag is not supported
-    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::isParallelShaderCompileSupported() {
-    return mContext->shaderCompiler->isParallelShaderCompileSupported();
-}
-
-bool MetalDriver::isDepthStencilResolveSupported() {
-    return false;
-}
-
-bool MetalDriver::isDepthStencilBlitSupported(TextureFormat format) {
    return true;
 }

-bool MetalDriver::isProtectedTexturesSupported() {
+bool MetalDriver::isParallelShaderCompileSupported() {
+    return true;
+}
+
+bool MetalDriver::isDepthStencilResolveSupported() {
    return false;
 }

@@ -954,10 +860,9 @@ void MetalDriver::setExternalImagePlane(Handle<HwTexture> th, void* image, uint3
 void MetalDriver::setExternalStream(Handle<HwTexture> th, Handle<HwStream> sh) {
 }

-TimerQueryResult MetalDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint64_t* elapsedTime) {
+bool MetalDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint64_t* elapsedTime) {
    auto* tq = handle_cast<MetalTimerQuery>(tqh);
-    return mContext->timerQueryImpl->getQueryResult(tq, elapsedTime) ?
-           TimerQueryResult::AVAILABLE : TimerQueryResult::NOT_READY;
+    return mContext->timerQueryImpl->getQueryResult(tq, elapsedTime);
 }

 void MetalDriver::generateMipmaps(Handle<HwTexture> th) {
@@ -1108,10 +1013,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) {}
@@ -1128,14 +1029,23 @@ void MetalDriver::endRenderPass(int dummy) {
    mContext->currentRenderPassEncoder = nil;
 }

-void MetalDriver::setRenderPrimitiveBuffer(Handle<HwRenderPrimitive> rph, PrimitiveType pt,
+void MetalDriver::setRenderPrimitiveBuffer(Handle<HwRenderPrimitive> rph,
        Handle<HwVertexBuffer> vbh, Handle<HwIndexBuffer> ibh) {
    auto primitive = handle_cast<MetalRenderPrimitive>(rph);
    auto vertexBuffer = handle_cast<MetalVertexBuffer>(vbh);
    auto indexBuffer = handle_cast<MetalIndexBuffer>(ibh);
-    MetalVertexBufferInfo const* const vbi = handle_cast<MetalVertexBufferInfo>(vertexBuffer->vbih);
-    primitive->setBuffers(vbi, vertexBuffer, indexBuffer);
+    primitive->setBuffers(vertexBuffer, indexBuffer);
+}
+
+void MetalDriver::setRenderPrimitiveRange(Handle<HwRenderPrimitive> rph,
+        PrimitiveType pt, uint32_t offset, uint32_t minIndex, uint32_t maxIndex,
+        uint32_t count) {
+    auto primitive = handle_cast<MetalRenderPrimitive>(rph);
    primitive->type = pt;
+    primitive->offset = offset * primitive->indexBuffer->elementSize;
+    primitive->count = count;
+    primitive->minIndex = minIndex;
+    primitive->maxIndex = maxIndex > minIndex ? maxIndex : primitive->maxVertexCount - 1;
 }

 void MetalDriver::makeCurrent(Handle<HwSwapChain> schDraw, Handle<HwSwapChain> schRead) {
@@ -1259,16 +1169,6 @@ void MetalDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
    mContext->samplerBindings[index] = sb;
 }

-void MetalDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
-        backend::PushConstantVariant value) {
-    ASSERT_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);
-}
-
 void MetalDriver::insertEventMarker(const char* string, uint32_t len) {

 }
@@ -1647,13 +1547,10 @@ void MetalDriver::finalizeSamplerGroup(MetalSamplerGroup* samplerGroup) {
    }
 }

-void MetalDriver::bindPipeline(PipelineState const& ps) {
+void MetalDriver::draw(PipelineState ps, Handle<HwRenderPrimitive> rph, uint32_t instanceCount) {
    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder != nullptr,
-            "bindPipeline() without a valid command encoder.");
-
-    MetalVertexBufferInfo const* const vbi =
-            handle_cast<MetalVertexBufferInfo>(ps.vertexBufferInfo);
-
+            "Attempted to draw without a valid command encoder.");
+    auto primitive = handle_cast<MetalRenderPrimitive>(rph);
    auto program = handle_cast<MetalProgram>(ps.program);
    const auto& rs = ps.rasterState;

@@ -1667,7 +1564,7 @@ void MetalDriver::bindPipeline(PipelineState const& ps) {
        return;
    }

-    functions.validate();
+    ASSERT_PRECONDITION(bool(functions), "Attempting to draw with an invalid Metal program.");

    auto [fragment, vertex] = functions.getRasterFunctions();

@@ -1694,7 +1591,7 @@ void MetalDriver::bindPipeline(PipelineState const& ps) {
    MetalPipelineState const pipelineState {
        .vertexFunction = vertex,
        .fragmentFunction = fragment,
-        .vertexDescription = vbi->vertexDescription,
+        .vertexDescription = primitive->vertexDescription,
        .colorAttachmentPixelFormat = {
            colorPixelFormat[0],
            colorPixelFormat[1],
@@ -1788,6 +1685,50 @@ void MetalDriver::bindPipeline(PipelineState const& ps) {
        mContext->currentPolygonOffset = ps.polygonOffset;
    }

+    // Set scissor-rectangle.
+    // In order to do this, we compute the intersection between:
+    //  1. the scissor rectangle
+    //  2. the render target attachment dimensions (important, as the scissor can't be set larger)
+    // fmax/min are used below to guard against NaN and because the MTLViewport/MTLRegion
+    // coordinates are doubles.
+    MTLRegion scissor = mContext->currentRenderTarget->getRegionFromClientRect(ps.scissor);
+    const float sleft = scissor.origin.x, sright = scissor.origin.x + scissor.size.width;
+    const float stop = scissor.origin.y, sbottom = scissor.origin.y + scissor.size.height;
+
+    // Attachment extent
+    const auto attachmentSize = mContext->currentRenderTarget->getAttachmentSize();
+    const float aleft = 0.0f, atop = 0.0f;
+    const float aright = static_cast<float>(attachmentSize.x);
+    const float abottom = static_cast<float>(attachmentSize.y);
+
+    const auto left   = std::fmax(sleft, aleft);
+    const auto right  = std::fmin(sright, aright);
+    const auto top    = std::fmax(stop, atop);
+    const auto bottom = std::fmin(sbottom, abottom);
+
+    MTLScissorRect scissorRect = {
+        .x      = static_cast<NSUInteger>(left),
+        .y      = static_cast<NSUInteger>(top),
+        .width  = static_cast<NSUInteger>(right  - left),
+        .height = static_cast<NSUInteger>(bottom - top)
+    };
+
+    [mContext->currentRenderPassEncoder setScissorRect:scissorRect];
+
+    // Bind uniform buffers.
+    MetalBuffer* uniformsToBind[Program::UNIFORM_BINDING_COUNT] = { nil };
+    NSUInteger offsets[Program::UNIFORM_BINDING_COUNT] = { 0 };
+
+    enumerateBoundBuffers(BufferObjectBinding::UNIFORM,
+            [&uniformsToBind, &offsets](const BufferState& state, MetalBuffer* buffer,
+                    uint32_t index) {
+        uniformsToBind[index] = buffer;
+        offsets[index] = state.offset;
+    });
+    MetalBuffer::bindBuffers(getPendingCommandBuffer(mContext), mContext->currentRenderPassEncoder,
+            UNIFORM_BUFFER_BINDING_START, MetalBuffer::Stage::VERTEX | MetalBuffer::Stage::FRAGMENT,
+            uniformsToBind, offsets, Program::UNIFORM_BINDING_COUNT);
+
    // Bind sampler groups (argument buffers).
    for (size_t s = 0; s < Program::SAMPLER_BINDING_COUNT; s++) {
        MetalSamplerGroup* const samplerGroup = mContext->samplerBindings[s];
@@ -1818,29 +1759,19 @@ void MetalDriver::bindPipeline(PipelineState const& ps) {
                                                          atIndex:(SAMPLER_GROUP_BINDING_START + s)];
        }
    }
-}
-
-void MetalDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
-    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder != nullptr,
-            "bindRenderPrimitive() without a valid command encoder.");

    // Bind the user vertex buffers.
+
    MetalBuffer* vertexBuffers[MAX_VERTEX_BUFFER_COUNT] = {};
    size_t vertexBufferOffsets[MAX_VERTEX_BUFFER_COUNT] = {};
    size_t maxBufferIndex = 0;

-    MetalRenderPrimitive const* const primitive = handle_cast<MetalRenderPrimitive>(rph);
-    MetalVertexBufferInfo const* const vbi =
-            handle_cast<MetalVertexBufferInfo>(primitive->vertexBuffer->vbih);
-
-    mContext->currentRenderPrimitive = rph;
-
    auto vb = primitive->vertexBuffer;
-    for (auto m : vbi->bufferMapping) {
+    for (auto m : primitive->bufferMapping) {
        assert_invariant(
                m.bufferArgumentIndex >= USER_VERTEX_BUFFER_BINDING_START &&
                m.bufferArgumentIndex < USER_VERTEX_BUFFER_BINDING_START + MAX_VERTEX_BUFFER_COUNT);
-        size_t const vertexBufferIndex = m.bufferArgumentIndex - USER_VERTEX_BUFFER_BINDING_START;
+        size_t vertexBufferIndex = m.bufferArgumentIndex - USER_VERTEX_BUFFER_BINDING_START;
        vertexBuffers[vertexBufferIndex] = vb->buffers[m.sourceBufferIndex];
        maxBufferIndex = std::max(maxBufferIndex, vertexBufferIndex);
    }
@@ -1855,58 +1786,19 @@ void MetalDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
    [mContext->currentRenderPassEncoder setVertexBytes:bytes
                                                length:16
                                               atIndex:ZERO_VERTEX_BUFFER_BINDING];
-}
-
-void MetalDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
-    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder != nullptr,
-            "draw() without a valid command encoder.");
-
-    // Bind uniform buffers.
-    MetalBuffer* uniformsToBind[Program::UNIFORM_BINDING_COUNT] = { nil };
-    NSUInteger offsets[Program::UNIFORM_BINDING_COUNT] = { 0 };
-
-    enumerateBoundBuffers(BufferObjectBinding::UNIFORM,
-            [&uniformsToBind, &offsets](const BufferState& state, MetalBuffer* buffer,
-                    uint32_t index) {
-                uniformsToBind[index] = buffer;
-                offsets[index] = state.offset;
-            });
-    MetalBuffer::bindBuffers(getPendingCommandBuffer(mContext), mContext->currentRenderPassEncoder,
-            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;

    id<MTLCommandBuffer> cmdBuffer = getPendingCommandBuffer(mContext);
    id<MTLBuffer> metalIndexBuffer = indexBuffer->buffer.getGpuBufferForDraw(cmdBuffer);
    [mContext->currentRenderPassEncoder drawIndexedPrimitives:getMetalPrimitiveType(primitive->type)
-                                                   indexCount:indexCount
+                                                   indexCount:primitive->count
                                                    indexType:getIndexType(indexBuffer->elementSize)
                                                  indexBuffer:metalIndexBuffer
-                                            indexBufferOffset:indexOffset * primitive->indexBuffer->elementSize
+                                            indexBufferOffset:primitive->offset
                                                instanceCount:instanceCount];
 }

-void MetalDriver::draw(PipelineState ps, Handle<HwRenderPrimitive> rph,
-        uint32_t const indexOffset, uint32_t const indexCount, uint32_t const instanceCount) {
-    MetalRenderPrimitive const* const rp = handle_cast<MetalRenderPrimitive>(rph);
-    ps.primitiveType = rp->type;
-    ps.vertexBufferInfo = rp->vertexBuffer->vbih;
-    bindPipeline(ps);
-    bindRenderPrimitive(rph);
-    draw2(indexOffset, indexCount, instanceCount);
-}
-
 void MetalDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGroupCount) {
    ASSERT_PRECONDITION(!isInRenderPass(mContext),
            "dispatchCompute must be called outside of a render pass.");
@@ -1976,38 +1868,6 @@ void MetalDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGro
    [computeEncoder endEncoding];
 }

-void MetalDriver::scissor(Viewport scissorBox) {
-    // Set scissor-rectangle.
-    // In order to do this, we compute the intersection between:
-    //  1. the scissor rectangle
-    //  2. the render target attachment dimensions (important, as the scissor can't be set larger)
-    // fmax/min are used below to guard against NaN and because the MTLViewport/MTLRegion
-    // coordinates are doubles.
-    MTLRegion scissor = mContext->currentRenderTarget->getRegionFromClientRect(scissorBox);
-    const float sleft = scissor.origin.x, sright = scissor.origin.x + scissor.size.width;
-    const float stop = scissor.origin.y, sbottom = scissor.origin.y + scissor.size.height;
-
-    // Attachment extent
-    const auto attachmentSize = mContext->currentRenderTarget->getAttachmentSize();
-    const float aleft = 0.0f, atop = 0.0f;
-    const float aright = static_cast<float>(attachmentSize.x);
-    const float abottom = static_cast<float>(attachmentSize.y);
-
-    const auto left   = std::fmax(sleft, aleft);
-    const auto right  = std::fmin(sright, aright);
-    const auto top    = std::fmax(stop, atop);
-    const auto bottom = std::fmin(sbottom, abottom);
-
-    MTLScissorRect scissorRect = {
-            .x      = static_cast<NSUInteger>(left),
-            .y      = static_cast<NSUInteger>(top),
-            .width  = static_cast<NSUInteger>(right  - left),
-            .height = static_cast<NSUInteger>(bottom - top)
-    };
-
-    [mContext->currentRenderPassEncoder setScissorRect:scissorRect];
-}
-
 void MetalDriver::beginTimerQuery(Handle<HwTimerQuery> tqh) {
    ASSERT_PRECONDITION(!isInRenderPass(mContext),
            "beginTimerQuery must be called outside of a render pass.");
@@ -31,8 +31,6 @@

 #include "private/backend/SamplerGroup.h"

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

    void releaseDrawable();

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

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

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

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

@@ -147,9 +145,28 @@ private:
    MetalBuffer buffer;
 };

-struct MetalVertexBufferInfo : public HwVertexBufferInfo {
-    MetalVertexBufferInfo(MetalContext& context,
-            uint8_t bufferCount, uint8_t attributeCount, AttributeArray const& attributes);
+struct MetalVertexBuffer : public HwVertexBuffer {
+    MetalVertexBuffer(MetalContext& context, uint8_t bufferCount, uint8_t attributeCount,
+            uint32_t vertexCount, AttributeArray const& attributes);
+
+    utils::FixedCapacityVector<MetalBuffer*> buffers;
+};
+
+struct MetalIndexBuffer : public HwIndexBuffer {
+    MetalIndexBuffer(MetalContext& context, BufferUsage usage, uint8_t elementSize,
+            uint32_t indexCount);
+
+    MetalBuffer buffer;
+};
+
+struct MetalRenderPrimitive : public HwRenderPrimitive {
+    MetalRenderPrimitive();
+    void setBuffers(MetalVertexBuffer* vertexBuffer, MetalIndexBuffer* indexBuffer);
+    // The pointers to MetalVertexBuffer and MetalIndexBuffer are "weak".
+    // The MetalVertexBuffer and MetalIndexBuffer must outlive the MetalRenderPrimitive.
+
+    MetalVertexBuffer* vertexBuffer = nullptr;
+    MetalIndexBuffer* indexBuffer = nullptr;

    // This struct is used to create the pipeline description to describe vertex assembly.
    VertexDescription vertexDescription = {};
@@ -168,32 +185,6 @@ struct MetalVertexBufferInfo : public HwVertexBufferInfo {
    utils::FixedCapacityVector<Entry> bufferMapping;
 };

-struct MetalVertexBuffer : public HwVertexBuffer {
-    MetalVertexBuffer(MetalContext& context,
-            uint32_t vertexCount, uint32_t bufferCount, Handle<HwVertexBufferInfo> vbih);
-
-    Handle<HwVertexBufferInfo> vbih;
-    utils::FixedCapacityVector<MetalBuffer*> buffers;
-};
-
-struct MetalIndexBuffer : public HwIndexBuffer {
-    MetalIndexBuffer(MetalContext& context, BufferUsage usage, uint8_t elementSize,
-            uint32_t indexCount);
-
-    MetalBuffer buffer;
-};
-
-struct MetalRenderPrimitive : public HwRenderPrimitive {
-    MetalRenderPrimitive();
-    void setBuffers(MetalVertexBufferInfo const* const vbi,
-            MetalVertexBuffer* vertexBuffer, MetalIndexBuffer* indexBuffer);
-    // The pointers to MetalVertexBuffer and MetalIndexBuffer are "weak".
-    // The MetalVertexBuffer and MetalIndexBuffer must outlive the MetalRenderPrimitive.
-
-    MetalVertexBuffer* vertexBuffer = nullptr;
-    MetalIndexBuffer* indexBuffer = nullptr;
-};
-
 class MetalProgram : public HwProgram {
 public:
    MetalProgram(MetalContext& context, Program&& program) noexcept;
@@ -19,7 +19,6 @@
 #include "MetalBlitter.h"
 #include "MetalEnums.h"
 #include "MetalUtils.h"
-#include "MetalBufferPool.h"

 #include <filament/SwapChain.h>

@@ -221,16 +220,16 @@ void MetalSwapChain::ensureDepthStencilTexture() {
    depthStencilTexture = [context.device newTextureWithDescriptor:descriptor];
 }

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

-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() {
@@ -238,7 +237,7 @@ void MetalSwapChain::present() {
        scheduleFrameCompletedCallback();
    }
    if (drawable) {
-        if (frameScheduled.callback) {
+        if (frameScheduledCallback) {
            scheduleFrameScheduledCallback();
        } else  {
            [getPendingCommandBuffer(&context) presentDrawable:drawable];
@@ -296,38 +295,21 @@ void presentDrawable(bool presentFrame, void* user) {
 }

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

    assert_invariant(drawable);

-    struct Callback {
-        Callback(std::shared_ptr<FrameScheduledCallback> callback, id<CAMetalDrawable> drawable,
-                MetalDriver* driver)
-            : f(callback), data(PresentDrawableData::create(drawable, driver)) {}
-        std::shared_ptr<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);
-            delete c;
-        }
-    };
+    // Destroy this by calling maybePresentAndDestroyAsync() later.
+    auto* presentData = PresentDrawableData::create(drawable, context.driver);

-    // 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, context.driver);
+    FrameScheduledCallback userCallback = frameScheduledCallback;
+    void* userData = frameScheduledUserData;

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

@@ -336,25 +318,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);
    }];
 }

@@ -370,12 +340,23 @@ void MetalBufferObject::updateBufferUnsynchronized(void* data, size_t size, uint
    buffer.copyIntoBufferUnsynchronized(data, size, byteOffset);
 }

-MetalVertexBufferInfo::MetalVertexBufferInfo(MetalContext& context, uint8_t bufferCount,
-        uint8_t attributeCount, AttributeArray const& attributes)
-        : HwVertexBufferInfo(bufferCount, attributeCount),
-          bufferMapping(utils::FixedCapacityVector<Entry>::with_capacity(MAX_VERTEX_BUFFER_COUNT)) {
+MetalVertexBuffer::MetalVertexBuffer(MetalContext& context, uint8_t bufferCount,
+            uint8_t attributeCount, uint32_t vertexCount, AttributeArray const& attributes)
+    : HwVertexBuffer(bufferCount, attributeCount, vertexCount, attributes), buffers(bufferCount, nullptr) {}

-    const size_t maxAttributeCount = attributes.size();
+MetalIndexBuffer::MetalIndexBuffer(MetalContext& context, BufferUsage usage, uint8_t elementSize,
+        uint32_t indexCount) : HwIndexBuffer(elementSize, indexCount),
+        buffer(context, BufferObjectBinding::VERTEX, usage, elementSize * indexCount, true) { }
+
+MetalRenderPrimitive::MetalRenderPrimitive()
+    : bufferMapping(utils::FixedCapacityVector<Entry>::with_capacity(MAX_VERTEX_BUFFER_COUNT)) {}
+
+void MetalRenderPrimitive::setBuffers(MetalVertexBuffer* vertexBuffer, MetalIndexBuffer*
+        indexBuffer) {
+    this->vertexBuffer = vertexBuffer;
+    this->indexBuffer = indexBuffer;
+
+    const size_t attributeCount = vertexBuffer->attributes.size();

    auto& mapping = bufferMapping;
    mapping.clear();
@@ -415,8 +396,8 @@ MetalVertexBufferInfo::MetalVertexBufferInfo(MetalContext& context, uint8_t buff
        }
    };

-    for (uint32_t attributeIndex = 0; attributeIndex < maxAttributeCount; attributeIndex++) {
-        const auto& attribute = attributes[attributeIndex];
+    for (uint32_t attributeIndex = 0; attributeIndex < attributeCount; attributeIndex++) {
+        const auto& attribute = vertexBuffer->attributes[attributeIndex];

        // If the attribute is unused, bind it to the zero buffer. It's a Metal error for a shader
        // to read from missing vertex attributes.
@@ -443,24 +424,6 @@ MetalVertexBufferInfo::MetalVertexBufferInfo(MetalContext& context, uint8_t buff
    }
 }

-MetalVertexBuffer::MetalVertexBuffer(MetalContext& context,
-        uint32_t vertexCount, uint32_t bufferCount, Handle<HwVertexBufferInfo> vbih)
-    : HwVertexBuffer(vertexCount), vbih(vbih), buffers(bufferCount, nullptr) {
-}
-
-MetalIndexBuffer::MetalIndexBuffer(MetalContext& context, BufferUsage usage, uint8_t elementSize,
-        uint32_t indexCount) : HwIndexBuffer(elementSize, indexCount),
-        buffer(context, BufferObjectBinding::VERTEX, usage, elementSize * indexCount, true) { }
-
-MetalRenderPrimitive::MetalRenderPrimitive() {
-}
-
-void MetalRenderPrimitive::setBuffers(MetalVertexBufferInfo const* const vbi,
-        MetalVertexBuffer* vertexBuffer, MetalIndexBuffer* indexBuffer) {
-    this->vertexBuffer = vertexBuffer;
-    this->indexBuffer = indexBuffer;
-}
-
 MetalProgram::MetalProgram(MetalContext& context, Program&& program) noexcept
    : HwProgram(program.getName()), mContext(context) {

@@ -800,13 +763,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
@@ -30,8 +30,6 @@

 #include <array>
 #include <memory>
-#include <tuple>
-#include <variant>

 namespace filament::backend {

@@ -41,81 +39,43 @@ class MetalShaderCompiler {
    struct MetalProgramToken;

 public:
-    enum class Mode {
-        SYNCHRONOUS,    // synchronous shader compilation
-        ASYNCHRONOUS    // asynchronous shader compilation
-    };
-
    class MetalFunctionBundle {
    public:
-        using Raster = std::tuple<id<MTLFunction>, id<MTLFunction>>;
-        using Compute = id<MTLFunction>;
-        using Error = std::tuple<NSString*, NSString*>; // error message, Program name
-        struct None {};
-
-        MetalFunctionBundle() : mPrograms{None{}} {}
-
-        explicit operator bool() const { return isValid(); }
-
-        bool isValid() const noexcept {
-            return std::holds_alternative<Raster>(mPrograms) ||
-                std::holds_alternative<Compute>(mPrograms);
-        }
-
-        /**
-         * Throws an NSException if this MetalFunctionBundle either contains an error or is empty.
-         *
-         * If this MetalFunctionBundle contains an error, will throw a MetalCompilationFailure
-         * NSException with the error string and program name passed to
-         * MetalFunctionBundle::error(NSString*, NSString*).
-         *
-         * If this MetalFunctionBundle is empty, will throw a MetalEmptyFunctionBundle NSException.
-         */
-        void validate() const;
-
-        Raster getRasterFunctions() const {
-            assert_invariant(std::holds_alternative<Raster>(mPrograms));
-            return std::get<Raster>(mPrograms);
-        }
-
-        Compute getComputeFunction() const {
-            assert_invariant(std::holds_alternative<Compute>(mPrograms));
-            return std::get<Compute>(mPrograms);
-        }
-
-        static MetalFunctionBundle none() {
-            return MetalFunctionBundle(None{});
-        }
-
-        static MetalFunctionBundle raster(id<MTLFunction> fragment, id<MTLFunction> vertex) {
+        MetalFunctionBundle() = default;
+        MetalFunctionBundle(id<MTLFunction> fragment, id<MTLFunction> vertex)
+            : functions{fragment, vertex} {
            assert_invariant(fragment && vertex);
            assert_invariant(fragment.functionType == MTLFunctionTypeFragment);
            assert_invariant(vertex.functionType == MTLFunctionTypeVertex);
-            return MetalFunctionBundle(Raster{fragment, vertex});
        }
-
-        static MetalFunctionBundle compute(id<MTLFunction> compute) {
+        explicit MetalFunctionBundle(id<MTLFunction> compute) : functions{compute, nil} {
            assert_invariant(compute);
            assert_invariant(compute.functionType == MTLFunctionTypeKernel);
-            return MetalFunctionBundle(Compute{compute});
        }

-        static MetalFunctionBundle error(NSString* errorMessage, NSString* programName) {
-            return MetalFunctionBundle(Error{errorMessage, programName});
+        std::pair<id<MTLFunction>, id<MTLFunction>> getRasterFunctions() const noexcept {
+            assert_invariant(functions[0].functionType == MTLFunctionTypeFragment);
+            assert_invariant(functions[1].functionType == MTLFunctionTypeVertex);
+            return {functions[0], functions[1]};
        }

+        id<MTLFunction> getComputeFunction() const noexcept {
+            assert_invariant(functions[0].functionType == MTLFunctionTypeKernel);
+            return functions[0];
+        }
+
+        explicit operator bool() const { return functions[0] != nil; }
+
    private:
-        MetalFunctionBundle(None&& t) : mPrograms(std::move(t)) {}
-        MetalFunctionBundle(Raster&& t) : mPrograms(std::move(t)) {}
-        MetalFunctionBundle(Compute&& t) : mPrograms(std::move(t)) {}
-        MetalFunctionBundle(Error&& t) : mPrograms(std::move(t)) {}
-
-        std::variant<Raster, Compute, None, Error> mPrograms;
+        // Can hold two functions, either:
+        // - fragment and vertex (for rasterization pipelines)
+        // - compute (for compute pipelines)
+        id<MTLFunction> functions[2] = {nil, nil};
    };

    using program_token_t = std::shared_ptr<MetalProgramToken>;

-    explicit MetalShaderCompiler(id<MTLDevice> device, MetalDriver& driver, Mode mode);
+    explicit MetalShaderCompiler(id<MTLDevice> device, MetalDriver& driver);

    MetalShaderCompiler(MetalShaderCompiler const& rhs) = delete;
    MetalShaderCompiler(MetalShaderCompiler&& rhs) = delete;
@@ -125,15 +85,15 @@ public:
    void init() noexcept;
    void terminate() noexcept;

-    bool isParallelShaderCompileSupported() const noexcept;
-
-    // Creates a program, either synchronously or asynchronously, depending on the Mode
-    // MetalShaderCompiler was constructed with.
+    // Creates a program asynchronously
    program_token_t createProgram(utils::CString const& name, Program&& program);

    // Returns the functions, blocking if necessary. The Token is destroyed and becomes invalid.
    MetalFunctionBundle getProgram(program_token_t& token);

+    // Destroys a valid token and all associated resources. Used to "cancel" a program compilation.
+    static void terminate(program_token_t& token);
+
    void notifyWhenAllProgramsAreReady(
            CallbackHandler* handler, CallbackHandler::Callback callback, void* user);

@@ -143,7 +103,6 @@ private:
    CompilerThreadPool mCompilerThreadPool;
    id<MTLDevice> mDevice;
    CallbackManager mCallbackManager;
-    Mode mMode;
 };

 } // namespace filament::backend
@@ -70,31 +70,22 @@ struct MetalShaderCompiler::MetalProgramToken : ProgramToken {

 MetalShaderCompiler::MetalProgramToken::~MetalProgramToken() = default;

-MetalShaderCompiler::MetalShaderCompiler(id<MTLDevice> device, MetalDriver& driver, Mode mode)
+MetalShaderCompiler::MetalShaderCompiler(id<MTLDevice> device, MetalDriver& driver)
        : mDevice(device),
-          mCallbackManager(driver),
-          mMode(mode) {
+          mCallbackManager(driver) {

 }

 void MetalShaderCompiler::init() noexcept {
-    const uint32_t poolSize = 1;
-    if (mMode == Mode::ASYNCHRONOUS) {
-        mCompilerThreadPool.init(poolSize, []() {}, []() {});
-    }
+    const uint32_t poolSize = 2;
+    mCompilerThreadPool.init(poolSize, []() {}, []() {});
 }

 void MetalShaderCompiler::terminate() noexcept {
-    if (mMode == Mode::ASYNCHRONOUS) {
-        mCompilerThreadPool.terminate();
-    }
+    mCompilerThreadPool.terminate();
    mCallbackManager.terminate();
 }

-bool MetalShaderCompiler::isParallelShaderCompileSupported() const noexcept {
-    return mMode == Mode::ASYNCHRONOUS;
-}
-
 /* static */ MetalShaderCompiler::MetalFunctionBundle MetalShaderCompiler::compileProgram(
        const Program& program, id<MTLDevice> device) {
    std::array<id<MTLFunction>, Program::SHADER_TYPE_COUNT> functions = { nil };
@@ -106,52 +97,34 @@ bool MetalShaderCompiler::isParallelShaderCompileSupported() const noexcept {
            continue;
        }

+        assert_invariant(source[source.size() - 1] == '\0');
+
+        // the shader string is null terminated and the length includes the null character
+        NSString* objcSource = [[NSString alloc] initWithBytes:source.data()
+                                                        length:source.size() - 1
+                                                      encoding:NSUTF8StringEncoding];
+
+        // By default, Metal uses the most recent language version.
+        MTLCompileOptions* options = [MTLCompileOptions new];
+
+        // Disable Fast Math optimizations.
+        // This ensures that operations adhere to IEEE standards for floating-point arithmetic,
+        // which is crucial for half precision floats in scenarios where fast math optimizations
+        // lead to inaccuracies, such as in handling special values like NaN or Infinity.
+        options.fastMathEnabled = NO;
+
        NSError* error = nil;
-        id<MTLLibrary> library = nil;
-        switch (program.getShaderLanguage()) {
-            case ShaderLanguage::MSL: {
-                // By default, Metal uses the most recent language version.
-                MTLCompileOptions* options = [MTLCompileOptions new];
-
-                // Disable Fast Math optimizations.
-                // This ensures that operations adhere to IEEE standards for floating-point
-                // arithmetic, which is crucial for half precision floats in scenarios where fast
-                // math optimizations lead to inaccuracies, such as in handling special values like
-                // NaN or Infinity.
-                options.fastMathEnabled = NO;
-
-                assert_invariant(source[source.size() - 1] == '\0');
-                // the shader string is null terminated and the length includes the null character
-                NSString* objcSource = [[NSString alloc] initWithBytes:source.data()
-                                                                length:source.size() - 1
-                                                              encoding:NSUTF8StringEncoding];
-                library = [device newLibraryWithSource:objcSource options:options error:&error];
-                break;
-            }
-            case ShaderLanguage::METAL_LIBRARY: {
-                dispatch_data_t data = dispatch_data_create(source.data(), source.size(),
-                        dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
-                        DISPATCH_DATA_DESTRUCTOR_DEFAULT);
-                library = [device newLibraryWithData:data error:&error];
-                break;
-            }
-            case ShaderLanguage::ESSL1:
-            case ShaderLanguage::ESSL3:
-            case ShaderLanguage::SPIRV:
-                break;
-        }
-
+        id<MTLLibrary> library = [device newLibraryWithSource:objcSource
+                                                      options:options
+                                                        error:&error];
        if (library == nil) {
-            NSString* errorMessage = @"unknown error";
            if (error) {
                auto description =
                        [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
                utils::slog.w << description << utils::io::endl;
-                errorMessage = error.localizedDescription;
            }
            PANIC_LOG("Failed to compile Metal program.");
-            NSString* programName = [NSString stringWithFormat:@"%s", program.getName().c_str_safe()];
-            return MetalFunctionBundle::error(errorMessage, programName);
+            return {};
        }

        MTLFunctionConstantValues* constants = [MTLFunctionConstantValues new];
@@ -169,23 +142,6 @@ bool MetalShaderCompiler::isParallelShaderCompileSupported() const noexcept {
        id<MTLFunction> function = [library newFunctionWithName:@"main0"
                                                 constantValues:constants
                                                          error:&error];
-        if (function == nil) {
-            // If the library loads but functions within it fail to load, it usually means the
-            // GPU backend crashed. (This can happen if it's a Metallib shader that was compiled
-            // with a minimum iOS version that's newer than this device.)
-            NSString* errorMessage = @"unknown error";
-            if (error) {
-                auto description =
-                        [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
-                utils::slog.w << description << utils::io::endl;
-                errorMessage = error.localizedDescription;
-            }
-            PANIC_LOG("Failed to load main0 in Metal program.");
-            NSString* programName =
-                [NSString stringWithFormat:@"%s::main0", program.getName().c_str_safe()];
-            return MetalFunctionBundle::error(errorMessage, programName);
-        }
-
        if (!program.getName().empty()) {
            function.label = @(program.getName().c_str());
        }
@@ -204,15 +160,14 @@ bool MetalShaderCompiler::isParallelShaderCompileSupported() const noexcept {
    assert_invariant(isRasterizationProgram != isComputeProgram);

    if (isRasterizationProgram) {
-        return MetalFunctionBundle::raster(fragmentFunction, vertexFunction);
+        return {fragmentFunction, vertexFunction};
    }

    if (isComputeProgram) {
-        return MetalFunctionBundle::compute(computeFunction);
+        return MetalFunctionBundle{computeFunction};
    }

-    // Should never reach here.
-    return MetalFunctionBundle::none();
+    return {};
 }

 MetalShaderCompiler::program_token_t MetalShaderCompiler::createProgram(
@@ -221,26 +176,14 @@ MetalShaderCompiler::program_token_t MetalShaderCompiler::createProgram(

    token->handle = mCallbackManager.get();

-    switch (mMode) {
-        case Mode::ASYNCHRONOUS: {
-            CompilerPriorityQueue const priorityQueue = program.getPriorityQueue();
-            mCompilerThreadPool.queue(priorityQueue, token,
-                    [this, name, device = mDevice, program = std::move(program), token]() {
-                        MetalFunctionBundle compiledProgram = compileProgram(program, device);
-                        token->set(compiledProgram);
-                        mCallbackManager.put(token->handle);
-                    });
+    CompilerPriorityQueue const priorityQueue = program.getPriorityQueue();
+    mCompilerThreadPool.queue(priorityQueue, token,
+            [this, name, device = mDevice, program = std::move(program), token]() {
+                MetalFunctionBundle compiledProgram = compileProgram(program, device);

-            break;
-        }
-
-        case Mode::SYNCHRONOUS: {
-            MetalFunctionBundle compiledProgram = compileProgram(program, mDevice);
-            token->set(compiledProgram);
-            mCallbackManager.put(token->handle);
-            break;
-        }
-    }
+                token->set(compiledProgram);
+                mCallbackManager.put(token->handle);
+            });

    return token;
 }
@@ -248,46 +191,38 @@ MetalShaderCompiler::program_token_t MetalShaderCompiler::createProgram(
 MetalShaderCompiler::MetalFunctionBundle MetalShaderCompiler::getProgram(program_token_t& token) {
    assert_invariant(token);

-    if (mMode == Mode::ASYNCHRONOUS) {
-        if (!token->isReady()) {
-            auto job = mCompilerThreadPool.dequeue(token);
-            if (job) {
-                job();
-            }
+    if (!token->isReady()) {
+        auto job = mCompilerThreadPool.dequeue(token);
+        if (job) {
+            job();
        }
    }

-    // The job isn't guaranteed to have finished yet. We may have failed to dequeue it above,
-    // which means it's currently running. In that case get() will block until it finishes.
-
    MetalShaderCompiler::MetalFunctionBundle program = token->get();
+
    token = nullptr;
+
    return program;
 }

+/* static */ void MetalShaderCompiler::terminate(program_token_t& token) {
+    assert_invariant(token);
+
+    auto job = token->compiler.mCompilerThreadPool.dequeue(token);
+    if (!job) {
+        // The job is being executed right now (or has already executed).
+        token->wait();
+    } else {
+        // The job has not executed yet.
+        token->compiler.mCallbackManager.put(token->handle);
+    }
+
+    token.reset();
+}
+
 void MetalShaderCompiler::notifyWhenAllProgramsAreReady(
        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
    mCallbackManager.setCallback(handler, callback, user);
 }

-UTILS_NOINLINE
-void MetalShaderCompiler::MetalFunctionBundle::validate() const {
-    if (UTILS_UNLIKELY(std::holds_alternative<Error>(mPrograms))) {
-        auto [errorMessage, programName] = std::get<Error>(mPrograms);
-        NSString* reason =
-                [NSString stringWithFormat:
-                        @"Attempting to draw with an id<MTLFunction> that failed to compile.\n"
-                        @"Program: %@\n"
-                        @"%@", programName, errorMessage];
-        [[NSException exceptionWithName:@"MetalCompilationFailure"
-                                reason:reason
-                              userInfo:nil] raise];
-    } else if (UTILS_UNLIKELY(std::holds_alternative<None>(mPrograms))) {
-        NSString* reason = @"Attempting to draw with an empty id<MTLFunction>.";
-        [[NSException exceptionWithName:@"MetalEmptyFunctionBundle"
-                                reason:reason
-                              userInfo:nil] raise];
-    }
-}
-
 } // namespace filament::backend
@@ -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,15 +90,9 @@ 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];
    }
    ASSERT_POSTCONDITION(error == nil, "Could not create Metal pipeline state.");

@@ -49,17 +49,16 @@ void NoopDriver::terminate() {
 void NoopDriver::tick(int) {
 }

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

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

 }

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

 }

@@ -78,9 +77,6 @@ void NoopDriver::finish(int) {
 void NoopDriver::destroyRenderPrimitive(Handle<HwRenderPrimitive> rph) {
 }

-void NoopDriver::destroyVertexBufferInfo(Handle<HwVertexBufferInfo> vbih) {
-}
-
 void NoopDriver::destroyVertexBuffer(Handle<HwVertexBuffer> vbh) {
 }

@@ -178,10 +174,6 @@ bool NoopDriver::isSRGBSwapChainSupported() {
    return false;
 }

-bool NoopDriver::isProtectedContentSupported() {
-    return false;
-}
-
 bool NoopDriver::isStereoSupported() {
    return false;
 }
@@ -194,14 +186,6 @@ bool NoopDriver::isDepthStencilResolveSupported() {
    return true;
 }

-bool NoopDriver::isDepthStencilBlitSupported(TextureFormat format) {
-    return true;
-}
-
-bool NoopDriver::isProtectedTexturesSupported() {
-    return true;
-}
-
 bool NoopDriver::isWorkaroundNeeded(Workaround) {
    return false;
 }
@@ -257,8 +241,8 @@ void NoopDriver::update3DImage(Handle<HwTexture> th,
 void NoopDriver::setupExternalImage(void* image) {
 }

-TimerQueryResult NoopDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint64_t* elapsedTime) {
-    return TimerQueryResult::ERROR;
+bool NoopDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint64_t* elapsedTime) {
+    return false;
 }

 void NoopDriver::setExternalImage(Handle<HwTexture> th, void* image) {
@@ -312,10 +296,6 @@ void NoopDriver::unbindBuffer(BufferObjectBinding bindingType, uint32_t index) {
 void NoopDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
 }

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

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

-void NoopDriver::bindPipeline(PipelineState const& pipelineState) {
-}
-
-void NoopDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
-}
-
-void NoopDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
-}
-
 void NoopDriver::draw(PipelineState pipelineState, Handle<HwRenderPrimitive> rph,
-        uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
+        uint32_t instanceCount) {
 }

 void NoopDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGroupCount) {
 }

-void NoopDriver::scissor(
-        Viewport scissor) {
-}
-
 void NoopDriver::beginTimerQuery(Handle<HwTimerQuery> tqh) {
 }

@@ -1,51 +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.
- */
-
-#ifndef TNT_FILAMENT_BACKEND_OPENGL_GLBUFFEROBJECT_H
-#define TNT_FILAMENT_BACKEND_OPENGL_GLBUFFEROBJECT_H
-
-#include "DriverBase.h"
-
-#include "gl_headers.h"
-
-#include <backend/DriverEnums.h>
-
-#include <stdint.h>
-
-namespace filament::backend {
-
-struct GLBufferObject : public HwBufferObject {
-    using HwBufferObject::HwBufferObject;
-    GLBufferObject(uint32_t size,
-            BufferObjectBinding bindingType, BufferUsage usage) noexcept
-            : HwBufferObject(size), usage(usage), bindingType(bindingType) {
-    }
-
-    struct {
-        GLuint id;
-        union {
-            GLenum binding;
-            void* buffer;
-        };
-    } gl;
-    BufferUsage usage;
-    BufferObjectBinding bindingType;
-    uint16_t age = 0;
-};
-
-} // namespace filament::backend
-
-#endif //TNT_FILAMENT_BACKEND_OPENGL_GLBUFFEROBJECT_H
@@ -1,55 +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.
- */
-
-#ifndef TNT_FILAMENT_BACKEND_OPENGL_GLTEXTURE_H
-#define TNT_FILAMENT_BACKEND_OPENGL_GLTEXTURE_H
-
-#include "DriverBase.h"
-
-#include "gl_headers.h"
-
-#include <backend/platforms/OpenGLPlatform.h>
-
-#include <stdint.h>
-
-namespace filament::backend {
-
-struct GLTexture : public HwTexture {
-    using HwTexture::HwTexture;
-    struct GL {
-        GL() noexcept : imported(false), sidecarSamples(1), reserved1(0) {}
-        GLuint id = 0;          // texture or renderbuffer id
-        GLenum target = 0;
-        GLenum internalFormat = 0;
-        GLuint sidecarRenderBufferMS = 0;  // multi-sample sidecar renderbuffer
-
-        // texture parameters go here too
-        GLfloat anisotropy = 1.0;
-        int8_t baseLevel = 127;
-        int8_t maxLevel = -1;
-        uint8_t reserved0 = 0;
-        bool imported           : 1;
-        uint8_t sidecarSamples  : 4;
-        uint8_t reserved1       : 3;
-    } gl;
-
-    OpenGLPlatform::ExternalTexture* externalTexture = nullptr;
-};
-
-
-} // namespace filament::backend
-
-#endif //TNT_FILAMENT_BACKEND_OPENGL_GLTEXTURE_H
@@ -16,25 +16,10 @@

 #include "OpenGLContext.h"

-#include "GLUtils.h"
-#include "OpenGLTimerQuery.h"
-
 #include <backend/platforms/OpenGLPlatform.h>
-#include <backend/DriverEnums.h>

-#include <utils/compiler.h>
-#include <utils/debug.h>
-#include <utils/Log.h>
-#include <utils/ostream.h>
-
-#include <functional>
-#include <string_view>
 #include <utility>

-#include <stddef.h>
-#include <stdio.h>
-#include <string.h>
-
 // change to true to display all GL extensions in the console on start-up
 #define DEBUG_PRINT_EXTENSIONS false

@@ -63,11 +48,7 @@ bool OpenGLContext::queryOpenGLVersion(GLint* major, GLint* minor) noexcept {
 #endif
 }

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

    state.vao.p = &mDefaultVAO;

@@ -87,13 +68,6 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,

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

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

    OpenGLContext::initProcs(&procs, ext, state.major, state.minor);
@@ -257,63 +231,6 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
        glDebugMessageCallback(cb, nullptr);
    }
 #endif
-
-    mTimerQueryFactory = TimerQueryFactory::init(platform, *this);
-}
-
-OpenGLContext::~OpenGLContext() noexcept {
-    // note: this is called from the main thread. Can't do any GL calls.
-    delete mTimerQueryFactory;
-}
-
-void OpenGLContext::terminate() noexcept {
-    // note: this is called from the backend thread
-#ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
-    if (!isES2()) {
-        for (auto& item: mSamplerMap) {
-            unbindSampler(item.second);
-            glDeleteSamplers(1, &item.second);
-        }
-        mSamplerMap.clear();
-    }
-#endif
-}
-
-void OpenGLContext::destroyWithContext(
-        size_t index, std::function<void(OpenGLContext&)> const& closure) noexcept {
-    if (index == 0) {
-        // Note: we only need to delay the destruction of objects on the unprotected context
-        // (index 0) because the protected context is always immediately destroyed and all its
-        // active objects and bindings are then automatically destroyed.
-        // TODO: this is only guaranteed for EGLPlatform, but that's the only one we care about.
-        mDestroyWithNormalContext.push_back(closure);
-    }
-}
-
-void OpenGLContext::unbindEverything() noexcept {
-    // TODO:  we're supposed to unbind everything here so that resources don't get
-    //        stuck in this context (contextIndex) when destroyed in the other context.
-    //        However, because EGLPlatform always immediately destroys the protected context (1),
-    //        the bindings will automatically be severed when we switch back to the default context.
-    //        Since bindings now only exist in one context, we don't have a ref-counting issue to
-    //        worry about.
-}
-
-void OpenGLContext::synchronizeStateAndCache(size_t index) noexcept {
-
-    // if we're just switching back to context 0, run all the pending destructors
-    if (index == 0) {
-        auto list = std::move(mDestroyWithNormalContext);
-        for (auto&& fn: list) {
-            fn(*this);
-        }
-    }
-
-    // the default FBO could be invalid
-    mDefaultFbo[index].reset();
-
-    contextIndex = index;
-    resetState();
 }

 void OpenGLContext::setDefaultState() noexcept {
@@ -367,8 +284,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);
    }
@@ -541,6 +457,8 @@ void OpenGLContext::initBugs(Bugs* bugs, Extensions const& exts,
            bugs->delay_fbo_destruction = true;
            // PowerVR seems to have no problem with this (which is good for us)
            bugs->allow_read_only_ancillary_feedback_loop = true;
+            // PowerVR has a shader compiler thread pinned on the last core
+            bugs->disable_thread_affinity = true;
        } else if (strstr(renderer, "Apple")) {
            // Apple GPU
        } else if (strstr(renderer, "Tegra") ||
@@ -681,7 +599,6 @@ void OpenGLContext::initExtensionsGLES(Extensions* ext, GLint major, GLint minor
    ext->EXT_disjoint_timer_query = exts.has("GL_EXT_disjoint_timer_query"sv);
    ext->EXT_multisampled_render_to_texture = exts.has("GL_EXT_multisampled_render_to_texture"sv);
    ext->EXT_multisampled_render_to_texture2 = exts.has("GL_EXT_multisampled_render_to_texture2"sv);
-    ext->EXT_protected_textures = exts.has("GL_EXT_protected_textures"sv);
 #endif
    ext->EXT_shader_framebuffer_fetch = exts.has("GL_EXT_shader_framebuffer_fetch"sv);
 #ifndef __EMSCRIPTEN__
@@ -705,7 +622,6 @@ void OpenGLContext::initExtensionsGLES(Extensions* ext, GLint major, GLint minor
    ext->OES_standard_derivatives = exts.has("GL_OES_standard_derivatives"sv);
    ext->OES_texture_npot = exts.has("GL_OES_texture_npot"sv);
    ext->OES_vertex_array_object = exts.has("GL_OES_vertex_array_object"sv);
-    ext->OVR_multiview2 = exts.has("GL_OVR_multiview2"sv);
    ext->WEBGL_compressed_texture_etc = exts.has("WEBGL_compressed_texture_etc"sv);
    ext->WEBGL_compressed_texture_s3tc = exts.has("WEBGL_compressed_texture_s3tc"sv);
    ext->WEBGL_compressed_texture_s3tc_srgb = exts.has("WEBGL_compressed_texture_s3tc_srgb"sv);
@@ -770,7 +686,6 @@ void OpenGLContext::initExtensionsGL(Extensions* ext, GLint major, GLint minor)
    ext->OES_standard_derivatives = true;
    ext->OES_texture_npot = true;
    ext->OES_vertex_array_object = true;
-    ext->OVR_multiview2 = exts.has("GL_OVR_multiview2"sv);
    ext->WEBGL_compressed_texture_etc = false;
    ext->WEBGL_compressed_texture_s3tc = false;
    ext->WEBGL_compressed_texture_s3tc_srgb = false;
@@ -792,51 +707,6 @@ void OpenGLContext::initExtensionsGL(Extensions* ext, GLint major, GLint minor)

 #endif // BACKEND_OPENGL_VERSION_GL

-
-GLuint OpenGLContext::bindFramebuffer(GLenum target, GLuint buffer) noexcept {
-    if (UTILS_UNLIKELY(buffer == 0)) {
-        // we're binding the default frame buffer, resolve its actual name
-        auto& defaultFboForThisContext = mDefaultFbo[contextIndex];
-        if (UTILS_UNLIKELY(!defaultFboForThisContext.has_value())) {
-            defaultFboForThisContext = GLuint(mPlatform.getDefaultFramebufferObject());
-        }
-        buffer = defaultFboForThisContext.value();
-    }
-    bindFramebufferResolved(target, buffer);
-    return buffer;
-}
-
-void OpenGLContext::unbindFramebuffer(GLenum target) noexcept {
-    bindFramebufferResolved(target, 0);
-}
-
-void OpenGLContext::bindFramebufferResolved(GLenum target, GLuint buffer) noexcept {
-    switch (target) {
-        case GL_FRAMEBUFFER:
-            if (state.draw_fbo != buffer || state.read_fbo != buffer) {
-                state.draw_fbo = state.read_fbo = buffer;
-                glBindFramebuffer(target, buffer);
-            }
-            break;
-#ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
-        case GL_DRAW_FRAMEBUFFER:
-            if (state.draw_fbo != buffer) {
-                state.draw_fbo = buffer;
-                glBindFramebuffer(target, buffer);
-            }
-            break;
-        case GL_READ_FRAMEBUFFER:
-            if (state.read_fbo != buffer) {
-                state.read_fbo = buffer;
-                glBindFramebuffer(target, buffer);
-            }
-            break;
-#endif
-        default:
-            break;
-    }
-}
-
 void OpenGLContext::bindBuffer(GLenum target, GLuint buffer) noexcept {
    if (target == GL_ELEMENT_ARRAY_BUFFER) {
        constexpr size_t targetIndex = getIndexForBufferTarget(GL_ELEMENT_ARRAY_BUFFER);
@@ -891,32 +761,19 @@ default_case:
    }
 }

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

-void OpenGLContext::unbindTextureUnit(GLuint unit) noexcept {
-    update_state(state.textures.units[unit].id, 0u, [&]() {
-        activeTexture(unit);
-        glBindTexture(state.textures.units[unit].target, 0u);
-    });
-}
-
 void OpenGLContext::unbindSampler(GLuint sampler) noexcept {
    // unbind this sampler from all the units it might be bound to
    UTILS_NOUNROLL  // clang generates >800B of code!!!
@@ -960,53 +817,19 @@ void OpenGLContext::deleteBuffers(GLsizei n, const GLuint* buffers, GLenum targe
 #endif
 }

-void OpenGLContext::deleteVertexArray(GLuint vao) noexcept {
-    if (UTILS_LIKELY(vao)) {
-        procs.deleteVertexArrays(1, &vao);
-        // if the destroyed VAO is bound, clear the binding.
-        if (state.vao.p->vao[contextIndex] == vao) {
+void OpenGLContext::deleteVertexArrays(GLsizei n, const GLuint* arrays) noexcept {
+    procs.deleteVertexArrays(n, arrays);
+    // if one of the destroyed VAO is bound, clear the binding.
+    for (GLsizei i = 0; i < n; ++i) {
+        if (state.vao.p->vao == arrays[i]) {
            bindVertexArray(nullptr);
+            break;
        }
    }
 }

-#ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
-GLuint OpenGLContext::getSamplerSlow(SamplerParams params) const noexcept {
-    assert_invariant(mSamplerMap.find(params) == mSamplerMap.end());
-
-    using namespace GLUtils;
-
-    GLuint s;
-    glGenSamplers(1, &s);
-    glSamplerParameteri(s, GL_TEXTURE_MIN_FILTER,   (GLint)getTextureFilter(params.filterMin));
-    glSamplerParameteri(s, GL_TEXTURE_MAG_FILTER,   (GLint)getTextureFilter(params.filterMag));
-    glSamplerParameteri(s, GL_TEXTURE_WRAP_S,       (GLint)getWrapMode(params.wrapS));
-    glSamplerParameteri(s, GL_TEXTURE_WRAP_T,       (GLint)getWrapMode(params.wrapT));
-    glSamplerParameteri(s, GL_TEXTURE_WRAP_R,       (GLint)getWrapMode(params.wrapR));
-    glSamplerParameteri(s, GL_TEXTURE_COMPARE_MODE, (GLint)getTextureCompareMode(params.compareMode));
-    glSamplerParameteri(s, GL_TEXTURE_COMPARE_FUNC, (GLint)getTextureCompareFunc(params.compareFunc));
-
-#if defined(GL_EXT_texture_filter_anisotropic)
-    if (ext.EXT_texture_filter_anisotropic &&
-        !bugs.texture_filter_anisotropic_broken_on_sampler) {
-        GLfloat const anisotropy = float(1u << params.anisotropyLog2);
-        glSamplerParameterf(s, GL_TEXTURE_MAX_ANISOTROPY_EXT,
-                std::min(gets.max_anisotropy, anisotropy));
-    }
-#endif
-    CHECK_GL_ERROR(utils::slog.e)
-    mSamplerMap[params] = s;
-    return s;
-}
-#endif
-
-
 void OpenGLContext::resetState() noexcept {
    // Force GL state to match the Filament state
-
-    // increase the state version so other parts of the state know to reset
-    state.age++;
-
    if (state.major > 2) {
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, state.draw_fbo);
@@ -1023,8 +846,11 @@ void OpenGLContext::resetState() noexcept {
    glUseProgram(state.program.use);

    // state.vao
-    state.vao.p = nullptr;
-    bindVertexArray(nullptr);
+    if (state.vao.p) {
+        procs.bindVertexArray(state.vao.p->vao);
+    } else {
+        bindVertexArray(nullptr);
+    }

    // state.raster
    glFrontFace(state.raster.frontFace);
@@ -1180,22 +1006,7 @@ void OpenGLContext::resetState() noexcept {
        state.window.viewport.w
    );
    glDepthRangef(state.window.depthRange.x, state.window.depthRange.y);
-}
-
-void OpenGLContext::createTimerQuery(GLTimerQuery* query) {
-    mTimerQueryFactory->createTimerQuery(query);
-}
-
-void OpenGLContext::destroyTimerQuery(GLTimerQuery* query) {
-    mTimerQueryFactory->destroyTimerQuery(query);
-}
-
-void OpenGLContext::beginTimeElapsedQuery(GLTimerQuery* query) {
-    mTimerQueryFactory->beginTimeElapsedQuery(query);
-}
-
-void OpenGLContext::endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQuery* query) {
-    mTimerQueryFactory->endTimeElapsedQuery(driver, query);
+    
 }

 } // namesapce filament
@@ -17,39 +17,25 @@
 #ifndef TNT_FILAMENT_BACKEND_OPENGLCONTEXT_H
 #define TNT_FILAMENT_BACKEND_OPENGLCONTEXT_H

-
-#include "OpenGLTimerQuery.h"
-
-#include <backend/platforms/OpenGLPlatform.h>
-
-#include <backend/DriverEnums.h>
-#include <backend/Handle.h>
-
-#include "gl_headers.h"
-
-#include <utils/compiler.h>
-#include <utils/bitset.h>
-#include <utils/debug.h>
-
-#include <math/vec2.h>
 #include <math/vec4.h>

-#include <tsl/robin_map.h>
+#include <utils/CString.h>
+#include <utils/debug.h>
+
+#include <backend/Handle.h>
+
+#include "GLUtils.h"

 #include <array>
-#include <functional>
-#include <optional>
+#include <set>
 #include <tuple>
-#include <vector>
-
-#include <stddef.h>
-#include <stdint.h>
+#include <utility>

 namespace filament::backend {

 class OpenGLPlatform;

-class OpenGLContext final : public TimerQueryFactoryInterface {
+class OpenGLContext {
 public:
    static constexpr const size_t MAX_TEXTURE_UNIT_COUNT = MAX_SAMPLER_COUNT;
    static constexpr const size_t DUMMY_TEXTURE_BINDING = 7; // highest binding guaranteed to work with ES2
@@ -60,29 +46,19 @@ public:
    struct RenderPrimitive {
        static_assert(MAX_VERTEX_ATTRIBUTE_COUNT <= 16);

-        GLuint vao[2] = {};                                     // 4
+        GLuint vao = 0;                                         // 4
        GLuint elementArray = 0;                                // 4
-        mutable utils::bitset<uint16_t> vertexAttribArray;      // 2
+        utils::bitset<uint16_t> vertexAttribArray;              // 2

-        // if this differs from vertexBufferWithObjects->bufferObjectsVersion, this VAO needs to
-        // be updated (see OpenGLDriver::updateVertexArrayObject())
+        // If this version number does not match vertexBufferWithObjects->bufferObjectsVersion,
+        // then the VAO needs to be updated.
        uint8_t vertexBufferVersion = 0;                        // 1
-
-        // if this differs from OpenGLContext::state.age, this VAO needs to
-        // be updated (see OpenGLDriver::updateVertexArrayObject())
-        uint8_t stateVersion = 0;                               // 1
-
-        // If this differs from OpenGLContext::state.age, this VAO's name needs to be updated.
-        // See OpenGLContext::bindVertexArray()
-        uint8_t nameVersion = 0;                                // 1
-
-        // Size in bytes of indices in the index buffer
        uint8_t indicesSize = 0;                                // 1

        // The optional 32-bit handle to a GLVertexBuffer is necessary only if the referenced
        // VertexBuffer supports buffer objects. If this is zero, then the VBO handles array is
        // immutable.
-        Handle<HwVertexBuffer> vertexBufferWithObjects;         // 4
+        Handle<HwVertexBuffer> vertexBufferWithObjects = {};    // 4

        GLenum getIndicesType() const noexcept {
            return indicesSize == 4 ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT;
@@ -91,22 +67,7 @@ public:

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

-    explicit OpenGLContext(OpenGLPlatform& platform,
-            Platform::DriverConfig const& driverConfig) noexcept;
-
-    ~OpenGLContext() noexcept final;
-
-    void terminate() noexcept;
-
-    // TimerQueryInterface ------------------------------------------------------------------------
-
-    // note: OpenGLContext being final ensures (clang) these are not called through the vtable
-    void createTimerQuery(GLTimerQuery* query) override;
-    void destroyTimerQuery(GLTimerQuery* query) override;
-    void beginTimeElapsedQuery(GLTimerQuery* query) override;
-    void endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQuery* query) override;
-
-    // --------------------------------------------------------------------------------------------
+    OpenGLContext() noexcept;

    template<int MAJOR, int MINOR>
    inline bool isAtLeastGL() const noexcept {
@@ -138,6 +99,7 @@ public:
 #endif
    }

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

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

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

           void unbindTexture(GLenum target, GLuint id) noexcept;
-           void unbindTextureUnit(GLuint unit) noexcept;
    inline void bindVertexArray(RenderPrimitive const* p) noexcept;
    inline void bindSampler(GLuint unit, GLuint sampler) noexcept;
           void unbindSampler(GLuint sampler) noexcept;
@@ -161,11 +123,10 @@ public:
    inline void bindBufferRange(GLenum target, GLuint index, GLuint buffer,
            GLintptr offset, GLsizeiptr size) noexcept;

-    GLuint bindFramebuffer(GLenum target, GLuint buffer) noexcept;
-    void unbindFramebuffer(GLenum target) noexcept;
+    inline void bindFramebuffer(GLenum target, GLuint buffer) noexcept;

-    inline void enableVertexAttribArray(RenderPrimitive const* rp, GLuint index) noexcept;
-    inline void disableVertexAttribArray(RenderPrimitive const* rp, GLuint index) noexcept;
+    inline void enableVertexAttribArray(GLuint index) noexcept;
+    inline void disableVertexAttribArray(GLuint index) noexcept;
    inline void enable(GLenum cap) noexcept;
    inline void disable(GLenum cap) noexcept;
    inline void frontFace(GLenum mode) noexcept;
@@ -187,9 +148,7 @@ public:
    inline void depthRange(GLclampf near, GLclampf far) noexcept;

    void deleteBuffers(GLsizei n, const GLuint* buffers, GLenum target) noexcept;
-    void deleteVertexArray(GLuint vao) noexcept;
-
-    void destroyWithContext(size_t index, std::function<void(OpenGLContext&)> const& closure) noexcept;
+    void deleteVertexArrays(GLsizei n, const GLuint* arrays) noexcept;

    // glGet*() values
    struct Gets {
@@ -224,7 +183,6 @@ public:
        bool EXT_discard_framebuffer;
        bool EXT_multisampled_render_to_texture2;
        bool EXT_multisampled_render_to_texture;
-        bool EXT_protected_textures;
        bool EXT_shader_framebuffer_fetch;
        bool EXT_texture_compression_bptc;
        bool EXT_texture_compression_etc2;
@@ -247,7 +205,6 @@ public:
        bool OES_standard_derivatives;
        bool OES_texture_npot;
        bool OES_vertex_array_object;
-        bool OVR_multiview2;
        bool WEBGL_compressed_texture_etc;
        bool WEBGL_compressed_texture_s3tc;
        bool WEBGL_compressed_texture_s3tc_srgb;
@@ -311,6 +268,10 @@ public:
        // a glFinish. So we must delay the destruction until we know the GPU is finished.
        bool delay_fbo_destruction;

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

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

    FeatureLevel getFeatureLevel() const noexcept { return mFeatureLevel; }

-    // This is the index of the context in use. Must be 0 or 1. This is used to manange the
-    // OpenGL name of ContainerObjects within each context.
-    uint32_t contextIndex = 0;
-
    // Try to keep the State structure sorted by data-access patterns
    struct State {
-        State() noexcept = default;
-        // make sure we don't copy this state by accident
-        State(State const& rhs) = delete;
-        State(State&& rhs) noexcept = delete;
-        State& operator=(State const& rhs) = delete;
-        State& operator=(State&& rhs) noexcept = delete;
-
        GLint major = 0;
        GLint minor = 0;

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

@@ -451,7 +396,6 @@ public:
            vec4gli viewport { 0 };
            vec2glf depthRange { 0.0f, 1.0f };
        } window;
-        uint8_t age = 0;
    } state;

    struct Procs {
@@ -471,49 +415,9 @@ public:
        void (* maxShaderCompilerThreadsKHR)(GLuint count);
    } procs{};

-    void unbindEverything() noexcept;
-    void synchronizeStateAndCache(size_t index) noexcept;
-    void setEs2UniformBinding(size_t index, GLuint id, void const* data, uint16_t age) noexcept {
-        mUniformBindings[index] = { id, data, age };
-    }
-    auto getEs2UniformBinding(size_t index) const noexcept {
-        return mUniformBindings[index];
-    }
-
-#ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
-    GLuint getSamplerSlow(SamplerParams sp) const noexcept;
-
-    inline GLuint getSampler(SamplerParams sp) const noexcept {
-        assert_invariant(!sp.padding0);
-        assert_invariant(!sp.padding1);
-        assert_invariant(!sp.padding2);
-        auto& samplerMap = mSamplerMap;
-        auto pos = samplerMap.find(sp);
-        if (UTILS_UNLIKELY(pos == samplerMap.end())) {
-            return getSamplerSlow(sp);
-        }
-        return pos->second;
-    }
-#endif
-
-
 private:
-    OpenGLPlatform& mPlatform;
    ShaderModel mShaderModel = ShaderModel::MOBILE;
    FeatureLevel mFeatureLevel = FeatureLevel::FEATURE_LEVEL_1;
-    TimerQueryFactoryInterface* mTimerQueryFactory = nullptr;
-    std::vector<std::function<void(OpenGLContext&)>> mDestroyWithNormalContext;
-    RenderPrimitive mDefaultVAO;
-    std::optional<GLuint> mDefaultFbo[2];
-    std::array<
-            std::tuple<GLuint, void const*, uint16_t>,
-            CONFIG_UNIFORM_BINDING_COUNT> mUniformBindings = {};
-    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{{
            {   bugs.disable_glFlush,
@@ -558,11 +462,16 @@ private:
            {   bugs.delay_fbo_destruction,
                    "delay_fbo_destruction",
                    ""},
+            {   bugs.disable_thread_affinity,
+                    "disable_thread_affinity",
+                    ""},
            {   bugs.force_feature_level0,
                    "force_feature_level0",
                    ""},
    }};

+    RenderPrimitive mDefaultVAO;
+
    // this is chosen to minimize code size
 #if defined(BACKEND_OPENGL_VERSION_GLES)
    static void initExtensionsGLES(Extensions* ext, GLint major, GLint minor) noexcept;
@@ -605,10 +514,31 @@ private:
    }

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

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

+constexpr size_t OpenGLContext::getIndexForTextureTarget(GLuint target) noexcept {
+    // this must match state.textures[].targets[]
+    switch (target) {
+        case GL_TEXTURE_2D:                     return 0;
+        case GL_TEXTURE_2D_ARRAY:               return 1;
+        case GL_TEXTURE_CUBE_MAP:               return 2;
+#if defined(BACKEND_OPENGL_LEVEL_GLES31)
+        case GL_TEXTURE_2D_MULTISAMPLE:         return 3;
+#endif
+        case GL_TEXTURE_EXTERNAL_OES:           return 4;
+        case GL_TEXTURE_3D:                     return 5;
+        case GL_TEXTURE_CUBE_MAP_ARRAY:         return 6;
+        default:
+            return 0;
+    }
+}
+
 constexpr size_t OpenGLContext::getIndexForCap(GLenum cap) noexcept { //NOLINT
    size_t index = 0;
    switch (cap) {
@@ -699,26 +629,11 @@ void OpenGLContext::depthRange(GLclampf near, GLclampf far) noexcept {
 void OpenGLContext::bindVertexArray(RenderPrimitive const* p) noexcept {
    RenderPrimitive* vao = p ? const_cast<RenderPrimitive *>(p) : &mDefaultVAO;
    update_state(state.vao.p, vao, [&]() {
-
-        // See if we need to create a name for this VAO on the fly, this would happen if:
-        // - we're not the default VAO, because its name is always 0
-        // - our name is 0, this could happen if this VAO was created in the "other" context
-        // - the nameVersion is out of date *and* we're on the protected context, in this case:
-        //      - the name must be stale from a previous use of this context because we always
-        //        destroy the protected context when we're done with it.
-        bool const recreateVaoName = p != &mDefaultVAO &&
-                ((vao->vao[contextIndex] == 0) ||
-                        (vao->nameVersion != state.age && contextIndex == 1));
-        if (UTILS_UNLIKELY(recreateVaoName)) {
-            vao->nameVersion = state.age;
-            procs.genVertexArrays(1, &vao->vao[contextIndex]);
-        }
-
-        procs.bindVertexArray(vao->vao[contextIndex]);
+        procs.bindVertexArray(vao->vao);
        // update GL_ELEMENT_ARRAY_BUFFER, which is updated by glBindVertexArray
        size_t const targetIndex = getIndexForBufferTarget(GL_ELEMENT_ARRAY_BUFFER);
        state.buffers.genericBinding[targetIndex] = vao->elementArray;
-        if (UTILS_UNLIKELY(bugs.vao_doesnt_store_element_array_buffer_binding || recreateVaoName)) {
+        if (UTILS_UNLIKELY(bugs.vao_doesnt_store_element_array_buffer_binding)) {
            // This shouldn't be needed, but it looks like some drivers don't do the implicit
            // glBindBuffer().
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vao->elementArray);
@@ -756,39 +671,66 @@ void OpenGLContext::bindBufferRange(GLenum target, GLuint index, GLuint buffer,
 #endif
 }

-void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId) noexcept {
-    update_state(state.textures.units[unit].target, target, [&]() {
-        activeTexture(unit);
-        glBindTexture(state.textures.units[unit].target, 0);
-    });
-    update_state(state.textures.units[unit].id, texId, [&]() {
+void OpenGLContext::bindFramebuffer(GLenum target, GLuint buffer) noexcept {
+    switch (target) {
+        case GL_FRAMEBUFFER:
+            if (state.draw_fbo != buffer || state.read_fbo != buffer) {
+                state.draw_fbo = state.read_fbo = buffer;
+                glBindFramebuffer(target, buffer);
+            }
+            break;
+#ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
+        case GL_DRAW_FRAMEBUFFER:
+            if (state.draw_fbo != buffer) {
+                state.draw_fbo = buffer;
+                glBindFramebuffer(target, buffer);
+            }
+            break;
+        case GL_READ_FRAMEBUFFER:
+            if (state.read_fbo != buffer) {
+                state.read_fbo = buffer;
+                glBindFramebuffer(target, buffer);
+            }
+            break;
+#endif
+        default:
+            break;
+    }
+}
+
+void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId, size_t targetIndex) noexcept {
+    assert_invariant(targetIndex == getIndexForTextureTarget(target));
+    assert_invariant(targetIndex < TEXTURE_TARGET_COUNT);
+    update_state(state.textures.units[unit].targets[targetIndex].texture_id, texId, [&]() {
        activeTexture(unit);
        glBindTexture(target, texId);
    }, target == GL_TEXTURE_EXTERNAL_OES);
 }

+void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId) noexcept {
+    bindTexture(unit, target, texId, getIndexForTextureTarget(target));
+}
+
 void OpenGLContext::useProgram(GLuint program) noexcept {
    update_state(state.program.use, program, [&]() {
        glUseProgram(program);
    });
 }

-void OpenGLContext::enableVertexAttribArray(RenderPrimitive const* rp, GLuint index) noexcept {
-    assert_invariant(rp);
-    assert_invariant(index < rp->vertexAttribArray.size());
-    bool const force = rp->stateVersion != state.age;
-    if (UTILS_UNLIKELY(force || !rp->vertexAttribArray[index])) {
-        rp->vertexAttribArray.set(index);
+void OpenGLContext::enableVertexAttribArray(GLuint index) noexcept {
+    assert_invariant(state.vao.p);
+    assert_invariant(index < state.vao.p->vertexAttribArray.size());
+    if (UTILS_UNLIKELY(!state.vao.p->vertexAttribArray[index])) {
+        state.vao.p->vertexAttribArray.set(index);
        glEnableVertexAttribArray(index);
    }
 }

-void OpenGLContext::disableVertexAttribArray(RenderPrimitive const* rp, GLuint index) noexcept {
-    assert_invariant(rp);
-    assert_invariant(index < rp->vertexAttribArray.size());
-    bool const force = rp->stateVersion != state.age;
-    if (UTILS_UNLIKELY(force || rp->vertexAttribArray[index])) {
-        rp->vertexAttribArray.unset(index);
+void OpenGLContext::disableVertexAttribArray(GLuint index) noexcept {
+    assert_invariant(state.vao.p);
+    assert_invariant(index < state.vao.p->vertexAttribArray.size());
+    if (UTILS_UNLIKELY(state.vao.p->vertexAttribArray[index])) {
+        state.vao.p->vertexAttribArray.unset(index);
        glDisableVertexAttribArray(index);
    }
 }
@@ -18,44 +18,27 @@
 #define TNT_FILAMENT_BACKEND_OPENGL_OPENGLDRIVER_H

 #include "DriverBase.h"
+#include "GLUtils.h"
 #include "OpenGLContext.h"
-#include "OpenGLTimerQuery.h"
-#include "GLBufferObject.h"
-#include "GLTexture.h"
 #include "ShaderCompilerService.h"

-#include <backend/platforms/OpenGLPlatform.h>
-
-#include <backend/AcquiredImage.h>
-#include <backend/DriverEnums.h>
-#include <backend/Handle.h>
-#include <backend/Platform.h>
-#include <backend/Program.h>
-#include <backend/TargetBufferInfo.h>
-
 #include "private/backend/Driver.h"
 #include "private/backend/HandleAllocator.h"

-#include <utils/FixedCapacityVector.h>
+#include <backend/platforms/OpenGLPlatform.h>
+
+#include <backend/AcquiredImage.h>
+#include <backend/Program.h>
+#include <backend/TargetBufferInfo.h>
+
 #include <utils/compiler.h>
-#include <utils/debug.h>
+#include <utils/Allocator.h>

 #include <math/vec4.h>

 #include <tsl/robin_map.h>

-#include <array>
-#include <condition_variable>
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include <stddef.h>
-#include <stdint.h>
+#include <set>

 #ifndef FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB
 #    define FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB 4
@@ -66,19 +49,17 @@ namespace filament::backend {
 class OpenGLPlatform;
 class PixelBufferDescriptor;
 struct TargetBufferInfo;
+
 class OpenGLProgram;
-class TimerQueryFactoryInterface;
-struct PushConstantBundle;
+class OpenGLTimerQueryInterface;

 class OpenGLDriver final : public DriverBase {
-    inline explicit OpenGLDriver(OpenGLPlatform* platform,
-            const Platform::DriverConfig& driverConfig) noexcept;
+    inline explicit OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfig& driverConfig) noexcept;
    ~OpenGLDriver() noexcept final;
    Dispatcher getDispatcher() const noexcept final;

 public:
-    static Driver* create(OpenGLPlatform* platform, void* sharedGLContext,
-            const Platform::DriverConfig& driverConfig) noexcept;
+    static Driver* create(OpenGLPlatform* platform, void* sharedGLContext, const Platform::DriverConfig& driverConfig) noexcept;

    class DebugMarker {
        OpenGLDriver& driver;
@@ -94,22 +75,27 @@ public:
        bool rec709 = false;
    };

-    struct GLVertexBufferInfo : public HwVertexBufferInfo {
-        GLVertexBufferInfo() noexcept = default;
-        GLVertexBufferInfo(uint8_t bufferCount, uint8_t attributeCount,
-                AttributeArray const& attributes)
-                : HwVertexBufferInfo(bufferCount, attributeCount),
-                  attributes(attributes) {
+    struct GLBufferObject : public HwBufferObject {
+        using HwBufferObject::HwBufferObject;
+        GLBufferObject(uint32_t size,
+                BufferObjectBinding bindingType, BufferUsage usage) noexcept
+                : HwBufferObject(size), usage(usage), bindingType(bindingType) {
        }
-        AttributeArray attributes;
+
+        struct {
+            GLuint id;
+            union {
+                GLenum binding;
+                void* buffer;
+            };
+        } gl;
+        BufferUsage usage;
+        BufferObjectBinding bindingType;
+        uint16_t age = 0;
    };

    struct GLVertexBuffer : public HwVertexBuffer {
-        GLVertexBuffer() noexcept = default;
-        GLVertexBuffer(uint32_t vertexCount, Handle<HwVertexBufferInfo> vbih)
-                : HwVertexBuffer(vertexCount), vbih(vbih) {
-        }
-        Handle<HwVertexBufferInfo> vbih;
+        using HwVertexBuffer::HwVertexBuffer;
        struct {
            // 4 * MAX_VERTEX_ATTRIBUTE_COUNT bytes
            std::array<GLuint, MAX_VERTEX_ATTRIBUTE_COUNT> buffers{};
@@ -123,6 +109,7 @@ public:
        } gl;
    };

+    struct GLTexture;
    struct GLSamplerGroup : public HwSamplerGroup {
        using HwSamplerGroup::HwSamplerGroup;
        struct Entry {
@@ -136,14 +123,39 @@ public:
    struct GLRenderPrimitive : public HwRenderPrimitive {
        using HwRenderPrimitive::HwRenderPrimitive;
        OpenGLContext::RenderPrimitive gl;
-        Handle<HwVertexBufferInfo> vbih;
    };

-    using GLBufferObject = filament::backend::GLBufferObject;
+    struct GLTexture : public HwTexture {
+        using HwTexture::HwTexture;
+        struct GL {
+            GL() noexcept : imported(false), sidecarSamples(1), reserved(0) {}
+            GLuint id = 0;          // texture or renderbuffer id
+            GLenum target = 0;
+            GLenum internalFormat = 0;
+            GLuint sidecarRenderBufferMS = 0;  // multi-sample sidecar renderbuffer

-    using GLTexture = filament::backend::GLTexture;
+            // texture parameters go here too
+            GLfloat anisotropy = 1.0;
+            int8_t baseLevel = 127;
+            int8_t maxLevel = -1;
+            uint8_t targetIndex = 0;    // optimization: index corresponding to target
+            bool imported           : 1;
+            uint8_t sidecarSamples  : 4;
+            uint8_t reserved        : 3;
+        } gl;

-    using GLTimerQuery = filament::backend::GLTimerQuery;
+        OpenGLPlatform::ExternalTexture* externalTexture = nullptr;
+    };
+
+    struct GLTimerQuery : public HwTimerQuery {
+        struct State {
+            struct {
+                GLuint query;
+            } gl;
+            std::atomic<int64_t> elapsed{};
+        };
+        std::shared_ptr<State> state;
+    };

    struct GLStream : public HwStream {
        using HwStream::HwStream;
@@ -197,8 +209,8 @@ private:
    OpenGLContext mContext;
    ShaderCompilerService mShaderCompilerService;

-    friend class TimerQueryFactory;
-    friend class TimerQueryNativeFactory;
+    friend class OpenGLTimerQueryFactory;
+    friend class TimerQueryNative;
    OpenGLContext& getContext() noexcept { return mContext; }

    ShaderCompilerService& getShaderCompilerService() noexcept {
@@ -232,13 +244,13 @@ private:
    HandleAllocatorGL mHandleAllocator;

    template<typename D, typename ... ARGS>
-    Handle<D> initHandle(ARGS&& ... args) {
+    Handle<D> initHandle(ARGS&& ... args) noexcept {
        return mHandleAllocator.allocateAndConstruct<D>(std::forward<ARGS>(args) ...);
    }

    template<typename D, typename B, typename ... ARGS>
    typename std::enable_if<std::is_base_of<B, D>::value, D>::type*
-    construct(Handle<B> const& handle, ARGS&& ... args) {
+    construct(Handle<B> const& handle, ARGS&& ... args) noexcept {
        return mHandleAllocator.destroyAndConstruct<D, B>(handle, std::forward<ARGS>(args) ...);
    }

@@ -252,7 +264,7 @@ private:
    typename std::enable_if_t<
            std::is_pointer_v<Dp> &&
            std::is_base_of_v<B, typename std::remove_pointer_t<Dp>>, Dp>
-    handle_cast(Handle<B>& handle) {
+    handle_cast(Handle<B>& handle) noexcept {
        return mHandleAllocator.handle_cast<Dp, B>(handle);
    }

@@ -260,7 +272,7 @@ private:
    inline typename std::enable_if_t<
            std::is_pointer_v<Dp> &&
            std::is_base_of_v<B, typename std::remove_pointer_t<Dp>>, Dp>
-    handle_cast(Handle<B> const& handle) {
+    handle_cast(Handle<B> const& handle) noexcept {
        return mHandleAllocator.handle_cast<Dp, B>(handle);
    }

@@ -278,7 +290,7 @@ private:
    void updateVertexArrayObject(GLRenderPrimitive* rp, GLVertexBuffer const* vb);

    void framebufferTexture(TargetBufferInfo const& binfo,
-            GLRenderTarget const* rt, GLenum attachment, uint8_t layerCount) noexcept;
+            GLRenderTarget const* rt, GLenum attachment) noexcept;

    void setRasterState(RasterState rs) noexcept;

@@ -299,8 +311,8 @@ private:
    void renderBufferStorage(GLuint rbo, GLenum internalformat, uint32_t width,
            uint32_t height, uint8_t samples) const noexcept;

-    void textureStorage(OpenGLDriver::GLTexture* t, uint32_t width, uint32_t height,
-            uint32_t depth, bool useProtectedMemory) noexcept;
+    void textureStorage(GLTexture* t,
+            uint32_t width, uint32_t height, uint32_t depth) noexcept;

    /* State tracking GL wrappers... */

@@ -312,13 +324,29 @@ private:
    void resolvePass(ResolveAction action, GLRenderTarget const* rt,
            TargetBufferFlags discardFlags) noexcept;

+#ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
+    GLuint getSamplerSlow(SamplerParams sp) const noexcept;
+
+    inline GLuint getSampler(SamplerParams sp) const noexcept {
+        assert_invariant(!sp.padding0);
+        assert_invariant(!sp.padding1);
+        assert_invariant(!sp.padding2);
+        auto& samplerMap = mSamplerMap;
+        auto pos = samplerMap.find(sp);
+        if (UTILS_UNLIKELY(pos == samplerMap.end())) {
+            return getSamplerSlow(sp);
+        }
+        return pos->second;
+    }
+#endif
+
    const std::array<GLSamplerGroup*, Program::SAMPLER_BINDING_COUNT>& getSamplerBindings() const {
        return mSamplerBindings;
    }

    using AttachmentArray = std::array<GLenum, MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT + 2>;
-    static GLsizei getAttachments(AttachmentArray& attachments, TargetBufferFlags buffers,
-            bool isDefaultFramebuffer) noexcept;
+    static GLsizei getAttachments(AttachmentArray& attachments,
+            GLRenderTarget const* rt, TargetBufferFlags buffers) noexcept;

    // state required to represent the current render pass
    Handle<HwRenderTarget> mRenderPassTarget;
@@ -327,23 +355,21 @@ private:
    GLboolean mRenderPassDepthWrite{};
    GLboolean mRenderPassStencilWrite{};

-    GLRenderPrimitive const* mBoundRenderPrimitive = nullptr;
-    bool mValidProgram = false;
-
-
    void clearWithRasterPipe(TargetBufferFlags clearFlags,
            math::float4 const& linearColor, GLfloat depth, GLint stencil) noexcept;

    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;
+    std::array<std::tuple<GLuint, void const*, uint16_t>, Program::UNIFORM_BINDING_COUNT> mUniformBindings = {};

    // sampler buffer binding points (nullptr if not used)
    std::array<GLSamplerGroup*, Program::SAMPLER_BINDING_COUNT> mSamplerBindings = {};   // 4 pointers

+    mutable tsl::robin_map<SamplerParams, GLuint,
+            SamplerParams::Hasher, SamplerParams::EqualTo> mSamplerMap;
+
    // this must be accessed from the driver thread only
    std::vector<GLTexture*> mTexturesWithStreamsAttached;

@@ -371,14 +397,15 @@ private:
    void executeEveryNowAndThenOps() noexcept;
    std::vector<std::function<bool()>> mEveryNowAndThenOps;

+    // timer query implementation
+    OpenGLTimerQueryInterface* mTimerQueryImpl = nullptr;
+
    const Platform::DriverConfig mDriverConfig;
    Platform::DriverConfig const& getDriverConfig() const noexcept { return mDriverConfig; }

    // for ES2 sRGB support
    GLSwapChain* mCurrentDrawSwapChain = nullptr;
    bool mRec709OutputColorspace = false;
-
-    PushConstantBundle* mCurrentPushConstants = nullptr;
 };

 // ------------------------------------------------------------------------------------------------
@@ -18,17 +18,6 @@

 #include "OpenGLDriverFactory.h"

-#include <backend/AcquiredImage.h>
-#include <backend/DriverEnums.h>
-#include <backend/Platform.h>
-
-#include <utils/compiler.h>
-
-#include <utils/Invocable.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-
 namespace filament::backend {

 Driver* OpenGLPlatform::createDefaultDriver(OpenGLPlatform* platform,
@@ -38,37 +27,14 @@ Driver* OpenGLPlatform::createDefaultDriver(OpenGLPlatform* platform,

 OpenGLPlatform::~OpenGLPlatform() noexcept = default;

-void OpenGLPlatform::makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain,
-        utils::Invocable<void()>, utils::Invocable<void(size_t)>) noexcept {
-    makeCurrent(getCurrentContextType(), drawSwapChain, readSwapChain);
-}
-
-bool OpenGLPlatform::isProtectedContextSupported() const noexcept {
-    return false;
-}
-
 bool OpenGLPlatform::isSRGBSwapChainSupported() const noexcept {
    return false;
 }

-uint32_t OpenGLPlatform::getDefaultFramebufferObject() noexcept {
+uint32_t OpenGLPlatform::createDefaultRenderTarget() noexcept {
    return 0;
 }

-void OpenGLPlatform::beginFrame(int64_t monotonic_clock_ns, int64_t refreshIntervalNs,
-        uint32_t frameId) noexcept {
-}
-
-void OpenGLPlatform::endFrame(uint32_t frameId) noexcept {
-}
-
-void OpenGLPlatform::preCommit() noexcept {
-}
-
-OpenGLPlatform::ContextType OpenGLPlatform::getCurrentContextType() const noexcept {
-    return ContextType::UNPROTECTED;
-}
-
 void OpenGLPlatform::setPresentationTime(
        UTILS_UNUSED int64_t presentationTimeInNanosecond) noexcept {
 }
@@ -139,14 +105,10 @@ AcquiredImage OpenGLPlatform::transformAcquiredImage(AcquiredImage source) noexc
    return source;
 }

-TargetBufferFlags OpenGLPlatform::getPreservedFlags(UTILS_UNUSED SwapChain*) noexcept {
+TargetBufferFlags OpenGLPlatform::getPreservedFlags(UTILS_UNUSED SwapChain* swapChain) noexcept {
    return TargetBufferFlags::NONE;
 }

-bool OpenGLPlatform::isSwapChainProtected(UTILS_UNUSED SwapChain*) noexcept {
-    return false;
-}
-
 bool OpenGLPlatform::isExtraContextSupported() const noexcept {
    return false;
 }
@@ -16,25 +16,16 @@

 #include "OpenGLProgram.h"

-#include "GLUtils.h"
+#include "BlobCacheKey.h"
 #include "OpenGLDriver.h"
 #include "ShaderCompilerService.h"

-#include <backend/Program.h>
-
-#include <private/backend/BackendUtils.h>
-
 #include <utils/debug.h>
 #include <utils/compiler.h>
 #include <utils/Log.h>
 #include <utils/Systrace.h>

-#include <array>
-#include <string_view>
-#include <utility>
-#include <new>
-
-#include <stddef.h>
+#include <private/backend/BackendUtils.h>

 namespace filament::backend {

@@ -46,8 +37,6 @@ struct OpenGLProgram::LazyInitializationData {
    Program::UniformBlockInfo uniformBlockInfo;
    Program::SamplerGroupInfo samplerGroupInfo;
    std::array<Program::UniformInfo, Program::UNIFORM_BINDING_COUNT> bindingUniformInfo;
-    utils::FixedCapacityVector<Program::PushConstant> vertexPushConstants;
-    utils::FixedCapacityVector<Program::PushConstant> fragmentPushConstants;
 };


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

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

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

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

 #include <utils/compiler.h>
 #include <utils/FixedCapacityVector.h>
-#include <utils/Slice.h>
-
-#include <array>
-#include <limits>

 #include <stddef.h>
 #include <stdint.h>
@@ -39,11 +35,6 @@ namespace filament::backend {

 class OpenGLDriver;

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

@@ -76,22 +67,14 @@ public:
        }
    }

+    struct {
+        GLuint program = 0;
+    } gl; // 12 bytes
+
    // For ES2 only
    void updateUniforms(uint32_t index, GLuint id, void const* buffer, uint16_t age) noexcept;
    void setRec709ColorSpace(bool rec709) const noexcept;

-    struct {
-        GLuint program = 0;
-    } gl;                                               // 4 bytes
-
-    PushConstantBundle getPushConstants() {
-        auto fragBegin = mPushConstants.begin() + mPushConstantFragmentStageOffset;
-        return {
-            .vertexConstants = utils::Slice(mPushConstants.begin(), fragBegin),
-            .fragmentConstants = utils::Slice(fragBegin, mPushConstants.end()),
-        };
-    }
-
 private:
    // keep these away from of other class attributes
    struct LazyInitializationData;
@@ -103,20 +86,14 @@ private:

    void updateSamplers(OpenGLDriver* gld) const noexcept;

+    ShaderCompilerService::program_token_t mToken{};
+
    // number of bindings actually used by this program
+    uint8_t mUsedBindingsCount = 0u;
+    UTILS_UNUSED uint8_t padding[3] = {};
    std::array<uint8_t, Program::SAMPLER_BINDING_COUNT> mUsedSamplerBindingPoints;   // 4 bytes

-    ShaderCompilerService::program_token_t mToken{};    // 16 bytes
-
-    uint8_t mUsedBindingsCount = 0u;                    // 1 byte
-    UTILS_UNUSED uint8_t padding[2] = {};               // 2 byte
-
-    // Push constant array offset for fragment stage constants.
-    uint8_t mPushConstantFragmentStageOffset = 0u;      // 1 byte
-
    // only needed for ES2
-    GLint mRec709Location = -1;                         // 4 bytes
-
    using LocationInfo = utils::FixedCapacityVector<GLint>;
    struct UniformsRecord {
        Program::UniformInfo uniforms;
@@ -124,15 +101,12 @@ private:
        mutable GLuint id = 0;
        mutable uint16_t age = std::numeric_limits<uint16_t>::max();
    };
-    UniformsRecord const* mUniformsRecords = nullptr;               // 8 bytes
-
-    // Note that this can be replaced with a raw pointer and an uint8_t (for size) to reduce the
-    // size of the container to 9 bytes if there is a need in the future.
-    utils::FixedCapacityVector<std::pair<GLint, ConstantType>> mPushConstants;// 16 bytes
+    UniformsRecord const* mUniformsRecords = nullptr;
+    GLint mRec709Location = -1;
 };

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

 } // namespace filament::backend

@@ -16,132 +16,110 @@

 #include "OpenGLTimerQuery.h"

-#include "GLUtils.h"
-#include "OpenGLDriver.h"
-
-#include <backend/Platform.h>
 #include <backend/platforms/OpenGLPlatform.h>
-#include <backend/DriverEnums.h>

 #include <utils/compiler.h>
-#include <utils/debug.h>
 #include <utils/JobSystem.h>
 #include <utils/Log.h>
-#include <utils/Mutex.h>
 #include <utils/Systrace.h>
-
-#include <atomic>
-#include <memory>
-#include <mutex>
-#include <new>
-#include <utility>
-
-#include <stdint.h>
+#include <utils/debug.h>

 namespace filament::backend {

 using namespace backend;
 using namespace GLUtils;

-class OpenGLDriver;
-
 // ------------------------------------------------------------------------------------------------

-bool TimerQueryFactory::mGpuTimeSupported = false;
+bool OpenGLTimerQueryFactory::mGpuTimeSupported = false;

-TimerQueryFactoryInterface* TimerQueryFactory::init(
-        OpenGLPlatform& platform, OpenGLContext& context) noexcept {
-    (void)context;
+OpenGLTimerQueryInterface* OpenGLTimerQueryFactory::init(
+        OpenGLPlatform& platform, OpenGLDriver& driver) noexcept {
+    (void)driver;

-    TimerQueryFactoryInterface* impl = nullptr;
+    OpenGLTimerQueryInterface* impl;

 #if defined(BACKEND_OPENGL_VERSION_GL) || defined(GL_EXT_disjoint_timer_query)
+    auto& context = driver.getContext();
    if (context.ext.EXT_disjoint_timer_query) {
        // timer queries are available
        if (context.bugs.dont_use_timer_query && platform.canCreateFence()) {
            // however, they don't work well, revert to using fences if we can.
-            impl = new(std::nothrow) TimerQueryFenceFactory(platform);
+            impl = new(std::nothrow) OpenGLTimerQueryFence(platform);
        } else {
-            impl = new(std::nothrow) TimerQueryNativeFactory(context);
+            impl = new(std::nothrow) TimerQueryNative(driver);
        }
        mGpuTimeSupported = true;
    } else
 #endif
    if (platform.canCreateFence()) {
        // no timer queries, but we can use fences
-        impl = new(std::nothrow) TimerQueryFenceFactory(platform);
+        impl = new(std::nothrow) OpenGLTimerQueryFence(platform);
        mGpuTimeSupported = true;
    } else {
        // no queries, no fences -- that's a problem
-        impl = new(std::nothrow) TimerQueryFallbackFactory();
+        impl = new(std::nothrow) TimerQueryFallback();
        mGpuTimeSupported = false;
    }
-    assert_invariant(impl);
    return impl;
 }

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

-TimerQueryFactoryInterface::~TimerQueryFactoryInterface() = default;
+OpenGLTimerQueryInterface::~OpenGLTimerQueryInterface() = default;

 // This is a backend synchronous call
-TimerQueryResult TimerQueryFactoryInterface::getTimerQueryValue(
-        GLTimerQuery* tq, uint64_t* elapsedTime) noexcept {
+bool OpenGLTimerQueryInterface::getTimerQueryValue(GLTimerQuery* tq, uint64_t* elapsedTime) noexcept {
    if (UTILS_LIKELY(tq->state)) {
        int64_t const elapsed = tq->state->elapsed.load(std::memory_order_relaxed);
-        if (elapsed > 0) {
+        bool const available = elapsed > 0;
+        if (available) {
            *elapsedTime = elapsed;
-            return TimerQueryResult::AVAILABLE;
        }
-        return TimerQueryResult(elapsed);
+        return available;
    }
-    return TimerQueryResult::ERROR;
+    return false;
 }

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

 #if defined(BACKEND_OPENGL_VERSION_GL) || defined(GL_EXT_disjoint_timer_query)

-TimerQueryNativeFactory::TimerQueryNativeFactory(OpenGLContext& context)
-        : mContext(context) {
+TimerQueryNative::TimerQueryNative(OpenGLDriver& driver)
+        : mDriver(driver) {
 }

-TimerQueryNativeFactory::~TimerQueryNativeFactory() = default;
+TimerQueryNative::~TimerQueryNative() = default;

-void TimerQueryNativeFactory::createTimerQuery(GLTimerQuery* tq) {
-    assert_invariant(!tq->state);
-
-    tq->state = std::make_shared<GLTimerQuery::State>();
-    mContext.procs.genQueries(1u, &tq->state->gl.query);
+void TimerQueryNative::createTimerQuery(GLTimerQuery* tq) {
+    if (UTILS_UNLIKELY(!tq->state)) {
+        tq->state = std::make_shared<GLTimerQuery::State>();
+    }
+    mDriver.getContext().procs.genQueries(1u, &tq->state->gl.query);
    CHECK_GL_ERROR(utils::slog.e)
 }

-void TimerQueryNativeFactory::destroyTimerQuery(GLTimerQuery* tq) {
+void TimerQueryNative::destroyTimerQuery(GLTimerQuery* tq) {
    assert_invariant(tq->state);
-
-    mContext.procs.deleteQueries(1u, &tq->state->gl.query);
-    CHECK_GL_ERROR(utils::slog.e)
-
-    tq->state.reset();
-}
-
-void TimerQueryNativeFactory::beginTimeElapsedQuery(GLTimerQuery* tq) {
-    assert_invariant(tq->state);
-
-    tq->state->elapsed.store(int64_t(TimerQueryResult::NOT_READY), std::memory_order_relaxed);
-    mContext.procs.beginQuery(GL_TIME_ELAPSED, tq->state->gl.query);
+    mDriver.getContext().procs.deleteQueries(1u, &tq->state->gl.query);
    CHECK_GL_ERROR(utils::slog.e)
 }

-void TimerQueryNativeFactory::endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQuery* tq) {
+void TimerQueryNative::beginTimeElapsedQuery(GLTimerQuery* tq) {
    assert_invariant(tq->state);
+    tq->state->elapsed.store(0);
+    mDriver.getContext().procs.beginQuery(GL_TIME_ELAPSED, tq->state->gl.query);
+    CHECK_GL_ERROR(utils::slog.e)
+}

-    mContext.procs.endQuery(GL_TIME_ELAPSED);
+void TimerQueryNative::endTimeElapsedQuery(GLTimerQuery* tq) {
+    assert_invariant(tq->state);
+    mDriver.getContext().procs.endQuery(GL_TIME_ELAPSED);
    CHECK_GL_ERROR(utils::slog.e)

    std::weak_ptr<GLTimerQuery::State> const weak = tq->state;

-    driver.runEveryNowAndThen([&context = mContext, weak]() -> bool {
+    mDriver.runEveryNowAndThen([context = mDriver.getContext(), weak]() -> bool {
        auto state = weak.lock();
        if (state) {
            GLuint available = 0;
@@ -155,8 +133,6 @@ void TimerQueryNativeFactory::endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQ
            // we won't end-up here if we're on ES and don't have GL_EXT_disjoint_timer_query
            context.procs.getQueryObjectui64v(state->gl.query, GL_QUERY_RESULT, &elapsedTime);
            state->elapsed.store((int64_t)elapsedTime, std::memory_order_relaxed);
-        } else {
-            state->elapsed.store(int64_t(TimerQueryResult::ERROR), std::memory_order_relaxed);
        }
        return true;
    });
@@ -166,7 +142,7 @@ void TimerQueryNativeFactory::endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQ

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

-TimerQueryFenceFactory::TimerQueryFenceFactory(OpenGLPlatform& platform)
+OpenGLTimerQueryFence::OpenGLTimerQueryFence(OpenGLPlatform& platform)
        : mPlatform(platform) {
    mQueue.reserve(2);
    mThread = std::thread([this]() {
@@ -190,8 +166,7 @@ TimerQueryFenceFactory::TimerQueryFenceFactory(OpenGLPlatform& platform)
    });
 }

-TimerQueryFenceFactory::~TimerQueryFenceFactory() {
-    assert_invariant(mQueue.empty());
+OpenGLTimerQueryFence::~OpenGLTimerQueryFence() {
    if (mThread.joinable()) {
        std::unique_lock<utils::Mutex> lock(mLock);
        mExitRequested = true;
@@ -203,26 +178,27 @@ TimerQueryFenceFactory::~TimerQueryFenceFactory() {
    }
 }

-void TimerQueryFenceFactory::push(TimerQueryFenceFactory::Job&& job) {
+void OpenGLTimerQueryFence::enqueue(OpenGLTimerQueryFence::Job&& job) {
    std::unique_lock<utils::Mutex> const lock(mLock);
-    mQueue.push_back(std::move(job));
+    mQueue.push_back(std::forward<Job>(job));
    mCondition.notify_one();
 }

-void TimerQueryFenceFactory::createTimerQuery(GLTimerQuery* tq) {
-    assert_invariant(!tq->state);
-    tq->state = std::make_shared<GLTimerQuery::State>();
+void OpenGLTimerQueryFence::createTimerQuery(GLTimerQuery* tq) {
+    if (UTILS_UNLIKELY(!tq->state)) {
+        tq->state = std::make_shared<GLTimerQuery::State>();
+    }
 }

-void TimerQueryFenceFactory::destroyTimerQuery(GLTimerQuery* tq) {
+void OpenGLTimerQueryFence::destroyTimerQuery(GLTimerQuery* tq) {
    assert_invariant(tq->state);
-    tq->state.reset();
 }

-void TimerQueryFenceFactory::beginTimeElapsedQuery(GLTimerQuery* tq) {
+void OpenGLTimerQueryFence::beginTimeElapsedQuery(GLTimerQuery* tq) {
    assert_invariant(tq->state);
-    tq->state->elapsed.store(int64_t(TimerQueryResult::NOT_READY), std::memory_order_relaxed);
+    tq->state->elapsed.store(0);

+    Platform::Fence* fence = mPlatform.createFence();
    std::weak_ptr<GLTimerQuery::State> const weak = tq->state;

    // FIXME: this implementation of beginTimeElapsedQuery is usually wrong; it ends up
@@ -231,11 +207,12 @@ void TimerQueryFenceFactory::beginTimeElapsedQuery(GLTimerQuery* tq) {
    //    on a dummy target for instance, or somehow latch the begin time at the next renderpass
    //    start.

-    push([&platform = mPlatform, fence = mPlatform.createFence(), weak]() {
+    push([&platform = mPlatform, fence, weak]() {
        auto state = weak.lock();
        if (state) {
            platform.waitFence(fence, FENCE_WAIT_FOR_EVER);
-            state->then = clock::now().time_since_epoch().count();
+            int64_t const then = clock::now().time_since_epoch().count();
+            state->elapsed.store(-then, std::memory_order_relaxed);
            SYSTRACE_CONTEXT();
            SYSTRACE_ASYNC_BEGIN("OpenGLTimerQueryFence", intptr_t(state.get()));
        }
@@ -243,16 +220,19 @@ void TimerQueryFenceFactory::beginTimeElapsedQuery(GLTimerQuery* tq) {
    });
 }

-void TimerQueryFenceFactory::endTimeElapsedQuery(OpenGLDriver&, GLTimerQuery* tq) {
+void OpenGLTimerQueryFence::endTimeElapsedQuery(GLTimerQuery* tq) {
    assert_invariant(tq->state);
+    Platform::Fence* fence = mPlatform.createFence();
    std::weak_ptr<GLTimerQuery::State> const weak = tq->state;

-    push([&platform = mPlatform, fence = mPlatform.createFence(), weak]() {
+    push([&platform = mPlatform, fence, weak]() {
        auto state = weak.lock();
        if (state) {
            platform.waitFence(fence, FENCE_WAIT_FOR_EVER);
            int64_t const now = clock::now().time_since_epoch().count();
-            state->elapsed.store(now - state->then, std::memory_order_relaxed);
+            int64_t const then = state->elapsed.load(std::memory_order_relaxed);
+            assert_invariant(then < 0);
+            state->elapsed.store(now + then, std::memory_order_relaxed);
            SYSTRACE_CONTEXT();
            SYSTRACE_ASYNC_END("OpenGLTimerQueryFence", intptr_t(state.get()));
        }
@@ -262,32 +242,34 @@ void TimerQueryFenceFactory::endTimeElapsedQuery(OpenGLDriver&, GLTimerQuery* tq

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

-TimerQueryFallbackFactory::TimerQueryFallbackFactory() = default;
+TimerQueryFallback::TimerQueryFallback() = default;

-TimerQueryFallbackFactory::~TimerQueryFallbackFactory() = default;
+TimerQueryFallback::~TimerQueryFallback() = default;

-void TimerQueryFallbackFactory::createTimerQuery(GLTimerQuery* tq) {
-    assert_invariant(!tq->state);
-    tq->state = std::make_shared<GLTimerQuery::State>();
+void TimerQueryFallback::createTimerQuery(GLTimerQuery* tq) {
+    if (UTILS_UNLIKELY(!tq->state)) {
+        tq->state = std::make_shared<GLTimerQuery::State>();
+    }
 }

-void TimerQueryFallbackFactory::destroyTimerQuery(GLTimerQuery* tq) {
+void TimerQueryFallback::destroyTimerQuery(GLTimerQuery* tq) {
    assert_invariant(tq->state);
-    tq->state.reset();
 }

-void TimerQueryFallbackFactory::beginTimeElapsedQuery(GLTimerQuery* tq) {
+void TimerQueryFallback::beginTimeElapsedQuery(OpenGLTimerQueryInterface::GLTimerQuery* tq) {
    assert_invariant(tq->state);
    // this implementation measures the CPU time, but we have no h/w support
-    tq->state->then = clock::now().time_since_epoch().count();
-    tq->state->elapsed.store(int64_t(TimerQueryResult::NOT_READY), std::memory_order_relaxed);
+    int64_t const then = clock::now().time_since_epoch().count();
+    tq->state->elapsed.store(-then, std::memory_order_relaxed);
 }

-void TimerQueryFallbackFactory::endTimeElapsedQuery(OpenGLDriver&, GLTimerQuery* tq) {
+void TimerQueryFallback::endTimeElapsedQuery(OpenGLTimerQueryInterface::GLTimerQuery* tq) {
    assert_invariant(tq->state);
    // this implementation measures the CPU time, but we have no h/w support
    int64_t const now = clock::now().time_since_epoch().count();
-    tq->state->elapsed.store(now - tq->state->then, std::memory_order_relaxed);
+    int64_t const then = tq->state->elapsed.load(std::memory_order_relaxed);
+    assert_invariant(then < 0);
+    tq->state->elapsed.store(now + then, std::memory_order_relaxed);
 }

 } // namespace filament::backend
@@ -17,41 +17,18 @@
 #ifndef TNT_FILAMENT_BACKEND_OPENGL_TIMERQUERY_H
 #define TNT_FILAMENT_BACKEND_OPENGL_TIMERQUERY_H

-#include <backend/DriverEnums.h>
-
-#include "DriverBase.h"
+#include "OpenGLDriver.h"

 #include <utils/Condition.h>
 #include <utils/Mutex.h>

-#include "gl_headers.h"
-
-#include <atomic>
-#include <chrono>
-#include <functional>
-#include <memory>
 #include <thread>
 #include <vector>

-#include <stdint.h>
-
 namespace filament::backend {

 class OpenGLPlatform;
-class OpenGLContext;
-class OpenGLDriver;
-class TimerQueryFactoryInterface;
-
-struct GLTimerQuery : public HwTimerQuery {
-    struct State {
-        struct {
-            GLuint query;
-        } gl;
-        int64_t then{};
-        std::atomic<int64_t> elapsed{};
-    };
-    std::shared_ptr<State> state;
-};
+class OpenGLTimerQueryInterface;

 /*
 * We need two implementation of timer queries (only elapsed time), because
@@ -61,80 +38,83 @@ struct GLTimerQuery : public HwTimerQuery {
 * These classes implement the various strategies...
 */

-class TimerQueryFactory {
+
+class OpenGLTimerQueryFactory {
    static bool mGpuTimeSupported;
 public:
-    static TimerQueryFactoryInterface* init(
-            OpenGLPlatform& platform, OpenGLContext& context) noexcept;
+    static OpenGLTimerQueryInterface* init(
+            OpenGLPlatform& platform, OpenGLDriver& driver) noexcept;

    static bool isGpuTimeSupported() noexcept {
        return mGpuTimeSupported;
    }
 };

-class TimerQueryFactoryInterface {
+class OpenGLTimerQueryInterface {
 protected:
-    using GLTimerQuery = filament::backend::GLTimerQuery;
+    using GLTimerQuery = OpenGLDriver::GLTimerQuery;
    using clock = std::chrono::steady_clock;

 public:
-    virtual ~TimerQueryFactoryInterface();
+    virtual ~OpenGLTimerQueryInterface();
    virtual void createTimerQuery(GLTimerQuery* query) = 0;
    virtual void destroyTimerQuery(GLTimerQuery* query) = 0;
    virtual void beginTimeElapsedQuery(GLTimerQuery* query) = 0;
-    virtual void endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQuery* query) = 0;
+    virtual void endTimeElapsedQuery(GLTimerQuery* query) = 0;

-    static TimerQueryResult getTimerQueryValue(GLTimerQuery* tq, uint64_t* elapsedTime) noexcept;
+    static bool getTimerQueryValue(GLTimerQuery* tq, uint64_t* elapsedTime) noexcept;
 };

 #if defined(BACKEND_OPENGL_VERSION_GL) || defined(GL_EXT_disjoint_timer_query)

-class TimerQueryNativeFactory final : public TimerQueryFactoryInterface {
+class TimerQueryNative : public OpenGLTimerQueryInterface {
 public:
-    explicit TimerQueryNativeFactory(OpenGLContext& context);
-    ~TimerQueryNativeFactory() override;
+    explicit TimerQueryNative(OpenGLDriver& driver);
+    ~TimerQueryNative() override;
 private:
    void createTimerQuery(GLTimerQuery* query) override;
    void destroyTimerQuery(GLTimerQuery* query) override;
    void beginTimeElapsedQuery(GLTimerQuery* query) override;
-    void endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQuery* query) override;
-    OpenGLContext& mContext;
+    void endTimeElapsedQuery(GLTimerQuery* query) override;
+    OpenGLDriver& mDriver;
 };

 #endif

-class TimerQueryFenceFactory final : public TimerQueryFactoryInterface {
+class OpenGLTimerQueryFence : public OpenGLTimerQueryInterface {
 public:
-    explicit TimerQueryFenceFactory(OpenGLPlatform& platform);
-    ~TimerQueryFenceFactory() override;
+    explicit OpenGLTimerQueryFence(OpenGLPlatform& platform);
+    ~OpenGLTimerQueryFence() override;
 private:
    using Job = std::function<void()>;
-    using Container = std::vector<Job>;
-
    void createTimerQuery(GLTimerQuery* query) override;
    void destroyTimerQuery(GLTimerQuery* query) override;
    void beginTimeElapsedQuery(GLTimerQuery* tq) override;
-    void endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQuery* tq) override;
+    void endTimeElapsedQuery(GLTimerQuery* tq) override;

-    void push(Job&& job);
+    void enqueue(Job&& job);
+    template<typename CALLABLE, typename ... ARGS>
+    void push(CALLABLE&& func, ARGS&& ... args) {
+        enqueue(Job(std::bind(std::forward<CALLABLE>(func), std::forward<ARGS>(args)...)));
+    }

    OpenGLPlatform& mPlatform;
    std::thread mThread;
    mutable utils::Mutex mLock;
    mutable utils::Condition mCondition;
-    Container mQueue;
+    std::vector<Job> mQueue;
    bool mExitRequested = false;
 };

-class TimerQueryFallbackFactory final : public TimerQueryFactoryInterface {
+class TimerQueryFallback : public OpenGLTimerQueryInterface {
 public:
-    explicit TimerQueryFallbackFactory();
-    ~TimerQueryFallbackFactory() override;
+    explicit TimerQueryFallback();
+    ~TimerQueryFallback() override;
 private:
    void createTimerQuery(GLTimerQuery* query) override;
    void destroyTimerQuery(GLTimerQuery* query) override;
    void beginTimeElapsedQuery(GLTimerQuery* query) override;
-    void endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQuery* query) override;
+    void endTimeElapsedQuery(GLTimerQuery* query) override;
 };

 } // namespace filament::backend
@@ -30,7 +30,6 @@
 #include <utils/Log.h>
 #include <utils/Systrace.h>

-#include <cctype>
 #include <chrono>
 #include <string>
 #include <string_view>
@@ -262,12 +261,12 @@ ShaderCompilerService::program_token_t ShaderCompilerService::createProgram(
                [this, &gl, program = std::move(program), token]() mutable {
                    // compile the shaders
                    std::array<GLuint, Program::SHADER_TYPE_COUNT> shaders{};
+                    std::array<utils::CString, Program::SHADER_TYPE_COUNT> shaderSourceCode;
                    compileShaders(gl,
                            std::move(program.getShadersSource()),
                            program.getSpecializationConstants(),
-                            program.isMultiview(),
                            shaders,
-                            token->shaderSourceCode);
+                            shaderSourceCode);

                    // link the program
                    GLuint const glProgram = linkProgram(gl, shaders, token->attributes);
@@ -301,7 +300,6 @@ ShaderCompilerService::program_token_t ShaderCompilerService::createProgram(
        compileShaders(gl,
                std::move(program.getShadersSource()),
                program.getSpecializationConstants(),
-                program.isMultiview(),
                token->gl.shaders,
                token->shaderSourceCode);

@@ -504,7 +502,6 @@ GLuint ShaderCompilerService::initialize(program_token_t& token) noexcept {
 void ShaderCompilerService::compileShaders(OpenGLContext& context,
        Program::ShaderSource shadersSource,
        utils::FixedCapacityVector<Program::SpecializationConstant> const& specializationConstants,
-        bool multiview,
        std::array<GLuint, Program::SHADER_TYPE_COUNT>& outShaders,
        UTILS_UNUSED_IN_RELEASE std::array<CString, Program::SHADER_TYPE_COUNT>& outShaderSourceCode) noexcept {

@@ -518,16 +515,8 @@ void ShaderCompilerService::compileShaders(OpenGLContext& context,
    };

    std::string specializationConstantString;
-    int32_t numViews = 2;
    for (auto const& sc : specializationConstants) {
        appendSpecConstantString(specializationConstantString, sc);
-        if (sc.id == 8) {
-            // This constant must match
-            // ReservedSpecializationConstants::CONFIG_STEREO_EYE_COUNT
-            // which we can't use here because it's defined in EngineEnums.h.
-            // (we're breaking layering here, but it's for the good cause).
-            numViews = std::get<int32_t>(sc.value);
-        }
    }
    if (!specializationConstantString.empty()) {
        specializationConstantString += '\n';
@@ -556,23 +545,17 @@ void ShaderCompilerService::compileShaders(OpenGLContext& context,

        if (UTILS_LIKELY(!shadersSource[i].empty())) {
            Program::ShaderBlob& shader = shadersSource[i];
-            char* shader_src = reinterpret_cast<char*>(shader.data());
-            size_t shader_len = shader.size();

            // remove GOOGLE_cpp_style_line_directive
-            process_GOOGLE_cpp_style_line_directive(context, shader_src, shader_len);
-
-            // replace the value of layout(num_views = X) for multiview extension
-            if (multiview && stage == ShaderStage::VERTEX) {
-                process_OVR_multiview2(context, numViews, shader_src, shader_len);
-            }
+            std::string_view const source = process_GOOGLE_cpp_style_line_directive(context,
+                    reinterpret_cast<char*>(shader.data()), shader.size());

            // add support for ARB_shading_language_packing if needed
            auto const packingFunctions = process_ARB_shading_language_packing(context);

            // split shader source, so we can insert the specialization constants and the packing
            // functions
-            auto const [prolog, body] = splitShaderSource({ shader_src, shader_len });
+            auto const [prolog, body] = splitShaderSource(source);

            const std::array<const char*, 4> sources = {
                    prolog.data(),
@@ -595,7 +578,7 @@ void ShaderCompilerService::compileShaders(OpenGLContext& context,
 #ifndef NDEBUG
            // for debugging we return the original shader source (without the modifications we
            // made here), otherwise the line numbers wouldn't match.
-            outShaderSourceCode[i] = { shader_src, shader_len };
+            outShaderSourceCode[i] = { source.data(), source.length() };
 #endif

            outShaders[i] = shaderId;
@@ -604,59 +587,15 @@ void ShaderCompilerService::compileShaders(OpenGLContext& context,
 }

 // If usages of the Google-style line directive are present, remove them, as some
-// drivers don't allow the quotation marks. This source modification happens in-place.
-void ShaderCompilerService::process_GOOGLE_cpp_style_line_directive(OpenGLContext& context,
+// drivers don't allow the quotation marks. This happens in-place.
+std::string_view ShaderCompilerService::process_GOOGLE_cpp_style_line_directive(OpenGLContext& context,
        char* source, size_t len) noexcept {
    if (!context.ext.GOOGLE_cpp_style_line_directive) {
        if (UTILS_UNLIKELY(requestsGoogleLineDirectivesExtension({ source, len }))) {
            removeGoogleLineDirectives(source, len); // length is unaffected
        }
    }
-}
-
-// Look up the `source` to replace the number of eyes for multiview with the given number. This is
-// necessary for OpenGL because OpenGL relies on the number specified in shader files to determine
-// the number of views, which is assumed as a single digit, for multiview.
-// This source modification happens in-place.
-void ShaderCompilerService::process_OVR_multiview2(OpenGLContext& context,
-        int32_t eyeCount, char* source, size_t len) noexcept {
-    // We don't use regular expression in favor of performance.
-    if (context.ext.OVR_multiview2) {
-        const std::string_view shader{ source, len };
-        const std::string_view layout = "layout";
-        const std::string_view num_views = "num_views";
-        size_t found = 0;
-        while (true) {
-            found = shader.find(layout, found);
-            if (found == std::string_view::npos) {
-                break;
-            }
-            found = shader.find_first_not_of(' ', found + layout.size());
-            if (found == std::string_view::npos || shader[found] != '(') {
-                continue;
-            }
-            found = shader.find_first_not_of(' ', found + 1);
-            if (found == std::string_view::npos) {
-                continue;
-            }
-            if (shader.compare(found, num_views.size(), num_views) != 0) {
-                continue;
-            }
-            found = shader.find_first_not_of(' ', found + num_views.size());
-            if (found == std::string_view::npos || shader[found] != '=') {
-                continue;
-            }
-            found = shader.find_first_not_of(' ', found + 1);
-            if (found == std::string_view::npos) {
-                continue;
-            }
-            // We assume the value should be one-digit number.
-            assert_invariant(eyeCount < 10);
-            assert_invariant(!::isdigit(source[found + 1]));
-            source[found] = '0' + eyeCount;
-            break;
-        }
-    }
+    return { source, len };
 }

 // Tragically, OpenGL 4.1 doesn't support unpackHalf2x16 (appeared in 4.2) and
@@ -134,14 +134,10 @@ private:
            OpenGLContext& context,
            Program::ShaderSource shadersSource,
            utils::FixedCapacityVector<Program::SpecializationConstant> const& specializationConstants,
-            bool multiview,
            std::array<GLuint, Program::SHADER_TYPE_COUNT>& outShaders,
            std::array<utils::CString, Program::SHADER_TYPE_COUNT>& outShaderSourceCode) noexcept;

-    static void process_GOOGLE_cpp_style_line_directive(OpenGLContext& context,
-            char* source, size_t len) noexcept;
-
-    static void process_OVR_multiview2(OpenGLContext& context, int32_t eyeCount,
+    static std::string_view process_GOOGLE_cpp_style_line_directive(OpenGLContext& context,
            char* source, size_t len) noexcept;

    static std::string_view process_ARB_shading_language_packing(OpenGLContext& context) noexcept;
@@ -67,9 +67,6 @@ PFNGLDISCARDFRAMEBUFFEREXTPROC glDiscardFramebufferEXT;
 #ifdef GL_KHR_parallel_shader_compile
 PFNGLMAXSHADERCOMPILERTHREADSKHRPROC glMaxShaderCompilerThreadsKHR;
 #endif
-#ifdef GL_OVR_multiview
-PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC glFramebufferTextureMultiviewOVR;
-#endif

 #if defined(__ANDROID__) && !defined(FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2)
 // On Android, If we want to support a build system less than ANDROID_API 21, we need to
@@ -120,9 +117,6 @@ void importGLESExtensionsEntryPoints() {
 #ifdef GL_KHR_parallel_shader_compile
        getProcAddress(glMaxShaderCompilerThreadsKHR, "glMaxShaderCompilerThreadsKHR");
 #endif
-#ifdef GL_OVR_multiview
-        getProcAddress(glFramebufferTextureMultiviewOVR, "glFramebufferTextureMultiviewOVR");
-#endif
 #if defined(__ANDROID__) && !defined(FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2)
        getProcAddress(glDispatchCompute, "glDispatchCompute");
 #endif
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mathias Agopian	0404be5127	new LinearAllocatorWithFallback LinearAllocatorWithFallback is a linear allocator that can fall back to the heap allocator. We use it for the high level command buffer to avoid crashing when running out of memory. FIXES=[277115740]	2024-02-21 14:52:04 -08:00
Mathias Agopian	a784fb7d8b	Rework RenderPass to improve allocations and API RenderPass now is a fully immutable object that gets constructed with a RenderPassBuilder. RenderPassBuilder can be passed around and doesn't do any (major) allocations. All RenderPass allocations and heavy lifting is done in RenderPassBuilder::Build(). Additionally, RenderPass cannot be copied anymore. Where allocations happen is now much clearer.	2024-02-21 14:51:57 -08:00
Mathias Agopian	8459cbc91c	Fix a couple threading vs. allocations - prepareVisibleLights was run on a dedicated thread (via JobSystem), but was using its own local ArenaScope. This is wrong because it could reset the root arena at any later point. This is fixed by just not using a local ArenaScope. - related to the above, the root Arena (LinearAllocatorArena) didn't use a locked policy, which cause also cause problems since some allocations are done off the main thread. We now pre-allocate the one buffer we need. This PR also renames some variable and types to improve readability.	2024-02-21 14:51:51 -08:00
Mathias Agopian	344c04a2d8	clenaup CircularBuffer implementation and API Also fix a bug in DEBUG mode that could corrupt the CircularBuffer, it was due to a wrong debugging code attempting to clear the unused area of the buffer (this was wrong because in "ashmem" mode, there are no guaranteed unused areas).	2024-02-21 14:51:44 -08:00
Mathias Agopian	55e2691f3f	Automatically flush CommandStream When generating commands, we now automatically flush the CommandStream, so that we're guaranteed to not overrun the circular buffer.	2024-02-21 14:51:36 -08:00