Merge branch 'rc/1.53.0' into release

Fixes #7905

.github/workflows/android-continuous.yml

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

.github/workflows/ios-continuous.yml

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

.github/workflows/linux-continuous.yml

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

.github/workflows/mac-continuous.yml

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

.github/workflows/npm-deploy.yml

@@ -13,7 +13,7 @@ jobs:
     name: npm-deploy
     runs-on: macos-14
     steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
         with:
           ref: ${{ github.event.inputs.release_tag }}
       # Setup .npmrc file to publish to npm

.github/workflows/presubmit.yml

@@ -18,7 +18,7 @@ jobs:
         os: [macos-14, ubuntu-22.04]
 
     steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
       - name: Run build script
         run: |
           WORKFLOW_OS=`echo \`uname\` | sed "s/Darwin/mac/" | tr [:upper:] [:lower:]`
@@ -32,7 +32,7 @@ jobs:
     runs-on: windows-2019
 
     steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
       - name: Run build script
         run: |
           build\windows\build-github.bat presubmit
@@ -43,7 +43,7 @@ jobs:
     runs-on: macos-14
 
     steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
       - uses: actions/setup-java@v3
         with:
           distribution: 'temurin'
@@ -57,7 +57,7 @@ jobs:
     runs-on: macos-14
 
     steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
       - name: Run build script
         run: |
           cd build/ios && printf "y" | ./build.sh presubmit
@@ -70,7 +70,7 @@ jobs:
     runs-on: macos-14
 
     steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
       - name: Run build script
         run: |
           cd build/web && printf "y" | ./build.sh presubmit

.github/workflows/release.yml

@@ -41,7 +41,7 @@ jobs:
           TAG=${REF##*/}
           echo "ref=${REF}" >> $GITHUB_OUTPUT
           echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
         with:
           ref: ${{ steps.git_ref.outputs.ref }}
       - name: Run build script
@@ -76,7 +76,7 @@ jobs:
           TAG=${REF##*/}
           echo "ref=${REF}" >> $GITHUB_OUTPUT
           echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
         with:
           ref: ${{ steps.git_ref.outputs.ref }}
       - name: Run build script
@@ -109,7 +109,7 @@ jobs:
           TAG=${REF##*/}
           echo "ref=${REF}" >> $GITHUB_OUTPUT
           echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
         with:
           ref: ${{ steps.git_ref.outputs.ref }}
       - uses: actions/setup-java@v3
@@ -163,7 +163,7 @@ jobs:
           TAG=${REF##*/}
           echo "ref=${REF}" >> $GITHUB_OUTPUT
           echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
         with:
           ref: ${{ steps.git_ref.outputs.ref }}
       - name: Run build script
@@ -197,7 +197,7 @@ jobs:
           echo "ref=${REF}" >> $GITHUB_OUTPUT
           echo "tag=${TAG}" >> $GITHUB_OUTPUT
         shell: bash
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
         with:
           ref: ${{ steps.git_ref.outputs.ref }}
       - name: Run build script

.github/workflows/web-continuous.yml

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

.github/workflows/windows-continuous.yml

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

BUILDING.md

@@ -73,7 +73,6 @@ 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:
@@ -426,7 +425,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
@@ -436,32 +435,62 @@ doxygen docs/doxygen/filament.doxygen
 
 Finally simply open `docs/html/index.html` in your web browser.
 
-## SwiftShader
+## Software Rasterization
 
-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`:
+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
 
 ```shell
 git clone https://github.com/google/swiftshader.git
 cd swiftshader/build
 cmake .. &&  make -j
-export SWIFTSHADER_LD_LIBRARY_PATH=`pwd`
 ```
 
-Next, go to your Filament repo and use the [easy build](#easy-build) script with `-t`.
+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
+```
 
-## SwiftShader for CI
+Build and run Filament as usual and specify the Vulkan backend when creating the Engine.
 
-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:
+### 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,
 
 ```shell
-docker pull ghcr.io/filament-assets/swiftshader
-docker run -it ghcr.io/filament-assets/swiftshader
+cd mesa
+mkdir -p out
+meson setup builddir/ -Dprefix=$(pwd)/out -Dglx=xlib -Dgallium-drivers=swrast -Dvulkan-drivers=swrast
+meson install -C builddir/
 ```
 
-To do more with the container, see the helper script at `build/swiftshader/test.sh`.
+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
+```
 
-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`.
+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
+
+```

CMakeLists.txt

@@ -21,8 +21,6 @@ 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)
@@ -71,6 +69,10 @@ set(FILAMENT_METAL_HANDLE_ARENA_SIZE_IN_MB "8" CACHE STRING
     "Size of the Metal handle arena, default 8."
 )
 
+set(FILAMENT_BACKEND_DEBUG_FLAG "" CACHE STRING
+    "A debug flag meant for enabling/disabling backend debugging paths"
+)
+
 # Enable exceptions by default in spirv-cross.
 set(SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS OFF)
 
@@ -141,11 +143,6 @@ 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()
@@ -169,15 +166,6 @@ if (NOT ANDROID AND NOT WEBGL AND NOT IOS AND NOT FILAMENT_LINUX_IS_MOBILE)
     set(IS_HOST_PLATFORM TRUE)
 endif()
 
-if (IOS)
-    # Remove the headerpad_max_install_names linker flag on iOS. It causes warnings when linking
-    # executables with bitcode.
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_C_LINK_FLAGS ${CMAKE_C_LINK_FLAGS})
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_CXX_LINK_FLAGS ${CMAKE_CXX_LINK_FLAGS})
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS})
-endif()
-
 if (WIN32)
     # Link statically against c/c++ lib to avoid missing redistriburable such as
     # "VCRUNTIME140.dll not found. Try reinstalling the app.", but give users
@@ -332,10 +320,6 @@ 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()
@@ -389,8 +373,9 @@ endif()
 if (NOT MSVC AND NOT IOS)
     # Omitting stack frame pointers prevents the generation of readable stack traces in crash reports on iOS
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer")
+endif()
 
-    # These aren't compatible with -fembed-bitcode (and seem to have no effect on Apple platforms anyway)
+if (NOT MSVC)
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffunction-sections -fdata-sections")
 endif()
 
@@ -455,8 +440,13 @@ 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 "")
@@ -470,7 +460,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}")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${GC_SECTIONS} ${B_SYMBOLIC_FUNCTIONS} ${BINARY_ALIGNMENT}")
 
 if (WEBGL_PTHREADS)
     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pthread")
@@ -534,13 +524,15 @@ else()
 endif()
 
 # This only affects the prebuilt shader files in gltfio and samples, not filament library.
-# The value can be either "instanced" or "multiview".
-set(FILAMENT_SAMPLES_STEREO_TYPE "instanced" CACHE STRING
+# 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")
-    message(FATAL_ERROR "Invalid stereo type: \"${FILAMENT_SAMPLES_STEREO_TYPE}\" choose either \"instanced\" or \"multiview\" ")
+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.
@@ -548,6 +540,12 @@ if (FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "multiview")
     set(FILAMENT_ENABLE_MULTIVIEW ON)
 endif ()
 
+# Define backend flag for debug only
+if (CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT FILAMENT_BACKEND_DEBUG_FLAG STREQUAL "")
+    add_definitions(-DFILAMENT_BACKEND_DEBUG_FLAG=${FILAMENT_BACKEND_DEBUG_FLAG})
+    unset(FILAMENT_BACKEND_DEBUG_FLAG)
+endif()
+
 # ==================================================================================================
 # Material compilation flags
 # ==================================================================================================
@@ -676,21 +674,6 @@ 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
 # ==================================================================================================
@@ -752,7 +735,6 @@ add_subdirectory(${FILAMENT}/filament)
 add_subdirectory(${FILAMENT}/shaders)
 add_subdirectory(${EXTERNAL}/basisu/tnt)
 add_subdirectory(${EXTERNAL}/civetweb/tnt)
-add_subdirectory(${EXTERNAL}/hat-trie/tnt)
 add_subdirectory(${EXTERNAL}/imgui/tnt)
 add_subdirectory(${EXTERNAL}/robin-map/tnt)
 add_subdirectory(${EXTERNAL}/smol-v/tnt)
@@ -819,6 +801,9 @@ if (IS_HOST_PLATFORM)
     add_subdirectory(${TOOLS}/glslminifier)
     add_subdirectory(${TOOLS}/matc)
     add_subdirectory(${TOOLS}/matinfo)
+    if (NOT WIN32)  # matedit not yet supported on Windows
+        add_subdirectory(${TOOLS}/matedit)
+    endif()
     add_subdirectory(${TOOLS}/mipgen)
     add_subdirectory(${TOOLS}/normal-blending)
     add_subdirectory(${TOOLS}/resgen)

NEW_RELEASE_NOTES.md

@@ -7,5 +7,3 @@ for next branch cut* header.
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).
 
 ## Release notes for next branch cut
-
-- engine: Add experimental APIs `Engine::builder::paused()` and `Engine::setPaused()`

README.md

@@ -31,7 +31,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.51.0'
+    implementation 'com.google.android.filament:filament-android:1.53.0'
 }
 ```
 
@@ -51,7 +51,7 @@ Here are all the libraries available in the group `com.google.android.filament`:
 iOS projects can use CocoaPods to install the latest release:
 
 ```shell
-pod 'Filament', '~> 1.51.0'
+pod 'Filament', '~> 1.53.0'
 ```
 
 ### Snapshots

RELEASE_NOTES.md

@@ -7,6 +7,55 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).
 
+## v1.53.0
+
+- engine: fix skinning normals with large transforms (b/342459864) [⚠️ **New Material Version**]
+
+## v1.52.3
+
+
+## v1.52.2
+
+
+## v1.52.1
+
+- Add instructions for using Mesa for software rasterization
+
+## v1.51.9
+
+
+## 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
 
 

android/build.gradle

@@ -83,12 +83,12 @@ buildscript {
         'minSdk': 21,
         'targetSdk': 34,
         'compileSdk': 34,
-        'kotlin': '1.9.21',
-        'kotlin_coroutines': '1.7.3',
+        'kotlin': '2.0.0',
+        'kotlin_coroutines': '1.9.0-RC',
         'buildTools': '34.0.0',
-        'ndk': '26.1.10909125',
-        'androidx_core': '1.12.0',
-        'androidx_annotations': '1.7.0'
+        'ndk': '27.0.11718014',
+        'androidx_core': '1.13.1',
+        'androidx_annotations': '1.8.0'
     ]
 
     ext.deps = [
@@ -104,7 +104,7 @@ buildscript {
     ]
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:8.2.0'
+        classpath 'com.android.tools.build:gradle:8.4.1'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin}"
     }
 

android/filamat-android/CMakeLists.txt

@@ -38,6 +38,7 @@ 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})

android/filament-android/CMakeLists.txt

@@ -59,6 +59,7 @@ 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

android/filament-android/src/main/cpp/Engine.cpp

@@ -342,6 +342,21 @@ Java_com_google_android_filament_Engine_nIsValidMaterial(JNIEnv*, jclass,
     return (jboolean)engine->isValid((Material*)nativeMaterial);
 }
 
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_Engine_nIsValidMaterialInstance(JNIEnv*, jclass,
+        jlong nativeEngine, jlong nativeMaterial, jlong nativeMaterialInstance) {
+    Engine* engine = (Engine *)nativeEngine;
+    return (jboolean)engine->isValid((Material*)nativeMaterial,
+            (MaterialInstance*)nativeMaterialInstance);
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+        Java_com_google_android_filament_Engine_nIsValidExpensiveMaterialInstance(JNIEnv*, jclass,
+        jlong nativeEngine, jlong nativeMaterialInstance) {
+    Engine* engine = (Engine *)nativeEngine;
+    return (jboolean)engine->isValidExpensive((MaterialInstance*)nativeMaterialInstance);
+}
+
 extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nIsValidSkybox(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeSkybox) {
@@ -391,6 +406,13 @@ Java_com_google_android_filament_Engine_nFlush(JNIEnv*, jclass,
     engine->flush();
 }
 
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_Engine_nIsPaused(JNIEnv*, jclass,
+        jlong nativeEngine) {
+    Engine* engine = (Engine*) nativeEngine;
+    return (jboolean)engine->isPaused();
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_Engine_nSetPaused(JNIEnv*, jclass,
         jlong nativeEngine, jboolean paused) {
@@ -398,6 +420,13 @@ Java_com_google_android_filament_Engine_nSetPaused(JNIEnv*, jclass,
     engine->setPaused(paused);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Engine_nUnprotected(JNIEnv*, jclass,
+        jlong nativeEngine, jboolean paused) {
+    Engine* engine = (Engine*) nativeEngine;
+    engine->unprotected();
+}
+
 // Managers...
 
 extern "C" JNIEXPORT jlong JNICALL
@@ -495,7 +524,9 @@ extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBu
         jlong textureUseAfterFreePoolSize, jboolean disableParallelShaderCompile,
         jint stereoscopicType, jlong stereoscopicEyeCount,
         jlong resourceAllocatorCacheSizeMB, jlong resourceAllocatorCacheMaxAge,
-        jboolean disableHandleUseAfterFreeCheck) {
+        jboolean disableHandleUseAfterFreeCheck,
+        jint preferredShaderLanguage,
+        jboolean forceGLES2Context) {
     Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
     Engine::Config config = {
             .commandBufferSizeMB = (uint32_t) commandBufferSizeMB,
@@ -511,6 +542,8 @@ extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBu
             .resourceAllocatorCacheSizeMB = (uint32_t) resourceAllocatorCacheSizeMB,
             .resourceAllocatorCacheMaxAge = (uint8_t) resourceAllocatorCacheMaxAge,
             .disableHandleUseAfterFreeCheck = (bool) disableHandleUseAfterFreeCheck,
+            .preferredShaderLanguage = (Engine::Config::ShaderLanguage) preferredShaderLanguage,
+            .forceGLES2Context = (bool) forceGLES2Context,
     };
     builder->config(&config);
 }

android/filament-android/src/main/cpp/RenderableManager.cpp

@@ -244,13 +244,25 @@ 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;
-    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
-    builder->morphing(level, primitiveIndex, morphTargetBuffer, offset, count);
+    if (nativeMorphTargetBuffer) {
+        MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
+        builder->morphing(level, primitiveIndex, morphTargetBuffer, offset, count);
+    } else {
+        builder->morphing(level, primitiveIndex, offset, count);
+    }
 }
 
 extern "C" JNIEXPORT void JNICALL
@@ -326,9 +338,14 @@ 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;
-    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
-    rm->setMorphTargetBufferAt((RenderableManager::Instance) i, (uint8_t) level,
-            (size_t) primitiveIndex, morphTargetBuffer, (size_t) offset, (size_t) count);
+    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);
+    }
 }
 
 extern "C" JNIEXPORT jint JNICALL

android/filament-android/src/main/cpp/View.cpp

@@ -49,6 +49,12 @@ Java_com_google_android_filament_View_nSetCamera(JNIEnv*, jclass,
     view->setCamera(camera);
 }
 
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_google_android_filament_View_nHasCamera(JNIEnv*, jclass, jlong nativeView) {
+    View* view = (View*) nativeView;
+    return (jboolean)view->hasCamera();
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_View_nSetColorGrading(JNIEnv*, jclass,
         jlong nativeView, jlong nativeColorGrading) {

android/filament-android/src/main/java/com/google/android/filament/Engine.java

@@ -159,9 +159,12 @@ public class Engine {
     };
 
     /**
-     * The type of technique for stereoscopic rendering
+     * 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. */
@@ -225,7 +228,9 @@ public class Engine {
                     config.textureUseAfterFreePoolSize, config.disableParallelShaderCompile,
                     config.stereoscopicType.ordinal(), config.stereoscopicEyeCount,
                     config.resourceAllocatorCacheSizeMB, config.resourceAllocatorCacheMaxAge,
-                    config.disableHandleUseAfterFreeCheck);
+                    config.disableHandleUseAfterFreeCheck,
+                    config.preferredShaderLanguage.ordinal(),
+                    config.forceGLES2Context);
             return this;
         }
 
@@ -403,7 +408,7 @@ public class Engine {
          *
          * @see View#setStereoscopicOptions
          */
-        public StereoscopicType stereoscopicType = StereoscopicType.INSTANCED;
+        public StereoscopicType stereoscopicType = StereoscopicType.NONE;
 
         /**
          * The number of eyes to render when stereoscopic rendering is enabled. Supported values are
@@ -428,6 +433,35 @@ public class Engine {
          * Disable backend handles use-after-free checks.
          */
         public boolean disableHandleUseAfterFreeCheck = false;
+
+        /*
+         * Sets a preferred shader language for Filament to use.
+         *
+         * The Metal backend supports two shader languages: MSL (Metal Shading Language) and
+         * METAL_LIBRARY (precompiled .metallib). This option controls which shader language is
+         * used when materials contain both.
+         *
+         * By default, when preferredShaderLanguage is unset, Filament will prefer METAL_LIBRARY
+         * shaders if present within a material, falling back to MSL. Setting
+         * preferredShaderLanguage to ShaderLanguage::MSL will instead instruct Filament to check
+         * for the presence of MSL in a material first, falling back to METAL_LIBRARY if MSL is not
+         * present.
+         *
+         * When using a non-Metal backend, setting this has no effect.
+         */
+        public enum ShaderLanguage {
+            DEFAULT,
+            MSL,
+            METAL_LIBRARY,
+        };
+        public ShaderLanguage preferredShaderLanguage = ShaderLanguage.DEFAULT;
+
+        /*
+         * When the OpenGL ES backend is used, setting this value to true will force a GLES2.0
+         * context if supported by the Platform, or if not, will have the backend pretend
+         * it's a GLES2 context. Ignored on other backends.
+         */
+        public boolean forceGLES2Context = false;
     }
 
     private Engine(long nativeEngine, Config config) {
@@ -849,6 +883,24 @@ public class Engine {
         return nIsValidMaterial(getNativeObject(), object.getNativeObject());
     }
 
+    /**
+     * Returns whether the object is valid.
+     * @param object Object to check for validity
+     * @return returns true if the specified object is valid.
+     */
+    public boolean isValidMaterialInstance(@NonNull Material ma, MaterialInstance mi) {
+        return nIsValidMaterialInstance(getNativeObject(), ma.getNativeObject(), mi.getNativeObject());
+    }
+
+    /**
+     * Returns whether the object is valid.
+     * @param object Object to check for validity
+     * @return returns true if the specified object is valid.
+     */
+    public boolean isValidExpensiveMaterialInstance(@NonNull MaterialInstance object) {
+        return nIsValidExpensiveMaterialInstance(getNativeObject(), object.getNativeObject());
+    }
+
     /**
      * Returns whether the object is valid.
      * @param object Object to check for validity
@@ -1209,6 +1261,17 @@ public class Engine {
         nFlush(getNativeObject());
     }
 
+    /**
+     * Get paused state of rendering thread.
+     *
+     * <p>Warning: This is an experimental API.
+     *
+     * @see #setPaused
+     */
+    public boolean isPaused() {
+        return nIsPaused(getNativeObject());
+    }
+
     /**
      * Pause or resume the rendering thread.
      *
@@ -1226,6 +1289,18 @@ public class Engine {
         nSetPaused(getNativeObject(), paused);
     }
 
+    /**
+     * Switch the command queue to unprotected mode. Protected mode can be activated via
+     * Renderer::beginFrame() using a protected SwapChain.
+
+     * @see Renderer
+     * @see SwapChain
+     */
+    public void unprotected() {
+        nUnprotected(getNativeObject());
+    }
+
+
     @UsedByReflection("TextureHelper.java")
     public long getNativeObject() {
         if (mNativeObject == 0) {
@@ -1291,6 +1366,8 @@ public class Engine {
     private static native boolean nIsValidSkinningBuffer(long nativeEngine, long nativeSkinningBuffer);
     private static native boolean nIsValidIndirectLight(long nativeEngine, long nativeIndirectLight);
     private static native boolean nIsValidMaterial(long nativeEngine, long nativeMaterial);
+    private static native boolean nIsValidMaterialInstance(long nativeEngine, long nativeMaterial, long nativeMaterialInstance);
+    private static native boolean nIsValidExpensiveMaterialInstance(long nativeEngine, long nativeMaterialInstance);
     private static native boolean nIsValidSkybox(long nativeEngine, long nativeSkybox);
     private static native boolean nIsValidColorGrading(long nativeEngine, long nativeColorGrading);
     private static native boolean nIsValidTexture(long nativeEngine, long nativeTexture);
@@ -1299,7 +1376,9 @@ 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 void nUnprotected(long nativeEngine);
     private static native long nGetTransformManager(long nativeEngine);
     private static native long nGetLightManager(long nativeEngine);
     private static native long nGetRenderableManager(long nativeEngine);
@@ -1321,7 +1400,9 @@ public class Engine {
             long textureUseAfterFreePoolSize, boolean disableParallelShaderCompile,
             int stereoscopicType, long stereoscopicEyeCount,
             long resourceAllocatorCacheSizeMB, long resourceAllocatorCacheMaxAge,
-            boolean disableHandleUseAfterFreeCheck);
+            boolean disableHandleUseAfterFreeCheck,
+            int preferredShaderLanguage,
+            boolean forceGLES2Context);
     private static native void nSetBuilderFeatureLevel(long nativeBuilder, int ordinal);
     private static native void nSetBuilderSharedContext(long nativeBuilder, long sharedContext);
     private static native void nSetBuilderPaused(long nativeBuilder, boolean paused);

android/filament-android/src/main/java/com/google/android/filament/RenderableManager.java

@@ -524,14 +524,7 @@ public class RenderableManager {
         }
 
         /**
-         * 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>
+         * Controls if the renderable has legacy vertex morphing targets, zero by default.
          *
          * For legacy morphing, the attached {@link VertexBuffer} must provide data in the
          * appropriate {@link VertexBuffer.VertexAttribute} slots (<code>MORPH_POSITION_0</code> etc).
@@ -549,6 +542,22 @@ 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.
          *
@@ -565,6 +574,17 @@ 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,
@@ -575,10 +595,8 @@ public class RenderableManager {
             return this;
         }
 
-        /**
-         * Utility method to specify morph target buffer for a primitive.
-         * For details, see the {@link RenderableManager.Builder#morphing}.
-         */
+        /** @deprecated */
+        @Deprecated
         @NonNull
         public Builder morphing(@IntRange(from = 0) int level,
                                 @IntRange(from = 0) int primitiveIndex,
@@ -687,6 +705,16 @@ 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,
@@ -697,10 +725,8 @@ public class RenderableManager {
                 morphTargetBuffer.getNativeObject(), offset, count);
     }
 
-    /**
-     * Utility method to change morph target buffer for the given primitive.
-     * For details, see the {@link RenderableManager#setMorphTargetBufferAt}.
-     */
+    /** @deprecated */
+    @Deprecated
     public void setMorphTargetBufferAt(@EntityInstance int i,
                                        @IntRange(from = 0) int level,
                                        @IntRange(from = 0) int primitiveIndex,
@@ -1006,6 +1032,7 @@ 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);

android/filament-android/src/main/java/com/google/android/filament/View.java

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

android/filament-utils-android/CMakeLists.txt

@@ -31,6 +31,7 @@ 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

android/gltfio-android/CMakeLists.txt

@@ -44,6 +44,7 @@ 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
@@ -86,7 +87,10 @@ set(GLTFIO_SRCS
         ${GLTFIO_DIR}/src/Wireframe.cpp
         ${GLTFIO_DIR}/src/Wireframe.h
         ${GLTFIO_DIR}/src/downcast.h
+        ${GLTFIO_DIR}/src/extended/AssetLoaderExtended.cpp
         ${GLTFIO_DIR}/src/extended/AssetLoaderExtended.h
+        ${GLTFIO_DIR}/src/extended/ResourceLoaderExtended.cpp
+        ${GLTFIO_DIR}/src/extended/ResourceLoaderExtended.h
         ${GLTFIO_DIR}/src/extended/TangentsJobExtended.cpp
         ${GLTFIO_DIR}/src/extended/TangentsJobExtended.h
         ${GLTFIO_DIR}/src/extended/TangentSpaceMeshWrapper.cpp
@@ -116,7 +120,6 @@ set(GLTFIO_INCLUDE_DIRS
         ../../third_party/cgltf
         ../../third_party/meshoptimizer/src
         ../../third_party/robin-map
-        ../../third_party/hat-trie
         ../../third_party/stb
         ../../libs/utils/include
         ../../libs/ktxreader/include

android/gradle.properties

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

android/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 #Wed Nov 17 10:40:18 PST 2021
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

android/samples/sample-hello-triangle/src/main/java/com/google/android/filament/hellotriangle/MainActivity.kt

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

build.sh

@@ -44,8 +44,6 @@ 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"
@@ -61,6 +59,14 @@ 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"
@@ -160,8 +166,6 @@ 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"
@@ -172,6 +176,10 @@ MATOPT_GRADLE_OPTION=""
 
 ASAN_UBSAN_OPTION=""
 
+BACKEND_DEBUG_FLAG_OPTION=""
+
+STEREOSCOPIC_OPTION=""
+
 IOS_BUILD_SIMULATOR=false
 BUILD_UNIVERSAL_LIBRARIES=false
 
@@ -226,11 +234,12 @@ function build_desktop_target {
             -DIMPORT_EXECUTABLES_DIR=out \
             -DCMAKE_BUILD_TYPE="$1" \
             -DCMAKE_INSTALL_PREFIX="../${lc_target}/filament" \
-            ${SWIFTSHADER_OPTION} \
             ${EGL_ON_LINUX_OPTION} \
             ${MATDBG_OPTION} \
             ${MATOPT_OPTION} \
             ${ASAN_UBSAN_OPTION} \
+            ${BACKEND_DEBUG_FLAG_OPTION} \
+            ${STEREOSCOPIC_OPTION} \
             ${architectures} \
             ../..
         ln -sf "out/cmake-${lc_target}/compile_commands.json" \
@@ -289,6 +298,7 @@ function build_webgl_with_target {
             -DCMAKE_BUILD_TYPE="$1" \
             -DCMAKE_INSTALL_PREFIX="../webgl-${lc_target}/filament" \
             -DWEBGL=1 \
+            ${BACKEND_DEBUG_FLAG_OPTION} \
             ../..
         ln -sf "out/cmake-webgl-${lc_target}/compile_commands.json" \
            ../../compile_commands.json
@@ -363,6 +373,8 @@ 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
@@ -597,6 +609,7 @@ 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
@@ -730,6 +743,13 @@ function validate_build_command {
             exit 1
         fi
     fi
+
+    # Make sure FILAMENT_BACKEND_DEBUG_FLAG is only meant for debug builds
+    if [[ "${ISSUE_DEBUG_BUILD}" != "true" ]] && [[ ! -z "${BACKEND_DEBUG_FLAG_OPTION}" ]]; then
+        echo "Error: cannot specify FILAMENT_BACKEND_DEBUG_FLAG in non-debug build"
+        exit 1
+    fi
+
     set -e
 }
 
@@ -776,7 +796,7 @@ function check_debug_release_build {
 
 pushd "$(dirname "$0")" > /dev/null
 
-while getopts ":hacCfgijmp:q:uvslwtedk:b" opt; do
+while getopts ":hacCfgijmp:q:uvslwedk:bx:S:" opt; do
     case ${opt} in
         h)
             print_help
@@ -840,7 +860,7 @@ while getopts ":hacCfgijmp:q:uvslwtedk:b" opt; do
                         echo "Platform must be one of [desktop|android|ios|webgl|all]"
                         echo ""
                         exit 1
-                    ;;    
+                    ;;
                 esac
             done
             ;;
@@ -895,10 +915,6 @@ while getopts ":hacCfgijmp:q:uvslwtedk:b" 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."
@@ -918,6 +934,22 @@ while getopts ":hacCfgijmp:q:uvslwtedk:b" opt; do
         b)  ASAN_UBSAN_OPTION="-DFILAMENT_ENABLE_ASAN_UBSAN=ON"
             echo "Enabled ASAN/UBSAN"
             ;;
+        x)  BACKEND_DEBUG_FLAG_OPTION="-DFILAMENT_BACKEND_DEBUG_FLAG=${OPTARG}"
+            ;;
+        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 ""

build/android/build.sh

@@ -57,7 +57,8 @@ FILAMENT_NDK_VERSION=${FILAMENT_NDK_VERSION:-$(cat `dirname $0`/ndk.version)}
 
 # Install the required NDK version specifically (if not present)
 if [[ ! -d "${ANDROID_HOME}/ndk/$FILAMENT_NDK_VERSION" ]]; then
-    ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager "ndk;$FILAMENT_NDK_VERSION" > /dev/null
+    yes | ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager --licenses
+    ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager "ndk;$FILAMENT_NDK_VERSION"
 fi
 
 # Only build 1 64 bit target during presubmit to cut down build times during presubmit

build/android/ndk.version

@@ -1 +1 @@
-26.1.10909125
+27.0.11718014

build/swiftshader/Dockerfile

@@ -1,53 +0,0 @@
-# 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

build/swiftshader/gallery.py

@@ -1,56 +0,0 @@
-#!/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>
-""")

build/swiftshader/patch_00.diff

@@ -1,62 +0,0 @@
-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;

build/swiftshader/test.sh

@@ -1,127 +0,0 @@
-#!/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

docs/Filament.html

@@ -476,7 +476,7 @@ Energy conservation is one of the key components of a good BRDF for physically b
 <p>
 
 
-For the specular term, \(f_m\) is a mirror BRDF that can be modeled with the Fresnel law, noted \(F\) in the Cook-Torrance approximation of the microfacet model integration:
+For the specular term, \(f_r\) is a mirror BRDF that can be modeled with the Fresnel law, noted \(F\) in the Cook-Torrance approximation of the microfacet model integration:
 
 </p><p>
 
@@ -857,7 +857,7 @@ The full GLSL implementation of the standard model is shown in <a href="#listing
 <span class="line">    <span class="hljs-comment">// perceptually linear roughness to roughness (see parameterization)</span></span>
 <span class="line">    <span class="hljs-type">float</span> roughness = perceptualRoughness * perceptualRoughness;</span>
 <span class="line"></span>
-<span class="line">    <span class="hljs-type">float</span> D = D_GGX(NoH, a);</span>
+<span class="line">    <span class="hljs-type">float</span> D = D_GGX(NoH, roughness);</span>
 <span class="line">    <span class="hljs-type">vec3</span>  F = F_Schlick(LoH, f0);</span>
 <span class="line">    <span class="hljs-type">float</span> V = V_SmithGGXCorrelated(NoV, NoL, roughness);</span>
 <span class="line"></span>

docs/Materials.md.html

@@ -1397,7 +1397,7 @@ Type
 :    `string`
 
 Value
-:     Any of `opaque`, `transparent`, `fade`, `add`, `masked`, `multiply`, `screen`. Defaults to `opaque`.
+:     Any of `opaque`, `transparent`, `fade`, `add`, `masked`, `multiply`, `screen`, `custom`. Defaults to `opaque`.
 
 Description
 :     Defines how/if the rendered object is blended with the content of the render target.
@@ -1420,6 +1420,7 @@ 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.
@@ -1432,6 +1433,36 @@ 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
@@ -2394,6 +2425,7 @@ The following APIs are only available from the vertex block:
 **getWorldFromModelMatrix()**        | float4x4 |  Matrix that converts from model (object) space to world space
 **getWorldFromModelNormalMatrix()**  | float3x3 |  Matrix that converts normals from model (object) space to world space
 **getVertexIndex()**                 | int      |  Index of the current vertex
+**getEyeIndex()**                    | int      |  Index of the eye being rendered, starting at 0
 
 ### Fragment only
 

docs/viewer/index.html

@@ -43,7 +43,7 @@ filament-viewer::part(canvas) {
 </p>
 
 </main>
-<script src="https://unpkg.com/filament@1.44.0/filament.js"></script>
+<script src="https://unpkg.com/filament@1.51.6/filament.js"></script>
 <script src="https://unpkg.com/gltumble"></script>
 <script src="filament-viewer.js" type="module"></script>
 </body>

filament/CMakeLists.txt

@@ -163,6 +163,7 @@ set(PRIVATE_HDRS
         src/ResourceList.h
         src/ShadowMap.h
         src/ShadowMapManager.h
+        src/SharedHandle.h
         src/TypedUniformBuffer.h
         src/UniformBuffer.h
         src/components/CameraManager.h
@@ -214,6 +215,7 @@ set(PRIVATE_HDRS
 set(MATERIAL_SRCS
         src/materials/antiAliasing/fxaa.mat
         src/materials/antiAliasing/taa.mat
+        src/materials/blitDepth.mat
         src/materials/blitLow.mat
         src/materials/blitArray.mat
         src/materials/bloom/bloomDownsample.mat

filament/backend/CMakeLists.txt

@@ -66,11 +66,13 @@ set(PRIVATE_HDRS
 # OpenGL / OpenGL ES Sources
 # ==================================================================================================
 
-if (FILAMENT_SUPPORTS_OPENGL AND NOT FILAMENT_USE_EXTERNAL_GLES3 AND NOT FILAMENT_USE_SWIFTSHADER)
+if (FILAMENT_SUPPORTS_OPENGL AND NOT FILAMENT_USE_EXTERNAL_GLES3)
     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
@@ -166,8 +168,10 @@ endif()
 if (FILAMENT_SUPPORTS_VULKAN)
     list(APPEND SRCS
             include/backend/platforms/VulkanPlatform.h
-            src/vulkan/caching/VulkanDescriptorSet.cpp
-            src/vulkan/caching/VulkanDescriptorSet.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
@@ -413,7 +417,9 @@ 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
@@ -474,6 +480,10 @@ if (APPLE)
        # linker from removing "unused" symbols.
        target_link_libraries(backend_test_mac PRIVATE -force_load backend_test)
        set_target_properties(backend_test_mac PROPERTIES FOLDER Tests)
+
+       # This is needed after XCode 15.3
+       set_target_properties(backend_test_mac PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
+       set_target_properties(backend_test_mac PROPERTIES INSTALL_RPATH /usr/local/lib)
     endif()
 endif()
 

filament/backend/include/backend/DriverEnums.h

@@ -22,14 +22,17 @@
 #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>
@@ -90,12 +93,15 @@ static constexpr uint64_t SWAP_CHAIN_HAS_STENCIL_BUFFER         = SWAP_CHAIN_CON
  */
 static constexpr uint64_t SWAP_CHAIN_CONFIG_PROTECTED_CONTENT   = 0x40;
 
-
 static constexpr size_t MAX_VERTEX_ATTRIBUTE_COUNT  = 16;   // This is guaranteed by OpenGL ES.
 static constexpr size_t MAX_SAMPLER_COUNT           = 62;   // Maximum needed at feature level 3.
 static constexpr size_t MAX_VERTEX_BUFFER_COUNT     = 16;   // Max number of bound buffer objects.
 static constexpr size_t MAX_SSBO_COUNT              = 4;    // This is guaranteed by OpenGL ES.
 
+static constexpr size_t MAX_PUSH_CONSTANT_COUNT     = 32;   // Vulkan 1.1 spec allows for 128-byte
+                                                            // of push constant (we assume 4-byte
+                                                            // types).
+
 // Per feature level caps
 // Use (int)FeatureLevel to index this array
 static constexpr struct {
@@ -112,7 +118,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 = 10;  // This is guaranteed by OpenGL ES.
+static constexpr size_t CONFIG_UNIFORM_BINDING_COUNT = 9;   // This is guaranteed by OpenGL ES.
 static constexpr size_t CONFIG_SAMPLER_BINDING_COUNT = 4;   // This is guaranteed by OpenGL ES.
 
 /**
@@ -158,14 +164,16 @@ static constexpr const char* backendToString(Backend backend) {
 }
 
 /**
- * Defines the shader language. Similar to the above backend enum, but the OpenGL backend can select
- * between two shader languages: ESSL 1.0 and ESSL 3.0.
+ * Defines the shader language. Similar to the above backend enum, with some differences:
+ * - The OpenGL backend can select between two shader languages: ESSL 1.0 and ESSL 3.0.
+ * - The Metal backend can prefer precompiled Metal libraries, while falling back to MSL.
  */
 enum class ShaderLanguage {
     ESSL1 = 0,
     ESSL3 = 1,
     SPIRV = 2,
     MSL = 3,
+    METAL_LIBRARY = 4,
 };
 
 static constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguage) {
@@ -178,6 +186,8 @@ static constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguag
             return "SPIR-V";
         case ShaderLanguage::MSL:
             return "MSL";
+        case ShaderLanguage::METAL_LIBRARY:
+            return "Metal precompiled library";
     }
 }
 
@@ -327,7 +337,7 @@ enum class UniformType : uint8_t {
 /**
  * Supported constant parameter types
  */
- enum class ConstantType : uint8_t {
+enum class ConstantType : uint8_t {
   INT,
   FLOAT,
   BOOL
@@ -682,7 +692,7 @@ enum class TextureUsage : uint16_t {
     SUBPASS_INPUT       = 0x0020,            //!< Texture can be used as a subpass input
     BLIT_SRC            = 0x0040,            //!< Texture can be used the source of a blit()
     BLIT_DST            = 0x0080,            //!< Texture can be used the destination of a blit()
-    PROTECTED           = 0x0100,            //!< Texture can be used the destination of a blit()
+    PROTECTED           = 0x0100,            //!< Texture can be used for protected content
     DEFAULT             = UPLOADABLE | SAMPLEABLE   //!< Default texture usage
 };
 
@@ -1214,13 +1224,15 @@ struct StencilState {
     uint8_t padding = 0;
 };
 
+using PushConstantVariant = std::variant<int32_t, float, bool>;
+
 static_assert(sizeof(StencilState::StencilOperations) == 5u,
         "StencilOperations size not what was intended");
 
 static_assert(sizeof(StencilState) == 12u,
         "StencilState size not what was intended");
 
-using FrameScheduledCallback = void(*)(PresentCallable callable, void* user);
+using FrameScheduledCallback = utils::Invocable<void(backend::PresentCallable)>;
 
 enum class Workaround : uint16_t {
     // The EASU pass must split because shader compiler flattens early-exit branch
@@ -1237,18 +1249,9 @@ enum class Workaround : uint16_t {
     DISABLE_BLIT_INTO_TEXTURE_ARRAY,
     // Multiple workarounds needed for PowerVR GPUs
     POWER_VR_SHADER_WORKAROUNDS,
-    // The driver has some threads pinned, and we can't easily know on which core, it can hurt
-    // performance more if we end-up pinned on the same one.
-    DISABLE_THREAD_AFFINITY
 };
 
-//! The type of technique for stereoscopic rendering
-enum class StereoscopicType : uint8_t {
-    // Stereoscopic rendering is performed using instanced rendering technique.
-    INSTANCED,
-    // Stereoscopic rendering is performed using the multiview feature from the graphics backend.
-    MULTIVIEW,
-};
+using StereoscopicType = backend::Platform::StereoscopicType;
 
 } // namespace filament::backend
 

filament/backend/include/backend/Handle.h

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

filament/backend/include/backend/Platform.h

@@ -41,6 +41,26 @@ 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.
@@ -65,6 +85,17 @@ public:
          * Disable backend handles use-after-free checks.
          */
         bool disableHandleUseAfterFreeCheck = false;
+
+        /**
+         * Force GLES2 context if supported, or pretend the context is ES2. Only meaningful on
+         * GLES 3.x backends.
+         */
+        bool forceGLES2Context = false;
+
+        /**
+         * Sets the technique for stereoscopic rendering.
+         */
+        StereoscopicType stereoscopicType = StereoscopicType::NONE;
     };
 
     Platform() noexcept;

filament/backend/include/backend/PresentCallable.h

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

filament/backend/include/backend/Program.h

@@ -84,6 +84,9 @@ public:
     // null terminating character.
     Program& shader(ShaderStage shader, void const* data, size_t size);
 
+    // sets the language of the shader sources provided with shader() (defaults to ESSL3)
+    Program& shaderLanguage(ShaderLanguage shaderLanguage);
+
     // Note: This is only needed for GLES3.0 backends, because the layout(binding=) syntax is
     //       not permitted in glsl. The backend needs a way to associate a uniform block
     //       to a binding point.
@@ -114,6 +117,14 @@ public:
     Program& specializationConstants(
             utils::FixedCapacityVector<SpecializationConstant> specConstants) noexcept;
 
+    struct PushConstant {
+        utils::CString name;
+        ConstantType type;
+    };
+
+    Program& pushConstants(ShaderStage stage,
+            utils::FixedCapacityVector<PushConstant> constants) noexcept;
+
     Program& cacheId(uint64_t cacheId) noexcept;
 
     Program& multiview(bool multiview) noexcept;
@@ -136,6 +147,8 @@ public:
     utils::CString const& getName() const noexcept { return mName; }
     utils::CString& getName() noexcept { return mName; }
 
+    auto const& getShaderLanguage() const { return mShaderLanguage; }
+
     utils::FixedCapacityVector<SpecializationConstant> const& getSpecializationConstants() const noexcept {
         return mSpecializationConstants;
     }
@@ -143,6 +156,15 @@ public:
         return mSpecializationConstants;
     }
 
+    utils::FixedCapacityVector<PushConstant> const& getPushConstants(
+            ShaderStage stage) const noexcept {
+        return mPushConstants[static_cast<uint8_t>(stage)];
+    }
+
+    utils::FixedCapacityVector<PushConstant>& getPushConstants(ShaderStage stage) noexcept {
+        return mPushConstants[static_cast<uint8_t>(stage)];
+    }
+
     uint64_t getCacheId() const noexcept { return mCacheId; }
 
     bool isMultiview() const noexcept { return mMultiview; }
@@ -155,10 +177,12 @@ private:
     UniformBlockInfo mUniformBlocks = {};
     SamplerGroupInfo mSamplerGroups = {};
     ShaderSource mShadersSource;
+    ShaderLanguage mShaderLanguage = ShaderLanguage::ESSL3;
     utils::CString mName;
     uint64_t mCacheId{};
     utils::Invocable<utils::io::ostream&(utils::io::ostream& out)> mLogger;
     utils::FixedCapacityVector<SpecializationConstant> mSpecializationConstants;
+    std::array<utils::FixedCapacityVector<PushConstant>, SHADER_TYPE_COUNT> mPushConstants;
     utils::FixedCapacityVector<std::pair<utils::CString, uint8_t>> mAttributes;
     std::array<UniformInfo, Program::UNIFORM_BINDING_COUNT> mBindingUniformInfo;
     CompilerPriorityQueue mPriorityQueue = CompilerPriorityQueue::HIGH;

filament/backend/include/backend/TargetBufferInfo.h

@@ -29,17 +29,36 @@ namespace filament::backend {
 //! \privatesection
 
 struct TargetBufferInfo {
+    // note: the parameters of this constructor are not in the order of this structure's fields
+    TargetBufferInfo(Handle<HwTexture> handle, uint8_t level, uint16_t layer, uint8_t baseViewIndex) noexcept
+        : handle(handle), baseViewIndex(baseViewIndex), level(level), layer(layer) {
+    }
+
+    TargetBufferInfo(Handle<HwTexture> handle, uint8_t level, uint16_t layer) noexcept
+            : handle(handle), level(level), layer(layer) {
+    }
+
+    TargetBufferInfo(Handle<HwTexture> handle, uint8_t level) noexcept
+            : handle(handle), level(level) {
+    }
+
+    TargetBufferInfo(Handle<HwTexture> handle) noexcept // NOLINT(*-explicit-constructor)
+            : handle(handle) {
+    }
+
+    TargetBufferInfo() noexcept = default;
+
     // texture to be used as render target
     Handle<HwTexture> handle;
 
-    // starting layer index for multiview. This value is only used when the `layerCount` for the
+    // Starting layer index for multiview. This value is only used when the `layerCount` for the
     // render target is greater than 1.
     uint8_t baseViewIndex = 0;
 
     // level to be used
     uint8_t level = 0;
 
-    // for cubemaps and 3D textures. See TextureCubemapFace for the face->layer mapping
+    // For cubemaps and 3D textures. See TextureCubemapFace for the face->layer mapping
     uint16_t layer = 0;
 };
 
@@ -64,7 +83,7 @@ public:
 
     MRT() noexcept = default;
 
-    MRT(TargetBufferInfo const& color) noexcept // NOLINT(hicpp-explicit-conversions)
+    MRT(TargetBufferInfo const& color) noexcept // NOLINT(hicpp-explicit-conversions, *-explicit-constructor)
             : mInfos{ color } {
     }
 
@@ -84,7 +103,7 @@ public:
 
     // this is here for backward compatibility
     MRT(Handle<HwTexture> handle, uint8_t level, uint16_t layer) noexcept
-            : mInfos{{ handle, 0, level, layer }} {
+            : mInfos{{ handle, level, layer, 0 }} {
     }
 };
 

filament/backend/include/backend/platforms/OpenGLPlatform.h

@@ -140,6 +140,23 @@ public:
      */
     virtual uint32_t getDefaultFramebufferObject() noexcept;
 
+    /**
+     * Called by the backend when a frame starts.
+     * @param steady_clock_ns vsync time point on the monotonic clock
+     * @param refreshIntervalNs refresh interval in nanosecond
+     * @param frameId a frame id
+     */
+    virtual void beginFrame(
+            int64_t monotonic_clock_ns,
+            int64_t refreshIntervalNs,
+            uint32_t frameId) noexcept;
+
+    /**
+     * Called by the backend when a frame ends.
+     * @param frameId the frame id used in beginFrame
+     */
+    virtual void endFrame(
+            uint32_t frameId) noexcept;
 
     /**
      * Type of contexts available
@@ -191,6 +208,12 @@ public:
             utils::Invocable<void()> preContextChange,
             utils::Invocable<void(size_t index)> postContextChange) noexcept;
 
+    /**
+     * Called by the backend just before calling commit()
+     * @see commit()
+     */
+    virtual void preCommit() noexcept;
+
     /**
      * Called by the driver once the current frame finishes drawing. Typically, this should present
      * the drawSwapChain. This is for example where `eglMakeCurrent()` would be called.

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

@@ -22,6 +22,10 @@
 #include <backend/platforms/OpenGLPlatform.h>
 #include <backend/platforms/PlatformEGL.h>
 
+#include <utils/android/PerformanceHintManager.h>
+
+#include <chrono>
+
 #include <stddef.h>
 #include <stdint.h>
 
@@ -58,6 +62,13 @@ protected:
 
     void terminate() noexcept override;
 
+    void beginFrame(
+            int64_t monotonic_clock_ns,
+            int64_t refreshIntervalNs,
+            uint32_t frameId) noexcept override;
+
+    void preCommit() noexcept override;
+
     /**
      * Set the presentation time using `eglPresentationTimeANDROID`
      * @param presentationTimeInNanosecond
@@ -79,8 +90,18 @@ protected:
     AcquiredImage transformAcquiredImage(AcquiredImage source) noexcept override;
 
 private:
+    struct InitializeJvmForPerformanceManagerIfNeeded {
+        InitializeJvmForPerformanceManagerIfNeeded();
+    };
+
     int mOSVersion;
     ExternalStreamManagerAndroid& mExternalStreamManager;
+    InitializeJvmForPerformanceManagerIfNeeded const mInitializeJvmForPerformanceManagerIfNeeded;
+    utils::PerformanceHintManager mPerformanceHintManager;
+    utils::PerformanceHintManager::Session mPerformanceHintSession;
+
+    using clock = std::chrono::high_resolution_clock;
+    clock::time_point mStartTimeOfActualWork;
 };
 
 } // namespace filament::backend

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

@@ -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,6 +47,14 @@ 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
@@ -192,6 +200,13 @@ 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()
@@ -236,10 +251,9 @@ public:
     VkQueue getGraphicsQueue() const noexcept;
 
 private:
-    // Platform dependent helper methods
-    using ExtensionSet = std::unordered_set<std::string_view>;
-    static ExtensionSet getRequiredInstanceExtensions();
+    static ExtensionSet getSwapchainInstanceExtensions();
 
+    // Platform dependent helper methods
     using SurfaceBundle = std::tuple<VkSurfaceKHR, VkExtent2D>;
     static SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
             uint64_t flags) noexcept;

filament/backend/include/private/backend/CommandBufferQueue.h

@@ -82,6 +82,7 @@ public:
     void requestExit();
 
     // suspend or unsuspend the queue.
+    bool isPaused() const noexcept;
     void setPaused(bool paused);
 
     bool isExitRequested() const;

filament/backend/include/private/backend/CommandStream.h

@@ -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) noexcept {
+        static inline void execute(M&& method, D&& driver, CommandBase* base, intptr_t* next) {
             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) noexcept;
+    static void execute(Driver&, CommandBase* base, intptr_t* next);
 public:
     inline CustomCommand(CustomCommand&& rhs) = default;
     inline explicit CustomCommand(std::function<void()> cmd)

filament/backend/include/private/backend/Driver.h

@@ -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) noexcept;
+    virtual void execute(std::function<void(void)> const& fn);
 
     // This is called on debug build, or when enabled manually on the backend thread side.
     virtual void debugCommandBegin(CommandStream* cmds,

filament/backend/include/private/backend/DriverAPI.inc

@@ -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::FrameScheduledCallback, callback,
-        void*, user)
+        backend::CallbackHandler*, handler,
+        backend::FrameScheduledCallback&&, callback)
 
 DECL_DRIVER_API_N(setFrameCompletedCallback,
         backend::SwapChainHandle, sch,
         backend::CallbackHandler*, handler,
-        backend::CallbackHandler::Callback, callback,
-        void*, user)
+        utils::Invocable<void(void)>&&, callback)
 
 DECL_DRIVER_API_N(setPresentationTime,
         int64_t, monotonic_clock_ns)
@@ -300,9 +300,10 @@ 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_N(bool, isStereoSupported, backend::StereoscopicType, stereoscopicType)
+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)
@@ -432,6 +433,11 @@ DECL_DRIVER_API_N(bindSamplers,
         uint32_t, index,
         backend::SamplerGroupHandle, sbh)
 
+DECL_DRIVER_API_N(setPushConstant,
+        backend::ShaderStage, stage,
+        uint8_t, index,
+        backend::PushConstantVariant, value)
+
 DECL_DRIVER_API_N(insertEventMarker,
         const char*, string,
         uint32_t, len = 0)
@@ -495,7 +501,7 @@ DECL_DRIVER_API_N(blit,
         math::uint2, size)
 
 DECL_DRIVER_API_N(bindPipeline,
-        backend::PipelineState, state)
+        backend::PipelineState const&, state)
 
 DECL_DRIVER_API_N(bindRenderPrimitive,
         backend::RenderPrimitiveHandle, rph)

filament/backend/include/private/backend/HandleAllocator.h

@@ -65,7 +65,7 @@ public:
      *
      */
     template<typename D, typename ... ARGS>
-    Handle<D> allocateAndConstruct(ARGS&& ... args) noexcept {
+    Handle<D> allocateAndConstruct(ARGS&& ... args) {
         Handle<D> h{ allocateHandle<D>() };
         D* addr = handle_cast<D*>(h);
         new(addr) D(std::forward<ARGS>(args)...);
@@ -97,7 +97,7 @@ 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) noexcept {
+    destroyAndConstruct(Handle<B> const& handle, ARGS&& ... args) {
         assert_invariant(handle);
         D* addr = handle_cast<D*>(const_cast<Handle<B>&>(handle));
         assert_invariant(addr);
@@ -163,7 +163,7 @@ 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) noexcept {
+    handle_cast(Handle<B>& handle) {
         assert_invariant(handle);
         auto [p, tag] = handleToPointer(handle.getId());
 
@@ -173,8 +173,8 @@ public:
                 uint8_t const age = (tag & HANDLE_AGE_MASK) >> HANDLE_AGE_SHIFT;
                 auto const pNode = static_cast<typename Allocator::Node*>(p);
                 uint8_t const expectedAge = pNode[-1].age;
-                ASSERT_POSTCONDITION(expectedAge == age,
-                        "use-after-free of Handle with id=%d", handle.getId());
+                FILAMENT_CHECK_POSTCONDITION(expectedAge == age) <<
+                        "use-after-free of Handle with id=" << handle.getId();
             }
         }
 
@@ -185,7 +185,7 @@ 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) noexcept {
+    handle_cast(Handle<B> const& handle) {
         return handle_cast<Dp>(const_cast<Handle<B>&>(handle));
     }
 
@@ -240,8 +240,8 @@ private:
             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);
+                FILAMENT_CHECK_POSTCONDITION(expectedAge == age) <<
+                        "double-free of Handle of size " << size << " at " << p;
             }
             expectedAge = (expectedAge + 1) & 0xF; // fixme
 
@@ -317,7 +317,7 @@ private:
         return (id & HANDLE_HEAP_FLAG) == 0u;
     }
 
-    HandleBase::HandleId allocateHandleSlow(size_t size) noexcept;
+    HandleBase::HandleId allocateHandleSlow(size_t size);
     void deallocateHandleSlow(HandleBase::HandleId id, size_t size) noexcept;
 
     // We inline this because it's just 4 instructions in the fast case

filament/backend/src/Callable.cpp

@@ -27,8 +27,8 @@ PresentCallable::PresentCallable(PresentFn fn, void* user) noexcept
 }
 
 void PresentCallable::operator()(bool presentFrame) noexcept {
-    ASSERT_PRECONDITION(mPresentFn, "This PresentCallable was already called. " \
-            "PresentCallables should be called exactly once.");
+    FILAMENT_CHECK_PRECONDITION(mPresentFn) << "This PresentCallable was already called. "
+                                               "PresentCallables should be called exactly once.";
     mPresentFn(presentFrame, mUser);
     // Set mPresentFn to nullptr to denote that the callable has been called.
     mPresentFn = nullptr;

filament/backend/src/CircularBuffer.cpp

@@ -119,9 +119,9 @@ void* CircularBuffer::alloc(size_t size) noexcept {
         data = mmap(nullptr, size * 2 + BLOCK_SIZE,
                 PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 
-        ASSERT_POSTCONDITION(data,
-                "couldn't allocate %u KiB of virtual address space for the command buffer",
-                (size * 2 / 1024));
+        FILAMENT_CHECK_POSTCONDITION(data) <<
+                "couldn't allocate " << (size * 2 / 1024) <<
+                " KiB of virtual address space for the command buffer";
 
         slog.d << "WARNING: Using soft CircularBuffer (" << (size * 2 / 1024) << " KiB)"
                << io::endl;

filament/backend/src/CommandBufferQueue.cpp

@@ -57,6 +57,11 @@ void CommandBufferQueue::requestExit() {
     mCondition.notify_one();
 }
 
+bool CommandBufferQueue::isPaused() const noexcept {
+    std::lock_guard<utils::Mutex> const lock(mLock);
+    return mPaused;
+}
+
 void CommandBufferQueue::setPaused(bool paused) {
     std::lock_guard<utils::Mutex> const lock(mLock);
     if (paused) {
@@ -69,8 +74,6 @@ void CommandBufferQueue::setPaused(bool paused) {
 
 bool CommandBufferQueue::isExitRequested() const {
     std::lock_guard<utils::Mutex> const lock(mLock);
-    ASSERT_PRECONDITION( mExitRequested == 0 || mExitRequested == EXIT_REQUESTED,
-            "mExitRequested is corrupted (value = 0x%08x)!", mExitRequested);
     return (bool)mExitRequested;
 }
 
@@ -103,11 +106,11 @@ void CommandBufferQueue::flush() noexcept {
     mCondition.notify_one();
 
     // circular buffer is too small, we corrupted the stream
-    ASSERT_POSTCONDITION(used <= mFreeSpace,
+    FILAMENT_CHECK_POSTCONDITION(used <= mFreeSpace) <<
             "Backend CommandStream overflow. Commands are corrupted and unrecoverable.\n"
             "Please increase minCommandBufferSizeMB inside the Config passed to Engine::create.\n"
-            "Space used at this time: %u bytes, overflow: %u bytes",
-            (unsigned)used, unsigned(used - mFreeSpace));
+            "Space used at this time: " << used <<
+            " bytes, overflow: " << used - mFreeSpace << " bytes";
 
     // wait until there is enough space in the buffer
     mFreeSpace -= used;
@@ -126,9 +129,11 @@ void CommandBufferQueue::flush() noexcept {
 #endif
 
         SYSTRACE_NAME("waiting: CircularBuffer::flush()");
-        ASSERT_POSTCONDITION(!mPaused,
+
+        FILAMENT_CHECK_POSTCONDITION(!mPaused) <<
                 "CommandStream is full, but since the rendering thread is paused, "
-                "the buffer cannot flush and we will deadlock. Instead, abort.");
+                "the buffer cannot flush and we will deadlock. Instead, abort.";
+
         mCondition.wait(lock, [this, requiredSize]() -> bool {
             // TODO: on macOS, we need to call pumpEvents from time to time
             return mFreeSpace >= requiredSize;
@@ -144,10 +149,6 @@ std::vector<CommandBufferQueue::Range> CommandBufferQueue::waitForCommands() con
     while ((mCommandBuffersToExecute.empty() || mPaused) && !mExitRequested) {
         mCondition.wait(lock);
     }
-
-    ASSERT_PRECONDITION( mExitRequested == 0 || mExitRequested == EXIT_REQUESTED,
-            "mExitRequested is corrupted (value = 0x%08x)!", mExitRequested);
-
     return std::move(mCommandBuffersToExecute);
 }
 

filament/backend/src/CommandStream.cpp

@@ -149,7 +149,7 @@ void CommandType<void (Driver::*)(ARGS...)>::Command<METHOD>::log() noexcept  {
 
 // ------------------------------------------------------------------------------------------------
 
-void CustomCommand::execute(Driver&, CommandBase* base, intptr_t* next) noexcept {
+void CustomCommand::execute(Driver&, CommandBase* base, intptr_t* next) {
     *next = CustomCommand::align(sizeof(CustomCommand));
     static_cast<CustomCommand*>(base)->mCommand();
     static_cast<CustomCommand*>(base)->~CustomCommand();

filament/backend/src/Driver.cpp

@@ -214,7 +214,7 @@ size_t Driver::getElementTypeSize(ElementType type) noexcept {
 
 Driver::~Driver() noexcept = default;
 
-void Driver::execute(std::function<void(void)> const& fn) noexcept {
+void Driver::execute(std::function<void(void)> const& fn) {
     fn();
 }
 

filament/backend/src/HandleAllocator.cpp

@@ -107,15 +107,15 @@ 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) noexcept {
+HandleBase::HandleId HandleAllocator<P0, P1, P2>::allocateHandleSlow(size_t size) {
     void* p = ::malloc(size);
     std::unique_lock lock(mLock);
 
     HandleBase::HandleId id = (++mId) | HANDLE_HEAP_FLAG;
 
-    ASSERT_POSTCONDITION(mId < HANDLE_HEAP_FLAG,
+    FILAMENT_CHECK_POSTCONDITION(mId < HANDLE_HEAP_FLAG) <<
             "No more Handle ids available! This can happen if HandleAllocator arena has been full"
-            " for a while. Please increase FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB");
+            " for a while. Please increase FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB";
 
     mOverflowMap.emplace(id, p);
     lock.unlock();

filament/backend/src/PlatformFactory.cpp

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

filament/backend/src/Program.cpp

@@ -21,7 +21,7 @@ namespace filament::backend {
 using namespace utils;
 
 // We want these in the .cpp file, so they're not inlined (not worth it)
-Program::Program() noexcept { // NOLINT(modernize-use-equals-default)
+Program::Program() noexcept {  // NOLINT(modernize-use-equals-default)
 }
 
 Program::Program(Program&& rhs) noexcept = default;
@@ -47,6 +47,11 @@ Program& Program::shader(ShaderStage shader, void const* data, size_t size) {
     return *this;
 }
 
+Program& Program::shaderLanguage(ShaderLanguage shaderLanguage) {
+    mShaderLanguage = shaderLanguage;
+    return *this;
+}
+
 Program& Program::uniformBlockBindings(
         FixedCapacityVector<std::pair<utils::CString, uint8_t>> const& uniformBlockBindings) noexcept {
     for (auto const& item : uniformBlockBindings) {
@@ -86,6 +91,12 @@ Program& Program::specializationConstants(
     return *this;
 }
 
+Program& Program::pushConstants(ShaderStage stage,
+        utils::FixedCapacityVector<PushConstant> constants) noexcept {
+    mPushConstants[static_cast<uint8_t>(stage)] = std::move(constants);
+    return *this;
+}
+
 Program& Program::cacheId(uint64_t cacheId) noexcept {
     mCacheId = cacheId;
     return *this;

filament/backend/src/VirtualMachineEnv.cpp

@@ -16,13 +16,23 @@
 
 #include "private/backend/VirtualMachineEnv.h"
 
+#include <utils/compiler.h>
 #include <utils/debug.h>
 
+#include <jni.h>
+
 namespace filament {
 
 JavaVM* VirtualMachineEnv::sVirtualMachine = nullptr;
 
-// This is called when the library is loaded. We need this to get a reference to the global VM
+/*
+ * This is typically called by filament_jni.so when it is loaded. If filament_jni.so is not used,
+ * then this must be called manually -- however, this is a problem because VirtualMachineEnv.h
+ * is currently private and part of backend.
+ * For now, we authorize this usage, but we will need to fix it; by making a proper public
+ * API for this.
+ */
+UTILS_PUBLIC
 UTILS_NOINLINE
 jint VirtualMachineEnv::JNI_OnLoad(JavaVM* vm) noexcept {
     JNIEnv* env = nullptr;

filament/backend/src/metal/MetalBlitter.mm

@@ -109,9 +109,8 @@ inline bool MTLSizeEqual(T a, T b) noexcept {
 MetalBlitter::MetalBlitter(MetalContext& context) noexcept : mContext(context) { }
 
 void MetalBlitter::blit(id<MTLCommandBuffer> cmdBuffer, const BlitArgs& args, const char* label) {
-
-    ASSERT_PRECONDITION(args.source.region.size.depth == args.destination.region.size.depth,
-            "Blitting requires the source and destination regions to have the same depth.");
+    FILAMENT_CHECK_PRECONDITION(args.source.region.size.depth == args.destination.region.size.depth)
+            << "Blitting requires the source and destination regions to have the same depth.";
 
     // Determine if the blit for color or depth are eligible to use a MTLBlitCommandEncoder.
     // blitFastPath returns true upon success.
@@ -327,7 +326,8 @@ id<MTLFunction> MetalBlitter::compileFragmentFunction(BlitFunctionKey key) const
             utils::slog.e << description << utils::io::endl;
         }
     }
-    ASSERT_POSTCONDITION(library && function, "Unable to compile fragment shader for MetalBlitter.");
+    FILAMENT_CHECK_POSTCONDITION(library && function)
+            << "Unable to compile fragment shader for MetalBlitter.";
 
     return function;
 }
@@ -352,7 +352,8 @@ id<MTLFunction> MetalBlitter::getBlitVertexFunction() {
             utils::slog.e << description << utils::io::endl;
         }
     }
-    ASSERT_POSTCONDITION(library && function, "Unable to compile vertex shader for MetalBlitter.");
+    FILAMENT_CHECK_POSTCONDITION(library && function)
+            << "Unable to compile vertex shader for MetalBlitter.";
 
     mVertexFunction = function;
 

filament/backend/src/metal/MetalBuffer.h

@@ -18,6 +18,7 @@
 #define TNT_FILAMENT_DRIVER_METALBUFFER_H
 
 #include "MetalContext.h"
+#include "MetalPlatform.h"
 
 #include <backend/DriverEnums.h>
 
@@ -28,20 +29,88 @@
 #include <utility>
 #include <memory>
 #include <atomic>
+#include <chrono>
 
 namespace filament::backend {
 
-class TrackedMetalBuffer {
+class ScopedAllocationTimer {
 public:
-    TrackedMetalBuffer() noexcept : mBuffer(nil) {}
-    TrackedMetalBuffer(id<MTLBuffer> buffer) noexcept : mBuffer(buffer) {
-        if (buffer) {
-            aliveBuffers++;
+    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) {
-            aliveBuffers--;
+            assert_invariant(mType != Type::NONE);
+            aliveBuffers[toIndex(mType)]--;
         }
     }
 
@@ -57,18 +126,31 @@ public:
     id<MTLBuffer> get() const noexcept { return mBuffer; }
     operator bool() const noexcept { return bool(mBuffer); }
 
-    static uint64_t getAliveBuffers() { return aliveBuffers; }
+    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 {
-        id<MTLBuffer> temp = mBuffer;
-        mBuffer = other.mBuffer;
-        other.mBuffer = temp;
+        std::swap(mBuffer, other.mBuffer);
+        std::swap(mType, other.mType);
     }
 
     id<MTLBuffer> mBuffer;
+    Type mType = Type::NONE;
 
-    static std::atomic<uint64_t> aliveBuffers;
+    static MetalPlatform* platform;
+    static std::array<uint64_t, TypeCount> aliveBuffers;
 };
 
 class MetalBuffer {
@@ -171,7 +253,9 @@ public:
           mBufferOptions(options),
           mSlotSizeBytes(computeSlotSize(layout)),
           mSlotCount(slotCount) {
-        mBuffer = [device newBufferWithLength:mSlotSizeBytes * mSlotCount options:mBufferOptions];
+        ScopedAllocationTimer timer("ring");
+        mBuffer = { [device newBufferWithLength:mSlotSizeBytes * mSlotCount options:mBufferOptions],
+            TrackedMetalBuffer::Type::RING };
         assert_invariant(mBuffer);
     }
 
@@ -189,9 +273,13 @@ public:
             // If we already have an aux buffer, it will get freed here, unless it has been retained
             // by a MTLCommandBuffer. In that case, it will be freed when the command buffer
             // finishes executing.
-            mAuxBuffer = [mDevice newBufferWithLength:mSlotSizeBytes options:mBufferOptions];
+            {
+                ScopedAllocationTimer timer("ring");
+                mAuxBuffer = { [mDevice newBufferWithLength:mSlotSizeBytes options:mBufferOptions],
+                    TrackedMetalBuffer::Type::RING };
+            }
             assert_invariant(mAuxBuffer);
-            return {mAuxBuffer.get(), 0};
+            return { mAuxBuffer.get(), 0 };
         }
         mCurrentSlot = (mCurrentSlot + 1) % mSlotCount;
         mOccupiedSlots->fetch_add(1, std::memory_order_relaxed);

filament/backend/src/metal/MetalBuffer.mm

@@ -22,7 +22,9 @@
 namespace filament {
 namespace backend {
 
-std::atomic<uint64_t> TrackedMetalBuffer::aliveBuffers = 0;
+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) {
@@ -37,8 +39,13 @@ MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType,
     }
 
     // Otherwise, we allocate a private GPU buffer.
-    mBuffer = [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate];
-    ASSERT_POSTCONDITION(mBuffer, "Could not allocate Metal buffer of size %zu.", size);
+    {
+        ScopedAllocationTimer timer("generic");
+        mBuffer = { [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate],
+            TrackedMetalBuffer::Type::GENERIC };
+    }
+    FILAMENT_CHECK_POSTCONDITION(mBuffer)
+            << "Could not allocate Metal buffer of size " << size << ".";
 }
 
 MetalBuffer::~MetalBuffer() {
@@ -51,9 +58,9 @@ void MetalBuffer::copyIntoBuffer(void* src, size_t size, size_t byteOffset) {
     if (size <= 0) {
         return;
     }
-    ASSERT_PRECONDITION(size + byteOffset <= mBufferSize,
-            "Attempting to copy %zu bytes into a buffer of size %zu at offset %zu",
-            size, mBufferSize, byteOffset);
+    FILAMENT_CHECK_PRECONDITION(size + byteOffset <= mBufferSize)
+            << "Attempting to copy " << size << " bytes into a buffer of size " << mBufferSize
+            << " at offset " << byteOffset;
 
     // Either copy into the Metal buffer or into our cpu buffer.
     if (mCpuBuffer) {
@@ -67,7 +74,7 @@ void MetalBuffer::copyIntoBuffer(void* src, size_t size, size_t byteOffset) {
     memcpy(staging->buffer.get().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");
+    FILAMENT_CHECK_PRECONDITION(!(byteOffset & 0x3u)) << "byteOffset must be a multiple of 4";
 
     // Encode a blit from the staging buffer into the private GPU buffer.
     id<MTLCommandBuffer> cmdBuffer = getPendingCommandBuffer(&mContext);

filament/backend/src/metal/MetalBufferPool.mm

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

filament/backend/src/metal/MetalContext.h

@@ -55,6 +55,18 @@ 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) {}
@@ -109,6 +121,8 @@ 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.

filament/backend/src/metal/MetalContext.mm

@@ -113,7 +113,8 @@ id<MTLCommandBuffer> getPendingCommandBuffer(MetalContext* context) {
             }
         }
     }];
-    ASSERT_POSTCONDITION(context->pendingCommandBuffer, "Could not obtain command buffer.");
+    FILAMENT_CHECK_POSTCONDITION(context->pendingCommandBuffer)
+            << "Could not obtain command buffer.";
     return context->pendingCommandBuffer;
 }
 
@@ -153,5 +154,68 @@ 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

filament/backend/src/metal/MetalDriver.h

@@ -17,6 +17,7 @@
 #ifndef TNT_FILAMENT_DRIVER_METALDRIVER_H
 #define TNT_FILAMENT_DRIVER_METALDRIVER_H
 
+#include <backend/DriverEnums.h>
 #include "private/backend/Driver.h"
 #include "DriverBase.h"
 
@@ -140,6 +141,7 @@ private:
     void enumerateBoundBuffers(BufferObjectBinding bindingType,
             const std::function<void(const BufferState&, MetalBuffer*, uint32_t)>& f);
 
+    backend::StereoscopicType const mStereoscopicType;
 };
 
 } // namespace backend

filament/backend/src/metal/MetalDriver.mm

@@ -102,9 +102,13 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
           mContext(new MetalContext(driverConfig.textureUseAfterFreePoolSize)),
           mHandleAllocator("Handles",
                   driverConfig.handleArenaSize,
-                  driverConfig.disableHandleUseAfterFreeCheck) {
+                  driverConfig.disableHandleUseAfterFreeCheck),
+          mStereoscopicType(driverConfig.stereoscopicType) {
     mContext->driver = this;
 
+    TrackedMetalBuffer::setPlatform(platform);
+    ScopedAllocationTimer::setPlatform(platform);
+
     mContext->device = mPlatform.createDevice();
     assert_invariant(mContext->device);
 
@@ -177,7 +181,8 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
 
     CVReturn success = CVMetalTextureCacheCreate(kCFAllocatorDefault, nullptr, mContext->device,
             nullptr, &mContext->textureCache);
-    ASSERT_POSTCONDITION(success == kCVReturnSuccess, "Could not create Metal texture cache.");
+    FILAMENT_CHECK_POSTCONDITION(success == kCVReturnSuccess)
+            << "Could not create Metal texture cache.";
 
     if (@available(iOS 12, *)) {
         dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);
@@ -198,6 +203,8 @@ 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);
@@ -212,25 +219,32 @@ void MetalDriver::tick(int) {
     executeTickOps();
 }
 
-void MetalDriver::beginFrame(int64_t monotonic_clock_ns, uint32_t frameId) {
+void MetalDriver::beginFrame(int64_t monotonic_clock_ns,
+        int64_t refreshIntervalNs, uint32_t frameId) {
 #if defined(FILAMENT_METAL_PROFILING)
     os_signpost_interval_begin(mContext->log, mContext->signpostId, "Frame encoding", "%{public}d", frameId);
 #endif
     if (mPlatform.hasDebugUpdateStatFunc()) {
         mPlatform.debugUpdateStat("filament.metal.alive_buffers", TrackedMetalBuffer::getAliveBuffers());
+        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,
-        FrameScheduledCallback callback, void* user) {
+void MetalDriver::setFrameScheduledCallback(
+        Handle<HwSwapChain> sch, CallbackHandler* handler, FrameScheduledCallback&& callback) {
     auto* swapChain = handle_cast<MetalSwapChain>(sch);
-    swapChain->setFrameScheduledCallback(callback, user);
+    swapChain->setFrameScheduledCallback(handler, std::move(callback));
 }
 
-void MetalDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
+void MetalDriver::setFrameCompletedCallback(
+        Handle<HwSwapChain> sch, CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
     auto* swapChain = handle_cast<MetalSwapChain>(sch);
-    swapChain->setFrameCompletedCallback(handler, callback, user);
+    swapChain->setFrameCompletedCallback(handler, std::move(callback));
 }
 
 void MetalDriver::execute(std::function<void(void)> const& fn) noexcept {
@@ -276,14 +290,14 @@ void MetalDriver::endFrame(uint32_t frameId) {
 }
 
 void MetalDriver::flush(int) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-                        "flush must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "flush must be called outside of a render pass.";
     submitPendingCommands(mContext);
 }
 
 void MetalDriver::finish(int) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-            "finish must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "finish must be called outside of a render pass.";
     // Wait for all frames to finish by submitting and waiting on a dummy command buffer.
     submitPendingCommands(mContext);
     id<MTLCommandBuffer> oneOffBuffer = [mContext->commandQueue commandBuffer];
@@ -344,19 +358,19 @@ void MetalDriver::importTextureR(Handle<HwTexture> th, intptr_t i,
         TextureFormat format, uint8_t samples, uint32_t width, uint32_t height,
         uint32_t depth, TextureUsage usage) {
     id<MTLTexture> metalTexture = (id<MTLTexture>) CFBridgingRelease((void*) i);
-    ASSERT_PRECONDITION(metalTexture.width == width,
-            "Imported id<MTLTexture> width (%d) != Filament texture width (%d)",
-            metalTexture.width, width);
-    ASSERT_PRECONDITION(metalTexture.height == height,
-            "Imported id<MTLTexture> height (%d) != Filament texture height (%d)",
-            metalTexture.height, height);
-    ASSERT_PRECONDITION(metalTexture.mipmapLevelCount == levels,
-            "Imported id<MTLTexture> levels (%d) != Filament texture levels (%d)",
-            metalTexture.mipmapLevelCount, levels);
+    FILAMENT_CHECK_PRECONDITION(metalTexture.width == width)
+            << "Imported id<MTLTexture> width (" << metalTexture.width
+            << ") != Filament texture width (" << width << ")";
+    FILAMENT_CHECK_PRECONDITION(metalTexture.height == height)
+            << "Imported id<MTLTexture> height (" << metalTexture.height
+            << ") != Filament texture height (" << height << ")";
+    FILAMENT_CHECK_PRECONDITION(metalTexture.mipmapLevelCount == levels)
+            << "Imported id<MTLTexture> levels (" << metalTexture.mipmapLevelCount
+            << ") != Filament texture levels (" << levels << ")";
     MTLTextureType filamentMetalType = getMetalType(target);
-    ASSERT_PRECONDITION(metalTexture.textureType == filamentMetalType,
-            "Imported id<MTLTexture> type (%d) != Filament texture type (%d)",
-            metalTexture.textureType, filamentMetalType);
+    FILAMENT_CHECK_PRECONDITION(metalTexture.textureType == filamentMetalType)
+            << "Imported id<MTLTexture> type (" << metalTexture.textureType
+            << ") != Filament texture type (" << filamentMetalType << ")";
     mContext->textures.insert(construct_handle<MetalTexture>(th, *mContext,
         target, levels, format, samples, width, height, depth, usage, metalTexture));
 }
@@ -385,8 +399,8 @@ void MetalDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
         TargetBufferFlags targetBufferFlags, uint32_t width, uint32_t height,
         uint8_t samples, uint8_t layerCount, MRT color,
         TargetBufferInfo depth, TargetBufferInfo stencil) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-            "createRenderTarget must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "createRenderTarget must be called outside of a render pass.";
     // Clamp sample count to what the device supports.
     auto& sc = mContext->sampleCountLookup;
     samples = sc[std::min(MAX_SAMPLE_COUNT, samples)];
@@ -397,33 +411,33 @@ void MetalDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
             continue;
         }
         const auto& buffer = color[i];
-        ASSERT_PRECONDITION(buffer.handle,
-                "The COLOR%u flag was specified, but invalid color handle provided.", i);
+        FILAMENT_CHECK_PRECONDITION(buffer.handle)
+                << "The COLOR" << i << " flag was specified, but invalid color handle provided.";
         auto colorTexture = handle_cast<MetalTexture>(buffer.handle);
-        ASSERT_PRECONDITION(colorTexture->getMtlTextureForWrite(),
-                "Color texture passed to render target has no texture allocation");
+        FILAMENT_CHECK_PRECONDITION(colorTexture->getMtlTextureForWrite())
+                << "Color texture passed to render target has no texture allocation";
         colorTexture->extendLodRangeTo(buffer.level);
         colorAttachments[i] = { colorTexture, color[i].level, color[i].layer };
     }
 
     MetalRenderTarget::Attachment depthAttachment = {};
     if (any(targetBufferFlags & TargetBufferFlags::DEPTH)) {
-        ASSERT_PRECONDITION(depth.handle,
-                "The DEPTH flag was specified, but invalid depth handle provided.");
+        FILAMENT_CHECK_PRECONDITION(depth.handle)
+                << "The DEPTH flag was specified, but invalid depth handle provided.";
         auto depthTexture = handle_cast<MetalTexture>(depth.handle);
-        ASSERT_PRECONDITION(depthTexture->getMtlTextureForWrite(),
-                "Depth texture passed to render target has no texture allocation.");
+        FILAMENT_CHECK_PRECONDITION(depthTexture->getMtlTextureForWrite())
+                << "Depth texture passed to render target has no texture allocation.";
         depthTexture->extendLodRangeTo(depth.level);
         depthAttachment = { depthTexture, depth.level, depth.layer };
     }
 
     MetalRenderTarget::Attachment stencilAttachment = {};
     if (any(targetBufferFlags & TargetBufferFlags::STENCIL)) {
-        ASSERT_PRECONDITION(stencil.handle,
-                "The STENCIL flag was specified, but invalid stencil handle provided.");
+        FILAMENT_CHECK_PRECONDITION(stencil.handle)
+                << "The STENCIL flag was specified, but invalid stencil handle provided.";
         auto stencilTexture = handle_cast<MetalTexture>(stencil.handle);
-        ASSERT_PRECONDITION(stencilTexture->getMtlTextureForWrite(),
-                "Stencil texture passed to render target has no texture allocation.");
+        FILAMENT_CHECK_PRECONDITION(stencilTexture->getMtlTextureForWrite())
+                << "Stencil texture passed to render target has no texture allocation.";
         stencilTexture->extendLodRangeTo(stencil.level);
         stencilAttachment = { stencilTexture, stencil.level, stencil.layer };
     }
@@ -787,13 +801,15 @@ bool MetalDriver::isProtectedContentSupported() {
     return false;
 }
 
-bool MetalDriver::isStereoSupported(backend::StereoscopicType stereoscopicType) {
-    switch (stereoscopicType) {
-    case backend::StereoscopicType::INSTANCED:
-        return true;
-    case backend::StereoscopicType::MULTIVIEW:
-        // TODO: implement multiview feature in Metal.
-        return false;
+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;
     }
 }
 
@@ -805,6 +821,10 @@ bool MetalDriver::isDepthStencilResolveSupported() {
     return false;
 }
 
+bool MetalDriver::isDepthStencilBlitSupported(TextureFormat format) {
+    return true;
+}
+
 bool MetalDriver::isProtectedTexturesSupported() {
     return false;
 }
@@ -862,8 +882,8 @@ void MetalDriver::updateIndexBuffer(Handle<HwIndexBuffer> ibh, BufferDescriptor&
 
 void MetalDriver::updateBufferObject(Handle<HwBufferObject> boh, BufferDescriptor&& data,
         uint32_t byteOffset) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-            "updateBufferObject must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "updateBufferObject must be called outside of a render pass.";
     auto* bo = handle_cast<MetalBufferObject>(boh);
     bo->updateBuffer(data.buffer, data.size, byteOffset);
     scheduleDestroy(std::move(data));
@@ -902,8 +922,8 @@ void MetalDriver::update3DImage(Handle<HwTexture> th, uint32_t level,
         uint32_t xoffset, uint32_t yoffset, uint32_t zoffset,
         uint32_t width, uint32_t height, uint32_t depth,
         PixelBufferDescriptor&& data) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-            "update3DImage must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "update3DImage must be called outside of a render pass.";
     auto tex = handle_cast<MetalTexture>(th);
     tex->loadImage(level, MTLRegionMake3D(xoffset, yoffset, zoffset, width, height, depth), data);
     scheduleDestroy(std::move(data));
@@ -919,15 +939,15 @@ void MetalDriver::setupExternalImage(void* image) {
 }
 
 void MetalDriver::setExternalImage(Handle<HwTexture> th, void* image) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-            "setExternalImage must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "setExternalImage must be called outside of a render pass.";
     auto texture = handle_cast<MetalTexture>(th);
     texture->externalImage.set((CVPixelBufferRef) image);
 }
 
 void MetalDriver::setExternalImagePlane(Handle<HwTexture> th, void* image, uint32_t plane) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-            "setExternalImagePlane must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "setExternalImagePlane must be called outside of a render pass.";
     auto texture = handle_cast<MetalTexture>(th);
     texture->externalImage.set((CVPixelBufferRef) image, plane);
 }
@@ -942,15 +962,15 @@ TimerQueryResult MetalDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint6
 }
 
 void MetalDriver::generateMipmaps(Handle<HwTexture> th) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-                        "generateMipmaps must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "generateMipmaps must be called outside of a render pass.";
     auto tex = handle_cast<MetalTexture>(th);
     tex->generateMipmaps();
 }
 
 void MetalDriver::updateSamplerGroup(Handle<HwSamplerGroup> sbh, BufferDescriptor&& data) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-            "updateSamplerGroup must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "updateSamplerGroup must be called outside of a render pass.";
 
     auto sb = handle_cast<MetalSamplerGroup>(sbh);
     assert_invariant(sb->size == data.size / sizeof(SamplerDescriptor));
@@ -1089,6 +1109,10 @@ 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) {}
@@ -1236,6 +1260,16 @@ 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) {
+    FILAMENT_CHECK_PRECONDITION(isInRenderPass(mContext))
+            << "setPushConstant must be called inside a render pass.";
+    assert_invariant(static_cast<size_t>(stage) < mContext->currentPushConstants.size());
+    MetalPushConstantBuffer& pushConstants =
+            mContext->currentPushConstants[static_cast<size_t>(stage)];
+    pushConstants.setPushConstant(value, index);
+}
+
 void MetalDriver::insertEventMarker(const char* string, uint32_t len) {
 
 }
@@ -1286,8 +1320,8 @@ void MetalDriver::stopCapture(int) {
 
 void MetalDriver::readPixels(Handle<HwRenderTarget> src, uint32_t x, uint32_t y, uint32_t width,
         uint32_t height, PixelBufferDescriptor&& data) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-                        "readPixels must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "readPixels must be called outside of a render pass.";
 
     auto srcTarget = handle_cast<MetalRenderTarget>(src);
     // We always readPixels from the COLOR0 attachment.
@@ -1301,17 +1335,19 @@ void MetalDriver::readPixels(Handle<HwRenderTarget> src, uint32_t x, uint32_t y,
     width = std::min(static_cast<uint32_t>(srcTextureSize.width), width);
 
     const MTLPixelFormat format = getMetalFormat(data.format, data.type);
-    ASSERT_PRECONDITION(format != MTLPixelFormatInvalid,
-            "The chosen combination of PixelDataFormat (%d) and PixelDataType (%d) is not supported for "
-            "readPixels.", (int) data.format, (int) data.type);
+    FILAMENT_CHECK_PRECONDITION(format != MTLPixelFormatInvalid)
+            << "The chosen combination of PixelDataFormat (" << (int)data.format
+            << ") and PixelDataType (" << (int)data.type
+            << ") is not supported for "
+               "readPixels.";
 
     const bool formatConversionNecessary = srcTexture.pixelFormat != format;
 
     // TODO: MetalBlitter does not currently support format conversions to integer types.
     // The format and type must match the source pixel format exactly.
-    ASSERT_PRECONDITION(!formatConversionNecessary || !isMetalFormatInteger(format),
-            "readPixels does not support integer format conversions from MTLPixelFormat (%d) to (%d).",
-            (int) srcTexture.pixelFormat, (int) format);
+    FILAMENT_CHECK_PRECONDITION(!formatConversionNecessary || !isMetalFormatInteger(format))
+            << "readPixels does not support integer format conversions from MTLPixelFormat ("
+            << (int)srcTexture.pixelFormat << ") to (" << (int)format << ").";
 
     MTLTextureDescriptor* textureDescriptor =
             [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:format
@@ -1377,31 +1413,31 @@ void MetalDriver::resolve(
     assert_invariant(srcTexture);
     assert_invariant(dstTexture);
 
-    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder == nil,
-            "resolve() cannot be invoked inside a render pass.");
+    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder == nil)
+            << "resolve() cannot be invoked inside a render pass.";
 
-    ASSERT_PRECONDITION(
-            dstTexture->width == srcTexture->width && dstTexture->height == srcTexture->height,
-            "invalid resolve: src and dst sizes don't match");
+    FILAMENT_CHECK_PRECONDITION(
+            dstTexture->width == srcTexture->width && dstTexture->height == srcTexture->height)
+            << "invalid resolve: src and dst sizes don't match";
 
-    ASSERT_PRECONDITION(srcTexture->samples > 1 && dstTexture->samples == 1,
-            "invalid resolve: src.samples=%u, dst.samples=%u",
-            +srcTexture->samples, +dstTexture->samples);
+    FILAMENT_CHECK_PRECONDITION(srcTexture->samples > 1 && dstTexture->samples == 1)
+            << "invalid resolve: src.samples=" << +srcTexture->samples
+            << ", dst.samples=" << +dstTexture->samples;
 
-    ASSERT_PRECONDITION(srcTexture->format == dstTexture->format,
-            "src and dst texture format don't match");
+    FILAMENT_CHECK_PRECONDITION(srcTexture->format == dstTexture->format)
+            << "src and dst texture format don't match";
 
-    ASSERT_PRECONDITION(!isDepthFormat(srcTexture->format),
-            "can't resolve depth formats");
+    FILAMENT_CHECK_PRECONDITION(!isDepthFormat(srcTexture->format))
+            << "can't resolve depth formats";
 
-    ASSERT_PRECONDITION(!isStencilFormat(srcTexture->format),
-            "can't resolve stencil formats");
+    FILAMENT_CHECK_PRECONDITION(!isStencilFormat(srcTexture->format))
+            << "can't resolve stencil formats";
 
-    ASSERT_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST),
-            "texture doesn't have BLIT_DST");
+    FILAMENT_CHECK_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST))
+            << "texture doesn't have BLIT_DST";
 
-    ASSERT_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC),
-            "texture doesn't have BLIT_SRC");
+    FILAMENT_CHECK_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC))
+            << "texture doesn't have BLIT_SRC";
 
     // FIXME: on metal the blit() call below always take the slow path (using a shader)
 
@@ -1426,21 +1462,22 @@ void MetalDriver::blit(
     assert_invariant(srcTexture);
     assert_invariant(dstTexture);
 
-    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder == nil,
-            "blit() cannot be invoked inside a render pass.");
+    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder == nil)
+            << "blit() cannot be invoked inside a render pass.";
 
-    ASSERT_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST),
-            "texture doesn't have BLIT_DST");
+    FILAMENT_CHECK_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST))
+            << "texture doesn't have BLIT_DST";
 
-    ASSERT_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC),
-            "texture doesn't have BLIT_SRC");
+    FILAMENT_CHECK_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC))
+            << "texture doesn't have BLIT_SRC";
 
-    ASSERT_PRECONDITION(srcTexture->format == dstTexture->format,
-            "src and dst texture format don't match");
+    FILAMENT_CHECK_PRECONDITION(srcTexture->format == dstTexture->format)
+            << "src and dst texture format don't match";
 
-    ASSERT_PRECONDITION(isBlitableTextureType(srcTexture->getMtlTextureForRead().textureType) &&
-                        isBlitableTextureType(dstTexture->getMtlTextureForWrite().textureType),
-            "Metal does not support blitting to/from non-2D textures.");
+    FILAMENT_CHECK_PRECONDITION(
+            isBlitableTextureType(srcTexture->getMtlTextureForRead().textureType) &&
+            isBlitableTextureType(dstTexture->getMtlTextureForWrite().textureType))
+            << "Metal does not support blitting to/from non-2D textures.";
 
     MetalBlitter::BlitArgs args{};
     args.filter = SamplerMagFilter::NEAREST;
@@ -1478,18 +1515,18 @@ void MetalDriver::blitDEPRECATED(TargetBufferFlags buffers,
     // It is called between beginFrame and endFrame, but should never be called in the middle of
     // a render pass.
 
-    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder == nil,
-            "blitDEPRECATED() cannot be invoked inside a render pass.");
+    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder == nil)
+            << "blitDEPRECATED() cannot be invoked inside a render pass.";
 
     auto srcTarget = handle_cast<MetalRenderTarget>(src);
     auto dstTarget = handle_cast<MetalRenderTarget>(dst);
 
-    ASSERT_PRECONDITION(buffers == TargetBufferFlags::COLOR0,
-            "blitDEPRECATED only supports COLOR0");
+    FILAMENT_CHECK_PRECONDITION(buffers == TargetBufferFlags::COLOR0)
+            << "blitDEPRECATED only supports COLOR0";
 
-    ASSERT_PRECONDITION(srcRect.left >= 0 && srcRect.bottom >= 0 &&
-                        dstRect.left >= 0 && dstRect.bottom >= 0,
-            "Source and destination rects must be positive.");
+    FILAMENT_CHECK_PRECONDITION(
+            srcRect.left >= 0 && srcRect.bottom >= 0 && dstRect.left >= 0 && dstRect.bottom >= 0)
+            << "Source and destination rects must be positive.";
 
     auto isBlitableTextureType = [](MTLTextureType t) {
         return t == MTLTextureType2D || t == MTLTextureType2DMultisample ||
@@ -1501,9 +1538,10 @@ void MetalDriver::blitDEPRECATED(TargetBufferFlags buffers,
     MetalRenderTarget::Attachment const dstColorAttachment = dstTarget->getDrawColorAttachment(0);
 
     if (srcColorAttachment && dstColorAttachment) {
-        ASSERT_PRECONDITION(isBlitableTextureType(srcColorAttachment.getTexture().textureType) &&
-                            isBlitableTextureType(dstColorAttachment.getTexture().textureType),
-                           "Metal does not support blitting to/from non-2D textures.");
+        FILAMENT_CHECK_PRECONDITION(
+                isBlitableTextureType(srcColorAttachment.getTexture().textureType) &&
+                isBlitableTextureType(dstColorAttachment.getTexture().textureType))
+                << "Metal does not support blitting to/from non-2D textures.";
 
         MetalBlitter::BlitArgs args{};
         args.filter = filter;
@@ -1614,9 +1652,9 @@ void MetalDriver::finalizeSamplerGroup(MetalSamplerGroup* samplerGroup) {
     }
 }
 
-void MetalDriver::bindPipeline(PipelineState ps) {
-    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder != nullptr,
-            "bindPipeline() without a valid command encoder.");
+void MetalDriver::bindPipeline(PipelineState const& ps) {
+    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder != nullptr)
+            << "bindPipeline() without a valid command encoder.";
 
     MetalVertexBufferInfo const* const vbi =
             handle_cast<MetalVertexBufferInfo>(ps.vertexBufferInfo);
@@ -1634,7 +1672,7 @@ void MetalDriver::bindPipeline(PipelineState ps) {
         return;
     }
 
-    ASSERT_PRECONDITION(bool(functions), "Attempting to bind an invalid Metal program.");
+    functions.validate();
 
     auto [fragment, vertex] = functions.getRasterFunctions();
 
@@ -1788,8 +1826,8 @@ void MetalDriver::bindPipeline(PipelineState ps) {
 }
 
 void MetalDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
-    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder != nullptr,
-            "bindRenderPrimitive() without a valid command encoder.");
+    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder != nullptr)
+            << "bindRenderPrimitive() without a valid command encoder.";
 
     // Bind the user vertex buffers.
     MetalBuffer* vertexBuffers[MAX_VERTEX_BUFFER_COUNT] = {};
@@ -1825,8 +1863,8 @@ void MetalDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
 }
 
 void MetalDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
-    ASSERT_PRECONDITION(mContext->currentRenderPassEncoder != nullptr,
-            "draw() without a valid command encoder.");
+    FILAMENT_CHECK_PRECONDITION(mContext->currentRenderPassEncoder != nullptr)
+            << "draw() without a valid command encoder.";
 
     // Bind uniform buffers.
     MetalBuffer* uniformsToBind[Program::UNIFORM_BINDING_COUNT] = { nil };
@@ -1842,6 +1880,14 @@ void MetalDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t inst
             UNIFORM_BUFFER_BINDING_START, MetalBuffer::Stage::VERTEX | MetalBuffer::Stage::FRAGMENT,
             uniformsToBind, offsets, Program::UNIFORM_BINDING_COUNT);
 
+    // Update push constants.
+    for (size_t i = 0; i < Program::SHADER_TYPE_COUNT; i++) {
+        auto& pushConstants = mContext->currentPushConstants[i];
+        if (UTILS_UNLIKELY(pushConstants.isDirty())) {
+            pushConstants.setBytes(mContext->currentRenderPassEncoder, static_cast<ShaderStage>(i));
+        }
+    }
+
     auto primitive = handle_cast<MetalRenderPrimitive>(mContext->currentRenderPrimitive);
 
     MetalIndexBuffer* indexBuffer = primitive->indexBuffer;
@@ -1867,8 +1913,8 @@ void MetalDriver::draw(PipelineState ps, Handle<HwRenderPrimitive> rph,
 }
 
 void MetalDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGroupCount) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-            "dispatchCompute must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "dispatchCompute must be called outside of a render pass.";
 
     auto mtlProgram = handle_cast<MetalProgram>(program);
 
@@ -1968,15 +2014,15 @@ void MetalDriver::scissor(Viewport scissorBox) {
 }
 
 void MetalDriver::beginTimerQuery(Handle<HwTimerQuery> tqh) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-            "beginTimerQuery must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "beginTimerQuery must be called outside of a render pass.";
     auto* tq = handle_cast<MetalTimerQuery>(tqh);
     mContext->timerQueryImpl->beginTimeElapsedQuery(tq);
 }
 
 void MetalDriver::endTimerQuery(Handle<HwTimerQuery> tqh) {
-    ASSERT_PRECONDITION(!isInRenderPass(mContext),
-            "endTimerQuery must be called outside of a render pass.");
+    FILAMENT_CHECK_PRECONDITION(!isInRenderPass(mContext))
+            << "endTimerQuery must be called outside of a render pass.";
     auto* tq = handle_cast<MetalTimerQuery>(tqh);
     mContext->timerQueryImpl->endTimeElapsedQuery(tq);
 }

filament/backend/src/metal/MetalEnums.h

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

filament/backend/src/metal/MetalExternalImage.mm

@@ -29,7 +29,7 @@
         auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding]; \
         utils::slog.e << description << utils::io::endl;                                           \
     }                                                                                              \
-    ASSERT_POSTCONDITION(error == nil, message);
+    FILAMENT_CHECK_POSTCONDITION(error == nil) << message;
 
 namespace filament {
 namespace backend {
@@ -86,14 +86,14 @@ void MetalExternalImage::set(CVPixelBufferRef image) noexcept {
     }
 
     OSType formatType = CVPixelBufferGetPixelFormatType(image);
-    ASSERT_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA ||
-                         formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
-            "Metal external images must be in either 32BGRA or 420f format.");
+    FILAMENT_CHECK_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA ||
+            formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange)
+            << "Metal external images must be in either 32BGRA or 420f format.";
 
     size_t planeCount = CVPixelBufferGetPlaneCount(image);
-    ASSERT_POSTCONDITION(planeCount == 0 || planeCount == 2,
-            "The Metal backend does not support images with plane counts of %d.", planeCount);
-
+    FILAMENT_CHECK_POSTCONDITION(planeCount == 0 || planeCount == 2)
+            << "The Metal backend does not support images with plane counts of " << planeCount
+            << ".";
 
     if (planeCount == 0) {
         mImage = image;
@@ -138,8 +138,8 @@ void MetalExternalImage::set(CVPixelBufferRef image, size_t plane) noexcept {
     }
 
     const OSType formatType = CVPixelBufferGetPixelFormatType(image);
-    ASSERT_POSTCONDITION(formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
-            "Metal planar external images must be in the 420f format.");
+    FILAMENT_CHECK_POSTCONDITION(formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange)
+            << "Metal planar external images must be in the 420f format.";
 
     mImage = image;
 
@@ -191,8 +191,8 @@ CVMetalTextureRef MetalExternalImage::createTextureFromImage(CVPixelBufferRef im
     CVMetalTextureRef texture;
     CVReturn result = CVMetalTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
             mContext.textureCache, image, nullptr, format, width, height, plane, &texture);
-    ASSERT_POSTCONDITION(result == kCVReturnSuccess,
-            "Could not create a CVMetalTexture from CVPixelBuffer.");
+    FILAMENT_CHECK_POSTCONDITION(result == kCVReturnSuccess)
+            << "Could not create a CVMetalTexture from CVPixelBuffer.";
 
     return texture;
 }
@@ -203,8 +203,8 @@ void MetalExternalImage::shutdown(MetalContext& context) noexcept {
 
 void MetalExternalImage::assertWritableImage(CVPixelBufferRef image) {
     OSType formatType = CVPixelBufferGetPixelFormatType(image);
-    ASSERT_PRECONDITION(formatType == kCVPixelFormatType_32BGRA,
-            "Metal SwapChain images must be in the 32BGRA format.");
+    FILAMENT_CHECK_PRECONDITION(formatType == kCVPixelFormatType_32BGRA)
+            << "Metal SwapChain images must be in the 32BGRA format.";
 }
 
 void MetalExternalImage::unset() {

filament/backend/src/metal/MetalHandles.h

@@ -31,6 +31,8 @@
 
 #include "private/backend/SamplerGroup.h"
 
+#include <backend/DriverEnums.h>
+
 #include <utils/bitset.h>
 #include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
@@ -71,9 +73,9 @@ public:
 
     void releaseDrawable();
 
-    void setFrameScheduledCallback(FrameScheduledCallback callback, void* user);
-    void setFrameCompletedCallback(CallbackHandler* handler,
-            CallbackHandler::Callback callback, void* user);
+    void setFrameScheduledCallback(CallbackHandler* handler, FrameScheduledCallback&& callback);
+    void setFrameCompletedCallback(
+            CallbackHandler* handler, utils::Invocable<void(void)>&& callback);
 
     // For CAMetalLayer-backed SwapChains, presents the drawable or schedules a
     // FrameScheduledCallback.
@@ -107,22 +109,23 @@ private:
     NSUInteger headlessWidth = 0;
     NSUInteger headlessHeight = 0;
     CAMetalLayer* layer = nullptr;
+    std::mutex layerDrawableMutex;
     MetalExternalImage externalImage;
     SwapChainType type;
 
-    // These two fields store a callback and user data to notify the client that a frame is ready
-    // for presentation.
-    // If frameScheduledCallback is nullptr, then the Metal backend automatically calls
-    // presentDrawable when the frame is committed.
-    // Otherwise, the Metal backend will not automatically present the frame. Instead, clients bear
-    // the responsibility of presenting the frame by calling the PresentCallable object.
-    FrameScheduledCallback frameScheduledCallback = nullptr;
-    void* frameScheduledUserData = nullptr;
+    // These fields store a callback to notify the client that a frame is ready for presentation. If
+    // !frameScheduled.callback, then the Metal backend automatically calls presentDrawable when the
+    // frame is committed. Otherwise, the Metal backend will not automatically present the frame.
+    // Instead, clients bear the responsibility of presenting the frame by calling the
+    // PresentCallable object.
+    struct {
+        CallbackHandler* handler = nullptr;
+        std::shared_ptr<FrameScheduledCallback> callback = nullptr;
+    } frameScheduled;
 
     struct {
         CallbackHandler* handler = nullptr;
-        CallbackHandler::Callback callback = {};
-        void* user = nullptr;
+        std::shared_ptr<utils::Invocable<void(void)>> callback = nullptr;
     } frameCompleted;
 };
 

filament/backend/src/metal/MetalHandles.mm

@@ -174,13 +174,21 @@ id<MTLTexture> MetalSwapChain::acquireDrawable() {
     }
 
     assert_invariant(isCaMetalLayer());
-    drawable = [layer nextDrawable];
 
-    ASSERT_POSTCONDITION(drawable != nil, "Could not obtain drawable.");
+    // CAMetalLayer's drawable pool is not thread safe. Use a mutex when
+    // calling -nextDrawable, or when releasing the last known reference
+    // to any CAMetalDrawable returned from a previous -nextDrawable.
+    {
+        std::lock_guard<std::mutex> lock(layerDrawableMutex);
+        drawable = [layer nextDrawable];
+    }
+
+    FILAMENT_CHECK_POSTCONDITION(drawable != nil) << "Could not obtain drawable.";
     return drawable.texture;
 }
 
 void MetalSwapChain::releaseDrawable() {
+    std::lock_guard<std::mutex> lock(layerDrawableMutex);
     drawable = nil;
 }
 
@@ -221,16 +229,16 @@ void MetalSwapChain::ensureDepthStencilTexture() {
     depthStencilTexture = [context.device newTextureWithDescriptor:descriptor];
 }
 
-void MetalSwapChain::setFrameScheduledCallback(FrameScheduledCallback callback, void* user) {
-    frameScheduledCallback = callback;
-    frameScheduledUserData = user;
+void MetalSwapChain::setFrameScheduledCallback(
+        CallbackHandler* handler, FrameScheduledCallback&& callback) {
+    frameScheduled.handler = handler;
+    frameScheduled.callback = std::make_shared<FrameScheduledCallback>(std::move(callback));
 }
 
-void MetalSwapChain::setFrameCompletedCallback(CallbackHandler* handler,
-        CallbackHandler::Callback callback, void* user) {
+void MetalSwapChain::setFrameCompletedCallback(
+        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
     frameCompleted.handler = handler;
-    frameCompleted.callback = callback;
-    frameCompleted.user = user;
+    frameCompleted.callback = std::make_shared<utils::Invocable<void(void)>>(std::move(callback));
 }
 
 void MetalSwapChain::present() {
@@ -238,7 +246,7 @@ void MetalSwapChain::present() {
         scheduleFrameCompletedCallback();
     }
     if (drawable) {
-        if (frameScheduledCallback) {
+        if (frameScheduled.callback) {
             scheduleFrameScheduledCallback();
         } else  {
             [getPendingCommandBuffer(&context) presentDrawable:drawable];
@@ -256,9 +264,11 @@ public:
     PresentDrawableData(const PresentDrawableData&) = delete;
     PresentDrawableData& operator=(const PresentDrawableData&) = delete;
 
-    static PresentDrawableData* create(id<CAMetalDrawable> drawable, MetalDriver* driver) {
+    static PresentDrawableData* create(id<CAMetalDrawable> drawable,
+            std::mutex* drawableMutex, MetalDriver* driver) {
+        assert_invariant(drawableMutex);
         assert_invariant(driver);
-        return new PresentDrawableData(drawable, driver);
+        return new PresentDrawableData(drawable, drawableMutex, driver);
     }
 
     static void maybePresentAndDestroyAsync(PresentDrawableData* that, bool shouldPresent) {
@@ -277,16 +287,22 @@ public:
     }
 
 private:
-    PresentDrawableData(id<CAMetalDrawable> drawable, MetalDriver* driver)
-        : mDrawable(drawable), mDriver(driver) {}
+    PresentDrawableData(id<CAMetalDrawable> drawable, std::mutex* drawableMutex,
+            MetalDriver* driver)
+        : mDrawable(drawable), mDrawableMutex(drawableMutex), mDriver(driver) {}
 
     static void cleanupAndDestroy(PresentDrawableData *that) {
-        that->mDrawable = nil;
+        {
+            std::lock_guard<std::mutex> lock(*(that->mDrawableMutex));
+            that->mDrawable = nil;
+        }
+        that->mDrawableMutex = nullptr;
         that->mDriver = nullptr;
         delete that;
     }
 
     id<CAMetalDrawable> mDrawable;
+    std::mutex* mDrawableMutex = nullptr;
     MetalDriver* mDriver = nullptr;
 };
 
@@ -296,21 +312,38 @@ void presentDrawable(bool presentFrame, void* user) {
 }
 
 void MetalSwapChain::scheduleFrameScheduledCallback() {
-    if (!frameScheduledCallback) {
+    if (!frameScheduled.callback) {
         return;
     }
 
     assert_invariant(drawable);
 
-    // Destroy this by calling maybePresentAndDestroyAsync() later.
-    auto* presentData = PresentDrawableData::create(drawable, context.driver);
+    struct Callback {
+        Callback(std::shared_ptr<FrameScheduledCallback> callback, id<CAMetalDrawable> drawable,
+                std::mutex* drawableMutex, MetalDriver* driver)
+            : f(callback), data(PresentDrawableData::create(drawable, drawableMutex, 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;
+        }
+    };
 
-    FrameScheduledCallback userCallback = frameScheduledCallback;
-    void* userData = frameScheduledUserData;
+    // This callback pointer will be captured by the block. Even if the scheduled handler is never
+    // called, the unique_ptr will still ensure we don't leak memory.
+    __block auto callback = std::make_unique<Callback>(
+        frameScheduled.callback, drawable, &layerDrawableMutex, context.driver);
 
+    backend::CallbackHandler* handler = frameScheduled.handler;
+    MetalDriver* driver = context.driver;
     [getPendingCommandBuffer(&context) addScheduledHandler:^(id<MTLCommandBuffer> cb) {
-        PresentCallable callable(presentDrawable, static_cast<void*>(presentData));
-        userCallback(callable, userData);
+        Callback* user = callback.release();
+        driver->scheduleCallback(handler, user, &Callback::func);
     }];
 }
 
@@ -319,13 +352,25 @@ void MetalSwapChain::scheduleFrameCompletedCallback() {
         return;
     }
 
-    CallbackHandler* handler = frameCompleted.handler;
-    void* user = frameCompleted.user;
-    CallbackHandler::Callback callback = frameCompleted.callback;
+    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;
     MetalDriver* driver = context.driver;
     [getPendingCommandBuffer(&context) addCompletedHandler:^(id<MTLCommandBuffer> cb) {
-        driver->scheduleCallback(handler, user, callback);
+        Callback* user = callback.release();
+        driver->scheduleCallback(handler, user, &Callback::func);
     }];
 }
 
@@ -464,15 +509,16 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
         externalImage(context, r, g, b, a) {
 
     devicePixelFormat = decidePixelFormat(&context, format);
-    ASSERT_POSTCONDITION(devicePixelFormat != MTLPixelFormatInvalid, "Texture format not supported.");
+    FILAMENT_CHECK_POSTCONDITION(devicePixelFormat != MTLPixelFormatInvalid)
+            << "Texture format not supported.";
 
     const BOOL mipmapped = levels > 1;
     const BOOL multisampled = samples > 1;
 
 #if defined(IOS)
     const BOOL textureArray = target == SamplerType::SAMPLER_2D_ARRAY;
-    ASSERT_PRECONDITION(!textureArray || !multisampled,
-            "iOS does not support multisampled texture arrays.");
+    FILAMENT_CHECK_PRECONDITION(!textureArray || !multisampled)
+            << "iOS does not support multisampled texture arrays.";
 #endif
 
     const auto get2DTextureType = [](SamplerType target, bool isMultisampled) {
@@ -507,12 +553,14 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
             descriptor.usage = getMetalTextureUsage(usage);
             descriptor.storageMode = MTLStorageModePrivate;
             texture = [context.device newTextureWithDescriptor:descriptor];
-            ASSERT_POSTCONDITION(texture != nil, "Could not create Metal texture. Out of memory?");
+            FILAMENT_CHECK_POSTCONDITION(texture != nil)
+                    << "Could not create Metal texture. Out of memory?";
             break;
         case SamplerType::SAMPLER_CUBEMAP:
         case SamplerType::SAMPLER_CUBEMAP_ARRAY:
-            ASSERT_POSTCONDITION(!multisampled, "Multisampled cubemap faces not supported.");
-            ASSERT_POSTCONDITION(width == height, "Cubemap faces must be square.");
+            FILAMENT_CHECK_POSTCONDITION(!multisampled)
+                    << "Multisampled cubemap faces not supported.";
+            FILAMENT_CHECK_POSTCONDITION(width == height) << "Cubemap faces must be square.";
             descriptor = [MTLTextureDescriptor textureCubeDescriptorWithPixelFormat:devicePixelFormat
                                                                                size:width
                                                                           mipmapped:mipmapped];
@@ -521,7 +569,8 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
             descriptor.usage = getMetalTextureUsage(usage);
             descriptor.storageMode = MTLStorageModePrivate;
             texture = [context.device newTextureWithDescriptor:descriptor];
-            ASSERT_POSTCONDITION(texture != nil, "Could not create Metal texture. Out of memory?");
+            FILAMENT_CHECK_POSTCONDITION(texture != nil)
+                    << "Could not create Metal texture. Out of memory?";
             break;
         case SamplerType::SAMPLER_3D:
             descriptor = [MTLTextureDescriptor new];
@@ -534,7 +583,8 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
             descriptor.usage = getMetalTextureUsage(usage);
             descriptor.storageMode = MTLStorageModePrivate;
             texture = [context.device newTextureWithDescriptor:descriptor];
-            ASSERT_POSTCONDITION(texture != nil, "Could not create Metal texture. Out of memory?");
+            FILAMENT_CHECK_POSTCONDITION(texture != nil)
+                    << "Could not create Metal texture. Out of memory?";
             break;
         case SamplerType::SAMPLER_EXTERNAL:
             // If we're using external textures (CVPixelBufferRefs), we don't need to make any
@@ -736,9 +786,9 @@ void MetalTexture::loadSlice(uint32_t level, MTLRegion region, uint32_t byteOffs
         PixelBufferDescriptor const& data) noexcept {
     const PixelBufferShape shape = PixelBufferShape::compute(data, format, region.size, byteOffset);
 
-    ASSERT_PRECONDITION(data.size >= shape.totalBytes,
-            "Expected buffer size of at least %d but "
-            "received PixelBufferDescriptor with size %d.", shape.totalBytes, data.size);
+    FILAMENT_CHECK_PRECONDITION(data.size >= shape.totalBytes)
+            << "Expected buffer size of at least " << shape.totalBytes
+            << " but received PixelBufferDescriptor with size " << data.size << ".";
 
     // Earlier versions of iOS don't have the maxBufferLength query, but 256 MB is a safe bet.
     NSUInteger deviceMaxBufferLength = 256 * 1024 * 1024;   // 256 MB
@@ -959,9 +1009,9 @@ MetalRenderTarget::MetalRenderTarget(MetalContext* context, uint32_t width, uint
         }
         color[i] = colorAttachments[i];
 
-        ASSERT_PRECONDITION(color[i].getSampleCount() <= samples,
-                "MetalRenderTarget was initialized with a MSAA COLOR%d texture, but sample count is %d.",
-                i, samples);
+        FILAMENT_CHECK_PRECONDITION(color[i].getSampleCount() <= samples)
+                << "MetalRenderTarget was initialized with a MSAA COLOR" << i
+                << " texture, but sample count is " << samples << ".";
 
         auto t = color[i].metalTexture;
         const auto twidth = std::max(1u, t->width >> color[i].level);
@@ -984,9 +1034,10 @@ MetalRenderTarget::MetalRenderTarget(MetalContext* context, uint32_t width, uint
     if (depthAttachment) {
         depth = depthAttachment;
 
-        ASSERT_PRECONDITION(depth.getSampleCount() <= samples,
-                "MetalRenderTarget was initialized with a MSAA DEPTH texture, but sample count is %d.",
-                samples);
+        FILAMENT_CHECK_PRECONDITION(depth.getSampleCount() <= samples)
+                << "MetalRenderTarget was initialized with a MSAA DEPTH texture, but sample count "
+                   "is "
+                << samples << ".";
 
         auto t = depth.metalTexture;
         const auto twidth = std::max(1u, t->width >> depth.level);
@@ -1009,9 +1060,10 @@ MetalRenderTarget::MetalRenderTarget(MetalContext* context, uint32_t width, uint
     if (stencilAttachment) {
         stencil = stencilAttachment;
 
-        ASSERT_PRECONDITION(stencil.getSampleCount() <= samples,
-                "MetalRenderTarget was initialized with a MSAA STENCIL texture, but sample count is %d.",
-                samples);
+        FILAMENT_CHECK_PRECONDITION(stencil.getSampleCount() <= samples)
+                << "MetalRenderTarget was initialized with a MSAA STENCIL texture, but sample "
+                   "count is "
+                << samples << ".";
 
         auto t = stencil.metalTexture;
         const auto twidth = std::max(1u, t->width >> stencil.level);

filament/backend/src/metal/MetalShaderCompiler.mm

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

filament/backend/src/metal/MetalState.h

@@ -43,7 +43,8 @@ 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-26       Uniform buffers                         10   Program::UNIFORM_BINDING_COUNT
+//   17-25       Uniform buffers                          9   Program::UNIFORM_BINDING_COUNT
+//   26          Push constants                           1
 //   27-30       Sampler groups (argument buffers)        4   Program::SAMPLER_BINDING_COUNT
 //
 //   Total                                               31
@@ -53,7 +54,8 @@ inline bool operator==(const SamplerParams& lhs, const SamplerParams& rhs) {
 //   Bindings    Buffer name                          Count
 //   ------------------------------------------------------
 //   0-3         SSBO buffers                             4   MAX_SSBO_COUNT
-//   17-26       Uniform buffers                         10   Program::UNIFORM_BINDING_COUNT
+//   17-25       Uniform buffers                          9   Program::UNIFORM_BINDING_COUNT
+//   26          Push constants                           1
 //   27-30       Sampler groups (argument buffers)        4   Program::SAMPLER_BINDING_COUNT
 //
 //   Total                                               18

filament/backend/src/metal/MetalState.mm

@@ -90,11 +90,17 @@ id<MTLRenderPipelineState> PipelineStateCreator::operator()(id<MTLDevice> device
     NSError* error = nullptr;
     id<MTLRenderPipelineState> pipeline = [device newRenderPipelineStateWithDescriptor:descriptor
                                                                                  error:&error];
-    if (error) {
-        auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
+    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];
         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.");
+    FILAMENT_CHECK_POSTCONDITION(error == nil) << "Could not create Metal pipeline state.";
 
     return pipeline;
 }

filament/backend/src/noop/NoopDriver.cpp

@@ -49,16 +49,17 @@ void NoopDriver::terminate() {
 void NoopDriver::tick(int) {
 }
 
-void NoopDriver::beginFrame(int64_t monotonic_clock_ns, uint32_t frameId) {
+void NoopDriver::beginFrame(int64_t monotonic_clock_ns,
+        int64_t refreshIntervalNs, uint32_t frameId) {
 }
 
 void NoopDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
-        FrameScheduledCallback callback, void* user) {
+        CallbackHandler* handler, FrameScheduledCallback&& callback) {
 
 }
 
 void NoopDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
+        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
 
 }
 
@@ -181,7 +182,7 @@ bool NoopDriver::isProtectedContentSupported() {
     return false;
 }
 
-bool NoopDriver::isStereoSupported(backend::StereoscopicType) {
+bool NoopDriver::isStereoSupported() {
     return false;
 }
 
@@ -193,6 +194,10 @@ bool NoopDriver::isDepthStencilResolveSupported() {
     return true;
 }
 
+bool NoopDriver::isDepthStencilBlitSupported(TextureFormat format) {
+    return true;
+}
+
 bool NoopDriver::isProtectedTexturesSupported() {
     return true;
 }
@@ -307,6 +312,10 @@ void NoopDriver::unbindBuffer(BufferObjectBinding bindingType, uint32_t index) {
 void NoopDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
 }
 
+void NoopDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
+        backend::PushConstantVariant value) {
+}
+
 void NoopDriver::insertEventMarker(char const* string, uint32_t len) {
 }
 
@@ -350,7 +359,7 @@ void NoopDriver::blit(
         math::uint2 size) {
 }
 
-void NoopDriver::bindPipeline(PipelineState pipelineState) {
+void NoopDriver::bindPipeline(PipelineState const& pipelineState) {
 }
 
 void NoopDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {

filament/backend/src/opengl/GLBufferObject.h

@@ -0,0 +1,51 @@
+/*
+ * 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

filament/backend/src/opengl/GLTexture.h

@@ -0,0 +1,55 @@
+/*
+ * 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

filament/backend/src/opengl/OpenGLContext.cpp

@@ -63,8 +63,11 @@ bool OpenGLContext::queryOpenGLVersion(GLint* major, GLint* minor) noexcept {
 #endif
 }
 
-OpenGLContext::OpenGLContext(OpenGLPlatform& platform) noexcept
-        : mPlatform(platform) {
+OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
+        Platform::DriverConfig const& driverConfig) noexcept
+        : mPlatform(platform),
+          mSamplerMap(32),
+          mDriverConfig(driverConfig) {
 
     state.vao.p = &mDefaultVAO;
 
@@ -84,6 +87,13 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform) noexcept
 
     queryOpenGLVersion(&state.major, &state.minor);
 
+    #if defined(BACKEND_OPENGL_VERSION_GLES)
+    if (UTILS_UNLIKELY(driverConfig.forceGLES2Context)) {
+        state.major = 2;
+        state.minor = 0;
+    }
+    #endif
+
     OpenGLContext::initExtensions(&ext, state.major, state.minor);
 
     OpenGLContext::initProcs(&procs, ext, state.major, state.minor);
@@ -252,9 +262,23 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform) noexcept
 }
 
 OpenGLContext::~OpenGLContext() noexcept {
+    // note: this is called from the main thread. Can't do any GL calls.
     delete mTimerQueryFactory;
 }
 
+void OpenGLContext::terminate() noexcept {
+    // note: this is called from the backend thread
+#ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
+    if (!isES2()) {
+        for (auto& item: mSamplerMap) {
+            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) {
@@ -343,7 +367,8 @@ void OpenGLContext::setDefaultState() noexcept {
     }
 #endif
 
-    if (ext.EXT_clip_cull_distance) {
+    if (ext.EXT_clip_cull_distance
+            && mDriverConfig.stereoscopicType == StereoscopicType::INSTANCED) {
         glEnable(GL_CLIP_DISTANCE0);
         glEnable(GL_CLIP_DISTANCE1);
     }
@@ -516,8 +541,6 @@ void OpenGLContext::initBugs(Bugs* bugs, Extensions const& exts,
             bugs->delay_fbo_destruction = true;
             // PowerVR seems to have no problem with this (which is good for us)
             bugs->allow_read_only_ancillary_feedback_loop = true;
-            // PowerVR has a shader compiler thread pinned on the last core
-            bugs->disable_thread_affinity = true;
         } else if (strstr(renderer, "Apple")) {
             // Apple GPU
         } else if (strstr(renderer, "Tegra") ||
@@ -868,19 +891,32 @@ default_case:
     }
 }
 
-void OpenGLContext::unbindTexture(GLenum target, GLuint texture_id) noexcept {
+void OpenGLContext::unbindTexture(
+        UTILS_UNUSED_IN_RELEASE GLenum target, GLuint texture_id) noexcept {
     // unbind this texture from all the units it might be bound to
     // no need unbind the texture from FBOs because we're not tracking that state (and there is
     // no need to).
-    const size_t index = getIndexForTextureTarget(target);
-    UTILS_NOUNROLL
-    for (GLuint unit = 0; unit < MAX_TEXTURE_UNIT_COUNT; unit++) {
-        if (state.textures.units[unit].targets[index].texture_id == texture_id) {
-            bindTexture(unit, target, (GLuint)0, index);
+    // Never attempt to unbind texture 0. This could happen with external textures w/ streaming if
+    // never populated.
+    if (texture_id) {
+        UTILS_NOUNROLL
+        for (GLuint unit = 0; unit < MAX_TEXTURE_UNIT_COUNT; unit++) {
+            if (state.textures.units[unit].id == texture_id) {
+                // if this texture is bound, it should be at the same target
+                assert_invariant(state.textures.units[unit].target == target);
+                unbindTextureUnit(unit);
+            }
         }
     }
 }
 
+void OpenGLContext::unbindTextureUnit(GLuint unit) noexcept {
+    update_state(state.textures.units[unit].id, 0u, [&]() {
+        activeTexture(unit);
+        glBindTexture(state.textures.units[unit].target, 0u);
+    });
+}
+
 void OpenGLContext::unbindSampler(GLuint sampler) noexcept {
     // unbind this sampler from all the units it might be bound to
     UTILS_NOUNROLL  // clang generates >800B of code!!!
@@ -934,6 +970,37 @@ void OpenGLContext::deleteVertexArray(GLuint vao) noexcept {
     }
 }
 
+#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
 

filament/backend/src/opengl/OpenGLContext.h

@@ -34,6 +34,8 @@
 #include <math/vec2.h>
 #include <math/vec4.h>
 
+#include <tsl/robin_map.h>
+
 #include <array>
 #include <functional>
 #include <optional>
@@ -89,9 +91,13 @@ public:
 
     static bool queryOpenGLVersion(GLint* major, GLint* minor) noexcept;
 
-    explicit OpenGLContext(OpenGLPlatform& platform) noexcept;
+    explicit OpenGLContext(OpenGLPlatform& platform,
+            Platform::DriverConfig const& driverConfig) noexcept;
+
     ~OpenGLContext() noexcept final;
 
+    void terminate() noexcept;
+
     // TimerQueryInterface ------------------------------------------------------------------------
 
     // note: OpenGLContext being final ensures (clang) these are not called through the vtable
@@ -132,7 +138,6 @@ public:
 #endif
     }
 
-    constexpr static inline size_t getIndexForTextureTarget(GLuint target) noexcept;
     constexpr        inline size_t getIndexForCap(GLenum cap) noexcept;
     constexpr static inline size_t getIndexForBufferTarget(GLenum target) noexcept;
 
@@ -144,10 +149,10 @@ public:
 
           void pixelStore(GLenum, GLint) noexcept;
     inline void activeTexture(GLuint unit) noexcept;
-    inline void bindTexture(GLuint unit, GLuint target, GLuint texId, size_t targetIndex) noexcept;
     inline void bindTexture(GLuint unit, GLuint target, GLuint texId) noexcept;
 
            void unbindTexture(GLenum target, GLuint id) noexcept;
+           void unbindTextureUnit(GLuint unit) noexcept;
     inline void bindVertexArray(RenderPrimitive const* p) noexcept;
     inline void bindSampler(GLuint unit, GLuint sampler) noexcept;
            void unbindSampler(GLuint sampler) noexcept;
@@ -306,10 +311,6 @@ public:
         // a glFinish. So we must delay the destruction until we know the GPU is finished.
         bool delay_fbo_destruction;
 
-        // The driver has some threads pinned, and we can't easily know on which core, it can hurt
-        // performance more if we end-up pinned on the same one.
-        bool disable_thread_affinity;
-
         // Force feature level 0. Typically used for low end ES3 devices with significant driver
         // bugs or performance issues.
         bool force_feature_level0;
@@ -321,8 +322,14 @@ public:
 
     // function to handle state changes we don't control
     void updateTexImage(GLenum target, GLuint id) noexcept {
-        const size_t index = getIndexForTextureTarget(target);
-        state.textures.units[state.textures.active].targets[index].texture_id = id;
+        assert_invariant(target == GL_TEXTURE_EXTERNAL_OES);
+        // if another target is bound to this texture unit, unbind that texture
+        if (UTILS_UNLIKELY(state.textures.units[state.textures.active].target != target)) {
+            glBindTexture(state.textures.units[state.textures.active].target, 0);
+            state.textures.units[state.textures.active].target = GL_TEXTURE_EXTERNAL_OES;
+        }
+        // the texture is already bound to `target`, we just update our internal state
+        state.textures.units[state.textures.active].id = id;
     }
     void resetProgram() noexcept { state.program.use = 0; }
 
@@ -425,9 +432,8 @@ public:
             GLuint active = 0;      // zero-based
             struct {
                 GLuint sampler = 0;
-                struct {
-                    GLuint texture_id = 0;
-                } targets[7];  // this must match getIndexForTextureTarget()
+                GLuint target = 0;
+                GLuint id = 0;
             } units[MAX_TEXTURE_UNIT_COUNT];
         } textures;
 
@@ -467,6 +473,29 @@ public:
 
     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;
@@ -476,6 +505,13 @@ private:
     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;
 
@@ -522,9 +558,6 @@ private:
             {   bugs.delay_fbo_destruction,
                     "delay_fbo_destruction",
                     ""},
-            {   bugs.disable_thread_affinity,
-                    "disable_thread_affinity",
-                    ""},
             {   bugs.force_feature_level0,
                     "force_feature_level0",
                     ""},
@@ -572,31 +605,10 @@ private:
     }
 
     void setDefaultState() noexcept;
-
-    static constexpr const size_t TEXTURE_TARGET_COUNT =
-            sizeof(state.textures.units[0].targets) / sizeof(state.textures.units[0].targets[0]);
-
 };
 
 // ------------------------------------------------------------------------------------------------
 
-constexpr size_t OpenGLContext::getIndexForTextureTarget(GLuint target) noexcept {
-    // this must match state.textures[].targets[]
-    switch (target) {
-        case GL_TEXTURE_2D:                     return 0;
-        case GL_TEXTURE_2D_ARRAY:               return 1;
-        case GL_TEXTURE_CUBE_MAP:               return 2;
-#if defined(BACKEND_OPENGL_LEVEL_GLES31)
-        case GL_TEXTURE_2D_MULTISAMPLE:         return 3;
-#endif
-        case GL_TEXTURE_EXTERNAL_OES:           return 4;
-        case GL_TEXTURE_3D:                     return 5;
-        case GL_TEXTURE_CUBE_MAP_ARRAY:         return 6;
-        default:
-            return 0;
-    }
-}
-
 constexpr size_t OpenGLContext::getIndexForCap(GLenum cap) noexcept { //NOLINT
     size_t index = 0;
     switch (cap) {
@@ -744,19 +756,17 @@ void OpenGLContext::bindBufferRange(GLenum target, GLuint index, GLuint buffer,
 #endif
 }
 
-void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId, size_t targetIndex) noexcept {
-    assert_invariant(targetIndex == getIndexForTextureTarget(target));
-    assert_invariant(targetIndex < TEXTURE_TARGET_COUNT);
-    update_state(state.textures.units[unit].targets[targetIndex].texture_id, texId, [&]() {
+void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId) noexcept {
+    update_state(state.textures.units[unit].target, target, [&]() {
+        activeTexture(unit);
+        glBindTexture(state.textures.units[unit].target, 0);
+    });
+    update_state(state.textures.units[unit].id, texId, [&]() {
         activeTexture(unit);
         glBindTexture(target, texId);
     }, target == GL_TEXTURE_EXTERNAL_OES);
 }
 
-void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId) noexcept {
-    bindTexture(unit, target, texId, getIndexForTextureTarget(target));
-}
-
 void OpenGLContext::useProgram(GLuint program) noexcept {
     update_state(state.program.use, program, [&]() {
         glUseProgram(program);

filament/backend/src/opengl/OpenGLDriver.cpp

@@ -173,6 +173,10 @@ Driver* OpenGLDriver::create(OpenGLPlatform* const platform,
         PANIC_LOG("OpenGL ES 2.0 minimum needed (current %d.%d)", major, minor);
         goto cleanup;
     }
+    if (UTILS_UNLIKELY(driverConfig.forceGLES2Context)) {
+        major = 2;
+        minor = 0;
+    }
 #else
     // we require GL 4.1 headers and minimum version
     if (UTILS_UNLIKELY(!((major == 4 && minor >= 1) || major > 4))) {
@@ -203,13 +207,13 @@ OpenGLDriver::DebugMarker::~DebugMarker() noexcept {
 
 OpenGLDriver::OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfig& driverConfig) noexcept
         : mPlatform(*platform),
-          mContext(mPlatform),
+          mContext(mPlatform, driverConfig),
           mShaderCompilerService(*this),
           mHandleAllocator("Handles",
                   driverConfig.handleArenaSize,
                   driverConfig.disableHandleUseAfterFreeCheck),
-          mSamplerMap(32),
-          mDriverConfig(driverConfig) {
+          mDriverConfig(driverConfig),
+          mCurrentPushConstants(new(std::nothrow) PushConstantBundle{}) {
 
     std::fill(mSamplerBindings.begin(), mSamplerBindings.end(), nullptr);
 
@@ -233,10 +237,19 @@ OpenGLDriver::OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfi
 }
 
 OpenGLDriver::~OpenGLDriver() noexcept { // NOLINT(modernize-use-equals-default)
+    // this is called from the main thread. Can't call GL.
 }
 
 Dispatcher OpenGLDriver::getDispatcher() const noexcept {
-    return ConcreteDispatcher<OpenGLDriver>::make();
+    auto dispatcher = ConcreteDispatcher<OpenGLDriver>::make();
+    if (mContext.isES2()) {
+        dispatcher.draw2_ = +[](Driver& driver, CommandBase* base, intptr_t* next){
+            using Cmd = COMMAND_TYPE(draw2);
+            OpenGLDriver& concreteDriver = static_cast<OpenGLDriver&>(driver);
+            Cmd::execute(&OpenGLDriver::draw2GLES2, concreteDriver, base, next);
+        };
+    }
+    return dispatcher;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -263,16 +276,13 @@ void OpenGLDriver::terminate() {
 
     // because we called glFinish(), all callbacks should have been executed
     assert_invariant(mGpuCommandCompleteOps.empty());
-
-    if (!getContext().isES2()) {
-        for (auto& item: mSamplerMap) {
-            mContext.unbindSampler(item.second);
-            glDeleteSamplers(1, &item.second);
-        }
-        mSamplerMap.clear();
-    }
 #endif
 
+    delete mCurrentPushConstants;
+    mCurrentPushConstants = nullptr;
+
+    mContext.terminate();
+
     mPlatform.terminate();
 }
 
@@ -291,9 +301,42 @@ void OpenGLDriver::bindSampler(GLuint unit, GLuint sampler) noexcept {
     mContext.bindSampler(unit, sampler);
 }
 
+void OpenGLDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
+        backend::PushConstantVariant value) {
+    assert_invariant(stage == ShaderStage::VERTEX || stage == ShaderStage::FRAGMENT);
+    utils::Slice<std::pair<GLint, ConstantType>> constants;
+    if (stage == ShaderStage::VERTEX) {
+        constants = mCurrentPushConstants->vertexConstants;
+    } else if (stage == ShaderStage::FRAGMENT) {
+        constants = mCurrentPushConstants->fragmentConstants;
+    }
+
+    assert_invariant(index < constants.size());
+    auto const& [location, type] = constants[index];
+
+    // This push constant wasn't found in the shader. It's ok to return without error-ing here.
+    if (location < 0) {
+        return;
+    }
+
+    if (std::holds_alternative<bool>(value)) {
+        assert_invariant(type == ConstantType::BOOL);
+        bool const bval = std::get<bool>(value);
+        glUniform1i(location, bval ? 1 : 0);
+    } else if (std::holds_alternative<float>(value)) {
+        assert_invariant(type == ConstantType::FLOAT);
+        float const fval = std::get<float>(value);
+        glUniform1f(location, fval);
+    } else {
+        assert_invariant(type == ConstantType::INT);
+        int const ival = std::get<int>(value);
+        glUniform1i(location, ival);
+    }
+}
+
 void OpenGLDriver::bindTexture(GLuint unit, GLTexture const* t) noexcept {
     assert_invariant(t != nullptr);
-    mContext.bindTexture(unit, t->gl.target, t->gl.id, t->gl.targetIndex);
+    mContext.bindTexture(unit, t->gl.target, t->gl.id);
 }
 
 bool OpenGLDriver::useProgram(OpenGLProgram* p) noexcept {
@@ -307,7 +350,7 @@ bool OpenGLDriver::useProgram(OpenGLProgram* p) noexcept {
 
     if (UTILS_UNLIKELY(mContext.isES2())) {
         for (uint32_t i = 0; i < Program::UNIFORM_BINDING_COUNT; i++) {
-            auto [id, buffer, age] = mUniformBindings[i];
+            auto [id, buffer, age] = mContext.getEs2UniformBinding(i);
             if (buffer) {
                 p->updateUniforms(i, id, buffer, age);
             }
@@ -724,10 +767,19 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
     GLenum internalFormat = getInternalFormat(format);
     assert_invariant(internalFormat);
 
-    if (UTILS_UNLIKELY(usage & TextureUsage::PROTECTED)) {
+    if (any(usage & TextureUsage::PROTECTED)) {
         // renderbuffers don't have a protected mode, so we need to use a texture
         // because protected textures are only supported on GLES 3.2, MSAA will be available.
         usage |= TextureUsage::SAMPLEABLE;
+    } else if (any(usage & TextureUsage::UPLOADABLE)) {
+        // if we have the uploadable flag, we also need to use a texture
+        usage |= TextureUsage::SAMPLEABLE;
+    } else if (target != SamplerType::SAMPLER_2D) {
+        // renderbuffers can only be 2D
+        usage |= TextureUsage::SAMPLEABLE;
+    } else if (levels > 1) {
+        // renderbuffers can't have mip levels
+        usage |= TextureUsage::SAMPLEABLE;
     }
 
     auto& gl = mContext;
@@ -746,7 +798,6 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
             if (t->externalTexture) {
                 t->gl.target = t->externalTexture->target;
                 t->gl.id = t->externalTexture->id;
-                t->gl.targetIndex = (uint8_t)OpenGLContext::getIndexForTextureTarget(t->gl.target);
                 // internalFormat actually depends on the external image, but it doesn't matter
                 // because it's not used anywhere for anything important.
                 t->gl.internalFormat = internalFormat;
@@ -758,30 +809,23 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
 
             t->gl.internalFormat = internalFormat;
 
-            // We DO NOT update targetIndex at function exit to take advantage of the fact that
-            // getIndexForTextureTarget() is constexpr -- so all of this disappears at compile time.
             switch (target) {
                 case SamplerType::SAMPLER_EXTERNAL:
                     // we can't be here -- doesn't matter what we do
                 case SamplerType::SAMPLER_2D:
                     t->gl.target = GL_TEXTURE_2D;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D);
                     break;
                 case SamplerType::SAMPLER_3D:
                     t->gl.target = GL_TEXTURE_3D;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_3D);
                     break;
                 case SamplerType::SAMPLER_2D_ARRAY:
                     t->gl.target = GL_TEXTURE_2D_ARRAY;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_ARRAY);
                     break;
                 case SamplerType::SAMPLER_CUBEMAP:
                     t->gl.target = GL_TEXTURE_CUBE_MAP;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP);
                     break;
                 case SamplerType::SAMPLER_CUBEMAP_ARRAY:
                     t->gl.target = GL_TEXTURE_CUBE_MAP_ARRAY;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP_ARRAY);
                     break;
             }
 
@@ -792,8 +836,6 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
                 if (gl.features.multisample_texture) {
                     // multi-sample texture on GL 3.2 / GLES 3.1 and above
                     t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
-                    t->gl.targetIndex = (uint8_t)
-                            OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_MULTISAMPLE);
                 } else {
                     // Turn off multi-sampling for that texture. It's just not supported.
                 }
@@ -803,13 +845,6 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
             textureStorage(t, w, h, depth, bool(usage & TextureUsage::PROTECTED));
         }
     } else {
-        assert_invariant(any(usage & (
-                TextureUsage::COLOR_ATTACHMENT |
-                TextureUsage::DEPTH_ATTACHMENT |
-                TextureUsage::STENCIL_ATTACHMENT)));
-        assert_invariant(levels == 1);
-        assert_invariant(target == SamplerType::SAMPLER_2D);
-        assert_invariant(none(usage & TextureUsage::PROTECTED));
         t->gl.internalFormat = internalFormat;
         t->gl.target = GL_RENDERBUFFER;
         glGenRenderbuffers(1, &t->gl.id);
@@ -859,32 +894,24 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
     t->gl.internalFormat = getInternalFormat(format);
     assert_invariant(t->gl.internalFormat);
 
-    // We DO NOT update targetIndex at function exit to take advantage of the fact that
-    // getIndexForTextureTarget() is constexpr -- so all of this disappears at compile time.
     switch (target) {
         case SamplerType::SAMPLER_EXTERNAL:
             t->gl.target = GL_TEXTURE_EXTERNAL_OES;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_EXTERNAL_OES);
             break;
         case SamplerType::SAMPLER_2D:
             t->gl.target = GL_TEXTURE_2D;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D);
             break;
         case SamplerType::SAMPLER_3D:
             t->gl.target = GL_TEXTURE_3D;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_3D);
             break;
         case SamplerType::SAMPLER_2D_ARRAY:
             t->gl.target = GL_TEXTURE_2D_ARRAY;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_ARRAY);
             break;
         case SamplerType::SAMPLER_CUBEMAP:
             t->gl.target = GL_TEXTURE_CUBE_MAP;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP);
             break;
         case SamplerType::SAMPLER_CUBEMAP_ARRAY:
             t->gl.target = GL_TEXTURE_CUBE_MAP_ARRAY;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP_ARRAY);
             break;
     }
 
@@ -895,7 +922,6 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
         if (gl.features.multisample_texture) {
             // multi-sample texture on GL 3.2 / GLES 3.1 and above
             t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_MULTISAMPLE);
         } else {
             // Turn off multi-sampling for that texture. It's just not supported.
         }
@@ -906,16 +932,18 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
 }
 
 void OpenGLDriver::updateVertexArrayObject(GLRenderPrimitive* rp, GLVertexBuffer const* vb) {
-    // NOTE: this is called from draw() and must be as efficient as possible.
+    // NOTE: this is called often and must be as efficient as possible.
 
     auto& gl = mContext;
 
+#ifndef NDEBUG
     if (UTILS_LIKELY(gl.ext.OES_vertex_array_object)) {
         // The VAO for the given render primitive must already be bound.
         GLint vaoBinding;
         glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &vaoBinding);
         assert_invariant(vaoBinding == (GLint)rp->gl.vao[gl.contextIndex]);
     }
+#endif
 
     if (UTILS_LIKELY(rp->gl.vertexBufferVersion == vb->bufferObjectsVersion &&
                      rp->gl.stateVersion == gl.state.age)) {
@@ -931,7 +959,7 @@ void OpenGLDriver::updateVertexArrayObject(GLRenderPrimitive* rp, GLVertexBuffer
             // if a buffer is defined it must not be invalid.
             assert_invariant(vb->gl.buffers[bi]);
 
-            // if w're on ES2, the user shouldn't use FLAG_INTEGER_TARGET
+            // if we're on ES2, the user shouldn't use FLAG_INTEGER_TARGET
             assert_invariant(!(gl.isES2() && (attribute.flags & Attribute::FLAG_INTEGER_TARGET)));
 
             gl.bindBuffer(GL_ARRAY_BUFFER, vb->gl.buffers[bi]);
@@ -1466,9 +1494,8 @@ void OpenGLDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
 
 #if !defined(__EMSCRIPTEN__)
     // note: in practice this should never happen on Android
-    ASSERT_POSTCONDITION(sc->swapChain,
-            "createSwapChain(%p, 0x%lx) failed. See logs for details.",
-            nativeWindow, flags);
+    FILAMENT_CHECK_POSTCONDITION(sc->swapChain) << "createSwapChain(" << nativeWindow << ", "
+                                                << flags << ") failed. See logs for details.";
 #endif
 
     // See if we need the emulated rec709 output conversion
@@ -1487,9 +1514,9 @@ void OpenGLDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch,
 
 #if !defined(__EMSCRIPTEN__)
     // note: in practice this should never happen on Android
-    ASSERT_POSTCONDITION(sc->swapChain,
-            "createSwapChainHeadless(%u, %u, 0x%lx) failed. See logs for details.",
-            width, height, flags);
+    FILAMENT_CHECK_POSTCONDITION(sc->swapChain)
+            << "createSwapChainHeadless(" << width << ", " << height << ", " << flags
+            << ") failed. See logs for details.";
 #endif
 
     // See if we need the emulated rec709 output conversion
@@ -1785,7 +1812,6 @@ void OpenGLDriver::updateStreams(DriverApi* driver) {
                         // the target and id can be reset each time
                         t->gl.target = t->externalTexture->target;
                         t->gl.id = t->externalTexture->id;
-                        t->gl.targetIndex = (uint8_t)OpenGLContext::getIndexForTextureTarget(t->gl.target);
                         bindTexture(OpenGLContext::DUMMY_TEXTURE_BINDING, t);
                     }
                 }
@@ -2023,19 +2049,19 @@ bool OpenGLDriver::isProtectedContentSupported() {
     return mPlatform.isProtectedContextSupported();
 }
 
-bool OpenGLDriver::isStereoSupported(backend::StereoscopicType stereoscopicType) {
+bool OpenGLDriver::isStereoSupported() {
     // Instanced-stereo requires instancing and EXT_clip_cull_distance.
     // Multiview-stereo requires ES 3.0 and OVR_multiview2.
     if (UTILS_UNLIKELY(mContext.isES2())) {
         return false;
     }
-    switch (stereoscopicType) {
-    case backend::StereoscopicType::INSTANCED:
-        return mContext.ext.EXT_clip_cull_distance;
-    case backend::StereoscopicType::MULTIVIEW:
-        return mContext.ext.OVR_multiview2;
-    default:
-        return false;
+    switch (mDriverConfig.stereoscopicType) {
+        case backend::StereoscopicType::INSTANCED:
+            return mContext.ext.EXT_clip_cull_distance;
+        case backend::StereoscopicType::MULTIVIEW:
+            return mContext.ext.OVR_multiview2;
+        case backend::StereoscopicType::NONE:
+            return false;
     }
 }
 
@@ -2047,6 +2073,10 @@ bool OpenGLDriver::isDepthStencilResolveSupported() {
     return true;
 }
 
+bool OpenGLDriver::isDepthStencilBlitSupported(TextureFormat format) {
+    return true;
+}
+
 bool OpenGLDriver::isProtectedTexturesSupported() {
     return getContext().ext.EXT_protected_textures;
 }
@@ -2063,8 +2093,6 @@ bool OpenGLDriver::isWorkaroundNeeded(Workaround workaround) {
             return mContext.bugs.disable_blit_into_texture_array;
         case Workaround::POWER_VR_SHADER_WORKAROUNDS:
             return mContext.bugs.powervr_shader_workarounds;
-        case Workaround::DISABLE_THREAD_AFFINITY:
-            return mContext.bugs.disable_thread_affinity;
         default:
             return false;
     }
@@ -2343,7 +2371,7 @@ void OpenGLDriver::updateSamplerGroup(Handle<HwSamplerGroup> sbh,
 #endif
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
             if (UTILS_LIKELY(!es2)) {
-                samplerId = getSampler(params);
+                samplerId = mContext.getSampler(params);
             } else
 #endif
             {
@@ -2673,7 +2701,6 @@ void OpenGLDriver::setExternalImage(Handle<HwTexture> th, void* image) {
         // the target and id can be reset each time
         t->gl.target = t->externalTexture->target;
         t->gl.id = t->externalTexture->id;
-        t->gl.targetIndex = (uint8_t)OpenGLContext::getIndexForTextureTarget(t->gl.target);
         bindTexture(OpenGLContext::DUMMY_TEXTURE_BINDING, t);
     }
 }
@@ -3068,11 +3095,10 @@ void OpenGLDriver::bindBufferRange(BufferObjectBinding bindingType, uint32_t ind
     assert_invariant(offset + size <= ub->byteCount);
 
     if (UTILS_UNLIKELY(ub->bindingType == BufferObjectBinding::UNIFORM && gl.isES2())) {
-        mUniformBindings[index] = {
+        gl.setEs2UniformBinding(index,
                 ub->gl.id,
                 static_cast<uint8_t const*>(ub->gl.buffer) + offset,
-                ub->age,
-        };
+                ub->age);
     } else {
         GLenum const target = GLUtils::getBufferBindingType(bindingType);
 
@@ -3090,7 +3116,7 @@ void OpenGLDriver::unbindBuffer(BufferObjectBinding bindingType, uint32_t index)
     auto& gl = mContext;
 
     if (UTILS_UNLIKELY(bindingType == BufferObjectBinding::UNIFORM && gl.isES2())) {
-        mUniformBindings[index] = {};
+        gl.setEs2UniformBinding(index, 0, nullptr, 0);
         return;
     }
 
@@ -3107,36 +3133,6 @@ void OpenGLDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
     CHECK_GL_ERROR(utils::slog.e)
 }
 
-
-#ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
-GLuint OpenGLDriver::getSamplerSlow(SamplerParams params) const noexcept {
-    assert_invariant(mSamplerMap.find(params) == mSamplerMap.end());
-
-    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)
-    auto& gl = mContext;
-    if (gl.ext.EXT_texture_filter_anisotropic &&
-            !gl.bugs.texture_filter_anisotropic_broken_on_sampler) {
-        GLfloat const anisotropy = float(1u << params.anisotropyLog2);
-        glSamplerParameterf(s, GL_TEXTURE_MAX_ANISOTROPY_EXT,
-                std::min(gl.gets.max_anisotropy, anisotropy));
-    }
-#endif
-    CHECK_GL_ERROR(utils::slog.e)
-    mSamplerMap[params] = s;
-    return s;
-}
-#endif
-
 void OpenGLDriver::insertEventMarker(char const* string, uint32_t len) {
 #ifndef __EMSCRIPTEN__
 #ifdef GL_EXT_debug_marker
@@ -3436,17 +3432,21 @@ void OpenGLDriver::executeGpuCommandsCompleteOps() noexcept {
 
 void OpenGLDriver::tick(int) {
     DEBUG_MARKER()
+#ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
     executeGpuCommandsCompleteOps();
+#endif
     executeEveryNowAndThenOps();
     getShaderCompilerService().tick();
 }
 
 void OpenGLDriver::beginFrame(
         UTILS_UNUSED int64_t monotonic_clock_ns,
+        UTILS_UNUSED int64_t refreshIntervalNs,
         UTILS_UNUSED uint32_t frameId) {
     DEBUG_MARKER()
     auto& gl = mContext;
     insertEventMarker("beginFrame");
+    mPlatform.beginFrame(monotonic_clock_ns, refreshIntervalNs, frameId);
     if (UTILS_UNLIKELY(!mTexturesWithStreamsAttached.empty())) {
         OpenGLPlatform& platform = mPlatform;
         for (GLTexture const* t : mTexturesWithStreamsAttached) {
@@ -3455,7 +3455,7 @@ void OpenGLDriver::beginFrame(
                 assert_invariant(t->hwStream->stream);
                 platform.updateTexImage(t->hwStream->stream,
                         &static_cast<GLStream*>(t->hwStream)->user_thread.timestamp); // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
-                // NOTE: We assume that updateTexImage() binds the texture on our behalf
+                // NOTE: We assume that OpenGLPlatform::updateTexImage() binds the texture on our behalf
                 gl.updateTexImage(GL_TEXTURE_EXTERNAL_OES, t->gl.id);
             }
         }
@@ -3463,12 +3463,12 @@ void OpenGLDriver::beginFrame(
 }
 
 void OpenGLDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
-        FrameScheduledCallback callback, void* user) {
+        CallbackHandler* handler, FrameScheduledCallback&& callback) {
     DEBUG_MARKER()
 }
 
 void OpenGLDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
+        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
     DEBUG_MARKER()
 }
 
@@ -3494,6 +3494,7 @@ void OpenGLDriver::endFrame(UTILS_UNUSED uint32_t frameId) {
 #endif
     //SYSTRACE_NAME("glFinish");
     //glFinish();
+    mPlatform.endFrame(frameId);
     insertEventMarker("endFrame");
 }
 
@@ -3604,13 +3605,11 @@ void OpenGLDriver::resolve(
     assert_invariant(s);
     assert_invariant(d);
 
-    ASSERT_PRECONDITION(
-            d->width == s->width && d->height == s->height,
-            "invalid resolve: src and dst sizes don't match");
+    FILAMENT_CHECK_PRECONDITION(d->width == s->width && d->height == s->height)
+            << "invalid resolve: src and dst sizes don't match";
 
-    ASSERT_PRECONDITION(s->samples > 1 && d->samples == 1,
-            "invalid resolve: src.samples=%u, dst.samples=%u",
-            +s->samples, +d->samples);
+    FILAMENT_CHECK_PRECONDITION(s->samples > 1 && d->samples == 1)
+            << "invalid resolve: src.samples=" << +s->samples << ", dst.samples=" << +d->samples;
 
     blit(   dst, dstLevel, dstLayer, {},
             src, srcLevel, srcLayer, {},
@@ -3705,7 +3704,7 @@ void OpenGLDriver::blit(
         case SamplerType::SAMPLER_EXTERNAL:
             break;
     }
-    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)
 
     gl.bindFramebuffer(GL_READ_FRAMEBUFFER, fbo[1]);
     switch (s->target) {
@@ -3731,7 +3730,7 @@ void OpenGLDriver::blit(
         case SamplerType::SAMPLER_EXTERNAL:
             break;
     }
-    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)
 
     gl.disable(GL_SCISSOR_TEST);
     glBlitFramebuffer(
@@ -3766,12 +3765,12 @@ void OpenGLDriver::blitDEPRECATED(TargetBufferFlags buffers,
     UTILS_UNUSED_IN_RELEASE auto& gl = mContext;
     assert_invariant(!gl.isES2());
 
-    ASSERT_PRECONDITION(buffers == TargetBufferFlags::COLOR0,
-            "blitDEPRECATED only supports COLOR0");
+    FILAMENT_CHECK_PRECONDITION(buffers == TargetBufferFlags::COLOR0)
+            << "blitDEPRECATED only supports COLOR0";
 
-    ASSERT_PRECONDITION(srcRect.left >= 0 && srcRect.bottom >= 0 &&
-                        dstRect.left >= 0 && dstRect.bottom >= 0,
-            "Source and destination rects must be positive.");
+    FILAMENT_CHECK_PRECONDITION(
+            srcRect.left >= 0 && srcRect.bottom >= 0 && dstRect.left >= 0 && dstRect.bottom >= 0)
+            << "Source and destination rects must be positive.";
 
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
 
@@ -3845,7 +3844,7 @@ void OpenGLDriver::updateTextureLodRange(GLTexture* texture, int8_t targetLevel)
 #endif
 }
 
-void OpenGLDriver::bindPipeline(PipelineState state) {
+void OpenGLDriver::bindPipeline(PipelineState const& state) {
     DEBUG_MARKER()
     auto& gl = mContext;
     setRasterState(state.rasterState);
@@ -3853,6 +3852,7 @@ void OpenGLDriver::bindPipeline(PipelineState state) {
     gl.polygonOffset(state.polygonOffset.slope, state.polygonOffset.constant);
     OpenGLProgram* const p = handle_cast<OpenGLProgram*>(state.program);
     mValidProgram = useProgram(p);
+    (*mCurrentPushConstants) = p->getPushConstants();
 }
 
 void OpenGLDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
@@ -3882,20 +3882,35 @@ void OpenGLDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
         return;
     }
 
-    if (UTILS_LIKELY(instanceCount <= 1)) {
-        glDrawElements(GLenum(rp->type), (GLsizei)indexCount, rp->gl.getIndicesType(),
-                reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize));
-    } else {
-        assert_invariant(!mContext.isES2());
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
-        glDrawElementsInstanced(GLenum(rp->type), (GLsizei)indexCount,
-                rp->gl.getIndicesType(),
-                reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize),
-                (GLsizei)instanceCount);
+    assert_invariant(!mContext.isES2());
+    glDrawElementsInstanced(GLenum(rp->type), (GLsizei)indexCount,
+            rp->gl.getIndicesType(),
+            reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize),
+            (GLsizei)instanceCount);
 #endif
+
+#if FILAMENT_ENABLE_MATDBG
+    CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
+#else
+    CHECK_GL_ERROR(utils::slog.e)
+#endif
+}
+
+void OpenGLDriver::draw2GLES2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
+    GLRenderPrimitive const* const rp = mBoundRenderPrimitive;
+    if (UTILS_UNLIKELY(!rp || !mValidProgram)) {
+        return;
     }
 
-#ifdef FILAMENT_ENABLE_MATDBG
+    assert_invariant(mContext.isES2());
+    assert_invariant(instanceCount == 1);
+
+    glDrawElements(GLenum(rp->type), (GLsizei)indexCount, rp->gl.getIndicesType(),
+            reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize));
+
+
+#if FILAMENT_ENABLE_MATDBG
     CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
 #else
     CHECK_GL_ERROR(utils::slog.e)
@@ -3914,7 +3929,11 @@ void OpenGLDriver::draw(PipelineState state, Handle<HwRenderPrimitive> rph,
     state.vertexBufferInfo = rp->vbih;
     bindPipeline(state);
     bindRenderPrimitive(rph);
-    draw2(indexOffset, indexCount, instanceCount);
+    if (UTILS_UNLIKELY(mContext.isES2())) {
+        draw2GLES2(indexOffset, indexCount, instanceCount);
+    } else {
+        draw2(indexOffset, indexCount, instanceCount);
+    }
 }
 
 void OpenGLDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGroupCount) {
@@ -3941,7 +3960,7 @@ void OpenGLDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGr
     glDispatchCompute(workGroupCount.x, workGroupCount.y, workGroupCount.z);
 #endif // BACKEND_OPENGL_LEVEL_GLES31
 
-#ifdef FILAMENT_ENABLE_MATDBG
+#if FILAMENT_ENABLE_MATDBG
     CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
 #else
     CHECK_GL_ERROR(utils::slog.e)

filament/backend/src/opengl/OpenGLDriver.h

@@ -20,6 +20,8 @@
 #include "DriverBase.h"
 #include "OpenGLContext.h"
 #include "OpenGLTimerQuery.h"
+#include "GLBufferObject.h"
+#include "GLTexture.h"
 #include "ShaderCompilerService.h"
 
 #include <backend/platforms/OpenGLPlatform.h>
@@ -64,9 +66,9 @@ namespace filament::backend {
 class OpenGLPlatform;
 class PixelBufferDescriptor;
 struct TargetBufferInfo;
-
 class OpenGLProgram;
 class TimerQueryFactoryInterface;
+struct PushConstantBundle;
 
 class OpenGLDriver final : public DriverBase {
     inline explicit OpenGLDriver(OpenGLPlatform* platform,
@@ -92,25 +94,6 @@ public:
         bool rec709 = false;
     };
 
-    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;
-    };
-
     struct GLVertexBufferInfo : public HwVertexBufferInfo {
         GLVertexBufferInfo() noexcept = default;
         GLVertexBufferInfo(uint8_t bufferCount, uint8_t attributeCount,
@@ -140,7 +123,6 @@ public:
         } gl;
     };
 
-    struct GLTexture;
     struct GLSamplerGroup : public HwSamplerGroup {
         using HwSamplerGroup::HwSamplerGroup;
         struct Entry {
@@ -157,27 +139,9 @@ public:
         Handle<HwVertexBufferInfo> vbih;
     };
 
-    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 GLBufferObject = filament::backend::GLBufferObject;
 
-            // 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;
-
-        OpenGLPlatform::ExternalTexture* externalTexture = nullptr;
-    };
+    using GLTexture = filament::backend::GLTexture;
 
     using GLTimerQuery = filament::backend::GLTimerQuery;
 
@@ -268,13 +232,13 @@ private:
     HandleAllocatorGL mHandleAllocator;
 
     template<typename D, typename ... ARGS>
-    Handle<D> initHandle(ARGS&& ... args) noexcept {
+    Handle<D> initHandle(ARGS&& ... args) {
         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) noexcept {
+    construct(Handle<B> const& handle, ARGS&& ... args) {
         return mHandleAllocator.destroyAndConstruct<D, B>(handle, std::forward<ARGS>(args) ...);
     }
 
@@ -288,7 +252,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) noexcept {
+    handle_cast(Handle<B>& handle) {
         return mHandleAllocator.handle_cast<Dp, B>(handle);
     }
 
@@ -296,7 +260,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) noexcept {
+    handle_cast(Handle<B> const& handle) {
         return mHandleAllocator.handle_cast<Dp, B>(handle);
     }
 
@@ -348,22 +312,6 @@ 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;
     }
@@ -388,16 +336,14 @@ private:
 
     void setScissor(Viewport const& scissor) noexcept;
 
+    void draw2GLES2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount);
+
     // ES2 only. Uniform buffer emulation binding points
     GLuint mLastAssignedEmulatedUboId = 0;
-    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;
 
@@ -431,6 +377,8 @@ private:
     // for ES2 sRGB support
     GLSwapChain* mCurrentDrawSwapChain = nullptr;
     bool mRec709OutputColorspace = false;
+
+    PushConstantBundle* mCurrentPushConstants = nullptr;
 };
 
 // ------------------------------------------------------------------------------------------------

filament/backend/src/opengl/OpenGLPlatform.cpp

@@ -55,6 +55,16 @@ uint32_t OpenGLPlatform::getDefaultFramebufferObject() noexcept {
     return 0;
 }
 
+void OpenGLPlatform::beginFrame(int64_t monotonic_clock_ns, int64_t refreshIntervalNs,
+        uint32_t frameId) noexcept {
+}
+
+void OpenGLPlatform::endFrame(uint32_t frameId) noexcept {
+}
+
+void OpenGLPlatform::preCommit() noexcept {
+}
+
 OpenGLPlatform::ContextType OpenGLPlatform::getCurrentContextType() const noexcept {
     return ContextType::UNPROTECTED;
 }

filament/backend/src/opengl/OpenGLProgram.cpp

@@ -46,6 +46,8 @@ struct OpenGLProgram::LazyInitializationData {
     Program::UniformBlockInfo uniformBlockInfo;
     Program::SamplerGroupInfo samplerGroupInfo;
     std::array<Program::UniformInfo, Program::UNIFORM_BINDING_COUNT> bindingUniformInfo;
+    utils::FixedCapacityVector<Program::PushConstant> vertexPushConstants;
+    utils::FixedCapacityVector<Program::PushConstant> fragmentPushConstants;
 };
 
 
@@ -53,7 +55,6 @@ OpenGLProgram::OpenGLProgram() noexcept = default;
 
 OpenGLProgram::OpenGLProgram(OpenGLDriver& gld, Program&& program) noexcept
         : HwProgram(std::move(program.getName())) {
-
     auto* const lazyInitializationData = new(std::nothrow) LazyInitializationData();
     lazyInitializationData->samplerGroupInfo = std::move(program.getSamplerGroupInfo());
     if (UTILS_UNLIKELY(gld.getContext().isES2())) {
@@ -61,6 +62,8 @@ OpenGLProgram::OpenGLProgram(OpenGLDriver& gld, Program&& program) noexcept
     } else {
         lazyInitializationData->uniformBlockInfo = std::move(program.getUniformBlockBindings());
     }
+    lazyInitializationData->vertexPushConstants = std::move(program.getPushConstants(ShaderStage::VERTEX));
+    lazyInitializationData->fragmentPushConstants = std::move(program.getPushConstants(ShaderStage::FRAGMENT));
 
     ShaderCompilerService& compiler = gld.getShaderCompilerService();
     mToken = compiler.createProgram(name, std::move(program));
@@ -203,6 +206,21 @@ void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint progra
         }
     }
     mUsedBindingsCount = usedBindingCount;
+
+    auto& vertexConstants = lazyInitializationData.vertexPushConstants;
+    auto& fragmentConstants = lazyInitializationData.fragmentPushConstants;
+
+    size_t const totalConstantCount = vertexConstants.size() + fragmentConstants.size();
+    if (totalConstantCount > 0) {
+        mPushConstants.reserve(totalConstantCount);
+        mPushConstantFragmentStageOffset = vertexConstants.size();
+        auto const transformAndAdd = [&](Program::PushConstant const& constant) {
+            GLint const loc = glGetUniformLocation(program, constant.name.c_str());
+            mPushConstants.push_back({loc, constant.type});
+        };
+        std::for_each(vertexConstants.cbegin(), vertexConstants.cend(), transformAndAdd);
+        std::for_each(fragmentConstants.cbegin(), fragmentConstants.cend(), transformAndAdd);
+    }
 }
 
 void OpenGLProgram::updateSamplers(OpenGLDriver* const gld) const noexcept {

filament/backend/src/opengl/OpenGLProgram.h

@@ -27,6 +27,7 @@
 
 #include <utils/compiler.h>
 #include <utils/FixedCapacityVector.h>
+#include <utils/Slice.h>
 
 #include <array>
 #include <limits>
@@ -38,6 +39,11 @@ namespace filament::backend {
 
 class OpenGLDriver;
 
+struct PushConstantBundle {
+    utils::Slice<std::pair<GLint, ConstantType>> vertexConstants;
+    utils::Slice<std::pair<GLint, ConstantType>> fragmentConstants;
+};
+
 class OpenGLProgram : public HwProgram {
 public:
 
@@ -70,14 +76,22 @@ 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;
@@ -89,14 +103,20 @@ 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;
@@ -104,12 +124,15 @@ private:
         mutable GLuint id = 0;
         mutable uint16_t age = std::numeric_limits<uint16_t>::max();
     };
-    UniformsRecord const* mUniformsRecords = nullptr;
-    GLint mRec709Location = -1;
+    UniformsRecord const* mUniformsRecords = nullptr;               // 8 bytes
+
+    // Note that this can be replaced with a raw pointer and an uint8_t (for size) to reduce the
+    // size of the container to 9 bytes if there is a need in the future.
+    utils::FixedCapacityVector<std::pair<GLint, ConstantType>> mPushConstants;// 16 bytes
 };
 
 // if OpenGLProgram is larger tha 64 bytes, it'll fall in a larger Handle bucket.
-static_assert(sizeof(OpenGLProgram) <= 64);
+static_assert(sizeof(OpenGLProgram) <= 64); // currently 64 bytes
 
 } // namespace filament::backend
 

filament/backend/src/opengl/platforms/CocoaExternalImage.mm

@@ -111,8 +111,8 @@ bool CocoaExternalImage::set(CVPixelBufferRef image) noexcept {
     }
 
     OSType formatType = CVPixelBufferGetPixelFormatType(image);
-    ASSERT_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA,
-            "macOS external images must be 32BGRA format.");
+    FILAMENT_CHECK_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA)
+            << "macOS external images must be 32BGRA format.";
 
     // The pixel buffer must be locked whenever we do rendering with it. We'll unlock it before
     // releasing.

filament/backend/src/opengl/platforms/CocoaTouchExternalImage.mm

@@ -135,13 +135,14 @@ bool CocoaTouchExternalImage::set(CVPixelBufferRef image) noexcept {
     }
 
     OSType formatType = CVPixelBufferGetPixelFormatType(image);
-    ASSERT_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA ||
-                         formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
-            "iOS external images must be in either 32BGRA or 420f format.");
+    FILAMENT_CHECK_POSTCONDITION(formatType == kCVPixelFormatType_32BGRA ||
+            formatType == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange)
+            << "iOS external images must be in either 32BGRA or 420f format.";
 
     size_t planeCount = CVPixelBufferGetPlaneCount(image);
-    ASSERT_POSTCONDITION(planeCount == 0 || planeCount == 2,
-            "The OpenGL backend does not support images with plane counts of %d.", planeCount);
+    FILAMENT_CHECK_POSTCONDITION(planeCount == 0 || planeCount == 2)
+            << "The OpenGL backend does not support images with plane counts of " << planeCount
+            << ".";
 
     // The pixel buffer must be locked whenever we do rendering with it. We'll unlock it before
     // releasing.

filament/backend/src/opengl/platforms/PlatformCocoaGL.mm

@@ -162,7 +162,7 @@ Driver* PlatformCocoaGL::createDriver(void* sharedContext, const Platform::Drive
     pImpl->mGLContext = nsOpenGLContext;
 
     int result = bluegl::bind();
-    ASSERT_POSTCONDITION(!result, "Unable to load OpenGL entry points.");
+    FILAMENT_CHECK_POSTCONDITION(!result) << "Unable to load OpenGL entry points.";
 
     UTILS_UNUSED_IN_RELEASE CVReturn success = CVOpenGLTextureCacheCreate(kCFAllocatorDefault, nullptr,
             [pImpl->mGLContext CGLContextObj], [pImpl->mGLContext.pixelFormat CGLPixelFormatObj], nullptr,

filament/backend/src/opengl/platforms/PlatformCocoaTouchGL.mm

@@ -61,7 +61,7 @@ Driver* PlatformCocoaTouchGL::createDriver(void* const sharedGLContext, const Pl
     EAGLSharegroup* sharegroup = (__bridge EAGLSharegroup*) sharedGLContext;
 
     EAGLContext *context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES3 sharegroup:sharegroup];
-    ASSERT_POSTCONDITION(context, "Unable to create OpenGL ES context.");
+    FILAMENT_CHECK_POSTCONDITION(context) << "Unable to create OpenGL ES context.";
 
     [EAGLContext setCurrentContext:context];
 
@@ -103,7 +103,7 @@ void PlatformCocoaTouchGL::createContext(bool shared) {
     EAGLContext* const context = [[EAGLContext alloc]
                                   initWithAPI:kEAGLRenderingAPIOpenGLES3
                                    sharegroup:sharegroup];
-    ASSERT_POSTCONDITION(context, "Unable to create extra OpenGL ES context.");
+    FILAMENT_CHECK_POSTCONDITION(context) << "Unable to create extra OpenGL ES context.";
     [EAGLContext setCurrentContext:context];
     pImpl->mAdditionalContexts.push_back(context);
 }
@@ -180,7 +180,8 @@ bool PlatformCocoaTouchGL::makeCurrent(ContextType type, SwapChain* drawSwapChai
         glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldFramebuffer);
         glBindFramebuffer(GL_FRAMEBUFFER, pImpl->mDefaultFramebuffer);
         GLenum const status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-        ASSERT_POSTCONDITION(status == GL_FRAMEBUFFER_COMPLETE, "Incomplete framebuffer.");
+        FILAMENT_CHECK_POSTCONDITION(status == GL_FRAMEBUFFER_COMPLETE)
+                << "Incomplete framebuffer.";
         glBindFramebuffer(GL_FRAMEBUFFER, oldFramebuffer);
     }
     return true;

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

@@ -174,7 +174,7 @@ Driver* PlatformEGL::createDriver(void* sharedContext, const Platform::DriverCon
     };
 
 #ifdef __ANDROID__
-    bool requestES2Context = false;
+    bool requestES2Context = driverConfig.forceGLES2Context;
     char property[PROP_VALUE_MAX];
     int const length = __system_property_get("debug.filament.es2", property);
     if (length > 0) {

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

@@ -19,12 +19,16 @@
 #include <backend/platforms/PlatformEGL.h>
 #include <backend/platforms/PlatformEGLAndroid.h>
 
+#include <private/backend/VirtualMachineEnv.h>
+
 #include "opengl/GLUtils.h"
 #include "ExternalStreamManagerAndroid.h"
 
 #include <android/api-level.h>
 #include <android/hardware_buffer.h>
 
+#include <utils/android/PerformanceHintManager.h>
+
 #include <utils/compiler.h>
 #include <utils/ostream.h>
 #include <utils/Log.h>
@@ -36,8 +40,11 @@
 
 #include <jni.h>
 
+#include <chrono>
 #include <new>
 
+#include <unistd.h>
+
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -77,9 +84,23 @@ using EGLStream = Platform::Stream;
 
 // ---------------------------------------------------------------------------------------------
 
+PlatformEGLAndroid::InitializeJvmForPerformanceManagerIfNeeded::InitializeJvmForPerformanceManagerIfNeeded() {
+    // PerformanceHintManager() needs the calling thread to be a Java thread; so we need
+    // to attach this thread to the JVM before we initialize PerformanceHintManager.
+    // This should be done in PerformanceHintManager(), but libutils doesn't have access to
+    // VirtualMachineEnv.
+    if (PerformanceHintManager::isSupported()) {
+        (void)VirtualMachineEnv::get().getEnvironment();
+    }
+}
+
+// ---------------------------------------------------------------------------------------------
+
 PlatformEGLAndroid::PlatformEGLAndroid() noexcept
         : PlatformEGL(),
-          mExternalStreamManager(ExternalStreamManagerAndroid::create()) {
+          mExternalStreamManager(ExternalStreamManagerAndroid::create()),
+          mInitializeJvmForPerformanceManagerIfNeeded(),
+          mPerformanceHintManager() {
 
     char scratch[PROP_VALUE_MAX + 1];
     int length = __system_property_get("ro.build.version.release", scratch);
@@ -112,8 +133,38 @@ void PlatformEGLAndroid::terminate() noexcept {
     PlatformEGL::terminate();
 }
 
+void PlatformEGLAndroid::beginFrame(
+        int64_t monotonic_clock_ns,
+        int64_t refreshIntervalNs,
+        uint32_t frameId) noexcept {
+    if (mPerformanceHintSession.isValid()) {
+        if (refreshIntervalNs <= 0) {
+            // we're not provided with a target time, assume 16.67ms
+            refreshIntervalNs = 16'666'667;
+        }
+        mStartTimeOfActualWork = clock::time_point(std::chrono::nanoseconds(monotonic_clock_ns));
+        mPerformanceHintSession.updateTargetWorkDuration(refreshIntervalNs);
+    }
+    PlatformEGL::beginFrame(monotonic_clock_ns, refreshIntervalNs, frameId);
+}
+
+void backend::PlatformEGLAndroid::preCommit() noexcept {
+    if (mPerformanceHintSession.isValid()) {
+        auto const actualWorkDuration = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                clock::now() - mStartTimeOfActualWork);
+        mPerformanceHintSession.reportActualWorkDuration(actualWorkDuration.count());
+    }
+    PlatformEGL::preCommit();
+}
+
 Driver* PlatformEGLAndroid::createDriver(void* sharedContext,
         const Platform::DriverConfig& driverConfig) noexcept {
+
+    // the refresh rate default value doesn't matter, we change it later
+    int32_t const tid = gettid();
+    mPerformanceHintSession = PerformanceHintManager::Session{
+            mPerformanceHintManager, &tid, 1, 16'666'667 };
+
     Driver* driver = PlatformEGL::createDriver(sharedContext, driverConfig);
     auto extensions = GLUtils::split(eglQueryString(mEGLDisplay, EGL_EXTENSIONS));
 

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

@@ -226,7 +226,7 @@ Driver* PlatformGLX::createDriver(void* const sharedGLContext,
     g_glx.setCurrentContext(mGLXDisplay, mDummySurface, mDummySurface, mGLXContext);
 
     int result = bluegl::bind();
-    ASSERT_POSTCONDITION(!result, "Unable to load OpenGL entry points.");
+    FILAMENT_CHECK_POSTCONDITION(!result) << "Unable to load OpenGL entry points.";
 
     return OpenGLPlatform::createDefaultDriver(this, sharedGLContext, driverConfig);
 }

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

@@ -154,7 +154,7 @@ Driver* PlatformWGL::createDriver(void* const sharedGLContext,
     }
 
     result = bluegl::bind();
-    ASSERT_POSTCONDITION(!result, "Unable to load OpenGL entry points.");
+    FILAMENT_CHECK_POSTCONDITION(!result) << "Unable to load OpenGL entry points.";
 
     return OpenGLPlatform::createDefaultDriver(this, sharedGLContext, driverConfig);
 

filament/backend/src/ostream.cpp

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