backend-test: centralize read pixel logic

we use a different hook for the draw() call when on an ES2 context,
this eliminates completely the overhead of supporting ES2 for the draw
call. draw calls are expected to be the most common calls.

BUILDING.md

@@ -73,7 +73,6 @@ The following CMake options are boolean options specific to Filament:
 - `FILAMENT_SUPPORTS_VULKAN`:      Include the Vulkan backend
 - `FILAMENT_INSTALL_BACKEND_TEST`: Install the backend test library so it can be consumed on iOS
 - `FILAMENT_USE_EXTERNAL_GLES3`:   Experimental: Compile Filament against OpenGL ES 3
-- `FILAMENT_USE_SWIFTSHADER`:      Compile Filament against SwiftShader
 - `FILAMENT_SKIP_SAMPLES`:         Don't build sample apps
 
 To turn an option on or off:
@@ -426,7 +425,7 @@ value is the desired roughness between 0 and 1.
 
 ## Generating C++ documentation
 
-To generate the documentation you must first install `doxygen` and `graphviz`, then run the 
+To generate the documentation you must first install `doxygen` and `graphviz`, then run the
 following commands:
 
 ```shell
@@ -436,32 +435,27 @@ doxygen docs/doxygen/filament.doxygen
 
 Finally simply open `docs/html/index.html` in your web browser.
 
-## SwiftShader
+## Software Rasterization
 
-To try out Filament's Vulkan support with SwiftShader, first build SwiftShader and set the
-`SWIFTSHADER_LD_LIBRARY_PATH` variable to the folder that contains `libvk_swiftshader.dylib`:
+We have tested swiftshader for running software rasterization on the Vulkan backend. To use this,
+please first make sure that the [Vulkan SDK](https://www.lunarg.com/vulkan-sdk/) is installed on
+your machine. If you are doing a manual installation of the SDK on Linux, you will have to source
+`setup-env.sh` in the SDK's root folder to make sure the Vulkan loader is the first lib loaded.
+
+### Swiftshader (Vulkan) [tested on macOS and Linux]
+
+First, build SwiftShader
 
 ```shell
 git clone https://github.com/google/swiftshader.git
 cd swiftshader/build
 cmake .. &&  make -j
-export SWIFTSHADER_LD_LIBRARY_PATH=`pwd`
 ```
 
-Next, go to your Filament repo and use the [easy build](#easy-build) script with `-t`.
-
-## SwiftShader for CI
-
-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:
-
+and then set `VK_ICD_FILENAMES` to the ICD json produced in the build. For example,
 ```shell
-docker pull ghcr.io/filament-assets/swiftshader
-docker run -it ghcr.io/filament-assets/swiftshader
+export VK_ICD_FILENAMES=/Users/user/swiftshader/build/Darwin/vk_swiftshader_icd.json
 ```
 
-To do more with the container, see the helper script at `build/swiftshader/test.sh`.
+Build Filament as normal and use the vulkan backend.
 
-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,8 +21,6 @@ project(TNT)
 # ==================================================================================================
 option(FILAMENT_USE_EXTERNAL_GLES3 "Experimental: Compile Filament against OpenGL ES 3" OFF)
 
-option(FILAMENT_USE_SWIFTSHADER "Compile Filament against SwiftShader" OFF)
-
 option(FILAMENT_ENABLE_LTO "Enable link-time optimizations if supported by the compiler" OFF)
 
 option(FILAMENT_SKIP_SAMPLES "Don't build samples" OFF)
@@ -71,6 +69,10 @@ set(FILAMENT_METAL_HANDLE_ARENA_SIZE_IN_MB "8" CACHE STRING
     "Size of the Metal handle arena, default 8."
 )
 
+set(FILAMENT_BACKEND_DEBUG_FLAG "" CACHE STRING
+    "A debug flag meant for enabling/disabling backend debugging paths"
+)
+
 # Enable exceptions by default in spirv-cross.
 set(SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS OFF)
 
@@ -141,11 +143,6 @@ if (LINUX)
             add_definitions(-DFILAMENT_SUPPORTS_XCB)
         endif()
 
-        # Default Swiftshader build does not enable the xlib extension
-        if (FILAMENT_SUPPORTS_XLIB AND FILAMENT_USE_SWIFTSHADER)
-            set(FILAMENT_SUPPORTS_XLIB OFF)
-        endif()
-
         if (FILAMENT_SUPPORTS_XLIB)
             add_definitions(-DFILAMENT_SUPPORTS_XLIB)
         endif()
@@ -169,15 +166,6 @@ if (NOT ANDROID AND NOT WEBGL AND NOT IOS AND NOT FILAMENT_LINUX_IS_MOBILE)
     set(IS_HOST_PLATFORM TRUE)
 endif()
 
-if (IOS)
-    # Remove the headerpad_max_install_names linker flag on iOS. It causes warnings when linking
-    # executables with bitcode.
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_C_LINK_FLAGS ${CMAKE_C_LINK_FLAGS})
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_CXX_LINK_FLAGS ${CMAKE_CXX_LINK_FLAGS})
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
-    string(REPLACE "-Wl,-headerpad_max_install_names" "" CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS})
-endif()
-
 if (WIN32)
     # Link statically against c/c++ lib to avoid missing redistriburable such as
     # "VCRUNTIME140.dll not found. Try reinstalling the app.", but give users
@@ -332,10 +320,6 @@ if (FILAMENT_SUPPORTS_EGL_ON_LINUX)
   set(EGL TRUE)
 endif()
 
-if (FILAMENT_USE_SWIFTSHADER)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DFILAMENT_USE_SWIFTSHADER")
-endif()
-
 if (WIN32)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_USE_MATH_DEFINES=1")
 endif()
@@ -389,8 +373,9 @@ endif()
 if (NOT MSVC AND NOT IOS)
     # Omitting stack frame pointers prevents the generation of readable stack traces in crash reports on iOS
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer")
+endif()
 
-    # These aren't compatible with -fembed-bitcode (and seem to have no effect on Apple platforms anyway)
+if (NOT MSVC)
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffunction-sections -fdata-sections")
 endif()
 
@@ -455,8 +440,13 @@ endif()
 if (NOT WEBGL)
     set(GC_SECTIONS "-Wl,--gc-sections")
 endif()
+
 set(B_SYMBOLIC_FUNCTIONS "-Wl,-Bsymbolic-functions")
 
+if (ANDROID)
+set(BINARY_ALIGNMENT "-Wl,-z,max-page-size=16384")
+endif()
+
 if (APPLE)
     set(GC_SECTIONS "-Wl,-dead_strip")
     set(B_SYMBOLIC_FUNCTIONS "")
@@ -470,7 +460,7 @@ if (APPLE)
 endif()
 
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${GC_SECTIONS}")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${GC_SECTIONS} ${B_SYMBOLIC_FUNCTIONS}")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${GC_SECTIONS} ${B_SYMBOLIC_FUNCTIONS} ${BINARY_ALIGNMENT}")
 
 if (WEBGL_PTHREADS)
     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pthread")
@@ -548,6 +538,12 @@ if (FILAMENT_SAMPLES_STEREO_TYPE STREQUAL "multiview")
     set(FILAMENT_ENABLE_MULTIVIEW ON)
 endif ()
 
+# Define backend flag for debug only
+if (CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT FILAMENT_BACKEND_DEBUG_FLAG STREQUAL "")
+    add_definitions(-DFILAMENT_BACKEND_DEBUG_FLAG=${FILAMENT_BACKEND_DEBUG_FLAG})
+    unset(FILAMENT_BACKEND_DEBUG_FLAG)
+endif()
+
 # ==================================================================================================
 # Material compilation flags
 # ==================================================================================================
@@ -676,21 +672,6 @@ else()
     set(IMPORT_EXECUTABLES ${FILAMENT}/${IMPORT_EXECUTABLES_DIR}/ImportExecutables-${CMAKE_BUILD_TYPE}.cmake)
 endif()
 
-# ==================================================================================================
-# Try to find Vulkan if the SDK is installed, otherwise fall back to the bundled version.
-# This needs to stay in our top-level CMakeLists because it sets up variables that are used by the
-# "bluevk" and "samples" targets.
-# ==================================================================================================
-
-if (FILAMENT_USE_SWIFTSHADER)
-    if (NOT FILAMENT_SUPPORTS_VULKAN)
-        message(ERROR "SwiftShader is only useful when Vulkan is enabled.")
-    endif()
-    find_library(SWIFTSHADER_VK NAMES vk_swiftshader HINTS "$ENV{SWIFTSHADER_LD_LIBRARY_PATH}")
-    message(STATUS "Found SwiftShader VK library in: ${SWIFTSHADER_VK}.")
-    add_definitions(-DFILAMENT_VKLIBRARY_PATH=\"${SWIFTSHADER_VK}\")
-endif()
-
 # ==================================================================================================
 # Common Functions
 # ==================================================================================================
@@ -819,6 +800,9 @@ if (IS_HOST_PLATFORM)
     add_subdirectory(${TOOLS}/glslminifier)
     add_subdirectory(${TOOLS}/matc)
     add_subdirectory(${TOOLS}/matinfo)
+    if (NOT WIN32)  # matedit not yet supported on Windows
+        add_subdirectory(${TOOLS}/matedit)
+    endif()
     add_subdirectory(${TOOLS}/mipgen)
     add_subdirectory(${TOOLS}/normal-blending)
     add_subdirectory(${TOOLS}/resgen)

README.md

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

RELEASE_NOTES.md

@@ -7,6 +7,31 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).
 
+## v1.51.9
+
+
+## v1.51.8
+
+- filagui: Fix regression which broke WebGL
+- Add a new Engine::Config setting to control preferred shader language
+- Add `getEyeIndex` vertex API
+- ios: Remove bitcode from iOS builds
+
+## v1.51.7
+
+- Add new matedit tool
+- filagui: Support rendering `GL_TEXTURE_EXTERNAL_OES` textures.
+- `setFrameScheduledCallback` now takes a `utils::Invocable`.
+- engine: Add `isPaused()`
+
+## v1.51.6
+
+- Add new matedit tool
+- filagui: Support rendering `GL_TEXTURE_EXTERNAL_OES` textures.
+
+## v1.51.5
+
+
 ## v1.51.4
 
 

android/filamat-android/CMakeLists.txt

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

android/filament-android/CMakeLists.txt

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

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

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

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

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

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

@@ -225,7 +225,9 @@ public class Engine {
                     config.textureUseAfterFreePoolSize, config.disableParallelShaderCompile,
                     config.stereoscopicType.ordinal(), config.stereoscopicEyeCount,
                     config.resourceAllocatorCacheSizeMB, config.resourceAllocatorCacheMaxAge,
-                    config.disableHandleUseAfterFreeCheck);
+                    config.disableHandleUseAfterFreeCheck,
+                    config.preferredShaderLanguage.ordinal(),
+                    config.forceGLES2Context);
             return this;
         }
 
@@ -428,6 +430,35 @@ public class Engine {
          * Disable backend handles use-after-free checks.
          */
         public boolean disableHandleUseAfterFreeCheck = false;
+
+        /*
+         * Sets a preferred shader language for Filament to use.
+         *
+         * The Metal backend supports two shader languages: MSL (Metal Shading Language) and
+         * METAL_LIBRARY (precompiled .metallib). This option controls which shader language is
+         * used when materials contain both.
+         *
+         * By default, when preferredShaderLanguage is unset, Filament will prefer METAL_LIBRARY
+         * shaders if present within a material, falling back to MSL. Setting
+         * preferredShaderLanguage to ShaderLanguage::MSL will instead instruct Filament to check
+         * for the presence of MSL in a material first, falling back to METAL_LIBRARY if MSL is not
+         * present.
+         *
+         * When using a non-Metal backend, setting this has no effect.
+         */
+        public enum ShaderLanguage {
+            DEFAULT,
+            MSL,
+            METAL_LIBRARY,
+        };
+        public ShaderLanguage preferredShaderLanguage = ShaderLanguage.DEFAULT;
+
+        /*
+         * When the OpenGL ES backend is used, setting this value to true will force a GLES2.0
+         * context if supported by the Platform, or if not, will have the backend pretend
+         * it's a GLES2 context. Ignored on other backends.
+         */
+        public boolean forceGLES2Context = false;
     }
 
     private Engine(long nativeEngine, Config config) {
@@ -849,6 +880,24 @@ public class Engine {
         return nIsValidMaterial(getNativeObject(), object.getNativeObject());
     }
 
+    /**
+     * Returns whether the object is valid.
+     * @param object Object to check for validity
+     * @return returns true if the specified object is valid.
+     */
+    public boolean isValidMaterialInstance(@NonNull Material ma, MaterialInstance mi) {
+        return nIsValidMaterialInstance(getNativeObject(), ma.getNativeObject(), mi.getNativeObject());
+    }
+
+    /**
+     * Returns whether the object is valid.
+     * @param object Object to check for validity
+     * @return returns true if the specified object is valid.
+     */
+    public boolean isValidExpensiveMaterialInstance(@NonNull MaterialInstance object) {
+        return nIsValidExpensiveMaterialInstance(getNativeObject(), object.getNativeObject());
+    }
+
     /**
      * Returns whether the object is valid.
      * @param object Object to check for validity
@@ -1209,6 +1258,17 @@ public class Engine {
         nFlush(getNativeObject());
     }
 
+    /**
+     * Get paused state of rendering thread.
+     *
+     * <p>Warning: This is an experimental API.
+     *
+     * @see #setPaused
+     */
+    public boolean isPaused() {
+        return nIsPaused(getNativeObject());
+    }
+
     /**
      * Pause or resume the rendering thread.
      *
@@ -1291,6 +1351,8 @@ public class Engine {
     private static native boolean nIsValidSkinningBuffer(long nativeEngine, long nativeSkinningBuffer);
     private static native boolean nIsValidIndirectLight(long nativeEngine, long nativeIndirectLight);
     private static native boolean nIsValidMaterial(long nativeEngine, long nativeMaterial);
+    private static native boolean nIsValidMaterialInstance(long nativeEngine, long nativeMaterial, long nativeMaterialInstance);
+    private static native boolean nIsValidExpensiveMaterialInstance(long nativeEngine, long nativeMaterialInstance);
     private static native boolean nIsValidSkybox(long nativeEngine, long nativeSkybox);
     private static native boolean nIsValidColorGrading(long nativeEngine, long nativeColorGrading);
     private static native boolean nIsValidTexture(long nativeEngine, long nativeTexture);
@@ -1299,6 +1361,7 @@ public class Engine {
     private static native void nDestroyEntity(long nativeEngine, int entity);
     private static native void nFlushAndWait(long nativeEngine);
     private static native void nFlush(long nativeEngine);
+    private static native boolean nIsPaused(long nativeEngine);
     private static native void nSetPaused(long nativeEngine, boolean paused);
     private static native long nGetTransformManager(long nativeEngine);
     private static native long nGetLightManager(long nativeEngine);
@@ -1321,7 +1384,9 @@ public class Engine {
             long textureUseAfterFreePoolSize, boolean disableParallelShaderCompile,
             int stereoscopicType, long stereoscopicEyeCount,
             long resourceAllocatorCacheSizeMB, long resourceAllocatorCacheMaxAge,
-            boolean disableHandleUseAfterFreeCheck);
+            boolean disableHandleUseAfterFreeCheck,
+            int preferredShaderLanguage,
+            boolean forceGLES2Context);
     private static native void nSetBuilderFeatureLevel(long nativeBuilder, int ordinal);
     private static native void nSetBuilderSharedContext(long nativeBuilder, long sharedContext);
     private static native void nSetBuilderPaused(long nativeBuilder, boolean paused);

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

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

android/filament-utils-android/CMakeLists.txt

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

android/gltfio-android/CMakeLists.txt

@@ -44,6 +44,7 @@ set_target_properties(uberarchive PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libuberarchive.a)
 
 set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/libgltfio-jni.map")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")
 
 set(GLTFIO_SRCS
         ${GLTFIO_DIR}/include/gltfio/Animator.h
@@ -86,7 +87,10 @@ set(GLTFIO_SRCS
         ${GLTFIO_DIR}/src/Wireframe.cpp
         ${GLTFIO_DIR}/src/Wireframe.h
         ${GLTFIO_DIR}/src/downcast.h
+        ${GLTFIO_DIR}/src/extended/AssetLoaderExtended.cpp
         ${GLTFIO_DIR}/src/extended/AssetLoaderExtended.h
+        ${GLTFIO_DIR}/src/extended/ResourceLoaderExtended.cpp
+        ${GLTFIO_DIR}/src/extended/ResourceLoaderExtended.h
         ${GLTFIO_DIR}/src/extended/TangentsJobExtended.cpp
         ${GLTFIO_DIR}/src/extended/TangentsJobExtended.h
         ${GLTFIO_DIR}/src/extended/TangentSpaceMeshWrapper.cpp

android/gradle.properties

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

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

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

build.sh

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

build/swiftshader/Dockerfile

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

build/swiftshader/gallery.py

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

build/swiftshader/patch_00.diff

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

build/swiftshader/test.sh

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

docs/Filament.html

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

docs/Materials.md.html

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

docs/viewer/index.html

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

filament/CMakeLists.txt

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

filament/backend/CMakeLists.txt

@@ -66,7 +66,7 @@ set(PRIVATE_HDRS
 # OpenGL / OpenGL ES Sources
 # ==================================================================================================
 
-if (FILAMENT_SUPPORTS_OPENGL AND NOT FILAMENT_USE_EXTERNAL_GLES3 AND NOT FILAMENT_USE_SWIFTSHADER)
+if (FILAMENT_SUPPORTS_OPENGL AND NOT FILAMENT_USE_EXTERNAL_GLES3)
     list(APPEND SRCS
             include/backend/platforms/OpenGLPlatform.h
             src/opengl/gl_headers.cpp
@@ -417,6 +417,7 @@ if (APPLE OR LINUX)
         test/test_MissingRequiredAttributes.cpp
         test/test_ReadPixels.cpp
         test/test_BufferUpdates.cpp
+        test/test_Callbacks.cpp
         test/test_MRT.cpp
         test/test_LoadImage.cpp
         test/test_StencilBuffer.cpp
@@ -478,6 +479,10 @@ if (APPLE)
        # linker from removing "unused" symbols.
        target_link_libraries(backend_test_mac PRIVATE -force_load backend_test)
        set_target_properties(backend_test_mac PROPERTIES FOLDER Tests)
+
+       # This is needed after XCode 15.3
+       set_target_properties(backend_test_mac PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
+       set_target_properties(backend_test_mac PROPERTIES INSTALL_RPATH /usr/local/lib)
     endif()
 endif()
 

filament/backend/include/backend/DriverEnums.h

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

filament/backend/include/backend/Handle.h

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

filament/backend/include/backend/Platform.h

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

filament/backend/include/backend/PresentCallable.h

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

filament/backend/include/backend/Program.h

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

filament/backend/include/backend/TargetBufferInfo.h

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

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

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

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

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

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

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

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

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

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

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

filament/backend/src/CommandBufferQueue.cpp

@@ -57,6 +57,11 @@ void CommandBufferQueue::requestExit() {
     mCondition.notify_one();
 }
 
+bool CommandBufferQueue::isPaused() const noexcept {
+    std::lock_guard<utils::Mutex> const lock(mLock);
+    return mPaused;
+}
+
 void CommandBufferQueue::setPaused(bool paused) {
     std::lock_guard<utils::Mutex> const lock(mLock);
     if (paused) {

filament/backend/src/PlatformFactory.cpp

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

filament/backend/src/Program.cpp

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

filament/backend/src/metal/MetalBuffer.h

@@ -18,6 +18,7 @@
 #define TNT_FILAMENT_DRIVER_METALBUFFER_H
 
 #include "MetalContext.h"
+#include "MetalPlatform.h"
 
 #include <backend/DriverEnums.h>
 
@@ -28,47 +29,122 @@
 #include <utility>
 #include <memory>
 #include <atomic>
+#include <chrono>
 
 namespace filament::backend {
 
-class TrackedMetalBuffer {
+class ScopedAllocationTimer {
 public:
-    TrackedMetalBuffer() noexcept : mBuffer(nil) {}
-    TrackedMetalBuffer(id<MTLBuffer> buffer) noexcept : mBuffer(buffer) {
-        if (buffer) {
-            aliveBuffers++;
-        }
-    }
-    ~TrackedMetalBuffer() {
-        if (mBuffer) {
-            aliveBuffers--;
+    ScopedAllocationTimer(const char* name) : mBeginning(clock_t::now()), mName(name) {}
+    ~ScopedAllocationTimer() {
+        using namespace std::literals::chrono_literals;
+        static constexpr std::chrono::seconds LONG_TIME_THRESHOLD = 10s;
+
+        auto end = clock_t::now();
+        std::chrono::duration<double, std::micro> allocationTimeMicroseconds = end - mBeginning;
+
+        if (UTILS_UNLIKELY(allocationTimeMicroseconds > LONG_TIME_THRESHOLD)) {
+            if (platform && platform->hasDebugUpdateStatFunc()) {
+                char buffer[64];
+                snprintf(buffer, sizeof(buffer), "filament.metal.long_buffer_allocation_time.%s",
+                        mName);
+                platform->debugUpdateStat(
+                        buffer, static_cast<uint64_t>(allocationTimeMicroseconds.count()));
+            }
         }
     }
 
-    TrackedMetalBuffer(TrackedMetalBuffer&&) = delete;
-    TrackedMetalBuffer(TrackedMetalBuffer const&) = delete;
-    TrackedMetalBuffer& operator=(TrackedMetalBuffer const&) = delete;
-
-    TrackedMetalBuffer& operator=(TrackedMetalBuffer&& rhs) noexcept {
-        swap(rhs);
-        return *this;
-    }
-
-    id<MTLBuffer> get() const noexcept { return mBuffer; }
-    operator bool() const noexcept { return bool(mBuffer); }
-
-    static uint64_t getAliveBuffers() { return aliveBuffers; }
+    static void setPlatform(MetalPlatform* p) { platform = p; }
 
 private:
-    void swap(TrackedMetalBuffer& other) noexcept {
-        id<MTLBuffer> temp = mBuffer;
-        mBuffer = other.mBuffer;
-        other.mBuffer = temp;
+    typedef std::chrono::steady_clock clock_t;
+
+    static MetalPlatform* platform;
+
+    std::chrono::time_point<clock_t> mBeginning;
+    const char* mName;
+};
+
+#ifndef FILAMENT_METAL_BUFFER_TRACKING
+#define FILAMENT_METAL_BUFFER_TRACKING 0
+#endif
+
+class MetalBufferTracking {
+public:
+    static constexpr size_t EXCESS_BUFFER_COUNT = 30000;
+
+    enum class Type {
+        NONE = 0,
+        GENERIC = 1,
+        RING = 2,
+        STAGING = 3,
+    };
+    static constexpr size_t TypeCount = 3;
+
+    static constexpr auto toIndex(Type t) {
+        assert_invariant(t != Type::NONE);
+        switch (t) {
+            case Type::NONE:
+            case Type::GENERIC:
+                return 0;
+            case Type::RING:
+                return 1;
+            case Type::STAGING:
+                return 2;
+        }
     }
 
-    id<MTLBuffer> mBuffer;
+#if FILAMENT_METAL_BUFFER_TRACKING
+    static void initialize() {
+        static dispatch_once_t onceToken;
+        dispatch_once(&onceToken, ^{
+            for (size_t i = 0; i < TypeCount; i++) {
+                aliveBuffers[i] = [NSHashTable weakObjectsHashTable];
+            }
+        });
+    }
 
-    static std::atomic<uint64_t> aliveBuffers;
+    static void setPlatform(MetalPlatform* p) { platform = p; }
+
+    static void track(id<MTLBuffer> buffer, Type type) {
+        assert_invariant(type != Type::NONE);
+        if (UTILS_UNLIKELY(getAliveBuffers() >= EXCESS_BUFFER_COUNT)) {
+            if (platform && platform->hasDebugUpdateStatFunc()) {
+                platform->debugUpdateStat("filament.metal.excess_buffers_allocated",
+                        MetalBufferTracking::getAliveBuffers());
+            }
+        }
+        [aliveBuffers[toIndex(type)] addObject:buffer];
+    }
+
+    static uint64_t getAliveBuffers() {
+        uint64_t sum = 0;
+        for (size_t i = 1; i < TypeCount; i++) {
+            sum += getAliveBuffers(static_cast<Type>(i));
+        }
+        return sum;
+    }
+
+    static uint64_t getAliveBuffers(Type type) {
+        assert_invariant(type != Type::NONE);
+        NSHashTable* hashTable = aliveBuffers[toIndex(type)];
+        // Caution! We can't simply use hashTable.count here, which is inaccurate.
+        // See http://cocoamine.net/blog/2013/12/13/nsmaptable-and-zeroing-weak-references/
+        return hashTable.objectEnumerator.allObjects.count;
+    }
+#else
+    static void initialize() {}
+    static void setPlatform(MetalPlatform* p) {}
+    static id<MTLBuffer> track(id<MTLBuffer> buffer, Type type) { return buffer; }
+    static uint64_t getAliveBuffers() { return 0; }
+    static uint64_t getAliveBuffers(Type type) { return 0; }
+#endif
+
+private:
+#if FILAMENT_METAL_BUFFER_TRACKING
+    static std::array<NSHashTable<id<MTLBuffer>>*, TypeCount> aliveBuffers;
+    static MetalPlatform* platform;
+#endif
 };
 
 class MetalBuffer {
@@ -122,7 +198,7 @@ public:
 
 private:
 
-    TrackedMetalBuffer mBuffer;
+    id<MTLBuffer> mBuffer;
     size_t mBufferSize = 0;
     void* mCpuBuffer = nullptr;
     MetalContext& mContext;
@@ -171,7 +247,11 @@ public:
           mBufferOptions(options),
           mSlotSizeBytes(computeSlotSize(layout)),
           mSlotCount(slotCount) {
-        mBuffer = [device newBufferWithLength:mSlotSizeBytes * mSlotCount options:mBufferOptions];
+        {
+            ScopedAllocationTimer timer("ring");
+            mBuffer = [device newBufferWithLength:mSlotSizeBytes * mSlotCount options:mBufferOptions];
+        }
+        MetalBufferTracking::track(mBuffer, MetalBufferTracking::Type::RING);
         assert_invariant(mBuffer);
     }
 
@@ -189,9 +269,13 @@ public:
             // If we already have an aux buffer, it will get freed here, unless it has been retained
             // by a MTLCommandBuffer. In that case, it will be freed when the command buffer
             // finishes executing.
-            mAuxBuffer = [mDevice newBufferWithLength:mSlotSizeBytes options:mBufferOptions];
+            {
+                ScopedAllocationTimer timer("ring");
+                mAuxBuffer = [mDevice newBufferWithLength:mSlotSizeBytes options:mBufferOptions];
+            }
+            MetalBufferTracking::track(mAuxBuffer, MetalBufferTracking::Type::RING);
             assert_invariant(mAuxBuffer);
-            return {mAuxBuffer.get(), 0};
+            return { mAuxBuffer, 0 };
         }
         mCurrentSlot = (mCurrentSlot + 1) % mSlotCount;
         mOccupiedSlots->fetch_add(1, std::memory_order_relaxed);
@@ -220,9 +304,9 @@ public:
      */
     std::pair<id<MTLBuffer>, NSUInteger> getCurrentAllocation() const {
         if (UTILS_UNLIKELY(mAuxBuffer)) {
-            return { mAuxBuffer.get(), 0 };
+            return { mAuxBuffer, 0 };
         }
-        return { mBuffer.get(), mCurrentSlot * mSlotSizeBytes };
+        return { mBuffer, mCurrentSlot * mSlotSizeBytes };
     }
 
     bool canAccomodateLayout(MTLSizeAndAlign layout) const {
@@ -231,8 +315,8 @@ public:
 
 private:
     id<MTLDevice> mDevice;
-    TrackedMetalBuffer mBuffer;
-    TrackedMetalBuffer mAuxBuffer;
+    id<MTLBuffer> mBuffer;
+    id<MTLBuffer> mAuxBuffer;
 
     MTLResourceOptions mBufferOptions;
 

filament/backend/src/metal/MetalBuffer.mm

@@ -22,7 +22,13 @@
 namespace filament {
 namespace backend {
 
-std::atomic<uint64_t> TrackedMetalBuffer::aliveBuffers = 0;
+MetalPlatform* ScopedAllocationTimer::platform = nullptr;
+
+#if FILAMENT_METAL_BUFFER_TRACKING
+std::array<NSHashTable<id<MTLBuffer>>*, MetalBufferTracking::TypeCount>
+        MetalBufferTracking::aliveBuffers;
+MetalPlatform* MetalBufferTracking::platform = nullptr;
+#endif
 
 MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType, BufferUsage usage,
         size_t size, bool forceGpuBuffer) : mBufferSize(size), mContext(context) {
@@ -37,7 +43,11 @@ MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType,
     }
 
     // Otherwise, we allocate a private GPU buffer.
-    mBuffer = [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate];
+    {
+        ScopedAllocationTimer timer("generic");
+        mBuffer = [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate];
+    }
+    MetalBufferTracking::track(mBuffer, MetalBufferTracking::Type::GENERIC);
     ASSERT_POSTCONDITION(mBuffer, "Could not allocate Metal buffer of size %zu.", size);
 }
 
@@ -64,7 +74,7 @@ void MetalBuffer::copyIntoBuffer(void* src, size_t size, size_t byteOffset) {
     // Acquire a staging buffer to hold the contents of this update.
     MetalBufferPool* bufferPool = mContext.bufferPool;
     const MetalBufferPoolEntry* const staging = bufferPool->acquireBuffer(size);
-    memcpy(staging->buffer.get().contents, src, size);
+    memcpy(staging->buffer.contents, src, size);
 
     // The blit below requires that byteOffset be a multiple of 4.
     ASSERT_PRECONDITION(!(byteOffset & 0x3u), "byteOffset must be a multiple of 4");
@@ -73,9 +83,9 @@ void MetalBuffer::copyIntoBuffer(void* src, size_t size, size_t byteOffset) {
     id<MTLCommandBuffer> cmdBuffer = getPendingCommandBuffer(&mContext);
     id<MTLBlitCommandEncoder> blitEncoder = [cmdBuffer blitCommandEncoder];
     blitEncoder.label = @"Buffer upload blit";
-    [blitEncoder copyFromBuffer:staging->buffer.get()
+    [blitEncoder copyFromBuffer:staging->buffer
                    sourceOffset:0
-                       toBuffer:mBuffer.get()
+                       toBuffer:mBuffer
               destinationOffset:byteOffset
                            size:size];
     [blitEncoder endEncoding];
@@ -96,7 +106,7 @@ id<MTLBuffer> MetalBuffer::getGpuBufferForDraw(id<MTLCommandBuffer> cmdBuffer) n
         return nil;
     }
     assert_invariant(mBuffer);
-    return mBuffer.get();
+    return mBuffer;
 }
 
 void MetalBuffer::bindBuffers(id<MTLCommandBuffer> cmdBuffer, id<MTLCommandEncoder> encoder,

filament/backend/src/metal/MetalBufferPool.h

@@ -32,7 +32,7 @@ struct MetalContext;
 
 // Immutable POD representing a shared CPU-GPU buffer.
 struct MetalBufferPoolEntry {
-    TrackedMetalBuffer buffer;
+    id<MTLBuffer> buffer;
     size_t capacity;
     mutable uint64_t lastAccessed;
     mutable uint32_t referenceCount;

filament/backend/src/metal/MetalBufferPool.mm

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

filament/backend/src/metal/MetalDriver.mm

@@ -105,6 +105,10 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
                   driverConfig.disableHandleUseAfterFreeCheck) {
     mContext->driver = this;
 
+    ScopedAllocationTimer::setPlatform(platform);
+    MetalBufferTracking::initialize();
+    MetalBufferTracking::setPlatform(platform);
+
     mContext->device = mPlatform.createDevice();
     assert_invariant(mContext->device);
 
@@ -198,6 +202,8 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
 }
 
 MetalDriver::~MetalDriver() noexcept {
+    MetalBufferTracking::setPlatform(nullptr);
+    ScopedAllocationTimer::setPlatform(nullptr);
     mContext->device = nil;
     mContext->emptyTexture = nil;
     CFRelease(mContext->textureCache);
@@ -212,25 +218,35 @@ void MetalDriver::tick(int) {
     executeTickOps();
 }
 
-void MetalDriver::beginFrame(int64_t monotonic_clock_ns, uint32_t frameId) {
+void MetalDriver::beginFrame(int64_t monotonic_clock_ns,
+        int64_t refreshIntervalNs, uint32_t frameId) {
 #if defined(FILAMENT_METAL_PROFILING)
     os_signpost_interval_begin(mContext->log, mContext->signpostId, "Frame encoding", "%{public}d", frameId);
 #endif
     if (mPlatform.hasDebugUpdateStatFunc()) {
-        mPlatform.debugUpdateStat("filament.metal.alive_buffers", TrackedMetalBuffer::getAliveBuffers());
+#if FILAMENT_METAL_BUFFER_TRACKING
+        const uint64_t generic = MetalBufferTracking::getAliveBuffers(MetalBufferTracking::Type::GENERIC);
+        const uint64_t ring = MetalBufferTracking::getAliveBuffers(MetalBufferTracking::Type::RING);
+        const uint64_t staging = MetalBufferTracking::getAliveBuffers(MetalBufferTracking::Type::STAGING);
+        const uint64_t total = generic + ring + staging;
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers", total);
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers.generic", generic);
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers.ring", ring);
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers.staging", staging);
+#endif
     }
 }
 
-void MetalDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
-        FrameScheduledCallback callback, void* user) {
+void MetalDriver::setFrameScheduledCallback(
+        Handle<HwSwapChain> sch, CallbackHandler* handler, FrameScheduledCallback&& callback) {
     auto* swapChain = handle_cast<MetalSwapChain>(sch);
-    swapChain->setFrameScheduledCallback(callback, user);
+    swapChain->setFrameScheduledCallback(handler, std::move(callback));
 }
 
-void MetalDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
+void MetalDriver::setFrameCompletedCallback(
+        Handle<HwSwapChain> sch, CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
     auto* swapChain = handle_cast<MetalSwapChain>(sch);
-    swapChain->setFrameCompletedCallback(handler, callback, user);
+    swapChain->setFrameCompletedCallback(handler, std::move(callback));
 }
 
 void MetalDriver::execute(std::function<void(void)> const& fn) noexcept {
@@ -805,6 +821,10 @@ bool MetalDriver::isDepthStencilResolveSupported() {
     return false;
 }
 
+bool MetalDriver::isDepthStencilBlitSupported(TextureFormat format) {
+    return true;
+}
+
 bool MetalDriver::isProtectedTexturesSupported() {
     return false;
 }
@@ -1236,6 +1256,9 @@ void MetalDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
     mContext->samplerBindings[index] = sb;
 }
 
+void MetalDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
+        backend::PushConstantVariant value) {}
+
 void MetalDriver::insertEventMarker(const char* string, uint32_t len) {
 
 }
@@ -1614,7 +1637,7 @@ void MetalDriver::finalizeSamplerGroup(MetalSamplerGroup* samplerGroup) {
     }
 }
 
-void MetalDriver::bindPipeline(PipelineState ps) {
+void MetalDriver::bindPipeline(PipelineState const& ps) {
     ASSERT_PRECONDITION(mContext->currentRenderPassEncoder != nullptr,
             "bindPipeline() without a valid command encoder.");
 

filament/backend/src/metal/MetalHandles.h

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

filament/backend/src/metal/MetalHandles.mm

@@ -221,16 +221,16 @@ void MetalSwapChain::ensureDepthStencilTexture() {
     depthStencilTexture = [context.device newTextureWithDescriptor:descriptor];
 }
 
-void MetalSwapChain::setFrameScheduledCallback(FrameScheduledCallback callback, void* user) {
-    frameScheduledCallback = callback;
-    frameScheduledUserData = user;
+void MetalSwapChain::setFrameScheduledCallback(
+        CallbackHandler* handler, FrameScheduledCallback&& callback) {
+    frameScheduled.handler = handler;
+    frameScheduled.callback = std::make_shared<FrameScheduledCallback>(std::move(callback));
 }
 
-void MetalSwapChain::setFrameCompletedCallback(CallbackHandler* handler,
-        CallbackHandler::Callback callback, void* user) {
+void MetalSwapChain::setFrameCompletedCallback(
+        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
     frameCompleted.handler = handler;
-    frameCompleted.callback = callback;
-    frameCompleted.user = user;
+    frameCompleted.callback = std::make_shared<utils::Invocable<void(void)>>(std::move(callback));
 }
 
 void MetalSwapChain::present() {
@@ -238,7 +238,7 @@ void MetalSwapChain::present() {
         scheduleFrameCompletedCallback();
     }
     if (drawable) {
-        if (frameScheduledCallback) {
+        if (frameScheduled.callback) {
             scheduleFrameScheduledCallback();
         } else  {
             [getPendingCommandBuffer(&context) presentDrawable:drawable];
@@ -296,21 +296,38 @@ void presentDrawable(bool presentFrame, void* user) {
 }
 
 void MetalSwapChain::scheduleFrameScheduledCallback() {
-    if (!frameScheduledCallback) {
+    if (!frameScheduled.callback) {
         return;
     }
 
     assert_invariant(drawable);
 
-    // Destroy this by calling maybePresentAndDestroyAsync() later.
-    auto* presentData = PresentDrawableData::create(drawable, context.driver);
+    struct Callback {
+        Callback(std::shared_ptr<FrameScheduledCallback> callback, id<CAMetalDrawable> drawable,
+                MetalDriver* driver)
+            : f(callback), data(PresentDrawableData::create(drawable, driver)) {}
+        std::shared_ptr<FrameScheduledCallback> f;
+        // PresentDrawableData* is destroyed by maybePresentAndDestroyAsync() later.
+        std::unique_ptr<PresentDrawableData> data;
+        static void func(void* user) {
+            auto* const c = reinterpret_cast<Callback*>(user);
+            PresentDrawableData* presentDrawableData = c->data.release();
+            PresentCallable presentCallable(presentDrawable, presentDrawableData);
+            c->f->operator()(presentCallable);
+            delete c;
+        }
+    };
 
-    FrameScheduledCallback userCallback = frameScheduledCallback;
-    void* userData = frameScheduledUserData;
+    // This callback pointer will be captured by the block. Even if the scheduled handler is never
+    // called, the unique_ptr will still ensure we don't leak memory.
+    __block auto callback =
+            std::make_unique<Callback>(frameScheduled.callback, drawable, context.driver);
 
+    backend::CallbackHandler* handler = frameScheduled.handler;
+    MetalDriver* driver = context.driver;
     [getPendingCommandBuffer(&context) addScheduledHandler:^(id<MTLCommandBuffer> cb) {
-        PresentCallable callable(presentDrawable, static_cast<void*>(presentData));
-        userCallback(callable, userData);
+        Callback* user = callback.release();
+        driver->scheduleCallback(handler, user, &Callback::func);
     }];
 }
 
@@ -319,13 +336,25 @@ void MetalSwapChain::scheduleFrameCompletedCallback() {
         return;
     }
 
-    CallbackHandler* handler = frameCompleted.handler;
-    void* user = frameCompleted.user;
-    CallbackHandler::Callback callback = frameCompleted.callback;
+    struct Callback {
+        Callback(std::shared_ptr<utils::Invocable<void(void)>> callback) : f(callback) {}
+        std::shared_ptr<utils::Invocable<void(void)>> f;
+        static void func(void* user) {
+            auto* const c = reinterpret_cast<Callback*>(user);
+            c->f->operator()();
+            delete c;
+        }
+    };
 
+    // This callback pointer will be captured by the block. Even if the completed handler is never
+    // called, the unique_ptr will still ensure we don't leak memory.
+    __block auto callback = std::make_unique<Callback>(frameCompleted.callback);
+
+    CallbackHandler* handler = frameCompleted.handler;
     MetalDriver* driver = context.driver;
     [getPendingCommandBuffer(&context) addCompletedHandler:^(id<MTLCommandBuffer> cb) {
-        driver->scheduleCallback(handler, user, callback);
+        Callback* user = callback.release();
+        driver->scheduleCallback(handler, user, &Callback::func);
     }];
 }
 
@@ -771,13 +800,13 @@ void MetalTexture::loadWithCopyBuffer(uint32_t level, uint32_t slice, MTLRegion
         PixelBufferDescriptor const& data, const PixelBufferShape& shape) {
     const size_t stagingBufferSize = shape.totalBytes;
     auto entry = context.bufferPool->acquireBuffer(stagingBufferSize);
-    memcpy(entry->buffer.get().contents,
+    memcpy(entry->buffer.contents,
             static_cast<uint8_t*>(data.buffer) + shape.sourceOffset,
             stagingBufferSize);
     id<MTLCommandBuffer> blitCommandBuffer = getPendingCommandBuffer(&context);
     id<MTLBlitCommandEncoder> blitCommandEncoder = [blitCommandBuffer blitCommandEncoder];
     blitCommandEncoder.label = @"Texture upload buffer blit";
-    [blitCommandEncoder copyFromBuffer:entry->buffer.get()
+    [blitCommandEncoder copyFromBuffer:entry->buffer
                           sourceOffset:0
                      sourceBytesPerRow:shape.bytesPerRow
                    sourceBytesPerImage:shape.bytesPerSlice

filament/backend/src/metal/MetalShaderCompiler.mm

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

filament/backend/src/noop/NoopDriver.cpp

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

filament/backend/src/opengl/GLTexture.h

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

filament/backend/src/opengl/OpenGLContext.cpp

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

filament/backend/src/opengl/OpenGLContext.h

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

filament/backend/src/opengl/OpenGLDriver.cpp

@@ -173,6 +173,10 @@ Driver* OpenGLDriver::create(OpenGLPlatform* const platform,
         PANIC_LOG("OpenGL ES 2.0 minimum needed (current %d.%d)", major, minor);
         goto cleanup;
     }
+    if (UTILS_UNLIKELY(driverConfig.forceGLES2Context)) {
+        major = 2;
+        minor = 0;
+    }
 #else
     // we require GL 4.1 headers and minimum version
     if (UTILS_UNLIKELY(!((major == 4 && minor >= 1) || major > 4))) {
@@ -203,12 +207,13 @@ OpenGLDriver::DebugMarker::~DebugMarker() noexcept {
 
 OpenGLDriver::OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfig& driverConfig) noexcept
         : mPlatform(*platform),
-          mContext(mPlatform),
+          mContext(mPlatform, driverConfig),
           mShaderCompilerService(*this),
           mHandleAllocator("Handles",
                   driverConfig.handleArenaSize,
                   driverConfig.disableHandleUseAfterFreeCheck),
-          mDriverConfig(driverConfig) {
+          mDriverConfig(driverConfig),
+          mCurrentPushConstants(new(std::nothrow) PushConstantBundle{}) {
 
     std::fill(mSamplerBindings.begin(), mSamplerBindings.end(), nullptr);
 
@@ -232,10 +237,19 @@ OpenGLDriver::OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfi
 }
 
 OpenGLDriver::~OpenGLDriver() noexcept { // NOLINT(modernize-use-equals-default)
+    // this is called from the main thread. Can't call GL.
 }
 
 Dispatcher OpenGLDriver::getDispatcher() const noexcept {
-    return ConcreteDispatcher<OpenGLDriver>::make();
+    auto dispatcher = ConcreteDispatcher<OpenGLDriver>::make();
+    if (mContext.isES2()) {
+        dispatcher.draw2_ = +[](Driver& driver, CommandBase* base, intptr_t* next){
+            using Cmd = COMMAND_TYPE(draw2);
+            OpenGLDriver& concreteDriver = static_cast<OpenGLDriver&>(driver);
+            Cmd::execute(&OpenGLDriver::draw2GLES2, concreteDriver, base, next);
+        };
+    }
+    return dispatcher;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -264,6 +278,11 @@ void OpenGLDriver::terminate() {
     assert_invariant(mGpuCommandCompleteOps.empty());
 #endif
 
+    delete mCurrentPushConstants;
+    mCurrentPushConstants = nullptr;
+
+    mContext.terminate();
+
     mPlatform.terminate();
 }
 
@@ -282,9 +301,42 @@ void OpenGLDriver::bindSampler(GLuint unit, GLuint sampler) noexcept {
     mContext.bindSampler(unit, sampler);
 }
 
+void OpenGLDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
+        backend::PushConstantVariant value) {
+    assert_invariant(stage == ShaderStage::VERTEX || stage == ShaderStage::FRAGMENT);
+    utils::Slice<std::pair<GLint, ConstantType>> constants;
+    if (stage == ShaderStage::VERTEX) {
+        constants = mCurrentPushConstants->vertexConstants;
+    } else if (stage == ShaderStage::FRAGMENT) {
+        constants = mCurrentPushConstants->fragmentConstants;
+    }
+
+    assert_invariant(index < constants.size());
+    auto const& [location, type] = constants[index];
+
+    // This push constant wasn't found in the shader. It's ok to return without error-ing here.
+    if (location < 0) {
+        return;
+    }
+
+    if (std::holds_alternative<bool>(value)) {
+        assert_invariant(type == ConstantType::BOOL);
+        bool const bval = std::get<bool>(value);
+        glUniform1i(location, bval ? 1 : 0);
+    } else if (std::holds_alternative<float>(value)) {
+        assert_invariant(type == ConstantType::FLOAT);
+        float const fval = std::get<float>(value);
+        glUniform1f(location, fval);
+    } else {
+        assert_invariant(type == ConstantType::INT);
+        int const ival = std::get<int>(value);
+        glUniform1i(location, ival);
+    }
+}
+
 void OpenGLDriver::bindTexture(GLuint unit, GLTexture const* t) noexcept {
     assert_invariant(t != nullptr);
-    mContext.bindTexture(unit, t->gl.target, t->gl.id, t->gl.targetIndex);
+    mContext.bindTexture(unit, t->gl.target, t->gl.id);
 }
 
 bool OpenGLDriver::useProgram(OpenGLProgram* p) noexcept {
@@ -746,7 +798,6 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
             if (t->externalTexture) {
                 t->gl.target = t->externalTexture->target;
                 t->gl.id = t->externalTexture->id;
-                t->gl.targetIndex = (uint8_t)OpenGLContext::getIndexForTextureTarget(t->gl.target);
                 // internalFormat actually depends on the external image, but it doesn't matter
                 // because it's not used anywhere for anything important.
                 t->gl.internalFormat = internalFormat;
@@ -758,30 +809,23 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
 
             t->gl.internalFormat = internalFormat;
 
-            // We DO NOT update targetIndex at function exit to take advantage of the fact that
-            // getIndexForTextureTarget() is constexpr -- so all of this disappears at compile time.
             switch (target) {
                 case SamplerType::SAMPLER_EXTERNAL:
                     // we can't be here -- doesn't matter what we do
                 case SamplerType::SAMPLER_2D:
                     t->gl.target = GL_TEXTURE_2D;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D);
                     break;
                 case SamplerType::SAMPLER_3D:
                     t->gl.target = GL_TEXTURE_3D;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_3D);
                     break;
                 case SamplerType::SAMPLER_2D_ARRAY:
                     t->gl.target = GL_TEXTURE_2D_ARRAY;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_ARRAY);
                     break;
                 case SamplerType::SAMPLER_CUBEMAP:
                     t->gl.target = GL_TEXTURE_CUBE_MAP;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP);
                     break;
                 case SamplerType::SAMPLER_CUBEMAP_ARRAY:
                     t->gl.target = GL_TEXTURE_CUBE_MAP_ARRAY;
-                    t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP_ARRAY);
                     break;
             }
 
@@ -792,8 +836,6 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
                 if (gl.features.multisample_texture) {
                     // multi-sample texture on GL 3.2 / GLES 3.1 and above
                     t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
-                    t->gl.targetIndex = (uint8_t)
-                            OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_MULTISAMPLE);
                 } else {
                     // Turn off multi-sampling for that texture. It's just not supported.
                 }
@@ -852,32 +894,24 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
     t->gl.internalFormat = getInternalFormat(format);
     assert_invariant(t->gl.internalFormat);
 
-    // We DO NOT update targetIndex at function exit to take advantage of the fact that
-    // getIndexForTextureTarget() is constexpr -- so all of this disappears at compile time.
     switch (target) {
         case SamplerType::SAMPLER_EXTERNAL:
             t->gl.target = GL_TEXTURE_EXTERNAL_OES;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_EXTERNAL_OES);
             break;
         case SamplerType::SAMPLER_2D:
             t->gl.target = GL_TEXTURE_2D;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D);
             break;
         case SamplerType::SAMPLER_3D:
             t->gl.target = GL_TEXTURE_3D;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_3D);
             break;
         case SamplerType::SAMPLER_2D_ARRAY:
             t->gl.target = GL_TEXTURE_2D_ARRAY;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_ARRAY);
             break;
         case SamplerType::SAMPLER_CUBEMAP:
             t->gl.target = GL_TEXTURE_CUBE_MAP;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP);
             break;
         case SamplerType::SAMPLER_CUBEMAP_ARRAY:
             t->gl.target = GL_TEXTURE_CUBE_MAP_ARRAY;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_CUBE_MAP_ARRAY);
             break;
     }
 
@@ -888,7 +922,6 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
         if (gl.features.multisample_texture) {
             // multi-sample texture on GL 3.2 / GLES 3.1 and above
             t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
-            t->gl.targetIndex = OpenGLContext::getIndexForTextureTarget(GL_TEXTURE_2D_MULTISAMPLE);
         } else {
             // Turn off multi-sampling for that texture. It's just not supported.
         }
@@ -899,16 +932,18 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
 }
 
 void OpenGLDriver::updateVertexArrayObject(GLRenderPrimitive* rp, GLVertexBuffer const* vb) {
-    // NOTE: this is called from draw() and must be as efficient as possible.
+    // NOTE: this is called often and must be as efficient as possible.
 
     auto& gl = mContext;
 
+#ifndef NDEBUG
     if (UTILS_LIKELY(gl.ext.OES_vertex_array_object)) {
         // The VAO for the given render primitive must already be bound.
         GLint vaoBinding;
         glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &vaoBinding);
         assert_invariant(vaoBinding == (GLint)rp->gl.vao[gl.contextIndex]);
     }
+#endif
 
     if (UTILS_LIKELY(rp->gl.vertexBufferVersion == vb->bufferObjectsVersion &&
                      rp->gl.stateVersion == gl.state.age)) {
@@ -924,7 +959,7 @@ void OpenGLDriver::updateVertexArrayObject(GLRenderPrimitive* rp, GLVertexBuffer
             // if a buffer is defined it must not be invalid.
             assert_invariant(vb->gl.buffers[bi]);
 
-            // if w're on ES2, the user shouldn't use FLAG_INTEGER_TARGET
+            // if we're on ES2, the user shouldn't use FLAG_INTEGER_TARGET
             assert_invariant(!(gl.isES2() && (attribute.flags & Attribute::FLAG_INTEGER_TARGET)));
 
             gl.bindBuffer(GL_ARRAY_BUFFER, vb->gl.buffers[bi]);
@@ -1778,7 +1813,6 @@ void OpenGLDriver::updateStreams(DriverApi* driver) {
                         // the target and id can be reset each time
                         t->gl.target = t->externalTexture->target;
                         t->gl.id = t->externalTexture->id;
-                        t->gl.targetIndex = (uint8_t)OpenGLContext::getIndexForTextureTarget(t->gl.target);
                         bindTexture(OpenGLContext::DUMMY_TEXTURE_BINDING, t);
                     }
                 }
@@ -2040,6 +2074,10 @@ bool OpenGLDriver::isDepthStencilResolveSupported() {
     return true;
 }
 
+bool OpenGLDriver::isDepthStencilBlitSupported(TextureFormat format) {
+    return true;
+}
+
 bool OpenGLDriver::isProtectedTexturesSupported() {
     return getContext().ext.EXT_protected_textures;
 }
@@ -2056,8 +2094,6 @@ bool OpenGLDriver::isWorkaroundNeeded(Workaround workaround) {
             return mContext.bugs.disable_blit_into_texture_array;
         case Workaround::POWER_VR_SHADER_WORKAROUNDS:
             return mContext.bugs.powervr_shader_workarounds;
-        case Workaround::DISABLE_THREAD_AFFINITY:
-            return mContext.bugs.disable_thread_affinity;
         default:
             return false;
     }
@@ -2666,7 +2702,6 @@ void OpenGLDriver::setExternalImage(Handle<HwTexture> th, void* image) {
         // the target and id can be reset each time
         t->gl.target = t->externalTexture->target;
         t->gl.id = t->externalTexture->id;
-        t->gl.targetIndex = (uint8_t)OpenGLContext::getIndexForTextureTarget(t->gl.target);
         bindTexture(OpenGLContext::DUMMY_TEXTURE_BINDING, t);
     }
 }
@@ -3398,17 +3433,21 @@ void OpenGLDriver::executeGpuCommandsCompleteOps() noexcept {
 
 void OpenGLDriver::tick(int) {
     DEBUG_MARKER()
+#ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
     executeGpuCommandsCompleteOps();
+#endif
     executeEveryNowAndThenOps();
     getShaderCompilerService().tick();
 }
 
 void OpenGLDriver::beginFrame(
         UTILS_UNUSED int64_t monotonic_clock_ns,
+        UTILS_UNUSED int64_t refreshIntervalNs,
         UTILS_UNUSED uint32_t frameId) {
     DEBUG_MARKER()
     auto& gl = mContext;
     insertEventMarker("beginFrame");
+    mPlatform.beginFrame(monotonic_clock_ns, refreshIntervalNs, frameId);
     if (UTILS_UNLIKELY(!mTexturesWithStreamsAttached.empty())) {
         OpenGLPlatform& platform = mPlatform;
         for (GLTexture const* t : mTexturesWithStreamsAttached) {
@@ -3417,7 +3456,7 @@ void OpenGLDriver::beginFrame(
                 assert_invariant(t->hwStream->stream);
                 platform.updateTexImage(t->hwStream->stream,
                         &static_cast<GLStream*>(t->hwStream)->user_thread.timestamp); // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
-                // NOTE: We assume that updateTexImage() binds the texture on our behalf
+                // NOTE: We assume that OpenGLPlatform::updateTexImage() binds the texture on our behalf
                 gl.updateTexImage(GL_TEXTURE_EXTERNAL_OES, t->gl.id);
             }
         }
@@ -3425,12 +3464,12 @@ void OpenGLDriver::beginFrame(
 }
 
 void OpenGLDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
-        FrameScheduledCallback callback, void* user) {
+        CallbackHandler* handler, FrameScheduledCallback&& callback) {
     DEBUG_MARKER()
 }
 
 void OpenGLDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
+        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
     DEBUG_MARKER()
 }
 
@@ -3456,6 +3495,7 @@ void OpenGLDriver::endFrame(UTILS_UNUSED uint32_t frameId) {
 #endif
     //SYSTRACE_NAME("glFinish");
     //glFinish();
+    mPlatform.endFrame(frameId);
     insertEventMarker("endFrame");
 }
 
@@ -3667,7 +3707,7 @@ void OpenGLDriver::blit(
         case SamplerType::SAMPLER_EXTERNAL:
             break;
     }
-    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)
 
     gl.bindFramebuffer(GL_READ_FRAMEBUFFER, fbo[1]);
     switch (s->target) {
@@ -3693,7 +3733,7 @@ void OpenGLDriver::blit(
         case SamplerType::SAMPLER_EXTERNAL:
             break;
     }
-    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)
 
     gl.disable(GL_SCISSOR_TEST);
     glBlitFramebuffer(
@@ -3807,7 +3847,7 @@ void OpenGLDriver::updateTextureLodRange(GLTexture* texture, int8_t targetLevel)
 #endif
 }
 
-void OpenGLDriver::bindPipeline(PipelineState state) {
+void OpenGLDriver::bindPipeline(PipelineState const& state) {
     DEBUG_MARKER()
     auto& gl = mContext;
     setRasterState(state.rasterState);
@@ -3815,6 +3855,7 @@ void OpenGLDriver::bindPipeline(PipelineState state) {
     gl.polygonOffset(state.polygonOffset.slope, state.polygonOffset.constant);
     OpenGLProgram* const p = handle_cast<OpenGLProgram*>(state.program);
     mValidProgram = useProgram(p);
+    (*mCurrentPushConstants) = p->getPushConstants();
 }
 
 void OpenGLDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
@@ -3844,20 +3885,35 @@ void OpenGLDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
         return;
     }
 
-    if (UTILS_LIKELY(instanceCount <= 1)) {
-        glDrawElements(GLenum(rp->type), (GLsizei)indexCount, rp->gl.getIndicesType(),
-                reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize));
-    } else {
-        assert_invariant(!mContext.isES2());
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
-        glDrawElementsInstanced(GLenum(rp->type), (GLsizei)indexCount,
-                rp->gl.getIndicesType(),
-                reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize),
-                (GLsizei)instanceCount);
+    assert_invariant(!mContext.isES2());
+    glDrawElementsInstanced(GLenum(rp->type), (GLsizei)indexCount,
+            rp->gl.getIndicesType(),
+            reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize),
+            (GLsizei)instanceCount);
 #endif
+
+#if FILAMENT_ENABLE_MATDBG
+    CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
+#else
+    CHECK_GL_ERROR(utils::slog.e)
+#endif
+}
+
+void OpenGLDriver::draw2GLES2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
+    GLRenderPrimitive const* const rp = mBoundRenderPrimitive;
+    if (UTILS_UNLIKELY(!rp || !mValidProgram)) {
+        return;
     }
 
-#ifdef FILAMENT_ENABLE_MATDBG
+    assert_invariant(mContext.isES2());
+    assert_invariant(instanceCount == 1);
+
+    glDrawElements(GLenum(rp->type), (GLsizei)indexCount, rp->gl.getIndicesType(),
+            reinterpret_cast<const void*>(indexOffset * rp->gl.indicesSize));
+
+
+#if FILAMENT_ENABLE_MATDBG
     CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
 #else
     CHECK_GL_ERROR(utils::slog.e)
@@ -3876,7 +3932,11 @@ void OpenGLDriver::draw(PipelineState state, Handle<HwRenderPrimitive> rph,
     state.vertexBufferInfo = rp->vbih;
     bindPipeline(state);
     bindRenderPrimitive(rph);
-    draw2(indexOffset, indexCount, instanceCount);
+    if (UTILS_UNLIKELY(mContext.isES2())) {
+        draw2GLES2(indexOffset, indexCount, instanceCount);
+    } else {
+        draw2(indexOffset, indexCount, instanceCount);
+    }
 }
 
 void OpenGLDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGroupCount) {
@@ -3903,7 +3963,7 @@ void OpenGLDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGr
     glDispatchCompute(workGroupCount.x, workGroupCount.y, workGroupCount.z);
 #endif // BACKEND_OPENGL_LEVEL_GLES31
 
-#ifdef FILAMENT_ENABLE_MATDBG
+#if FILAMENT_ENABLE_MATDBG
     CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
 #else
     CHECK_GL_ERROR(utils::slog.e)

filament/backend/src/opengl/OpenGLDriver.h

@@ -66,9 +66,9 @@ namespace filament::backend {
 class OpenGLPlatform;
 class PixelBufferDescriptor;
 struct TargetBufferInfo;
-
 class OpenGLProgram;
 class TimerQueryFactoryInterface;
+struct PushConstantBundle;
 
 class OpenGLDriver final : public DriverBase {
     inline explicit OpenGLDriver(OpenGLPlatform* platform,
@@ -336,6 +336,8 @@ 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;
 
@@ -375,6 +377,8 @@ private:
     // for ES2 sRGB support
     GLSwapChain* mCurrentDrawSwapChain = nullptr;
     bool mRec709OutputColorspace = false;
+
+    PushConstantBundle* mCurrentPushConstants = nullptr;
 };
 
 // ------------------------------------------------------------------------------------------------

filament/backend/src/opengl/OpenGLPlatform.cpp

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

filament/backend/src/opengl/OpenGLProgram.cpp

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

filament/backend/src/opengl/OpenGLProgram.h

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

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

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

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

@@ -25,6 +25,8 @@
 #include <android/api-level.h>
 #include <android/hardware_buffer.h>
 
+#include <utils/android/PerformanceHintManager.h>
+
 #include <utils/compiler.h>
 #include <utils/ostream.h>
 #include <utils/Log.h>
@@ -36,8 +38,11 @@
 
 #include <jni.h>
 
+#include <chrono>
 #include <new>
 
+#include <unistd.h>
+
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -112,8 +117,38 @@ void PlatformEGLAndroid::terminate() noexcept {
     PlatformEGL::terminate();
 }
 
+void PlatformEGLAndroid::beginFrame(
+        int64_t monotonic_clock_ns,
+        int64_t refreshIntervalNs,
+        uint32_t frameId) noexcept {
+    if (mPerformanceHintSession.isValid()) {
+        if (refreshIntervalNs <= 0) {
+            // we're not provided with a target time, assume 16.67ms
+            refreshIntervalNs = 16'666'667;
+        }
+        mStartTimeOfActualWork = clock::time_point(std::chrono::nanoseconds(monotonic_clock_ns));
+        mPerformanceHintSession.updateTargetWorkDuration(refreshIntervalNs);
+    }
+    PlatformEGL::beginFrame(monotonic_clock_ns, refreshIntervalNs, frameId);
+}
+
+void backend::PlatformEGLAndroid::preCommit() noexcept {
+    if (mPerformanceHintSession.isValid()) {
+        auto const actualWorkDuration = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                clock::now() - mStartTimeOfActualWork);
+        mPerformanceHintSession.reportActualWorkDuration(actualWorkDuration.count());
+    }
+    PlatformEGL::preCommit();
+}
+
 Driver* PlatformEGLAndroid::createDriver(void* sharedContext,
         const Platform::DriverConfig& driverConfig) noexcept {
+
+    // the refresh rate default value doesn't matter, we change it later
+    int32_t const tid = gettid();
+    mPerformanceHintSession = PerformanceHintManager::Session{
+            mPerformanceHintManager, &tid, 1, 16'666'667 };
+
     Driver* driver = PlatformEGL::createDriver(sharedContext, driverConfig);
     auto extensions = GLUtils::split(eglQueryString(mEGLDisplay, EGL_EXTENSIONS));
 

filament/backend/src/ostream.cpp

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

filament/backend/src/vulkan/VulkanBlitter.cpp

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

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

filament/backend/src/vulkan/VulkanBuffer.h

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

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,18 +75,14 @@
 #define FVK_DEBUG_PERFORMANCE     \
     FVK_DEBUG_SYSTRACE
 
-#define FVK_DEBUG_CORRECTNESS     \
-    FVK_DEBUG_VALIDATION |        \
-    FVK_DEBUG_SHADER_MODULE |     \
-    FVK_DEBUG_TEXTURE |           \
-    FVK_DEBUG_LAYOUT_TRANSITION
-
-#define FVK_DEBUG_RENDER_PASSES   \
-    FVK_DEBUG_GROUP_MARKERS |     \
-    FVK_DEBUG_PRINT_GROUP_MARKERS
+#if defined(FILAMENT_BACKEND_DEBUG_FLAG)
+#define FVK_DEBUG_FORWARDED_FLAG (FILAMENT_BACKEND_DEBUG_FLAG & FVK_DEBUG_EVERYTHING)
+#else
+#define FVK_DEBUG_FORWARDED_FLAG 0
+#endif
 
 #ifndef NDEBUG
-#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE)
+#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE | FVK_DEBUG_FORWARDED_FLAG)
 #else
 #define FVK_DEBUG_FLAGS 0
 #endif
@@ -112,7 +108,7 @@ static_assert(FVK_ENABLED(FVK_DEBUG_VALIDATION));
 // end dependcy checks
 
 // Shorthand for combination of enabled debug flags
-#if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS) || FVK_ENABLED(FVK_DEBUG_TEXTURE)
+#if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS) && FVK_ENABLED(FVK_DEBUG_TEXTURE)
 #define FVK_ENABLED_DEBUG_SAMPLER_NAME 1
 #else
 #define FVK_ENABLED_DEBUG_SAMPLER_NAME 0

filament/backend/src/vulkan/VulkanContext.cpp

@@ -57,15 +57,19 @@ VkExtent2D VulkanAttachment::getExtent2D() const {
     return { std::max(1u, texture->width >> level), std::max(1u, texture->height >> level) };
 }
 
-VkImageView VulkanAttachment::getImageView(VkImageAspectFlags aspect) {
+VkImageView VulkanAttachment::getImageView() {
     assert_invariant(texture);
-    return texture->getAttachmentView(getSubresourceRange(aspect));
+    return texture->getAttachmentView(getSubresourceRange());
 }
 
-VkImageSubresourceRange VulkanAttachment::getSubresourceRange(VkImageAspectFlags aspect) const {
+bool VulkanAttachment::isDepth() const {
+    return texture->getImageAspect() & VK_IMAGE_ASPECT_DEPTH_BIT;
+}
+
+VkImageSubresourceRange VulkanAttachment::getSubresourceRange() const {
     assert_invariant(texture);
     return {
-            .aspectMask = aspect,
+            .aspectMask = texture->getImageAspect(),
             .baseMipLevel = uint32_t(level),
             .levelCount = 1,
             .baseArrayLayer = uint32_t(layer),

filament/backend/src/vulkan/VulkanContext.h

@@ -44,13 +44,15 @@ struct VulkanAttachment {
     VulkanTexture* texture = nullptr;
     uint8_t level = 0;
     uint16_t layer = 0;
+
+    bool isDepth() const;
     VkImage getImage() const;
     VkFormat getFormat() const;
     VulkanLayout getLayout() const;
     VkExtent2D getExtent2D() const;
-    VkImageView getImageView(VkImageAspectFlags aspect);
+    VkImageView getImageView();
     // TODO: maybe embed aspect into the attachment or texture itself.
-    VkImageSubresourceRange getSubresourceRange(VkImageAspectFlags aspect) const;
+    VkImageSubresourceRange getSubresourceRange() const;
 };
 
 class VulkanTimestamps {
@@ -101,8 +103,12 @@ public:
         return (uint32_t) VK_MAX_MEMORY_TYPES;
     }
 
-    inline VkFormatList const& getAttachmentDepthFormats() const {
-        return mDepthFormats;
+    inline VkFormatList const& getAttachmentDepthStencilFormats() const {
+        return mDepthStencilFormats;
+    }
+
+    inline VkFormatList const& getBlittableDepthStencilFormats() const {
+        return mBlittableDepthStencilFormats;
     }
 
     inline VkPhysicalDeviceLimits const& getPhysicalDeviceLimits() const noexcept {
@@ -131,7 +137,8 @@ private:
     bool mDebugMarkersSupported = false;
     bool mDebugUtilsSupported = false;
 
-    VkFormatList mDepthFormats;
+    VkFormatList mDepthStencilFormats;
+    VkFormatList mBlittableDepthStencilFormats;
 
     // For convenience so that VulkanPlatform can initialize the private fields.
     friend class VulkanPlatform;

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -22,7 +22,6 @@
 #include "VulkanCommands.h"
 #include "VulkanDriverFactory.h"
 #include "VulkanHandles.h"
-#include "VulkanImageUtility.h"
 #include "VulkanMemory.h"
 #include "VulkanTexture.h"
 
@@ -206,8 +205,6 @@ void DebugUtils::setName(VkObjectType type, uint64_t handle, char const* name) {
 }
 #endif // FVK_EANBLED(FVK_DEBUG_DEBUG_UTILS)
 
-using ImgUtil = VulkanImageUtility;
-
 Dispatcher VulkanDriver::getDispatcher() const noexcept {
     return ConcreteDispatcher<VulkanDriver>::make();
 }
@@ -262,8 +259,8 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
     mDescriptorSetManager.setPlaceHolders(mSamplerCache.getSampler({}), mEmptyTexture,
             mEmptyBufferObject);
 
-    mGetPipelineFunction = [this](VulkanDescriptorSetLayoutList const& layouts) {
-        return mPipelineLayoutCache.getLayout(layouts);
+    mGetPipelineFunction = [this](VulkanDescriptorSetLayoutList const& layouts, VulkanProgram* program) {
+        return mPipelineLayoutCache.getLayout(layouts, program);
     };
 }
 
@@ -391,16 +388,17 @@ void VulkanDriver::collectGarbage() {
 
     FVK_SYSTRACE_END();
 }
-void VulkanDriver::beginFrame(int64_t monotonic_clock_ns, uint32_t frameId) {
+void VulkanDriver::beginFrame(int64_t monotonic_clock_ns,
+        int64_t refreshIntervalNs, uint32_t frameId) {
     // Do nothing.
 }
 
 void VulkanDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
-        FrameScheduledCallback callback, void* user) {
+        CallbackHandler* handler, FrameScheduledCallback&& callback) {
 }
 
 void VulkanDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
+        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
 }
 
 void VulkanDriver::setPresentationTime(int64_t monotonic_clock_ns) {
@@ -920,6 +918,11 @@ bool VulkanDriver::isDepthStencilResolveSupported() {
     return false;
 }
 
+bool VulkanDriver::isDepthStencilBlitSupported(TextureFormat format) {
+    auto const& formats = mContext.getBlittableDepthStencilFormats();
+    return std::find(formats.begin(), formats.end(), getVkFormat(format)) != formats.end();
+}
+
 bool VulkanDriver::isProtectedTexturesSupported() {
     return false;
 }
@@ -1233,12 +1236,7 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
         }
     }
 
-    VulkanLayout const currentDepthLayout = depth.getLayout();
-    VulkanLayout const renderPassDepthLayout = VulkanLayout::DEPTH_ATTACHMENT;
-    // We need to keep the final layout as an attachment because the implicit transition does not
-    // have any barrier guarrantees, meaning that if we want to sample from the output in the next
-    // pass, then we'd have a race-condition/validation error.
-    VulkanLayout const finalDepthLayout = renderPassDepthLayout;
+    VulkanLayout currentDepthLayout = depth.getLayout();
 
     TargetBufferFlags clearVal = params.flags.clear;
     TargetBufferFlags discardEndVal = params.flags.discardEnd;
@@ -1247,16 +1245,20 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
             discardEndVal &= ~TargetBufferFlags::DEPTH;
             clearVal &= ~TargetBufferFlags::DEPTH;
         }
-        auto const attachmentSubresourceRange = depth.getSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT);
-        depth.texture->setLayout(attachmentSubresourceRange, VulkanLayout::DEPTH_ATTACHMENT);
+        // If the depth attachment texture was previously sampled, then we need to manually
+        // transition it to an attachment. This is necessary to also set up a barrier between the
+        // previous read and the potentially coming write.
+        if (currentDepthLayout == VulkanLayout::DEPTH_SAMPLER) {
+            depth.texture->transitionLayout(cmdbuffer, depth.getSubresourceRange(),
+                    VulkanLayout::DEPTH_ATTACHMENT);
+            currentDepthLayout = VulkanLayout::DEPTH_ATTACHMENT;
+        }
     }
 
     // Create the VkRenderPass or fetch it from cache.
     VulkanFboCache::RenderPassKey rpkey = {
         .initialColorLayoutMask = 0,
         .initialDepthLayout = currentDepthLayout,
-        .renderPassDepthLayout = renderPassDepthLayout,
-        .finalDepthLayout = finalDepthLayout,
         .depthFormat = depth.getFormat(),
         .clear = clearVal,
         .discardStart = discardStart,
@@ -1273,9 +1275,9 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
                 rpkey.needsResolveMask |= (1 << i);
             }
             if (info.texture->getPrimaryImageLayout() != VulkanLayout::COLOR_ATTACHMENT) {
-                ((VulkanTexture*) info.texture)->transitionLayout(cmdbuffer,
-                        info.getSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT),
-                        VulkanLayout::COLOR_ATTACHMENT);
+                ((VulkanTexture*) info.texture)
+                        ->transitionLayout(cmdbuffer, info.getSubresourceRange(),
+                                VulkanLayout::COLOR_ATTACHMENT);
             }
         } else {
             rpkey.colorFormat[i] = VK_FORMAT_UNDEFINED;
@@ -1293,27 +1295,42 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
         .layers = 1,
         .samples = rpkey.samples,
     };
+    auto& renderPassAttachments = mRenderPassFboInfo.attachments;
     for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; i++) {
         if (!rt->getColor(i).texture) {
             fbkey.color[i] = VK_NULL_HANDLE;
             fbkey.resolve[i] = VK_NULL_HANDLE;
         } else if (fbkey.samples == 1) {
-            fbkey.color[i] = rt->getColor(i).getImageView(VK_IMAGE_ASPECT_COLOR_BIT);
+            auto& colorAttachment = rt->getColor(i);
+            renderPassAttachments.insert(colorAttachment);
+            fbkey.color[i] = colorAttachment.getImageView();
             fbkey.resolve[i] = VK_NULL_HANDLE;
             assert_invariant(fbkey.color[i]);
         } else {
-            fbkey.color[i] = rt->getMsaaColor(i).getImageView(VK_IMAGE_ASPECT_COLOR_BIT);
-            VulkanTexture* texture = (VulkanTexture*) rt->getColor(i).texture;
+            auto& msaaColorAttachment = rt->getMsaaColor(i);
+            renderPassAttachments.insert(msaaColorAttachment);
+
+            auto& colorAttachment = rt->getColor(i);
+            fbkey.color[i] = msaaColorAttachment.getImageView();
+
+            VulkanTexture* texture = colorAttachment.texture;
             if (texture->samples == 1) {
-                fbkey.resolve[i] = rt->getColor(i).getImageView(VK_IMAGE_ASPECT_COLOR_BIT);
+                mRenderPassFboInfo.hasColorResolve = true;
+
+                renderPassAttachments.insert(colorAttachment);
+                fbkey.resolve[i] = colorAttachment.getImageView();
                 assert_invariant(fbkey.resolve[i]);
             }
             assert_invariant(fbkey.color[i]);
         }
     }
     if (depth.texture) {
-        fbkey.depth = depth.getImageView(VK_IMAGE_ASPECT_DEPTH_BIT);
+        fbkey.depth = depth.getImageView();
         assert_invariant(fbkey.depth);
+        renderPassAttachments.insert(depth);
+
+        UTILS_UNUSED_IN_RELEASE bool const depthDiscardEnd =
+                any(rpkey.discardEnd & TargetBufferFlags::DEPTH);
 
         // Vulkan 1.1 does not support multisampled depth resolve, so let's check here
         // and assert if this is requested. (c.f. isAutoDepthResolveSupported)
@@ -1322,7 +1339,7 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
         // - If the RT is MS then all SS attachments are auto resolved if not discarded.
         assert_invariant(!(rt->getSamples() > 1 &&
                 rt->getDepth().texture->samples == 1 &&
-                !any(rpkey.discardEnd & TargetBufferFlags::DEPTH)));
+                !depthDiscardEnd));
     }
     VkFramebuffer vkfb = mFramebufferCache.getFramebuffer(fbkey);
 
@@ -1335,16 +1352,10 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
     }
 #endif
 
-    // The current command buffer now owns a reference to the render target and its attachments.
-    // Note that we must acquire parent textures, not sidecars.
+    // The current command buffer now has references to the render target and its attachments.
     commands.acquire(rt);
-    if (depth.texture) {
-        commands.acquire((VulkanTexture*) depth.texture);
-    }
-    for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; i++) {
-        if (rt->getColor(i).texture) {
-            commands.acquire(rt->getColor(i).texture);
-        }
+    for (auto const& attachment: renderPassAttachments) {
+        commands.acquire(attachment.texture);
     }
 
     // Populate the structures required for vkCmdBeginRenderPass.
@@ -1430,27 +1441,51 @@ void VulkanDriver::endRenderPass(int) {
     // issue several of them when considering MRT. This would be very complex to set up and would
     // require more state tracking, so we've chosen to use a memory barrier for simplicity and
     // correctness.
-
-    // NOTE: ideally dstStageMask would merely be VERTEX_SHADER_BIT | FRAGMENT_SHADER_BIT, but this
-    // seems to be insufficient on Mali devices. To work around this we are adding a more aggressive
-    // TOP_OF_PIPE barrier.
     if (!rt->isSwapChain()) {
-        VkMemoryBarrier barrier{
-                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
-                .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-                .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
-        };
-        VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-        if (rt->hasDepth()) {
-            barrier.srcAccessMask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-            srcStageMask |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
+        for (auto const& attachment: mRenderPassFboInfo.attachments) {
+            bool const isDepth = attachment.isDepth();
+            VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+
+            // This is a workaround around a validation issue (might not be an actual driver issue).
+            if (mRenderPassFboInfo.hasColorResolve && !isDepth) {
+                srcStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
+            }
+
+            VkPipelineStageFlags dstStageMask =
+                    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+            VkAccessFlags srcAccess = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+            VkAccessFlags dstAccess = VK_ACCESS_SHADER_READ_BIT;
+            VulkanLayout layout = VulkanFboCache::FINAL_COLOR_ATTACHMENT_LAYOUT;
+            if (isDepth) {
+                srcAccess = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+                dstAccess = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+                srcStageMask = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
+                dstStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+                layout =  VulkanFboCache::FINAL_DEPTH_ATTACHMENT_LAYOUT;
+            }
+
+            auto const vkLayout = imgutil::getVkLayout(layout);
+            auto const& range = attachment.getSubresourceRange();
+            VkImageMemoryBarrier barrier = {
+                .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = srcAccess,
+                .dstAccessMask = dstAccess,
+                .oldLayout = vkLayout,
+                .newLayout = vkLayout,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                .image = attachment.getImage(),
+                .subresourceRange = range,
+            };
+
+            attachment.texture->setLayout(range, layout);
+            vkCmdPipelineBarrier(cmdbuffer, srcStageMask, dstStageMask, 0, 0, nullptr, 0, nullptr,
+                    1, &barrier);
         }
-        vkCmdPipelineBarrier(cmdbuffer, srcStageMask,
-                VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT | // <== For Mali
-                VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-                0, 1, &barrier, 0, nullptr, 0, nullptr);
     }
 
+    mRenderPassFboInfo.clear();
     mDescriptorSetManager.clearState();
     mCurrentRenderPass.renderTarget = nullptr;
     mCurrentRenderPass.renderPass = VK_NULL_HANDLE;
@@ -1537,6 +1572,14 @@ void VulkanDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
     mSamplerBindings[index] = hwsb;
 }
 
+void VulkanDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
+        backend::PushConstantVariant value) {
+    assert_invariant(mBoundPipeline.program && "Expect a program when writing to push constants");
+    VulkanCommands* commands = &mCommands;
+    mBoundPipeline.program->writePushConstant(commands, mBoundPipeline.pipelineLayout, stage, index,
+            value);
+}
+
 void VulkanDriver::insertEventMarker(char const* string, uint32_t len) {
 #if FVK_ENABLED(FVK_DEBUG_GROUP_MARKERS)
     mCommands.insertEventMarker(string, len);
@@ -1720,7 +1763,7 @@ void VulkanDriver::blitDEPRECATED(TargetBufferFlags buffers,
     FVK_SYSTRACE_END();
 }
 
-void VulkanDriver::bindPipeline(PipelineState pipelineState) {
+void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {
     FVK_SYSTRACE_CONTEXT();
     FVK_SYSTRACE_START("draw");
 
@@ -1806,7 +1849,7 @@ void VulkanDriver::bindPipeline(PipelineState pipelineState) {
         // This fallback path is very flaky because the dummy texture might not have
         // matching characteristics. (e.g. if the missing texture is a 3D texture)
         if (UTILS_UNLIKELY(texture->getPrimaryImageLayout() == VulkanLayout::UNDEFINED)) {
-#if FVK_ENABLED(FVK_DEBUG_TEXTURE)
+#if FVK_ENABLED(FVK_DEBUG_TEXTURE) && FVK_ENABLED_DEBUG_SAMPLER_NAME
             utils::slog.w << "Uninitialized texture bound to '" << bindingToName[binding] << "'";
             utils::slog.w << " in material '" << program->name.c_str() << "'";
             utils::slog.w << " at binding point " << +binding << utils::io::endl;
@@ -1814,20 +1857,28 @@ void VulkanDriver::bindPipeline(PipelineState pipelineState) {
             texture = mEmptyTexture;
         }
 
+        VkSampler const vksampler = mSamplerCache.getSampler(boundSampler->s);
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
         VulkanDriver::DebugUtils::setName(VK_OBJECT_TYPE_SAMPLER,
                 reinterpret_cast<uint64_t>(vksampler), bindingToName[binding].c_str());
-        VulkanDriver::DebugUtils::setName(VK_OBJECT_TYPE_SAMPLER,
-                reinterpret_cast<uint64_t>(samplerInfo.sampler), bindingToName[binding].c_str());
 #endif
-
-        VkSampler const vksampler = mSamplerCache.getSampler(boundSampler->s);
-
         mDescriptorSetManager.updateSampler({}, binding, texture, vksampler);
     }
 
-    mPipelineCache.bindLayout(mDescriptorSetManager.bind(commands, program, mGetPipelineFunction));
+    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});
+
     FVK_SYSTRACE_END();
 }
 
@@ -1918,7 +1969,7 @@ void VulkanDriver::scissor(Viewport scissorBox) {
 
     const VulkanRenderTarget* rt = mCurrentRenderPass.renderTarget;
     rt->transformClientRectToPlatform(&scissor);
-    mPipelineCache.bindScissor(cmdbuffer, scissor);
+    vkCmdSetScissor(cmdbuffer, 0, 1, &scissor);
 }
 
 void VulkanDriver::beginTimerQuery(Handle<HwTimerQuery> tqh) {

filament/backend/src/vulkan/VulkanDriver.h

@@ -42,6 +42,25 @@ namespace filament::backend {
 class VulkanPlatform;
 struct VulkanSamplerGroup;
 
+// The maximum number of attachments for any renderpass (color + resolve + depth)
+constexpr uint8_t MAX_RENDERTARGET_ATTACHMENT_TEXTURES =
+        MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT * 2 + 1;
+
+// We need to store information about a render pass to enable better barriers at the end of a
+// renderpass.
+struct RenderPassFboBundle {
+    using AttachmentArray =
+            CappedArray<VulkanAttachment, MAX_RENDERTARGET_ATTACHMENT_TEXTURES>;
+
+    AttachmentArray attachments;
+    bool hasColorResolve = false;
+
+    void clear() {
+        attachments.clear();
+        hasColorResolve = false;
+    }
+};
+
 class VulkanDriver final : public DriverBase {
 public:
     static Driver* create(VulkanPlatform* platform, VulkanContext const& context,
@@ -141,6 +160,15 @@ private:
 
     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;
 };
 

filament/backend/src/vulkan/VulkanFboCache.cpp

@@ -29,14 +29,10 @@ using namespace bluevk;
 
 namespace filament::backend {
 
-using ImgUtil = VulkanImageUtility;
-
 bool VulkanFboCache::RenderPassEq::operator()(const RenderPassKey& k1,
         const RenderPassKey& k2) const {
     if (k1.initialColorLayoutMask != k2.initialColorLayoutMask) return false;
     if (k1.initialDepthLayout != k2.initialDepthLayout) return false;
-    if (k1.renderPassDepthLayout != k2.renderPassDepthLayout) return false;
-    if (k1.finalDepthLayout != k2.finalDepthLayout) return false;
     for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; i++) {
         if (k1.colorFormat[i] != k2.colorFormat[i]) return false;
     }
@@ -197,7 +193,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
         if (config.colorFormat[i] == VK_FORMAT_UNDEFINED) {
             continue;
         }
-        const VkImageLayout subpassLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT);
+        const VkImageLayout subpassLayout = imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT);
         uint32_t index;
 
         if (!hasSubpasses) {
@@ -243,9 +239,9 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
             .stencilLoadOp = kDontCare,
             .stencilStoreOp = kDisableStore,
             .initialLayout = ((!discard && config.initialColorLayoutMask & (1 << i)) || clear)
-                                     ? ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT)
-                                     : ImgUtil::getVkLayout(VulkanLayout::UNDEFINED),
-            .finalLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
+                                     ? imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT)
+                                     : imgutil::getVkLayout(VulkanLayout::UNDEFINED),
+            .finalLayout = imgutil::getVkLayout(FINAL_COLOR_ATTACHMENT_LAYOUT),
         };
     }
 
@@ -272,7 +268,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
 
         pResolveAttachment->attachment = attachmentIndex;
         pResolveAttachment->layout
-                = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT_RESOLVE);
+                = imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT_RESOLVE);
         ++pResolveAttachment;
 
         attachments[attachmentIndex++] = {
@@ -282,8 +278,8 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
             .storeOp = kEnableStore,
             .stencilLoadOp = kDontCare,
             .stencilStoreOp = kDisableStore,
-            .initialLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
-            .finalLayout = ImgUtil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
+            .initialLayout = imgutil::getVkLayout(VulkanLayout::COLOR_ATTACHMENT),
+            .finalLayout = imgutil::getVkLayout(FINAL_COLOR_ATTACHMENT_LAYOUT),
         };
     }
 
@@ -292,7 +288,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
         const bool clear = any(config.clear & TargetBufferFlags::DEPTH);
         const bool discardStart = any(config.discardStart & TargetBufferFlags::DEPTH);
         const bool discardEnd = any(config.discardEnd & TargetBufferFlags::DEPTH);
-        depthAttachmentRef.layout = ImgUtil::getVkLayout(config.renderPassDepthLayout);
+        depthAttachmentRef.layout = imgutil::getVkLayout(VulkanLayout::DEPTH_ATTACHMENT);
         depthAttachmentRef.attachment = attachmentIndex;
         attachments[attachmentIndex++] = {
             .format = config.depthFormat,
@@ -301,8 +297,8 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
             .storeOp = discardEnd ? kDisableStore : kEnableStore,
             .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
             .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
-            .initialLayout = ImgUtil::getVkLayout(config.initialDepthLayout),
-            .finalLayout = ImgUtil::getVkLayout(config.finalDepthLayout),
+            .initialLayout = imgutil::getVkLayout(config.initialDepthLayout),
+            .finalLayout = imgutil::getVkLayout(FINAL_DEPTH_ATTACHMENT_LAYOUT),
         };
     }
     renderPassInfo.attachmentCount = attachmentIndex;

filament/backend/src/vulkan/VulkanFboCache.h

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

filament/backend/src/vulkan/VulkanHandles.cpp

@@ -65,21 +65,6 @@ static constexpr Bitmask fromStageFlags(ShaderStageFlags2 flags, uint8_t binding
     return ret;
 }
 
-UsageFlags getUsageFlags(uint16_t binding, ShaderStageFlags flags, UsageFlags src) {
-    // NOTE: if you modify this function, you also need to modify getShaderStageFlags.
-    assert_invariant(binding < MAX_SAMPLER_COUNT);
-    if (any(flags & ShaderStageFlags::VERTEX)) {
-        src.set(binding);
-    }
-    if (any(flags & ShaderStageFlags::FRAGMENT)) {
-        src.set(MAX_SAMPLER_COUNT + binding);
-    }
-    // TODO: add support for compute by extending SHADER_MODULE_COUNT and ensuring UsageFlags
-    // has 186 bits (MAX_SAMPLER_COUNT * 3)
-    // assert_invariant(!any(flags & ~(ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT)));
-    return src;
-}
-
 constexpr decltype(VulkanProgram::MAX_SHADER_MODULES) MAX_SHADER_MODULES =
         VulkanProgram::MAX_SHADER_MODULES;
 
@@ -127,27 +112,82 @@ inline VkDescriptorSetLayout createDescriptorSetLayout(VkDevice device,
     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)
+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)) {
-}
+      count(Count::fromLayoutBitmask(bitmask)) {}
 
 VulkanDescriptorSetLayout::~VulkanDescriptorSetLayout() {
     vkDestroyDescriptorSetLayout(mDevice, vklayout, VKALLOC);
 }
 
+PushConstantDescription::PushConstantDescription(backend::Program const& program) noexcept {
+    mRangeCount = 0;
+    for (auto stage : { ShaderStage::VERTEX, ShaderStage::FRAGMENT, ShaderStage::COMPUTE }) {
+        auto const& constants = program.getPushConstants(stage);
+        if (constants.empty()) {
+            continue;
+        }
+
+        // We store the type of the constant for type-checking when writing.
+        auto& types = mTypes[(uint8_t) stage];
+        types.reserve(constants.size());
+        std::for_each(constants.cbegin(), constants.cend(), [&types] (Program::PushConstant t) {
+            types.push_back(t.type);
+        });
+
+        mRanges[mRangeCount++] = {
+            .stageFlags = getVkStage(stage),
+            .offset = 0,
+            .size = (uint32_t) constants.size() * ENTRY_SIZE,
+        };
+    }
+}
+
+void PushConstantDescription::write(VulkanCommands* commands, VkPipelineLayout layout,
+        backend::ShaderStage stage, uint8_t index, backend::PushConstantVariant const& value) {
+    VulkanCommandBuffer* cmdbuf = &(commands->get());
+    uint32_t binaryValue = 0;
+    UTILS_UNUSED_IN_RELEASE auto const& types = mTypes[(uint8_t) stage];
+    if (std::holds_alternative<bool>(value)) {
+        assert_invariant(types[index] == ConstantType::BOOL);
+        bool const bval = std::get<bool>(value);
+        binaryValue = static_cast<uint32_t const>(bval ? VK_TRUE : VK_FALSE);
+    } else if (std::holds_alternative<float>(value)) {
+        assert_invariant(types[index] == ConstantType::FLOAT);
+        float const fval = std::get<float>(value);
+        binaryValue = *reinterpret_cast<uint32_t const*>(&fval);
+    } else {
+        assert_invariant(types[index] == ConstantType::INT);
+        int const ival = std::get<int>(value);
+        binaryValue = *reinterpret_cast<uint32_t const*>(&ival);
+    }
+    vkCmdPushConstants(cmdbuf->buffer(), layout, getVkStage(stage), index * ENTRY_SIZE, ENTRY_SIZE,
+            &binaryValue);
+}
+
 VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
     : HwProgram(builder.getName()),
       VulkanResource(VulkanResourceType::PROGRAM),
-      mInfo(new PipelineInfo()),
+      mInfo(new(std::nothrow) PipelineInfo(builder)),
       mDevice(device) {
 
     constexpr uint8_t UBO_MODULE_OFFSET = (sizeof(UniformBufferBitmask) * 8) / MAX_SHADER_MODULES;
@@ -236,7 +276,6 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
     auto& groupInfo = builder.getSamplerGroupInfo();
     auto& bindingToSamplerIndex = mInfo->bindingToSamplerIndex;
     auto& bindings = mInfo->bindings;
-    auto& usage = mInfo->usage;
     for (uint8_t groupInd = 0; groupInd < Program::SAMPLER_BINDING_COUNT; groupInd++) {
         auto const& group = groupInfo[groupInd];
         auto const& samplers = group.samplers;
@@ -245,7 +284,6 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
             bindingToSamplerIndex[binding] = (groupInd << 8) | (0xff & i);
             assert_invariant(bindings.find(binding) == bindings.end());
             bindings.insert(binding);
-            usage = getUsageFlags(binding, group.stageFlags, usage);
 
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
             bindingToName[binding] = samplers[i].name.c_str();
@@ -302,13 +340,13 @@ VulkanRenderTarget::VulkanRenderTarget(VkDevice device, VkPhysicalDevice physica
 
     // Constrain the sample count according to both kinds of sample count masks obtained from
     // VkPhysicalDeviceProperties. This is consistent with the VulkanTexture constructor.
-    const auto& limits = context.getPhysicalDeviceLimits();
+    auto const& limits = context.getPhysicalDeviceLimits();
     mSamples = samples = reduceSampleCount(samples, limits.framebufferDepthSampleCounts &
             limits.framebufferColorSampleCounts);
 
     // Create sidecar MSAA textures for color attachments if they don't already exist.
     for (int index = 0; index < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; index++) {
-        const VulkanAttachment& spec = color[index];
+        VulkanAttachment const& spec = color[index];
         VulkanTexture* texture = (VulkanTexture*) spec.texture;
         if (texture && texture->samples == 1) {
             auto msTexture = texture->getSidecar();
@@ -371,19 +409,19 @@ VkExtent2D VulkanRenderTarget::getExtent() const {
     return {width, height};
 }
 
-VulkanAttachment VulkanRenderTarget::getColor(int target) const {
+VulkanAttachment& VulkanRenderTarget::getColor(int target) {
     return mColor[target];
 }
 
-VulkanAttachment VulkanRenderTarget::getMsaaColor(int target) const {
+VulkanAttachment& VulkanRenderTarget::getMsaaColor(int target) {
     return mMsaaAttachments[target];
 }
 
-VulkanAttachment VulkanRenderTarget::getDepth() const {
+VulkanAttachment& VulkanRenderTarget::getDepth() {
     return mDepth;
 }
 
-VulkanAttachment VulkanRenderTarget::getMsaaDepth() const {
+VulkanAttachment& VulkanRenderTarget::getMsaaDepth() {
     return mMsaaDepthAttachment;
 }
 

filament/backend/src/vulkan/VulkanHandles.h

@@ -26,10 +26,10 @@
 #include "VulkanTexture.h"
 #include "VulkanUtility.h"
 
-#include "private/backend/SamplerGroup.h"
-#include "utils/FixedCapacityVector.h"
-#include "vulkan/vulkan_core.h"
+#include <private/backend/SamplerGroup.h>
+#include <backend/Program.h>
 
+#include <utils/FixedCapacityVector.h>
 #include <utils/Mutex.h>
 #include <utils/StructureOfArrays.h>
 
@@ -180,6 +180,28 @@ private:
 using VulkanDescriptorSetList = std::array<Handle<VulkanDescriptorSet>,
         VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;
 
+using PushConstantNameArray = utils::FixedCapacityVector<char const*>;
+using PushConstantNameByStage = std::array<PushConstantNameArray, Program::SHADER_TYPE_COUNT>;
+
+struct PushConstantDescription {
+
+    explicit PushConstantDescription(backend::Program const& program) noexcept;
+
+    VkPushConstantRange const* getVkRanges() const noexcept { return mRanges; }
+
+    uint32_t getVkRangeCount() const noexcept { return mRangeCount; }
+
+    void write(VulkanCommands* commands, VkPipelineLayout layout, backend::ShaderStage stage,
+            uint8_t index, backend::PushConstantVariant const& value);
+
+private:
+    static constexpr uint32_t ENTRY_SIZE = sizeof(uint32_t);
+
+    utils::FixedCapacityVector<backend::ConstantType> mTypes[Program::SHADER_TYPE_COUNT];
+    VkPushConstantRange mRanges[Program::SHADER_TYPE_COUNT];
+    uint32_t mRangeCount;
+};
+
 struct VulkanProgram : public HwProgram, VulkanResource {
 
     using BindingList = CappedArray<uint16_t, MAX_SAMPLER_COUNT>;
@@ -198,10 +220,6 @@ struct VulkanProgram : public HwProgram, VulkanResource {
         return mInfo->bindingToSamplerIndex;
     }
 
-    inline UsageFlags getUsage() const {
-        return mInfo->usage;
-    }
-
     // Get a list of the sampler binding indices so that we don't have to loop through all possible
     // samplers.
     inline BindingList const& getBindings() const { return mInfo->bindings; }
@@ -216,6 +234,19 @@ struct VulkanProgram : public HwProgram, VulkanResource {
             VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;
     inline LayoutDescriptionList const& getLayoutDescriptionList() const { return mInfo->layouts; }
 
+    inline uint32_t getPushConstantRangeCount() const {
+        return mInfo->pushConstantDescription.getVkRangeCount();
+    }
+
+    inline VkPushConstantRange const* getPushConstantRanges() const {
+        return mInfo->pushConstantDescription.getVkRanges();
+    }
+
+    inline void writePushConstant(VulkanCommands* commands, VkPipelineLayout layout,
+            backend::ShaderStage stage, uint8_t index, backend::PushConstantVariant const& value) {
+        mInfo->pushConstantDescription.write(commands, layout, stage, index, value);
+    }
+
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
     inline utils::FixedCapacityVector<std::string> const& getBindingToName() const {
         return mInfo->bindingToName;
@@ -228,17 +259,14 @@ struct VulkanProgram : public HwProgram, VulkanResource {
 
 private:
     struct PipelineInfo {
-        PipelineInfo()
-            : bindingToSamplerIndex(MAX_SAMPLER_COUNT, 0xffff)
+        explicit PipelineInfo(backend::Program const& program) noexcept
+            : bindingToSamplerIndex(MAX_SAMPLER_COUNT, 0xffff),
+              pushConstantDescription(program)
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
             , bindingToName(MAX_SAMPLER_COUNT, "")
 #endif
             {}
 
-        // This bitset maps to each of the sampler in the sampler groups associated with this
-        // program, and whether each sampler is used in which shader (i.e. vert, frag, compute).
-        UsageFlags usage;
-
         BindingList bindings;
 
         // We store the samplerGroupIndex as the top 8-bit and the index within each group as the lower 8-bit.
@@ -249,6 +277,8 @@ private:
         // descset::DescriptorSetLayout layout;
         LayoutDescriptionList layouts;
 
+        PushConstantDescription pushConstantDescription;
+
 #if FVK_ENABLED_DEBUG_SAMPLER_NAME
         // We store the sampler name mapped from binding index (only for debug purposes).
         utils::FixedCapacityVector<std::string> bindingToName;
@@ -282,10 +312,11 @@ struct VulkanRenderTarget : private HwRenderTarget, VulkanResource {
     void transformClientRectToPlatform(VkRect2D* bounds) const;
     void transformClientRectToPlatform(VkViewport* bounds) const;
     VkExtent2D getExtent() const;
-    VulkanAttachment getColor(int target) const;
-    VulkanAttachment getMsaaColor(int target) const;
-    VulkanAttachment getDepth() const;
-    VulkanAttachment getMsaaDepth() const;
+    // We return references in the following methods to avoid a copy.
+    VulkanAttachment& getColor(int target);
+    VulkanAttachment& getMsaaColor(int target);
+    VulkanAttachment& getDepth();
+    VulkanAttachment& getMsaaDepth();
     uint8_t getColorTargetCount(const VulkanRenderPass& pass) const;
     uint8_t getSamples() const { return mSamples; }
     bool hasDepth() const { return mDepth.texture; }

filament/backend/src/vulkan/VulkanImageUtility.cpp

@@ -26,38 +26,10 @@
 
 using namespace bluevk;
 
-namespace filament::backend {
+namespace filament::backend::imgutil {
 
 namespace {
 
-inline VkImageLayout getVkImageLayout(VulkanLayout layout) {
-    switch (layout) {
-        case VulkanLayout::UNDEFINED:
-            return VK_IMAGE_LAYOUT_UNDEFINED;
-        case VulkanLayout::READ_WRITE:
-            return VK_IMAGE_LAYOUT_GENERAL;
-        case VulkanLayout::READ_ONLY:
-            return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-        case VulkanLayout::TRANSFER_SRC:
-            return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-        case VulkanLayout::TRANSFER_DST:
-            return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-        case VulkanLayout::DEPTH_ATTACHMENT:
-            return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-        case VulkanLayout::DEPTH_SAMPLER:
-            return VK_IMAGE_LAYOUT_GENERAL;
-        case VulkanLayout::PRESENT:
-            return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
-        // Filament sometimes samples from one miplevel while writing to another level in the same
-        // texture (e.g. bloom does this). Moreover we'd like to avoid lots of expensive layout
-        // transitions. So, keep it simple and use GENERAL for all color-attachable textures.
-        case VulkanLayout::COLOR_ATTACHMENT:
-            return VK_IMAGE_LAYOUT_GENERAL;
-        case VulkanLayout::COLOR_ATTACHMENT_RESOLVE:
-            return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-    }
-}
-
 inline std::tuple<VkAccessFlags, VkAccessFlags, VkPipelineStageFlags, VkPipelineStageFlags,
         VkImageLayout, VkImageLayout>
 getVkTransition(const VulkanLayoutTransition& transition) {
@@ -70,11 +42,11 @@ getVkTransition(const VulkanLayoutTransition& transition) {
             srcStage = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
             break;
         case VulkanLayout::COLOR_ATTACHMENT:
-            srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT
-                            | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
-                            | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-            srcStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
-                       | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+            srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
+                            VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
+                            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+            srcStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+                       VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
             break;
         case VulkanLayout::READ_WRITE:
             srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
@@ -154,27 +126,12 @@ getVkTransition(const VulkanLayoutTransition& transition) {
     }
 
     return std::make_tuple(srcAccessMask, dstAccessMask, srcStage, dstStage,
-            getVkImageLayout(transition.oldLayout), getVkImageLayout(transition.newLayout));
+            getVkLayout(transition.oldLayout), getVkLayout(transition.newLayout));
 }
 
 }// anonymous namespace
 
-VkImageViewType VulkanImageUtility::getViewType(SamplerType target) {
-    switch (target) {
-        case SamplerType::SAMPLER_CUBEMAP:
-            return VK_IMAGE_VIEW_TYPE_CUBE;
-        case SamplerType::SAMPLER_2D_ARRAY:
-            return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
-        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
-            return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
-        case SamplerType::SAMPLER_3D:
-            return VK_IMAGE_VIEW_TYPE_3D;
-        default:
-            return VK_IMAGE_VIEW_TYPE_2D;
-    }
-}
-
-void VulkanImageUtility::transitionLayout(VkCommandBuffer cmdbuffer,
+void transitionLayout(VkCommandBuffer cmdbuffer,
         VulkanLayoutTransition transition) {
     if (transition.oldLayout == transition.newLayout) {
         return;
@@ -197,10 +154,6 @@ void VulkanImageUtility::transitionLayout(VkCommandBuffer cmdbuffer,
     vkCmdPipelineBarrier(cmdbuffer, srcStage, dstStage, 0, 0, nullptr, 0, nullptr, 1, &barrier);
 }
 
-VkImageLayout VulkanImageUtility::getVkLayout(VulkanLayout layout) {
-    return getVkImageLayout(layout);
-}
-
 }// namespace filament::backend
 
 bool operator<(const VkImageSubresourceRange& a, const VkImageSubresourceRange& b) {
@@ -217,12 +170,12 @@ bool operator<(const VkImageSubresourceRange& a, const VkImageSubresourceRange&
     return false;
 }
 
-#if FVK_ENABLED(FVK_DEBUG_LAYOUT_TRANSITION | FVK_DEBUG_TEXTURE)
+#if FVK_ENABLED(FVK_DEBUG_LAYOUT_TRANSITION) || FVK_ENABLED(FVK_DEBUG_TEXTURE)
 #define CASE(VALUE)                                                                                \
     case filament::backend::VulkanLayout::VALUE: {                                                 \
         out << #VALUE;                                                                             \
         out << " ["                                                                                \
-            << filament::backend::VulkanImageUtility::getVkLayout(                                 \
+            << filament::backend::imgutil::getVkLayout(                                            \
                        filament::backend::VulkanLayout::VALUE)                                     \
             << "]";                                                                                \
         break;                                                                                     \

filament/backend/src/vulkan/VulkanImageUtility.h

@@ -59,44 +59,85 @@ struct VulkanLayoutTransition {
     VkImageSubresourceRange subresources;
 };
 
-class VulkanImageUtility {
-public:
-    static VkImageViewType getViewType(SamplerType target);
+namespace imgutil {
 
-    inline static VulkanLayout getDefaultLayout(TextureUsage usage) {
-        if (any(usage & TextureUsage::DEPTH_ATTACHMENT)) {
-            if (any(usage & TextureUsage::SAMPLEABLE)) {
-                return VulkanLayout::DEPTH_SAMPLER;
-            } else {
-                return VulkanLayout::DEPTH_ATTACHMENT;
-            }
-        }
+inline VkImageViewType getViewType(SamplerType target) {
+    switch (target) {
+        case SamplerType::SAMPLER_CUBEMAP:
+            return VK_IMAGE_VIEW_TYPE_CUBE;
+        case SamplerType::SAMPLER_2D_ARRAY:
+            return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
+        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
+            return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
+        case SamplerType::SAMPLER_3D:
+            return VK_IMAGE_VIEW_TYPE_3D;
+        default:
+            return VK_IMAGE_VIEW_TYPE_2D;
+    }
+}
 
-        if (any(usage & TextureUsage::COLOR_ATTACHMENT)) {
-            return VulkanLayout::COLOR_ATTACHMENT;
+inline VulkanLayout getDefaultLayout(TextureUsage usage) {
+    if (any(usage & TextureUsage::DEPTH_ATTACHMENT)) {
+        if (any(usage & TextureUsage::SAMPLEABLE)) {
+            return VulkanLayout::DEPTH_SAMPLER;
+        } else {
+            return VulkanLayout::DEPTH_ATTACHMENT;
         }
-        // Finally, the layout for an immutable texture is optimal read-only.        
-        return VulkanLayout::READ_ONLY;
     }
 
-    inline static VulkanLayout getDefaultLayout(VkImageUsageFlags vkusage) {
-        TextureUsage usage {};
-        if (vkusage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
-            usage = usage | TextureUsage::DEPTH_ATTACHMENT;
-        }
-        if (vkusage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
-            usage = usage | TextureUsage::COLOR_ATTACHMENT;
-        }
-        if (vkusage & VK_IMAGE_USAGE_SAMPLED_BIT) {
-            usage = usage | TextureUsage::SAMPLEABLE;
-        }
-        return getDefaultLayout(usage);
+    if (any(usage & TextureUsage::COLOR_ATTACHMENT)) {
+        return VulkanLayout::COLOR_ATTACHMENT;
     }
+    // Finally, the layout for an immutable texture is optimal read-only.
+    return VulkanLayout::READ_ONLY;
+}
 
-    static VkImageLayout getVkLayout(VulkanLayout layout);
-    
-    static void transitionLayout(VkCommandBuffer cmdbuffer, VulkanLayoutTransition transition);
-};
+inline VulkanLayout getDefaultLayout(VkImageUsageFlags vkusage) {
+    TextureUsage usage{};
+    if (vkusage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
+        usage = usage | TextureUsage::DEPTH_ATTACHMENT;
+    }
+    if (vkusage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
+        usage = usage | TextureUsage::COLOR_ATTACHMENT;
+    }
+    if (vkusage & VK_IMAGE_USAGE_SAMPLED_BIT) {
+        usage = usage | TextureUsage::SAMPLEABLE;
+    }
+    return getDefaultLayout(usage);
+}
+
+constexpr inline VkImageLayout getVkLayout(VulkanLayout layout) {
+    switch (layout) {
+        case VulkanLayout::UNDEFINED:
+            return VK_IMAGE_LAYOUT_UNDEFINED;
+        case VulkanLayout::READ_WRITE:
+            return VK_IMAGE_LAYOUT_GENERAL;
+        case VulkanLayout::READ_ONLY:
+            return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+        case VulkanLayout::TRANSFER_SRC:
+            return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+        case VulkanLayout::TRANSFER_DST:
+            return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+        case VulkanLayout::DEPTH_ATTACHMENT:
+            return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+        case VulkanLayout::DEPTH_SAMPLER:
+            return VK_IMAGE_LAYOUT_GENERAL;
+        case VulkanLayout::PRESENT:
+            return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+        // Filament sometimes samples from one miplevel while writing to another level in the
+        // same texture (e.g. bloom does this). Moreover we'd like to avoid lots of expensive
+        // layout transitions. So, keep it simple and use GENERAL for all color-attachable
+        // textures.
+        case VulkanLayout::COLOR_ATTACHMENT:
+            return VK_IMAGE_LAYOUT_GENERAL;
+        case VulkanLayout::COLOR_ATTACHMENT_RESOLVE:
+            return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+    }
+}
+
+void transitionLayout(VkCommandBuffer cmdbuffer, VulkanLayoutTransition transition);
+
+} // namespace imgutil
 
 } // namespace filament::backend
 

filament/backend/src/vulkan/VulkanPipelineCache.cpp

@@ -79,10 +79,6 @@ void VulkanPipelineCache::bindPipeline(VulkanCommandBuffer* commands) {
     commands->setPipeline(cacheEntry->handle);
 }
 
-void VulkanPipelineCache::bindScissor(VkCommandBuffer cmdbuffer, VkRect2D scissor) noexcept {
-    vkCmdSetScissor(cmdbuffer, 0, 1, &scissor);
-}
-
 VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() noexcept {
     assert_invariant(mPipelineRequirements.shaders[0] && "Vertex shader is not bound.");
     assert_invariant(mPipelineRequirements.layout && "No pipeline layout specified");
@@ -306,7 +302,6 @@ void VulkanPipelineCache::gc() noexcept {
     // The Vulkan spec says: "When a command buffer begins recording, all state in that command
     // buffer is undefined." Therefore, we need to clear all bindings at this time.
     mBoundPipeline = {};
-    mCurrentScissor = {};
 
     // NOTE: Due to robin_map restrictions, we cannot use auto or range-based loops.
 

filament/backend/src/vulkan/VulkanPipelineCache.h

@@ -120,9 +120,6 @@ public:
     // Creates a new pipeline if necessary and binds it using vkCmdBindPipeline.
     void bindPipeline(VulkanCommandBuffer* commands);
 
-    // Sets up a new scissor rectangle if it has been dirtied.
-    void bindScissor(VkCommandBuffer cmdbuffer, VkRect2D scissor) noexcept;
-
     // Each of the following methods are fast and do not make Vulkan calls.
     void bindProgram(VulkanProgram* program) noexcept;
     void bindRasterState(const RasterState& rasterState) noexcept;
@@ -263,9 +260,6 @@ private:
 
     // Current bindings for the pipeline and descriptor sets.
     PipelineKey mBoundPipeline = {};
-
-    // Current state for scissoring.
-    VkRect2D mCurrentScissor = {};
 };
 
 } // namespace filament::backend

filament/backend/src/vulkan/VulkanReadPixels.cpp

@@ -28,7 +28,6 @@ using namespace bluevk;
 
 namespace filament::backend {
 
-using ImgUtil = VulkanImageUtility;
 using TaskHandler = VulkanReadPixels::TaskHandler;
 using WorkloadFunc = TaskHandler::WorkloadFunc;
 using OnCompleteFunc = TaskHandler::OnCompleteFunc;
@@ -118,7 +117,7 @@ void VulkanReadPixels::terminate() noexcept {
 VulkanReadPixels::VulkanReadPixels(VkDevice device)
     : mDevice(device) {}
 
-void VulkanReadPixels::run(VulkanRenderTarget const* srcTarget, uint32_t const x, uint32_t const y,
+void VulkanReadPixels::run(VulkanRenderTarget* srcTarget, uint32_t const x, uint32_t const y,
         uint32_t const width, uint32_t const height, uint32_t const graphicsQueueFamilyIndex,
         PixelBufferDescriptor&& pbd, SelecteMemoryFunction const& selectMemoryFunc,
         OnReadCompleteFunction const& readCompleteFunc) {
@@ -218,7 +217,7 @@ void VulkanReadPixels::run(VulkanRenderTarget const* srcTarget, uint32_t const x
     };
     vkBeginCommandBuffer(cmdbuffer, &binfo);
 
-    ImgUtil::transitionLayout(cmdbuffer, {
+    imgutil::transitionLayout(cmdbuffer, {
         .image = stagingImage,
         .oldLayout = VulkanLayout::UNDEFINED,
         .newLayout = VulkanLayout::TRANSFER_DST,
@@ -232,8 +231,7 @@ void VulkanReadPixels::run(VulkanRenderTarget const* srcTarget, uint32_t const x
     });
 
     VulkanAttachment const srcAttachment = srcTarget->getColor(0);
-    const VkImageSubresourceRange srcRange
-            = srcAttachment.getSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT);
+    VkImageSubresourceRange const srcRange = srcAttachment.getSubresourceRange();
     srcTexture->transitionLayout(cmdbuffer, srcRange, VulkanLayout::TRANSFER_SRC);
 
     VkImageCopy const imageCopyRegion = {
@@ -266,8 +264,8 @@ void VulkanReadPixels::run(VulkanRenderTarget const* srcTarget, uint32_t const x
             imageCopyRegion.srcOffset.y + imageCopyRegion.extent.height <= srcExtent.height);
 
     vkCmdCopyImage(cmdbuffer, srcAttachment.getImage(),
-            ImgUtil::getVkLayout(VulkanLayout::TRANSFER_SRC), stagingImage,
-            ImgUtil::getVkLayout(VulkanLayout::TRANSFER_DST), 1, &imageCopyRegion);
+            imgutil::getVkLayout(VulkanLayout::TRANSFER_SRC), stagingImage,
+            imgutil::getVkLayout(VulkanLayout::TRANSFER_DST), 1, &imageCopyRegion);
 
     // Restore the source image layout.
     srcTexture->transitionLayout(cmdbuffer, srcRange, VulkanLayout::COLOR_ATTACHMENT);

filament/backend/src/vulkan/VulkanReadPixels.h

@@ -26,9 +26,7 @@
 #include <functional>
 #include <mutex>
 #include <queue>
-#include <set>
 #include <thread>
-#include <vector>
 
 namespace filament::backend {
 
@@ -74,8 +72,8 @@ public:
 
     void terminate() noexcept;
 
-    void run(VulkanRenderTarget const* srcTarget, uint32_t x, uint32_t y, uint32_t width,
-            uint32_t height, uint32_t graphicsQueueFamilyIndex, PixelBufferDescriptor&& pbd,
+    void run(VulkanRenderTarget* srcTarget, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
+            uint32_t graphicsQueueFamilyIndex, PixelBufferDescriptor&& pbd,
             SelecteMemoryFunction const& selectMemoryFunc,
             OnReadCompleteFunction const& readCompleteFunc);
 

filament/backend/src/vulkan/VulkanStagePool.cpp

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

filament/backend/src/vulkan/VulkanTexture.cpp

@@ -28,7 +28,6 @@ using namespace bluevk;
 
 namespace filament::backend {
 
-using ImgUtil = VulkanImageUtility;
 VulkanTexture::VulkanTexture(VkDevice device, VmaAllocator allocator, VulkanCommands* commands,
         VkImage image, VkFormat format, uint8_t samples, uint32_t width, uint32_t height,
         TextureUsage tusage, VulkanStagePool& stagePool, bool heapAllocated)
@@ -37,7 +36,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VmaAllocator allocator, VulkanComm
       VulkanResource(
               heapAllocated ? VulkanResourceType::HEAP_ALLOCATED : VulkanResourceType::TEXTURE),
       mVkFormat(format),
-      mViewType(ImgUtil::getViewType(target)),
+      mViewType(imgutil::getViewType(target)),
       mSwizzle({}),
       mTextureImage(image),
       mFullViewRange{
@@ -62,7 +61,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
       VulkanResource(
               heapAllocated ? VulkanResourceType::HEAP_ALLOCATED : VulkanResourceType::TEXTURE),
       mVkFormat(backend::getVkFormat(tformat)),
-      mViewType(ImgUtil::getViewType(target)),
+      mViewType(imgutil::getViewType(target)),
       mSwizzle(swizzle),
       mStagePool(stagePool),
       mDevice(device),
@@ -236,7 +235,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
         VulkanCommandBuffer& commands = mCommands->get();
         VkCommandBuffer const cmdbuf = commands.buffer();
         commands.acquire(this);
-        transitionLayout(cmdbuf, mFullViewRange, ImgUtil::getDefaultLayout(imageInfo.usage));
+        transitionLayout(cmdbuf, mFullViewRange, imgutil::getDefaultLayout(imageInfo.usage));
     }
 }
 
@@ -327,10 +326,10 @@ void VulkanTexture::updateImage(const PixelBufferDescriptor& data, uint32_t widt
 
     VulkanLayout const newLayout = VulkanLayout::TRANSFER_DST;
     VulkanLayout nextLayout = getLayout(transitionRange.baseArrayLayer, miplevel);
-    VkImageLayout const newVkLayout = ImgUtil::getVkLayout(newLayout);
+    VkImageLayout const newVkLayout = imgutil::getVkLayout(newLayout);
 
     if (nextLayout == VulkanLayout::UNDEFINED) {
-        nextLayout = ImgUtil::getDefaultLayout(this->usage);
+        nextLayout = imgutil::getDefaultLayout(this->usage);
     }
 
     transitionLayout(cmdbuf, transitionRange, newLayout);
@@ -374,8 +373,8 @@ void VulkanTexture::updateImageWithBlit(const PixelBufferDescriptor& hostData, u
     VulkanLayout const oldLayout = getLayout(layer, miplevel);
     transitionLayout(cmdbuf, range, newLayout);
 
-    vkCmdBlitImage(cmdbuf, stage->image, ImgUtil::getVkLayout(VulkanLayout::TRANSFER_SRC),
-            mTextureImage, ImgUtil::getVkLayout(newLayout), 1, blitRegions, VK_FILTER_NEAREST);
+    vkCmdBlitImage(cmdbuf, stage->image, imgutil::getVkLayout(VulkanLayout::TRANSFER_SRC),
+            mTextureImage, imgutil::getVkLayout(newLayout), 1, blitRegions, VK_FILTER_NEAREST);
 
     transitionLayout(cmdbuf, range, oldLayout);
 }
@@ -467,7 +466,7 @@ void VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, const VkImageSubres
         for (uint32_t i = firstLayer; i < lastLayer; ++i) {
             for (uint32_t j = firstLevel; j < lastLevel; ++j) {
                 VulkanLayout const layout = getLayout(i, j);
-                ImgUtil::transitionLayout(cmdbuf, {
+                imgutil::transitionLayout(cmdbuf, {
                         .image = mTextureImage,
                         .oldLayout = layout,
                         .newLayout = newLayout,
@@ -482,7 +481,7 @@ void VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, const VkImageSubres
             }
         }
     } else {
-        ImgUtil::transitionLayout(cmdbuf, {
+        imgutil::transitionLayout(cmdbuf, {
             .image = mTextureImage,
             .oldLayout = oldLayout,
             .newLayout = newLayout,

filament/backend/src/vulkan/VulkanUtility.cpp

@@ -655,6 +655,4 @@ uint8_t reduceSampleCount(uint8_t sampleCount, VkSampleCountFlags mask) {
     return mostSignificantBit((sampleCount - 1) & mask);
 }
 
-_BitCountHelper _BitCountHelper::BitCounter = {};
-
 } // namespace filament::backend

filament/backend/src/vulkan/VulkanUtility.h

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

filament/backend/src/vulkan/caching/VulkanDescriptorSetManager.cpp

@@ -42,8 +42,6 @@ constexpr uint8_t MAX_INPUT_ATTACHMENT_BINDING = 1;
 constexpr uint8_t MAX_BINDINGS =
         MAX_SAMPLER_BINDING + MAX_UBO_BINDING + MAX_INPUT_ATTACHMENT_BINDING;
 
-using ImgUtil = VulkanImageUtility;
-
 using Bitmask = VulkanDescriptorSetLayout::Bitmask;
 using DescriptorCount = VulkanDescriptorSetLayout::Count;
 using UBOMap = std::array<std::pair<VkDescriptorBufferInfo, VulkanBufferObject*>, MAX_UBO_BINDING>;
@@ -881,7 +879,7 @@ public:
             vkUpdateDescriptorSets(mDevice, nwrites, descriptorWrites, 0, nullptr);
         }
 
-        VkPipelineLayout const pipelineLayout = getPipelineLayoutFn(outLayouts);
+        VkPipelineLayout const pipelineLayout = getPipelineLayoutFn(outLayouts, program);
         VkCommandBuffer const cmdbuffer = commands->buffer();
 
         BoundState state{};
@@ -1010,15 +1008,15 @@ public:
         } else {
             info.imageView = texture->getViewForType(range, expectedType);
         }
-        info.imageLayout = ImgUtil::getVkLayout(texture->getPrimaryImageLayout());
+        info.imageLayout = imgutil::getVkLayout(texture->getPrimaryImageLayout());
         mSamplerMap[binding] = {info, texture};
         mResources.acquire(texture);
     }
 
     void updateInputAttachment(Handle<VulkanDescriptorSet>, VulkanAttachment attachment) noexcept {
         VkDescriptorImageInfo info = {
-                .imageView = attachment.getImageView(VK_IMAGE_ASPECT_COLOR_BIT),
-                .imageLayout = ImgUtil::getVkLayout(attachment.getLayout()),
+                .imageView = attachment.getImageView(),
+                .imageLayout = imgutil::getVkLayout(attachment.getLayout()),
         };
         mInputAttachment = {attachment, info};
         mResources.acquire(attachment.texture);
@@ -1042,7 +1040,7 @@ public:
         mPlaceHolderImageInfo = {
                 .sampler = sampler,
                 .imageView = texture->getPrimaryImageView(),
-                .imageLayout = ImgUtil::getVkLayout(texture->getPrimaryImageLayout()),
+                .imageLayout = imgutil::getVkLayout(texture->getPrimaryImageLayout()),
         };
     }
 

filament/backend/src/vulkan/caching/VulkanDescriptorSetManager.h

@@ -45,8 +45,8 @@ class VulkanDescriptorSetManager {
 public:
     static constexpr uint8_t UNIQUE_DESCRIPTOR_SET_COUNT =
             VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT;
-    using GetPipelineLayoutFunction =
-            std::function<VkPipelineLayout(VulkanDescriptorSetLayoutList const&)>;
+    using GetPipelineLayoutFunction = std::function<VkPipelineLayout(
+            VulkanDescriptorSetLayoutList const&, VulkanProgram* program)>;
 
     VulkanDescriptorSetManager(VkDevice device, VulkanResourceAllocator* resourceAllocator);
 
@@ -108,3 +108,4 @@ private:
 }// namespace filament::backend
 
 #endif// TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETMANAGER_H
+

filament/backend/src/vulkan/caching/VulkanPipelineLayoutCache.cpp

@@ -21,13 +21,34 @@
 namespace filament::backend {
 
 VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
-        VulkanDescriptorSetLayoutList const& descriptorSetLayouts) {
-    PipelineLayoutKey key = {VK_NULL_HANDLE};
+        VulkanDescriptorSetLayoutList const& descriptorSetLayouts, VulkanProgram* program) {
+    PipelineLayoutKey key = {};
     uint8_t descSetLayoutCount = 0;
     for (auto layoutHandle: descriptorSetLayouts) {
         if (layoutHandle) {
             auto layout = mAllocator->handle_cast<VulkanDescriptorSetLayout*>(layoutHandle);
-            key[descSetLayoutCount++] = layout->vklayout;
+            key.descSetLayouts[descSetLayoutCount++] = layout->vklayout;
+        }
+    }
+
+    // build the push constant layout key
+    uint32_t pushConstantRangeCount = program->getPushConstantRangeCount();
+    auto const& pushCostantRanges = program->getPushConstantRanges();    
+    if (pushConstantRangeCount > 0) {
+        assert_invariant(pushConstantRangeCount <= Program::SHADER_TYPE_COUNT);
+        for (uint8_t i = 0; i < pushConstantRangeCount; ++i) {
+            auto const& range = pushCostantRanges[i];
+            auto& pushConstant = key.pushConstant[i];
+            if (range.stageFlags &  VK_SHADER_STAGE_VERTEX_BIT) {
+                pushConstant.stage = static_cast<uint8_t>(ShaderStage::VERTEX);
+            }
+            if (range.stageFlags &  VK_SHADER_STAGE_FRAGMENT_BIT) {
+                pushConstant.stage = static_cast<uint8_t>(ShaderStage::FRAGMENT);
+            }
+            if (range.stageFlags &  VK_SHADER_STAGE_COMPUTE_BIT) {
+                pushConstant.stage = static_cast<uint8_t>(ShaderStage::COMPUTE);
+            }
+            pushConstant.size = range.size;
         }
     }
 
@@ -42,9 +63,11 @@ VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
         .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
         .pNext = nullptr,
         .setLayoutCount = (uint32_t) descSetLayoutCount,
-        .pSetLayouts = key.data(),
-        .pushConstantRangeCount = 0,
+        .pSetLayouts = key.descSetLayouts.data(),
+        .pushConstantRangeCount = pushConstantRangeCount,
+        .pPushConstantRanges = pushCostantRanges,
     };
+
     VkPipelineLayout layout;
     vkCreatePipelineLayout(mDevice, &info, VKALLOC, &layout);
 

filament/backend/src/vulkan/caching/VulkanPipelineLayoutCache.h

@@ -35,13 +35,29 @@ public:
 
     void terminate() noexcept;
 
-    using PipelineLayoutKey = std::array<VkDescriptorSetLayout,
-            VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;
+    struct PushConstantKey {
+        uint8_t stage;// We have one set of push constant per shader stage (fragment, vertex, etc).
+        uint8_t size;
+        // Note that there is also an offset parameter for push constants, but
+        // we always assume our update range will have the offset 0.
+    };
+
+    struct PipelineLayoutKey {
+        using DescriptorSetLayoutArray = std::array<VkDescriptorSetLayout,
+                VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT>;
+        DescriptorSetLayoutArray descSetLayouts = {};                   // 8 * 3
+        PushConstantKey pushConstant[Program::SHADER_TYPE_COUNT] = {};  // 2 * 3
+        uint16_t padding = 0;
+    };
+    static_assert(sizeof(PipelineLayoutKey) == 32);
 
     VulkanPipelineLayoutCache(VulkanPipelineLayoutCache const&) = delete;
     VulkanPipelineLayoutCache& operator=(VulkanPipelineLayoutCache const&) = delete;
 
-    VkPipelineLayout getLayout(VulkanDescriptorSetLayoutList const& descriptorSetLayouts);
+    // A pipeline layout depends on the descriptor set layout and the push constant ranges, which
+    // are described in the program.
+    VkPipelineLayout getLayout(VulkanDescriptorSetLayoutList const& descriptorSetLayouts,
+            VulkanProgram* program);
 
 private:
     using Timestamp = uint64_t;

filament/backend/src/vulkan/platform/VulkanPlatform.cpp

@@ -44,7 +44,11 @@ namespace {
 
 constexpr uint32_t const INVALID_VK_INDEX = 0xFFFFFFFF;
 
-typedef std::unordered_set<std::string_view> ExtensionSet;
+using ExtensionSet = VulkanPlatform::ExtensionSet;
+
+inline bool setContains(ExtensionSet const& set, utils::CString const& extension) {
+    return set.find(extension) != set.end();
+};
 
 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
 // These strings need to be allocated outside a function stack
@@ -80,7 +84,7 @@ FixedCapacityVector<const char*> getEnabledLayers() {
 
 void printDeviceInfo(VkInstance instance, VkPhysicalDevice device) {
     // Print some driver or MoltenVK information if it is available.
-    if (vkGetPhysicalDeviceProperties2KHR) {
+    if (vkGetPhysicalDeviceProperties2) {
         VkPhysicalDeviceDriverProperties driverProperties = {
                 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
         };
@@ -88,7 +92,7 @@ void printDeviceInfo(VkInstance instance, VkPhysicalDevice device) {
                 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
                 .pNext = &driverProperties,
         };
-        vkGetPhysicalDeviceProperties2KHR(device, &physicalDeviceProperties2);
+        vkGetPhysicalDeviceProperties2(device, &physicalDeviceProperties2);
         utils::slog.i << "Vulkan device driver: " << driverProperties.driverName << " "
                       << driverProperties.driverInfo << utils::io::endl;
     }
@@ -137,53 +141,48 @@ void printDepthFormats(VkPhysicalDevice device) {
     const VkFormatFeatureFlags required = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
                                               | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
     utils::slog.i << "Sampleable depth formats: ";
-    for (VkFormat format = (VkFormat) 1;;) {
+    for (VkFormat format : ALL_VK_FORMATS) {
         VkFormatProperties props;
         vkGetPhysicalDeviceFormatProperties(device, format, &props);
         if ((props.optimalTilingFeatures & required) == required) {
             utils::slog.i << format << " ";
         }
-        if (format == VK_FORMAT_ASTC_12x12_SRGB_BLOCK) {
-            utils::slog.i << utils::io::endl;
-            break;
-        }
-        format = (VkFormat) (1 + (int) format);
     }
+    utils::slog.i << utils::io::endl;
 }
 #endif
 
-ExtensionSet getInstanceExtensions() {
-    std::string_view const TARGET_EXTS[] = {
-            // Request all cross-platform extensions.
-            VK_KHR_SURFACE_EXTENSION_NAME,
-            VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
+ExtensionSet getInstanceExtensions(ExtensionSet const& externallyRequiredExts = {}) {
+    ExtensionSet const TARGET_EXTS = {
+        // Request all cross-platform extensions.
+        VK_KHR_SURFACE_EXTENSION_NAME,
+        VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
 
-            // Request these if available.
+    // Request these if available.
 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
-            VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
+        VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
 #endif
-            VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,
+        VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,
 
 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
-            VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
+        VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
 #endif
     };
     ExtensionSet exts;
-    FixedCapacityVector<VkExtensionProperties> const availableExts
-            = filament::backend::enumerate(vkEnumerateInstanceExtensionProperties,
+    FixedCapacityVector<VkExtensionProperties> const availableExts =
+            filament::backend::enumerate(vkEnumerateInstanceExtensionProperties,
                     static_cast<char const*>(nullptr) /* pLayerName */);
     for (auto const& extProps: availableExts) {
-        for (auto const& targetExt: TARGET_EXTS) {
-            if (targetExt == extProps.extensionName) {
-                exts.insert(targetExt);
-            }
+        utils::CString name { extProps.extensionName };
+        if (setContains(TARGET_EXTS, name) || setContains(externallyRequiredExts, name)) {
+            exts.insert(name);
         }
     }
     return exts;
 }
 
 ExtensionSet getDeviceExtensions(VkPhysicalDevice device) {
-    std::string_view const TARGET_EXTS[] = {
+    ExtensionSet const TARGET_EXTS = {
 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
             VK_EXT_DEBUG_MARKER_EXTENSION_NAME,
 #endif
@@ -198,10 +197,9 @@ ExtensionSet getDeviceExtensions(VkPhysicalDevice device) {
             = filament::backend::enumerate(vkEnumerateDeviceExtensionProperties, device,
                     static_cast<const char*>(nullptr) /* pLayerName */);
     for (auto const& extension: extensions) {
-        for (auto const& targetExt: TARGET_EXTS) {
-            if (targetExt == extension.extensionName) {
-                exts.insert(targetExt);
-            }
+        utils::CString name { extension.extensionName };
+        if (setContains(TARGET_EXTS, name)) {
+            exts.insert(name);
         }
     }
     return exts;
@@ -249,7 +247,7 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
         ppEnabledExtensions[enabledExtensionCount++] = VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME;
     }
     // Request platform-specific extensions.
-    for (auto const requiredExt: requiredExts) {
+    for (auto const& requiredExt: requiredExts) {
         assert_invariant(enabledExtensionCount < MAX_INSTANCE_EXTENSION_COUNT);
         ppEnabledExtensions[enabledExtensionCount++] = requiredExt.data();
     }
@@ -257,13 +255,14 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
     // Create the Vulkan instance.
     VkApplicationInfo appInfo = {};
     appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+    appInfo.pEngineName = "Filament";
     appInfo.apiVersion
             = VK_MAKE_API_VERSION(0, FVK_REQUIRED_VERSION_MAJOR, FVK_REQUIRED_VERSION_MINOR, 0);
     instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instanceCreateInfo.pApplicationInfo = &appInfo;
     instanceCreateInfo.enabledExtensionCount = enabledExtensionCount;
     instanceCreateInfo.ppEnabledExtensionNames = ppEnabledExtensions;
-    if (requiredExts.find(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) != requiredExts.end()) {
+    if (setContains(requiredExts, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)) {
         instanceCreateInfo.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
     }
 
@@ -286,8 +285,8 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
 }
 
 VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
-        const VkPhysicalDeviceFeatures& features, uint32_t graphicsQueueFamilyIndex,
-        const ExtensionSet& deviceExtensions) {
+        VkPhysicalDeviceFeatures const& features, uint32_t graphicsQueueFamilyIndex,
+        ExtensionSet const& deviceExtensions) {
     VkDevice device;
     VkDeviceQueueCreateInfo deviceQueueCreateInfo[1] = {};
     const float queuePriority[] = {1.0f};
@@ -295,9 +294,9 @@ VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
     FixedCapacityVector<const char*> requestExtensions;
     requestExtensions.reserve(deviceExtensions.size() + 1);
 
-    // TODO:We don't really need this if we only ever expect headless swapchains.
+    // TODO: We don't really need this if we only ever expect headless swapchains.
     requestExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
-    for (auto ext: deviceExtensions) {
+    for (auto const& ext: deviceExtensions) {
         requestExtensions.push_back(ext.data());
     }
     deviceQueueCreateInfo->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
@@ -326,12 +325,12 @@ VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
             .imageViewFormatSwizzle = VK_TRUE,
             .mutableComparisonSamplers = VK_TRUE,
     };
-    if (deviceExtensions.find(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) != deviceExtensions.end()) {
+    if (setContains(deviceExtensions, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)) {
         deviceCreateInfo.pNext = &portability;
     }
 
     VkResult result = vkCreateDevice(physicalDevice, &deviceCreateInfo, VKALLOC, &device);
-    ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateDevice error.");
+    ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateDevice error=%d.", result);
 
     return device;
 }
@@ -343,18 +342,18 @@ std::tuple<ExtensionSet, ExtensionSet> pruneExtensions(VkPhysicalDevice device,
     ExtensionSet newInstExts = instExts;
     ExtensionSet newDeviceExts = deviceExts;
 
-#if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)    
+#if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
     // debugUtils and debugMarkers extensions are used mutually exclusively.
-    if (newInstExts.find(VK_EXT_DEBUG_UTILS_EXTENSION_NAME) != newInstExts.end()
-            && newDeviceExts.find(VK_EXT_DEBUG_MARKER_EXTENSION_NAME) != newDeviceExts.end()) {
+    if (setContains(newInstExts, VK_EXT_DEBUG_UTILS_EXTENSION_NAME) &&
+            setContains(newInstExts, VK_EXT_DEBUG_MARKER_EXTENSION_NAME)) {
         newDeviceExts.erase(VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
     }
-#endif    
+#endif
 
 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
     // debugMarker must also request debugReport the instance extension. So check if that's present.
-    if (newDeviceExts.find(VK_EXT_DEBUG_MARKER_EXTENSION_NAME) != newDeviceExts.end()
-            && newInstExts.find(VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == newInstExts.end()) {
+    if (setContains(newInstExts, VK_EXT_DEBUG_MARKER_EXTENSION_NAME) &&
+            !setContains(newInstExts, VK_EXT_DEBUG_MARKER_EXTENSION_NAME)) {
         newDeviceExts.erase(VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
     }
 #endif
@@ -404,7 +403,7 @@ inline int deviceTypeOrder(VkPhysicalDeviceType deviceType) {
         case VK_PHYSICAL_DEVICE_TYPE_OTHER:
             return 1;
         default:
-            utils::slog.w << "devcieTypeOrder: Unexpected deviceType: " << deviceType
+            utils::slog.w << "deviceTypeOrder: Unexpected deviceType: " << deviceType
                           << utils::io::endl;
             return -1;
     }
@@ -499,7 +498,7 @@ VkPhysicalDevice selectPhysicalDevice(VkInstance instance,
     return device;
 }
 
-VkFormatList findAttachmentDepthFormats(VkPhysicalDevice device) {
+VkFormatList findAttachmentDepthStencilFormats(VkPhysicalDevice device) {
     VkFormatFeatureFlags const features = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
 
     // The ordering here indicates the preference of choosing depth+stencil format.
@@ -523,6 +522,24 @@ VkFormatList findAttachmentDepthFormats(VkPhysicalDevice device) {
     return ret;
 }
 
+VkFormatList findBlittableDepthStencilFormats(VkPhysicalDevice device) {
+    std::vector<VkFormat> selectedFormats;
+    VkFormatFeatureFlags const required = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT |
+            VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
+    for (VkFormat format : ALL_VK_FORMATS) {
+        if (isVkDepthFormat(format)) {
+            VkFormatProperties props;
+            vkGetPhysicalDeviceFormatProperties(device, format, &props);
+            if ((props.optimalTilingFeatures & required) == required) {
+                selectedFormats.push_back(format);
+            }
+        }
+    }
+    VkFormatList ret(selectedFormats.size());
+    std::copy(selectedFormats.begin(), selectedFormats.end(), ret.begin());
+    return ret;
+}
+
 }// anonymous namespace
 
 using SwapChainPtr = VulkanPlatform::SwapChainPtr;
@@ -542,6 +559,7 @@ struct VulkanPlatformPrivate {
     std::unordered_set<SwapChainPtr> mHeadlessSwapChains;
 
     bool mSharedContext = false;
+    bool mForceXCBSwapchain = false;
 };
 
 void VulkanPlatform::terminate() {
@@ -595,7 +613,25 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
     ExtensionSet instExts;
     // If using a shared context, we do not assume any extensions.
     if (!mImpl->mSharedContext) {
-        instExts = getInstanceExtensions();
+        // This constains instance extensions that are required for the platform, which includes
+        // swapchain surface extensions.
+        auto const& swapchainExts = getSwapchainInstanceExtensions();
+        instExts = getInstanceExtensions(swapchainExts);
+
+#if defined(FILAMENT_SUPPORTS_XCB) && defined(FILAMENT_SUPPORTS_XLIB)
+        // For the special case where we're on linux and both xcb and xlib are "required", then we
+        // check if the set of supported extensions contain both of them.  If only xcb is supported,
+        // we force XCB surface creation.  This workaround is needed for the default swiftshader
+        // build where only XCB is available.
+        if (setContains(swapchainExts, VK_KHR_XCB_SURFACE_EXTENSION_NAME) &&
+                setContains(swapchainExts, VK_KHR_XLIB_SURFACE_EXTENSION_NAME)) {
+            // Assume only XCB is left, then we force the XCB path in the swapchain creation.
+            mImpl->mForceXCBSwapchain = !setContains(instExts, VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
+            assert_invariant(!mImpl->mForceXCBSwapchain ||
+                             setContains(instExts, VK_KHR_XCB_SURFACE_EXTENSION_NAME));
+        }
+#endif
+
         instExts.merge(getRequiredInstanceExtensions());
     }
 
@@ -657,10 +693,8 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
     assert_invariant(mImpl->mGraphicsQueue != VK_NULL_HANDLE);
 
     // Store the extension support in the context
-    context.mDebugUtilsSupported
-            = instExts.find(VK_EXT_DEBUG_UTILS_EXTENSION_NAME) != instExts.end();
-    context.mDebugMarkersSupported
-            = deviceExts.find(VK_EXT_DEBUG_MARKER_EXTENSION_NAME) != deviceExts.end();
+    context.mDebugUtilsSupported = setContains(instExts, VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+    context.mDebugMarkersSupported = setContains(deviceExts, VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
 
 #ifdef NDEBUG
     // If we are in release build, we should not have turned on debug extensions
@@ -668,9 +702,11 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
             "Debug utils should not be enabled in release build.");
 #endif
 
-    context.mDepthFormats = findAttachmentDepthFormats(mImpl->mPhysicalDevice);
+    context.mDepthStencilFormats = findAttachmentDepthStencilFormats(mImpl->mPhysicalDevice);
+    context.mBlittableDepthStencilFormats =
+            findBlittableDepthStencilFormats(mImpl->mPhysicalDevice);
 
-    assert_invariant(context.mDepthFormats.size() > 0);
+    assert_invariant(context.mDepthStencilFormats.size() > 0);
 
 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
     printDepthFormats(mImpl->mPhysicalDevice);
@@ -731,6 +767,10 @@ SwapChainPtr VulkanPlatform::createSwapChain(void* nativeWindow, uint64_t flags,
         return swapchain;
     }
 
+    if (mImpl->mForceXCBSwapchain) {
+        flags |= SWAP_CHAIN_CONFIG_ENABLE_XCB;
+    }
+
     auto [surface, fallbackExtent] = createVkSurfaceKHR(nativeWindow, mImpl->mInstance, flags);
     // The VulkanPlatformSurfaceSwapChain now `owns` the surface.
     VulkanPlatformSurfaceSwapChain* swapchain = new VulkanPlatformSurfaceSwapChain(mImpl->mContext,

filament/backend/src/vulkan/platform/VulkanPlatformAndroidLinuxWindows.cpp

@@ -46,7 +46,7 @@
             uint32_t height;
         } wl;
     }// anonymous namespace
-#elif LINUX_OR_FREEBSD && defined(FILAMENT_SUPPORTS_X11)
+#elif defined(LINUX_OR_FREEBSD) && defined(FILAMENT_SUPPORTS_X11)
     // TODO: we should allow for headless on Linux explicitly. Right now this is the headless path
     // (with no FILAMENT_SUPPORTS_XCB or FILAMENT_SUPPORTS_XLIB).
     #include <dlfcn.h>
@@ -86,22 +86,23 @@ using namespace bluevk;
 
 namespace filament::backend {
 
-VulkanPlatform::ExtensionSet VulkanPlatform::getRequiredInstanceExtensions() {
-    VulkanPlatform::ExtensionSet ret;
-    #if defined(__ANDROID__)
-        ret.insert("VK_KHR_android_surface");
-    #elif defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
-        ret.insert("VK_KHR_wayland_surface");
-    #elif LINUX_OR_FREEBSD && defined(FILAMENT_SUPPORTS_X11)
-        #if defined(FILAMENT_SUPPORTS_XCB)
-            ret.insert("VK_KHR_xcb_surface");
-        #endif
-        #if defined(FILAMENT_SUPPORTS_XLIB)
-            ret.insert("VK_KHR_xlib_surface");
-        #endif
-    #elif defined(WIN32)
-        ret.insert("VK_KHR_win32_surface");
+VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() {
+    VulkanPlatform::ExtensionSet const ret = {
+#if defined(__ANDROID__)
+        VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
+#elif defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
+        VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
+#elif defined(LINUX_OR_FREEBSD) && defined(FILAMENT_SUPPORTS_X11)
+    #if defined(FILAMENT_SUPPORTS_XCB)
+        VK_KHR_XCB_SURFACE_EXTENSION_NAME,
     #endif
+    #if defined(FILAMENT_SUPPORTS_XLIB)
+        VK_KHR_XLIB_SURFACE_EXTENSION_NAME,
+    #endif
+#elif defined(WIN32)
+        VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
+#endif
+    };
     return ret;
 }
 
@@ -138,7 +139,7 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
         VkResult const result = vkCreateWaylandSurfaceKHR(instance, &createInfo, VKALLOC,
                 (VkSurfaceKHR*) &surface);
         ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateWaylandSurfaceKHR error.");
-    #elif LINUX_OR_FREEBSD && defined(FILAMENT_SUPPORTS_X11)
+    #elif defined(LINUX_OR_FREEBSD) && defined(FILAMENT_SUPPORTS_X11)
         if (g_x11_vk.library == nullptr) {
             g_x11_vk.library = dlopen(LIBRARY_X11, RTLD_LOCAL | RTLD_NOW);
             ASSERT_PRECONDITION(g_x11_vk.library, "Unable to open X11 library.");
@@ -146,15 +147,11 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
                 g_x11_vk.xcbConnect = (XCB_CONNECT) dlsym(g_x11_vk.library, "xcb_connect");
                 int screen;
                 g_x11_vk.connection = g_x11_vk.xcbConnect(nullptr, &screen);
-                ASSERT_POSTCONDITION(vkCreateXcbSurfaceKHR,
-                        "Unable to load vkCreateXcbSurfaceKHR function.");
             #endif
             #if defined(FILAMENT_SUPPORTS_XLIB)
                 g_x11_vk.openDisplay = (X11_OPEN_DISPLAY) dlsym(g_x11_vk.library, "XOpenDisplay");
                 g_x11_vk.display = g_x11_vk.openDisplay(NULL);
                 ASSERT_PRECONDITION(g_x11_vk.display, "Unable to open X11 display.");
-                ASSERT_POSTCONDITION(vkCreateXlibSurfaceKHR,
-                        "Unable to load vkCreateXlibSurfaceKHR function.");
             #endif
         }
         #if defined(FILAMENT_SUPPORTS_XCB) || defined(FILAMENT_SUPPORTS_XLIB)
@@ -167,6 +164,9 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
                 useXcb = true;
             #endif
             if (useXcb) {
+                ASSERT_POSTCONDITION(vkCreateXcbSurfaceKHR,
+                        "Unable to load vkCreateXcbSurfaceKHR function.");
+
                 VkXcbSurfaceCreateInfoKHR const createInfo = {
                         .sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
                         .connection = g_x11_vk.connection,
@@ -179,6 +179,9 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
         #endif
         #if defined(FILAMENT_SUPPORTS_XLIB)
             if (!useXcb) {
+                ASSERT_POSTCONDITION(vkCreateXlibSurfaceKHR,
+                        "Unable to load vkCreateXlibSurfaceKHR function.");
+
                 VkXlibSurfaceCreateInfoKHR const createInfo = {
                         .sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
                         .dpy = g_x11_vk.display,

filament/backend/src/vulkan/platform/VulkanPlatformApple.mm

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

filament/backend/src/vulkan/platform/VulkanPlatformSwapChainImpl.cpp

@@ -243,7 +243,7 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
     mSwapChainBundle.colors = enumerate(vkGetSwapchainImagesKHR, mDevice, mSwapchain);
     mSwapChainBundle.colorFormat = surfaceFormat.format;
     mSwapChainBundle.depthFormat =
-            selectDepthFormat(mContext.getAttachmentDepthFormats(), mHasStencil);
+            selectDepthFormat(mContext.getAttachmentDepthStencilFormats(), mHasStencil);
     mSwapChainBundle.depth = createImage(mSwapChainBundle.extent, mSwapChainBundle.depthFormat);
 
     slog.i << "vkCreateSwapchain"
@@ -330,7 +330,7 @@ VulkanPlatformHeadlessSwapChain::VulkanPlatformHeadlessSwapChain(VulkanContext c
 
     bool const hasStencil = (flags & backend::SWAP_CHAIN_HAS_STENCIL_BUFFER) != 0;
     mSwapChainBundle.depthFormat =
-            selectDepthFormat(mContext.getAttachmentDepthFormats(), hasStencil);
+            selectDepthFormat(mContext.getAttachmentDepthStencilFormats(), hasStencil);
     mSwapChainBundle.depth = createImage(extent, mSwapChainBundle.depthFormat);
 }
 

filament/backend/src/vulkan/spirv/VulkanSpirvUtils.cpp

@@ -183,7 +183,7 @@ std::tuple<uint32_t,uint32_t, uint32_t> getProgramBindings(Program::ShaderBlob c
     constexpr uint32_t IATTACHMENT = 2;
     uint32_t ubo = 0, sampler = 0, inputAttachment = 0;
 
-    for (auto const [target, setId]: targetToSet) {
+    for (auto const& [target, setId]: targetToSet) {
         uint32_t const binding = targetToBinding[target];
         assert_invariant(binding < 32);
         switch(setId) {

filament/backend/test/BackendTest.cpp

@@ -20,6 +20,7 @@
 
 #include "BackendTest.h"
 
+#include <utils/Log.h>
 #include <utils/Hash.h>
 
 #include <fstream>
@@ -149,50 +150,59 @@ void BackendTest::renderTriangle(Handle<HwRenderTarget> renderTarget,
 }
 
 void BackendTest::readPixelsAndAssertHash(const char* testName, size_t width, size_t height,
-        Handle<HwRenderTarget> rt, uint32_t expectedHash, bool exportScreenshot) {
-    void* buffer = calloc(1, width * height * 4);
+        Handle<HwRenderTarget> rt, uint32_t const expectedHash, bool const exportScreenshot) {
+    auto img = getRenderTargetRGB(rt, width, height);
+    uint32_t hash = computeImageHash(img);
 
-    struct Capture {
-        uint32_t expectedHash;
-        char* name;
-        bool exportScreenshot;
-        size_t width, height;
-    };
-    auto* c = new Capture();
-    c->expectedHash = expectedHash;
-    c->name = strdup(testName);
-    c->exportScreenshot = exportScreenshot;
-    c->width = width;
-    c->height = height;
-
-    PixelBufferDescriptor pbd(buffer, width * height * 4, PixelDataFormat::RGBA, PixelDataType::UBYTE,
-            1, 0, 0, width, [](void* buffer, size_t size, void* user) {
-                auto* c = (Capture*)user;
-
-                // Export a screenshot, if requested.
-                if (c->exportScreenshot) {
-#ifndef IOS
-                    LinearImage image(c->width, c->height, 4);
-                    image = toLinearWithAlpha<uint8_t>(c->width, c->height, c->width * 4,
-                            (uint8_t*) buffer);
-                    const std::string png = std::string(c->name) + ".png";
-                    std::ofstream outputStream(png.c_str(), std::ios::binary | std::ios::trunc);
-                    ImageEncoder::encode(outputStream, ImageEncoder::Format::PNG, image, "",
-                            png);
-#endif
-                }
-
-                // Hash the contents of the buffer and check that they match.
-                uint32_t hash = utils::hash::murmur3((const uint32_t*) buffer, size / 4, 0);
-                ASSERT_EQ(hash, c->expectedHash) << c->name << " failed: hashes do not match." << std::endl;
-
-                free(buffer);
-                free(c->name);
-                free(c);
-            }, (void*)c);
-    getDriverApi().readPixels(rt, 0, 0, width, height, std::move(pbd));
+    if (exportScreenshot) {
+        writeImage(img, width, height, utils::CString(testName));
+    }
+    ASSERT_EQ(hash, expectedHash) << testName << " failed: hashes do not match." << std::endl;
 }
 
+void BackendTest::writeImage(utils::FixedCapacityVector<uint8_t> img, size_t w, size_t h,
+        utils::CString const& fname) {
+    constexpr size_t MAX_FNAME_LEN = 50;
+    constexpr size_t FNAME_EXT_LEN = 4;
+    constexpr size_t TOTAL_LEN = MAX_FNAME_LEN + FNAME_EXT_LEN + 1;
+    char buf[TOTAL_LEN];
+
+    ASSERT_PRECONDITION(fname.size() <= MAX_FNAME_LEN, "File name %s is too long", fname.c_str());
+
+    snprintf(buf, TOTAL_LEN, "%s.png", fname.c_str());
+
+#ifndef IOS
+    LinearImage image(w, h, 4);
+    image = toLinearWithAlpha<uint8_t>(w, h, w * 4, img.data());
+    std::ofstream pngstrm(buf, std::ios::binary | std::ios::trunc);
+    ImageEncoder::encode(pngstrm, ImageEncoder::Format::PNG, image, "", buf);
+#endif
+}
+
+utils::FixedCapacityVector<uint8_t> BackendTest::getRenderTarget(
+        Handle<HwRenderTarget> rt, size_t width, size_t height, PixelDataFormat format,
+        PixelDataType dataType) {
+    auto& api = getDriverApi();
+    size_t const size = width * height * 4;
+    utils::FixedCapacityVector<uint8_t> result(size);
+    PixelBufferDescriptor pb(result.data(), size, format, dataType);
+    api.readPixels(rt, 0, 0, width, height, std::move(pb));
+    flushAndWait();
+
+    return result;
+}
+
+uint32_t BackendTest::computeImageHash(utils::FixedCapacityVector<uint8_t> const& img) {
+    return utils::hash::murmur3((uint32_t*) img.data(), img.size() / 4, 0);
+}
+
+utils::FixedCapacityVector<uint8_t> BackendTest::getRenderTargetRGB(
+        Handle<HwRenderTarget> rt, size_t width, size_t height) {
+    return getRenderTarget(rt, width, height, PixelDataFormat::RGBA,
+            PixelDataType::UBYTE);
+}
+
+
 class Environment : public ::testing::Environment {
 public:
     virtual void SetUp() override {

filament/backend/test/BackendTest.h

@@ -67,6 +67,17 @@ protected:
     filament::backend::Driver& getDriver() { return *driver; }
 
 private:
+    void writeImage(utils::FixedCapacityVector<uint8_t> img, size_t w, size_t h,
+            utils::CString const& fname);
+    utils::FixedCapacityVector<uint8_t> getRenderTarget(
+            filament::backend::Handle<filament::backend::HwRenderTarget> rt, size_t width,
+            size_t height, filament::backend::PixelDataFormat format,
+            filament::backend::PixelDataType dataType);
+    uint32_t computeImageHash(utils::FixedCapacityVector<uint8_t> const& img);
+
+    utils::FixedCapacityVector<uint8_t> getRenderTargetRGB(
+            filament::backend::Handle<filament::backend::HwRenderTarget> rt, size_t width,
+            size_t height);
 
     filament::backend::Driver* driver = nullptr;
     filament::backend::CommandBufferQueue commandBufferQueue;

filament/backend/test/ShaderGenerator.cpp

@@ -79,6 +79,20 @@ ShaderGenerator::ShaderGenerator(std::string vertex, std::string fragment,
           mVertexBlob(transpileShader(ShaderStage::VERTEX, std::move(vertex), backend, isMobile, sib)),
           mFragmentBlob(transpileShader(ShaderStage::FRAGMENT, std::move(fragment), backend,
                   isMobile, sib)) {
+    switch (backend) {
+        case Backend::OPENGL:
+            mShaderLanguage = filament::backend::ShaderLanguage::ESSL3;
+            break;
+        case Backend::VULKAN:
+            mShaderLanguage = filament::backend::ShaderLanguage::SPIRV;
+            break;
+        case Backend::METAL:
+            mShaderLanguage = filament::backend::ShaderLanguage::MSL;
+            break;
+        case Backend::NOOP:
+            mShaderLanguage = filament::backend::ShaderLanguage::ESSL3;
+            break;
+    }
 }
 
 ShaderGenerator::Blob ShaderGenerator::transpileShader(
@@ -160,6 +174,7 @@ ShaderGenerator::Blob ShaderGenerator::transpileShader(
 
 Program ShaderGenerator::getProgram(filament::backend::DriverApi&) noexcept {
     Program program;
+    program.shaderLanguage(mShaderLanguage);
     program.shader(ShaderStage::VERTEX, mVertexBlob.data(), mVertexBlob.size());
     program.shader(ShaderStage::FRAGMENT, mFragmentBlob.data(), mFragmentBlob.size());
     return program;

filament/backend/test/ShaderGenerator.h

@@ -60,6 +60,7 @@ private:
     Blob mFragmentBlob;
     std::string mCompiledVertexShader;
     std::string mCompiledFragmentShader;
+    filament::backend::ShaderLanguage mShaderLanguage;
 
 };
 

filament/backend/test/test_Blit.cpp

@@ -60,36 +60,6 @@ struct MaterialParams {
     float4 scale;
 };
 
-struct ScreenshotParams {
-    int width;
-    int height;
-    const char* filename;
-    uint32_t pixelHashResult;
-};
-
-#ifdef IOS
-static void dumpScreenshot(DriverApi& dapi, Handle<HwRenderTarget> rt, ScreenshotParams* params) {}
-#else
-static void dumpScreenshot(DriverApi& dapi, Handle<HwRenderTarget> rt, ScreenshotParams* params) {
-    using namespace image;
-    const size_t size = params->width * params->height * 4;
-    void* buffer = calloc(1, size);
-    auto cb = [](void* buffer, size_t size, void* user) {
-        ScreenshotParams* params = (ScreenshotParams*) user;
-        int w = params->width, h = params->height;
-        const uint32_t* texels = (uint32_t*) buffer;
-        params->pixelHashResult = utils::hash::murmur3(texels, size / 4, 0);
-        LinearImage image(w, h, 4);
-        image = toLinearWithAlpha<uint8_t>(w, h, w * 4, (uint8_t*) buffer);
-        std::ofstream pngstrm(params->filename, std::ios::binary | std::ios::trunc);
-        ImageEncoder::encode(pngstrm, ImageEncoder::Format::PNG, image, "", params->filename);
-    };
-    PixelBufferDescriptor pb(buffer, size, PixelDataFormat::RGBA, PixelDataType::UBYTE, cb,
-            (void*) params);
-    dapi.readPixels(rt, 0, 0, params->width, params->height, std::move(pb));
-}
-#endif
-
 static void uploadUniforms(DriverApi& dapi, Handle<HwBufferObject> ubh, MaterialParams params) {
     MaterialParams* tmp = new MaterialParams(params);
     auto cb = [](void* buffer, size_t size, void* user) {
@@ -238,26 +208,17 @@ TEST_F(BackendTest, ColorMagnify) {
             {0, 0, kSrcTexWidth >> srcLevel, kSrcTexHeight >> srcLevel}, SamplerMagFilter::LINEAR);
 
     // Push through an empty frame to allow the texture to upload and the blit to execute.
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);
     api.commit(swapChain);
     api.endFrame(0);
 
     // Grab a screenshot.
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "ColorMagnify.png" };
-    api.beginFrame(0, 0);
-    dumpScreenshot(api, dstRenderTargets[0], &params);
-    api.commit(swapChain);
+    api.beginFrame(0, 0, 0);
+    constexpr uint32_t expected = 0x410bdd31;
+    readPixelsAndAssertHash("ColorMagnify", kDstTexWidth, kDstTexHeight, dstRenderTargets[0],
+            expected, true);
     api.endFrame(0);
-
-    // Wait for the ReadPixels result to come back.
-    api.finish();
-    executeCommands();
-    getDriver().purge();
-
-    // Check if the image matches perfectly to our golden run.
-    const uint32_t expected = 0x410bdd31;
-    printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", params.pixelHashResult, expected);
-    EXPECT_TRUE(params.pixelHashResult == expected);
+    flushAndWait();
 
     // Cleanup.
     api.destroyTexture(srcTexture);
@@ -315,17 +276,15 @@ TEST_F(BackendTest, ColorMinify) {
             SamplerMagFilter::LINEAR);
 
     // Grab a screenshot.
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "ColorMinify.png" };
-    dumpScreenshot(api, dstRenderTargets[0], &params);
+    api.beginFrame(0, 0, 0);
+    constexpr uint32_t expected = 0xf3d9c53f;
+    readPixelsAndAssertHash("ColorMinify", kDstTexWidth, kDstTexHeight, dstRenderTargets[0],
+            expected, true);
 
-    // Wait for the ReadPixels result to come back.
+    api.commit(swapChain);
+    api.endFrame(0);
     flushAndWait();
 
-    // Check if the image matches perfectly to our golden run.
-    const uint32_t expected = 0xf3d9c53f;
-    printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", params.pixelHashResult, expected);
-    EXPECT_TRUE(params.pixelHashResult == expected);
-
     // Cleanup.
     api.destroyTexture(srcTexture);
     api.destroyTexture(dstTexture);
@@ -402,7 +361,7 @@ TEST_F(BackendTest, ColorResolve) {
     });
 
     // FIXME: on Metal this triangle is not drawn. Can't understand why.
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);
         api.beginRenderPass(srcRenderTarget, params);
             api.bindUniformBuffer(0, ubuffer);
             api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
@@ -416,17 +375,13 @@ TEST_F(BackendTest, ColorResolve) {
             SamplerMagFilter::NEAREST);
 
     // Grab a screenshot.
-    ScreenshotParams sparams{ kDstTexWidth, kDstTexHeight, "ColorResolve.png" };
-    dumpScreenshot(api, dstRenderTarget, &sparams);
-
-    // Wait for the ReadPixels result to come back.
+    api.beginFrame(0, 0, 0);
+    constexpr uint32_t expected = 0xebfac2ef;
+    readPixelsAndAssertHash("ColorResolve", kDstTexWidth, kDstTexHeight, dstRenderTarget,
+            expected, true);
+    api.endFrame(0);
     flushAndWait();
 
-    // Check if the image matches perfectly to our golden run.
-    const uint32_t expected = 0xebfac2ef;
-    printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", sparams.pixelHashResult, expected);
-    EXPECT_TRUE(sparams.pixelHashResult == expected);
-
     // Cleanup.
     api.destroyBufferObject(ubuffer);
     api.destroyProgram(program);
@@ -484,26 +439,17 @@ TEST_F(BackendTest, Blit2DTextureArray) {
             {0, 0, kSrcTexWidth >> srcLevel, kSrcTexHeight >> srcLevel}, SamplerMagFilter::LINEAR);
 
     // Push through an empty frame to allow the texture to upload and the blit to execute.
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);
     api.commit(swapChain);
     api.endFrame(0);
 
     // Grab a screenshot.
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "Blit2DTextureArray.png" };
-    api.beginFrame(0, 0);
-    dumpScreenshot(api, dstRenderTarget, &params);
-    api.commit(swapChain);
+    api.beginFrame(0, 0, 0);
+    constexpr uint32_t expected = 0x8de7d55b;
+    readPixelsAndAssertHash("Blit2DTextureArray", kDstTexWidth, kDstTexHeight, dstRenderTarget,
+            expected, true);
     api.endFrame(0);
-
-    // Wait for the ReadPixels result to come back.
-    api.finish();
-    executeCommands();
-    getDriver().purge();
-
-    // Check if the image matches perfectly to our golden run.
-    const uint32_t expected = 0x8de7d55b;
-    printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", params.pixelHashResult, expected);
-    EXPECT_TRUE(params.pixelHashResult == expected);
+    flushAndWait();
 
     // Cleanup.
     api.destroyTexture(srcTexture);
@@ -574,32 +520,21 @@ TEST_F(BackendTest, BlitRegion) {
             SamplerMagFilter::LINEAR);
 
     // Push through an empty frame to allow the texture to upload and the blit to execute.
-    api.beginFrame(0, 0);
+    api.beginFrame(0, 0, 0);
     api.commit(swapChain);
     api.endFrame(0);
 
-    // Grab a screenshot.
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "BlitRegion.png" };
-    api.beginFrame(0, 0);
-    dumpScreenshot(api, dstRenderTarget, &params);
-    api.commit(swapChain);
-    api.endFrame(0);
-
-    // Wait for the ReadPixels result to come back.
-    api.finish();
-    executeCommands();
-    getDriver().purge();
-
     // Check if the image matches perfectly to our golden run.
-    //
     // TODO: for some reason, this test has very, very slight (as in one pixel) differences between
     // OpenGL and Metal. So disable golden checking for now.
     // Use the compare tool from ImageMagick to see visual differences:
     // compare -verbose -metric mae BlitRegion_Metal.png BlitRegion_OpenGL.png difference.png
-    //
-    // const uint32_t expected = 0x74fa34ed;
-    // printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", params.pixelHashResult, expected);
-    // EXPECT_TRUE(params.pixelHashResult == expected);
+    // api.beginFrame(0, 0, 0);
+    // constexpr uint32_t expected = 0x74fa34ed;
+    // readPixelsAndAssertHash("BlitRegion", kDstTexWidth, kDstTexHeight, dstRenderTarget,
+    //         expected, true);
+    // api.endFrame(0);
+    // flushAndWait();
 
     // Cleanup.
     api.destroyTexture(srcTexture);
@@ -655,23 +590,22 @@ TEST_F(BackendTest, BlitRegionToSwapChain) {
         .height = kDstTexHeight - 10,
     };
 
-    api.beginFrame(0, 0);
-
     api.blitDEPRECATED(TargetBufferFlags::COLOR0, dstRenderTarget,
             dstRect, srcRenderTargets[srcLevel],
             srcRect, SamplerMagFilter::LINEAR);
 
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "BlitRegionToSwapChain.png" };
-    dumpScreenshot(api, dstRenderTarget, &params);
-
+    // Push through an empty frame to allow the texture to upload and the blit to execute.
+    api.beginFrame(0, 0, 0);
     api.commit(swapChain);
-
     api.endFrame(0);
 
-    // Wait for the ReadPixels result to come back.
-    api.finish();
-    executeCommands();
-    getDriver().purge();
+    // Grab a screenshot.
+    api.beginFrame(0, 0, 0);
+    constexpr uint32_t expected = 0xebfac2ef;
+    readPixelsAndAssertHash("BlitRegionToSwapChain", kDstTexWidth, kDstTexHeight, dstRenderTarget,
+            expected, true);
+    api.endFrame(0);
+    flushAndWait();
 
     // Cleanup.
     api.destroyTexture(srcTexture);

filament/backend/test/test_BufferUpdates.cpp

@@ -143,7 +143,7 @@ TEST_F(BackendTest, VertexBufferUpdate) {
         }
 
         getDriverApi().makeCurrent(swapChain, swapChain);
-        getDriverApi().beginFrame(0, 0);
+        getDriverApi().beginFrame(0, 0, 0);
 
         // Draw 10 triangles, updating the vertex buffer / index buffer each time.
         size_t triangleIndex = 0;

filament/backend/test/test_Callbacks.cpp

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

filament/backend/test/test_ComputeBasic.cpp

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