Throw an NSException on Apple platforms when panicking

BUILDING.md

@@ -73,6 +73,7 @@ The following CMake options are boolean options specific to Filament:
 - `FILAMENT_SUPPORTS_VULKAN`:      Include the Vulkan backend
 - `FILAMENT_INSTALL_BACKEND_TEST`: Install the backend test library so it can be consumed on iOS
 - `FILAMENT_USE_EXTERNAL_GLES3`:   Experimental: Compile Filament against OpenGL ES 3
+- `FILAMENT_USE_SWIFTSHADER`:      Compile Filament against SwiftShader
 - `FILAMENT_SKIP_SAMPLES`:         Don't build sample apps
 
 To turn an option on or off:
@@ -425,7 +426,7 @@ value is the desired roughness between 0 and 1.
 
 ## Generating C++ documentation
 
-To generate the documentation you must first install `doxygen` and `graphviz`, then run the
+To generate the documentation you must first install `doxygen` and `graphviz`, then run the 
 following commands:
 
 ```shell
@@ -435,62 +436,32 @@ doxygen docs/doxygen/filament.doxygen
 
 Finally simply open `docs/html/index.html` in your web browser.
 
-## Software Rasterization
+## SwiftShader
 
-We have tested swiftshader and Mesa for software rasterization on the Vulkan/GL backends.
-
-To use this for Vulkan, please first make sure that the [Vulkan SDK](https://www.lunarg.com/vulkan-sdk/) is
-installed on your machine. If you are doing a manual installation of the SDK on Linux, you will have
-to source `setup-env.sh` in the SDK's root folder to make sure the Vulkan loader is the first lib loaded.
-
-### Swiftshader (Vulkan) [tested on macOS and Linux]
-
-First, build SwiftShader
+To try out Filament's Vulkan support with SwiftShader, first build SwiftShader and set the
+`SWIFTSHADER_LD_LIBRARY_PATH` variable to the folder that contains `libvk_swiftshader.dylib`:
 
 ```shell
 git clone https://github.com/google/swiftshader.git
 cd swiftshader/build
 cmake .. &&  make -j
+export SWIFTSHADER_LD_LIBRARY_PATH=`pwd`
 ```
 
-and then set `VK_ICD_FILENAMES` to the ICD json produced in the build. For example,
-```shell
-export VK_ICD_FILENAMES=/Users/user/swiftshader/build/Darwin/vk_swiftshader_icd.json
-```
+Next, go to your Filament repo and use the [easy build](#easy-build) script with `-t`.
 
-Build and run Filament as usual and specify the Vulkan backend when creating the Engine.
+## SwiftShader for CI
 
-### Mesa's LLVMPipe (GL) and Lavapipe (Vulkan) [tested on Linux]
-
-We will only cover steps that build Mesa from source. The official documentation of Mesa mentioned
-that in general precompiled libraries [are **not** made available](https://docs.mesa3d.org/precompiled.html).
-
-Download the repo and make sure you have the build depedencies. For example (assuming an Ubuntu/Debian distro),
-```shell
-git clone https://gitlab.freedesktop.org/mesa/mesa.git
-sudo apt-get build-dep mesa
-```
-
-To build both the GL and Vulkan rasterizers,
+Continuous testing turnaround can be quite slow if you need to build SwiftShader from scratch, so we
+provide an Ubuntu-based Docker image that has it already built. The Docker image also includes
+everything necessary for building Filament. You can fetch and run the image as follows:
 
 ```shell
-cd mesa
-mkdir -p out
-meson setup builddir/ -Dprefix=$(pwd)/out -Dglx=xlib -Dgallium-drivers=swrast -Dvulkan-drivers=swrast
-meson install -C builddir/
+docker pull ghcr.io/filament-assets/swiftshader
+docker run -it ghcr.io/filament-assets/swiftshader
 ```
 
-For GL, we need to ensure that we load the GL lib from the mesa output directory.  For example, to run
-the debug `gltf_viewer`, we would execute
-```shell
-LD_LIBRARY_PATH=/Users/user/mesa/out/lib/x86_64-linux-gnu \
-    ./out/cmake-debug/samples/gltf_viewer -a opengl
-```
+To do more with the container, see the helper script at `build/swiftshader/test.sh`.
 
-For Vulkan, we need to set the path to the ICD json, which tells the loader where to find the driver
-library. To run `gltf_viewer`, we would execute
-```shell
-VK_ICD_FILENAMES=/Users/user/mesa/out/share/vulkan/icd.d/lvp_icd.x86_64.json \
-    ./out/cmake-debug/samples/gltf_viewer -a vulkan
-
-```
+If you are a team member, you can update the public image to the latest SwiftShader by
+following the instructions at the top of `build/swiftshader/Dockerfile`.

CMakeLists.txt

@@ -21,6 +21,8 @@ project(TNT)
 # ==================================================================================================
 option(FILAMENT_USE_EXTERNAL_GLES3 "Experimental: Compile Filament against OpenGL ES 3" OFF)
 
+option(FILAMENT_USE_SWIFTSHADER "Compile Filament against SwiftShader" OFF)
+
 option(FILAMENT_ENABLE_LTO "Enable link-time optimizations if supported by the compiler" OFF)
 
 option(FILAMENT_SKIP_SAMPLES "Don't build samples" OFF)
@@ -69,10 +71,6 @@ set(FILAMENT_METAL_HANDLE_ARENA_SIZE_IN_MB "8" CACHE STRING
     "Size of the Metal handle arena, default 8."
 )
 
-set(FILAMENT_BACKEND_DEBUG_FLAG "" CACHE STRING
-    "A debug flag meant for enabling/disabling backend debugging paths"
-)
-
 # Enable exceptions by default in spirv-cross.
 set(SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS OFF)
 
@@ -143,6 +141,11 @@ if (LINUX)
             add_definitions(-DFILAMENT_SUPPORTS_XCB)
         endif()
 
+        # Default Swiftshader build does not enable the xlib extension
+        if (FILAMENT_SUPPORTS_XLIB AND FILAMENT_USE_SWIFTSHADER)
+            set(FILAMENT_SUPPORTS_XLIB OFF)
+        endif()
+
         if (FILAMENT_SUPPORTS_XLIB)
             add_definitions(-DFILAMENT_SUPPORTS_XLIB)
         endif()
@@ -166,6 +169,15 @@ if (NOT ANDROID AND NOT WEBGL AND NOT IOS AND NOT FILAMENT_LINUX_IS_MOBILE)
     set(IS_HOST_PLATFORM TRUE)
 endif()
 
+if (IOS)
+    # Remove the headerpad_max_install_names linker flag on iOS. It causes warnings when linking
+    # executables with bitcode.
+    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_C_LINK_FLAGS ${CMAKE_C_LINK_FLAGS})
+    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_CXX_LINK_FLAGS ${CMAKE_CXX_LINK_FLAGS})
+    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
+    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS})
+endif()
+
 if (WIN32)
     # Link statically against c/c++ lib to avoid missing redistriburable such as
     # "VCRUNTIME140.dll not found. Try reinstalling the app.", but give users
@@ -320,6 +332,10 @@ if (FILAMENT_SUPPORTS_EGL_ON_LINUX)
   set(EGL TRUE)
 endif()
 
+if (FILAMENT_USE_SWIFTSHADER)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DFILAMENT_USE_SWIFTSHADER")
+endif()
+
 if (WIN32)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_USE_MATH_DEFINES=1")
 endif()
@@ -373,9 +389,8 @@ endif()
 if (NOT MSVC AND NOT IOS)
     # Omitting stack frame pointers prevents the generation of readable stack traces in crash reports on iOS
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer")
-endif()
 
-if (NOT MSVC)
+    # These aren't compatible with -fembed-bitcode (and seem to have no effect on Apple platforms anyway)
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffunction-sections -fdata-sections")
 endif()
 
@@ -440,13 +455,8 @@ endif()
 if (NOT WEBGL)
     set(GC_SECTIONS "-Wl,--gc-sections")
 endif()
-
 set(B_SYMBOLIC_FUNCTIONS "-Wl,-Bsymbolic-functions")
 
-if (ANDROID)
-set(BINARY_ALIGNMENT "-Wl,-z,max-page-size=16384")
-endif()
-
 if (APPLE)
     set(GC_SECTIONS "-Wl,-dead_strip")
     set(B_SYMBOLIC_FUNCTIONS "")
@@ -460,7 +470,7 @@ if (APPLE)
 endif()
 
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${GC_SECTIONS}")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${GC_SECTIONS} ${B_SYMBOLIC_FUNCTIONS} ${BINARY_ALIGNMENT}")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${GC_SECTIONS} ${B_SYMBOLIC_FUNCTIONS}")
 
 if (WEBGL_PTHREADS)
     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pthread")
@@ -524,15 +534,13 @@ else()
 endif()
 
 # This only affects the prebuilt shader files in gltfio and samples, not filament library.
-# The value can be either "instanced", "multiview", or "none"
-set(FILAMENT_SAMPLES_STEREO_TYPE "none" CACHE STRING
+# The value can be either "instanced" or "multiview".
+set(FILAMENT_SAMPLES_STEREO_TYPE "instanced" CACHE STRING
     "Stereoscopic type that shader files in gltfio and samples are built for."
 )
 string(TOLOWER "${FILAMENT_SAMPLES_STEREO_TYPE}" FILAMENT_SAMPLES_STEREO_TYPE)
-if (NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "instanced"
-    AND NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "multiview"
-    AND NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "none")
-    message(FATAL_ERROR "Invalid stereo type: \"${FILAMENT_SAMPLES_STEREO_TYPE}\" choose either \"instanced\",  \"multiview\", or \"none\" ")
+if (NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "instanced" AND NOT FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "multiview")
+    message(FATAL_ERROR "Invalid stereo type: \"${FILAMENT_SAMPLES_STEREO_TYPE}\" choose either \"instanced\" or \"multiview\" ")
 endif ()
 
 # Compiling samples for multiview implies enabling multiview feature as well.
@@ -540,12 +548,6 @@ if (FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "multiview")
     set(FILAMENT_ENABLE_MULTIVIEW ON)
 endif ()
 
-# Define backend flag for debug only
-if (CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT FILAMENT_BACKEND_DEBUG_FLAG STREQUAL "")
-    add_definitions(-DFILAMENT_BACKEND_DEBUG_FLAG=${FILAMENT_BACKEND_DEBUG_FLAG})
-    unset(FILAMENT_BACKEND_DEBUG_FLAG)
-endif()
-
 # ==================================================================================================
 # Material compilation flags
 # ==================================================================================================
@@ -674,6 +676,21 @@ else()
     set(IMPORT_EXECUTABLES ${FILAMENT}/${IMPORT_EXECUTABLES_DIR}/ImportExecutables-${CMAKE_BUILD_TYPE}.cmake)
 endif()
 
+# ==================================================================================================
+# Try to find Vulkan if the SDK is installed, otherwise fall back to the bundled version.
+# This needs to stay in our top-level CMakeLists because it sets up variables that are used by the
+# "bluevk" and "samples" targets.
+# ==================================================================================================
+
+if (FILAMENT_USE_SWIFTSHADER)
+    if (NOT FILAMENT_SUPPORTS_VULKAN)
+        message(ERROR "SwiftShader is only useful when Vulkan is enabled.")
+    endif()
+    find_library(SWIFTSHADER_VK NAMES vk_swiftshader HINTS "$ENV{SWIFTSHADER_LD_LIBRARY_PATH}")
+    message(STATUS "Found SwiftShader VK library in: ${SWIFTSHADER_VK}.")
+    add_definitions(-DFILAMENT_VKLIBRARY_PATH=\"${SWIFTSHADER_VK}\")
+endif()
+
 # ==================================================================================================
 # Common Functions
 # ==================================================================================================
@@ -735,6 +752,7 @@ add_subdirectory(${FILAMENT}/filament)
 add_subdirectory(${FILAMENT}/shaders)
 add_subdirectory(${EXTERNAL}/basisu/tnt)
 add_subdirectory(${EXTERNAL}/civetweb/tnt)
+add_subdirectory(${EXTERNAL}/hat-trie/tnt)
 add_subdirectory(${EXTERNAL}/imgui/tnt)
 add_subdirectory(${EXTERNAL}/robin-map/tnt)
 add_subdirectory(${EXTERNAL}/smol-v/tnt)
@@ -801,9 +819,6 @@ if (IS_HOST_PLATFORM)
     add_subdirectory(${TOOLS}/glslminifier)
     add_subdirectory(${TOOLS}/matc)
     add_subdirectory(${TOOLS}/matinfo)
-    if (NOT WIN32)  # matedit not yet supported on Windows
-        add_subdirectory(${TOOLS}/matedit)
-    endif()
     add_subdirectory(${TOOLS}/mipgen)
     add_subdirectory(${TOOLS}/normal-blending)
     add_subdirectory(${TOOLS}/resgen)

NEW_RELEASE_NOTES.md

@@ -7,3 +7,5 @@ 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.52.3'
+    implementation 'com.google.android.filament:filament-android:1.51.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.52.3'
+pod 'Filament', '~> 1.51.0'
 ```
 
 ### Snapshots

RELEASE_NOTES.md

@@ -7,51 +7,6 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).
 
-## v1.52.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/filamat-android/CMakeLists.txt

@@ -38,7 +38,6 @@ set(FILAMAT_INCLUDE_DIRS
 include_directories(${FILAMENT_DIR}/include)
 
 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${CMAKE_SOURCE_DIR}/libfilamat-jni.map")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")
 
 add_library(filamat-jni SHARED src/main/cpp/MaterialBuilder.cpp)
 target_include_directories(filamat-jni PRIVATE ${FILAMAT_INCLUDE_DIRS})

android/filament-android/CMakeLists.txt

@@ -59,7 +59,6 @@ endif()
 
 set(VERSION_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/libfilament-jni.map")
 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${VERSION_SCRIPT}")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")
 
 add_library(filament-jni SHARED
     src/main/cpp/BufferObject.cpp

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

@@ -342,21 +342,6 @@ Java_com_google_android_filament_Engine_nIsValidMaterial(JNIEnv*, jclass,
     return (jboolean)engine->isValid((Material*)nativeMaterial);
 }
 
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsValidMaterialInstance(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeMaterial, jlong nativeMaterialInstance) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValid((Material*)nativeMaterial,
-            (MaterialInstance*)nativeMaterialInstance);
-}
-
-extern "C" JNIEXPORT jboolean JNICALL
-        Java_com_google_android_filament_Engine_nIsValidExpensiveMaterialInstance(JNIEnv*, jclass,
-        jlong nativeEngine, jlong nativeMaterialInstance) {
-    Engine* engine = (Engine *)nativeEngine;
-    return (jboolean)engine->isValidExpensive((MaterialInstance*)nativeMaterialInstance);
-}
-
 extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Engine_nIsValidSkybox(JNIEnv*, jclass,
         jlong nativeEngine, jlong nativeSkybox) {
@@ -406,13 +391,6 @@ Java_com_google_android_filament_Engine_nFlush(JNIEnv*, jclass,
     engine->flush();
 }
 
-extern "C" JNIEXPORT jboolean JNICALL
-Java_com_google_android_filament_Engine_nIsPaused(JNIEnv*, jclass,
-        jlong nativeEngine) {
-    Engine* engine = (Engine*) nativeEngine;
-    return (jboolean)engine->isPaused();
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_Engine_nSetPaused(JNIEnv*, jclass,
         jlong nativeEngine, jboolean paused) {
@@ -517,9 +495,7 @@ 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,
-        jint preferredShaderLanguage,
-        jboolean forceGLES2Context) {
+        jboolean disableHandleUseAfterFreeCheck) {
     Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
     Engine::Config config = {
             .commandBufferSizeMB = (uint32_t) commandBufferSizeMB,
@@ -535,8 +511,6 @@ 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,25 +244,13 @@ Java_com_google_android_filament_RenderableManager_nBuilderMorphing(JNIEnv*, jcl
     builder->morphing(targetCount);
 }
 
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nBuilderMorphingStandard(JNIEnv*, jclass,
-        jlong nativeBuilder, jlong nativeMorphTargetBuffer) {
-    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
-    builder->morphing(morphTargetBuffer);
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_RenderableManager_nBuilderSetMorphTargetBufferAt(JNIEnv*, jclass,
         jlong nativeBuilder, int level, int primitiveIndex, jlong nativeMorphTargetBuffer,
         int offset, int count) {
     RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    if (nativeMorphTargetBuffer) {
-        MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
-        builder->morphing(level, primitiveIndex, morphTargetBuffer, offset, count);
-    } else {
-        builder->morphing(level, primitiveIndex, offset, count);
-    }
+    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
+    builder->morphing(level, primitiveIndex, morphTargetBuffer, offset, count);
 }
 
 extern "C" JNIEXPORT void JNICALL
@@ -338,14 +326,9 @@ Java_com_google_android_filament_RenderableManager_nSetMorphTargetBufferAt(JNIEn
         jclass, jlong nativeRenderableManager, jint i, int level, jint primitiveIndex,
         jlong nativeMorphTargetBuffer, jint offset, jint count) {
     RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
-    if (nativeMorphTargetBuffer) {
-        MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
-        rm->setMorphTargetBufferAt((RenderableManager::Instance) i, (uint8_t) level,
-                (size_t) primitiveIndex, morphTargetBuffer, (size_t) offset, (size_t) count);
-    } else {
-        rm->setMorphTargetBufferAt((RenderableManager::Instance) i, (uint8_t) level,
-                (size_t) primitiveIndex, (size_t) offset, (size_t) count);
-    }
+    MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
+    rm->setMorphTargetBufferAt((RenderableManager::Instance) i, (uint8_t) level,
+            (size_t) primitiveIndex, morphTargetBuffer, (size_t) offset, (size_t) count);
 }
 
 extern "C" JNIEXPORT jint JNICALL

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

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

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

@@ -159,12 +159,9 @@ public class Engine {
     };
 
     /**
-     * The type of technique for stereoscopic rendering. (Note that the materials used will need to be
-     * compatible with the chosen technique.)
+     * The type of technique for stereoscopic rendering
      */
     public enum StereoscopicType {
-        /** No stereoscopic rendering. */
-        NONE,
         /** Stereoscopic rendering is performed using instanced rendering technique. */
         INSTANCED,
         /** Stereoscopic rendering is performed using the multiview feature from the graphics backend. */
@@ -228,9 +225,7 @@ public class Engine {
                     config.textureUseAfterFreePoolSize, config.disableParallelShaderCompile,
                     config.stereoscopicType.ordinal(), config.stereoscopicEyeCount,
                     config.resourceAllocatorCacheSizeMB, config.resourceAllocatorCacheMaxAge,
-                    config.disableHandleUseAfterFreeCheck,
-                    config.preferredShaderLanguage.ordinal(),
-                    config.forceGLES2Context);
+                    config.disableHandleUseAfterFreeCheck);
             return this;
         }
 
@@ -408,7 +403,7 @@ public class Engine {
          *
          * @see View#setStereoscopicOptions
          */
-        public StereoscopicType stereoscopicType = StereoscopicType.NONE;
+        public StereoscopicType stereoscopicType = StereoscopicType.INSTANCED;
 
         /**
          * The number of eyes to render when stereoscopic rendering is enabled. Supported values are
@@ -433,35 +428,6 @@ 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) {
@@ -883,24 +849,6 @@ public class Engine {
         return nIsValidMaterial(getNativeObject(), object.getNativeObject());
     }
 
-    /**
-     * Returns whether the object is valid.
-     * @param object Object to check for validity
-     * @return returns true if the specified object is valid.
-     */
-    public boolean isValidMaterialInstance(@NonNull Material ma, MaterialInstance mi) {
-        return nIsValidMaterialInstance(getNativeObject(), ma.getNativeObject(), mi.getNativeObject());
-    }
-
-    /**
-     * Returns whether the object is valid.
-     * @param object Object to check for validity
-     * @return returns true if the specified object is valid.
-     */
-    public boolean isValidExpensiveMaterialInstance(@NonNull MaterialInstance object) {
-        return nIsValidExpensiveMaterialInstance(getNativeObject(), object.getNativeObject());
-    }
-
     /**
      * Returns whether the object is valid.
      * @param object Object to check for validity
@@ -1261,17 +1209,6 @@ public class Engine {
         nFlush(getNativeObject());
     }
 
-    /**
-     * Get paused state of rendering thread.
-     *
-     * <p>Warning: This is an experimental API.
-     *
-     * @see #setPaused
-     */
-    public boolean isPaused() {
-        return nIsPaused(getNativeObject());
-    }
-
     /**
      * Pause or resume the rendering thread.
      *
@@ -1354,8 +1291,6 @@ public class Engine {
     private static native boolean nIsValidSkinningBuffer(long nativeEngine, long nativeSkinningBuffer);
     private static native boolean nIsValidIndirectLight(long nativeEngine, long nativeIndirectLight);
     private static native boolean nIsValidMaterial(long nativeEngine, long nativeMaterial);
-    private static native boolean nIsValidMaterialInstance(long nativeEngine, long nativeMaterial, long nativeMaterialInstance);
-    private static native boolean nIsValidExpensiveMaterialInstance(long nativeEngine, long nativeMaterialInstance);
     private static native boolean nIsValidSkybox(long nativeEngine, long nativeSkybox);
     private static native boolean nIsValidColorGrading(long nativeEngine, long nativeColorGrading);
     private static native boolean nIsValidTexture(long nativeEngine, long nativeTexture);
@@ -1364,7 +1299,6 @@ public class Engine {
     private static native void nDestroyEntity(long nativeEngine, int entity);
     private static native void nFlushAndWait(long nativeEngine);
     private static native void nFlush(long nativeEngine);
-    private static native boolean nIsPaused(long nativeEngine);
     private static native void nSetPaused(long nativeEngine, boolean paused);
     private static native long nGetTransformManager(long nativeEngine);
     private static native long nGetLightManager(long nativeEngine);
@@ -1387,9 +1321,7 @@ public class Engine {
             long textureUseAfterFreePoolSize, boolean disableParallelShaderCompile,
             int stereoscopicType, long stereoscopicEyeCount,
             long resourceAllocatorCacheSizeMB, long resourceAllocatorCacheMaxAge,
-            boolean disableHandleUseAfterFreeCheck,
-            int preferredShaderLanguage,
-            boolean forceGLES2Context);
+            boolean disableHandleUseAfterFreeCheck);
     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,7 +524,14 @@ public class RenderableManager {
         }
 
         /**
-         * Controls if the renderable has legacy vertex morphing targets, zero by default.
+         * Controls if the renderable has vertex morphing targets, zero by default. This is
+         * required to enable GPU morphing.
+         *
+         * <p>Filament supports two morphing modes: standard (default) and legacy.</p>
+         *
+         * <p>For standard morphing, A {@link MorphTargetBuffer} must be created and provided via
+         * {@link RenderableManager#setMorphTargetBufferAt}. Standard morphing supports up to
+         * <code>CONFIG_MAX_MORPH_TARGET_COUNT</code> morph targets.</p>
          *
          * For legacy morphing, the attached {@link VertexBuffer} must provide data in the
          * appropriate {@link VertexBuffer.VertexAttribute} slots (<code>MORPH_POSITION_0</code> etc).
@@ -542,22 +549,6 @@ public class RenderableManager {
             return this;
         }
 
-        /**
-         * Controls if the renderable has vertex morphing targets, zero by default.
-         *
-         * <p>For standard morphing, A {@link MorphTargetBuffer} must be provided.
-         * Standard morphing supports up to
-         * <code>CONFIG_MAX_MORPH_TARGET_COUNT</code> morph targets.</p>
-         *
-         * <p>See also {@link RenderableManager#setMorphWeights}, which can be called on a per-frame basis
-         * to advance the animation.</p>
-         */
-        @NonNull
-        public Builder morphing(@NonNull MorphTargetBuffer morphTargetBuffer) {
-            nBuilderMorphingStandard(mNativeBuilder, morphTargetBuffer.getNativeObject());
-            return this;
-        }
-
         /**
          * Specifies the morph target buffer for a primitive.
          *
@@ -574,17 +565,6 @@ public class RenderableManager {
          * @param count number of vertices in the morph target buffer to read, must equal the geometry's count (for triangles, this should be a multiple of 3)
          */
         @NonNull
-        public Builder morphing(@IntRange(from = 0) int level,
-                                @IntRange(from = 0) int primitiveIndex,
-                                @IntRange(from = 0) int offset,
-                                @IntRange(from = 0) int count) {
-            nBuilderSetMorphTargetBufferAt(mNativeBuilder, level, primitiveIndex, 0, offset, count);
-            return this;
-        }
-
-        /** @deprecated */
-        @Deprecated
-        @NonNull
         public Builder morphing(@IntRange(from = 0) int level,
                                 @IntRange(from = 0) int primitiveIndex,
                                 @NonNull MorphTargetBuffer morphTargetBuffer,
@@ -595,8 +575,10 @@ public class RenderableManager {
             return this;
         }
 
-        /** @deprecated */
-        @Deprecated
+        /**
+         * Utility method to specify morph target buffer for a primitive.
+         * For details, see the {@link RenderableManager.Builder#morphing}.
+         */
         @NonNull
         public Builder morphing(@IntRange(from = 0) int level,
                                 @IntRange(from = 0) int primitiveIndex,
@@ -705,16 +687,6 @@ public class RenderableManager {
      *
      * @see Builder#morphing
      */
-    public void setMorphTargetBufferAt(@EntityInstance int i,
-                                       @IntRange(from = 0) int level,
-                                       @IntRange(from = 0) int primitiveIndex,
-                                       @IntRange(from = 0) int offset,
-                                       @IntRange(from = 0) int count) {
-        nSetMorphTargetBufferAt(mNativeObject, i, level, primitiveIndex, 0, offset, count);
-    }
-
-    /** @deprecated */
-    @Deprecated
     public void setMorphTargetBufferAt(@EntityInstance int i,
                                        @IntRange(from = 0) int level,
                                        @IntRange(from = 0) int primitiveIndex,
@@ -725,8 +697,10 @@ public class RenderableManager {
                 morphTargetBuffer.getNativeObject(), offset, count);
     }
 
-    /** @deprecated */
-    @Deprecated
+    /**
+     * Utility method to change morph target buffer for the given primitive.
+     * For details, see the {@link RenderableManager#setMorphTargetBufferAt}.
+     */
     public void setMorphTargetBufferAt(@EntityInstance int i,
                                        @IntRange(from = 0) int level,
                                        @IntRange(from = 0) int primitiveIndex,
@@ -1032,7 +1006,6 @@ public class RenderableManager {
     private static native int nBuilderSkinningBones(long nativeBuilder, int boneCount, Buffer bones, int remaining);
     private static native void nBuilderSkinningBuffer(long nativeBuilder, long nativeSkinningBuffer, int boneCount, int offset);
     private static native void nBuilderMorphing(long nativeBuilder, int targetCount);
-    private static native void nBuilderMorphingStandard(long nativeBuilder, long nativeMorphTargetBuffer);
     private static native void nBuilderSetMorphTargetBufferAt(long nativeBuilder, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset, int count);
     private static native void nBuilderEnableSkinningBuffers(long nativeBuilder, boolean enabled);
     private static native void nBuilderFog(long nativeBuilder, boolean enabled);

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

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

android/filament-utils-android/CMakeLists.txt

@@ -31,7 +31,6 @@ set_target_properties(iblprefilter PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libfilament-iblprefilter.a)
 
 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/libfilament-utils-jni.map")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")
 
 add_library(filament-utils-jni SHARED
         src/main/cpp/AutomationEngine.cpp

android/gltfio-android/CMakeLists.txt

@@ -44,7 +44,6 @@ set_target_properties(uberarchive PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libuberarchive.a)
 
 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/libgltfio-jni.map")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")
 
 set(GLTFIO_SRCS
         ${GLTFIO_DIR}/include/gltfio/Animator.h
@@ -87,10 +86,7 @@ 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
@@ -120,6 +116,7 @@ set(GLTFIO_INCLUDE_DIRS
         ../../third_party/cgltf
         ../../third_party/meshoptimizer/src
         ../../third_party/robin-map
+        ../../third_party/hat-trie
         ../../third_party/stb
         ../../libs/utils/include
         ../../libs/ktxreader/include

android/gradle.properties

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

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 SwapChainFlags.CONFIG_SRGB_COLORSPACE
+                    flags = flags or SwapChain.CONFIG_SRGB_COLORSPACE
                 }
             }
 

build.sh

@@ -44,6 +44,8 @@ function print_help {
     echo "        Exclude Vulkan support from the Android build."
     echo "    -s"
     echo "        Add iOS simulator support to the iOS build."
+    echo "    -t"
+    echo "        Enable SwiftShader support for Vulkan in desktop builds."
     echo "    -e"
     echo "        Enable EGL on Linux support for desktop builds."
     echo "    -l"
@@ -59,14 +61,6 @@ function print_help {
     echo "    -b"
     echo "        Enable Address and Undefined Behavior Sanitizers (asan/ubsan) for debugging."
     echo "        This is only for the desktop build."
-    echo "    -x value"
-    echo "        Define a preprocessor flag FILAMENT_BACKEND_DEBUG_FLAG with [value]. This is useful for"
-    echo "        enabling debug paths in the backend from the build script. For example, make a"
-    echo "        systrace-enabled build without directly changing #defines. Remember to add -f when"
-    echo "        changing this option."
-    echo "    -S type"
-    echo "        Enable stereoscopic rendering where type is one of [instanced|multiview]. This is only"
-    echo "        meant for building the samples."
     echo ""
     echo "Build types:"
     echo "    release"
@@ -166,6 +160,8 @@ INSTALL_COMMAND=
 VULKAN_ANDROID_OPTION="-DFILAMENT_SUPPORTS_VULKAN=ON"
 VULKAN_ANDROID_GRADLE_OPTION=""
 
+SWIFTSHADER_OPTION="-DFILAMENT_USE_SWIFTSHADER=OFF"
+
 EGL_ON_LINUX_OPTION="-DFILAMENT_SUPPORTS_EGL_ON_LINUX=OFF"
 
 MATDBG_OPTION="-DFILAMENT_ENABLE_MATDBG=OFF"
@@ -176,10 +172,6 @@ MATOPT_GRADLE_OPTION=""
 
 ASAN_UBSAN_OPTION=""
 
-BACKEND_DEBUG_FLAG_OPTION=""
-
-STEREOSCOPIC_OPTION=""
-
 IOS_BUILD_SIMULATOR=false
 BUILD_UNIVERSAL_LIBRARIES=false
 
@@ -234,12 +226,11 @@ function build_desktop_target {
             -DIMPORT_EXECUTABLES_DIR=out \
             -DCMAKE_BUILD_TYPE="$1" \
             -DCMAKE_INSTALL_PREFIX="../${lc_target}/filament" \
+            ${SWIFTSHADER_OPTION} \
             ${EGL_ON_LINUX_OPTION} \
             ${MATDBG_OPTION} \
             ${MATOPT_OPTION} \
             ${ASAN_UBSAN_OPTION} \
-            ${BACKEND_DEBUG_FLAG_OPTION} \
-            ${STEREOSCOPIC_OPTION} \
             ${architectures} \
             ../..
         ln -sf "out/cmake-${lc_target}/compile_commands.json" \
@@ -298,7 +289,6 @@ function build_webgl_with_target {
             -DCMAKE_BUILD_TYPE="$1" \
             -DCMAKE_INSTALL_PREFIX="../webgl-${lc_target}/filament" \
             -DWEBGL=1 \
-            ${BACKEND_DEBUG_FLAG_OPTION} \
             ../..
         ln -sf "out/cmake-webgl-${lc_target}/compile_commands.json" \
            ../../compile_commands.json
@@ -373,8 +363,6 @@ function build_android_target {
             ${MATDBG_OPTION} \
             ${MATOPT_OPTION} \
             ${VULKAN_ANDROID_OPTION} \
-            ${BACKEND_DEBUG_FLAG_OPTION} \
-            ${STEREOSCOPIC_OPTION} \
             ../..
         ln -sf "out/cmake-android-${lc_target}-${arch}/compile_commands.json" \
            ../../compile_commands.json
@@ -609,7 +597,6 @@ function build_ios_target {
             -DCMAKE_TOOLCHAIN_FILE=../../third_party/clang/iOS.cmake \
             ${MATDBG_OPTION} \
             ${MATOPT_OPTION} \
-            ${STEREOSCOPIC_OPTION} \
             ../..
         ln -sf "out/cmake-ios-${lc_target}-${arch}/compile_commands.json" \
            ../../compile_commands.json
@@ -743,13 +730,6 @@ function validate_build_command {
             exit 1
         fi
     fi
-
-    # Make sure FILAMENT_BACKEND_DEBUG_FLAG is only meant for debug builds
-    if [[ "${ISSUE_DEBUG_BUILD}" != "true" ]] && [[ ! -z "${BACKEND_DEBUG_FLAG_OPTION}" ]]; then
-        echo "Error: cannot specify FILAMENT_BACKEND_DEBUG_FLAG in non-debug build"
-        exit 1
-    fi
-
     set -e
 }
 
@@ -796,7 +776,7 @@ function check_debug_release_build {
 
 pushd "$(dirname "$0")" > /dev/null
 
-while getopts ":hacCfgijmp:q:uvslwedk:bx:S:" opt; do
+while getopts ":hacCfgijmp:q:uvslwtedk:b" opt; do
     case ${opt} in
         h)
             print_help
@@ -860,7 +840,7 @@ while getopts ":hacCfgijmp:q:uvslwedk:bx:S:" opt; do
                         echo "Platform must be one of [desktop|android|ios|webgl|all]"
                         echo ""
                         exit 1
-                    ;;
+                    ;;    
                 esac
             done
             ;;
@@ -915,6 +895,10 @@ while getopts ":hacCfgijmp:q:uvslwedk:bx:S:" opt; do
             IOS_BUILD_SIMULATOR=true
             echo "iOS simulator support enabled."
             ;;
+        t)
+            SWIFTSHADER_OPTION="-DFILAMENT_USE_SWIFTSHADER=ON"
+            echo "SwiftShader support enabled."
+            ;;
         e)
             EGL_ON_LINUX_OPTION="-DFILAMENT_SUPPORTS_EGL_ON_LINUX=ON -DFILAMENT_SKIP_SDL2=ON -DFILAMENT_SKIP_SAMPLES=ON"
             echo "EGL on Linux support enabled; skipping SDL2."
@@ -934,22 +918,6 @@ while getopts ":hacCfgijmp:q:uvslwedk:bx:S:" opt; do
         b)  ASAN_UBSAN_OPTION="-DFILAMENT_ENABLE_ASAN_UBSAN=ON"
             echo "Enabled ASAN/UBSAN"
             ;;
-        x)  BACKEND_DEBUG_FLAG_OPTION="-DFILAMENT_BACKEND_DEBUG_FLAG=${OPTARG}"
-            ;;
-        S)  case $(echo "${OPTARG}" | tr '[:upper:]' '[:lower:]') in
-                instanced)
-                    STEREOSCOPIC_OPTION="-DFILAMENT_SAMPLES_STEREO_TYPE=instanced"
-                    ;;
-                multiview)
-                    STEREOSCOPIC_OPTION="-DFILAMENT_SAMPLES_STEREO_TYPE=multiview"
-                    ;;
-                *)
-                    echo "Unknown stereoscopic type ${OPTARG}"
-                    echo "Type must be one of [instanced|multiview]"
-                    echo ""
-                    exit 1
-            esac
-            ;;
         \?)
             echo "Invalid option: -${OPTARG}" >&2
             echo ""

build/swiftshader/Dockerfile

@@ -0,0 +1,53 @@
+# Build the image:
+#   docker build --no-cache --tag ssfilament -f build/swiftshader/Dockerfile .
+#   docker tag ssfilament ghcr.io/filament-assets/swiftshader
+#
+# Publish the image:
+#   docker login ghcr.io --username <user> --password <token>
+#   docker push ghcr.io/filament-assets/swiftshader
+#
+# Run the image and mount the current directory:
+#   docker run -it -v `pwd`:/trees/filament -t ssfilament
+
+FROM ubuntu:focal
+WORKDIR /trees
+ARG DEBIAN_FRONTEND=noninteractive
+ENV SWIFTSHADER_LD_LIBRARY_PATH=/trees/swiftshader/build
+ENV CXXFLAGS='-fno-builtin -Wno-pass-failed'
+
+RUN apt-get update && \
+    apt-get --no-install-recommends install -y \
+	apt-transport-https \
+	apt-utils \
+	build-essential \
+	cmake \
+	ca-certificates \
+	git \
+	ninja-build \
+	python \
+	python3 \
+	xorg-dev \
+	clang-7 \
+	libc++-7-dev \
+	libc++abi-7-dev \
+	lldb
+
+# Ensure that clang is used instead of gcc.
+RUN set -eux ;\
+    update-alternatives --install /usr/bin/clang clang /usr/bin/clang-7 100 ;\
+    update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-7 100 ;\
+    update-alternatives --install /usr/bin/cc cc /usr/bin/clang 100 ;\
+    update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 100
+
+# Get patch files from the local Filament tree.
+COPY build/swiftshader/*.diff .
+
+# Clone SwiftShader, apply patches, and build it.
+RUN set -eux ;\
+	git clone https://swiftshader.googlesource.com/SwiftShader swiftshader ;\
+    cd swiftshader ;\
+	git checkout 139f5c3 ;\
+	git apply /trees/*.diff ;\
+    cd build ;\
+    cmake .. -GNinja -DCMAKE_BUILD_TYPE=Release ;\
+    ninja

build/swiftshader/gallery.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+
+from pathlib import Path
+import os
+
+spath = os.path.dirname(os.path.realpath(__file__))
+
+path = Path(spath)
+
+folder = "../../results/"
+
+images = list(path.glob(folder + '*.png'))
+
+images.sort()
+
+gallery = open(path.absolute().joinpath(folder + 'index.html'), 'w')
+
+gallery.write("""<html>
+<head>
+<script type="module" src="https://unpkg.com/img-comparison-slider@latest/dist/component/component.esm.js"></script>
+<script nomodule="" src="https://unpkg.com/img-comparison-slider@latest/dist/component/component.js"></script>
+<link rel="stylesheet" href="https://unpkg.com/img-comparison-slider@latest/dist/collection/styles/initial.css"/>
+<style>
+    h2 {
+        font-weight: normal;
+        margin-top: 150px;
+        margin-bottom: 20px;
+    }
+    a {
+        text-decoration: none;
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        color: blue;
+    }
+    a:hover {
+        font-weight: bold;
+    }
+</style>
+</head>
+<body>
+""")
+
+tag = ''
+
+for image in images:
+    group = image.stem.rstrip('0123456789')
+    before = f'https://filament-assets.github.io/golden/{group}/{image.name}'
+    after = image.name
+    gallery.write('\n')
+    gallery.write(f'<h2><a href="{image.stem}.json">{image.stem}.json</a></h2>\n')
+    gallery.write('<img-comparison-slider>\n')
+    gallery.write(f'<img slot="before" src="{before}" /> <img slot="after" src="{after}" />\n')
+    gallery.write('</img-comparison-slider>\n')
+
+gallery.write("""</body>
+</html>
+""")

build/swiftshader/patch_00.diff

@@ -0,0 +1,62 @@
+diff --git a/src/Vulkan/VkPipeline.cpp b/src/Vulkan/VkPipeline.cpp
+index 86913ec72..3b35345af 100644
+--- a/src/Vulkan/VkPipeline.cpp
++++ b/src/Vulkan/VkPipeline.cpp
+@@ -71,7 +71,56 @@ std::vector<uint32_t> preprocessSpirv(
+ 	if(optimize)
+ 	{
+ 		// Full optimization list taken from spirv-opt.
+-		opt.RegisterPerformancePasses();
++
++		// We have removed CreateRedundancyEliminationPass because it segfaults when encountering:
++		//     %389 = OpCompositeConstruct %7 %386 %387 %388 %86
++		// When inserting an entry into instruction_to_value_ (which is an unordered_map)
++		// This could perhaps be investigated further with help from asan.
++
++		using namespace spvtools;
++		opt.RegisterPass(CreateWrapOpKillPass())
++			.RegisterPass(CreateDeadBranchElimPass())
++			.RegisterPass(CreateMergeReturnPass())
++			.RegisterPass(CreateInlineExhaustivePass())
++			.RegisterPass(CreateAggressiveDCEPass())
++			.RegisterPass(CreatePrivateToLocalPass())
++			.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
++			.RegisterPass(CreateLocalSingleStoreElimPass())
++			.RegisterPass(CreateAggressiveDCEPass())
++			.RegisterPass(CreateScalarReplacementPass())
++			.RegisterPass(CreateLocalAccessChainConvertPass())
++			.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
++			.RegisterPass(CreateLocalSingleStoreElimPass())
++			.RegisterPass(CreateAggressiveDCEPass())
++			.RegisterPass(CreateLocalMultiStoreElimPass())
++			.RegisterPass(CreateAggressiveDCEPass())
++			.RegisterPass(CreateCCPPass())
++			.RegisterPass(CreateAggressiveDCEPass())
++			.RegisterPass(CreateLoopUnrollPass(true))
++			.RegisterPass(CreateDeadBranchElimPass())
++			.RegisterPass(CreateRedundancyEliminationPass()) // workaround for SEGFAULT
++			.RegisterPass(CreateCombineAccessChainsPass())
++			.RegisterPass(CreateSimplificationPass())
++			.RegisterPass(CreateScalarReplacementPass())
++			.RegisterPass(CreateLocalAccessChainConvertPass())
++			.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
++			.RegisterPass(CreateLocalSingleStoreElimPass())
++			.RegisterPass(CreateAggressiveDCEPass())
++			.RegisterPass(CreateSSARewritePass())
++			.RegisterPass(CreateAggressiveDCEPass())
++			.RegisterPass(CreateVectorDCEPass())
++			.RegisterPass(CreateDeadInsertElimPass())
++			.RegisterPass(CreateDeadBranchElimPass())
++			.RegisterPass(CreateSimplificationPass())
++			.RegisterPass(CreateIfConversionPass())
++			.RegisterPass(CreateCopyPropagateArraysPass())
++			.RegisterPass(CreateReduceLoadSizePass())
++			.RegisterPass(CreateAggressiveDCEPass())
++			.RegisterPass(CreateBlockMergePass())
++			.RegisterPass(CreateRedundancyEliminationPass()) // workaround for SEGFAULT
++			.RegisterPass(CreateDeadBranchElimPass())
++			.RegisterPass(CreateBlockMergePass())
++			.RegisterPass(CreateSimplificationPass());
+ 	}
+ 
+ 	std::vector<uint32_t> optimized;

build/swiftshader/test.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+set -e
+
+function print_help {
+    local self_name=$(basename "$0")
+    echo "This script issues docker commands for testing Filament with SwiftShader."
+    echo "The usual sequence of commands is: fetch, start, build filament release, and run."
+    echo ""
+    echo "Usage:"
+    echo "    $self_name [command]"
+    echo ""
+    echo "Commands:"
+    echo "    build filament [debug | release]"
+    echo "        Use the container to build Filament."
+    echo "    build swiftshader [debug | release]"
+    echo "        Use the container to do a clean rebuild of SwiftShader."
+    echo "        (Note that the container already has SwiftShader built.)"
+    echo "    fetch"
+    echo "        Download the docker image from the central repository."
+    echo "    help"
+    echo "        Print this help message."
+    echo "    logs"
+    echo "        Print messages from the container's kernel ring buffer."
+    echo "        This is useful for diagnosing OOM issues."
+    echo "    run [lldb]"
+    echo "        Launch a test inside the container, optionally via lldb."
+    echo "    shell"
+    echo "        Interact with a bash prompt in the container."
+    echo "    start"
+    echo "        Start a container from the image."
+    echo "    stop"
+    echo "        Stop the container."
+    echo ""
+}
+
+# Change the current working directory to the Filament root.
+pushd "$(dirname "$0")/../.." > /dev/null
+
+if [[ "$1" == "build" ]] && [[ "$2" == "filament" ]]; then
+    docker exec runner filament/build.sh -t $3 gltf_viewer
+    exit $?
+fi
+
+if [[ "$1" == "build" ]] && [[ "$2" == "swiftshader" ]]; then
+    BUILD_TYPE="$3"
+    BUILD_TYPE="$(tr '[:lower:]' '[:upper:]' <<< ${BUILD_TYPE:0:1})${BUILD_TYPE:1}"
+    docker exec --workdir /trees/swiftshader runner rm -rf build
+    docker exec --workdir /trees/swiftshader runner mkdir build
+    docker exec --workdir /trees/swiftshader/build runner cmake -GNinja -DCMAKE_BUILD_TYPE="$BUILD_TYPE" ..
+    docker exec --workdir /trees/swiftshader/build runner ninja
+    exit $?
+fi
+
+if [[ "$1" == "fetch" ]]; then
+    docker pull ghcr.io/filament-assets/swiftshader:latest
+    docker tag ghcr.io/filament-assets/swiftshader:latest ssfilament
+    exit $?
+fi
+
+if [[ "$1" == "help" ]]; then
+    print_help
+    exit 0
+fi
+
+if [[ "$1" == "logs" ]]; then
+    docker exec runner dmesg --human --read-clear
+    exit $?
+fi
+
+if [[ "$1" == "run" ]] && [[ "$2" == "lldb" ]]; then
+    docker exec -i --workdir /trees/filament/results runner \
+          lldb --batch -o run -o bt -- \
+          ../out/cmake-release/samples/gltf_viewer \
+          --headless \
+          --batch ../libs/viewer/tests/basic.json \
+          --api vulkan
+    docker exec runner /trees/filament/build/swiftshader/gallery.py
+    exit $?
+fi
+
+if [[ "$1" == "run" ]]; then
+    docker exec --tty  --workdir /trees/filament/results runner \
+          /usr/bin/catchsegv \
+          ../out/cmake-release/samples/gltf_viewer \
+          --headless \
+          --batch ../libs/viewer/tests/basic.json \
+          --api vulkan
+    docker exec runner /trees/filament/build/swiftshader/gallery.py
+    exit $?
+fi
+
+if [[ "$1" == "shell" ]]; then
+    docker exec --interactive --tty runner /bin/bash
+    exit $?
+fi
+
+# Notes on options being passed to docker's run command:
+#
+# - The memory constraint seems to prevent an OOM signal in GitHub Actions.
+# - The cap / security args allow use of lldb and creation of core dumps.
+# - The privileged arg allows use of dmesg for examining OOM logs.
+#
+# Currently, a GitHub Actions VM has 2 CPUs, 7 GB RAM, and 14 GB of SSD disk space.
+#
+# Please be aware that Docker Desktop might impose additional resource constraints, and that those
+# settings can only be controlled with its GUI. We recommend at least 7 GB of memory and 2 GB swap.
+if [[ "$1" == "start" ]]; then
+    mkdir -p results
+    docker run --tty --rm --detach --privileged \
+          --memory 6.5g \
+          --name runner \
+          --cap-add=SYS_PTRACE \
+          --security-opt seccomp=unconfined \
+          --security-opt apparmor=unconfined \
+          --volume `pwd`:/trees/filament \
+          --workdir /trees \
+          ssfilament
+    exit $?
+fi
+
+if [[ "$1" == "stop" ]]; then
+    docker container rm runner --force
+    exit $?
+fi
+
+print_help
+exit 1

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

docs/Materials.md.html

@@ -1397,7 +1397,7 @@ Type
 :    `string`
 
 Value
-:     Any of `opaque`, `transparent`, `fade`, `add`, `masked`, `multiply`, `screen`, `custom`. Defaults to `opaque`.
+:     Any of `opaque`, `transparent`, `fade`, `add`, `masked`, `multiply`, `screen`. Defaults to `opaque`.
 
 Description
 :     Defines how/if the rendered object is blended with the content of the render target.
@@ -1420,7 +1420,6 @@ Description
       of the material's output defines whether a fragment is discarded or not. Additionally,
       ALPHA_TO_COVERAGE is enabled for non-translucent views. See the maskThreshold section for more
       information.
-    - **Custom**: blending is enabled. But the blending function is user specified. See `blendFunction`.
 
 !!! Note
     When `blending` is set to `masked`, alpha to coverage is automatically enabled for the material.
@@ -1433,36 +1432,6 @@ material {
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-### Blending and transparency: blendFunction
-
-Type
-:    `object`
-
-Fields
-:     `srcRGB`, `srcA`, `dstRGB`, `dstA`
-
-Description
-:       - *srcRGB*: source function applied to the RGB channels
-        - *srcA*: source function applied to the alpha channel
-        - *srcRGB*: destination function applied to the RGB channels
-        - *srcRGB*: destination function applied to the alpha channel
-        The values possible for each functions are one of `zero`, `one`, `srcColor`, `oneMinusSrcColor`,
-               `dstColor`, `oneMinusDstColor`, `srcAlpha`, `oneMinusSrcAlpha`, `dstAlpha`,
-               `oneMinusDstAlpha`, `srcAlphaSaturate`
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JSON
-material {
-    blending : custom,
-    blendFunction :
-    {
-        srcRGB: one,
-        srcA: one,
-        dstRGB: oneMinusSrcColor,
-        dstA: oneMinusSrcAlpha
-    }
- }
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 ### Blending and transparency: postLightingBlending
 
 Type
@@ -2425,7 +2394,6 @@ The following APIs are only available from the vertex block:
 **getWorldFromModelMatrix()**        | float4x4 |  Matrix that converts from model (object) space to world space
 **getWorldFromModelNormalMatrix()**  | float3x3 |  Matrix that converts normals from model (object) space to world space
 **getVertexIndex()**                 | int      |  Index of the current vertex
-**getEyeIndex()**                    | int      |  Index of the eye being rendered, starting at 0
 
 ### Fragment only
 

docs/viewer/index.html

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

filament/CMakeLists.txt

@@ -163,7 +163,6 @@ set(PRIVATE_HDRS
         src/ResourceList.h
         src/ShadowMap.h
         src/ShadowMapManager.h
-        src/SharedHandle.h
         src/TypedUniformBuffer.h
         src/UniformBuffer.h
         src/components/CameraManager.h
@@ -215,7 +214,6 @@ 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,13 +66,11 @@ set(PRIVATE_HDRS
 # OpenGL / OpenGL ES Sources
 # ==================================================================================================
 
-if (FILAMENT_SUPPORTS_OPENGL AND NOT FILAMENT_USE_EXTERNAL_GLES3)
+if (FILAMENT_SUPPORTS_OPENGL AND NOT FILAMENT_USE_EXTERNAL_GLES3 AND NOT FILAMENT_USE_SWIFTSHADER)
     list(APPEND SRCS
             include/backend/platforms/OpenGLPlatform.h
             src/opengl/gl_headers.cpp
             src/opengl/gl_headers.h
-            src/opengl/GLBufferObject.h
-            src/opengl/GLTexture.h
             src/opengl/GLUtils.cpp
             src/opengl/GLUtils.h
             src/opengl/OpenGLBlobCache.cpp
@@ -168,10 +166,8 @@ endif()
 if (FILAMENT_SUPPORTS_VULKAN)
     list(APPEND SRCS
             include/backend/platforms/VulkanPlatform.h
-            src/vulkan/caching/VulkanDescriptorSetManager.cpp
-            src/vulkan/caching/VulkanDescriptorSetManager.h
-            src/vulkan/caching/VulkanPipelineLayoutCache.cpp
-            src/vulkan/caching/VulkanPipelineLayoutCache.h
+            src/vulkan/caching/VulkanDescriptorSet.cpp
+            src/vulkan/caching/VulkanDescriptorSet.h
             src/vulkan/platform/VulkanPlatform.cpp
             src/vulkan/platform/VulkanPlatformSwapChainImpl.cpp
             src/vulkan/platform/VulkanPlatformSwapChainImpl.h
@@ -417,9 +413,7 @@ if (APPLE OR LINUX)
         test/test_MissingRequiredAttributes.cpp
         test/test_ReadPixels.cpp
         test/test_BufferUpdates.cpp
-        test/test_Callbacks.cpp
         test/test_MRT.cpp
-        test/test_PushConstants.cpp
         test/test_LoadImage.cpp
         test/test_StencilBuffer.cpp
         test/test_Scissor.cpp
@@ -480,10 +474,6 @@ if (APPLE)
        # linker from removing "unused" symbols.
        target_link_libraries(backend_test_mac PRIVATE -force_load backend_test)
        set_target_properties(backend_test_mac PROPERTIES FOLDER Tests)
-
-       # This is needed after XCode 15.3
-       set_target_properties(backend_test_mac PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
-       set_target_properties(backend_test_mac PROPERTIES INSTALL_RPATH /usr/local/lib)
     endif()
 endif()
 

filament/backend/include/backend/DriverEnums.h

@@ -22,17 +22,14 @@
 #include <utils/BitmaskEnum.h>
 #include <utils/unwindows.h> // Because we define ERROR in the FenceStatus enum.
 
-#include <backend/Platform.h>
 #include <backend/PresentCallable.h>
 
-#include <utils/Invocable.h>
 #include <utils/ostream.h>
 
 #include <math/vec4.h>
 
 #include <array>        // FIXME: STL headers are not allowed in public headers
 #include <type_traits>  // FIXME: STL headers are not allowed in public headers
-#include <variant>      // FIXME: STL headers are not allowed in public headers
 
 #include <stddef.h>
 #include <stdint.h>
@@ -93,15 +90,12 @@ 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 {
@@ -118,7 +112,7 @@ static_assert(MAX_VERTEX_BUFFER_COUNT <= MAX_VERTEX_ATTRIBUTE_COUNT,
         "The number of buffer objects that can be attached to a VertexBuffer must be "
         "less than or equal to the maximum number of vertex attributes.");
 
-static constexpr size_t CONFIG_UNIFORM_BINDING_COUNT = 9;   // This is guaranteed by OpenGL ES.
+static constexpr size_t CONFIG_UNIFORM_BINDING_COUNT = 10;  // This is guaranteed by OpenGL ES.
 static constexpr size_t CONFIG_SAMPLER_BINDING_COUNT = 4;   // This is guaranteed by OpenGL ES.
 
 /**
@@ -164,16 +158,14 @@ static constexpr const char* backendToString(Backend backend) {
 }
 
 /**
- * Defines the shader language. Similar to the above backend enum, with some differences:
- * - The OpenGL backend can select between two shader languages: ESSL 1.0 and ESSL 3.0.
- * - The Metal backend can prefer precompiled Metal libraries, while falling back to MSL.
+ * Defines the shader language. Similar to the above backend enum, but the OpenGL backend can select
+ * between two shader languages: ESSL 1.0 and ESSL 3.0.
  */
 enum class ShaderLanguage {
     ESSL1 = 0,
     ESSL3 = 1,
     SPIRV = 2,
     MSL = 3,
-    METAL_LIBRARY = 4,
 };
 
 static constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguage) {
@@ -186,8 +178,6 @@ static constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguag
             return "SPIR-V";
         case ShaderLanguage::MSL:
             return "MSL";
-        case ShaderLanguage::METAL_LIBRARY:
-            return "Metal precompiled library";
     }
 }
 
@@ -337,7 +327,7 @@ enum class UniformType : uint8_t {
 /**
  * Supported constant parameter types
  */
-enum class ConstantType : uint8_t {
+ enum class ConstantType : uint8_t {
   INT,
   FLOAT,
   BOOL
@@ -692,7 +682,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 for protected content
+    PROTECTED           = 0x0100,            //!< Texture can be used the destination of a blit()
     DEFAULT             = UPLOADABLE | SAMPLEABLE   //!< Default texture usage
 };
 
@@ -1224,15 +1214,13 @@ struct StencilState {
     uint8_t padding = 0;
 };
 
-using PushConstantVariant = std::variant<int32_t, float, bool>;
-
 static_assert(sizeof(StencilState::StencilOperations) == 5u,
         "StencilOperations size not what was intended");
 
 static_assert(sizeof(StencilState) == 12u,
         "StencilState size not what was intended");
 
-using FrameScheduledCallback = utils::Invocable<void(backend::PresentCallable)>;
+using FrameScheduledCallback = void(*)(PresentCallable callable, void* user);
 
 enum class Workaround : uint16_t {
     // The EASU pass must split because shader compiler flattens early-exit branch
@@ -1249,9 +1237,18 @@ enum class Workaround : uint16_t {
     DISABLE_BLIT_INTO_TEXTURE_ARRAY,
     // Multiple workarounds needed for PowerVR GPUs
     POWER_VR_SHADER_WORKAROUNDS,
+    // The driver has some threads pinned, and we can't easily know on which core, it can hurt
+    // performance more if we end-up pinned on the same one.
+    DISABLE_THREAD_AFFINITY
 };
 
-using StereoscopicType = backend::Platform::StereoscopicType;
+//! The type of technique for stereoscopic rendering
+enum class StereoscopicType : uint8_t {
+    // Stereoscopic rendering is performed using instanced rendering technique.
+    INSTANCED,
+    // Stereoscopic rendering is performed using the multiview feature from the graphics backend.
+    MULTIVIEW,
+};
 
 } // namespace filament::backend
 

filament/backend/include/backend/Handle.h

@@ -75,19 +75,6 @@ protected:
     HandleBase(HandleBase const& rhs) noexcept = default;
     HandleBase& operator=(HandleBase const& rhs) noexcept = default;
 
-    HandleBase(HandleBase&& rhs) noexcept
-            : object(rhs.object) {
-        rhs.object = nullid;
-    }
-
-    HandleBase& operator=(HandleBase&& rhs) noexcept {
-        if (this != &rhs) {
-            object = rhs.object;
-            rhs.object = nullid;
-        }
-        return *this;
-    }
-
 private:
     HandleId object;
 };
@@ -102,10 +89,8 @@ 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,26 +41,6 @@ public:
     struct Fence {};
     struct Stream {};
 
-    /**
-     * The type of technique for stereoscopic rendering. (Note that the materials used will need to
-     * be compatible with the chosen technique.)
-     */
-    enum class StereoscopicType : uint8_t {
-        /**
-         * No stereoscopic rendering
-         */
-        NONE,
-        /**
-         * Stereoscopic rendering is performed using instanced rendering technique.
-         */
-        INSTANCED,
-        /**
-         * Stereoscopic rendering is performed using the multiview feature from the graphics
-         * backend.
-         */
-        MULTIVIEW,
-    };
-
     struct DriverConfig {
         /**
          * Size of handle arena in bytes. Setting to 0 indicates default value is to be used.
@@ -85,17 +65,6 @@ 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(nullptr, myFrameScheduledCallback);
+ * swapChain->setFrameScheduledCallback(myFrameScheduledCallback, nullptr);
  * if (renderer->beginFrame(swapChain)) {
  *     renderer->render(view);
  *     renderer->endFrame();
@@ -58,6 +58,8 @@ namespace filament::backend {
  * @remark Only Filament's Metal backend supports PresentCallables and frame callbacks. Other
  * backends ignore the callback (which will never be called) and proceed normally.
  *
+ * @remark The SwapChain::FrameScheduledCallback is called on an arbitrary thread.
+ *
  * Applications *must* call each PresentCallable they receive. Each PresentCallable represents a
  * frame that is waiting to be presented. If an application fails to call a PresentCallable, a
  * memory leak could occur. To "cancel" the presentation of a frame, pass false to the

filament/backend/include/backend/Program.h

@@ -84,9 +84,6 @@ public:
     // null terminating character.
     Program& shader(ShaderStage shader, void const* data, size_t size);
 
-    // sets the language of the shader sources provided with shader() (defaults to ESSL3)
-    Program& shaderLanguage(ShaderLanguage shaderLanguage);
-
     // Note: This is only needed for GLES3.0 backends, because the layout(binding=) syntax is
     //       not permitted in glsl. The backend needs a way to associate a uniform block
     //       to a binding point.
@@ -117,14 +114,6 @@ 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;
@@ -147,8 +136,6 @@ public:
     utils::CString const& getName() const noexcept { return mName; }
     utils::CString& getName() noexcept { return mName; }
 
-    auto const& getShaderLanguage() const { return mShaderLanguage; }
-
     utils::FixedCapacityVector<SpecializationConstant> const& getSpecializationConstants() const noexcept {
         return mSpecializationConstants;
     }
@@ -156,15 +143,6 @@ 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; }
@@ -177,12 +155,10 @@ 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,36 +29,17 @@ 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;
 };
 
@@ -83,7 +64,7 @@ public:
 
     MRT() noexcept = default;
 
-    MRT(TargetBufferInfo const& color) noexcept // NOLINT(hicpp-explicit-conversions, *-explicit-constructor)
+    MRT(TargetBufferInfo const& color) noexcept // NOLINT(hicpp-explicit-conversions)
             : mInfos{ color } {
     }
 
@@ -103,7 +84,7 @@ public:
 
     // this is here for backward compatibility
     MRT(Handle<HwTexture> handle, uint8_t level, uint16_t layer) noexcept
-            : mInfos{{ handle, level, layer, 0 }} {
+            : mInfos{{ handle, 0, level, layer }} {
     }
 };
 

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

@@ -140,23 +140,6 @@ 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
@@ -208,12 +191,6 @@ 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,10 +22,6 @@
 #include <backend/platforms/OpenGLPlatform.h>
 #include <backend/platforms/PlatformEGL.h>
 
-#include <utils/android/PerformanceHintManager.h>
-
-#include <chrono>
-
 #include <stddef.h>
 #include <stdint.h>
 
@@ -62,13 +58,6 @@ protected:
 
     void terminate() noexcept override;
 
-    void beginFrame(
-            int64_t monotonic_clock_ns,
-            int64_t refreshIntervalNs,
-            uint32_t frameId) noexcept override;
-
-    void preCommit() noexcept override;
-
     /**
      * Set the presentation time using `eglPresentationTimeANDROID`
      * @param presentationTimeInNanosecond
@@ -92,11 +81,6 @@ protected:
 private:
     int mOSVersion;
     ExternalStreamManagerAndroid& mExternalStreamManager;
-    utils::PerformanceHintManager mPerformanceHintManager;
-    utils::PerformanceHintManager::Session mPerformanceHintSession;
-
-    using clock = std::chrono::high_resolution_clock;
-    clock::time_point mStartTimeOfActualWork;
 };
 
 } // namespace filament::backend

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,14 +47,6 @@ struct VulkanPlatformPrivate;
 class VulkanPlatform : public Platform, utils::PrivateImplementation<VulkanPlatformPrivate> {
 public:
 
-    struct ExtensionHashFn {
-        std::size_t operator()(utils::CString const& s) const noexcept {
-            return std::hash<std::string>{}(s.data());
-        }
-    };
-    // Utility for managing device or instance extensions during initialization.
-    using ExtensionSet = std::unordered_set<utils::CString, ExtensionHashFn>;
-
     /**
      * A collection of handles to objects and metadata that comprises a Vulkan context. The client
      * can instantiate this struct and pass to Engine::Builder::sharedContext if they wishes to
@@ -200,13 +192,6 @@ public:
     virtual SwapChainPtr createSwapChain(void* nativeWindow, uint64_t flags = 0,
             VkExtent2D extent = {0, 0});
 
-    /**
-     * Allows implementers to provide instance extensions that they'd like to include in the
-     * instance creation.
-     * @return          A set of extensions to enable for the instance.
-     */
-    virtual ExtensionSet getRequiredInstanceExtensions() { return {}; }
-
     /**
      * Destroy the swapchain.
      * @param handle    The handle returned by createSwapChain()
@@ -251,9 +236,10 @@ public:
     VkQueue getGraphicsQueue() const noexcept;
 
 private:
-    static ExtensionSet getSwapchainInstanceExtensions();
-
     // Platform dependent helper methods
+    using ExtensionSet = std::unordered_set<std::string_view>;
+    static ExtensionSet getRequiredInstanceExtensions();
+
     using SurfaceBundle = std::tuple<VkSurfaceKHR, VkExtent2D>;
     static SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
             uint64_t flags) noexcept;

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

@@ -82,7 +82,6 @@ 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) {
+        static inline void execute(M&& method, D&& driver, CommandBase* base, intptr_t* next) noexcept {
             Command* self = static_cast<Command*>(base);
             *next = align(sizeof(Command));
 #if DEBUG_COMMAND_STREAM
@@ -168,7 +168,7 @@ struct CommandType<void (Driver::*)(ARGS...)> {
 
 class CustomCommand : public CommandBase {
     std::function<void()> mCommand;
-    static void execute(Driver&, CommandBase* base, intptr_t* next);
+    static void execute(Driver&, CommandBase* base, intptr_t* next) noexcept;
 public:
     inline CustomCommand(CustomCommand&& rhs) = default;
     inline explicit CustomCommand(std::function<void()> cmd)

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

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

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

@@ -65,7 +65,7 @@ public:
      *
      */
     template<typename D, typename ... ARGS>
-    Handle<D> allocateAndConstruct(ARGS&& ... args) {
+    Handle<D> allocateAndConstruct(ARGS&& ... args) noexcept {
         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) {
+    destroyAndConstruct(Handle<B> const& handle, ARGS&& ... args) noexcept {
         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) {
+    handle_cast(Handle<B>& handle) noexcept {
         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;
-                FILAMENT_CHECK_POSTCONDITION(expectedAge == age) <<
-                        "use-after-free of Handle with id=" << handle.getId();
+                ASSERT_POSTCONDITION(expectedAge == age,
+                        "use-after-free of Handle with id=%d", handle.getId());
             }
         }
 
@@ -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) {
+    handle_cast(Handle<B> const& handle) noexcept {
         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)) {
-                FILAMENT_CHECK_POSTCONDITION(expectedAge == age) <<
-                        "double-free of Handle of size " << size << " at " << p;
+                ASSERT_POSTCONDITION(expectedAge == age,
+                        "double-free of Handle of size %d at %p", size, p);
             }
             expectedAge = (expectedAge + 1) & 0xF; // fixme
 
@@ -317,7 +317,7 @@ private:
         return (id & HANDLE_HEAP_FLAG) == 0u;
     }
 
-    HandleBase::HandleId allocateHandleSlow(size_t size);
+    HandleBase::HandleId allocateHandleSlow(size_t size) noexcept;
     void deallocateHandleSlow(HandleBase::HandleId id, size_t size) noexcept;
 
     // We inline this because it's just 4 instructions in the fast case

filament/backend/src/Callable.cpp

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

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);
 
-        FILAMENT_CHECK_POSTCONDITION(data) <<
-                "couldn't allocate " << (size * 2 / 1024) <<
-                " KiB of virtual address space for the command buffer";
+        ASSERT_POSTCONDITION(data,
+                "couldn't allocate %u KiB of virtual address space for the command buffer",
+                (size * 2 / 1024));
 
         slog.d << "WARNING: Using soft CircularBuffer (" << (size * 2 / 1024) << " KiB)"
                << io::endl;

filament/backend/src/CommandBufferQueue.cpp

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

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) {
+void CustomCommand::execute(Driver&, CommandBase* base, intptr_t* next) noexcept {
     *next = CustomCommand::align(sizeof(CustomCommand));
     static_cast<CustomCommand*>(base)->mCommand();
     static_cast<CustomCommand*>(base)->~CustomCommand();

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

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

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,11 +47,6 @@ Program& Program::shader(ShaderStage shader, void const* data, size_t size) {
     return *this;
 }
 
-Program& Program::shaderLanguage(ShaderLanguage shaderLanguage) {
-    mShaderLanguage = shaderLanguage;
-    return *this;
-}
-
 Program& Program::uniformBlockBindings(
         FixedCapacityVector<std::pair<utils::CString, uint8_t>> const& uniformBlockBindings) noexcept {
     for (auto const& item : uniformBlockBindings) {
@@ -91,12 +86,6 @@ 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/metal/MetalBlitter.mm

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

filament/backend/src/metal/MetalBuffer.h

@@ -18,7 +18,6 @@
 #define TNT_FILAMENT_DRIVER_METALBUFFER_H
 
 #include "MetalContext.h"
-#include "MetalPlatform.h"
 
 #include <backend/DriverEnums.h>
 
@@ -29,88 +28,20 @@
 #include <utility>
 #include <memory>
 #include <atomic>
-#include <chrono>
 
 namespace filament::backend {
 
-class ScopedAllocationTimer {
-public:
-    ScopedAllocationTimer(const char* name) : mBeginning(clock_t::now()), mName(name) {}
-    ~ScopedAllocationTimer() {
-        using namespace std::literals::chrono_literals;
-        static constexpr std::chrono::seconds LONG_TIME_THRESHOLD = 10s;
-
-        auto end = clock_t::now();
-        std::chrono::duration<double, std::micro> allocationTimeMicroseconds = end - mBeginning;
-
-        if (UTILS_UNLIKELY(allocationTimeMicroseconds > LONG_TIME_THRESHOLD)) {
-            if (platform && platform->hasDebugUpdateStatFunc()) {
-                char buffer[64];
-                snprintf(buffer, sizeof(buffer), "filament.metal.long_buffer_allocation_time.%s",
-                        mName);
-                platform->debugUpdateStat(
-                        buffer, static_cast<uint64_t>(allocationTimeMicroseconds.count()));
-            }
-        }
-    }
-
-    static void setPlatform(MetalPlatform* p) { platform = p; }
-
-private:
-    typedef std::chrono::steady_clock clock_t;
-
-    static MetalPlatform* platform;
-
-    std::chrono::time_point<clock_t> mBeginning;
-    const char* mName;
-};
-
 class TrackedMetalBuffer {
 public:
-
-    static constexpr size_t EXCESS_BUFFER_COUNT = 30000;
-
-    enum class Type {
-        NONE = 0,
-        GENERIC = 1,
-        RING = 2,
-        STAGING = 3,
-    };
-    static constexpr size_t TypeCount = 3;
-
-    static constexpr auto toIndex(Type t) {
-        assert_invariant(t != Type::NONE);
-        switch (t) {
-            case Type::NONE:
-            case Type::GENERIC:
-                return 0;
-            case Type::RING:
-                return 1;
-            case Type::STAGING:
-                return 2;
-        }
-    }
-
     TrackedMetalBuffer() noexcept : mBuffer(nil) {}
-    TrackedMetalBuffer(nullptr_t) noexcept : mBuffer(nil) {}
-    TrackedMetalBuffer(id<MTLBuffer> buffer, Type type) : mBuffer(buffer), mType(type) {
-        assert_invariant(type != Type::NONE);
+    TrackedMetalBuffer(id<MTLBuffer> buffer) noexcept : mBuffer(buffer) {
         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());
-                }
-            }
+            aliveBuffers++;
         }
     }
-
     ~TrackedMetalBuffer() {
         if (mBuffer) {
-            assert_invariant(mType != Type::NONE);
-            aliveBuffers[toIndex(mType)]--;
+            aliveBuffers--;
         }
     }
 
@@ -126,31 +57,18 @@ public:
     id<MTLBuffer> get() const noexcept { return mBuffer; }
     operator bool() const noexcept { return bool(mBuffer); }
 
-    static uint64_t getAliveBuffers() {
-        uint64_t sum = 0;
-        for (const auto& v : aliveBuffers) {
-            sum += v;
-        }
-        return sum;
-    }
-
-    static uint64_t getAliveBuffers(Type type) {
-        assert_invariant(type != Type::NONE);
-        return aliveBuffers[toIndex(type)];
-    }
-    static void setPlatform(MetalPlatform* p) { platform = p; }
+    static uint64_t getAliveBuffers() { return aliveBuffers; }
 
 private:
     void swap(TrackedMetalBuffer& other) noexcept {
-        std::swap(mBuffer, other.mBuffer);
-        std::swap(mType, other.mType);
+        id<MTLBuffer> temp = mBuffer;
+        mBuffer = other.mBuffer;
+        other.mBuffer = temp;
     }
 
     id<MTLBuffer> mBuffer;
-    Type mType = Type::NONE;
 
-    static MetalPlatform* platform;
-    static std::array<uint64_t, TypeCount> aliveBuffers;
+    static std::atomic<uint64_t> aliveBuffers;
 };
 
 class MetalBuffer {
@@ -253,9 +171,7 @@ public:
           mBufferOptions(options),
           mSlotSizeBytes(computeSlotSize(layout)),
           mSlotCount(slotCount) {
-        ScopedAllocationTimer timer("ring");
-        mBuffer = { [device newBufferWithLength:mSlotSizeBytes * mSlotCount options:mBufferOptions],
-            TrackedMetalBuffer::Type::RING };
+        mBuffer = [device newBufferWithLength:mSlotSizeBytes * mSlotCount options:mBufferOptions];
         assert_invariant(mBuffer);
     }
 
@@ -273,13 +189,9 @@ public:
             // If we already have an aux buffer, it will get freed here, unless it has been retained
             // by a MTLCommandBuffer. In that case, it will be freed when the command buffer
             // finishes executing.
-            {
-                ScopedAllocationTimer timer("ring");
-                mAuxBuffer = { [mDevice newBufferWithLength:mSlotSizeBytes options:mBufferOptions],
-                    TrackedMetalBuffer::Type::RING };
-            }
+            mAuxBuffer = [mDevice newBufferWithLength:mSlotSizeBytes options:mBufferOptions];
             assert_invariant(mAuxBuffer);
-            return { mAuxBuffer.get(), 0 };
+            return {mAuxBuffer.get(), 0};
         }
         mCurrentSlot = (mCurrentSlot + 1) % mSlotCount;
         mOccupiedSlots->fetch_add(1, std::memory_order_relaxed);

filament/backend/src/metal/MetalBuffer.mm

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

filament/backend/src/metal/MetalBufferPool.mm

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

filament/backend/src/metal/MetalContext.h

@@ -55,18 +55,6 @@ struct MetalVertexBuffer;
 
 constexpr static uint8_t MAX_SAMPLE_COUNT = 8;  // Metal devices support at most 8 MSAA samples
 
-class MetalPushConstantBuffer {
-public:
-    void setPushConstant(PushConstantVariant value, uint8_t index);
-    bool isDirty() const { return mDirty; }
-    void setBytes(id<MTLCommandEncoder> encoder, ShaderStage stage);
-    void clear();
-
-private:
-    std::vector<PushConstantVariant> mPushConstants;
-    bool mDirty = false;
-};
-
 struct MetalContext {
     explicit MetalContext(size_t metalFreedTextureListSize)
         : texturesToDestroy(metalFreedTextureListSize) {}
@@ -121,8 +109,6 @@ struct MetalContext {
 
     PolygonOffset currentPolygonOffset = {0.0f, 0.0f};
 
-    std::array<MetalPushConstantBuffer, Program::SHADER_TYPE_COUNT> currentPushConstants;
-
     MetalSamplerGroup* samplerBindings[Program::SAMPLER_BINDING_COUNT] = {};
 
     // Keeps track of sampler groups we've finalized for the current render pass.

filament/backend/src/metal/MetalContext.mm

@@ -113,8 +113,7 @@ id<MTLCommandBuffer> getPendingCommandBuffer(MetalContext* context) {
             }
         }
     }];
-    FILAMENT_CHECK_POSTCONDITION(context->pendingCommandBuffer)
-            << "Could not obtain command buffer.";
+    ASSERT_POSTCONDITION(context->pendingCommandBuffer, "Could not obtain command buffer.");
     return context->pendingCommandBuffer;
 }
 
@@ -154,68 +153,5 @@ bool isInRenderPass(MetalContext* context) {
     return context->currentRenderPassEncoder != nil;
 }
 
-void MetalPushConstantBuffer::setPushConstant(PushConstantVariant value, uint8_t index) {
-    if (mPushConstants.size() <= index) {
-        mPushConstants.resize(index + 1);
-        mDirty = true;
-    }
-    if (UTILS_LIKELY(mPushConstants[index] != value)) {
-        mDirty = true;
-        mPushConstants[index] = value;
-    }
-}
-
-void MetalPushConstantBuffer::setBytes(id<MTLCommandEncoder> encoder, ShaderStage stage) {
-    constexpr size_t PUSH_CONSTANT_SIZE_BYTES = 4;
-    constexpr size_t PUSH_CONSTANT_BUFFER_INDEX = 26;
-
-    static char buffer[MAX_PUSH_CONSTANT_COUNT * PUSH_CONSTANT_SIZE_BYTES];
-    assert_invariant(mPushConstants.size() <= MAX_PUSH_CONSTANT_COUNT);
-
-    size_t bufferSize = PUSH_CONSTANT_SIZE_BYTES * mPushConstants.size();
-    for (size_t i = 0; i < mPushConstants.size(); i++) {
-        const auto& constant = mPushConstants[i];
-        std::visit(
-                [i](auto arg) {
-                    if constexpr (std::is_same_v<decltype(arg), bool>) {
-                        // bool push constants are converted to uints in MSL.
-                        // We must ensure we write all the bytes for boolean values to work
-                        // correctly.
-                        uint32_t boolAsUint = arg ? 0x00000001 : 0x00000000;
-                        *(reinterpret_cast<uint32_t*>(buffer + PUSH_CONSTANT_SIZE_BYTES * i)) =
-                                boolAsUint;
-                    } else {
-                        *(decltype(arg)*)(buffer + PUSH_CONSTANT_SIZE_BYTES * i) = arg;
-                    }
-                },
-                constant);
-    }
-
-    switch (stage) {
-        case ShaderStage::VERTEX:
-            [(id<MTLRenderCommandEncoder>)encoder setVertexBytes:buffer
-                                                          length:bufferSize
-                                                         atIndex:PUSH_CONSTANT_BUFFER_INDEX];
-            break;
-        case ShaderStage::FRAGMENT:
-            [(id<MTLRenderCommandEncoder>)encoder setFragmentBytes:buffer
-                                                            length:bufferSize
-                                                           atIndex:PUSH_CONSTANT_BUFFER_INDEX];
-            break;
-        case ShaderStage::COMPUTE:
-            [(id<MTLComputeCommandEncoder>)encoder setBytes:buffer
-                                                     length:bufferSize
-                                                    atIndex:PUSH_CONSTANT_BUFFER_INDEX];
-            break;
-    }
-
-    mDirty = false;
-}
-
-void MetalPushConstantBuffer::clear() {
-    mPushConstants.clear();
-    mDirty = false;
-}
-
 } // namespace backend
 } // namespace filament

filament/backend/src/metal/MetalDriver.h

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

filament/backend/src/metal/MetalDriver.mm

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

filament/backend/src/metal/MetalEnums.h

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

filament/backend/src/metal/MetalExternalImage.mm

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

filament/backend/src/metal/MetalHandles.h

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

filament/backend/src/metal/MetalHandles.mm

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

filament/backend/src/metal/MetalShaderCompiler.mm

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

filament/backend/src/metal/MetalState.h

@@ -43,8 +43,7 @@ inline bool operator==(const SamplerParams& lhs, const SamplerParams& rhs) {
 //   ------------------------------------------------------
 //   0           Zero buffer (placeholder vertex buffer)  1
 //   1-16        Filament vertex buffers                 16   limited by MAX_VERTEX_BUFFER_COUNT
-//   17-25       Uniform buffers                          9   Program::UNIFORM_BINDING_COUNT
-//   26          Push constants                           1
+//   17-26       Uniform buffers                         10   Program::UNIFORM_BINDING_COUNT
 //   27-30       Sampler groups (argument buffers)        4   Program::SAMPLER_BINDING_COUNT
 //
 //   Total                                               31
@@ -54,8 +53,7 @@ inline bool operator==(const SamplerParams& lhs, const SamplerParams& rhs) {
 //   Bindings    Buffer name                          Count
 //   ------------------------------------------------------
 //   0-3         SSBO buffers                             4   MAX_SSBO_COUNT
-//   17-25       Uniform buffers                          9   Program::UNIFORM_BINDING_COUNT
-//   26          Push constants                           1
+//   17-26       Uniform buffers                         10   Program::UNIFORM_BINDING_COUNT
 //   27-30       Sampler groups (argument buffers)        4   Program::SAMPLER_BINDING_COUNT
 //
 //   Total                                               18

filament/backend/src/metal/MetalState.mm

@@ -90,17 +90,11 @@ id<MTLRenderPipelineState> PipelineStateCreator::operator()(id<MTLDevice> device
     NSError* error = nullptr;
     id<MTLRenderPipelineState> pipeline = [device newRenderPipelineStateWithDescriptor:descriptor
                                                                                  error:&error];
-    if (UTILS_UNLIKELY(pipeline == nil)) {
-        NSString *errorMessage =
-            [NSString stringWithFormat:@"Could not create Metal pipeline state: %@",
-                error ? error.localizedDescription : @"unknown error"];
-        auto description = [errorMessage cStringUsingEncoding:NSUTF8StringEncoding];
+    if (error) {
+        auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
         utils::slog.e << description << utils::io::endl;
-        [[NSException exceptionWithName:@"MetalRenderPipelineFailure"
-                                 reason:errorMessage
-                               userInfo:nil] raise];
     }
-    FILAMENT_CHECK_POSTCONDITION(error == nil) << "Could not create Metal pipeline state.";
+    ASSERT_POSTCONDITION(error == nil, "Could not create Metal pipeline state.");
 
     return pipeline;
 }

filament/backend/src/noop/NoopDriver.cpp

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

filament/backend/src/opengl/GLBufferObject.h

@@ -1,51 +0,0 @@
-/*
- * Copyright (C) 2024 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TNT_FILAMENT_BACKEND_OPENGL_GLBUFFEROBJECT_H
-#define TNT_FILAMENT_BACKEND_OPENGL_GLBUFFEROBJECT_H
-
-#include "DriverBase.h"
-
-#include "gl_headers.h"
-
-#include <backend/DriverEnums.h>
-
-#include <stdint.h>
-
-namespace filament::backend {
-
-struct GLBufferObject : public HwBufferObject {
-    using HwBufferObject::HwBufferObject;
-    GLBufferObject(uint32_t size,
-            BufferObjectBinding bindingType, BufferUsage usage) noexcept
-            : HwBufferObject(size), usage(usage), bindingType(bindingType) {
-    }
-
-    struct {
-        GLuint id;
-        union {
-            GLenum binding;
-            void* buffer;
-        };
-    } gl;
-    BufferUsage usage;
-    BufferObjectBinding bindingType;
-    uint16_t age = 0;
-};
-
-} // namespace filament::backend
-
-#endif //TNT_FILAMENT_BACKEND_OPENGL_GLBUFFEROBJECT_H

filament/backend/src/opengl/GLTexture.h

@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2024 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TNT_FILAMENT_BACKEND_OPENGL_GLTEXTURE_H
-#define TNT_FILAMENT_BACKEND_OPENGL_GLTEXTURE_H
-
-#include "DriverBase.h"
-
-#include "gl_headers.h"
-
-#include <backend/platforms/OpenGLPlatform.h>
-
-#include <stdint.h>
-
-namespace filament::backend {
-
-struct GLTexture : public HwTexture {
-    using HwTexture::HwTexture;
-    struct GL {
-        GL() noexcept : imported(false), sidecarSamples(1), reserved1(0) {}
-        GLuint id = 0;          // texture or renderbuffer id
-        GLenum target = 0;
-        GLenum internalFormat = 0;
-        GLuint sidecarRenderBufferMS = 0;  // multi-sample sidecar renderbuffer
-
-        // texture parameters go here too
-        GLfloat anisotropy = 1.0;
-        int8_t baseLevel = 127;
-        int8_t maxLevel = -1;
-        uint8_t reserved0 = 0;
-        bool imported           : 1;
-        uint8_t sidecarSamples  : 4;
-        uint8_t reserved1       : 3;
-    } gl;
-
-    OpenGLPlatform::ExternalTexture* externalTexture = nullptr;
-};
-
-
-} // namespace filament::backend
-
-#endif //TNT_FILAMENT_BACKEND_OPENGL_GLTEXTURE_H

filament/backend/src/opengl/OpenGLContext.cpp

@@ -63,11 +63,8 @@ bool OpenGLContext::queryOpenGLVersion(GLint* major, GLint* minor) noexcept {
 #endif
 }
 
-OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
-        Platform::DriverConfig const& driverConfig) noexcept
-        : mPlatform(platform),
-          mSamplerMap(32),
-          mDriverConfig(driverConfig) {
+OpenGLContext::OpenGLContext(OpenGLPlatform& platform) noexcept
+        : mPlatform(platform) {
 
     state.vao.p = &mDefaultVAO;
 
@@ -87,13 +84,6 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
 
     queryOpenGLVersion(&state.major, &state.minor);
 
-    #if defined(BACKEND_OPENGL_VERSION_GLES)
-    if (UTILS_UNLIKELY(driverConfig.forceGLES2Context)) {
-        state.major = 2;
-        state.minor = 0;
-    }
-    #endif
-
     OpenGLContext::initExtensions(&ext, state.major, state.minor);
 
     OpenGLContext::initProcs(&procs, ext, state.major, state.minor);
@@ -262,23 +252,9 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
 }
 
 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) {
@@ -367,8 +343,7 @@ void OpenGLContext::setDefaultState() noexcept {
     }
 #endif
 
-    if (ext.EXT_clip_cull_distance
-            && mDriverConfig.stereoscopicType == StereoscopicType::INSTANCED) {
+    if (ext.EXT_clip_cull_distance) {
         glEnable(GL_CLIP_DISTANCE0);
         glEnable(GL_CLIP_DISTANCE1);
     }
@@ -541,6 +516,8 @@ void OpenGLContext::initBugs(Bugs* bugs, Extensions const& exts,
             bugs->delay_fbo_destruction = true;
             // PowerVR seems to have no problem with this (which is good for us)
             bugs->allow_read_only_ancillary_feedback_loop = true;
+            // PowerVR has a shader compiler thread pinned on the last core
+            bugs->disable_thread_affinity = true;
         } else if (strstr(renderer, "Apple")) {
             // Apple GPU
         } else if (strstr(renderer, "Tegra") ||
@@ -891,32 +868,19 @@ default_case:
     }
 }
 
-void OpenGLContext::unbindTexture(
-        UTILS_UNUSED_IN_RELEASE GLenum target, GLuint texture_id) noexcept {
+void OpenGLContext::unbindTexture(GLenum target, GLuint texture_id) noexcept {
     // unbind this texture from all the units it might be bound to
     // no need unbind the texture from FBOs because we're not tracking that state (and there is
     // no need to).
-    // Never attempt to unbind texture 0. This could happen with external textures w/ streaming if
-    // never populated.
-    if (texture_id) {
-        UTILS_NOUNROLL
-        for (GLuint unit = 0; unit < MAX_TEXTURE_UNIT_COUNT; unit++) {
-            if (state.textures.units[unit].id == texture_id) {
-                // if this texture is bound, it should be at the same target
-                assert_invariant(state.textures.units[unit].target == target);
-                unbindTextureUnit(unit);
-            }
+    const size_t index = getIndexForTextureTarget(target);
+    UTILS_NOUNROLL
+    for (GLuint unit = 0; unit < MAX_TEXTURE_UNIT_COUNT; unit++) {
+        if (state.textures.units[unit].targets[index].texture_id == texture_id) {
+            bindTexture(unit, target, (GLuint)0, index);
         }
     }
 }
 
-void OpenGLContext::unbindTextureUnit(GLuint unit) noexcept {
-    update_state(state.textures.units[unit].id, 0u, [&]() {
-        activeTexture(unit);
-        glBindTexture(state.textures.units[unit].target, 0u);
-    });
-}
-
 void OpenGLContext::unbindSampler(GLuint sampler) noexcept {
     // unbind this sampler from all the units it might be bound to
     UTILS_NOUNROLL  // clang generates >800B of code!!!
@@ -970,37 +934,6 @@ 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,8 +34,6 @@
 #include <math/vec2.h>
 #include <math/vec4.h>
 
-#include <tsl/robin_map.h>
-
 #include <array>
 #include <functional>
 #include <optional>
@@ -91,13 +89,9 @@ public:
 
     static bool queryOpenGLVersion(GLint* major, GLint* minor) noexcept;
 
-    explicit OpenGLContext(OpenGLPlatform& platform,
-            Platform::DriverConfig const& driverConfig) noexcept;
-
+    explicit OpenGLContext(OpenGLPlatform& platform) noexcept;
     ~OpenGLContext() noexcept final;
 
-    void terminate() noexcept;
-
     // TimerQueryInterface ------------------------------------------------------------------------
 
     // note: OpenGLContext being final ensures (clang) these are not called through the vtable
@@ -138,6 +132,7 @@ public:
 #endif
     }
 
+    constexpr static inline size_t getIndexForTextureTarget(GLuint target) noexcept;
     constexpr        inline size_t getIndexForCap(GLenum cap) noexcept;
     constexpr static inline size_t getIndexForBufferTarget(GLenum target) noexcept;
 
@@ -149,10 +144,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;
@@ -311,6 +306,10 @@ public:
         // a glFinish. So we must delay the destruction until we know the GPU is finished.
         bool delay_fbo_destruction;
 
+        // The driver has some threads pinned, and we can't easily know on which core, it can hurt
+        // performance more if we end-up pinned on the same one.
+        bool disable_thread_affinity;
+
         // Force feature level 0. Typically used for low end ES3 devices with significant driver
         // bugs or performance issues.
         bool force_feature_level0;
@@ -322,14 +321,8 @@ public:
 
     // function to handle state changes we don't control
     void updateTexImage(GLenum target, GLuint id) noexcept {
-        assert_invariant(target == GL_TEXTURE_EXTERNAL_OES);
-        // if another target is bound to this texture unit, unbind that texture
-        if (UTILS_UNLIKELY(state.textures.units[state.textures.active].target != target)) {
-            glBindTexture(state.textures.units[state.textures.active].target, 0);
-            state.textures.units[state.textures.active].target = GL_TEXTURE_EXTERNAL_OES;
-        }
-        // the texture is already bound to `target`, we just update our internal state
-        state.textures.units[state.textures.active].id = id;
+        const size_t index = getIndexForTextureTarget(target);
+        state.textures.units[state.textures.active].targets[index].texture_id = id;
     }
     void resetProgram() noexcept { state.program.use = 0; }
 
@@ -432,8 +425,9 @@ public:
             GLuint active = 0;      // zero-based
             struct {
                 GLuint sampler = 0;
-                GLuint target = 0;
-                GLuint id = 0;
+                struct {
+                    GLuint texture_id = 0;
+                } targets[7];  // this must match getIndexForTextureTarget()
             } units[MAX_TEXTURE_UNIT_COUNT];
         } textures;
 
@@ -473,29 +467,6 @@ 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;
@@ -505,13 +476,6 @@ 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;
 
@@ -558,6 +522,9 @@ private:
             {   bugs.delay_fbo_destruction,
                     "delay_fbo_destruction",
                     ""},
+            {   bugs.disable_thread_affinity,
+                    "disable_thread_affinity",
+                    ""},
             {   bugs.force_feature_level0,
                     "force_feature_level0",
                     ""},
@@ -605,10 +572,31 @@ private:
     }
 
     void setDefaultState() noexcept;
+
+    static constexpr const size_t TEXTURE_TARGET_COUNT =
+            sizeof(state.textures.units[0].targets) / sizeof(state.textures.units[0].targets[0]);
+
 };
 
 // ------------------------------------------------------------------------------------------------
 
+constexpr size_t OpenGLContext::getIndexForTextureTarget(GLuint target) noexcept {
+    // this must match state.textures[].targets[]
+    switch (target) {
+        case GL_TEXTURE_2D:                     return 0;
+        case GL_TEXTURE_2D_ARRAY:               return 1;
+        case GL_TEXTURE_CUBE_MAP:               return 2;
+#if defined(BACKEND_OPENGL_LEVEL_GLES31)
+        case GL_TEXTURE_2D_MULTISAMPLE:         return 3;
+#endif
+        case GL_TEXTURE_EXTERNAL_OES:           return 4;
+        case GL_TEXTURE_3D:                     return 5;
+        case GL_TEXTURE_CUBE_MAP_ARRAY:         return 6;
+        default:
+            return 0;
+    }
+}
+
 constexpr size_t OpenGLContext::getIndexForCap(GLenum cap) noexcept { //NOLINT
     size_t index = 0;
     switch (cap) {
@@ -756,17 +744,19 @@ void OpenGLContext::bindBufferRange(GLenum target, GLuint index, GLuint buffer,
 #endif
 }
 
-void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId) noexcept {
-    update_state(state.textures.units[unit].target, target, [&]() {
-        activeTexture(unit);
-        glBindTexture(state.textures.units[unit].target, 0);
-    });
-    update_state(state.textures.units[unit].id, texId, [&]() {
+void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId, size_t targetIndex) noexcept {
+    assert_invariant(targetIndex == getIndexForTextureTarget(target));
+    assert_invariant(targetIndex < TEXTURE_TARGET_COUNT);
+    update_state(state.textures.units[unit].targets[targetIndex].texture_id, texId, [&]() {
         activeTexture(unit);
         glBindTexture(target, texId);
     }, target == GL_TEXTURE_EXTERNAL_OES);
 }
 
+void OpenGLContext::bindTexture(GLuint unit, GLuint target, GLuint texId) noexcept {
+    bindTexture(unit, target, texId, getIndexForTextureTarget(target));
+}
+
 void OpenGLContext::useProgram(GLuint program) noexcept {
     update_state(state.program.use, program, [&]() {
         glUseProgram(program);

filament/backend/src/opengl/OpenGLDriver.cpp

@@ -173,10 +173,6 @@ 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))) {
@@ -207,13 +203,13 @@ OpenGLDriver::DebugMarker::~DebugMarker() noexcept {
 
 OpenGLDriver::OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfig& driverConfig) noexcept
         : mPlatform(*platform),
-          mContext(mPlatform, driverConfig),
+          mContext(mPlatform),
           mShaderCompilerService(*this),
           mHandleAllocator("Handles",
                   driverConfig.handleArenaSize,
                   driverConfig.disableHandleUseAfterFreeCheck),
-          mDriverConfig(driverConfig),
-          mCurrentPushConstants(new(std::nothrow) PushConstantBundle{}) {
+          mSamplerMap(32),
+          mDriverConfig(driverConfig) {
 
     std::fill(mSamplerBindings.begin(), mSamplerBindings.end(), nullptr);
 
@@ -237,19 +233,10 @@ 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 {
-    auto dispatcher = ConcreteDispatcher<OpenGLDriver>::make();
-    if (mContext.isES2()) {
-        dispatcher.draw2_ = +[](Driver& driver, CommandBase* base, intptr_t* next){
-            using Cmd = COMMAND_TYPE(draw2);
-            OpenGLDriver& concreteDriver = static_cast<OpenGLDriver&>(driver);
-            Cmd::execute(&OpenGLDriver::draw2GLES2, concreteDriver, base, next);
-        };
-    }
-    return dispatcher;
+    return ConcreteDispatcher<OpenGLDriver>::make();
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -276,13 +263,16 @@ 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();
 }
 
@@ -301,42 +291,9 @@ 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);
+    mContext.bindTexture(unit, t->gl.target, t->gl.id, t->gl.targetIndex);
 }
 
 bool OpenGLDriver::useProgram(OpenGLProgram* p) noexcept {
@@ -350,7 +307,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] = mContext.getEs2UniformBinding(i);
+            auto [id, buffer, age] = mUniformBindings[i];
             if (buffer) {
                 p->updateUniforms(i, id, buffer, age);
             }
@@ -767,19 +724,10 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
     GLenum internalFormat = getInternalFormat(format);
     assert_invariant(internalFormat);
 
-    if (any(usage & TextureUsage::PROTECTED)) {
+    if (UTILS_UNLIKELY(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;
@@ -798,6 +746,7 @@ 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;
@@ -809,23 +758,30 @@ 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;
             }
 
@@ -836,6 +792,8 @@ 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.
                 }
@@ -845,6 +803,13 @@ 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);
@@ -894,24 +859,32 @@ 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;
     }
 
@@ -922,6 +895,7 @@ 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.
         }
@@ -932,18 +906,16 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
 }
 
 void OpenGLDriver::updateVertexArrayObject(GLRenderPrimitive* rp, GLVertexBuffer const* vb) {
-    // NOTE: this is called often and must be as efficient as possible.
+    // NOTE: this is called from draw() and must be as efficient as possible.
 
     auto& gl = mContext;
 
-#ifndef NDEBUG
     if (UTILS_LIKELY(gl.ext.OES_vertex_array_object)) {
         // The VAO for the given render primitive must already be bound.
         GLint vaoBinding;
         glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &vaoBinding);
         assert_invariant(vaoBinding == (GLint)rp->gl.vao[gl.contextIndex]);
     }
-#endif
 
     if (UTILS_LIKELY(rp->gl.vertexBufferVersion == vb->bufferObjectsVersion &&
                      rp->gl.stateVersion == gl.state.age)) {
@@ -959,7 +931,7 @@ void OpenGLDriver::updateVertexArrayObject(GLRenderPrimitive* rp, GLVertexBuffer
             // if a buffer is defined it must not be invalid.
             assert_invariant(vb->gl.buffers[bi]);
 
-            // if we're on ES2, the user shouldn't use FLAG_INTEGER_TARGET
+            // if w're on ES2, the user shouldn't use FLAG_INTEGER_TARGET
             assert_invariant(!(gl.isES2() && (attribute.flags & Attribute::FLAG_INTEGER_TARGET)));
 
             gl.bindBuffer(GL_ARRAY_BUFFER, vb->gl.buffers[bi]);
@@ -1494,8 +1466,9 @@ void OpenGLDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
 
 #if !defined(__EMSCRIPTEN__)
     // note: in practice this should never happen on Android
-    FILAMENT_CHECK_POSTCONDITION(sc->swapChain) << "createSwapChain(" << nativeWindow << ", "
-                                                << flags << ") failed. See logs for details.";
+    ASSERT_POSTCONDITION(sc->swapChain,
+            "createSwapChain(%p, 0x%lx) failed. See logs for details.",
+            nativeWindow, flags);
 #endif
 
     // See if we need the emulated rec709 output conversion
@@ -1514,9 +1487,9 @@ void OpenGLDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch,
 
 #if !defined(__EMSCRIPTEN__)
     // note: in practice this should never happen on Android
-    FILAMENT_CHECK_POSTCONDITION(sc->swapChain)
-            << "createSwapChainHeadless(" << width << ", " << height << ", " << flags
-            << ") failed. See logs for details.";
+    ASSERT_POSTCONDITION(sc->swapChain,
+            "createSwapChainHeadless(%u, %u, 0x%lx) failed. See logs for details.",
+            width, height, flags);
 #endif
 
     // See if we need the emulated rec709 output conversion
@@ -1812,6 +1785,7 @@ 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);
                     }
                 }
@@ -2049,19 +2023,19 @@ bool OpenGLDriver::isProtectedContentSupported() {
     return mPlatform.isProtectedContextSupported();
 }
 
-bool OpenGLDriver::isStereoSupported() {
+bool OpenGLDriver::isStereoSupported(backend::StereoscopicType stereoscopicType) {
     // Instanced-stereo requires instancing and EXT_clip_cull_distance.
     // Multiview-stereo requires ES 3.0 and OVR_multiview2.
     if (UTILS_UNLIKELY(mContext.isES2())) {
         return false;
     }
-    switch (mDriverConfig.stereoscopicType) {
-        case backend::StereoscopicType::INSTANCED:
-            return mContext.ext.EXT_clip_cull_distance;
-        case backend::StereoscopicType::MULTIVIEW:
-            return mContext.ext.OVR_multiview2;
-        case backend::StereoscopicType::NONE:
-            return false;
+    switch (stereoscopicType) {
+    case backend::StereoscopicType::INSTANCED:
+        return mContext.ext.EXT_clip_cull_distance;
+    case backend::StereoscopicType::MULTIVIEW:
+        return mContext.ext.OVR_multiview2;
+    default:
+        return false;
     }
 }
 
@@ -2073,10 +2047,6 @@ bool OpenGLDriver::isDepthStencilResolveSupported() {
     return true;
 }
 
-bool OpenGLDriver::isDepthStencilBlitSupported(TextureFormat format) {
-    return true;
-}
-
 bool OpenGLDriver::isProtectedTexturesSupported() {
     return getContext().ext.EXT_protected_textures;
 }
@@ -2093,6 +2063,8 @@ 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;
     }
@@ -2371,7 +2343,7 @@ void OpenGLDriver::updateSamplerGroup(Handle<HwSamplerGroup> sbh,
 #endif
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
             if (UTILS_LIKELY(!es2)) {
-                samplerId = mContext.getSampler(params);
+                samplerId = getSampler(params);
             } else
 #endif
             {
@@ -2701,6 +2673,7 @@ 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);
     }
 }
@@ -3095,10 +3068,11 @@ void OpenGLDriver::bindBufferRange(BufferObjectBinding bindingType, uint32_t ind
     assert_invariant(offset + size <= ub->byteCount);
 
     if (UTILS_UNLIKELY(ub->bindingType == BufferObjectBinding::UNIFORM && gl.isES2())) {
-        gl.setEs2UniformBinding(index,
+        mUniformBindings[index] = {
                 ub->gl.id,
                 static_cast<uint8_t const*>(ub->gl.buffer) + offset,
-                ub->age);
+                ub->age,
+        };
     } else {
         GLenum const target = GLUtils::getBufferBindingType(bindingType);
 
@@ -3116,7 +3090,7 @@ void OpenGLDriver::unbindBuffer(BufferObjectBinding bindingType, uint32_t index)
     auto& gl = mContext;
 
     if (UTILS_UNLIKELY(bindingType == BufferObjectBinding::UNIFORM && gl.isES2())) {
-        gl.setEs2UniformBinding(index, 0, nullptr, 0);
+        mUniformBindings[index] = {};
         return;
     }
 
@@ -3133,6 +3107,36 @@ 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
@@ -3432,21 +3436,17 @@ 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 OpenGLPlatform::updateTexImage() binds the texture on our behalf
+                // NOTE: We assume that 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,
-        CallbackHandler* handler, FrameScheduledCallback&& callback) {
+        FrameScheduledCallback callback, void* user) {
     DEBUG_MARKER()
 }
 
 void OpenGLDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
+        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
     DEBUG_MARKER()
 }
 
@@ -3494,7 +3494,6 @@ void OpenGLDriver::endFrame(UTILS_UNUSED uint32_t frameId) {
 #endif
     //SYSTRACE_NAME("glFinish");
     //glFinish();
-    mPlatform.endFrame(frameId);
     insertEventMarker("endFrame");
 }
 
@@ -3605,11 +3604,13 @@ void OpenGLDriver::resolve(
     assert_invariant(s);
     assert_invariant(d);
 
-    FILAMENT_CHECK_PRECONDITION(d->width == s->width && d->height == s->height)
-            << "invalid resolve: src and dst sizes don't match";
+    ASSERT_PRECONDITION(
+            d->width == s->width && d->height == s->height,
+            "invalid resolve: src and dst sizes don't match");
 
-    FILAMENT_CHECK_PRECONDITION(s->samples > 1 && d->samples == 1)
-            << "invalid resolve: src.samples=" << +s->samples << ", dst.samples=" << +d->samples;
+    ASSERT_PRECONDITION(s->samples > 1 && d->samples == 1,
+            "invalid resolve: src.samples=%u, dst.samples=%u",
+            +s->samples, +d->samples);
 
     blit(   dst, dstLevel, dstLayer, {},
             src, srcLevel, srcLayer, {},
@@ -3704,7 +3705,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.bindFramebuffer(GL_READ_FRAMEBUFFER, fbo[1]);
     switch (s->target) {
@@ -3730,7 +3731,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.disable(GL_SCISSOR_TEST);
     glBlitFramebuffer(
@@ -3765,12 +3766,12 @@ void OpenGLDriver::blitDEPRECATED(TargetBufferFlags buffers,
     UTILS_UNUSED_IN_RELEASE auto& gl = mContext;
     assert_invariant(!gl.isES2());
 
-    FILAMENT_CHECK_PRECONDITION(buffers == TargetBufferFlags::COLOR0)
-            << "blitDEPRECATED only supports COLOR0";
+    ASSERT_PRECONDITION(buffers == TargetBufferFlags::COLOR0,
+            "blitDEPRECATED only supports COLOR0");
 
-    FILAMENT_CHECK_PRECONDITION(
-            srcRect.left >= 0 && srcRect.bottom >= 0 && dstRect.left >= 0 && dstRect.bottom >= 0)
-            << "Source and destination rects must be positive.";
+    ASSERT_PRECONDITION(srcRect.left >= 0 && srcRect.bottom >= 0 &&
+                        dstRect.left >= 0 && dstRect.bottom >= 0,
+            "Source and destination rects must be positive.");
 
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
 
@@ -3844,7 +3845,7 @@ void OpenGLDriver::updateTextureLodRange(GLTexture* texture, int8_t targetLevel)
 #endif
 }
 
-void OpenGLDriver::bindPipeline(PipelineState const& state) {
+void OpenGLDriver::bindPipeline(PipelineState state) {
     DEBUG_MARKER()
     auto& gl = mContext;
     setRasterState(state.rasterState);
@@ -3852,7 +3853,6 @@ void OpenGLDriver::bindPipeline(PipelineState const& 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,35 +3882,20 @@ void OpenGLDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
         return;
     }
 
+    if (UTILS_LIKELY(instanceCount <= 1)) {
+        glDrawElements(GLenum(rp->type), (GLsizei)indexCount, rp->gl.getIndicesType(),
+                reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize));
+    } else {
+        assert_invariant(!mContext.isES2());
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
-    assert_invariant(!mContext.isES2());
-    glDrawElementsInstanced(GLenum(rp->type), (GLsizei)indexCount,
-            rp->gl.getIndicesType(),
-            reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize),
-            (GLsizei)instanceCount);
+        glDrawElementsInstanced(GLenum(rp->type), (GLsizei)indexCount,
+                rp->gl.getIndicesType(),
+                reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize),
+                (GLsizei)instanceCount);
 #endif
-
-#if FILAMENT_ENABLE_MATDBG
-    CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
-#else
-    CHECK_GL_ERROR(utils::slog.e)
-#endif
-}
-
-void OpenGLDriver::draw2GLES2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
-    GLRenderPrimitive const* const rp = mBoundRenderPrimitive;
-    if (UTILS_UNLIKELY(!rp || !mValidProgram)) {
-        return;
     }
 
-    assert_invariant(mContext.isES2());
-    assert_invariant(instanceCount == 1);
-
-    glDrawElements(GLenum(rp->type), (GLsizei)indexCount, rp->gl.getIndicesType(),
-            reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize));
-
-
-#if FILAMENT_ENABLE_MATDBG
+#ifdef FILAMENT_ENABLE_MATDBG
     CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
 #else
     CHECK_GL_ERROR(utils::slog.e)
@@ -3929,11 +3914,7 @@ void OpenGLDriver::draw(PipelineState state, Handle<HwRenderPrimitive> rph,
     state.vertexBufferInfo = rp->vbih;
     bindPipeline(state);
     bindRenderPrimitive(rph);
-    if (UTILS_UNLIKELY(mContext.isES2())) {
-        draw2GLES2(indexOffset, indexCount, instanceCount);
-    } else {
-        draw2(indexOffset, indexCount, instanceCount);
-    }
+    draw2(indexOffset, indexCount, instanceCount);
 }
 
 void OpenGLDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGroupCount) {
@@ -3960,7 +3941,7 @@ void OpenGLDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGr
     glDispatchCompute(workGroupCount.x, workGroupCount.y, workGroupCount.z);
 #endif // BACKEND_OPENGL_LEVEL_GLES31
 
-#if FILAMENT_ENABLE_MATDBG
+#ifdef FILAMENT_ENABLE_MATDBG
     CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
 #else
     CHECK_GL_ERROR(utils::slog.e)

filament/backend/src/opengl/OpenGLDriver.h

@@ -20,8 +20,6 @@
 #include "DriverBase.h"
 #include "OpenGLContext.h"
 #include "OpenGLTimerQuery.h"
-#include "GLBufferObject.h"
-#include "GLTexture.h"
 #include "ShaderCompilerService.h"
 
 #include <backend/platforms/OpenGLPlatform.h>
@@ -66,9 +64,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,
@@ -94,6 +92,25 @@ 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,
@@ -123,6 +140,7 @@ public:
         } gl;
     };
 
+    struct GLTexture;
     struct GLSamplerGroup : public HwSamplerGroup {
         using HwSamplerGroup::HwSamplerGroup;
         struct Entry {
@@ -139,9 +157,27 @@ public:
         Handle<HwVertexBufferInfo> vbih;
     };
 
-    using GLBufferObject = filament::backend::GLBufferObject;
+    struct GLTexture : public HwTexture {
+        using HwTexture::HwTexture;
+        struct GL {
+            GL() noexcept : imported(false), sidecarSamples(1), reserved(0) {}
+            GLuint id = 0;          // texture or renderbuffer id
+            GLenum target = 0;
+            GLenum internalFormat = 0;
+            GLuint sidecarRenderBufferMS = 0;  // multi-sample sidecar renderbuffer
 
-    using GLTexture = filament::backend::GLTexture;
+            // texture parameters go here too
+            GLfloat anisotropy = 1.0;
+            int8_t baseLevel = 127;
+            int8_t maxLevel = -1;
+            uint8_t targetIndex = 0;    // optimization: index corresponding to target
+            bool imported           : 1;
+            uint8_t sidecarSamples  : 4;
+            uint8_t reserved        : 3;
+        } gl;
+
+        OpenGLPlatform::ExternalTexture* externalTexture = nullptr;
+    };
 
     using GLTimerQuery = filament::backend::GLTimerQuery;
 
@@ -232,13 +268,13 @@ private:
     HandleAllocatorGL mHandleAllocator;
 
     template<typename D, typename ... ARGS>
-    Handle<D> initHandle(ARGS&& ... args) {
+    Handle<D> initHandle(ARGS&& ... args) noexcept {
         return mHandleAllocator.allocateAndConstruct<D>(std::forward<ARGS>(args) ...);
     }
 
     template<typename D, typename B, typename ... ARGS>
     typename std::enable_if<std::is_base_of<B, D>::value, D>::type*
-    construct(Handle<B> const& handle, ARGS&& ... args) {
+    construct(Handle<B> const& handle, ARGS&& ... args) noexcept {
         return mHandleAllocator.destroyAndConstruct<D, B>(handle, std::forward<ARGS>(args) ...);
     }
 
@@ -252,7 +288,7 @@ private:
     typename std::enable_if_t<
             std::is_pointer_v<Dp> &&
             std::is_base_of_v<B, typename std::remove_pointer_t<Dp>>, Dp>
-    handle_cast(Handle<B>& handle) {
+    handle_cast(Handle<B>& handle) noexcept {
         return mHandleAllocator.handle_cast<Dp, B>(handle);
     }
 
@@ -260,7 +296,7 @@ private:
     inline typename std::enable_if_t<
             std::is_pointer_v<Dp> &&
             std::is_base_of_v<B, typename std::remove_pointer_t<Dp>>, Dp>
-    handle_cast(Handle<B> const& handle) {
+    handle_cast(Handle<B> const& handle) noexcept {
         return mHandleAllocator.handle_cast<Dp, B>(handle);
     }
 
@@ -312,6 +348,22 @@ 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;
     }
@@ -336,14 +388,16 @@ 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;
 
@@ -377,8 +431,6 @@ private:
     // for ES2 sRGB support
     GLSwapChain* mCurrentDrawSwapChain = nullptr;
     bool mRec709OutputColorspace = false;
-
-    PushConstantBundle* mCurrentPushConstants = nullptr;
 };
 
 // ------------------------------------------------------------------------------------------------

filament/backend/src/opengl/OpenGLPlatform.cpp

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

filament/backend/src/opengl/OpenGLProgram.h

@@ -27,7 +27,6 @@
 
 #include <utils/compiler.h>
 #include <utils/FixedCapacityVector.h>
-#include <utils/Slice.h>
 
 #include <array>
 #include <limits>
@@ -39,11 +38,6 @@ namespace filament::backend {
 
 class OpenGLDriver;
 
-struct PushConstantBundle {
-    utils::Slice<std::pair<GLint, ConstantType>> vertexConstants;
-    utils::Slice<std::pair<GLint, ConstantType>> fragmentConstants;
-};
-
 class OpenGLProgram : public HwProgram {
 public:
 
@@ -76,22 +70,14 @@ public:
         }
     }
 
+    struct {
+        GLuint program = 0;
+    } gl; // 12 bytes
+
     // For ES2 only
     void updateUniforms(uint32_t index, GLuint id, void const* buffer, uint16_t age) noexcept;
     void setRec709ColorSpace(bool rec709) const noexcept;
 
-    struct {
-        GLuint program = 0;
-    } gl;                                               // 4 bytes
-
-    PushConstantBundle getPushConstants() {
-        auto fragBegin = mPushConstants.begin() + mPushConstantFragmentStageOffset;
-        return {
-            .vertexConstants = utils::Slice(mPushConstants.begin(), fragBegin),
-            .fragmentConstants = utils::Slice(fragBegin, mPushConstants.end()),
-        };
-    }
-
 private:
     // keep these away from of other class attributes
     struct LazyInitializationData;
@@ -103,20 +89,14 @@ private:
 
     void updateSamplers(OpenGLDriver* gld) const noexcept;
 
+    ShaderCompilerService::program_token_t mToken{};
+
     // number of bindings actually used by this program
+    uint8_t mUsedBindingsCount = 0u;
+    UTILS_UNUSED uint8_t padding[3] = {};
     std::array<uint8_t, Program::SAMPLER_BINDING_COUNT> mUsedSamplerBindingPoints;   // 4 bytes
 
-    ShaderCompilerService::program_token_t mToken{};    // 16 bytes
-
-    uint8_t mUsedBindingsCount = 0u;                    // 1 byte
-    UTILS_UNUSED uint8_t padding[2] = {};               // 2 byte
-
-    // Push constant array offset for fragment stage constants.
-    uint8_t mPushConstantFragmentStageOffset = 0u;      // 1 byte
-
     // only needed for ES2
-    GLint mRec709Location = -1;                         // 4 bytes
-
     using LocationInfo = utils::FixedCapacityVector<GLint>;
     struct UniformsRecord {
         Program::UniformInfo uniforms;
@@ -124,15 +104,12 @@ private:
         mutable GLuint id = 0;
         mutable uint16_t age = std::numeric_limits<uint16_t>::max();
     };
-    UniformsRecord const* mUniformsRecords = nullptr;               // 8 bytes
-
-    // Note that this can be replaced with a raw pointer and an uint8_t (for size) to reduce the
-    // size of the container to 9 bytes if there is a need in the future.
-    utils::FixedCapacityVector<std::pair<GLint, ConstantType>> mPushConstants;// 16 bytes
+    UniformsRecord const* mUniformsRecords = nullptr;
+    GLint mRec709Location = -1;
 };
 
 // if OpenGLProgram is larger tha 64 bytes, it'll fall in a larger Handle bucket.
-static_assert(sizeof(OpenGLProgram) <= 64); // currently 64 bytes
+static_assert(sizeof(OpenGLProgram) <= 64);
 
 } // namespace filament::backend
 

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

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

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

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

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();
-    FILAMENT_CHECK_POSTCONDITION(!result) << "Unable to load OpenGL entry points.";
+    ASSERT_POSTCONDITION(!result, "Unable to load OpenGL entry points.");
 
     UTILS_UNUSED_IN_RELEASE CVReturn success = CVOpenGLTextureCacheCreate(kCFAllocatorDefault, nullptr,
             [pImpl->mGLContext CGLContextObj], [pImpl->mGLContext.pixelFormat CGLPixelFormatObj], nullptr,

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

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

@@ -174,7 +174,7 @@ Driver* PlatformEGL::createDriver(void* sharedContext, const Platform::DriverCon
     };
 
 #ifdef __ANDROID__
-    bool requestES2Context = driverConfig.forceGLES2Context;
+    bool requestES2Context = false;
     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

@@ -25,8 +25,6 @@
 #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>
@@ -38,11 +36,8 @@
 
 #include <jni.h>
 
-#include <chrono>
 #include <new>
 
-#include <unistd.h>
-
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -117,38 +112,8 @@ 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();
-    FILAMENT_CHECK_POSTCONDITION(!result) << "Unable to load OpenGL entry points.";
+    ASSERT_POSTCONDITION(!result, "Unable to load OpenGL entry points.");
 
     return OpenGLPlatform::createDefaultDriver(this, sharedGLContext, driverConfig);
 }

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

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

filament/backend/src/ostream.cpp

@@ -410,7 +410,6 @@ 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 << "}";
 }

filament/backend/src/vulkan/VulkanBlitter.cpp

@@ -26,16 +26,21 @@
 
 #include <smolv.h>
 
+#include "generated/vkshaders/vkshaders.h"
+
 using namespace bluevk;
 using namespace utils;
 
 namespace filament::backend {
 
+using ImgUtil = VulkanImageUtility;
+
 namespace {
 
 inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect, VkFilter filter,
         VulkanAttachment src, VulkanAttachment dst,
         const VkOffset3D srcRect[2], const VkOffset3D dstRect[2]) {
+
     if constexpr (FVK_ENABLED(FVK_DEBUG_BLITTER)) {
         utils::slog.d << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                       << " layout=" << src.getLayout()
@@ -43,8 +48,21 @@ inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
                       << " layout=" << dst.getLayout() << utils::io::endl;
     }
 
-    VkImageSubresourceRange const srcRange = src.getSubresourceRange();
-    VkImageSubresourceRange const dstRange = dst.getSubresourceRange();
+    const VkImageSubresourceRange srcRange = {
+            .aspectMask = aspect,
+            .baseMipLevel = src.level,
+            .levelCount = 1,
+            .baseArrayLayer = src.layer,
+            .layerCount = 1,
+    };
+
+    const VkImageSubresourceRange dstRange = {
+            .aspectMask = aspect,
+            .baseMipLevel = dst.level,
+            .levelCount = 1,
+            .baseArrayLayer = dst.layer,
+            .layerCount = 1,
+    };
 
     VulkanLayout oldSrcLayout = src.getLayout();
     VulkanLayout oldDstLayout = dst.getLayout();
@@ -59,15 +77,15 @@ inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
             .dstOffsets = { dstRect[0], dstRect[1] },
     }};
     vkCmdBlitImage(cmdbuffer,
-            src.getImage(), imgutil::getVkLayout(VulkanLayout::TRANSFER_SRC),
-            dst.getImage(), imgutil::getVkLayout(VulkanLayout::TRANSFER_DST),
+            src.getImage(), ImgUtil::getVkLayout(VulkanLayout::TRANSFER_SRC),
+            dst.getImage(), ImgUtil::getVkLayout(VulkanLayout::TRANSFER_DST),
             1, blitRegions, filter);
 
     if (oldSrcLayout == VulkanLayout::UNDEFINED) {
-        oldSrcLayout = imgutil::getDefaultLayout(src.texture->usage);
+        oldSrcLayout = ImgUtil::getDefaultLayout(src.texture->usage);
     }
     if (oldDstLayout == VulkanLayout::UNDEFINED) {
-        oldDstLayout = imgutil::getDefaultLayout(dst.texture->usage);
+        oldDstLayout = ImgUtil::getDefaultLayout(dst.texture->usage);
     }
     src.texture->transitionLayout(cmdbuffer, srcRange, oldSrcLayout);
     dst.texture->transitionLayout(cmdbuffer, dstRange, oldDstLayout);
@@ -75,6 +93,7 @@ inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
 
 inline void resolveFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
         VulkanAttachment src, VulkanAttachment dst) {
+
     if constexpr (FVK_ENABLED(FVK_DEBUG_BLITTER)) {
         utils::slog.d << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                       << " layout=" << src.getLayout()
@@ -82,8 +101,21 @@ inline void resolveFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspe
                       << " layout=" << dst.getLayout() << utils::io::endl;
     }
 
-    VkImageSubresourceRange const srcRange = src.getSubresourceRange();
-    VkImageSubresourceRange const dstRange = dst.getSubresourceRange();
+    const VkImageSubresourceRange srcRange = {
+            .aspectMask = aspect,
+            .baseMipLevel = src.level,
+            .levelCount = 1,
+            .baseArrayLayer = src.layer,
+            .layerCount = 1,
+    };
+
+    const VkImageSubresourceRange dstRange = {
+            .aspectMask = aspect,
+            .baseMipLevel = dst.level,
+            .levelCount = 1,
+            .baseArrayLayer = dst.layer,
+            .layerCount = 1,
+    };
 
     VulkanLayout oldSrcLayout = src.getLayout();
     VulkanLayout oldDstLayout = dst.getLayout();
@@ -101,15 +133,15 @@ inline void resolveFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspe
             .extent = { src.getExtent2D().width, src.getExtent2D().height, 1 },
     }};
     vkCmdResolveImage(cmdbuffer,
-            src.getImage(), imgutil::getVkLayout(VulkanLayout::TRANSFER_SRC),
-            dst.getImage(), imgutil::getVkLayout(VulkanLayout::TRANSFER_DST),
+            src.getImage(), ImgUtil::getVkLayout(VulkanLayout::TRANSFER_SRC),
+            dst.getImage(), ImgUtil::getVkLayout(VulkanLayout::TRANSFER_DST),
             1, resolveRegions);
 
     if (oldSrcLayout == VulkanLayout::UNDEFINED) {
-        oldSrcLayout = imgutil::getDefaultLayout(src.texture->usage);
+        oldSrcLayout = ImgUtil::getDefaultLayout(src.texture->usage);
     }
     if (oldDstLayout == VulkanLayout::UNDEFINED) {
-        oldDstLayout = imgutil::getDefaultLayout(dst.texture->usage);
+        oldDstLayout = ImgUtil::getDefaultLayout(dst.texture->usage);
     }
     src.texture->transitionLayout(cmdbuffer, srcRange, oldSrcLayout);
     dst.texture->transitionLayout(cmdbuffer, dstRange, oldDstLayout);

filament/backend/src/vulkan/VulkanBlitter.h

@@ -17,7 +17,6 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANBLITTER_H
 #define TNT_FILAMENT_BACKEND_VULKANBLITTER_H
 
-#include "VulkanCommands.h"
 #include "VulkanContext.h"
 
 #include <utils/compiler.h>

filament/backend/src/vulkan/VulkanBuffer.cpp

@@ -27,8 +27,8 @@ VulkanBuffer::VulkanBuffer(VmaAllocator allocator, VulkanStagePool& stagePool,
         VkBufferUsageFlags usage, uint32_t numBytes)
     : mAllocator(allocator),
       mStagePool(stagePool),
-      mUsage(usage),
-      mUpdatedBytes(0) {
+      mUsage(usage) {
+
     // for now make sure that only 1 bit is set in usage
     // (because loadFromCpu() assumes that somewhat)
     assert_invariant(usage && !(usage & (usage - 1)));
@@ -49,7 +49,8 @@ VulkanBuffer::~VulkanBuffer() {
 }
 
 void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint32_t byteOffset,
-        uint32_t numBytes) {
+        uint32_t numBytes) const {
+    assert_invariant(byteOffset == 0);
     VulkanStage const* stage = mStagePool.acquireStage(numBytes);
     void* mapped;
     vmaMapMemory(mAllocator, stage->memory, &mapped);
@@ -57,51 +58,15 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
     vmaUnmapMemory(mAllocator, stage->memory);
     vmaFlushAllocation(mAllocator, stage->memory, byteOffset, numBytes);
 
-    // If there was a previous update, then we need to make sure the following write is properly
-    // synced with the previous read.
-    if (mUpdatedBytes > 0) {
-        VkAccessFlags srcAccess = 0;
-        VkPipelineStageFlags srcStage = 0;
-        if (mUsage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
-            srcAccess = VK_ACCESS_SHADER_READ_BIT;
-            srcStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-        } else if (mUsage & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) {
-            srcAccess = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
-            srcStage = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
-        } else if (mUsage & VK_BUFFER_USAGE_INDEX_BUFFER_BIT) {
-            srcAccess = VK_ACCESS_INDEX_READ_BIT;
-            srcStage = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
-        }
-
-        VkBufferMemoryBarrier barrier{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-            .srcAccessMask = srcAccess,
-            .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .buffer = mGpuBuffer,
-            .size = mUpdatedBytes,
-        };
-        vkCmdPipelineBarrier(cmdbuf, srcStage, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1,
-                &barrier, 0, nullptr);
-    }
-
-    VkBufferCopy region {
-            .srcOffset = 0,
-            .dstOffset = byteOffset,
-            .size = numBytes,
-    };
+    VkBufferCopy region{ .size = numBytes };
     vkCmdCopyBuffer(cmdbuf, stage->buffer, mGpuBuffer, 1, &region);
 
-    mUpdatedBytes = numBytes;
-
     // Firstly, ensure that the copy finishes before the next draw call.
     // Secondly, in case the user decides to upload another chunk (without ever using the first one)
     // we need to ensure that this upload completes first (hence
     // dstStageMask=VK_PIPELINE_STAGE_TRANSFER_BIT).
     VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
     VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
-
     if (mUsage & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) {
         dstAccessMask |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
         dstStageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
@@ -110,24 +75,26 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
         dstStageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
     } else if (mUsage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
         dstAccessMask |= VK_ACCESS_UNIFORM_READ_BIT;
-        dstStageMask |=
-                (VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
+        // NOTE: ideally dstStageMask would include VERTEX_SHADER_BIT | FRAGMENT_SHADER_BIT, but
+        // this seems to be insufficient on Mali devices. To work around this we are using a more
+        // aggressive ALL_GRAPHICS_BIT barrier.
+        dstStageMask |= VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
     } else if (mUsage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) {
         // TODO: implement me
     }
 
     VkBufferMemoryBarrier barrier{
-        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-        .dstAccessMask = dstAccessMask,
-        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-        .buffer = mGpuBuffer,
-        .size = VK_WHOLE_SIZE,
+	    .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+	    .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+	    .dstAccessMask = dstAccessMask,
+	    .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+	    .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+	    .buffer = mGpuBuffer,
+	    .size = VK_WHOLE_SIZE,
     };
 
     vkCmdPipelineBarrier(cmdbuf, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageMask, 0, 0, nullptr, 1,
-            &barrier, 0, nullptr);
+	    &barrier, 0, nullptr);
 }
 
 } // namespace filament::backend

filament/backend/src/vulkan/VulkanBuffer.h

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

filament/backend/src/vulkan/VulkanCommands.cpp

@@ -47,8 +47,7 @@ VulkanCmdFence::VulkanCmdFence(VkFence ifence)
 
 VulkanCommandBuffer::VulkanCommandBuffer(VulkanResourceAllocator* allocator, VkDevice device,
         VkCommandPool pool)
-    : mResourceManager(allocator),
-      mPipeline(VK_NULL_HANDLE) {
+    : mResourceManager(allocator) {
     // Create the low-level command buffer.
     const VkCommandBufferAllocateInfo allocateInfo{
             .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,

filament/backend/src/vulkan/VulkanCommands.h

@@ -89,15 +89,6 @@ struct VulkanCommandBuffer {
     inline void reset() {
         fence.reset();
         mResourceManager.clear();
-        mPipeline = VK_NULL_HANDLE;
-    }
-
-    inline void setPipeline(VkPipeline pipeline) {
-        mPipeline = pipeline;
-    }
-
-    inline VkPipeline pipeline() const {
-        return mPipeline;
     }
 
     inline VkCommandBuffer buffer() const {
@@ -112,7 +103,6 @@ struct VulkanCommandBuffer {
 private:
     VulkanAcquireOnlyResourceManager mResourceManager;
     VkCommandBuffer mBuffer;
-    VkPipeline mPipeline;
 };
 
 // Allows classes to be notified after a new command buffer has been activated.

filament/backend/src/vulkan/VulkanConstants.h

@@ -47,7 +47,7 @@
 // granualarity of a renderpass. You can enable this along with FVK_DEBUG_DEBUG_UTILS to take
 // advantage of vkCmdBegin/EndDebugUtilsLabelEXT. You can also just enable this with
 // FVK_DEBUG_PRINT_GROUP_MARKERS to print the current marker to stdout.
-#define FVK_DEBUG_GROUP_MARKERS           0x00000002
+#define FVK_DEBUG_GROUP_MARKERS 0x00000002
 
 #define FVK_DEBUG_TEXTURE                 0x00000004
 #define FVK_DEBUG_LAYOUT_TRANSITION       0x00000008
@@ -75,14 +75,18 @@
 #define FVK_DEBUG_PERFORMANCE     \
     FVK_DEBUG_SYSTRACE
 
-#if defined(FILAMENT_BACKEND_DEBUG_FLAG)
-#define FVK_DEBUG_FORWARDED_FLAG (FILAMENT_BACKEND_DEBUG_FLAG & FVK_DEBUG_EVERYTHING)
-#else
-#define FVK_DEBUG_FORWARDED_FLAG 0
-#endif
+#define FVK_DEBUG_CORRECTNESS     \
+    FVK_DEBUG_VALIDATION |        \
+    FVK_DEBUG_SHADER_MODULE |     \
+    FVK_DEBUG_TEXTURE |           \
+    FVK_DEBUG_LAYOUT_TRANSITION
+
+#define FVK_DEBUG_RENDER_PASSES   \
+    FVK_DEBUG_GROUP_MARKERS |     \
+    FVK_DEBUG_PRINT_GROUP_MARKERS
 
 #ifndef NDEBUG
-#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE | FVK_DEBUG_FORWARDED_FLAG)
+#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE)
 #else
 #define FVK_DEBUG_FLAGS 0
 #endif
@@ -108,7 +112,7 @@ static_assert(FVK_ENABLED(FVK_DEBUG_VALIDATION));
 // end dependcy checks
 
 // Shorthand for combination of enabled debug flags
-#if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS) && FVK_ENABLED(FVK_DEBUG_TEXTURE)
+#if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS) || FVK_ENABLED(FVK_DEBUG_TEXTURE)
 #define FVK_ENABLED_DEBUG_SAMPLER_NAME 1
 #else
 #define FVK_ENABLED_DEBUG_SAMPLER_NAME 0

filament/backend/src/vulkan/VulkanContext.cpp

@@ -57,19 +57,15 @@ VkExtent2D VulkanAttachment::getExtent2D() const {
     return { std::max(1u, texture->width >> level), std::max(1u, texture->height >> level) };
 }
 
-VkImageView VulkanAttachment::getImageView() {
+VkImageView VulkanAttachment::getImageView(VkImageAspectFlags aspect) {
     assert_invariant(texture);
-    return texture->getAttachmentView(getSubresourceRange());
+    return texture->getAttachmentView(getSubresourceRange(aspect));
 }
 
-bool VulkanAttachment::isDepth() const {
-    return texture->getImageAspect() & VK_IMAGE_ASPECT_DEPTH_BIT;
-}
-
-VkImageSubresourceRange VulkanAttachment::getSubresourceRange() const {
+VkImageSubresourceRange VulkanAttachment::getSubresourceRange(VkImageAspectFlags aspect) const {
     assert_invariant(texture);
     return {
-            .aspectMask = texture->getImageAspect(),
+            .aspectMask = aspect,
             .baseMipLevel = uint32_t(level),
             .levelCount = 1,
             .baseArrayLayer = uint32_t(layer),
@@ -86,7 +82,7 @@ VulkanTimestamps::VulkanTimestamps(VkDevice device) : mDevice(device) {
     std::unique_lock<utils::Mutex> lock(mMutex);
     tqpCreateInfo.queryCount = mUsed.size() * 2;
     VkResult result = vkCreateQueryPool(mDevice, &tqpCreateInfo, VKALLOC, &mPool);
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateQueryPool error.";
+    ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateQueryPool error.");
     mUsed.reset();
 }
 
@@ -134,8 +130,8 @@ VulkanTimestamps::QueryResult VulkanTimestamps::getResult(VulkanTimerQuery const
     VkResult vkresult =
             vkGetQueryPoolResults(mDevice, mPool, index, 2, dataSize, (void*) result.data(),
                     stride, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT);
-    FILAMENT_CHECK_POSTCONDITION(vkresult == VK_SUCCESS || vkresult == VK_NOT_READY)
-            << "vkGetQueryPoolResults error: " << static_cast<int32_t>(vkresult);
+    ASSERT_POSTCONDITION(vkresult == VK_SUCCESS || vkresult == VK_NOT_READY,
+            "vkGetQueryPoolResults error: %d", static_cast<int32_t>(vkresult));
     if (vkresult == VK_NOT_READY) {
         return {0, 0, 0, 0};
     }

filament/backend/src/vulkan/VulkanContext.h

@@ -19,6 +19,7 @@
 
 #include "VulkanConstants.h"
 #include "VulkanImageUtility.h"
+#include "VulkanPipelineCache.h"
 #include "VulkanUtility.h"
 
 #include <utils/bitset.h>
@@ -41,18 +42,16 @@ struct VulkanTimerQuery;
 struct VulkanCommandBuffer;
 
 struct VulkanAttachment {
-    VulkanTexture* texture = nullptr;
+    VulkanTexture* texture;
     uint8_t level = 0;
     uint16_t layer = 0;
-
-    bool isDepth() const;
     VkImage getImage() const;
     VkFormat getFormat() const;
     VulkanLayout getLayout() const;
     VkExtent2D getExtent2D() const;
-    VkImageView getImageView();
+    VkImageView getImageView(VkImageAspectFlags aspect);
     // TODO: maybe embed aspect into the attachment or texture itself.
-    VkImageSubresourceRange getSubresourceRange() const;
+    VkImageSubresourceRange getSubresourceRange(VkImageAspectFlags aspect) const;
 };
 
 class VulkanTimestamps {
@@ -103,12 +102,8 @@ public:
         return (uint32_t) VK_MAX_MEMORY_TYPES;
     }
 
-    inline VkFormatList const& getAttachmentDepthStencilFormats() const {
-        return mDepthStencilFormats;
-    }
-
-    inline VkFormatList const& getBlittableDepthStencilFormats() const {
-        return mBlittableDepthStencilFormats;
+    inline VkFormatList const& getAttachmentDepthFormats() const {
+        return mDepthFormats;
     }
 
     inline VkPhysicalDeviceLimits const& getPhysicalDeviceLimits() const noexcept {
@@ -120,21 +115,16 @@ public:
     }
 
     inline bool isImageCubeArraySupported() const noexcept {
-        return mPhysicalDeviceFeatures.imageCubeArray == VK_TRUE;
+        return mPhysicalDeviceFeatures.imageCubeArray;
     }
 
     inline bool isDebugMarkersSupported() const noexcept {
         return mDebugMarkersSupported;
     }
-
     inline bool isDebugUtilsSupported() const noexcept {
         return mDebugUtilsSupported;
     }
 
-    inline bool isClipDistanceSupported() const noexcept {
-        return mPhysicalDeviceFeatures.shaderClipDistance == VK_TRUE;
-    }
-
 private:
     VkPhysicalDeviceMemoryProperties mMemoryProperties = {};
     VkPhysicalDeviceProperties mPhysicalDeviceProperties = {};
@@ -142,8 +132,7 @@ private:
     bool mDebugMarkersSupported = false;
     bool mDebugUtilsSupported = false;
 
-    VkFormatList mDepthStencilFormats;
-    VkFormatList mBlittableDepthStencilFormats;
+    VkFormatList mDepthFormats;
 
     // For convenience so that VulkanPlatform can initialize the private fields.
     friend class VulkanPlatform;

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "VulkanDriver.h"
+#include "vulkan/VulkanDriver.h"
 
 #include "CommandStreamDispatcher.h"
 #include "DataReshaper.h"
@@ -22,6 +22,7 @@
 #include "VulkanCommands.h"
 #include "VulkanDriverFactory.h"
 #include "VulkanHandles.h"
+#include "VulkanImageUtility.h"
 #include "VulkanMemory.h"
 #include "VulkanTexture.h"
 
@@ -101,15 +102,6 @@ VulkanTexture* createEmptyTexture(VkDevice device, VkPhysicalDevice physicalDevi
     return emptyTexture;
 }
 
-VulkanBufferObject* createEmptyBufferObject(VmaAllocator allocator, VulkanStagePool& stagePool,
-        VulkanCommands* commands) {
-    VulkanBufferObject* obj =
-            new VulkanBufferObject(allocator, stagePool, 1, BufferObjectBinding::UNIFORM);
-    uint8_t byte = 0;
-    obj->buffer.loadFromCpu(commands->get().buffer(), &byte, 0, 1);
-    return obj;
-}
-
 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
 VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallback(VkDebugReportFlagsEXT flags,
         VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location,
@@ -173,8 +165,7 @@ DebugUtils::DebugUtils(VkInstance instance, VkDevice device, VulkanContext const
         };
         VkResult result = vkCreateDebugUtilsMessengerEXT(instance, &createInfo,
                 VKALLOC, &mDebugMessenger);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-                << "Unable to create Vulkan debug messenger.";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS, "Unable to create Vulkan debug messenger.");
     }
 #endif // FVK_EANBLED(FVK_DEBUG_VALIDATION)
 }
@@ -206,6 +197,8 @@ void DebugUtils::setName(VkObjectType type, uint64_t handle, char const* name) {
 }
 #endif // FVK_EANBLED(FVK_DEBUG_DEBUG_UTILS)
 
+using ImgUtil = VulkanImageUtility;
+
 Dispatcher VulkanDriver::getDispatcher() const noexcept {
     return ConcreteDispatcher<VulkanDriver>::make();
 }
@@ -221,16 +214,13 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
       mThreadSafeResourceManager(&mResourceAllocator),
       mCommands(mPlatform->getDevice(), mPlatform->getGraphicsQueue(),
               mPlatform->getGraphicsQueueFamilyIndex(), &mContext, &mResourceAllocator),
-      mPipelineLayoutCache(mPlatform->getDevice(), &mResourceAllocator),
-      mPipelineCache(mPlatform->getDevice(), mAllocator),
+      mPipelineCache(&mResourceAllocator),
       mStagePool(mAllocator, &mCommands),
       mFramebufferCache(mPlatform->getDevice()),
       mSamplerCache(mPlatform->getDevice()),
       mBlitter(mPlatform->getPhysicalDevice(), &mCommands),
       mReadPixels(mPlatform->getDevice()),
-      mDescriptorSetManager(mPlatform->getDevice(), &mResourceAllocator),
-      mIsSRGBSwapChainSupported(mPlatform->getCustomization().isSRGBSwapChainSupported),
-      mStereoscopicType(driverConfig.stereoscopicType) {
+      mIsSRGBSwapChainSupported(mPlatform->getCustomization().isSRGBSwapChainSupported) {
 
 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
     DebugUtils::mSingleton =
@@ -248,23 +238,18 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
         };
         VkResult result = createDebugReportCallback(mPlatform->getInstance(), &cbinfo, VKALLOC,
                 &mDebugCallback);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-                << "Unable to create Vulkan debug callback.";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS, "Unable to create Vulkan debug callback.");
     }
 #endif
 
     mTimestamps = std::make_unique<VulkanTimestamps>(mPlatform->getDevice());
+    mCommands.setObserver(&mPipelineCache);
+    mPipelineCache.setDevice(mPlatform->getDevice(), mAllocator);
 
     mEmptyTexture = createEmptyTexture(mPlatform->getDevice(), mPlatform->getPhysicalDevice(),
             mContext, mAllocator, &mCommands, mStagePool);
-    mEmptyBufferObject = createEmptyBufferObject(mAllocator, mStagePool, &mCommands);
 
-    mDescriptorSetManager.setPlaceHolders(mSamplerCache.getSampler({}), mEmptyTexture,
-            mEmptyBufferObject);
-
-    mGetPipelineFunction = [this](VulkanDescriptorSetLayoutList const& layouts, VulkanProgram* program) {
-        return mPipelineLayoutCache.getLayout(layouts, program);
-    };
+    mPipelineCache.setDummyTexture(mEmptyTexture->getPrimaryImageView());
 }
 
 VulkanDriver::~VulkanDriver() noexcept = default;
@@ -325,18 +310,13 @@ ShaderModel VulkanDriver::getShaderModel() const noexcept {
 }
 
 void VulkanDriver::terminate() {
-    // Flush and wait here to make sure all queued commands are executed and resources that are tied
-    // to those commands are no longer referenced.
-    finish(0);
-
-    delete mEmptyBufferObject;
-    delete mEmptyTexture;
-
     // Command buffers should come first since it might have commands depending on resources that
     // are about to be destroyed.
     mCommands.terminate();
 
+    delete mEmptyTexture;
     mResourceManager.clear();
+
     mTimestamps.reset();
 
     mBlitter.terminate();
@@ -349,12 +329,6 @@ void VulkanDriver::terminate() {
     mPipelineCache.terminate();
     mFramebufferCache.reset();
     mSamplerCache.terminate();
-    mDescriptorSetManager.terminate();
-    mPipelineLayoutCache.terminate();
-
-#if FVK_ENABLED(FVK_DEBUG_RESOURCE_LEAK)
-    mResourceAllocator.print();
-#endif
 
     vmaDestroyAllocator(mAllocator);
 
@@ -386,8 +360,6 @@ void VulkanDriver::collectGarbage() {
     mCommands.gc();
     mStagePool.gc();
     mFramebufferCache.gc();
-    mPipelineCache.gc();
-    mDescriptorSetManager.gc();
 
 #if FVK_ENABLED(FVK_DEBUG_RESOURCE_LEAK)
     mResourceAllocator.print();
@@ -395,17 +367,16 @@ void VulkanDriver::collectGarbage() {
 
     FVK_SYSTRACE_END();
 }
-void VulkanDriver::beginFrame(int64_t monotonic_clock_ns,
-        int64_t refreshIntervalNs, uint32_t frameId) {
+void VulkanDriver::beginFrame(int64_t monotonic_clock_ns, uint32_t frameId) {
     // Do nothing.
 }
 
 void VulkanDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, FrameScheduledCallback&& callback) {
+        FrameScheduledCallback callback, void* user) {
 }
 
 void VulkanDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
+        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
 }
 
 void VulkanDriver::setPresentationTime(int64_t monotonic_clock_ns) {
@@ -518,6 +489,9 @@ void VulkanDriver::destroyBufferObject(Handle<HwBufferObject> boh) {
         return;
     }
     auto bufferObject = mResourceAllocator.handle_cast<VulkanBufferObject*>(boh);
+    if (bufferObject->bindingType == BufferObjectBinding::UNIFORM) {
+        mPipelineCache.unbindUniformBuffer(bufferObject->buffer.getGpuBuffer());
+    }
     mResourceManager.release(bufferObject);
 }
 
@@ -568,7 +542,6 @@ void VulkanDriver::destroyProgram(Handle<HwProgram> ph) {
         return;
     }
     auto vkprogram = mResourceAllocator.handle_cast<VulkanProgram*>(ph);
-    mDescriptorSetManager.clearProgram(vkprogram);
     mResourceManager.release(vkprogram);
 }
 
@@ -906,14 +879,13 @@ bool VulkanDriver::isProtectedContentSupported() {
     return false;
 }
 
-bool VulkanDriver::isStereoSupported() {
-    switch (mStereoscopicType) {
-        case backend::StereoscopicType::INSTANCED:
-            return mContext.isClipDistanceSupported();
-        case backend::StereoscopicType::MULTIVIEW:
-            // TODO: implement multiview feature in Vulkan.
-        case backend::StereoscopicType::NONE:
-            return false;
+bool VulkanDriver::isStereoSupported(backend::StereoscopicType stereoscopicType) {
+    switch (stereoscopicType) {
+    case backend::StereoscopicType::INSTANCED:
+        return true;
+    case backend::StereoscopicType::MULTIVIEW:
+        // TODO: implement multiview feature in Vulkan.
+        return false;
     }
 }
 
@@ -926,11 +898,6 @@ bool VulkanDriver::isDepthStencilResolveSupported() {
     return false;
 }
 
-bool VulkanDriver::isDepthStencilBlitSupported(TextureFormat format) {
-    auto const& formats = mContext.getBlittableDepthStencilFormats();
-    return std::find(formats.begin(), formats.end(), getVkFormat(format)) != formats.end();
-}
-
 bool VulkanDriver::isProtectedTexturesSupported() {
     return false;
 }
@@ -1096,8 +1063,7 @@ TimerQueryResult VulkanDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint
         return TimerQueryResult::NOT_READY;
     }
 
-    FILAMENT_CHECK_POSTCONDITION(timestamp1 >= timestamp0)
-            << "Timestamps are not monotonically increasing.";
+    ASSERT_POSTCONDITION(timestamp1 >= timestamp0, "Timestamps are not monotonically increasing.");
 
     // NOTE: MoltenVK currently writes system time so the following delta will always be zero.
     // However there are plans for implementing this properly. See the following GitHub ticket.
@@ -1245,7 +1211,12 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
         }
     }
 
-    VulkanLayout currentDepthLayout = depth.getLayout();
+    VulkanLayout const currentDepthLayout = depth.getLayout();
+    VulkanLayout const renderPassDepthLayout = VulkanLayout::DEPTH_ATTACHMENT;
+    // We need to keep the final layout as an attachment because the implicit transition does not
+    // have any barrier guarrantees, meaning that if we want to sample from the output in the next
+    // pass, then we'd have a race-condition/validation error.
+    VulkanLayout const finalDepthLayout = renderPassDepthLayout;
 
     TargetBufferFlags clearVal = params.flags.clear;
     TargetBufferFlags discardEndVal = params.flags.discardEnd;
@@ -1254,20 +1225,16 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
             discardEndVal &= ~TargetBufferFlags::DEPTH;
             clearVal &= ~TargetBufferFlags::DEPTH;
         }
-        // If the depth attachment texture was previously sampled, then we need to manually
-        // transition it to an attachment. This is necessary to also set up a barrier between the
-        // previous read and the potentially coming write.
-        if (currentDepthLayout == VulkanLayout::DEPTH_SAMPLER) {
-            depth.texture->transitionLayout(cmdbuffer, depth.getSubresourceRange(),
-                    VulkanLayout::DEPTH_ATTACHMENT);
-            currentDepthLayout = VulkanLayout::DEPTH_ATTACHMENT;
-        }
+        auto const attachmentSubresourceRange = depth.getSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT);
+        depth.texture->setLayout(attachmentSubresourceRange, VulkanLayout::DEPTH_ATTACHMENT);
     }
 
     // Create the VkRenderPass or fetch it from cache.
     VulkanFboCache::RenderPassKey rpkey = {
         .initialColorLayoutMask = 0,
         .initialDepthLayout = currentDepthLayout,
+        .renderPassDepthLayout = renderPassDepthLayout,
+        .finalDepthLayout = finalDepthLayout,
         .depthFormat = depth.getFormat(),
         .clear = clearVal,
         .discardStart = discardStart,
@@ -1284,9 +1251,9 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
                 rpkey.needsResolveMask |= (1 << i);
             }
             if (info.texture->getPrimaryImageLayout() != VulkanLayout::COLOR_ATTACHMENT) {
-                ((VulkanTexture*) info.texture)
-                        ->transitionLayout(cmdbuffer, info.getSubresourceRange(),
-                                VulkanLayout::COLOR_ATTACHMENT);
+                ((VulkanTexture*) info.texture)->transitionLayout(cmdbuffer,
+                        info.getSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT),
+                        VulkanLayout::COLOR_ATTACHMENT);
             }
         } else {
             rpkey.colorFormat[i] = VK_FORMAT_UNDEFINED;
@@ -1304,42 +1271,27 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
         .layers = 1,
         .samples = rpkey.samples,
     };
-    auto& renderPassAttachments = mRenderPassFboInfo.attachments;
     for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; i++) {
         if (!rt->getColor(i).texture) {
             fbkey.color[i] = VK_NULL_HANDLE;
             fbkey.resolve[i] = VK_NULL_HANDLE;
         } else if (fbkey.samples == 1) {
-            auto& colorAttachment = rt->getColor(i);
-            renderPassAttachments.insert(colorAttachment);
-            fbkey.color[i] = colorAttachment.getImageView();
+            fbkey.color[i] = rt->getColor(i).getImageView(VK_IMAGE_ASPECT_COLOR_BIT);
             fbkey.resolve[i] = VK_NULL_HANDLE;
             assert_invariant(fbkey.color[i]);
         } else {
-            auto& msaaColorAttachment = rt->getMsaaColor(i);
-            renderPassAttachments.insert(msaaColorAttachment);
-
-            auto& colorAttachment = rt->getColor(i);
-            fbkey.color[i] = msaaColorAttachment.getImageView();
-
-            VulkanTexture* texture = colorAttachment.texture;
+            fbkey.color[i] = rt->getMsaaColor(i).getImageView(VK_IMAGE_ASPECT_COLOR_BIT);
+            VulkanTexture* texture = (VulkanTexture*) rt->getColor(i).texture;
             if (texture->samples == 1) {
-                mRenderPassFboInfo.hasColorResolve = true;
-
-                renderPassAttachments.insert(colorAttachment);
-                fbkey.resolve[i] = colorAttachment.getImageView();
+                fbkey.resolve[i] = rt->getColor(i).getImageView(VK_IMAGE_ASPECT_COLOR_BIT);
                 assert_invariant(fbkey.resolve[i]);
             }
             assert_invariant(fbkey.color[i]);
         }
     }
     if (depth.texture) {
-        fbkey.depth = depth.getImageView();
+        fbkey.depth = depth.getImageView(VK_IMAGE_ASPECT_DEPTH_BIT);
         assert_invariant(fbkey.depth);
-        renderPassAttachments.insert(depth);
-
-        UTILS_UNUSED_IN_RELEASE bool const depthDiscardEnd =
-                any(rpkey.discardEnd & TargetBufferFlags::DEPTH);
 
         // Vulkan 1.1 does not support multisampled depth resolve, so let's check here
         // and assert if this is requested. (c.f. isAutoDepthResolveSupported)
@@ -1348,7 +1300,7 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
         // - If the RT is MS then all SS attachments are auto resolved if not discarded.
         assert_invariant(!(rt->getSamples() > 1 &&
                 rt->getDepth().texture->samples == 1 &&
-                !depthDiscardEnd));
+                !any(rpkey.discardEnd & TargetBufferFlags::DEPTH)));
     }
     VkFramebuffer vkfb = mFramebufferCache.getFramebuffer(fbkey);
 
@@ -1361,10 +1313,16 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
     }
 #endif
 
-    // The current command buffer now has references to the render target and its attachments.
+    // The current command buffer now owns a reference to the render target and its attachments.
+    // Note that we must acquire parent textures, not sidecars.
     commands.acquire(rt);
-    for (auto const& attachment: renderPassAttachments) {
-        commands.acquire(attachment.texture);
+    if (depth.texture) {
+        commands.acquire((VulkanTexture*) depth.texture);
+    }
+    for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; i++) {
+        if (rt->getColor(i).texture) {
+            commands.acquire(rt->getColor(i).texture);
+        }
     }
 
     // Populate the structures required for vkCmdBeginRenderPass.
@@ -1450,60 +1408,41 @@ void VulkanDriver::endRenderPass(int) {
     // issue several of them when considering MRT. This would be very complex to set up and would
     // require more state tracking, so we've chosen to use a memory barrier for simplicity and
     // correctness.
+
+    // NOTE: ideally dstStageMask would merely be VERTEX_SHADER_BIT | FRAGMENT_SHADER_BIT, but this
+    // seems to be insufficient on Mali devices. To work around this we are adding a more aggressive
+    // TOP_OF_PIPE barrier.
     if (!rt->isSwapChain()) {
-        for (auto const& attachment: mRenderPassFboInfo.attachments) {
-            bool const isDepth = attachment.isDepth();
-            VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-
-            // This is a workaround around a validation issue (might not be an actual driver issue).
-            if (mRenderPassFboInfo.hasColorResolve && !isDepth) {
-                srcStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
-            }
-
-            VkPipelineStageFlags dstStageMask =
-                    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-            VkAccessFlags srcAccess = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-            VkAccessFlags dstAccess = VK_ACCESS_SHADER_READ_BIT;
-            VulkanLayout layout = VulkanFboCache::FINAL_COLOR_ATTACHMENT_LAYOUT;
-            if (isDepth) {
-                srcAccess = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-                dstAccess = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
-                srcStageMask = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
-                dstStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
-                layout =  VulkanFboCache::FINAL_DEPTH_ATTACHMENT_LAYOUT;
-            }
-
-            auto const vkLayout = imgutil::getVkLayout(layout);
-            auto const& range = attachment.getSubresourceRange();
-            VkImageMemoryBarrier barrier = {
-                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-                .pNext = nullptr,
-                .srcAccessMask = srcAccess,
-                .dstAccessMask = dstAccess,
-                .oldLayout = vkLayout,
-                .newLayout = vkLayout,
-                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                .image = attachment.getImage(),
-                .subresourceRange = range,
-            };
-
-            attachment.texture->setLayout(range, layout);
-            vkCmdPipelineBarrier(cmdbuffer, srcStageMask, dstStageMask, 0, 0, nullptr, 0, nullptr,
-                    1, &barrier);
+        VkMemoryBarrier barrier{
+                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
+                .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
+        };
+        VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+        if (rt->hasDepth()) {
+            barrier.srcAccessMask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+            srcStageMask |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
         }
+        vkCmdPipelineBarrier(cmdbuffer, srcStageMask,
+                VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT | // <== For Mali
+                VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                0, 1, &barrier, 0, nullptr, 0, nullptr);
     }
 
-    mRenderPassFboInfo.clear();
-    mDescriptorSetManager.clearState();
+    if (mCurrentRenderPass.currentSubpass > 0) {
+        for (uint32_t i = 0; i < VulkanPipelineCache::INPUT_ATTACHMENT_COUNT; i++) {
+            mPipelineCache.bindInputAttachment(i, {});
+        }
+        mCurrentRenderPass.currentSubpass = 0;
+    }
     mCurrentRenderPass.renderTarget = nullptr;
     mCurrentRenderPass.renderPass = VK_NULL_HANDLE;
     FVK_SYSTRACE_END();
 }
 
 void VulkanDriver::nextSubpass(int) {
-    FILAMENT_CHECK_PRECONDITION(mCurrentRenderPass.currentSubpass == 0)
-            << "Only two subpasses are currently supported.";
+    ASSERT_PRECONDITION(mCurrentRenderPass.currentSubpass == 0,
+            "Only two subpasses are currently supported.");
 
     VulkanRenderTarget* renderTarget = mCurrentRenderPass.renderTarget;
     assert_invariant(renderTarget);
@@ -1514,9 +1453,15 @@ void VulkanDriver::nextSubpass(int) {
     mPipelineCache.bindRenderPass(mCurrentRenderPass.renderPass,
             ++mCurrentRenderPass.currentSubpass);
 
-    if (mCurrentRenderPass.params.subpassMask & 0x1) {
-        VulkanAttachment subpassInput = renderTarget->getColor(0);
-        mDescriptorSetManager.updateInputAttachment({}, subpassInput);
+    for (uint32_t i = 0; i < VulkanPipelineCache::INPUT_ATTACHMENT_COUNT; i++) {
+        if ((1 << i) & mCurrentRenderPass.params.subpassMask) {
+            VulkanAttachment subpassInput = renderTarget->getColor(i);
+            VkDescriptorImageInfo info = {
+                .imageView = subpassInput.getImageView(VK_IMAGE_ASPECT_COLOR_BIT),
+                .imageLayout = ImgUtil::getVkLayout(subpassInput.getLayout()),
+            };
+            mPipelineCache.bindInputAttachment(i, info);
+        }
     }
 }
 
@@ -1556,24 +1501,25 @@ void VulkanDriver::commit(Handle<HwSwapChain> sch) {
 
 void VulkanDriver::bindUniformBuffer(uint32_t index, Handle<HwBufferObject> boh) {
     auto* bo = mResourceAllocator.handle_cast<VulkanBufferObject*>(boh);
-    VkDeviceSize const offset = 0;
-    VkDeviceSize const size = VK_WHOLE_SIZE;
-    mDescriptorSetManager.updateBuffer({}, (uint32_t) index, bo, offset, size);
+    const VkDeviceSize offset = 0;
+    const VkDeviceSize size = VK_WHOLE_SIZE;
+    mPipelineCache.bindUniformBufferObject((uint32_t) index, bo, offset, size);
 }
 
 void VulkanDriver::bindBufferRange(BufferObjectBinding bindingType, uint32_t index,
         Handle<HwBufferObject> boh, uint32_t offset, uint32_t size) {
 
-    assert_invariant(bindingType == BufferObjectBinding::UNIFORM);
+    assert_invariant(bindingType == BufferObjectBinding::SHADER_STORAGE ||
+                     bindingType == BufferObjectBinding::UNIFORM);
 
     // TODO: implement BufferObjectBinding::SHADER_STORAGE case
 
     auto* bo = mResourceAllocator.handle_cast<VulkanBufferObject*>(boh);
-    mDescriptorSetManager.updateBuffer({}, (uint32_t) index, bo, offset, size);
+    mPipelineCache.bindUniformBufferObject((uint32_t)index, bo, offset, size);
 }
 
 void VulkanDriver::unbindBuffer(BufferObjectBinding bindingType, uint32_t index) {
-    mDescriptorSetManager.clearBuffer((uint32_t) index);
+    // TODO: implement unbindBuffer()
 }
 
 void VulkanDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
@@ -1581,14 +1527,6 @@ void VulkanDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
     mSamplerBindings[index] = hwsb;
 }
 
-void VulkanDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
-        backend::PushConstantVariant value) {
-    assert_invariant(mBoundPipeline.program && "Expect a program when writing to push constants");
-    VulkanCommands* commands = &mCommands;
-    mBoundPipeline.program->writePushConstant(commands, mBoundPipeline.pipelineLayout, stage, index,
-            value);
-}
-
 void VulkanDriver::insertEventMarker(char const* string, uint32_t len) {
 #if FVK_ENABLED(FVK_DEBUG_GROUP_MARKERS)
     mCommands.insertEventMarker(string, len);
@@ -1643,36 +1581,36 @@ void VulkanDriver::resolve(
     FVK_SYSTRACE_CONTEXT();
     FVK_SYSTRACE_START("resolve");
 
-    FILAMENT_CHECK_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE)
-            << "resolve() cannot be invoked inside a render pass.";
+    ASSERT_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE,
+            "resolve() cannot be invoked inside a render pass.");
 
     auto* const srcTexture = mResourceAllocator.handle_cast<VulkanTexture*>(src);
     auto* const dstTexture = mResourceAllocator.handle_cast<VulkanTexture*>(dst);
     assert_invariant(srcTexture);
     assert_invariant(dstTexture);
 
-    FILAMENT_CHECK_PRECONDITION(
-            dstTexture->width == srcTexture->width && dstTexture->height == srcTexture->height)
-            << "invalid resolve: src and dst sizes don't match";
+    ASSERT_PRECONDITION(
+            dstTexture->width == srcTexture->width && dstTexture->height == srcTexture->height,
+            "invalid resolve: src and dst sizes don't match");
 
-    FILAMENT_CHECK_PRECONDITION(srcTexture->samples > 1 && dstTexture->samples == 1)
-            << "invalid resolve: src.samples=" << +srcTexture->samples
-            << ", dst.samples=" << +dstTexture->samples;
+    ASSERT_PRECONDITION(srcTexture->samples > 1 && dstTexture->samples == 1,
+            "invalid resolve: src.samples=%u, dst.samples=%u",
+            +srcTexture->samples, +dstTexture->samples);
 
-    FILAMENT_CHECK_PRECONDITION(srcTexture->format == dstTexture->format)
-            << "src and dst texture format don't match";
+    ASSERT_PRECONDITION(srcTexture->format == dstTexture->format,
+            "src and dst texture format don't match");
 
-    FILAMENT_CHECK_PRECONDITION(!isDepthFormat(srcTexture->format))
-            << "can't resolve depth formats";
+    ASSERT_PRECONDITION(!isDepthFormat(srcTexture->format),
+            "can't resolve depth formats");
 
-    FILAMENT_CHECK_PRECONDITION(!isStencilFormat(srcTexture->format))
-            << "can't resolve stencil formats";
+    ASSERT_PRECONDITION(!isStencilFormat(srcTexture->format),
+            "can't resolve stencil formats");
 
-    FILAMENT_CHECK_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST))
-            << "texture doesn't have BLIT_DST";
+    ASSERT_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST),
+            "texture doesn't have BLIT_DST");
 
-    FILAMENT_CHECK_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC))
-            << "texture doesn't have BLIT_SRC";
+    ASSERT_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC),
+            "texture doesn't have BLIT_SRC");
 
     mBlitter.resolve(
             { .texture = dstTexture, .level = dstLevel, .layer = dstLayer },
@@ -1688,20 +1626,20 @@ void VulkanDriver::blit(
     FVK_SYSTRACE_CONTEXT();
     FVK_SYSTRACE_START("blit");
 
-    FILAMENT_CHECK_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE)
-            << "blit() cannot be invoked inside a render pass.";
+    ASSERT_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE,
+            "blit() cannot be invoked inside a render pass.");
 
     auto* const srcTexture = mResourceAllocator.handle_cast<VulkanTexture*>(src);
     auto* const dstTexture = mResourceAllocator.handle_cast<VulkanTexture*>(dst);
 
-    FILAMENT_CHECK_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST))
-            << "texture doesn't have BLIT_DST";
+    ASSERT_PRECONDITION(any(dstTexture->usage & TextureUsage::BLIT_DST),
+            "texture doesn't have BLIT_DST");
 
-    FILAMENT_CHECK_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC))
-            << "texture doesn't have BLIT_SRC";
+    ASSERT_PRECONDITION(any(srcTexture->usage & TextureUsage::BLIT_SRC),
+            "texture doesn't have BLIT_SRC");
 
-    FILAMENT_CHECK_PRECONDITION(srcTexture->format == dstTexture->format)
-            << "src and dst texture format don't match";
+    ASSERT_PRECONDITION(srcTexture->format == dstTexture->format,
+            "src and dst texture format don't match");
 
     // The Y inversion below makes it so that Vk matches GL and Metal.
 
@@ -1733,15 +1671,15 @@ void VulkanDriver::blitDEPRECATED(TargetBufferFlags buffers,
 
     // Note: blitDEPRECATED is only used for Renderer::copyFrame()
 
-    FILAMENT_CHECK_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE)
-            << "blitDEPRECATED() cannot be invoked inside a render pass.";
+    ASSERT_PRECONDITION(mCurrentRenderPass.renderPass == VK_NULL_HANDLE,
+            "blitDEPRECATED() cannot be invoked inside a render pass.");
 
-    FILAMENT_CHECK_PRECONDITION(buffers == TargetBufferFlags::COLOR0)
-            << "blitDEPRECATED only supports COLOR0";
+    ASSERT_PRECONDITION(buffers == TargetBufferFlags::COLOR0,
+            "blitDEPRECATED only supports COLOR0");
 
-    FILAMENT_CHECK_PRECONDITION(
-            srcRect.left >= 0 && srcRect.bottom >= 0 && dstRect.left >= 0 && dstRect.bottom >= 0)
-            << "Source and destination rects must be positive.";
+    ASSERT_PRECONDITION(srcRect.left >= 0 && srcRect.bottom >= 0 &&
+                        dstRect.left >= 0 && dstRect.bottom >= 0,
+            "Source and destination rects must be positive.");
 
     VulkanRenderTarget* dstTarget = mResourceAllocator.handle_cast<VulkanRenderTarget*>(dst);
     VulkanRenderTarget* srcTarget = mResourceAllocator.handle_cast<VulkanRenderTarget*>(src);
@@ -1772,7 +1710,7 @@ void VulkanDriver::blitDEPRECATED(TargetBufferFlags buffers,
     FVK_SYSTRACE_END();
 }
 
-void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {
+void VulkanDriver::bindPipeline(PipelineState pipelineState) {
     FVK_SYSTRACE_CONTEXT();
     FVK_SYSTRACE_START("draw");
 
@@ -1829,14 +1767,22 @@ void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {
     // where "SamplerBinding" is the integer in the GLSL, and SamplerGroupBinding is the abstract
     // Filament concept used to form groups of samplers.
 
+    VkDescriptorImageInfo samplerInfo[VulkanPipelineCache::SAMPLER_BINDING_COUNT] = {};
+    VulkanTexture* samplerTextures[VulkanPipelineCache::SAMPLER_BINDING_COUNT] = {nullptr};
+
     auto const& bindingToSamplerIndex = program->getBindingToSamplerIndex();
+    VulkanPipelineCache::UsageFlags usage = program->getUsage();
+
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
     auto const& bindingToName = program->getBindingToName();
 #endif
 
-    for (auto binding: program->getBindings()) {
+    UTILS_NOUNROLL
+    for (uint8_t binding = 0; binding < VulkanPipelineCache::SAMPLER_BINDING_COUNT; binding++) {
         uint16_t const indexPair = bindingToSamplerIndex[binding];
+
         if (indexPair == 0xffff) {
+            usage = VulkanPipelineCache::disableUsageFlags(binding, usage);
             continue;
         }
 
@@ -1845,20 +1791,24 @@ void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {
 
         VulkanSamplerGroup* vksb = mSamplerBindings[samplerGroupInd];
         if (!vksb) {
+            usage = VulkanPipelineCache::disableUsageFlags(binding, usage);
             continue;
         }
         SamplerDescriptor const* boundSampler = ((SamplerDescriptor*) vksb->sb->data()) + samplerInd;
 
         if (UTILS_UNLIKELY(!boundSampler->t)) {
+            usage = VulkanPipelineCache::disableUsageFlags(binding, usage);
             continue;
         }
+
         VulkanTexture* texture = mResourceAllocator.handle_cast<VulkanTexture*>(boundSampler->t);
+        VkImageViewType const expectedType = texture->getViewType();
 
         // TODO: can this uninitialized check be checked in a higher layer?
         // This fallback path is very flaky because the dummy texture might not have
         // matching characteristics. (e.g. if the missing texture is a 3D texture)
         if (UTILS_UNLIKELY(texture->getPrimaryImageLayout() == VulkanLayout::UNDEFINED)) {
-#if FVK_ENABLED(FVK_DEBUG_TEXTURE) && FVK_ENABLED_DEBUG_SAMPLER_NAME
+#if FVK_ENABLED(FVK_DEBUG_TEXTURE)
             utils::slog.w << "Uninitialized texture bound to '" << bindingToName[binding] << "'";
             utils::slog.w << " in material '" << program->name.c_str() << "'";
             utils::slog.w << " at binding point " << +binding << utils::io::endl;
@@ -1866,28 +1816,43 @@ void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {
             texture = mEmptyTexture;
         }
 
-        VkSampler const vksampler = mSamplerCache.getSampler(boundSampler->s);
+        SamplerParams const& samplerParams = boundSampler->s;
+        VkSampler const vksampler = mSamplerCache.getSampler(samplerParams);
+
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
         VulkanDriver::DebugUtils::setName(VK_OBJECT_TYPE_SAMPLER,
                 reinterpret_cast<uint64_t>(vksampler), bindingToName[binding].c_str());
 #endif
-        mDescriptorSetManager.updateSampler({}, binding, texture, vksampler);
+
+        VkImageView imageView = VK_NULL_HANDLE;
+        VkImageSubresourceRange const range = texture->getPrimaryViewRange();
+        if (any(texture->usage & TextureUsage::DEPTH_ATTACHMENT) &&
+                expectedType == VK_IMAGE_VIEW_TYPE_2D) {
+            // If the sampler is part of a mipmapped depth texture, where one of the level *can* be
+            // an attachment, then the sampler for this texture has the same view properties as a
+            // view for an attachment. Therefore, we can use getAttachmentView to get a
+            // corresponding VkImageView.
+            imageView = texture->getAttachmentView(range);
+        } else {
+            imageView = texture->getViewForType(range, expectedType);
+        }
+
+        samplerInfo[binding] = {
+            .sampler = vksampler,
+            .imageView = imageView,
+            .imageLayout = ImgUtil::getVkLayout(texture->getPrimaryImageLayout())
+        };
+        samplerTextures[binding] = texture;
     }
 
-    auto const pipelineLayout = mDescriptorSetManager.bind(commands, program, mGetPipelineFunction);
-    mBoundPipeline = {
-        .program = program,
-        .pipelineLayout = pipelineLayout,
-    };
-
-    mPipelineCache.bindLayout(pipelineLayout);
-    mPipelineCache.bindPipeline(commands);
-
-    // Since we don't statically define scissor as part of the pipeline, we need to call scissor at
-    // least once. Context: VUID-vkCmdDrawIndexed-None-07832.
-    auto const& extent = rt->getExtent();
-    scissor({0, 0, extent.width, extent.height});
+    mPipelineCache.bindSamplers(samplerInfo, samplerTextures, usage);
 
+    // Bind a new pipeline if the pipeline state changed.
+    // If allocation failed, skip the draw call and bail. We do not emit an error since the
+    // validation layer will already do so.
+    if (!mPipelineCache.bindPipeline(commands)) {
+        return;
+    }
     FVK_SYSTRACE_END();
 }
 
@@ -1927,8 +1892,12 @@ void VulkanDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
     VulkanCommandBuffer& commands = mCommands.get();
     VkCommandBuffer cmdbuffer = commands.buffer();
 
-    // Bind "dynamic" UBOs if they need to change.
-    mDescriptorSetManager.dynamicBind(&commands, {});
+    // Bind new descriptor sets if they need to change.
+    // If descriptor set allocation failed, skip the draw call and bail. No need to emit an error
+    // message since the validation layers already do so.
+    if (!mPipelineCache.bindDescriptors(cmdbuffer)) {
+        return;
+    }
 
     // Finally, make the actual draw call. TODO: support subranges
     const uint32_t firstIndex = indexOffset;
@@ -1978,7 +1947,7 @@ void VulkanDriver::scissor(Viewport scissorBox) {
 
     const VulkanRenderTarget* rt = mCurrentRenderPass.renderTarget;
     rt->transformClientRectToPlatform(&scissor);
-    vkCmdSetScissor(cmdbuffer, 0, 1, &scissor);
+    mPipelineCache.bindScissor(cmdbuffer, scissor);
 }
 
 void VulkanDriver::beginTimerQuery(Handle<HwTimerQuery> tqh) {

filament/backend/src/vulkan/VulkanDriver.h

@@ -28,9 +28,6 @@
 #include "VulkanSamplerCache.h"
 #include "VulkanStagePool.h"
 #include "VulkanUtility.h"
-#include "backend/DriverEnums.h"
-#include "caching/VulkanDescriptorSetManager.h"
-#include "caching/VulkanPipelineLayoutCache.h"
 
 #include "DriverBase.h"
 #include "private/backend/Driver.h"
@@ -43,25 +40,6 @@ namespace filament::backend {
 class VulkanPlatform;
 struct VulkanSamplerGroup;
 
-// The maximum number of attachments for any renderpass (color + resolve + depth)
-constexpr uint8_t MAX_RENDERTARGET_ATTACHMENT_TEXTURES =
-        MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT * 2 + 1;
-
-// We need to store information about a render pass to enable better barriers at the end of a
-// renderpass.
-struct RenderPassFboBundle {
-    using AttachmentArray =
-            CappedArray<VulkanAttachment, MAX_RENDERTARGET_ATTACHMENT_TEXTURES>;
-
-    AttachmentArray attachments;
-    bool hasColorResolve = false;
-
-    void clear() {
-        attachments.clear();
-        hasColorResolve = false;
-    }
-};
-
 class VulkanDriver final : public DriverBase {
 public:
     static Driver* create(VulkanPlatform* platform, VulkanContext const& context,
@@ -92,8 +70,6 @@ public:
 #endif // FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
 
 private:
-    static constexpr uint8_t MAX_SAMPLER_BINDING_COUNT = Program::SAMPLER_BINDING_COUNT;
-
     void debugCommandBegin(CommandStream* cmds, bool synchronous,
             const char* methodName) noexcept override;
 
@@ -130,9 +106,7 @@ private:
     VulkanPlatform* mPlatform = nullptr;
     std::unique_ptr<VulkanTimestamps> mTimestamps;
 
-    // Placeholder resources
     VulkanTexture* mEmptyTexture;
-    VulkanBufferObject* mEmptyBufferObject;
 
     VulkanSwapChain* mCurrentSwapChain = nullptr;
     VulkanRenderTarget* mDefaultRenderTarget = nullptr;
@@ -149,28 +123,15 @@ private:
     VulkanThreadSafeResourceManager mThreadSafeResourceManager;
 
     VulkanCommands mCommands;
-    VulkanPipelineLayoutCache mPipelineLayoutCache;
     VulkanPipelineCache mPipelineCache;
     VulkanStagePool mStagePool;
     VulkanFboCache mFramebufferCache;
     VulkanSamplerCache mSamplerCache;
     VulkanBlitter mBlitter;
-    VulkanSamplerGroup* mSamplerBindings[MAX_SAMPLER_BINDING_COUNT] = {};
+    VulkanSamplerGroup* mSamplerBindings[VulkanPipelineCache::SAMPLER_BINDING_COUNT] = {};
     VulkanReadPixels mReadPixels;
-    VulkanDescriptorSetManager mDescriptorSetManager;
-
-    VulkanDescriptorSetManager::GetPipelineLayoutFunction mGetPipelineFunction;
-
-    // This is necessary for us to write to push constants after binding a pipeline.
-    struct BoundPipeline {
-        VulkanProgram* program;
-        VkPipelineLayout pipelineLayout;
-    };
-    BoundPipeline mBoundPipeline = {};
-    RenderPassFboBundle mRenderPassFboInfo;
 
     bool const mIsSRGBSwapChainSupported;
-    backend::StereoscopicType const mStereoscopicType;
 };
 
 } // namespace filament::backend

filament/backend/src/vulkan/VulkanFboCache.cpp

@@ -29,10 +29,14 @@ using namespace bluevk;
 
 namespace filament::backend {
 
+using ImgUtil = VulkanImageUtility;
+
 bool VulkanFboCache::RenderPassEq::operator()(const RenderPassKey& k1,
         const RenderPassKey& k2) const {
     if (k1.initialColorLayoutMask != k2.initialColorLayoutMask) return false;
     if (k1.initialDepthLayout != k2.initialDepthLayout) return false;
+    if (k1.renderPassDepthLayout != k2.renderPassDepthLayout) return false;
+    if (k1.finalDepthLayout != k2.finalDepthLayout) return false;
     for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; i++) {
         if (k1.colorFormat[i] != k2.colorFormat[i]) return false;
     }
@@ -64,8 +68,8 @@ VulkanFboCache::VulkanFboCache(VkDevice device)
     : mDevice(device) {}
 
 VulkanFboCache::~VulkanFboCache() {
-    FILAMENT_CHECK_POSTCONDITION(mFramebufferCache.empty() && mRenderPassCache.empty())
-            << "Please explicitly call terminate() while the VkDevice is still alive.";
+    ASSERT_POSTCONDITION(mFramebufferCache.empty() && mRenderPassCache.empty(),
+            "Please explicitly call terminate() while the VkDevice is still alive.");
 }
 
 VkFramebuffer VulkanFboCache::getFramebuffer(FboKey config) noexcept {
@@ -115,7 +119,7 @@ VkFramebuffer VulkanFboCache::getFramebuffer(FboKey config) noexcept {
     mRenderPassRefCount[info.renderPass]++;
     VkFramebuffer framebuffer;
     VkResult error = vkCreateFramebuffer(mDevice, &info, VKALLOC, &framebuffer);
-    FILAMENT_CHECK_POSTCONDITION(!error) << "Unable to create framebuffer.";
+    ASSERT_POSTCONDITION(!error, "Unable to create framebuffer.");
     mFramebufferCache[config] = {framebuffer, mCurrentTime};
     return framebuffer;
 }
@@ -193,7 +197,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
         if (config.colorFormat[i] == VK_FORMAT_UNDEFINED) {
             continue;
         }
-        const VkImageLayout subpassLayout = imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT);
+        const VkImageLayout subpassLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT);
         uint32_t index;
 
         if (!hasSubpasses) {
@@ -239,9 +243,9 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
             .stencilLoadOp = kDontCare,
             .stencilStoreOp = kDisableStore,
             .initialLayout = ((!discard && config.initialColorLayoutMask & (1 << i)) || clear)
-                                     ? imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT)
-                                     : imgutil::getVkLayout(VulkanLayout::UNDEFINED),
-            .finalLayout = imgutil::getVkLayout(FINAL_COLOR_ATTACHMENT_LAYOUT),
+                                     ? ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT)
+                                     : ImgUtil::getVkLayout(VulkanLayout::UNDEFINED),
+            .finalLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
         };
     }
 
@@ -268,7 +272,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
 
         pResolveAttachment->attachment = attachmentIndex;
         pResolveAttachment->layout
-                = imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT_RESOLVE);
+                = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT_RESOLVE);
         ++pResolveAttachment;
 
         attachments[attachmentIndex++] = {
@@ -278,8 +282,8 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
             .storeOp = kEnableStore,
             .stencilLoadOp = kDontCare,
             .stencilStoreOp = kDisableStore,
-            .initialLayout = imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
-            .finalLayout = imgutil::getVkLayout(FINAL_COLOR_ATTACHMENT_LAYOUT),
+            .initialLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
+            .finalLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
         };
     }
 
@@ -288,7 +292,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
         const bool clear = any(config.clear & TargetBufferFlags::DEPTH);
         const bool discardStart = any(config.discardStart & TargetBufferFlags::DEPTH);
         const bool discardEnd = any(config.discardEnd & TargetBufferFlags::DEPTH);
-        depthAttachmentRef.layout = imgutil::getVkLayout(VulkanLayout::DEPTH_ATTACHMENT);
+        depthAttachmentRef.layout = ImgUtil::getVkLayout(config.renderPassDepthLayout);
         depthAttachmentRef.attachment = attachmentIndex;
         attachments[attachmentIndex++] = {
             .format = config.depthFormat,
@@ -297,8 +301,8 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
             .storeOp = discardEnd ? kDisableStore : kEnableStore,
             .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
             .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
-            .initialLayout = imgutil::getVkLayout(config.initialDepthLayout),
-            .finalLayout = imgutil::getVkLayout(FINAL_DEPTH_ATTACHMENT_LAYOUT),
+            .initialLayout = ImgUtil::getVkLayout(config.initialDepthLayout),
+            .finalLayout = ImgUtil::getVkLayout(config.finalDepthLayout),
         };
     }
     renderPassInfo.attachmentCount = attachmentIndex;
@@ -306,7 +310,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
     // Finally, create the VkRenderPass.
     VkRenderPass renderPass;
     VkResult error = vkCreateRenderPass(mDevice, &renderPassInfo, VKALLOC, &renderPass);
-    FILAMENT_CHECK_POSTCONDITION(!error) << "Unable to create render pass.";
+    ASSERT_POSTCONDITION(!error, "Unable to create render pass.");
     mRenderPassCache[config] = {renderPass, mCurrentTime};
 
     #if FVK_ENABLED(FVK_DEBUG_FBO_CACHE)

filament/backend/src/vulkan/VulkanFboCache.h

@@ -35,25 +35,24 @@ namespace filament::backend {
 //
 class VulkanFboCache {
 public:
-    constexpr static VulkanLayout FINAL_COLOR_ATTACHMENT_LAYOUT = VulkanLayout::COLOR_ATTACHMENT;
-    constexpr static VulkanLayout FINAL_RESOLVE_ATTACHMENT_LAYOUT = VulkanLayout::COLOR_ATTACHMENT;
-    constexpr static VulkanLayout FINAL_DEPTH_ATTACHMENT_LAYOUT = VulkanLayout::DEPTH_ATTACHMENT;
-
     // RenderPassKey is a small POD representing the immutable state that is used to construct
     // a VkRenderPass. It is hashed and used as a lookup key.
+    // TODO: This struct can be reduced in size by using a subset of formats instead of VkFormat
+    //       and removing the "finalDepthLayout" field.
     struct alignas(8) RenderPassKey {
         // For each target, we need to know three image layouts: the layout BEFORE the pass, the
         // layout DURING the pass, and the layout AFTER the pass. Here are the rules:
         // - For depth, we explicitly specify all three layouts.
         // - Color targets have their initial image layout specified with a bitmask.
         // - For each color target, the pre-existing layout is either UNDEFINED (0) or GENERAL (1).
-        // - The render pass and final images layout for color buffers is always
-        //   VulkanLayout::COLOR_ATTACHMENT.
+        // - The render pass and final images layout for color buffers is always GENERAL.
         uint8_t initialColorLayoutMask;
 
         // Note that if VulkanLayout grows beyond 16, we'd need to up this.
-        VulkanLayout initialDepthLayout : 8;
-        uint8_t padding0;
+        VulkanLayout initialDepthLayout : 4;
+        VulkanLayout renderPassDepthLayout : 4;
+        VulkanLayout finalDepthLayout : 4;
+        uint8_t padding0 : 4;
         uint8_t padding1;
 
         VkFormat colorFormat[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT]; // 32 bytes
@@ -64,7 +63,7 @@ public:
         uint8_t samples; // 1 byte
         uint8_t needsResolveMask; // 1 byte
         uint8_t subpassMask; // 1 byte
-        uint8_t padding2; // 1 byte
+        bool padding2; // 1 byte
     };
     struct RenderPassVal {
         VkRenderPass handle;

filament/backend/src/vulkan/VulkanHandles.cpp

@@ -20,9 +20,7 @@
 #include "VulkanConstants.h"
 #include "VulkanDriver.h"
 #include "VulkanMemory.h"
-#include "VulkanUtility.h"
 #include "spirv/VulkanSpirvUtils.h"
-#include "utils/Log.h"
 
 #include <backend/platforms/VulkanPlatform.h>
 
@@ -32,17 +30,15 @@ using namespace bluevk;
 
 namespace filament::backend {
 
-namespace {
-
-void flipVertically(VkRect2D* rect, uint32_t framebufferHeight) {
+static void flipVertically(VkRect2D* rect, uint32_t framebufferHeight) {
     rect->offset.y = framebufferHeight - rect->offset.y - rect->extent.height;
 }
 
-void flipVertically(VkViewport* rect, uint32_t framebufferHeight) {
+static void flipVertically(VkViewport* rect, uint32_t framebufferHeight) {
     rect->y = framebufferHeight - rect->y - rect->height;
 }
 
-void clampToFramebuffer(VkRect2D* rect, uint32_t fbWidth, uint32_t fbHeight) {
+static void clampToFramebuffer(VkRect2D* rect, uint32_t fbWidth, uint32_t fbHeight) {
     int32_t x = std::max(rect->offset.x, 0);
     int32_t y = std::max(rect->offset.y, 0);
     int32_t right = std::min(rect->offset.x + (int32_t) rect->extent.width, (int32_t) fbWidth);
@@ -53,165 +49,17 @@ void clampToFramebuffer(VkRect2D* rect, uint32_t fbWidth, uint32_t fbHeight) {
     rect->extent.height = std::max(top - y, 0);
 }
 
-template<typename Bitmask>
-static constexpr Bitmask fromStageFlags(ShaderStageFlags2 flags, uint8_t binding) {
-    Bitmask ret = 0;
-    if (flags & ShaderStageFlags2::VERTEX) {
-        ret |= (getVertexStage<Bitmask>() << binding);
-    }
-    if (flags & ShaderStageFlags2::FRAGMENT) {
-        ret |= (getFragmentStage<Bitmask>() << binding);
-    }
-    return ret;
-}
-
-constexpr decltype(VulkanProgram::MAX_SHADER_MODULES) MAX_SHADER_MODULES =
-        VulkanProgram::MAX_SHADER_MODULES;
-
-using LayoutDescriptionList = VulkanProgram::LayoutDescriptionList;
-
-template<typename Bitmask>
-void addDescriptors(Bitmask mask,
-        utils::FixedCapacityVector<DescriptorSetLayoutBinding>& outputList) {
-    constexpr uint8_t MODULE_OFFSET = (sizeof(Bitmask) * 8) / MAX_SHADER_MODULES;
-    for (uint8_t i = 0; i < MODULE_OFFSET; ++i) {
-        bool const hasVertex = (mask & (1ULL << i)) != 0;
-        bool const hasFragment = (mask & (1ULL << (MODULE_OFFSET + i))) != 0;
-        if (!hasVertex && !hasFragment) {
-            continue;
-        }
-
-        DescriptorSetLayoutBinding binding{
-            .binding = i,
-            .flags = DescriptorFlags::NONE,
-            .count = 0,// This is always 0 for now as we pass the size of the UBOs in the Driver API
-                       // instead.
-        };
-        if (hasVertex) {
-            binding.stageFlags = ShaderStageFlags2::VERTEX;
-        }
-        if (hasFragment) {
-            binding.stageFlags = static_cast<ShaderStageFlags2>(
-                    binding.stageFlags | ShaderStageFlags2::FRAGMENT);
-        }
-        if constexpr (std::is_same_v<Bitmask, UniformBufferBitmask>) {
-            binding.type = DescriptorType::UNIFORM_BUFFER;
-        } else if constexpr (std::is_same_v<Bitmask, SamplerBitmask>) {
-            binding.type = DescriptorType::SAMPLER;
-        } else if constexpr (std::is_same_v<Bitmask, InputAttachmentBitmask>) {
-            binding.type = DescriptorType::INPUT_ATTACHMENT;
-        }
-        outputList.push_back(binding);
-    }
-}
-
-inline VkDescriptorSetLayout createDescriptorSetLayout(VkDevice device,
-        VkDescriptorSetLayoutCreateInfo const& info) {
-    VkDescriptorSetLayout layout;
-    vkCreateDescriptorSetLayout(device, &info, VKALLOC, &layout);
-    return layout;
-}
-
-inline VkShaderStageFlags getVkStage(backend::ShaderStage stage) {
-    switch(stage) {
-        case backend::ShaderStage::VERTEX:
-            return VK_SHADER_STAGE_VERTEX_BIT;
-        case backend::ShaderStage::FRAGMENT:
-            return VK_SHADER_STAGE_FRAGMENT_BIT;
-        case backend::ShaderStage::COMPUTE:
-            PANIC_POSTCONDITION("Unsupported stage");
-    }
-}
-
-} // anonymous namespace
-
-
-VulkanDescriptorSetLayout::VulkanDescriptorSetLayout(VkDevice device,
-        VkDescriptorSetLayoutCreateInfo const& info, Bitmask const& bitmask)
-    : VulkanResource(VulkanResourceType::DESCRIPTOR_SET_LAYOUT),
-      mDevice(device),
-      vklayout(createDescriptorSetLayout(device, info)),
-      bitmask(bitmask),
-      bindings(getBindings(bitmask)),
-      count(Count::fromLayoutBitmask(bitmask)) {}
-
-VulkanDescriptorSetLayout::~VulkanDescriptorSetLayout() {
-    vkDestroyDescriptorSetLayout(mDevice, vklayout, VKALLOC);
-}
-
-PushConstantDescription::PushConstantDescription(backend::Program const& program) noexcept {
-    mRangeCount = 0;
-    for (auto stage : { ShaderStage::VERTEX, ShaderStage::FRAGMENT, ShaderStage::COMPUTE }) {
-        auto const& constants = program.getPushConstants(stage);
-        if (constants.empty()) {
-            continue;
-        }
-
-        // We store the type of the constant for type-checking when writing.
-        auto& types = mTypes[(uint8_t) stage];
-        types.reserve(constants.size());
-        std::for_each(constants.cbegin(), constants.cend(), [&types] (Program::PushConstant t) {
-            types.push_back(t.type);
-        });
-
-        mRanges[mRangeCount++] = {
-            .stageFlags = getVkStage(stage),
-            .offset = 0,
-            .size = (uint32_t) constants.size() * ENTRY_SIZE,
-        };
-    }
-}
-
-void PushConstantDescription::write(VulkanCommands* commands, VkPipelineLayout layout,
-        backend::ShaderStage stage, uint8_t index, backend::PushConstantVariant const& value) {
-    VulkanCommandBuffer* cmdbuf = &(commands->get());
-    uint32_t binaryValue = 0;
-    UTILS_UNUSED_IN_RELEASE auto const& types = mTypes[(uint8_t) stage];
-    if (std::holds_alternative<bool>(value)) {
-        assert_invariant(types[index] == ConstantType::BOOL);
-        bool const bval = std::get<bool>(value);
-        binaryValue = static_cast<uint32_t const>(bval ? VK_TRUE : VK_FALSE);
-    } else if (std::holds_alternative<float>(value)) {
-        assert_invariant(types[index] == ConstantType::FLOAT);
-        float const fval = std::get<float>(value);
-        binaryValue = *reinterpret_cast<uint32_t const*>(&fval);
-    } else {
-        assert_invariant(types[index] == ConstantType::INT);
-        int const ival = std::get<int>(value);
-        binaryValue = *reinterpret_cast<uint32_t const*>(&ival);
-    }
-    vkCmdPushConstants(cmdbuf->buffer(), layout, getVkStage(stage), index * ENTRY_SIZE, ENTRY_SIZE,
-            &binaryValue);
-}
-
 VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
     : HwProgram(builder.getName()),
       VulkanResource(VulkanResourceType::PROGRAM),
-      mInfo(new(std::nothrow) PipelineInfo(builder)),
+      mInfo(new PipelineInfo()),
       mDevice(device) {
-
-    constexpr uint8_t UBO_MODULE_OFFSET = (sizeof(UniformBufferBitmask) * 8) / MAX_SHADER_MODULES;
-    constexpr uint8_t SAMPLER_MODULE_OFFSET = (sizeof(SamplerBitmask) * 8) / MAX_SHADER_MODULES;
-    constexpr uint8_t INPUT_ATTACHMENT_MODULE_OFFSET =
-            (sizeof(InputAttachmentBitmask) * 8) / MAX_SHADER_MODULES;
-
     Program::ShaderSource const& blobs = builder.getShadersSource();
     auto& modules = mInfo->shaders;
 
     auto const& specializationConstants = builder.getSpecializationConstants();
 
     std::vector<uint32_t> shader;
-
-    // TODO: this will be moved out of the shader as the descriptor set layout will be provided by
-    // Filament instead of parsed from the shaders. See [GDSR] in VulkanDescriptorSetManager.h
-    UniformBufferBitmask uboMask = 0;
-    SamplerBitmask samplerMask = 0;
-    InputAttachmentBitmask inputAttachmentMask = 0;
-
-    static_assert(static_cast<ShaderStage>(0) == ShaderStage::VERTEX &&
-            static_cast<ShaderStage>(1) == ShaderStage::FRAGMENT &&
-            MAX_SHADER_MODULES == 2);
-
     for (size_t i = 0; i < MAX_SHADER_MODULES; i++) {
         Program::ShaderBlob const& blob = blobs[i];
 
@@ -224,12 +72,6 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
             dataSize = shader.size() * 4;
         }
 
-        auto const [ubo, sampler, inputAttachment] = getProgramBindings(blob);
-        uboMask |= (static_cast<UniformBufferBitmask>(ubo) << (UBO_MODULE_OFFSET * i));
-        samplerMask |= (static_cast<SamplerBitmask>(sampler) << (SAMPLER_MODULE_OFFSET * i));
-        inputAttachmentMask |= (static_cast<InputAttachmentBitmask>(inputAttachment)
-                                << (INPUT_ATTACHMENT_MODULE_OFFSET * i));
-
         VkShaderModule& module = modules[i];
         VkShaderModuleCreateInfo moduleInfo = {
             .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
@@ -237,7 +79,7 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
             .pCode = data,
         };
         VkResult result = vkCreateShaderModule(mDevice, &moduleInfo, VKALLOC, &module);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to create shader module.";
+        ASSERT_POSTCONDITION(result == VK_SUCCESS, "Unable to create shader module.");
 
 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
         std::string name{ builder.getName().c_str(), builder.getName().size() };
@@ -257,33 +99,20 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
 #endif
     }
 
-    LayoutDescriptionList& layouts = mInfo->layouts;
-    layouts[0].bindings = utils::FixedCapacityVector<DescriptorSetLayoutBinding>::with_capacity(
-            countBits(collapseStages(uboMask)));
-    layouts[1].bindings = utils::FixedCapacityVector<DescriptorSetLayoutBinding>::with_capacity(
-            countBits(collapseStages(samplerMask)));
-    layouts[2].bindings = utils::FixedCapacityVector<DescriptorSetLayoutBinding>::with_capacity(
-            countBits(collapseStages(inputAttachmentMask)));
-
-    addDescriptors(uboMask, layouts[0].bindings);
-    addDescriptors(samplerMask, layouts[1].bindings);
-    addDescriptors(inputAttachmentMask, layouts[2].bindings);
-
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
     auto& bindingToName = mInfo->bindingToName;
 #endif
 
     auto& groupInfo = builder.getSamplerGroupInfo();
     auto& bindingToSamplerIndex = mInfo->bindingToSamplerIndex;
-    auto& bindings = mInfo->bindings;
+    auto& usage = mInfo->usage;
     for (uint8_t groupInd = 0; groupInd < Program::SAMPLER_BINDING_COUNT; groupInd++) {
         auto const& group = groupInfo[groupInd];
         auto const& samplers = group.samplers;
         for (size_t i = 0; i < samplers.size(); ++i) {
             uint32_t const binding = samplers[i].binding;
             bindingToSamplerIndex[binding] = (groupInd << 8) | (0xff & i);
-            assert_invariant(bindings.find(binding) == bindings.end());
-            bindings.insert(binding);
+            usage = VulkanPipelineCache::getUsageFlags(binding, group.stageFlags, usage);
 
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
             bindingToName[binding] = samplers[i].name.c_str();
@@ -297,6 +126,24 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
 #endif
 }
 
+VulkanProgram::VulkanProgram(VkDevice device, VkShaderModule vs, VkShaderModule fs,
+        CustomSamplerInfoList const& samplerInfo) noexcept
+    : VulkanResource(VulkanResourceType::PROGRAM),
+      mInfo(new PipelineInfo()),
+      mDevice(device) {
+    mInfo->shaders[0] = vs;
+    mInfo->shaders[1] = fs;
+    auto& bindingToSamplerIndex = mInfo->bindingToSamplerIndex;
+    auto& usage = mInfo->usage;
+    bindingToSamplerIndex.resize(samplerInfo.size());
+    for (uint16_t binding = 0; binding < samplerInfo.size(); ++binding) {
+        auto const& sampler = samplerInfo[binding];
+        bindingToSamplerIndex[binding]
+                = (sampler.groupIndex << 8) | (0xff & sampler.samplerIndex);
+        usage = VulkanPipelineCache::getUsageFlags(binding, sampler.flags, usage);
+    }
+}
+
 VulkanProgram::~VulkanProgram() {
     for (auto shader: mInfo->shaders) {
         vkDestroyShaderModule(mDevice, shader, VKALLOC);
@@ -340,13 +187,13 @@ VulkanRenderTarget::VulkanRenderTarget(VkDevice device, VkPhysicalDevice physica
 
     // Constrain the sample count according to both kinds of sample count masks obtained from
     // VkPhysicalDeviceProperties. This is consistent with the VulkanTexture constructor.
-    auto const& limits = context.getPhysicalDeviceLimits();
+    const auto& limits = context.getPhysicalDeviceLimits();
     mSamples = samples = reduceSampleCount(samples, limits.framebufferDepthSampleCounts &
             limits.framebufferColorSampleCounts);
 
     // Create sidecar MSAA textures for color attachments if they don't already exist.
     for (int index = 0; index < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; index++) {
-        VulkanAttachment const& spec = color[index];
+        const VulkanAttachment& spec = color[index];
         VulkanTexture* texture = (VulkanTexture*) spec.texture;
         if (texture && texture->samples == 1) {
             auto msTexture = texture->getSidecar();
@@ -409,19 +256,19 @@ VkExtent2D VulkanRenderTarget::getExtent() const {
     return {width, height};
 }
 
-VulkanAttachment& VulkanRenderTarget::getColor(int target) {
+VulkanAttachment VulkanRenderTarget::getColor(int target) const {
     return mColor[target];
 }
 
-VulkanAttachment& VulkanRenderTarget::getMsaaColor(int target) {
+VulkanAttachment VulkanRenderTarget::getMsaaColor(int target) const {
     return mMsaaAttachments[target];
 }
 
-VulkanAttachment& VulkanRenderTarget::getDepth() {
+VulkanAttachment VulkanRenderTarget::getDepth() const {
     return mDepth;
 }
 
-VulkanAttachment& VulkanRenderTarget::getMsaaDepth() {
+VulkanAttachment VulkanRenderTarget::getMsaaDepth() const {
     return mMsaaDepthAttachment;
 }
 
@@ -558,35 +405,4 @@ VulkanRenderPrimitive::VulkanRenderPrimitive(VulkanResourceAllocator* resourceAl
     mResources.acquire(indexBuffer);
 }
 
-using Bitmask = VulkanDescriptorSetLayout::Bitmask;
-
-Bitmask Bitmask::fromBackendLayout(descset::DescriptorSetLayout const& layout) {
-    Bitmask mask;
-    for (auto const& binding: layout.bindings) {
-        switch (binding.type) {
-            case descset::DescriptorType::UNIFORM_BUFFER: {
-                if (binding.flags == descset::DescriptorFlags::DYNAMIC_OFFSET) {
-                    mask.dynamicUbo |= fromStageFlags<UniformBufferBitmask>(binding.stageFlags,
-                            binding.binding);
-                } else {
-                    mask.ubo |= fromStageFlags<UniformBufferBitmask>(binding.stageFlags,
-                            binding.binding);
-                }
-                break;
-            }
-            case descset::DescriptorType::SAMPLER: {
-                mask.sampler |= fromStageFlags<SamplerBitmask>(binding.stageFlags, binding.binding);
-                break;
-            }
-            case descset::DescriptorType::INPUT_ATTACHMENT: {
-                mask.inputAttachment |=
-                        fromStageFlags<InputAttachmentBitmask>(binding.stageFlags, binding.binding);
-                break;
-            }
-        }
-    }
-    return mask;
-}
-
-
 } // namespace filament::backend