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)
@@ -145,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()
@@ -327,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()
@@ -451,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 "")
@@ -466,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")
@@ -678,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
 # ==================================================================================================

README.md

@@ -31,7 +31,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.51.7'
+    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.7'
+pod 'Filament', '~> 1.51.8'
 ```
 
 ### Snapshots

RELEASE_NOTES.md

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

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

@@ -518,6 +518,7 @@ extern "C" JNIEXPORT void JNICALL Java_com_google_android_filament_Engine_nSetBu
         jint stereoscopicType, jlong stereoscopicEyeCount,
         jlong resourceAllocatorCacheSizeMB, jlong resourceAllocatorCacheMaxAge,
         jboolean disableHandleUseAfterFreeCheck,
+        jint preferredShaderLanguage,
         jboolean forceGLES2Context) {
     Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
     Engine::Config config = {
@@ -534,7 +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,
-            .forceGLES2Context = (bool) forceGLES2Context
+            .preferredShaderLanguage = (Engine::Config::ShaderLanguage) preferredShaderLanguage,
+            .forceGLES2Context = (bool) forceGLES2Context,
     };
     builder->config(&config);
 }

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

@@ -226,6 +226,7 @@ public class Engine {
                     config.stereoscopicType.ordinal(), config.stereoscopicEyeCount,
                     config.resourceAllocatorCacheSizeMB, config.resourceAllocatorCacheMaxAge,
                     config.disableHandleUseAfterFreeCheck,
+                    config.preferredShaderLanguage.ordinal(),
                     config.forceGLES2Context);
             return this;
         }
@@ -430,6 +431,28 @@ public class Engine {
          */
         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
@@ -1362,6 +1385,7 @@ public class Engine {
             int stereoscopicType, long stereoscopicEyeCount,
             long resourceAllocatorCacheSizeMB, long resourceAllocatorCacheMaxAge,
             boolean disableHandleUseAfterFreeCheck,
+            int preferredShaderLanguage,
             boolean forceGLES2Context);
     private static native void nSetBuilderFeatureLevel(long nativeBuilder, int ordinal);
     private static native void nSetBuilderSharedContext(long nativeBuilder, long sharedContext);

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

android/gradle.properties

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

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"
@@ -165,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"
@@ -233,7 +229,6 @@ 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} \
@@ -794,7 +789,7 @@ function check_debug_release_build {
 
 pushd "$(dirname "$0")" > /dev/null
 
-while getopts ":hacCfgijmp:q:uvslwtedk:bx:" opt; do
+while getopts ":hacCfgijmp:q:uvslwedk:bx:" opt; do
     case ${opt} in
         h)
             print_help
@@ -913,10 +908,6 @@ while getopts ":hacCfgijmp:q:uvslwtedk:bx:" 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."

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

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

@@ -31,6 +31,7 @@
 
 #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>
@@ -91,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 {
@@ -332,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
@@ -1219,6 +1223,8 @@ 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");
 

filament/backend/include/backend/Program.h

@@ -117,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;
@@ -148,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; }
@@ -165,6 +182,7 @@ private:
     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/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/DriverAPI.inc

@@ -144,8 +144,7 @@ DECL_DRIVER_API_N(setFrameScheduledCallback,
 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)
@@ -434,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)
@@ -497,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/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

@@ -91,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,11 +29,49 @@
 #include <utility>
 #include <memory>
 #include <atomic>
+#include <chrono>
 
 namespace filament::backend {
 
-class TrackedMetalBuffer {
+class ScopedAllocationTimer {
 public:
+    ScopedAllocationTimer(const char* name) : mBeginning(clock_t::now()), mName(name) {}
+    ~ScopedAllocationTimer() {
+        using namespace std::literals::chrono_literals;
+        static constexpr std::chrono::seconds LONG_TIME_THRESHOLD = 10s;
+
+        auto end = clock_t::now();
+        std::chrono::duration<double, std::micro> allocationTimeMicroseconds = end - mBeginning;
+
+        if (UTILS_UNLIKELY(allocationTimeMicroseconds > LONG_TIME_THRESHOLD)) {
+            if (platform && platform->hasDebugUpdateStatFunc()) {
+                char buffer[64];
+                snprintf(buffer, sizeof(buffer), "filament.metal.long_buffer_allocation_time.%s",
+                        mName);
+                platform->debugUpdateStat(
+                        buffer, static_cast<uint64_t>(allocationTimeMicroseconds.count()));
+            }
+        }
+    }
+
+    static void setPlatform(MetalPlatform* p) { platform = p; }
+
+private:
+    typedef std::chrono::steady_clock clock_t;
+
+    static MetalPlatform* platform;
+
+    std::chrono::time_point<clock_t> mBeginning;
+    const char* mName;
+};
+
+#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,
@@ -55,58 +94,57 @@ public:
         }
     }
 
-    TrackedMetalBuffer() noexcept : mBuffer(nil) {}
-    TrackedMetalBuffer(nullptr_t) noexcept : mBuffer(nil) {}
-    TrackedMetalBuffer(id<MTLBuffer> buffer, Type type) : mBuffer(buffer), mType(type) {
+#if FILAMENT_METAL_BUFFER_TRACKING
+    static void initialize() {
+        static dispatch_once_t onceToken;
+        dispatch_once(&onceToken, ^{
+            for (size_t i = 0; i < TypeCount; i++) {
+                aliveBuffers[i] = [NSHashTable weakObjectsHashTable];
+            }
+        });
+    }
+
+    static void setPlatform(MetalPlatform* p) { platform = p; }
+
+    static void track(id<MTLBuffer> buffer, Type type) {
         assert_invariant(type != Type::NONE);
-        if (buffer) {
-            aliveBuffers[toIndex(type)]++;
-            mType = type;
+        if (UTILS_UNLIKELY(getAliveBuffers() >= EXCESS_BUFFER_COUNT)) {
+            if (platform && platform->hasDebugUpdateStatFunc()) {
+                platform->debugUpdateStat("filament.metal.excess_buffers_allocated",
+                        MetalBufferTracking::getAliveBuffers());
+            }
         }
+        [aliveBuffers[toIndex(type)] addObject:buffer];
     }
 
-    ~TrackedMetalBuffer() {
-        if (mBuffer) {
-            assert_invariant(mType != Type::NONE);
-            aliveBuffers[toIndex(mType)]--;
-        }
-    }
-
-    TrackedMetalBuffer(TrackedMetalBuffer&&) = delete;
-    TrackedMetalBuffer(TrackedMetalBuffer const&) = delete;
-    TrackedMetalBuffer& operator=(TrackedMetalBuffer const&) = delete;
-
-    TrackedMetalBuffer& operator=(TrackedMetalBuffer&& rhs) noexcept {
-        swap(rhs);
-        return *this;
-    }
-
-    id<MTLBuffer> get() const noexcept { return mBuffer; }
-    operator bool() const noexcept { return bool(mBuffer); }
-
     static uint64_t getAliveBuffers() {
         uint64_t sum = 0;
-        for (const auto& v : aliveBuffers) {
-            sum += v;
+        for (size_t i = 1; i < TypeCount; i++) {
+            sum += getAliveBuffers(static_cast<Type>(i));
         }
         return sum;
     }
 
     static uint64_t getAliveBuffers(Type type) {
         assert_invariant(type != Type::NONE);
-        return aliveBuffers[toIndex(type)];
+        NSHashTable* hashTable = aliveBuffers[toIndex(type)];
+        // Caution! We can't simply use hashTable.count here, which is inaccurate.
+        // See http://cocoamine.net/blog/2013/12/13/nsmaptable-and-zeroing-weak-references/
+        return hashTable.objectEnumerator.allObjects.count;
     }
+#else
+    static void initialize() {}
+    static void setPlatform(MetalPlatform* p) {}
+    static id<MTLBuffer> track(id<MTLBuffer> buffer, Type type) { return buffer; }
+    static uint64_t getAliveBuffers() { return 0; }
+    static uint64_t getAliveBuffers(Type type) { return 0; }
+#endif
 
 private:
-    void swap(TrackedMetalBuffer& other) noexcept {
-        std::swap(mBuffer, other.mBuffer);
-        std::swap(mType, other.mType);
-    }
-
-    id<MTLBuffer> mBuffer;
-    Type mType = Type::NONE;
-
-    static std::array<uint64_t, TypeCount> aliveBuffers;
+#if FILAMENT_METAL_BUFFER_TRACKING
+    static std::array<NSHashTable<id<MTLBuffer>>*, TypeCount> aliveBuffers;
+    static MetalPlatform* platform;
+#endif
 };
 
 class MetalBuffer {
@@ -160,7 +198,7 @@ public:
 
 private:
 
-    TrackedMetalBuffer mBuffer;
+    id<MTLBuffer> mBuffer;
     size_t mBufferSize = 0;
     void* mCpuBuffer = nullptr;
     MetalContext& mContext;
@@ -209,8 +247,11 @@ public:
           mBufferOptions(options),
           mSlotSizeBytes(computeSlotSize(layout)),
           mSlotCount(slotCount) {
-        mBuffer = { [device newBufferWithLength:mSlotSizeBytes * mSlotCount options:mBufferOptions],
-            TrackedMetalBuffer::Type::RING };
+        {
+            ScopedAllocationTimer timer("ring");
+            mBuffer = [device newBufferWithLength:mSlotSizeBytes * mSlotCount options:mBufferOptions];
+        }
+        MetalBufferTracking::track(mBuffer, MetalBufferTracking::Type::RING);
         assert_invariant(mBuffer);
     }
 
@@ -228,10 +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],
-                TrackedMetalBuffer::Type::RING };
+            {
+                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);
@@ -260,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 {
@@ -271,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::array<uint64_t, TrackedMetalBuffer::TypeCount> 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,8 +43,11 @@ MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType,
     }
 
     // Otherwise, we allocate a private GPU buffer.
-    mBuffer = { [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate],
-        TrackedMetalBuffer::Type::GENERIC };
+    {
+        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);
 }
 
@@ -65,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");
@@ -74,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];
@@ -97,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,11 +42,16 @@ MetalBufferPoolEntry const* MetalBufferPool::acquireBuffer(size_t numBytes) {
     }
 
     // We were not able to find a sufficiently large stage, so create a new one.
-    id<MTLBuffer> buffer = [mContext.device newBufferWithLength:numBytes
-                                                        options:MTLResourceStorageModeShared];
+    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, TrackedMetalBuffer::Type::STAGING },
+        .buffer = buffer,
         .capacity = numBytes,
         .lastAccessed = mCurrentFrame,
         .referenceCount = 1

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);
@@ -218,13 +224,16 @@ void MetalDriver::beginFrame(int64_t monotonic_clock_ns,
     os_signpost_interval_begin(mContext->log, mContext->signpostId, "Frame encoding", "%{public}d", frameId);
 #endif
     if (mPlatform.hasDebugUpdateStatFunc()) {
-        mPlatform.debugUpdateStat("filament.metal.alive_buffers", TrackedMetalBuffer::getAliveBuffers());
-        mPlatform.debugUpdateStat("filament.metal.alive_buffers.generic",
-                TrackedMetalBuffer::getAliveBuffers(TrackedMetalBuffer::Type::GENERIC));
-        mPlatform.debugUpdateStat("filament.metal.alive_buffers.ring",
-                TrackedMetalBuffer::getAliveBuffers(TrackedMetalBuffer::Type::RING));
-        mPlatform.debugUpdateStat("filament.metal.alive_buffers.staging",
-                TrackedMetalBuffer::getAliveBuffers(TrackedMetalBuffer::Type::STAGING));
+#if FILAMENT_METAL_BUFFER_TRACKING
+        const uint64_t generic = MetalBufferTracking::getAliveBuffers(MetalBufferTracking::Type::GENERIC);
+        const uint64_t ring = MetalBufferTracking::getAliveBuffers(MetalBufferTracking::Type::RING);
+        const uint64_t staging = MetalBufferTracking::getAliveBuffers(MetalBufferTracking::Type::STAGING);
+        const uint64_t total = generic + ring + staging;
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers", total);
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers.generic", generic);
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers.ring", ring);
+        mPlatform.debugUpdateStat("filament.metal.alive_buffers.staging", staging);
+#endif
     }
 }
 
@@ -234,10 +243,10 @@ void MetalDriver::setFrameScheduledCallback(
     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 {
@@ -1247,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) {
 
 }
@@ -1625,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

@@ -75,7 +75,7 @@ public:
 
     void setFrameScheduledCallback(CallbackHandler* handler, FrameScheduledCallback&& callback);
     void setFrameCompletedCallback(
-            CallbackHandler* handler, CallbackHandler::Callback callback, void* user);
+            CallbackHandler* handler, utils::Invocable<void(void)>&& callback);
 
     // For CAMetalLayer-backed SwapChains, presents the drawable or schedules a
     // FrameScheduledCallback.
@@ -119,13 +119,12 @@ private:
     // PresentCallable object.
     struct {
         CallbackHandler* handler = nullptr;
-        FrameScheduledCallback callback = {};
+        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

@@ -224,14 +224,13 @@ void MetalSwapChain::ensureDepthStencilTexture() {
 void MetalSwapChain::setFrameScheduledCallback(
         CallbackHandler* handler, FrameScheduledCallback&& callback) {
     frameScheduled.handler = handler;
-    frameScheduled.callback = std::move(callback);
+    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() {
@@ -304,17 +303,17 @@ void MetalSwapChain::scheduleFrameScheduledCallback() {
     assert_invariant(drawable);
 
     struct Callback {
-        Callback(FrameScheduledCallback&& callback, id<CAMetalDrawable> drawable,
+        Callback(std::shared_ptr<FrameScheduledCallback> callback, id<CAMetalDrawable> drawable,
                 MetalDriver* driver)
-            : f(std::move(callback)), data(PresentDrawableData::create(drawable, driver)) {}
-        FrameScheduledCallback f;
+            : 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(presentCallable);
+            c->f->operator()(presentCallable);
             delete c;
         }
     };
@@ -322,7 +321,7 @@ void MetalSwapChain::scheduleFrameScheduledCallback() {
     // 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>(std::move(frameScheduled.callback), drawable, context.driver);
+            std::make_unique<Callback>(frameScheduled.callback, drawable, context.driver);
 
     backend::CallbackHandler* handler = frameScheduled.handler;
     MetalDriver* driver = context.driver;
@@ -337,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);
     }];
 }
 
@@ -789,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

@@ -169,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

@@ -59,7 +59,7 @@ void NoopDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
 }
 
 void NoopDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
+        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
 
 }
 
@@ -312,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) {
 }
 
@@ -355,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/OpenGLContext.cpp

@@ -894,12 +894,16 @@ void OpenGLContext::unbindTexture(
     // 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).
-    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);
+    // 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);
+            }
         }
     }
 }

filament/backend/src/opengl/OpenGLDriver.cpp

@@ -212,7 +212,8 @@ OpenGLDriver::OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfi
           mHandleAllocator("Handles",
                   driverConfig.handleArenaSize,
                   driverConfig.disableHandleUseAfterFreeCheck),
-          mDriverConfig(driverConfig) {
+          mDriverConfig(driverConfig),
+          mCurrentPushConstants(new(std::nothrow) PushConstantBundle{}) {
 
     std::fill(mSamplerBindings.begin(), mSamplerBindings.end(), nullptr);
 
@@ -240,7 +241,15 @@ OpenGLDriver::~OpenGLDriver() noexcept { // NOLINT(modernize-use-equals-default)
 }
 
 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;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -269,6 +278,9 @@ void OpenGLDriver::terminate() {
     assert_invariant(mGpuCommandCompleteOps.empty());
 #endif
 
+    delete mCurrentPushConstants;
+    mCurrentPushConstants = nullptr;
+
     mContext.terminate();
 
     mPlatform.terminate();
@@ -289,6 +301,39 @@ 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);
@@ -887,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)) {
@@ -912,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]);
@@ -3422,7 +3469,7 @@ void OpenGLDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
 }
 
 void OpenGLDriver::setFrameCompletedCallback(Handle<HwSwapChain> sch,
-        CallbackHandler* handler, CallbackHandler::Callback callback, void* user) {
+        CallbackHandler* handler, utils::Invocable<void(void)>&& callback) {
     DEBUG_MARKER()
 }
 
@@ -3800,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);
@@ -3808,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) {
@@ -3837,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)
@@ -3869,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) {
@@ -3896,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/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/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/VulkanDriver.cpp

@@ -259,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);
     };
 }
 
@@ -398,7 +398,7 @@ void VulkanDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
 }
 
 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) {
@@ -1572,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);
@@ -1755,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");
 
@@ -1857,8 +1865,20 @@ void VulkanDriver::bindPipeline(PipelineState pipelineState) {
         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();
 }
 
@@ -1949,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

@@ -160,6 +160,13 @@ 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/VulkanHandles.cpp

@@ -112,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;

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>;
@@ -212,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;
@@ -224,8 +259,9 @@ 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
@@ -241,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;

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/caching/VulkanDescriptorSetManager.cpp

@@ -879,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{};

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;
     }
@@ -148,38 +152,37 @@ void printDepthFormats(VkPhysicalDevice device) {
 }
 #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
@@ -194,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;
@@ -245,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();
     }
@@ -260,7 +262,7 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
     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;
     }
 
@@ -283,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};
@@ -292,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;
@@ -323,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;
 }
@@ -342,16 +344,16 @@ std::tuple<ExtensionSet, ExtensionSet> pruneExtensions(VkPhysicalDevice device,
 
 #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
 
 #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
@@ -557,6 +559,7 @@ struct VulkanPlatformPrivate {
     std::unordered_set<SwapChainPtr> mHeadlessSwapChains;
 
     bool mSharedContext = false;
+    bool mForceXCBSwapchain = false;
 };
 
 void VulkanPlatform::terminate() {
@@ -610,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());
     }
 
@@ -672,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
@@ -748,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/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/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) {
@@ -243,21 +213,12 @@ TEST_F(BackendTest, ColorMagnify) {
     api.endFrame(0);
 
     // Grab a screenshot.
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "ColorMagnify.png" };
     api.beginFrame(0, 0, 0);
-    dumpScreenshot(api, dstRenderTargets[0], &params);
-    api.commit(swapChain);
+    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);
@@ -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);
@@ -489,21 +444,12 @@ TEST_F(BackendTest, Blit2DTextureArray) {
     api.endFrame(0);
 
     // Grab a screenshot.
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "Blit2DTextureArray.png" };
     api.beginFrame(0, 0, 0);
-    dumpScreenshot(api, dstRenderTarget, &params);
-    api.commit(swapChain);
+    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);
@@ -578,28 +524,17 @@ TEST_F(BackendTest, BlitRegion) {
     api.commit(swapChain);
     api.endFrame(0);
 
-    // Grab a screenshot.
-    ScreenshotParams params { kDstTexWidth, kDstTexHeight, "BlitRegion.png" };
-    api.beginFrame(0, 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, 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_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_FeedbackLoops.cpp

@@ -16,6 +16,7 @@
 
 #include "BackendTest.h"
 
+#include "BackendTestUtils.h"
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"
 
@@ -64,8 +65,6 @@ void main() {
     fragColor = textureLod(test_tex, uv, params.sourceLevel);
 })";
 
-static uint32_t sPixelHashResult = 0;
-
 // Selecting a NPOT texture size seems to exacerbate the bug seen with Intel GPU's.
 // Note that Filament uses a higher precision format (R11F_G11F_B10F) but this does not seem
 // necessary to trigger the bug.
@@ -99,30 +98,13 @@ static void uploadUniforms(DriverApi& dapi, Handle<HwBufferObject> ubh, Material
     dapi.updateBufferObject(ubh, std::move(bd), 0);
 }
 
-static void dumpScreenshot(DriverApi& dapi, Handle<HwRenderTarget> rt) {
-    const size_t size = kTexWidth * kTexHeight * 4;
-    void* buffer = calloc(1, size);
-    auto cb = [](void* buffer, size_t size, void* user) {
-        int w = kTexWidth, h = kTexHeight;
-        const uint32_t* texels = (uint32_t*) buffer;
-        sPixelHashResult = utils::hash::murmur3(texels, size / 4, 0);
-        #ifndef IOS
-        LinearImage image(w, h, 4);
-        image = toLinearWithAlpha<uint8_t>(w, h, w * 4, (uint8_t*) buffer);
-        std::ofstream pngstrm("feedback.png", std::ios::binary | std::ios::trunc);
-        ImageEncoder::encode(pngstrm, ImageEncoder::Format::PNG, image, "", "feedback.png");
-        #endif
-        free(buffer);
-    };
-    PixelBufferDescriptor pb(buffer, size, PixelDataFormat::RGBA, PixelDataType::UBYTE, cb);
-    dapi.readPixels(rt, 0, 0, kTexWidth, kTexHeight, std::move(pb));
-}
-
 // TODO: This test needs work to get Metal and OpenGL to agree on results.
 // The problems are caused by both uploading and rendering into the same texture, since the OpenGL
 // backend's readPixels does not work correctly with textures that have image data uploaded.
 TEST_F(BackendTest, FeedbackLoops) {
     auto& api = getDriverApi();
+    auto& driver = getDriver();
+    uint32_t pixelHashResult = 0;
 
     // The test is executed within this block scope to force destructors to run before
     // executeCommands().
@@ -147,7 +129,7 @@ TEST_F(BackendTest, FeedbackLoops) {
             program = api.createProgram(std::move(prog));
         }
 
-        TrianglePrimitive const triangle(getDriverApi());
+        TrianglePrimitive const triangle(api);
 
         // Create a texture.
         auto usage = TextureUsage::COLOR_ATTACHMENT | TextureUsage::SAMPLEABLE;
@@ -211,8 +193,8 @@ TEST_F(BackendTest, FeedbackLoops) {
                 const uint32_t sourceLevel = targetLevel - 1;
                 params.viewport.width = kTexWidth >> targetLevel;
                 params.viewport.height = kTexHeight >> targetLevel;
-                getDriverApi().setMinMaxLevels(texture, sourceLevel, sourceLevel);
-                uploadUniforms(getDriverApi(), ubuffer, {
+                api.setMinMaxLevels(texture, sourceLevel, sourceLevel);
+                uploadUniforms(api, ubuffer, {
                     .fbWidth = float(params.viewport.width),
                     .fbHeight = float(params.viewport.height),
                     .sourceLevel = float(sourceLevel),
@@ -230,8 +212,8 @@ TEST_F(BackendTest, FeedbackLoops) {
                 const uint32_t sourceLevel = targetLevel + 1;
                 params.viewport.width = kTexWidth >> targetLevel;
                 params.viewport.height = kTexHeight >> targetLevel;
-                getDriverApi().setMinMaxLevels(texture, sourceLevel, sourceLevel);
-                uploadUniforms(getDriverApi(), ubuffer, {
+                api.setMinMaxLevels(texture, sourceLevel, sourceLevel);
+                uploadUniforms(api, ubuffer, {
                     .fbWidth = float(params.viewport.width),
                     .fbHeight = float(params.viewport.height),
                     .sourceLevel = float(sourceLevel),
@@ -241,14 +223,16 @@ TEST_F(BackendTest, FeedbackLoops) {
                 api.endRenderPass();
             }
 
-            getDriverApi().setMinMaxLevels(texture, 0, 0x7f);
+            api.setMinMaxLevels(texture, 0, 0x7f);
 
             // Read back the render target corresponding to the base level.
             //
             // NOTE: Calling glReadPixels on any miplevel other than the base level
             // seems to be un-reliable on some GPU's.
             if (frame == kNumFrames - 1) {
-                dumpScreenshot(api, renderTargets[0]);
+                constexpr uint32_t expected = 0x70695aa1;
+                readPixelsAndAssertHash("feedback", kTexWidth, kTexHeight, renderTargets[0],
+                        expected, true);
             }
 
             api.flush();
@@ -256,7 +240,7 @@ TEST_F(BackendTest, FeedbackLoops) {
             api.endFrame(0);
             api.finish();
             executeCommands();
-            getDriver().purge();
+            driver.purge();
         }
 
         api.destroyProgram(program);
@@ -264,10 +248,6 @@ TEST_F(BackendTest, FeedbackLoops) {
         api.destroyTexture(texture);
         for (auto rt : renderTargets)  api.destroyRenderTarget(rt);
     }
-
-    const uint32_t expected = 0xe93a4a07;
-    printf("Computed hash is 0x%8.8x, Expected 0x%8.8x\n", sPixelHashResult, expected);
-    EXPECT_TRUE(sPixelHashResult == expected);
 }
 
 } // namespace test

filament/src/MaterialParser.cpp

@@ -30,6 +30,7 @@
 #include <private/filament/SubpassInfo.h>
 #include <private/filament/Variant.h>
 #include <private/filament/ConstantInfo.h>
+#include <private/filament/PushConstantInfo.h>
 
 #include <utils/CString.h>
 
@@ -225,6 +226,14 @@ bool MaterialParser::getConstants(utils::FixedCapacityVector<MaterialConstant>*
     return ChunkMaterialConstants::unflatten(unflattener, value);
 }
 
+bool MaterialParser::getPushConstants(utils::CString* structVarName,
+        utils::FixedCapacityVector<MaterialPushConstant>* value) const noexcept {
+    auto [start, end] = mImpl.mChunkContainer.getChunkRange(filamat::MaterialPushConstants);
+    if (start == end) return false;
+    Unflattener unflattener(start, end);
+    return ChunkMaterialPushConstants::unflatten(unflattener, structVarName, value);
+}
+
 bool MaterialParser::getDepthWriteSet(bool* value) const noexcept {
     return mImpl.getFromSimpleChunk(ChunkType::MaterialDepthWriteSet, value);
 }
@@ -709,4 +718,46 @@ bool ChunkMaterialConstants::unflatten(filaflat::Unflattener& unflattener,
     return true;
 }
 
+bool ChunkMaterialPushConstants::unflatten(filaflat::Unflattener& unflattener,
+        utils::CString* structVarName,
+        utils::FixedCapacityVector<MaterialPushConstant>* materialPushConstants) {
+    assert_invariant(materialPushConstants);
+
+    if (!unflattener.read(structVarName)) {
+        return false;
+    }
+
+    // Read number of constants.
+    uint64_t numConstants = 0;
+    if (!unflattener.read(&numConstants)) {
+        return false;
+    }
+
+    materialPushConstants->reserve(numConstants);
+    materialPushConstants->resize(numConstants);
+
+    for (uint64_t i = 0; i < numConstants; i++) {
+        CString constantName;
+        uint8_t constantType = 0;
+        uint8_t shaderStage = 0;
+
+        if (!unflattener.read(&constantName)) {
+            return false;
+        }
+
+        if (!unflattener.read(&constantType)) {
+            return false;
+        }
+
+        if (!unflattener.read(&shaderStage)) {
+            return false;
+        }
+
+        (*materialPushConstants)[i].name = constantName;
+        (*materialPushConstants)[i].type = static_cast<backend::ConstantType>(constantType);
+        (*materialPushConstants)[i].stage = static_cast<backend::ShaderStage>(shaderStage);
+    }
+    return true;
+}
+
 } // namespace filament

filament/src/MaterialParser.h

@@ -47,6 +47,7 @@ class BufferInterfaceBlock;
 class SamplerInterfaceBlock;
 struct SubpassInfo;
 struct MaterialConstant;
+struct MaterialPushConstant;
 
 class MaterialParser {
 public:
@@ -79,6 +80,8 @@ public:
     bool getSamplerBlockBindings(SamplerGroupBindingInfoList* pSamplerGroupInfoList,
             SamplerBindingToNameMap* pSamplerBindingToNameMap) const noexcept;
     bool getConstants(utils::FixedCapacityVector<MaterialConstant>* value) const noexcept;
+    bool getPushConstants(utils::CString* structVarName,
+            utils::FixedCapacityVector<MaterialPushConstant>* value) const noexcept;
 
     using BindingUniformInfoContainer = utils::FixedCapacityVector<
             std::pair<filament::UniformBindingPoints, backend::Program::UniformInfo>>;
@@ -214,6 +217,11 @@ struct ChunkMaterialConstants {
             utils::FixedCapacityVector<MaterialConstant>* materialConstants);
 };
 
+struct ChunkMaterialPushConstants {
+    static bool unflatten(filaflat::Unflattener& unflattener, utils::CString* structVarName,
+            utils::FixedCapacityVector<MaterialPushConstant>* materialPushConstants);
+};
+
 } // namespace filament
 
 #endif // TNT_FILAMENT_MATERIALPARSER_H

filament/src/details/Material.cpp

@@ -25,6 +25,7 @@
 #include <private/filament/EngineEnums.h>
 #include <private/filament/SamplerInterfaceBlock.h>
 #include <private/filament/BufferInterfaceBlock.h>
+#include <private/filament/PushConstantInfo.h>
 #include <private/filament/Variant.h>
 
 #include <filament/Material.h>
@@ -57,10 +58,9 @@
 #include <array>
 #include <iterator>
 #include <memory>
-#include <mutex>
 #include <new>
 #include <optional>
-#include <sstream>
+#include <string>
 #include <string_view>
 #include <unordered_map>
 #include <utility>
@@ -83,18 +83,18 @@ static std::unique_ptr<MaterialParser> createParser(Backend backend,
     MaterialParser::ParseResult const materialResult = materialParser->parse();
 
     if (UTILS_UNLIKELY(materialResult == MaterialParser::ParseResult::ERROR_MISSING_BACKEND)) {
-        std::stringstream languageNames;
+        std::string languageNames;
         for (auto it = languages.begin(); it != languages.end(); ++it) {
-            languageNames << shaderLanguageToString(*it);
+            languageNames.append(shaderLanguageToString(*it));
             if (std::next(it) != languages.end()) {
-                languageNames << ", ";
+                languageNames.append(", ");
             }
         }
 
         ASSERT_PRECONDITION(materialResult != MaterialParser::ParseResult::ERROR_MISSING_BACKEND,
                 "the material was not built for any of the %s backend's supported shader "
                 "languages (%s)\n",
-                backendToString(backend), languageNames.str().c_str());
+                backendToString(backend), languageNames.c_str());
     }
 
     if (backend == Backend::NOOP) {
@@ -298,6 +298,7 @@ FMaterial::FMaterial(FEngine& engine, const Material::Builder& builder,
 
     processBlendingMode(parser);
     processSpecializationConstants(engine, builder, parser);
+    processPushConstants(engine, parser);
     processDepthVariants(engine, parser);
 
     // we can only initialize the default instance once we're initialized ourselves
@@ -576,6 +577,9 @@ Program FMaterial::getProgramWithVariants(
 
     program.specializationConstants(mSpecializationConstants);
 
+    program.pushConstants(ShaderStage::VERTEX, mPushConstants[(uint8_t) ShaderStage::VERTEX]);
+    program.pushConstants(ShaderStage::FRAGMENT, mPushConstants[(uint8_t) ShaderStage::FRAGMENT]);
+
     program.cacheId(utils::hash::combine(size_t(mCacheId), variant.key));
 
     return program;
@@ -928,6 +932,42 @@ void FMaterial::processSpecializationConstants(FEngine& engine, Material::Builde
     }
 }
 
+void FMaterial::processPushConstants(FEngine& engine, MaterialParser const* parser) {
+    utils::FixedCapacityVector<backend::Program::PushConstant>& vertexConstants =
+            mPushConstants[(uint8_t) ShaderStage::VERTEX];
+    utils::FixedCapacityVector<backend::Program::PushConstant>& fragmentConstants =
+            mPushConstants[(uint8_t) ShaderStage::FRAGMENT];
+
+    CString structVarName;
+    utils::FixedCapacityVector<MaterialPushConstant> pushConstants;
+    parser->getPushConstants(&structVarName, &pushConstants);
+
+    vertexConstants.reserve(pushConstants.size());
+    fragmentConstants.reserve(pushConstants.size());
+
+    constexpr size_t MAX_NAME_LEN = 60;
+    char buf[MAX_NAME_LEN];
+    uint8_t vertexCount = 0, fragmentCount = 0;
+
+    std::for_each(pushConstants.cbegin(), pushConstants.cend(),
+            [&](MaterialPushConstant const& constant) {
+                snprintf(buf, sizeof(buf), "%s.%s", structVarName.c_str(), constant.name.c_str());
+
+                switch (constant.stage) {
+                    case ShaderStage::VERTEX:
+                        vertexConstants.push_back({utils::CString(buf), constant.type});
+                        vertexCount++;
+                        break;
+                    case ShaderStage::FRAGMENT:
+                        fragmentConstants.push_back({utils::CString(buf), constant.type});
+                        fragmentCount++;
+                        break;
+                    case ShaderStage::COMPUTE:
+                        break;
+                }
+            });
+}
+
 void FMaterial::processDepthVariants(FEngine& engine, MaterialParser const* const parser) {
     parser->hasCustomDepthShader(&mHasCustomDepthShader);
 

filament/src/details/Material.h

@@ -253,6 +253,8 @@ private:
     void processSpecializationConstants(FEngine& engine, Material::Builder const& builder,
             MaterialParser const* parser);
 
+    void processPushConstants(FEngine& engine, MaterialParser const* parser);
+
     void processDepthVariants(FEngine& engine, MaterialParser const* parser);
 
     void createAndCacheProgram(backend::Program&& p, Variant variant) const noexcept;
@@ -318,6 +320,11 @@ private:
     // current specialization constants for the HwProgram
     utils::FixedCapacityVector<backend::Program::SpecializationConstant> mSpecializationConstants;
 
+    // current push constants for the HwProgram
+    std::array<utils::FixedCapacityVector<backend::Program::PushConstant>,
+            backend::Program::SHADER_TYPE_COUNT>
+            mPushConstants;
+
 #if FILAMENT_ENABLE_MATDBG
     matdbg::MaterialKey mDebuggerId;
     mutable utils::Mutex mActiveProgramsLock;

filament/src/details/SwapChain.cpp

@@ -79,24 +79,11 @@ bool FSwapChain::isFrameScheduledCallbackSet() const noexcept {
     return mFrameScheduledCallbackIsSet;
 }
 
-void FSwapChain::setFrameCompletedCallback(backend::CallbackHandler* handler,
-                utils::Invocable<void(SwapChain*)>&& callback) noexcept {
-    struct Callback {
-        utils::Invocable<void(SwapChain*)> f;
-        SwapChain* s;
-        static void func(void* user) {
-            auto* const c = reinterpret_cast<Callback*>(user);
-            c->f(c->s);
-            delete c;
-        }
-    };
-    if (callback) {
-        auto* const user = new(std::nothrow) Callback{ std::move(callback), this };
-        mEngine.getDriverApi().setFrameCompletedCallback(
-                mHwSwapChain, handler, &Callback::func, static_cast<void*>(user));
-    } else {
-        mEngine.getDriverApi().setFrameCompletedCallback(mHwSwapChain, nullptr, nullptr, nullptr);
-    }
+void FSwapChain::setFrameCompletedCallback(
+        backend::CallbackHandler* handler, FrameCompletedCallback&& callback) noexcept {
+    using namespace std::placeholders;
+    auto boundCallback = std::bind(std::move(callback), this);
+    mEngine.getDriverApi().setFrameCompletedCallback(mHwSwapChain, handler, std::move(boundCallback));
 }
 
 bool FSwapChain::isSRGBSwapChainSupported(FEngine& engine) noexcept {

filament/test/filament_test.cpp

@@ -179,6 +179,23 @@ TEST(FilamentTest, SkinningMath) {
     }
 }
 
+TEST(FilamentTest, TransformManagerSimple) {
+    filament::FTransformManager tcm;
+    EntityManager& em = EntityManager::get();
+    Entity root = em.create();
+    tcm.create(root);
+
+    auto ti = tcm.getInstance(root);
+
+    auto t = mat4f::translation(float3{ 1, 2, 3 });
+    auto prev = tcm.getWorldTransform(ti);
+    tcm.setTransform(ti, t);
+    auto updated = tcm.getWorldTransform(ti);
+
+    EXPECT_NE(prev, t);
+    EXPECT_EQ(updated, t);
+}
+
 TEST(FilamentTest, TransformManager) {
     filament::FTransformManager tcm;
     tcm.setAccurateTranslationsEnabled(true);

ios/CocoaPods/Filament.podspec

@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
   spec.name = "Filament"
-  spec.version = "1.51.7"
+  spec.version = "1.51.8"
   spec.license = { :type => "Apache 2.0", :file => "LICENSE" }
   spec.homepage = "https://google.github.io/filament"
   spec.authors = "Google LLC."
   spec.summary = "Filament is a real-time physically based rendering engine for Android, iOS, Windows, Linux, macOS, and WASM/WebGL."
   spec.platform = :ios, "11.0"
-  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.51.7/filament-v1.51.7-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.51.8/filament-v1.51.8-ios.tgz" }
 
   # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
   spec.pod_target_xcconfig = {

libs/filabridge/include/filament/MaterialChunkType.h

@@ -53,6 +53,7 @@ enum UTILS_PUBLIC ChunkType : uint64_t {
     MaterialAttributeInfo = charTo64bitNum("MAT_ATTR"),
     MaterialProperties = charTo64bitNum("MAT_PROP"),
     MaterialConstants = charTo64bitNum("MAT_CONS"),
+    MaterialPushConstants = charTo64bitNum("MAT_PCON"),
 
     MaterialName = charTo64bitNum("MAT_NAME"),
     MaterialVersion = charTo64bitNum("MAT_VERS"),

libs/filabridge/include/private/filament/EngineEnums.h

@@ -20,6 +20,7 @@
 #include <backend/DriverEnums.h>
 
 #include <utils/BitmaskEnum.h>
+#include <utils/FixedCapacityVector.h>
 
 #include <stddef.h>
 #include <stdint.h>
@@ -71,6 +72,10 @@ enum class ReservedSpecializationConstants : uint8_t {
     CONFIG_STEREO_EYE_COUNT = 8, // don't change (hardcoded in ShaderCompilerService.cpp)
 };
 
+enum class PushConstantIds {
+    MORPHING_BUFFER_OFFSET = 0,
+};
+
 // This value is limited by UBO size, ES3.0 only guarantees 16 KiB.
 // It's also limited by the Froxelizer's record buffer data type (uint8_t).
 constexpr size_t CONFIG_MAX_LIGHT_COUNT = 256;

libs/filabridge/include/private/filament/PushConstantInfo.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TNT_FILAMENT_PUSHCONSTANTINFO_H
+#define TNT_FILAMENT_PUSHCONSTANTINFO_H
+
+#include <backend/DriverEnums.h>
+
+#include <utils/CString.h>
+
+namespace filament {
+
+struct MaterialPushConstant {
+    using ShaderStage = backend::ShaderStage;
+    using ConstantType = backend::ConstantType;
+
+    utils::CString name;
+    ConstantType type;
+    ShaderStage stage;
+
+    MaterialPushConstant() = default;
+    MaterialPushConstant(const char* name, ConstantType type, ShaderStage stage)
+        : name(name),
+          type(type),
+          stage(stage) {}
+};
+
+}
+
+#endif  // TNT_FILAMENT_PUSHCONSTANTINFO_H

libs/filamat/CMakeLists.txt

@@ -23,7 +23,8 @@ set(COMMON_PRIVATE_HDRS
         src/eiff/MaterialInterfaceBlockChunk.h
         src/eiff/ShaderEntry.h
         src/eiff/SimpleFieldChunk.h
-        src/Includes.h)
+        src/Includes.h
+        src/PushConstantDefinitions.h)
 
 set(COMMON_SRCS
         src/eiff/Chunk.cpp

libs/filamat/include/filamat/MaterialBuilder.h

@@ -245,6 +245,7 @@ public:
     using CullingMode = filament::backend::CullingMode;
     using FeatureLevel = filament::backend::FeatureLevel;
     using StereoscopicType = filament::backend::StereoscopicType;
+    using ShaderStage = filament::backend::ShaderStage;
 
     enum class VariableQualifier : uint8_t {
         OUT
@@ -692,6 +693,12 @@ public:
         } defaultValue;
     };
 
+    struct PushConstant {
+        utils::CString name;
+        ConstantType type;
+        ShaderStage stage;
+    };
+
     static constexpr size_t MATERIAL_PROPERTIES_COUNT = filament::MATERIAL_PROPERTIES_COUNT;
     using Property = filament::Property;
 
@@ -720,6 +727,7 @@ public:
     using SubpassList = Parameter[MAX_SUBPASS_COUNT];
     using BufferList = std::vector<std::unique_ptr<filament::BufferInterfaceBlock>>;
     using ConstantList = std::vector<Constant>;
+    using PushConstantList = std::vector<PushConstant>;
 
     // returns the number of parameters declared in this material
     uint8_t getParameterCount() const noexcept { return mParameterCount; }
@@ -763,6 +771,10 @@ private:
 
     void prepareToBuild(MaterialInfo& info) noexcept;
 
+    // Initialize internal push constants that will both be written to the shaders and material
+    // chunks (like user-defined spec constants).
+    void initPushConstants() noexcept;
+
     // Return true if the shader is syntactically and semantically valid.
     // This method finds all the properties defined in the fragment and
     // vertex shaders of the material.
@@ -829,6 +841,7 @@ private:
     PropertyList mProperties;
     ParameterList mParameters;
     ConstantList mConstants;
+    PushConstantList mPushConstants;
     SubpassList mSubpasses;
     VariableList mVariables;
     OutputList mOutputs;

libs/filamat/src/MaterialBuilder.cpp

@@ -20,6 +20,7 @@
 
 #include "Includes.h"
 #include "MaterialVariants.h"
+#include "PushConstantDefinitions.h"
 #include "shaders/SibGenerator.h"
 #include "shaders/UibGenerator.h"
 
@@ -173,6 +174,8 @@ void MaterialBuilderBase::prepare(bool vulkanSemantics,
 MaterialBuilder::MaterialBuilder() : mMaterialName("Unnamed") {
     std::fill_n(mProperties, MATERIAL_PROPERTIES_COUNT, false);
     mShaderModels.reset();
+
+    initPushConstants();
 }
 
 MaterialBuilder::~MaterialBuilder() = default;
@@ -660,6 +663,19 @@ void MaterialBuilder::prepareToBuild(MaterialInfo& info) noexcept {
     info.userMaterialHasCustomDepth = false;
 }
 
+void MaterialBuilder::initPushConstants() noexcept {
+    mPushConstants.reserve(PUSH_CONSTANTS.size());
+    mPushConstants.resize(PUSH_CONSTANTS.size());
+    std::transform(PUSH_CONSTANTS.cbegin(), PUSH_CONSTANTS.cend(), mPushConstants.begin(),
+            [](filament::MaterialPushConstant const& inConstant) -> PushConstant {
+                return {
+                    .name = inConstant.name,
+                    .type = inConstant.type,
+                    .stage = inConstant.stage,
+                };
+            });
+}
+
 bool MaterialBuilder::findProperties(backend::ShaderStage type,
         MaterialBuilder::PropertyList& allProperties,
         CodeGenParams const& semanticCodeGenParams) noexcept {
@@ -828,7 +844,7 @@ bool MaterialBuilder::generateShaders(JobSystem& jobSystem, const std::vector<Va
     BlobDictionary spirvDictionary;
     // End: must be protected by lock
 
-    ShaderGenerator sg(mProperties, mVariables, mOutputs, mDefines, mConstants,
+    ShaderGenerator sg(mProperties, mVariables, mOutputs, mDefines, mConstants, mPushConstants,
             mMaterialFragmentCode.getResolved(), mMaterialFragmentCode.getLineOffset(),
             mMaterialVertexCode.getResolved(), mMaterialVertexCode.getLineOffset(),
             mMaterialDomain);
@@ -1358,7 +1374,7 @@ bool MaterialBuilder::needsStandardDepthProgram() const noexcept {
 std::string MaterialBuilder::peek(backend::ShaderStage stage,
         const CodeGenParams& params, const PropertyList& properties) noexcept {
 
-    ShaderGenerator sg(properties, mVariables, mOutputs, mDefines, mConstants,
+    ShaderGenerator sg(properties, mVariables, mOutputs, mDefines, mConstants, mPushConstants,
             mMaterialFragmentCode.getResolved(), mMaterialFragmentCode.getLineOffset(),
             mMaterialVertexCode.getResolved(), mMaterialVertexCode.getLineOffset(),
             mMaterialDomain);
@@ -1512,6 +1528,14 @@ void MaterialBuilder::writeCommonChunks(ChunkContainer& container, MaterialInfo&
             [](Constant const& c) { return MaterialConstant(c.name.c_str(), c.type); });
     container.push<MaterialConstantParametersChunk>(std::move(constantsEntry));
 
+    utils::FixedCapacityVector<MaterialPushConstant> pushConstantsEntry(mPushConstants.size());
+    std::transform(mPushConstants.begin(), mPushConstants.end(), pushConstantsEntry.begin(),
+            [](PushConstant const& c) {
+                return MaterialPushConstant(c.name.c_str(), c.type, c.stage);
+            });
+    container.push<MaterialPushConstantParametersChunk>(
+            utils::CString(PUSH_CONSTANT_STRUCT_VAR_NAME), std::move(pushConstantsEntry));
+
     // TODO: should we write the SSBO info? this would only be needed if we wanted to provide
     //       an interface to set [get?] values in the buffer. But we can do that easily
     //       with a c-struct (what about kotlin/java?). tbd.

libs/filamat/src/PushConstantDefinitions.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TNT_FILAMAT_PUSH_CONSTANT_DEFINTITIONS_H
+#define TNT_FILAMAT_PUSH_CONSTANT_DEFINTITIONS_H
+
+#include <private/filament/EngineEnums.h>
+#include <private/filament/PushConstantInfo.h>
+
+#include <utils/FixedCapacityVector.h>
+
+#include <tuple>
+
+namespace filamat {
+
+constexpr char PUSH_CONSTANT_STRUCT_VAR_NAME[] = "pushConstants";
+
+utils::FixedCapacityVector<filament::MaterialPushConstant> const PUSH_CONSTANTS = {
+    {
+        "morphingBufferOffset",
+        filament::backend::ConstantType::INT,
+        filament::backend::ShaderStage::VERTEX,
+    },
+};
+
+// Make sure that the indices defined in filabridge match the actual array indices defined here.
+static_assert(static_cast<uint8_t>(filament::PushConstantIds::MORPHING_BUFFER_OFFSET) == 0u);
+
+}// namespace filamat
+
+#endif

libs/filamat/src/eiff/MaterialInterfaceBlockChunk.cpp

@@ -22,6 +22,7 @@
 #include <private/filament/BufferInterfaceBlock.h>
 #include <private/filament/SubpassInfo.h>
 #include <private/filament/ConstantInfo.h>
+#include <private/filament/PushConstantInfo.h>
 
 #include <utility>
 
@@ -104,6 +105,24 @@ void MaterialConstantParametersChunk::flatten(Flattener& f) {
 
 // ------------------------------------------------------------------------------------------------
 
+MaterialPushConstantParametersChunk::MaterialPushConstantParametersChunk(
+        CString const& structVarName, utils::FixedCapacityVector<MaterialPushConstant> constants)
+    : Chunk(ChunkType::MaterialPushConstants),
+      mStructVarName(structVarName),
+      mConstants(std::move(constants)) {}
+
+void MaterialPushConstantParametersChunk::flatten(Flattener& f) {
+    f.writeString(mStructVarName.c_str());
+    f.writeUint64(mConstants.size());
+    for (const auto& constant: mConstants) {
+        f.writeString(constant.name.c_str());
+        f.writeUint8(static_cast<uint8_t>(constant.type));
+        f.writeUint8(static_cast<uint8_t>(constant.stage));
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+
 MaterialUniformBlockBindingsChunk::MaterialUniformBlockBindingsChunk(
         utils::FixedCapacityVector<std::pair<std::string_view, filament::UniformBindingPoints>> list)
         : Chunk(ChunkType::MaterialUniformBindings),

libs/filamat/src/eiff/MaterialInterfaceBlockChunk.h

@@ -31,6 +31,7 @@ class SamplerInterfaceBlock;
 class BufferInterfaceBlock;
 struct SubpassInfo;
 struct MaterialConstant;
+struct MaterialPushConstant;
 } // namespace filament
 
 namespace filamat {
@@ -88,6 +89,21 @@ private:
 
 // ------------------------------------------------------------------------------------------------
 
+class MaterialPushConstantParametersChunk final : public Chunk {
+public:
+    explicit MaterialPushConstantParametersChunk(utils::CString const& structVarName,
+            utils::FixedCapacityVector<filament::MaterialPushConstant> constants);
+    ~MaterialPushConstantParametersChunk() final = default;
+
+private:
+    void flatten(Flattener&) final;
+
+    utils::CString mStructVarName;
+    utils::FixedCapacityVector<filament::MaterialPushConstant> mConstants;
+};
+
+// ------------------------------------------------------------------------------------------------
+
 class MaterialUniformBlockBindingsChunk final : public Chunk {
     using Container = utils::FixedCapacityVector<
             std::pair<std::string_view, filament::UniformBindingPoints>>;

libs/filamat/src/shaders/CodeGenerator.cpp

@@ -17,6 +17,7 @@
 #include "CodeGenerator.h"
 
 #include "MaterialInfo.h"
+#include "../PushConstantDefinitions.h"
 
 #include "generated/shaders.h"
 
@@ -454,8 +455,8 @@ io::sstream& CodeGenerator::generateVariable(io::sstream& out, ShaderStage stage
 }
 
 io::sstream& CodeGenerator::generateShaderInputs(io::sstream& out, ShaderStage type,
-        const AttributeBitset& attributes, Interpolation interpolation) const {
-
+        const AttributeBitset& attributes, Interpolation interpolation,
+        MaterialBuilder::PushConstantList const& pushConstants) const {
     auto const& attributeDatabase = MaterialBuilder::getAttributeDatabase();
 
     const char* shading = getInterpolationQualifier(interpolation);
@@ -479,6 +480,9 @@ io::sstream& CodeGenerator::generateShaderInputs(io::sstream& out, ShaderStage t
             }
             out << getTypeName(attribute.type) << " " << attribute.getAttributeName() << ";\n";
         });
+
+        out << "\n";
+        generatePushConstants(out, pushConstants, attributes.size());
     }
 
     out << "\n";
@@ -906,6 +910,41 @@ utils::io::sstream& CodeGenerator::generateSpecializationConstant(utils::io::sst
     return out;
 }
 
+utils::io::sstream& CodeGenerator::generatePushConstants(utils::io::sstream& out,
+        MaterialBuilder::PushConstantList const& pushConstants, size_t const layoutLocation) const {
+    static constexpr char const* STRUCT_NAME = "Constants";
+
+    bool const outputSpirv =
+            mTargetLanguage == TargetLanguage::SPIRV && mTargetApi != TargetApi::OPENGL;
+    auto const getType = [](ConstantType const& type) {
+        switch (type) {
+            case ConstantType::BOOL:
+                return "bool";
+            case ConstantType::INT:
+                return "int";
+            case ConstantType::FLOAT:
+                return "float";
+        }
+    };
+    if (outputSpirv) {
+        out << "layout(push_constant) uniform " << STRUCT_NAME << " {\n ";
+    } else {
+        out << "struct " << STRUCT_NAME << " {\n";
+    }
+
+    for (auto const& constant: pushConstants) {
+        out << getType(constant.type) << " " << constant.name.c_str() << ";\n";
+    }
+
+    if (outputSpirv) {
+        out << "} " << PUSH_CONSTANT_STRUCT_VAR_NAME << ";\n";
+    } else {
+        out << "};\n";
+        out << "LAYOUT_LOCATION(" << static_cast<int>(layoutLocation) << ") uniform " << STRUCT_NAME
+            << " " << PUSH_CONSTANT_STRUCT_VAR_NAME << ";\n";
+    }
+    return out;
+}
 
 io::sstream& CodeGenerator::generateMaterialProperty(io::sstream& out,
         MaterialBuilder::Property property, bool isSet) {

libs/filamat/src/shaders/CodeGenerator.h

@@ -107,7 +107,8 @@ public:
 
     // generate declarations for non-custom "in" variables
     utils::io::sstream& generateShaderInputs(utils::io::sstream& out, ShaderStage type,
-        const filament::AttributeBitset& attributes, filament::Interpolation interpolation) const;
+            const filament::AttributeBitset& attributes, filament::Interpolation interpolation,
+            MaterialBuilder::PushConstantList const& pushConstants) const;
     static utils::io::sstream& generatePostProcessInputs(utils::io::sstream& out, ShaderStage type);
 
     // generate declarations for custom output variables
@@ -156,6 +157,10 @@ public:
     utils::io::sstream& generateSpecializationConstant(utils::io::sstream& out,
             const char* name, uint32_t id, std::variant<int, float, bool> value) const;
 
+    utils::io::sstream& generatePushConstants(utils::io::sstream& out,
+            MaterialBuilder::PushConstantList const& pushConstants,
+            size_t const layoutLocation) const;
+
     static utils::io::sstream& generatePostProcessGetters(utils::io::sstream& out, ShaderStage type);
     static utils::io::sstream& generateGetters(utils::io::sstream& out, ShaderStage stage);
     static utils::io::sstream& generateParameters(utils::io::sstream& out, ShaderStage type);

libs/filamat/src/shaders/ShaderGenerator.cpp

@@ -304,6 +304,7 @@ ShaderGenerator::ShaderGenerator(
         MaterialBuilder::OutputList const& outputs,
         MaterialBuilder::PreprocessorDefineList const& defines,
         MaterialBuilder::ConstantList const& constants,
+        MaterialBuilder::PushConstantList const& pushConstants,
         CString const& materialCode, size_t lineOffset,
         CString const& materialVertexCode, size_t vertexLineOffset,
         MaterialBuilder::MaterialDomain materialDomain) noexcept {
@@ -325,6 +326,7 @@ ShaderGenerator::ShaderGenerator(
     mMaterialDomain = materialDomain;
     mDefines = defines;
     mConstants = constants;
+    mPushConstants = pushConstants;
 
     if (mMaterialFragmentCode.empty()) {
         if (mMaterialDomain == MaterialBuilder::MaterialDomain::SURFACE) {
@@ -418,7 +420,15 @@ std::string ShaderGenerator::createVertexProgram(ShaderModel shaderModel,
             attributes.set(VertexAttribute::MORPH_TANGENTS_3);
         }
     }
-    cg.generateShaderInputs(vs, ShaderStage::VERTEX, attributes, interpolation);
+
+    MaterialBuilder::PushConstantList vertexPushConstants;
+    std::copy_if(mPushConstants.begin(), mPushConstants.end(),
+            std::back_insert_iterator<MaterialBuilder::PushConstantList>(vertexPushConstants),
+            [](MaterialBuilder::PushConstant const& constant) {
+                return constant.stage == ShaderStage::VERTEX;
+            });
+    cg.generateShaderInputs(vs, ShaderStage::VERTEX, attributes, interpolation,
+            vertexPushConstants);
 
     CodeGenerator::generateCommonTypes(vs, ShaderStage::VERTEX);
 
@@ -519,9 +529,14 @@ std::string ShaderGenerator::createFragmentProgram(ShaderModel shaderModel,
 
     generateSurfaceMaterialVariantProperties(fs, mProperties, mDefines);
 
-
-    cg.generateShaderInputs(fs, ShaderStage::FRAGMENT,
-            material.requiredAttributes, interpolation);
+    MaterialBuilder::PushConstantList fragmentPushConstants;
+    std::copy_if(mPushConstants.begin(), mPushConstants.end(),
+            std::back_insert_iterator<MaterialBuilder::PushConstantList>(fragmentPushConstants),
+            [](MaterialBuilder::PushConstant const& constant) {
+                return constant.stage == ShaderStage::FRAGMENT;
+            });
+    cg.generateShaderInputs(fs, ShaderStage::FRAGMENT, material.requiredAttributes, interpolation,
+            fragmentPushConstants);
 
     CodeGenerator::generateCommonTypes(fs, ShaderStage::FRAGMENT);
 

libs/filamat/src/shaders/ShaderGenerator.h

@@ -43,6 +43,7 @@ public:
             MaterialBuilder::OutputList const& outputs,
             MaterialBuilder::PreprocessorDefineList const& defines,
             MaterialBuilder::ConstantList const& constants,
+            MaterialBuilder::PushConstantList const& pushConstants,
             utils::CString const& materialCode,
             size_t lineOffset,
             utils::CString const& materialVertexCode,
@@ -125,6 +126,7 @@ private:
     MaterialBuilder::MaterialDomain mMaterialDomain;
     MaterialBuilder::PreprocessorDefineList mDefines;
     MaterialBuilder::ConstantList mConstants;
+    MaterialBuilder::PushConstantList mPushConstants;
     utils::CString mMaterialFragmentCode;   // fragment or compute code
     utils::CString mMaterialVertexCode;
     size_t mMaterialLineOffset;

libs/utils/include/utils/FixedCapacityVector.h

@@ -299,6 +299,16 @@ public:
         }
     }
 
+    UTILS_NOINLINE
+    void shrink_to_fit() {
+        if (size() < capacity()) {
+            FixedCapacityVector t(construct_with_capacity, size(), allocator());
+            t.mSize = size();
+            std::uninitialized_move(begin(), end(), t.begin());
+            this->swap(t);
+        }
+    }
+
 private:
     enum construct_with_capacity_tag{ construct_with_capacity };
 

libs/utils/include/utils/bitset.h

@@ -60,6 +60,11 @@ public:
         std::fill(std::begin(storage), std::end(storage), 0);
     }
 
+    template<typename U, typename = typename std::enable_if_t<N == 1, U>>
+    explicit bitset(U value) noexcept {
+        storage[0] = value;
+    }
+
     T getBitsAt(size_t n) const noexcept {
         assert_invariant(n<N);
         return storage[n];
@@ -94,6 +99,8 @@ public:
 
     size_t size() const noexcept { return N * BITS_PER_WORD; }
 
+    bool empty() const noexcept { return none(); }
+
     bool test(size_t bit) const noexcept { return operator[](bit); }
 
     void set(size_t b) noexcept {
@@ -117,11 +124,14 @@ public:
         storage[b / BITS_PER_WORD] ^= T(1) << (b % BITS_PER_WORD);
     }
 
-
     void reset() noexcept {
         std::fill(std::begin(storage), std::end(storage), 0);
     }
 
+    void clear() noexcept {
+        reset();
+    }
+
     bool operator[](size_t b) const noexcept {
         assert_invariant(b / BITS_PER_WORD < N);
         return bool(storage[b / BITS_PER_WORD] & (T(1) << (b % BITS_PER_WORD)));

web/filament-js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "filament",
-  "version": "1.51.7",
+  "version": "1.51.8",
   "description": "Real-time physically based rendering engine",
   "main": "filament.js",
   "module": "filament.js",