Merge branch 'main' into ebridgewater/RequiredFeatures

.github/actions/dep-versions/action.yml

@@ -3,5 +3,5 @@ runs:
   using: "composite"
   steps:
     - name: Set up dependency versions
-      shell: bash
+      shell: bash    
       run: cat ./build/common/versions >> $GITHUB_ENV

.github/actions/web-prereq/action.yml

@@ -1,16 +0,0 @@
-name: 'Web Preqrequisites'
-runs:
-  using: "composite"
-  steps:
-    - uses: ./.github/actions/dep-versions
-    - name: Cache EMSDK
-      id: emsdk-cache
-      uses: actions/cache@v4 # Use a specific version
-      with:
-        path: emsdk
-        key: ${{ runner.os }}-emsdk-${{ env.GITHUB_EMSDK_VERSION }}
-    - name: Install Web Prerequisites
-      shell: bash
-      run: |
-        bash ./build/common/get-emscripten.sh
-        echo "EMSDK=$PWD/emsdk" >> $GITHUB_ENV

.github/workflows/mac-continuous.yml

@@ -26,4 +26,4 @@ jobs:
           path: out/filament-release-darwin.tgz
       - name: Check public headers
         run: |
-          test/check-headers/test.sh out/release/filament/include
+          build/common/check-headers.sh out/release/filament/include

.github/workflows/presubmit.yml

@@ -96,7 +96,6 @@ jobs:
         with:
           fetch-depth: 0
       - uses: ./.github/actions/linux-prereq
-      - uses: ./.github/actions/web-prereq
       - name: Run build script
         run: |
           cd build/web && printf "y" | ./build.sh presubmit
@@ -124,15 +123,13 @@ jobs:
       - uses: ./.github/actions/mac-prereq
       - name: Cache Mesa and deps
         id: mesa-cache
-        uses: actions/cache@v4
+        uses: actions/cache@v4 # Use a specific version
         with:
           path: mesa
           key: ${{ runner.os }}-mesa-deps-2-${{ vars.MESA_VERSION }}
-      - name: Prerequisites
-        id: prereqs
-        run: |
-          bash build/common/get-mesa.sh
-          pip install tifffile numpy
+      - name: Get Mesa
+        id: mesa-prereq
+        run: bash test/utils/get_mesa.sh
       - name: Run Test
         run: bash test/renderdiff/test.sh
       - uses: actions/upload-artifact@v4
@@ -153,8 +150,8 @@ jobs:
       - name: Run test
         run: ./out/cmake-debug/libs/filamat/test_filamat --gtest_filter=MaterialCompiler.Wgsl*
 
-  test-code-correctness:
-    name: test-code-correctness
+  code-correcteness:
+    name: code-correctness
     runs-on: 'macos-14-xlarge'
     steps:
       - uses: actions/checkout@v4.1.6

.github/workflows/release.yml

@@ -65,9 +65,13 @@ jobs:
 
   build-mac:
     name: build-mac
-    runs-on: macos-14-xlarge
+    runs-on: ${{ matrix.os }}
     if: github.event_name == 'release' || github.event.inputs.platform == 'desktop'
 
+    strategy:
+      matrix:
+        os: [macos-14-xlarge, ubuntu-22.04-32core]
+
     steps:
       - name: Decide Git ref
         id: git_ref
@@ -114,7 +118,6 @@ jobs:
         with:
           ref: ${{ steps.git_ref.outputs.ref }}
       - uses: ./.github/actions/linux-prereq
-      - uses: ./.github/actions/web-prereq
       - name: Run build script
         env:
           TAG: ${{ steps.git_ref.outputs.tag }}
@@ -163,9 +166,6 @@ jobs:
           mv out/filamat-android-release.aar out/filamat-${TAG}-android.aar
           mv out/gltfio-android-release.aar out/gltfio-${TAG}-android.aar
           mv out/filament-utils-android-release.aar out/filament-utils-${TAG}-android.aar
-          cd out/android-release/filament
-          tar -czf ../../filament-${TAG}-android-native.tgz .
-          cd ../../..
       - name: Sign sample-gltf-viewer
         run: |
           echo "${APK_KEYSTORE_BASE64}" > filament.jks.base64
@@ -187,7 +187,7 @@ jobs:
           script: |
             const upload = require('./build/common/upload-release-assets');
             const { TAG } = process.env;
-            const globber = await glob.create(['out/*.aar', 'out/*.apk', 'out/*.tgz'].join('\n'));
+            const globber = await glob.create(['out/*.aar', 'out/*.apk'].join('\n'));
             await upload({ github, context }, await globber.glob(), TAG);
 
   build-ios:

.github/workflows/web-continuous.yml

@@ -17,7 +17,6 @@ jobs:
         with:
           fetch-depth: 0
       - uses: ./.github/actions/linux-prereq
-      - uses: ./.github/actions/web-prereq
       - name: Run build script
         run: |
           cd build/web && printf "y" | ./build.sh continuous

BUILDING.md

@@ -363,8 +363,6 @@ python ./emsdk.py activate latest
 source ./emsdk_env.sh
 ```
 
-Alternatively, you can try running the script `build/common/get-emscripten.sh`.
-
 After this you can invoke the [easy build](#easy-build) script as follows:
 
 ```shell

NEW_RELEASE_NOTES.md

@@ -7,3 +7,5 @@ for next branch cut* header.
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).
 
 ## Release notes for next branch cut
+
+- materials: remove dependence on per-view descset layout from filamat. [⚠️ **New Material Version**]

README.md

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

RELEASE_NOTES.md

@@ -7,16 +7,6 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).
 
-## v1.60.1
-
-
-## v1.60.0
-
-- materials: remove dependence on per-view descset layout from filamat. [⚠️ **New Material Version**]
-- matc non-functional change: Update GLSL postprocessor to
-  isolate calls to SPVRemap from calls to SPIRV-Cross.
-
-
 ## v1.59.5
 
 

android/gradle.properties

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

build.sh

@@ -151,7 +151,7 @@ function print_fgviewer_help {
 }
 
 # Unless explicitly specified, NDK version will be selected as highest available version within same major release chain
-FILAMENT_NDK_VERSION=${FILAMENT_NDK_VERSION:-$(cat `dirname $0`/build/common/versions | grep GITHUB_NDK_VERSION | sed s/GITHUB_NDK_VERSION=//g | cut -f 1 -d ".")}
+FILAMENT_NDK_VERSION=${FILAMENT_NDK_VERSION:-$(cat `dirname $0`/build/android/ndk.version | cut -f 1 -d ".")}
 
 # Requirements
 CMAKE_MAJOR=3
@@ -463,6 +463,16 @@ function ensure_android_build {
         echo "Error: Android NDK side-by-side version ${FILAMENT_NDK_VERSION} or compatible must be installed, exiting"
         exit 1
     fi
+
+    local cmake_version=$(cmake --version)
+    if [[ "${cmake_version}" =~ ([0-9]+)\.([0-9]+)\.[0-9]+ ]]; then
+        if [[ "${BASH_REMATCH[1]}" -lt "${CMAKE_MAJOR}" ]] || \
+           [[ "${BASH_REMATCH[2]}" -lt "${CMAKE_MINOR}" ]]; then
+            echo "Error: cmake version ${CMAKE_MAJOR}.${CMAKE_MINOR}+ is required," \
+                 "${BASH_REMATCH[1]}.${BASH_REMATCH[2]} installed, exiting"
+            exit 1
+        fi
+    fi
 }
 
 function build_android {

build/android/build.sh

@@ -1,6 +1,28 @@
 #!/bin/bash
 
-source `dirname $0`/../common/ci-check.sh
+# Usage: the first argument selects the build type:
+# - release, to build release only
+# - debug, to build debug only
+# - continuous, to build release and debug
+# - presubmit, for presubmit builds
+#
+# The default is release
+
+echo "This script is intended to run in a CI environment and may modify your current environment."
+echo "Please refer to BUILDING.md for more information."
+
+read -r -p "Do you wish to proceed (y/n)? " choice
+case "${choice}" in
+    y|Y)
+              echo "Build will proceed..."
+              ;;
+    n|N)
+          exit 0
+          ;;
+          *)
+        exit 0
+        ;;
+esac
 
 set -e
 set -x
@@ -8,6 +30,11 @@ set -x
 UNAME=`echo $(uname)`
 LC_UNAME=`echo $UNAME | tr '[:upper:]' '[:lower:]'`
 
+# build-common.sh will generate the following variables:
+#     $GENERATE_ARCHIVES
+#     $BUILD_DEBUG
+#     $BUILD_RELEASE
+source `dirname $0`/../common/ci-common.sh
 source `dirname $0`/../common/build-common.sh
 
 if [[ "$GITHUB_WORKFLOW" ]]; then

build/common/build-common.sh

@@ -1,20 +1,5 @@
 #!/bin/bash
 
-# build-common.sh will generate the following variables:
-#     $GENERATE_ARCHIVES
-#     $BUILD_DEBUG
-#     $BUILD_RELEASE
-
-# Typically a build script (build.sh) would source this script. For example,
-#   source `dirname $0`/../common/build-common.sh
-
-# Usage: the first argument selects the build type:
-# - release, to build release only
-# - debug, to build debug only
-# - continuous, to build release and debug
-# - presubmit, for presubmit builds
-#
-# The default is release
 if [[ ! "$TARGET" ]]; then
     if [[ "$1" ]]; then
         TARGET=$1

build/common/ci-check.sh

@@ -1,19 +0,0 @@
-echo "This script is intended to run in a CI environment and may modify your current environment."
-echo "Please refer to BUILDING.md for more information."
-
-read -r -p "Do you wish to proceed (y/n)? " choice
-case "${choice}" in
-    y|Y)
-	      echo "Build will proceed..."
-	      ;;
-    n|N)
-    	  exit 0
-    	  ;;
-	  *)
-        exit 0
-        ;;
-esac
-
-if [[ "$GITHUB_WORKFLOW" ]]; then
-    echo "Running workflow $GITHUB_WORKFLOW (event: $GITHUB_EVENT_NAME, action: $GITHUB_ACTION)"
-fi

build/common/ci-common.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+if [[ "$GITHUB_WORKFLOW" ]]; then
+    echo "Running workflow $GITHUB_WORKFLOW (event: $GITHUB_EVENT_NAME, action: $GITHUB_ACTION)"
+fi

build/common/get-emscripten.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-
-if [ -d "./emsdk" ]; then
-    echo "emsdk folder found. Assume emsdk has been installed."
-    cd emsdk
-    ./emsdk activate latest
-    source ./emsdk_env.sh
-    export EMSDK="$PWD"
-    cd ..
-    exit 0
-fi
-
-# Install emscripten.
-EMSDK_VERSION=${GITHUB_EMSDK_VERSION-3.1.60}
-curl -L https://github.com/emscripten-core/emsdk/archive/refs/tags/${EMSDK_VERSION}.zip > emsdk.zip
-unzip emsdk.zip ; mv emsdk-* emsdk ; cd emsdk
-./emsdk install latest
-./emsdk activate latest
-source ./emsdk_env.sh
-
-export EMSDK="$PWD"
-cd ..

build/common/versions

@@ -3,5 +3,4 @@ GITHUB_CMAKE_VERSION=3.19.5
 GITHUB_NINJA_VERSION=1.10.2
 GITHUB_MESA_VERSION=24.2.1
 GITHUB_LLVM_VERSION=16
-GITHUB_NDK_VERSION=27.0.11718014
-GITHUB_EMSDK_VERSION=3.1.60
+GITHUB_NDK_VERSION=27.0.11718014

build/ios/build.sh

@@ -1,11 +1,35 @@
 #!/bin/bash
 
-source `dirname $0`/../common/ci-check.sh
+# Usage: the first argument selects the build type:
+# - release, to build release only
+# - debug, to build debug only
+# - continuous, to build release and debug
+# - presubmit, for presubmit builds
+#
+# The default is release
+
+echo "This script is intended to run in a CI environment and may modify your current environment."
+echo "Please refer to BUILDING.md for more information."
+
+read -r -p "Do you wish to proceed (y/n)? " choice
+case "${choice}" in
+    y|Y)
+	      echo "Build will proceed..."
+	      ;;
+    n|N)
+    	  exit 0
+    	  ;;
+	  *)
+        exit 0
+        ;;
+esac
 
 set -e
 set -x
 
+source `dirname $0`/../common/ci-common.sh
 source `dirname $0`/../common/build-common.sh
+
 pushd `dirname $0`/../.. > /dev/null
 
 # If we're generating an archive for release or continuous builds, then we'll also build for the

build/linux/build.sh

@@ -1,11 +1,38 @@
 #!/bin/bash
 
-source `dirname $0`/../common/ci-check.sh
+# Usage: the first argument selects the build type:
+# - release, to build release only
+# - debug, to build debug only
+# - continuous, to build release and debug
+# - presubmit, for presubmit builds
+#
+# The default is release
+
+echo "This script is intended to run in a CI environment and may modify your current environment."
+echo "Please refer to BUILDING.md for more information."
+
+read -r -p "Do you wish to proceed (y/n)? " choice
+case "${choice}" in
+    y|Y)
+	      echo "Build will proceed..."
+	      ;;
+    n|N)
+    	  exit 0
+    	  ;;
+	  *)
+        exit 0
+        ;;
+esac
 
 set -e
 set -x
 
+# build-common.sh will generate the following variables:
+#     $GENERATE_ARCHIVES
+#     $BUILD_DEBUG
+#     $BUILD_RELEASE
+source `dirname $0`/../common/ci-common.sh
 source `dirname $0`/../common/build-common.sh
-pushd `dirname $0`/../.. > /dev/null
 
+pushd `dirname $0`/../.. > /dev/null
 ./build.sh -c $RUN_TESTS $GENERATE_ARCHIVES $BUILD_DEBUG $BUILD_RELEASE

build/mac/build.sh

@@ -1,11 +1,34 @@
 #!/bin/bash
 
-source `dirname $0`/../common/ci-check.sh
+# Usage: the first argument selects the build type:
+# - release, to build release only
+# - debug, to build debug only
+# - continuous, to build release and debug
+# - presubmit, for presubmit builds
+#
+# The default is release
+
+echo "This script is intended to run in a CI environment and may modify your current environment."
+echo "Please refer to BUILDING.md for more information."
+
+read -r -p "Do you wish to proceed (y/n)? " choice
+case "${choice}" in
+    y|Y)
+	      echo "Build will proceed..."
+	      ;;
+    n|N)
+    	  exit 0
+    	  ;;
+	  *)
+        exit 0
+        ;;
+esac
 
 set -e
 set -x
 
+source `dirname $0`/../common/ci-common.sh
 source `dirname $0`/../common/build-common.sh
-pushd `dirname $0`/../.. > /dev/null
 
+pushd `dirname $0`/../.. > /dev/null
 ./build.sh -c $RUN_TESTS $GENERATE_ARCHIVES $BUILD_DEBUG $BUILD_RELEASE

build/web/build.sh

@@ -1,10 +1,34 @@
 #!/bin/bash
 
-source `dirname $0`/../common/ci-check.sh
+# Usage: the first argument selects the build type:
+# - release, to build release only
+# - debug, to build debug only
+# - continuous, to build release and debug
+# - presubmit, for presubmit builds
+#
+# The default is release
+
+echo "This script is intended to run in a CI environment and may modify your current environment."
+echo "Please refer to BUILDING.md for more information."
+
+read -r -p "Do you wish to proceed (y/n)? " choice
+case "${choice}" in
+    y|Y)
+	      echo "Build will proceed..."
+	      ;;
+    n|N)
+    	  exit 0
+    	  ;;
+	  *)
+        exit 0
+        ;;
+esac
 
 set -e
 set -x
 
+source `dirname $0`/../common/ci-common.sh
+source `dirname $0`/ci-common.sh
 source `dirname $0`/../common/build-common.sh
 pushd `dirname $0`/../.. > /dev/null
 

build/web/ci-common.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+# Install emscripten.
+curl -L https://github.com/emscripten-core/emsdk/archive/refs/tags/3.1.60.zip > emsdk.zip
+unzip emsdk.zip ; mv emsdk-* emsdk ; cd emsdk
+./emsdk install latest
+./emsdk activate latest
+source ./emsdk_env.sh
+
+export EMSDK="$PWD"
+cd ..

docs_src/markdeep/Materials.md.html

@@ -1023,12 +1023,8 @@ samplerCubemap         | Cubemap texture
 [Table [materialParamsTypes]: Material parameter types]
 
 Samplers
-:     Sampler types can specify additional options:
-
-      - `format`: either `int` or `float` (defaults to `float`).
-      - `stages`: array of strings containing the list of shader stages this
-        sampler can be accessed from. Each entry must be either `vertex` or
-        `fragment` (defaults to both).
+:     Sampler types can also specify a `format` which can be either `int` or `float` (defaults to
+      `float`).
 
 Arrays
 :     A parameter can define an array of values by appending `[size]` after the type name, where

docs_src/src/SUMMARY.md

@@ -18,7 +18,6 @@
     - [Metal](./notes/metal_debugging.md)
     - [Vulkan](./notes/vulkan_debugging.md)
     - [SPIR-V](./notes/spirv_debugging.md)
-    - [Running with ASAN and UBSAN](./notes/asan_ubsan.md)
   - [Libraries](./notes/libs.md)
     - [bluegl](./dup/bluegl.md)
     - [bluevk](./dup/bluevk.md)

docs_src/src/notes/asan_ubsan.md

@@ -1,41 +0,0 @@
-# Running with ASAN/UBSAN
-
-## Enabling
-
-When building though build.sh, pass the `-b` flag. This sets the cmake variable
-`FILAMENT_ENABLE_ASAN_UBSAN=ON` which eventually passes `"-fsanitize=address -fsanitize=undefined"`
-to all compile and link operations.
-
-If building through CMake directly, or an IDE like CLion that doesn't use build.sh, instead pass
-`-DFILAMENT_ENABLE_ASAN_UBSAN=ON` to cmake in order to get the same result.
-
-## Getting memory leak detection on Mac
-
-Memory leak detection isn't enabled by default on MacOS. There are two issues to address, first is
-using a version of clang that supports memory leak detection and second is enabling it at runtime.
-
-The version of clang distributed by Apple (with a version like "Apple clang version 16.0.0") doesn't
-currently support leak detection at all. Instead you will need to get or build a different LLVM,
-such as the one distributed through homebrew and get CMake to use that instead.
-
-Then during runtime you'll need to have the environment variable `ASAN_OPTIONS` include the option
-`detect_leaks=1`. Multiple `ASAN_OPTIONS` values are concatenated with `:`.
-
-## Getting memory leak output in CLion
-
-### Setting variables
-
-Under `Settings | Build, Execution, Deployment | Dynamic Analysis Tools | Sanitizers` there is an
-ASAN Settings field that overrides whatever other `ASAN_OPTIONS` you might set elsewhere, so you
-must use that instead of setting it through your Run/Debug Configuration.
-
-To pass `-DFILAMENT_ENABLE_ASAN_UBSAN=ON` to CMake you'll want to create a new CMake Profile and
-pass it as a CMake argument.
-
-### Avoiding losing output
-
-CMake will consume ASAN output and display it through a separate "Sanitizers" tab. Unfortunately
-certain leak detection errors that interrupt the executable seem to not show up in this tab, but are
-still removed from the user-visible console output. If this is happening and you need to see the
-unfiltered console output you'll need to go to `Settings | Build, Execution, Deployment | Dynamic
-Analysis Tools | Sanitizers` and uncheck "Use visual representation for Sanitizer's output".

filament/backend/CMakeLists.txt

@@ -5,6 +5,18 @@ set(TARGET backend)
 set(PUBLIC_HDR_DIR include)
 set(GENERATION_ROOT ${CMAKE_CURRENT_BINARY_DIR})
 
+# ==================================================================================================
+# Compilation options
+# ==================================================================================================
+#
+set(BACKEND_SANITIZATION "" CACHE STRING "Sanitization option")
+set_property(CACHE BACKEND_SANITIZATION PROPERTY STRINGS ";ASAN")
+
+set(BACKEND_SANITIZERS)
+if (BACKEND_SANITIZATION STREQUAL "ASAN")
+    set(BACKEND_SANITIZERS -fsanitize=address)
+endif()
+
 # ==================================================================================================
 # Sources and headers
 # ==================================================================================================
@@ -472,6 +484,7 @@ target_compile_options(${TARGET} PRIVATE
         ${OSMESA_COMPILE_FLAGS}
         $<$<CONFIG:Release>:${OPTIMIZATION_FLAGS}>
         $<$<AND:$<PLATFORM_ID:Darwin>,$<CONFIG:Release>>:${DARWIN_OPTIMIZATION_FLAGS}>
+        ${BACKEND_SANITIZERS}
 )
 
 if (FILAMENT_SUPPORTS_METAL)
@@ -482,6 +495,8 @@ if (FILAMENT_SUPPORTS_WEBGPU)
     target_compile_definitions(${TARGET} PRIVATE $<$<BOOL:${FILAMENT_WEBGPU_IMMEDIATE_ERROR_HANDLING}>:FILAMENT_WEBGPU_IMMEDIATE_ERROR_HANDLING>)
 endif()
 
+target_link_options(${TARGET} PRIVATE ${BACKEND_SANITIZERS})
+
 target_link_libraries(${TARGET} PRIVATE
         ${OSMESA_LINKER_FLAGS}
         $<$<AND:$<PLATFORM_ID:Linux>,$<CONFIG:Release>>:${LINUX_LINKER_OPTIMIZATION_FLAGS}>
@@ -551,6 +566,8 @@ if (APPLE AND NOT IOS)
          test/test_RenderExternalImage.cpp)
     add_library(backend_test STATIC ${BACKEND_TEST_SRC})
     target_link_libraries(backend_test PUBLIC ${BACKEND_TEST_LIBS})
+    target_compile_options(backend_test PRIVATE ${BACKEND_SANITIZERS})
+    target_link_options(backend_test PRIVATE ${BACKEND_SANITIZERS})
 
     set(BACKEND_TEST_DEPS
             OSDependent
@@ -589,6 +606,7 @@ if (APPLE AND NOT IOS)
        # 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)
+       target_link_options(backend_test_mac PRIVATE ${BACKEND_SANITIZERS})
 
        # This is needed after XCode 15.3
        set_target_properties(backend_test_mac PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
@@ -598,6 +616,8 @@ endif()
 
 if (LINUX)
     add_executable(backend_test_linux test/linux_runner.cpp ${BACKEND_TEST_SRC})
+    target_compile_options(backend_test_linux PRIVATE ${BACKEND_SANITIZERS})
+    target_link_options(backend_test_linux PRIVATE ${BACKEND_SANITIZERS})
     target_link_libraries(backend_test_linux PRIVATE ${BACKEND_TEST_LIBS})
     set_target_properties(backend_test_linux PROPERTIES FOLDER Tests)
 endif()

filament/backend/include/backend/BufferDescriptor.h

@@ -20,15 +20,10 @@
 #define TNT_FILAMENT_BACKEND_BUFFERDESCRIPTOR_H
 
 #include <utils/compiler.h>
-
-#include <utility>
+#include <utils/ostream.h>
 
 #include <stddef.h>
 
-namespace utils::io {
-class ostream;
-} // namespace utils::io
-
 namespace filament::backend {
 
 class CallbackHandler;
@@ -94,8 +89,8 @@ public:
      * @param callback  A callback used to release the CPU buffer from this BufferDescriptor
      * @param user      An opaque user pointer passed to the callback function when it's called
      */
-    BufferDescriptor(void const* buffer, size_t const size,
-            Callback const callback = nullptr, void* user = nullptr) noexcept
+    BufferDescriptor(void const* buffer, size_t size,
+            Callback callback = nullptr, void* user = nullptr) noexcept
                 : buffer(const_cast<void*>(buffer)), size(size), mCallback(callback), mUser(user) {
     }
 
@@ -103,12 +98,11 @@ public:
      * Creates a BufferDescriptor that references a CPU memory-buffer
      * @param buffer    Memory address of the CPU buffer to reference
      * @param size      Size of the CPU buffer in bytes
-     * @param handler   A custom handler for the callback
      * @param callback  A callback used to release the CPU buffer from this BufferDescriptor
      * @param user      An opaque user pointer passed to the callback function when it's called
      */
-    BufferDescriptor(void const* buffer, size_t const size,
-            CallbackHandler* handler, Callback const callback, void* user = nullptr) noexcept
+    BufferDescriptor(void const* buffer, size_t size,
+            CallbackHandler* handler, Callback callback, void* user = nullptr) noexcept
                 : buffer(const_cast<void*>(buffer)), size(size),
                 mCallback(callback), mUser(user), mHandler(handler) {
     }
@@ -122,9 +116,8 @@ public:
      *
      * @param buffer    Memory address of the CPU buffer to reference
      * @param size      Size of the CPU buffer in bytes
-     * @param data      A pointer to the data
      * @param handler   Handler to use to dispatch the callback, or nullptr for the default handler
-     * @return          A new BufferDescriptor
+     * @return          a new BufferDescriptor
      */
     template<typename T, void(T::*method)(void const*, size_t)>
     static BufferDescriptor make(void const* buffer, size_t size, T* data,
@@ -171,7 +164,7 @@ public:
      * @param callback  The new callback function
      * @param user      An opaque user pointer passed to the callbeck function when it's called
      */
-    void setCallback(Callback const callback, void* user = nullptr) noexcept {
+    void setCallback(Callback callback, void* user = nullptr) noexcept {
         this->mCallback = callback;
         this->mUser = user;
         this->mHandler = nullptr;
@@ -183,7 +176,7 @@ public:
      * @param callback  The new callback function
      * @param user      An opaque user pointer passed to the callbeck function when it's called
      */
-    void setCallback(CallbackHandler* handler, Callback const callback, void* user = nullptr) noexcept {
+    void setCallback(CallbackHandler* handler, Callback callback, void* user = nullptr) noexcept {
         mCallback = callback;
         mUser = user;
         mHandler = handler;

filament/backend/include/backend/DescriptorSetOffsetArray.h

@@ -19,6 +19,8 @@
 
 #include <backend/DriverApiForward.h>
 
+#include <utils/ostream.h>
+
 #include <initializer_list>
 #include <memory>
 
@@ -26,10 +28,6 @@
 #include <stdint.h>
 
 
-namespace utils::io {
-class ostream;
-} // namespace utils::io
-
 namespace filament::backend {
 
 void* allocateFromCommandStream(DriverApi& driver, size_t size, size_t alignment) noexcept;

filament/backend/include/backend/DriverEnums.h

@@ -25,11 +25,12 @@
 #include <backend/PresentCallable.h>
 
 #include <utils/BitmaskEnum.h>
-#include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/Invocable.h>
-#include <utils/StaticString.h>
+#include <utils/compiler.h>
 #include <utils/debug.h>
+#include <utils/ostream.h>
+#include <utils/StaticString.h>
 
 #include <math/vec4.h>
 
@@ -40,10 +41,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-namespace utils::io {
-class ostream;
-} // namespace utils::io
-
 /**
  * Types and enums used by filament's driver.
  *

filament/backend/include/backend/Handle.h

@@ -17,6 +17,9 @@
 #ifndef TNT_FILAMENT_BACKEND_HANDLE_H
 #define TNT_FILAMENT_BACKEND_HANDLE_H
 
+#if !defined(NDEBUG)
+#include <utils/ostream.h>
+#endif
 #include <utils/debug.h>
 
 #include <type_traits> // FIXME: STL headers are not allowed in public headers
@@ -24,10 +27,6 @@
 
 #include <stdint.h>
 
-namespace utils::io {
-class ostream;
-} // namespace utils::io
-
 namespace filament::backend {
 
 struct HwBufferObject;

filament/backend/include/backend/PipelineState.h

@@ -20,14 +20,12 @@
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>
 
+#include <utils/ostream.h>
+
 #include <array>
 
 #include <stdint.h>
 
-namespace utils::io {
-class ostream;
-} // namespace utils::io
-
 namespace filament::backend {
 
 //! \privatesection

filament/backend/include/backend/PixelBufferDescriptor.h

@@ -24,14 +24,11 @@
 
 #include <utils/compiler.h>
 #include <utils/debug.h>
+#include <utils/ostream.h>
 
 #include <stddef.h>
 #include <stdint.h>
 
-namespace utils::io {
-class ostream;
-} // namespace utils::io
-
 namespace filament::backend {
 
 /**

filament/backend/include/backend/Program.h

@@ -20,10 +20,12 @@
 #include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/Invocable.h>
+#include <utils/ostream.h>
 
 #include <backend/DriverEnums.h>
 
 #include <array>
+#include <unordered_map>
 #include <tuple>
 #include <utility>
 #include <variant>
@@ -31,10 +33,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-namespace utils::io {
-class ostream;
-} // namespace utils::io
-
 namespace filament::backend {
 
 class Program {

filament/backend/include/backend/TargetBufferInfo.h

@@ -19,26 +19,22 @@
 
 #include <backend/Handle.h>
 
-#include <utility>
+#include <utils/ostream.h>
 
 #include <stddef.h>
 #include <stdint.h>
 
-namespace utils::io {
-class ostream;
-} // namespace utils::io
-
 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 const level, uint16_t const layer) noexcept
-            : handle(std::move(handle)), 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 const level) noexcept
+    TargetBufferInfo(Handle<HwTexture> handle, uint8_t level) noexcept
             : handle(handle), level(level) {
     }
 
@@ -74,11 +70,11 @@ private:
     TargetBufferInfo mInfos[MAX_SUPPORTED_RENDER_TARGET_COUNT];
 
 public:
-    TargetBufferInfo const& operator[](size_t const i) const noexcept {
+    TargetBufferInfo const& operator[](size_t i) const noexcept {
         return mInfos[i];
     }
 
-    TargetBufferInfo& operator[](size_t const i) noexcept {
+    TargetBufferInfo& operator[](size_t i) noexcept {
         return mInfos[i];
     }
 

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

@@ -27,11 +27,8 @@
 #include <utils/Hash.h>
 #include <utils/PrivateImplementation.h>
 
-#include <cstddef>
-#include <functional>
 #include <tuple>
 #include <unordered_set>
-#include <string>
 
 #include <stddef.h>
 #include <stdint.h>

filament/backend/src/Platform.cpp

@@ -17,7 +17,6 @@
 #include <backend/Platform.h>
 
 #include <utils/compiler.h>
-#include <utils/ostream.h>
 
 #include <atomic>
 #include <utility>

filament/backend/src/metal/MetalBuffer.mm

@@ -19,8 +19,6 @@
 
 #include "MetalContext.h"
 
-#include <utils/Panic.h>
-
 namespace filament {
 namespace backend {
 

filament/backend/src/metal/MetalDriver.mm

@@ -721,25 +721,15 @@ const char* toString(DescriptorFlags flags) {
 
 void MetalDriver::createDescriptorSetLayoutR(
         Handle<HwDescriptorSetLayout> dslh, DescriptorSetLayout&& info) {
-#if FILAMENT_METAL_DEBUG_LOG == 1
-    const char* labelStr = "";
-    std::visit([&labelStr](auto&& arg) {
-        using T = std::decay_t<decltype(arg)>;
-        if constexpr (std::is_same_v<T, utils::CString> || std::is_same_v<T, utils::StaticString>) {
-            labelStr = arg.c_str();
-        }
-    }, info.label);
     std::sort(info.bindings.begin(), info.bindings.end(),
             [](const auto& a, const auto& b) { return a.binding < b.binding; });
-    DEBUG_LOG("createDescriptorSetLayoutR(dslh = %d, info = { label = %s,\n", dslh.getId(),
-            labelStr);
+    DEBUG_LOG("createDescriptorSetLayoutR(dslh = %d, info = {\n", dslh.getId());
     for (size_t i = 0; i < info.bindings.size(); i++) {
         DEBUG_LOG("    {binding = %d, type = %s, count = %d, stage = %s, flags = %s},\n",
                 info.bindings[i].binding, toString(info.bindings[i].type), info.bindings[i].count,
                 toString(info.bindings[i].stageFlags), toString(info.bindings[i].flags));
     }
     DEBUG_LOG("})\n");
-#endif
     construct_handle<MetalDescriptorSetLayout>(dslh, std::move(info));
 }
 

filament/backend/src/metal/MetalHandles.mm

@@ -1382,9 +1382,6 @@ id<MTLArgumentEncoder> MetalDescriptorSetLayout::getArgumentEncoderSlow(id<MTLDe
                 break;
         }
     }
-    if (arguments.count == 0) {
-        return nil;
-    }
     return [device newArgumentEncoderWithArguments:arguments];
 }
 
@@ -1445,9 +1442,6 @@ id<MTLBuffer> MetalDescriptorSet::finalizeAndGetBuffer(MetalDriver* driver, Shad
 
     id<MTLArgumentEncoder> encoder =
             layout->getArgumentEncoder(context.device, stage, textureTypes);
-    if (!encoder) {
-        return nil;
-    }
 
     {
         ScopedAllocationTimer timer("descriptor_set");

filament/backend/src/metal/MetalState.h

@@ -20,18 +20,17 @@
 #include <Metal/Metal.h>
 
 #include "private/backend/Driver.h"
+#include "backend/Program.h"
 
 #include <backend/DriverEnums.h>
-#include <backend/Program.h>
 
-#include <utils/bitset.h>
 #include <utils/FixedCapacityVector.h>
-#include <utils/Hash.h>
-#include <utils/Invocable.h>
-
-#include <tsl/robin_map.h>
 
 #include <memory>
+#include <tsl/robin_map.h>
+
+#include <utils/Hash.h>
+#include <utils/Invocable.h>
 
 namespace filament {
 namespace backend {

filament/backend/src/opengl/OpenGLContext.cpp

@@ -542,13 +542,6 @@ void OpenGLContext::initBugs(Bugs* bugs, Extensions const& exts,
         } else if (strstr(renderer, "Intel")) {
             // Intel GPU
             bugs->vao_doesnt_store_element_array_buffer_binding = true;
-
-            if (strstr(renderer, "Mesa")) {
-                // Mesa Intel driver on Linux/Android
-                // Renderer of the form [Mesa Intel(R) HD Graphics 505 (APL 3)]
-                // b/405252622
-                bugs->disable_invalidate_framebuffer = true;
-            }
         } else if (strstr(renderer, "PowerVR")) {
             // PowerVR GPU
             // On PowerVR (Rogue GE8320) glFlush doesn't seem to do anything, in particular,

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

@@ -54,7 +54,7 @@ struct PlatformCocoaGLImpl {
     CVOpenGLTextureCacheRef mTextureCache = nullptr;
     std::unique_ptr<CocoaExternalImage::SharedGl> mExternalImageSharedGl;
     void updateOpenGLContext(NSView *nsView, bool resetView, bool clearView);
-    struct ExternalImageCocoaGL final : public Platform::ExternalImage {
+    struct ExternalImageCocoaGL : public Platform::ExternalImage {
         CVPixelBufferRef cvBuffer;
     protected:
         ~ExternalImageCocoaGL() noexcept final;

filament/backend/src/vulkan/VulkanContext.h

@@ -142,10 +142,6 @@ public:
         return mPortabilitySubsetFeatures.imageView2DOn3DImage == VK_TRUE;
     }
 
-    inline bool isUnifiedMemoryArchitecture() const noexcept {
-        return mIsUnifiedMemoryArchitecture;
-    }
-
 private:
     VkPhysicalDeviceMemoryProperties mMemoryProperties = {};
     VkPhysicalDeviceProperties2 mPhysicalDeviceProperties = {
@@ -168,7 +164,6 @@ private:
     bool mDebugUtilsSupported = false;
     bool mLazilyAllocatedMemorySupported = false;
     bool mProtectedMemorySupported = false;
-    bool mIsUnifiedMemoryArchitecture = false;
 
     fvkutils::VkFormatList mDepthStencilFormats;
     fvkutils::VkFormatList mBlittableDepthStencilFormats;

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

@@ -631,21 +631,6 @@ fvkutils::VkFormatList findBlittableDepthStencilFormats(VkPhysicalDevice device)
     return ret;
 }
 
-/**
- *  Check if the GPU has a unified memory architecture.
- */
-bool hasUnifiedMemoryArchitecture(VkPhysicalDeviceMemoryProperties memoryProperties) noexcept {
-    // Try to identify if the platform is running on a Unified Memory Architecture by inspecting the
-    // memory heap flags, if they are all VK_MEMORY_HEAP_DEVICE_LOCAL_BIT it's UMA, otherwise not
-    // enough information to make a decision, so default to false.
-    for (uint32_t i = 0; i < memoryProperties.memoryHeapCount; ++i) {
-        if ((memoryProperties.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) == 0) {
-            return false;
-        }
-    }
-    return true;
-}
-
 }// anonymous namespace
 
 using SwapChainPtr = VulkanPlatform::SwapChainPtr;
@@ -879,8 +864,6 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
         }
     }
 
-    context.mIsUnifiedMemoryArchitecture = hasUnifiedMemoryArchitecture(context.mMemoryProperties);
-
 #ifdef NDEBUG
     // If we are in release build, we should not have turned on debug extensions
     FILAMENT_CHECK_POSTCONDITION(!context.mDebugUtilsSupported && !context.mDebugMarkersSupported)

filament/backend/src/vulkan/utils/Helper.h

@@ -21,7 +21,6 @@
 
 #include <utils/bitset.h>
 #include <utils/FixedCapacityVector.h>
-#include <utils/Panic.h>
 
 #include <bluevk/BlueVK.h>
 

filament/backend/src/webgpu/WebGPUHandles.cpp

@@ -19,7 +19,6 @@
 #include <backend/DriverEnums.h>
 
 #include <utils/BitmaskEnum.h>
-#include <utils/Panic.h>
 
 #include <webgpu/webgpu_cpp.h>
 
@@ -503,6 +502,7 @@ size_t WebGPUDescriptorSet::countEntitiesWithDynamicOffsets() const {
     return mEntriesByBindingWithDynamicOffsets.count();
 }
 
+// From createTextureR
 WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat format, uint8_t samples,
         uint32_t width, uint32_t height, uint32_t depth, TextureUsage usage,
         wgpu::Device const& device) noexcept {
@@ -516,7 +516,6 @@ WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat forma
     // First, the texture aspect, starting with the defaults/basic configuration
     mUsage = fToWGPUTextureUsage(usage);
     mFormat = fToWGPUTextureFormat(format);
-    mAspect = fToWGPUTextureViewAspect(usage, format);
     wgpu::TextureDescriptor textureDescriptor{
         .label = getUserTextureLabel(target),
         .usage = mUsage,
@@ -561,12 +560,13 @@ WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat forma
     mTexView = makeTextureView(0, levels, target);
 }
 
+// From createTextureViewR
 WGPUTexture::WGPUTexture(WGPUTexture* src, uint8_t baseLevel, uint8_t levelCount) noexcept {
     mTexture = src->mTexture;
     mTexView = makeTextureView(baseLevel, levelCount, target);
 }
 
-wgpu::TextureUsage WGPUTexture::fToWGPUTextureUsage(TextureUsage const& fUsage) {
+wgpu::TextureUsage WGPUTexture::fToWGPUTextureUsage(const TextureUsage& fUsage) {
     wgpu::TextureUsage retUsage = wgpu::TextureUsage::None;
 
     // Basing this mapping off of VulkanTexture.cpp's getUsage func and suggestions from Gemini
@@ -614,9 +614,8 @@ wgpu::TextureUsage WGPUTexture::fToWGPUTextureUsage(TextureUsage const& fUsage)
     //  PROTECTED
     return retUsage;
 }
-
-wgpu::TextureFormat WGPUTexture::fToWGPUTextureFormat(TextureFormat const& fFormat) {
-    switch (fFormat) {
+wgpu::TextureFormat WGPUTexture::fToWGPUTextureFormat(const TextureFormat& fUsage) {
+    switch (fUsage) {
         case filament::backend::TextureFormat::R8:
             return wgpu::TextureFormat::R8Unorm;
         case filament::backend::TextureFormat::R8_SNORM:
@@ -855,57 +854,24 @@ wgpu::TextureFormat WGPUTexture::fToWGPUTextureFormat(TextureFormat const& fForm
     }
 }
 
-wgpu::TextureAspect WGPUTexture::fToWGPUTextureViewAspect(TextureUsage const& fUsage,
-        TextureFormat const& fFormat) {
-
-    const bool isDepth = any(fUsage & TextureUsage::DEPTH_ATTACHMENT);
-    const bool isStencil = any(fUsage & TextureUsage::STENCIL_ATTACHMENT);
-    const bool isColor = any(fUsage & TextureUsage::COLOR_ATTACHMENT);
-    const bool isSample = (fUsage == TextureUsage::SAMPLEABLE);
-
-    if (isDepth && !isColor && !isStencil) {
-        return wgpu::TextureAspect::DepthOnly;
-    }
-
-    if (isStencil && !isColor && !isDepth) {
-        return wgpu::TextureAspect::StencilOnly;
-    }
-
-    if (fFormat == filament::backend::TextureFormat::DEPTH32F ||
-            fFormat == filament::backend::TextureFormat::DEPTH24 ||
-            fFormat == filament::backend::TextureFormat::DEPTH16) {
-        return wgpu::TextureAspect::DepthOnly;
-    }
-
-    if (fFormat == filament::backend::TextureFormat::STENCIL8) {
-        return wgpu::TextureAspect::StencilOnly;
-    }
-
-    if (fFormat == filament::backend::TextureFormat::DEPTH24_STENCIL8 ||
-            fFormat == filament::backend::TextureFormat::DEPTH32F_STENCIL8) {
-        if (isSample) {
-            return wgpu::TextureAspect::DepthOnly;
-        }
-    }
-
-    return wgpu::TextureAspect::All;
-}
-
 wgpu::TextureView WGPUTexture::makeTextureView(const uint8_t& baseLevel, const uint8_t& levelCount,
         SamplerType target) {
-
+    // starting with the defaults/basic configuration
     wgpu::TextureViewDescriptor textureViewDescriptor{
         .label = getUserTextureViewLabel(target),
         .format = mFormat,
+        // dimension depends on target and is set below
         .baseMipLevel = baseLevel,
         .mipLevelCount = levelCount,
-        // TODO: check if this baseArrayLayer assumption is correct
+        // baseArrayLayer is required, making a guess
         .baseArrayLayer = 0,
         .arrayLayerCount = mArrayLayerCount,
-        .aspect = mAspect,
+        // Have not found an analog to aspect in other drivers, but ALL should be unrestrictive.
+        // TODO Can we make this better?
+        .aspect = wgpu::TextureAspect::All,
         .usage = mUsage
     };
-
+    // adjust for specific cases
     switch (target) {
         case SamplerType::SAMPLER_2D:
             textureViewDescriptor.dimension = wgpu::TextureViewDimension::e2D;

filament/backend/src/webgpu/WebGPUHandles.h

@@ -74,8 +74,8 @@ public:
 
 private:
     // TODO: can we do better in terms on heap management.
-    std::vector<wgpu::VertexBufferLayout> mVertexBufferLayout{};
-    std::vector<std::vector<wgpu::VertexAttribute>> mAttributes{};
+    std::vector<wgpu::VertexBufferLayout> mVertexBufferLayout {};
+    std::vector<std::vector<wgpu::VertexAttribute>> mAttributes {};
 };
 
 struct WGPUVertexBuffer : public HwVertexBuffer {
@@ -145,8 +145,8 @@ public:
     [[nodiscard]] uint32_t const* setDynamicOffsets(uint32_t const* offsets);
     [[nodiscard]] bool getIsLocked() const { return mBindGroup != nullptr; }
     [[nodiscard]] size_t countEntitiesWithDynamicOffsets() const;
-
 private:
+
     static wgpu::Buffer sDummyUniformBuffer;
     static wgpu::Texture sDummyTexture;
     static wgpu::TextureView sDummyTextureView;
@@ -161,10 +161,10 @@ private:
     // Also storing the wgpu ObjectBase takes care of ownership challenges in theory
     wgpu::BindGroupLayout mLayout = nullptr;
     static constexpr uint8_t INVALID_INDEX = MAX_DESCRIPTOR_COUNT + 1;
-    std::array<uint8_t, MAX_DESCRIPTOR_COUNT> mEntryIndexByBinding{};
+    std::array<uint8_t, MAX_DESCRIPTOR_COUNT> mEntryIndexByBinding {};
     std::vector<wgpu::BindGroupEntry> mEntriesSortedByBinding;
-    std::bitset<MAX_DESCRIPTOR_COUNT> mEntriesByBindingWithDynamicOffsets{};
-    std::bitset<MAX_DESCRIPTOR_COUNT> mEntriesByBindingAdded{};
+    std::bitset<MAX_DESCRIPTOR_COUNT> mEntriesByBindingWithDynamicOffsets {};
+    std::bitset<MAX_DESCRIPTOR_COUNT> mEntriesByBindingAdded {};
     std::vector<uint32_t> mDynamicOffsets;
     wgpu::BindGroup mBindGroup = nullptr;
 };
@@ -177,14 +177,11 @@ public:
 
     WGPUTexture(WGPUTexture* src, uint8_t baseLevel, uint8_t levelCount) noexcept;
 
-    [[nodiscard]] const wgpu::Texture& getTexture() const { return mTexture; }
-    [[nodiscard]] const wgpu::TextureView& getTexView() const { return mTexView; }
+    const wgpu::Texture& getTexture() const { return mTexture; }
+    const wgpu::TextureView& getTexView() const { return mTexView; }
 
-    static wgpu::TextureFormat fToWGPUTextureFormat(
-            filament::backend::TextureFormat const& fFormat);
-    static wgpu::TextureAspect fToWGPUTextureViewAspect(
-            filament::backend::TextureUsage const& fUsage,
-            filament::backend::TextureFormat const& fFormat);
+    // Public to allow checking for support of a texture format
+    static wgpu::TextureFormat fToWGPUTextureFormat(const filament::backend::TextureFormat& fUsage);
 
 private:
     wgpu::TextureView makeTextureView(const uint8_t& baseLevel, const uint8_t& levelCount,
@@ -195,10 +192,9 @@ private:
     wgpu::Texture mTexture = nullptr;
     wgpu::TextureUsage mUsage = wgpu::TextureUsage::None;
     wgpu::TextureFormat mFormat = wgpu::TextureFormat::Undefined;
-    wgpu::TextureAspect mAspect = wgpu::TextureAspect::Undefined;
     uint32_t mArrayLayerCount = 1;
     wgpu::TextureView mTexView = nullptr;
-    wgpu::TextureUsage fToWGPUTextureUsage(filament::backend::TextureUsage const& fUsage);
+    wgpu::TextureUsage fToWGPUTextureUsage(const filament::backend::TextureUsage& fUsage);
 };
 
 struct WGPURenderPrimitive : public HwRenderPrimitive {
@@ -256,7 +252,7 @@ private:
 
     Attachment color[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT] = {};
     math::uint2 attachmentSize = {};
-    std::vector<wgpu::RenderPassColorAttachment> colorAttachments{};
+    std::vector<wgpu::RenderPassColorAttachment> colorAttachments {};
 };
 
 }// namespace filament::backend

filament/backend/test/BackendTest.cpp

@@ -45,7 +45,6 @@ namespace test {
 Backend BackendTest::sBackend = Backend::NOOP;
 OperatingSystem BackendTest::sOperatingSystem = OperatingSystem::OTHER;
 bool BackendTest::sIsMobilePlatform = false;
-std::vector<std::string> BackendTest::sFailedImages;
 
 void BackendTest::init(Backend backend, OperatingSystem operatingSystem, bool isMobilePlatform) {
     sBackend = backend;
@@ -64,12 +63,11 @@ BackendTest::~BackendTest() {
     flushAndWait();
     mImageExpectations->evaluate();
     // Note: Don't terminate the driver for OpenGL, as it wipes away the context and removes the buffer from the screen.
-    if (sBackend != Backend::OPENGL) {
-        driver->terminate();
-        delete driver;
+    if (sBackend == Backend::OPENGL) {
+        return;
     }
-
-    recordFailedImages();
+    driver->terminate();
+    delete driver;
 }
 
 void BackendTest::initializeDriver() {
@@ -169,24 +167,8 @@ bool BackendTest::matchesEnvironment(OperatingSystem operatingSystem) {
     return sOperatingSystem == operatingSystem;
 }
 
-void BackendTest::markImageAsFailure(std::string failedImageName) {
-    sFailedImages.emplace_back(std::move(failedImageName));
-}
-
-void BackendTest::recordFailedImages() {
-    if (!sFailedImages.empty()) {
-        std::string failedImages;
-        for (auto& failedTestImageName: sFailedImages) {
-            if (failedImages.empty()) {
-                failedImages = failedTestImageName;
-            } else {
-                failedImages.append(",");
-                failedImages.append(failedTestImageName);
-            }
-        }
-        RecordProperty("FailedImages", failedImages);
-    }
-    sFailedImages.clear();
+bool BackendTest::matchesEnvironment(OperatingSystem operatingSystem, Backend backend) {
+    return matchesEnvironment(operatingSystem) && matchesEnvironment(backend);
 }
 
 class Environment : public ::testing::Environment {

filament/backend/test/BackendTest.h

@@ -38,9 +38,6 @@ public:
     static OperatingSystem sOperatingSystem;
     static bool sIsMobilePlatform;
 
-    // Takes the name of the image that wasn't correct, without the .png suffix
-    static void markImageAsFailure(std::string failedImageName);
-
 protected:
 
     BackendTest();
@@ -76,13 +73,8 @@ protected:
 
     static bool matchesEnvironment(Backend backend);
     static bool matchesEnvironment(OperatingSystem operatingSystem);
+    static bool matchesEnvironment(OperatingSystem operatingSystem, Backend backend);
 private:
-    // Adds all the images that failed an ImageExpectation to the XML metadata for the current tests
-    // case. Add --gtest_output=xml as a command line argument to generate a test_detail.xml file in
-    // the directory where the tests are run.
-    static void recordFailedImages();
-
-    static std::vector<std::string> sFailedImages;
 
     filament::backend::Driver* driver = nullptr;
     filament::backend::CommandBufferQueue commandBufferQueue;

filament/backend/test/ImageExpectations.cpp

@@ -21,7 +21,6 @@
 #include "utils/Hash.h"
 #include <fstream>
 
-#include "BackendTest.h"
 #include "backend/PixelBufferDescriptor.h"
 #include "private/backend/DriverApi.h"
 
@@ -33,8 +32,6 @@
 
 #endif
 
-namespace test {
-
 ScreenshotParams::ScreenshotParams(int width, int height, std::string fileName,
         uint32_t expectedHash, bool isSrgb)
     : mWidth(width),
@@ -83,10 +80,6 @@ std::string ScreenshotParams::expectedFilePath() const {
     return absl::StrFormat("%s/%s", expectedDirectoryPath(), expectedFileName());
 }
 
-const std::string ScreenshotParams::filePrefix() const {
-    return mFileName;
-}
-
 ImageExpectation::ImageExpectation(const char* fileName, int lineNumber,
         filament::backend::DriverApi& api, ScreenshotParams params,
         filament::backend::RenderTargetHandle renderTarget)
@@ -120,11 +113,7 @@ void ImageExpectation::compareImage() const {
 #ifndef FILAMENT_IOS
         LoadedPng loadedImage(mParams.expectedFilePath());
         uint32_t loadedImageHash = loadedImage.hash();
-        auto compareToImageMatcher = testing::Eq(loadedImageHash);
-        if (!testing::Matches(compareToImageMatcher)(actualHash)) {
-            BackendTest::markImageAsFailure(mParams.filePrefix());
-        }
-        EXPECT_THAT(actualHash, compareToImageMatcher) << mParams.expectedFileName();
+        EXPECT_THAT(actualHash, testing::Eq(loadedImageHash)) << mParams.expectedFileName();
 #endif
         // For builds that can't load PNGs (currently iOS only) use the expected hash.
         EXPECT_THAT(actualHash, testing::Eq(mParams.expectedHash())) << mParams.expectedFileName();
@@ -211,10 +200,6 @@ uint32_t RenderTargetDump::hash() const {
     return mInternal->hash();
 }
 
-const std::vector<unsigned char>& RenderTargetDump::bytes() const {
-    return mInternal->bytes;
-}
-
 bool RenderTargetDump::bytesFilled() const {
     return mInternal->bytesFilled;
 }
@@ -252,5 +237,3 @@ uint32_t LoadedPng::hash() const {
 const std::vector<unsigned char>& LoadedPng::bytes() const {
     return mBytes;
 }
-
-} // namespace test

filament/backend/test/ImageExpectations.h

@@ -35,8 +35,6 @@ do {                                                                \
         screenshotParams);                                          \
 } while (0)
 
-namespace test {
-
 /**
  * Stores user-provided configuration values for an image expectation
  */
@@ -56,7 +54,6 @@ public:
     static std::string expectedDirectoryPath();
     std::string expectedFileName() const;
     std::string expectedFilePath() const;
-    const std::string filePrefix() const;
 
 private:
     int mWidth;
@@ -85,12 +82,6 @@ public:
      * @return The hash of the stored bytes.
      */
     uint32_t hash() const;
-    /**
-     * Gets the bytes of the render target. The hash should usually be preferable for comparisons
-     * but this is available for debugging.
-     * @return The stored bytes.
-     */
-    const std::vector<unsigned char>& bytes() const;
     /**
      * Thread safe as this is backed by an atomic.
      * Once this returns true it will never return false.
@@ -162,6 +153,4 @@ private:
     std::vector<std::unique_ptr<ImageExpectation>> mExpectations;
 };
 
-} // namespace test
-
 #endif //TNT_IMAGE_EXPECTATIONS_H

filament/backend/test/ShaderGenerator.cpp

@@ -17,6 +17,7 @@
 #include "ShaderGenerator.h"
 
 #include <GlslangToSpv.h>
+#include <SPVRemapper.h>
 
 #include <spirv_glsl.hpp>
 #include <spirv_msl.hpp>

filament/backend/test/Skip.h

@@ -32,24 +32,13 @@ do {
     }                                                                                          \
 } while (false)
 
-#define NONFATAL_FAIL_IF(skipEnvironment, rationale)                                           \
-do {                                                                                           \
-    SkipEnvironment skip(skipEnvironment);                                                     \
-    if (skip.matches()) {                                                                      \
-        ADD_FAILURE()                                                                          \
-                << "Failing test as the " << skip.describe() << "\n"                           \
-                << " This test has a known failure where "   \
-                << rationale;                                                                  \
-    }                                                                                          \
-} while (false)
-
 #define FAIL_IF(skipEnvironment, rationale)                                                    \
 do {                                                                                           \
     SkipEnvironment skip(skipEnvironment);                                                     \
     if (skip.matches()) {                                                                      \
         GTEST_FAIL()                                                                           \
                 << "Failing test as the " << skip.describe() << "\n"                           \
-                << " This test should be able to succeed but it needs to fail early because "  \
+                << " This test should be able to succeed but it needs to fail early because"   \
                 << rationale;                                                                  \
     }                                                                                          \
 } while (false)

filament/backend/test/move_actual_images_to_expected.py

@@ -1,153 +1,62 @@
-import os, shutil, argparse, typing, xml.etree.ElementTree, subprocess, platform
+import os, shutil, argparse, typing
+
+def match_sufffix(file_name: str, suffix: str, accepted_prefixes: typing.List[str]) -> str:
+  """
+  Check if the file name is one of the searched for ones with the given suffix and if so return it.
+  :param accepted_prefixes: If None accepts any prefix
+  :return: file_name with the suffix removed or "" if it doesn't match. This does mean a string that
+  is just the suffix is considered to not match as it will return the empty string.
+  """
+  if file_name.endswith(suffix):
+    prefix = file_name.removesuffix(suffix)
+    if accepted_prefixes is None or prefix in accepted_prefixes:
+      return prefix
+  return ""
 
 
-class TestResults(object):
-    ACTUAL_SUFFIX = '_actual.png'
-    EXPECTED_SUFFIX = '.png'
-
-    def __init__(self, results_directory: str, source_expected_directory: str):
-        self.results_directory = results_directory
-        self.actual_directory = os.path.join(self.results_directory, 'images', 'actual_images')
-        self.expected_directory = os.path.join(self.results_directory, 'images', 'expected_images')
-        self.source_expected_directory = source_expected_directory
-
-    def get_latest_failed_images(self) -> typing.List[str]:
-        failed_images = []
-        xml_tree = xml.etree.ElementTree.parse(
-            os.path.join(self.results_directory, 'test_detail.xml'))
-        testsuites = xml_tree.getroot()
-        for testsuite in testsuites.findall('testsuite'):
-            for testcase in testsuite.findall('testcase'):
-                for properties in testcase.findall('properties'):
-                    for property in properties.findall('property'):
-                        if property.get('name') == 'FailedImages':
-                            failed_images.extend(property.get('value').split(','))
-
-        return failed_images
-
-    def handle_failed_image(self, failed_image):
-        self.show_images(failed_image)
-        print(f'Update {failed_image}\'s expected image? y/n')
-        while True:
-            user_input = input()
-            if user_input == 'y':
-                self.move_actual_to_source([failed_image])
-                break
-            elif user_input == 'n':
-                break
-
-    def handle_all_failed_images(self):
-        for failed_image in self.get_latest_failed_images():
-            self.handle_failed_image(failed_image)
-
-    def show_images(self, failed_image):
-        # TODO: Test more on non-mac systems
-        open_command: str
-        os_name = platform.system().lower()
-        if 'windows' in os_name:
-            open_command = 'start'
-        elif 'osx' in os_name or 'darwin' in os_name:
-            open_command = 'open'
-        else:
-            open_command = 'xdg-open'
-
-        subprocess.run(
-            [open_command,
-             os.path.join(self.actual_directory, failed_image + TestResults.ACTUAL_SUFFIX)])
-        subprocess.run(
-            [open_command,
-             os.path.join(self.expected_directory, failed_image + TestResults.EXPECTED_SUFFIX)])
-
-    def move_actual_to_source(self, file_prefixes: typing.List[str]):
-        replace_file_names(path=self.actual_directory, removed=TestResults.ACTUAL_SUFFIX,
-                           replacement=TestResults.EXPECTED_SUFFIX,
-                           output_path=self.source_expected_directory, prefixes=file_prefixes)
-
-    def batch_move(self, prefixes: typing.Optional[typing.List[str]] = None):
-        replace_file_names(path=self.actual_directory, removed=TestResults.ACTUAL_SUFFIX,
-                           replacement=TestResults.EXPECTED_SUFFIX,
-                           output_path=self.source_expected_directory, prefixes=prefixes)
-
-
-def match_suffix(file_name: str, suffix: str, accepted_prefixes: typing.List[str]) -> str:
-    """
-    Check if the file name is one of the searched for ones with the given suffix and if so return
-    it.
-    :param accepted_prefixes: If None accepts any prefix
-    :return: file_name with the suffix removed or "" if it doesn't match. This does mean a string
-    that is just the suffix is considered to not match as it will return the empty string.
-    """
-    if file_name.endswith(suffix):
-        prefix = file_name.removesuffix(suffix)
-        if accepted_prefixes is None or prefix in accepted_prefixes:
-            return prefix
-    return ''
-
-
-def replace_file_names(path: str, removed: str, replacement: str = '', output_path: str = '',
-                       prefixes: typing.Optional[typing.List[str]] = None):
-    if not output_path:
-        output_path = path
-    for file_name in os.listdir(path=path):
-        prefix = match_suffix(file_name, removed, prefixes)
-        if prefix:
-            # Remove the prefix from the list so that prefixes is the list of intended but not yet
-            # found files.
-            if prefixes is not None:
-                prefixes.remove(prefix)
-            new_file_name = prefix + replacement
-            new_file_path = os.path.join(output_path, new_file_name)
-            old_file_path = os.path.join(path, file_name)
-            print(f'{old_file_path} to {new_file_path}')
-            shutil.copyfile(old_file_path, new_file_path)
-    if prefixes is not None:
-        for unfound_prefix in prefixes:
-            print(f'Failed to find {unfound_prefix}_actual.png')
-
+def replace_file_names(path: str, removed: str, replacement: str = "", output_path: str = "",
+                       prefixes: typing.List[str] = None):
+  if not output_path:
+    output_path = path
+  for file_name in os.listdir(path=path):
+    prefix = match_sufffix(file_name, removed, prefixes)
+    if prefix:
+      # Remove the prefix from the list so that prefixes is the list of intended but not yet found
+      # files.
+      if prefixes is not None:
+        prefixes.remove(prefix)
+      new_file_name = prefix + replacement
+      new_file_path = os.path.join(output_path, new_file_name)
+      old_file_path = os.path.join(path, file_name)
+      print(f'{old_file_path} to {new_file_path}')
+      shutil.move(old_file_path, new_file_path)
+  if prefixes is not None:
+    for unfound_prefix in prefixes:
+      print(f'Failed to find {unfound_prefix}_actual.png')
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(prog='Backend Test File Renamer',
-                                     description='Moves actual generated test images to the '
-                                                 'expected images directory, to update the test '
-                                                 'requirements. test_cases accepts multiple '
-                                                 'arguments that should be the name of the '
-                                                 'expected image file without the .png suffix. '
-                                                 'Also --all can be passed to copy all images.\n'
-                                                 'Remember to sync CMake after running this to '
-                                                 'move the new expected images to the binary '
-                                                 'directory.')
-    parser.add_argument('-r', '--results_path',
-                        help='The path with the generated images directory, which should be where '
-                             'the test binary was run.')
-    parser.add_argument('-s', '--source_expected_path', default="./expected_images",
-                        help='The directory that updated expected images should be written to, '
-                             'which should be the source directory copy.')
-    # The mutually exclusive options for how to process the actual images
-    parser.add_argument('-b', '--batch', action='extend', nargs='*',
-                        help='If true copy all actual images to the source expected image '
-                             'directory.')
-    parser.add_argument('-a', '--all', action='store_true',
-                        help='If true, visually compare all generated images.')
-    parser.add_argument('-t', '--tests', action='store_true',
-                        help='If true use a test_detail.xml file that exists in the results_path '
-                             'directory to visually compare all images that failed a test.')
-    parser.add_argument('-c', '--compare', action='extend', nargs='*',
-                        help='A list of image names to visually compare (without the .png suffix).')
+  parser = argparse.ArgumentParser(prog='Backend Test File Renamer',
+                                   description='Moves actual generated test images to the expected '
+                                               'images directory, to update the test requirements. '
+                                               'test_cases accepts multiple arguments that should '
+                                               'be the name of the expected image file without the '
+                                               '.png suffix. Also --all can be passed to copy all '
+                                               'images.\n'
+                                               'Remember to sync CMake after running this to move '
+                                               'the new expected images to the binary directory.')
+  parser.add_argument('-i', '--input_path')
+  parser.add_argument('-o', '--output_path', default="./expected_images")
+  parser.add_argument('-t', '--test_cases', action='extend', nargs='*')
+  parser.add_argument('-a', '--all', action='store_true')
 
-    args = parser.parse_args()
-    if not args.results_path:
-        raise AssertionError("No result path provided")
-    results_path = args.results_path
+  args = parser.parse_args()
+  input_path = "."
+  if args.input_path:
+    input_path = args.input_path
 
-    results = TestResults(results_directory=results_path,
-                          source_expected_directory=args.source_expected_path)
+  prefixes = args.test_cases
+  if args.all:
+    prefixes = None
 
-    if args.all:
-        results.batch_move()
-    elif args.tests:
-        results.handle_all_failed_images()
-    elif args.compare:
-        for file_prefix in args.compare:
-            results.show_images(file_prefix)
-    else:
-        results.batch_move(args.batch)
+  replace_file_names(path=input_path, output_path=args.output_path, removed="_actual.png",
+                     replacement=".png", prefixes=prefixes)

filament/backend/test/test_Blit.cpp

@@ -260,8 +260,6 @@ TEST_F(BlitTest, ColorMinify) {
 }
 
 TEST_F(BlitTest, ColorResolve) {
-    NONFATAL_FAIL_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::VULKAN),
-            "Nothing is drawn, see b/417229577");
     auto& api = getDriverApi();
 
     constexpr int kSrcTexWidth = 256;
@@ -492,7 +490,7 @@ TEST_F(BlitTest, BlitRegion) {
 }
 
 TEST_F(BlitTest, BlitRegionToSwapChain) {
-    FAIL_IF(Backend::VULKAN, "Crashes due to not finding color attachment, see b/417481493");
+    FAIL_IF(Backend::VULKAN, "Crashes due to not finding color attachment");
     auto& api = getDriverApi();
     mCleanup.addPostCall([&]() { executeCommands(); });
 

filament/backend/test/test_BufferUpdates.cpp

@@ -20,7 +20,6 @@
 #include "Lifetimes.h"
 #include "Shader.h"
 #include "SharedShaders.h"
-#include "Skip.h"
 #include "TrianglePrimitive.h"
 
 namespace test {
@@ -160,8 +159,6 @@ TEST_F(BufferUpdatesTest, VertexBufferUpdate) {
 // This test renders two triangles in two separate draw calls. Between the draw calls, a uniform
 // buffer object is partially updated.
 TEST_F(BufferUpdatesTest, BufferObjectUpdateWithOffset) {
-    NONFATAL_FAIL_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::VULKAN),
-            "All values including alpha are written as 0, see b/417254943");
     auto& api = getDriverApi();
     Cleanup cleanup(api);
 

filament/backend/test/test_Callbacks.cpp

@@ -26,7 +26,6 @@ namespace test {
 
 TEST_F(BackendTest, FrameScheduledCallback) {
     SKIP_IF(Backend::OPENGL, "Frame callbacks are unsupported in OpenGL");
-    SKIP_IF(Backend::VULKAN, "Frame callbacks are unsupported in Vulkan, see b/417254479");
 
     auto& api = getDriverApi();
     Cleanup cleanup(api);
@@ -86,7 +85,6 @@ TEST_F(BackendTest, FrameScheduledCallback) {
 
 TEST_F(BackendTest, FrameCompletedCallback) {
     SKIP_IF(Backend::OPENGL, "Frame callbacks are unsupported in OpenGL");
-    SKIP_IF(Backend::VULKAN, "Frame callbacks are unsupported in Vulkan, see b/417254479");
 
     auto& api = getDriverApi();
     Cleanup cleanup(api);

filament/backend/test/test_FeedbackLoops.cpp

@@ -99,8 +99,6 @@ struct MaterialParams {
 // 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) {
-    NONFATAL_FAIL_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::VULKAN),
-            "Image is unexpectedly darker, see b/417226296");
     SKIP_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::OPENGL),
             "OpenGL image is upside down due to readPixels failing for texture with uploaded image "
             "data");

filament/backend/test/test_LoadImage.cpp

@@ -212,7 +212,7 @@ static SamplerFormat getSamplerFormat(TextureFormat textureFormat) {
 }
 
 TEST_F(LoadImageTest, UpdateImage2D) {
-    FAIL_IF(Backend::VULKAN, "Multiple test cases crash, see b/417481434");
+    FAIL_IF(Backend::VULKAN, "Multiple test cases crash");
 
     // All of these test cases should result in the same rendered image, and thus the same hash.
     static const uint32_t expectedHash = 3644679986;
@@ -485,9 +485,6 @@ TEST_F(LoadImageTest, UpdateImageMipLevel) {
 }
 
 TEST_F(LoadImageTest, UpdateImage3D) {
-    NONFATAL_FAIL_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::VULKAN),
-            "Checkerboard not drawn, possibly due to using wrong z value of 3d texture, "
-            "see b/417254499");
     auto& api = getDriverApi();
     Cleanup cleanup(api);
     api.startCapture();

filament/backend/test/test_PushConstants.cpp

@@ -81,8 +81,7 @@ void main() {
 
 TEST_F(BackendTest, PushConstants) {
     SKIP_IF(Backend::OPENGL, "Push constants not supported on OpenGL");
-    FAIL_IF(Backend::VULKAN,
-            "Crashing due to no program set when setting push constants, see b/417477740");
+    FAIL_IF(Backend::VULKAN, "Crashing due to no program set when setting push constants");
 
     auto& api = getDriverApi();
 

filament/backend/test/test_ReadPixels.cpp

@@ -20,7 +20,6 @@
 #include "Lifetimes.h"
 #include "Shader.h"
 #include "SharedShaders.h"
-#include "Skip.h"
 #include "TrianglePrimitive.h"
 
 #include <utils/Hash.h>
@@ -75,8 +74,6 @@ public:
 };
 
 TEST_F(ReadPixelsTest, ReadPixels) {
-    NONFATAL_FAIL_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::VULKAN),
-            "Two cases fail, see b/417255941 and b/417255943");
     // These test scenarios use a known hash of the result pixel buffer to decide pass / fail,
     // asserting an exact pixel-for-pixel match. So far, rendering on macOS and iPhone have had
     // deterministic results. Take this test with a grain of salt, however, as other platform / GPU

filament/backend/test/test_Scissor.cpp

@@ -20,7 +20,6 @@
 #include "Lifetimes.h"
 #include "Shader.h"
 #include "SharedShaders.h"
-#include "Skip.h"
 #include "TrianglePrimitive.h"
 
 #include <utils/Hash.h>
@@ -31,8 +30,6 @@ using namespace filament;
 using namespace filament::backend;
 
 TEST_F(BackendTest, ScissorViewportRegion) {
-    NONFATAL_FAIL_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::VULKAN),
-            "Affected area in wrong corner, see b/417229118");
     auto& api = getDriverApi();
 
     constexpr int kSrcTexWidth = 1024;

filament/backend/test/test_StencilBuffer.cpp

@@ -117,8 +117,6 @@ public:
 };
 
 TEST_F(BasicStencilBufferTest, StencilBuffer) {
-    SKIP_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::VULKAN),
-            "Stencil not supported, see b/417230776");
     auto& api = getDriverApi();
     Cleanup cleanup(api);
 
@@ -141,8 +139,6 @@ TEST_F(BasicStencilBufferTest, StencilBuffer) {
 }
 
 TEST_F(BasicStencilBufferTest, DepthAndStencilBuffer) {
-    SKIP_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::VULKAN),
-            "Stencil not supported, see b/417230776");
     auto& api = getDriverApi();
     Cleanup cleanup(api);
 
@@ -166,8 +162,6 @@ TEST_F(BasicStencilBufferTest, DepthAndStencilBuffer) {
 }
 
 TEST_F(BasicStencilBufferTest, StencilBufferMSAA) {
-    SKIP_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::VULKAN),
-            "Stencil not supported, see b/417230776");
     SKIP_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::OPENGL), "Stencil isn't applied");
     auto& api = getDriverApi();
     Cleanup cleanup(api);

filament/include/filament/SwapChain.h

@@ -21,6 +21,7 @@
 
 #include <backend/CallbackHandler.h>
 #include <backend/DriverEnums.h>
+#include <backend/PresentCallable.h>
 
 #include <utils/compiler.h>
 #include <utils/Invocable.h>
@@ -34,7 +35,7 @@ class Engine;
 /**
  * A swap chain represents an Operating System's *native* renderable surface.
  *
- * Typically, it's a native window or a view. Because a SwapChain is initialized from a
+ * Typically it's a native window or a view. Because a SwapChain is initialized from a
  * native object, it is given to filament as a `void *`, which must be of the proper type
  * for each platform filament is running on.
  *
@@ -157,7 +158,7 @@ public:
     /**
      * Requests a SwapChain with an alpha channel.
      */
-    static constexpr uint64_t CONFIG_TRANSPARENT = backend::SWAP_CHAIN_CONFIG_TRANSPARENT;
+    static const uint64_t CONFIG_TRANSPARENT = backend::SWAP_CHAIN_CONFIG_TRANSPARENT;
 
     /**
      * This flag indicates that the swap chain may be used as a source surface
@@ -167,13 +168,13 @@ public:
      * @see
      * Renderer.copyFrame()
      */
-    static constexpr uint64_t CONFIG_READABLE = backend::SWAP_CHAIN_CONFIG_READABLE;
+    static const uint64_t CONFIG_READABLE = backend::SWAP_CHAIN_CONFIG_READABLE;
 
     /**
      * Indicates that the native X11 window is an XCB window rather than an XLIB window.
      * This is ignored on non-Linux platforms and in builds that support only one X11 API.
      */
-    static constexpr uint64_t CONFIG_ENABLE_XCB = backend::SWAP_CHAIN_CONFIG_ENABLE_XCB;
+    static const uint64_t CONFIG_ENABLE_XCB = backend::SWAP_CHAIN_CONFIG_ENABLE_XCB;
 
     /**
      * Indicates that the native window is a CVPixelBufferRef.
@@ -185,7 +186,7 @@ public:
      * Filament. Filament will call CVPixelBufferRetain during Engine::createSwapChain, and
      * CVPixelBufferRelease when the swap chain is destroyed.
      */
-    static constexpr uint64_t CONFIG_APPLE_CVPIXELBUFFER =
+    static const uint64_t CONFIG_APPLE_CVPIXELBUFFER =
             backend::SWAP_CHAIN_CONFIG_APPLE_CVPIXELBUFFER;
 
     /**
@@ -302,7 +303,6 @@ public:
      *
      * @param handler     Handler to dispatch the callback or nullptr for the default handler.
      * @param callback    Callback called when the frame is scheduled.
-     * @param flags
      *
      * @remark Only Filament's Metal backend supports PresentCallables and frame callbacks. Other
      * backends ignore the callback (which will never be called) and proceed normally.
@@ -314,7 +314,7 @@ public:
             FrameScheduledCallback&& callback = {}, uint64_t flags = 0);
 
     /**
-     * Returns whether this SwapChain currently has a FrameScheduledCallback set.
+     * Returns whether or not this SwapChain currently has a FrameScheduledCallback set.
      *
      * @return true, if the last call to setFrameScheduledCallback set a callback
      *

filament/src/AtlasAllocator.cpp

@@ -16,22 +16,13 @@
 
 #include "AtlasAllocator.h"
 
-#include <utils/compiler.h>
-#include <utils/algorithm.h>
 #include <utils/debug.h>
-#include <utils/QuadTree.h>
-
-#include <algorithm>
-#include <utility>
-
-#include <stddef.h>
-#include <stdint.h>
 
 namespace filament {
 
 using namespace utils;
 
-static constexpr std::pair<uint8_t, uint8_t> unmorton(uint16_t const m) noexcept {
+static inline constexpr std::pair<uint8_t, uint8_t> unmorton(uint16_t const m) noexcept {
     uint32_t r = (m | (uint32_t(m) << 15u)) & 0x55555555u;
     r = (r | (r >> 1u)) & 0x33333333u;
     r = (r | (r >> 2u)) & 0x0f0f0f0fu;
@@ -174,8 +165,8 @@ AtlasAllocator::NodeId AtlasAllocator::allocateInLayer(size_t const maxHeight) n
             NodeId found{ -1, 0 };
             QuadTree::traverse(candidate.l, candidate.code,
                     [this, n, &found](NodeId const& curr) -> QuadTree::TraversalResult {
-                        size_t const j = index(curr.l, curr.code);
-                        Node& node = mQuadTree[j];
+                        size_t const i = index(curr.l, curr.code);
+                        Node& node = mQuadTree[i];
                         if (curr.l == n) {
                             found = curr;
                             assert_invariant(!node.hasChildren());

ios/CocoaPods/Filament.podspec

@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
   spec.name = "Filament"
-  spec.version = "1.60.1"
+  spec.version = "1.59.4"
   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.60.1/filament-v1.60.1-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.59.4/filament-v1.59.4-ios.tgz" }
 
   # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
   spec.pod_target_xcconfig = {

ios/samples/README.md

@@ -102,8 +102,7 @@ project in Xcode to see changes take effect.
 
 ## Building iOS Samples with ASan / UBSan
 
-1. Turn on ASan / UBSan in Filament's top-level CMakeLists.txt by passing
-   `-DFILAMENT_ENABLE_ASAN_UBSAN=1` to trigger the following line:
+1. Turn on ASan / UBSan in Filament's top-level CMakeLists.txt by uncommenting the following line:
 
 ```
 set(EXTRA_SANITIZE_OPTIONS "-fsanitize=undefined -fsanitize=address")

libs/filabridge/include/filament/MaterialEnums.h

@@ -28,7 +28,7 @@
 namespace filament {
 
 // update this when a new version of filament wouldn't work with older materials
-static constexpr size_t MATERIAL_VERSION = 60;
+static constexpr size_t MATERIAL_VERSION = 59;
 
 /**
  * Supported shading models

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

@@ -52,7 +52,6 @@ public:
     using Precision = backend::Precision;
     using SamplerParams = backend::SamplerParams;
     using Binding = backend::descriptor_binding_t;
-    using ShaderStageFlags = backend::ShaderStageFlags;
 
     struct SamplerInfo { // NOLINT(cppcoreguidelines-pro-type-member-init)
         utils::CString name;        // name of this sampler
@@ -62,7 +61,6 @@ public:
         Format format;              // format of this sampler
         Precision precision;        // precision of this sampler
         bool multisample;           // multisample capable
-        ShaderStageFlags stages;    // stages the sampler can be accessed from
     };
 
     using SamplerInfoList = utils::FixedCapacityVector<SamplerInfo>;
@@ -84,8 +82,6 @@ public:
             Format format;                  // format of this sampler
             Precision precision;            // precision of this sampler
             bool multisample = false;       // multisample capable
-            ShaderStageFlags stages =
-                    ShaderStageFlags::ALL_SHADER_STAGE_FLAGS; // shader stages using this sampler
         };
 
         // Give a name to this sampler interface block
@@ -95,8 +91,8 @@ public:
 
         // Add a sampler
         Builder& add(std::string_view samplerName, Binding binding, Type type, Format format,
-                Precision precision = Precision::MEDIUM, bool multisample = false,
-                ShaderStageFlags stages = ShaderStageFlags::ALL_SHADER_STAGE_FLAGS) noexcept;
+                Precision precision = Precision::MEDIUM,
+                bool multisample = false) noexcept;
 
         // Add multiple samplers
         Builder& add(std::initializer_list<ListEntry> list) noexcept;

libs/filabridge/src/SamplerInterfaceBlock.cpp

@@ -49,13 +49,13 @@ SamplerInterfaceBlock::Builder::stageFlags(backend::ShaderStageFlags stageFlags)
     return *this;
 }
 
-SamplerInterfaceBlock::Builder& SamplerInterfaceBlock::Builder::add(std::string_view samplerName,
-        Binding binding, Type type, Format format, Precision precision, bool multisample,
-        ShaderStageFlags stages) noexcept {
+SamplerInterfaceBlock::Builder& SamplerInterfaceBlock::Builder::add(
+        std::string_view samplerName, Binding binding, Type type, Format format,
+        Precision precision, bool multisample) noexcept {
     mEntries.push_back({
             { samplerName.data(), samplerName.size() }, // name
             { }, // uniform name
-            binding, type, format, precision, multisample, stages });
+            binding, type, format, precision, multisample });
     return *this;
 }
 
@@ -66,7 +66,7 @@ SamplerInterfaceBlock SamplerInterfaceBlock::Builder::build() {
 SamplerInterfaceBlock::Builder& SamplerInterfaceBlock::Builder::add(
         std::initializer_list<ListEntry> list) noexcept {
     for (auto& e : list) {
-        add(e.name, e.binding, e.type, e.format, e.precision, e.multisample, e.stages);
+        add(e.name, e.binding, e.type, e.format, e.precision, e.multisample);
     }
     return *this;
 }
@@ -91,7 +91,6 @@ SamplerInterfaceBlock::SamplerInterfaceBlock(Builder const& builder) noexcept
         size_t const i = std::distance(builder.mEntries.data(), &e);
         SamplerInfo& info = samplersInfoList[i];
         info = e;
-        info.stages &= builder.mStageFlags;
         info.uniformName = generateUniformName(mName.c_str(), e.name.c_str());
         infoMap[{ info.name.data(), info.name.size() }] = i; // info.name.c_str() guaranteed constant
     }

libs/filamat/CMakeLists.txt

@@ -56,7 +56,6 @@ set(PRIVATE_HDRS
         src/MetalArgumentBuffer.h
         src/ShaderMinifier.h
         src/SpirvFixup.h
-        src/SpirvRemapWrapper.h
         src/sca/ASTHelpers.h
         src/sca/GLSLTools.h
         src/sca/builtinResource.h)
@@ -72,8 +71,7 @@ set(SRCS
         src/sca/GLSLTools.cpp
         src/GLSLPostProcessor.cpp
         src/ShaderMinifier.cpp
-        src/SpirvFixup.cpp
-        src/SpirvRemapWrapper.cpp)
+        src/SpirvFixup.cpp)
 
 # ==================================================================================================
 # Include and target definitions

libs/filamat/include/filamat/Enums.h

@@ -35,7 +35,6 @@ using OutputTarget = MaterialBuilder::OutputTarget;
 using OutputQualifier = MaterialBuilder::VariableQualifier;
 using OutputType = MaterialBuilder::OutputType;
 using ConstantType = MaterialBuilder::ConstantType;
-using ShaderStageType = MaterialBuilder::ShaderStageFlags;
 
 // Convenience methods to convert std::string to Enum and also iterate over Enum values.
 class Enums {
@@ -80,7 +79,6 @@ private:
     static std::unordered_map<std::string, OutputQualifier> mStringToOutputQualifier;
     static std::unordered_map<std::string, OutputType> mStringToOutputType;
     static std::unordered_map<std::string, ConstantType> mStringToConstantType;
-    static std::unordered_map<std::string, ShaderStageType> mStringToShaderStageType;
 };
 
 template<typename T>

libs/filamat/include/filamat/MaterialBuilder.h

@@ -254,7 +254,6 @@ public:
     using FeatureLevel = filament::backend::FeatureLevel;
     using StereoscopicType = filament::backend::StereoscopicType;
     using ShaderStage = filament::backend::ShaderStage;
-    using ShaderStageFlags = filament::backend::ShaderStageFlags;
 
     enum class VariableQualifier : uint8_t {
         OUT
@@ -323,9 +322,9 @@ public:
      */
     MaterialBuilder& parameter(const char* name, SamplerType samplerType,
             SamplerFormat format = SamplerFormat::FLOAT,
-            ParameterPrecision precision = ParameterPrecision::DEFAULT, bool multisample = false,
-            const char* transformName = "",
-            ShaderStageFlags stages = ShaderStageFlags::ALL_SHADER_STAGE_FLAGS) noexcept;
+            ParameterPrecision precision = ParameterPrecision::DEFAULT,
+            bool multisample = false,
+            const char* transformName = "") noexcept;
 
     MaterialBuilder& buffer(filament::BufferInterfaceBlock bib) noexcept;
 
@@ -657,10 +656,8 @@ public:
         Parameter() noexcept: parameterType(INVALID) {}
 
         // Sampler
-        Parameter(const char* paramName, SamplerType t, SamplerFormat f, ParameterPrecision p,
-                bool ms, const char* tn, ShaderStageFlags s)
-            : name(paramName), size(1), precision(p), samplerType(t), format(f),
-              parameterType(SAMPLER), multisample(ms), transformName(tn), stages(s) { }
+        Parameter(const char* paramName, SamplerType t, SamplerFormat f, ParameterPrecision p, bool ms, const char* tn)
+                : name(paramName), size(1), precision(p), samplerType(t), format(f), parameterType(SAMPLER), multisample(ms), transformName(tn) { }
 
         // Uniform
         Parameter(const char* paramName, UniformType t, size_t typeSize, ParameterPrecision p)
@@ -679,7 +676,6 @@ public:
         SamplerFormat format;
         bool multisample;
         utils::CString transformName;
-        ShaderStageFlags stages;
         enum {
             INVALID,
             UNIFORM,

libs/filamat/src/Enums.cpp

@@ -175,15 +175,4 @@ std::unordered_map<std::string, ConstantType>& Enums::getMap<ConstantType>() noe
     return mStringToConstantType;
 };
 
-std::unordered_map<std::string, ShaderStageType> Enums::mStringToShaderStageType = {
-        { "fragment", ShaderStageType::FRAGMENT },
-        { "vertex",   ShaderStageType::VERTEX },
-        { "compute",  ShaderStageType::COMPUTE },
-};
-
-template <>
-std::unordered_map<std::string, ShaderStageType>& Enums::getMap<ShaderStageType>() noexcept {
-    return mStringToShaderStageType;
-};
-
 } // namespace filamat

libs/filamat/src/GLSLPostProcessor.cpp

@@ -17,6 +17,7 @@
 #include "GLSLPostProcessor.h"
 
 #include <GlslangToSpv.h>
+#include <SPVRemapper.h>
 #include <spirv-tools/libspirv.hpp>
 
 #include <spirv_glsl.hpp>
@@ -144,12 +145,12 @@ DescriptorSetLayout getPerMaterialDescriptorSet(SamplerInterfaceBlock const& sib
             ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,
             +PerMaterialBindingPoints::MATERIAL_PARAMS, DescriptorFlags::NONE, 0 });
 
-    for (auto const& sampler: samplers) {
-        layout.bindings.push_back(DescriptorSetLayoutBinding{
-            (sampler.type == SamplerInterfaceBlock::Type::SAMPLER_EXTERNAL)
-                    ? DescriptorType::SAMPLER_EXTERNAL
-                    : DescriptorType::SAMPLER,
-            sampler.stages, sampler.binding, DescriptorFlags::NONE, 0 });
+    for (auto const& sampler : samplers) {
+        layout.bindings.push_back(DescriptorSetLayoutBinding {
+                (sampler.type == SamplerInterfaceBlock::Type::SAMPLER_EXTERNAL) ?
+                        DescriptorType::SAMPLER_EXTERNAL : DescriptorType::SAMPLER,
+                ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT, sampler.binding,
+                DescriptorFlags::NONE, 0 });
     }
 
     return layout;
@@ -288,8 +289,24 @@ GLSLPostProcessor::GLSLPostProcessor(MaterialBuilder::Optimization optimization,
         : mOptimization(optimization),
           mPrintShaders(flags & PRINT_SHADERS),
           mGenerateDebugInfo(flags & GENERATE_DEBUG_INFO) {
-    // This should occur only once, to avoid races.
-    SpirvRemapWrapperSetUp();
+    // SPIRV error handler registration needs to occur only once. To avoid a race we do it up here
+    // in the constructor, which gets invoked before MaterialBuilder kicks off jobs.
+    spv::spirvbin_t::registerErrorHandler([](const std::string& str) {
+        slog.e << str << io::endl;
+    });
+
+    // Similar to above, we need to do a no-op remap to init a static table in the remapper before
+    // the jobs start using remap().
+    spv::spirvbin_t remapper(0);
+    // We need to provide at least a valid header to not crash.
+    SpirvBlob spirv {
+        0x07230203,// MAGIC
+        0,         // VERSION
+        0,         // GENERATOR
+        0,         // BOUND
+        0          // SCHEMA, must be 0
+    };
+    remapper.remap(spirv, 0);
 }
 
 GLSLPostProcessor::~GLSLPostProcessor() = default;
@@ -971,7 +988,8 @@ void GLSLPostProcessor::optimizeSpirv(OptimizerPtr optimizer, SpirvBlob& spirv)
     }
 
     // Remove dead module-level objects: functions, types, vars
-    SpirvRemapWrapperRemap(spirv);
+    spv::spirvbin_t remapper(0);
+    remapper.remap(spirv, spv::spirvbin_base_t::DCE_ALL);
 }
 
 void GLSLPostProcessor::fixupClipDistance(

libs/filamat/src/GLSLPostProcessor.h

@@ -23,7 +23,6 @@
 #include <private/filament/SamplerInterfaceBlock.h>
 
 #include "ShaderMinifier.h"
-#include "SpirvRemapWrapper.h"
 
 #include <spirv-tools/optimizer.hpp>
 

libs/filamat/src/MaterialBuilder.cpp

@@ -302,8 +302,7 @@ MaterialBuilder& MaterialBuilder::parameter(const char* name, UniformType const
 
 
 MaterialBuilder& MaterialBuilder::parameter(const char* name, SamplerType samplerType,
-        SamplerFormat format, ParameterPrecision precision, bool multisample,
-        const char* transformName, ShaderStageFlags stages) noexcept {
+        SamplerFormat format, ParameterPrecision precision, bool multisample, const char* transformName) noexcept {
     FILAMENT_CHECK_PRECONDITION(!multisample ||
             (format != SamplerFormat::SHADOW &&
                     (samplerType == SamplerType::SAMPLER_2D ||
@@ -312,7 +311,7 @@ MaterialBuilder& MaterialBuilder::parameter(const char* name, SamplerType sample
                " as long as type is not SHADOW";
 
     FILAMENT_CHECK_POSTCONDITION(mParameterCount < MAX_PARAMETERS_COUNT) << "Too many parameters";
-    mParameters[mParameterCount++] = { name, samplerType, format, precision, multisample, transformName, stages };
+    mParameters[mParameterCount++] = { name, samplerType, format, precision, multisample, transformName };
     return *this;
 }
 
@@ -638,8 +637,8 @@ void MaterialBuilder::prepareToBuild(MaterialInfo& info) noexcept {
         auto const& param = mParameters[i];
         assert_invariant(!param.isSubpass());
         if (param.isSampler()) {
-            sbb.add({ param.name.data(), param.name.size() }, binding, param.samplerType,
-                    param.format, param.precision, param.multisample, param.stages);
+            sbb.add({ param.name.data(), param.name.size() },
+                    binding, param.samplerType, param.format, param.precision, param.multisample);
             if (!param.transformName.empty()) {
                 ibb.add({{{ param.transformName.data(), param.transformName.size() }, uint8_t(binding),
                           0, UniformType::MAT3, Precision::DEFAULT, FeatureLevel::FEATURE_LEVEL_0 }});

libs/filamat/src/SpirvRemapWrapper.cpp

@@ -1,54 +0,0 @@
-/*
- * Copyright (C) 2017 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 "SpirvRemapWrapper.h"
-
-#include <SPVRemapper.h>
-#include <utils/Log.h>
-#include <utils/ostream.h>
-
-#include <string>
-
-namespace filamat {
-
-void SpirvRemapWrapperSetUp() {
-    // SPIRV error handler registration should occur only once.
-    // Construct this SpirvRemapWrapper object only once.
-    spv::spirvbin_t::registerErrorHandler([](const std::string& str) {
-        utils::slog.e << str << utils::io::endl;
-    });
-
-    // Similar to above, we need to do a no-op remap to init a static
-    // table in the remapper before the jobs start using remap().
-    spv::spirvbin_t remapper(0);
-    // We need to provide at least a valid header to not crash.
-    std::vector<uint32_t> spirv {
-        0x07230203,// MAGIC
-        0,         // VERSION
-        0,         // GENERATOR
-        0,         // BOUND
-        0          // SCHEMA, must be 0
-    };
-    remapper.remap(spirv, 0);
-}
-
-void SpirvRemapWrapperRemap(std::vector<uint32_t>& spirv) {
-    // Remove dead module-level objects: functions, types, vars
-    spv::spirvbin_t remapper(0);
-    remapper.remap(spirv, spv::spirvbin_base_t::DCE_ALL);
-}
-
-} // namespace filamat

libs/filamat/src/SpirvRemapWrapper.h

@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2017 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_SPIRVREMAPWRAPPER_H
-#define TNT_SPIRVREMAPWRAPPER_H
-
-#include <cstdint>
-#include <vector>
-
-namespace filamat {
-
-void SpirvRemapWrapperSetUp();
-void SpirvRemapWrapperRemap(std::vector<uint32_t>& spirv);
-
-} // namespace filamat
-
-#endif //TNT_SPIRVREMAPWRAPPER_H

libs/filamat/src/eiff/MaterialInterfaceBlockChunk.cpp

@@ -233,7 +233,7 @@ void MaterialDescriptorSetLayoutChunk::flatten(Flattener& f) {
         } else {
             f.writeUint8(uint8_t(DescriptorType::SAMPLER));
         }
-        f.writeUint8(uint8_t(entry.stages));
+        f.writeUint8(uint8_t(ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT));
         f.writeUint8(entry.binding);
         f.writeUint8(uint8_t(DescriptorFlags::NONE));
         f.writeUint16(0);

libs/filamat/tests/test_filamat.cpp

@@ -26,7 +26,6 @@
 #include <filamat/MaterialBuilder.h>
 
 #include <utils/JobSystem.h>
-#include <utils/Panic.h>
 
 #include <memory>
 

libs/gltfio/src/FilamentInstance.cpp

@@ -21,7 +21,6 @@
 
 #include <utils/JobSystem.h>
 #include <utils/Log.h>
-#include <utils/Panic.h>
 
 using namespace filament;
 using namespace filament::math;

libs/gltfio/src/extended/TangentsJobExtended.cpp

@@ -24,7 +24,6 @@
 
 #include <geometry/TangentSpaceMesh.h>
 #include <utils/Log.h>
-#include <utils/Panic.h>
 #include <utils/StructureOfArrays.h>
 
 #include <cstring>

libs/uberz/src/WritableArchive.cpp

@@ -22,7 +22,6 @@
 #include <string_view>
 
 #include <utils/Log.h>
-#include <utils/Panic.h>
 
 using namespace utils;
 using namespace std::literals;

libs/utils/CMakeLists.txt

@@ -65,8 +65,6 @@ set(SRCS
         src/CyclicBarrier.cpp
         src/EntityManager.cpp
         src/EntityManagerImpl.h
-        src/FixedCapacityVectorBase.cpp
-        src/Invocable.cpp
         src/JobSystem.cpp
         src/Log.cpp
         src/NameComponentManager.cpp

libs/utils/include/utils/CString.h

@@ -20,9 +20,9 @@
 // NOTE: this header should not include STL headers
 
 #include <utils/compiler.h>
+#include <utils/ostream.h>
 
 #include <string_view>
-#include <utility>
 
 #include <assert.h>
 #include <stddef.h>
@@ -31,9 +31,6 @@
 #include <string.h>
 
 namespace utils {
-namespace io {
-class ostream;
-}
 
 //! \privatesection
 struct hashCStrings {
@@ -41,7 +38,7 @@ struct hashCStrings {
     typedef size_t result_type;
     result_type operator()(argument_type cstr) const noexcept {
         size_t hash = 5381;
-        while (int const c = static_cast<unsigned char>(*cstr++)) {
+        while (int const c = *cstr++) {
             hash = (hash * 33u) ^ size_t(c);
         }
         return hash;
@@ -100,7 +97,11 @@ public:
         return *this;
     }
 
-    ~CString() noexcept;
+    ~CString() noexcept {
+        if (mData) {
+            free(mData - 1);
+        }
+    }
 
     void swap(CString& other) noexcept {
         // don't use std::swap(), we don't want an STL dependency in this file
@@ -109,8 +110,8 @@ public:
         other.mCStr = temp;
     }
 
+    const_pointer c_str() const noexcept { return mCStr; }
     pointer c_str() noexcept { return mCStr; }
-    const_pointer c_str() const noexcept { return const_cast<CString*>(this)->c_str(); }
     const_pointer c_str_safe() const noexcept { return mData ? c_str() : ""; }
     const_pointer data() const noexcept { return c_str(); }
     pointer data() noexcept { return c_str(); }
@@ -118,89 +119,33 @@ public:
     size_type length() const noexcept { return size(); }
     bool empty() const noexcept { return size() == 0; }
 
-    iterator begin() noexcept { return c_str(); }
+    iterator begin() noexcept { return mCStr; }
     iterator end() noexcept { return begin() + length(); }
     const_iterator begin() const noexcept { return data(); }
     const_iterator end() const noexcept { return begin() + length(); }
     const_iterator cbegin() const noexcept { return begin(); }
     const_iterator cend() const noexcept { return end(); }
 
-    // replace
-    template<size_t N>
-    CString& replace(size_type const pos,
-            size_type const len, const StringLiteral<N>& str) & noexcept {
-        return replace(pos, len, str, N - 1);
-    }
+    CString& replace(size_type pos, size_type len, const CString& str) noexcept;
+    CString& insert(size_type pos, const CString& str) noexcept { return replace(pos, 0, str); }
+    CString& append(const CString& str) noexcept { return insert(length(), str); }
 
-    CString& replace(size_type const pos, size_type const len, const CString& str) & noexcept {
-        return replace(pos, len, str.c_str_safe(), str.size());
-    }
-
-    template<size_t N>
-    CString&& replace(size_type const pos,
-            size_type const len, const StringLiteral<N>& str) && noexcept {
-        return std::move(replace(pos, len, str));
-    }
-
-    CString&& replace(size_type const pos, size_type const len, const CString& str) && noexcept {
-        return std::move(replace(pos, len, str));
-    }
-
-    // insert
-    template<size_t N>
-    CString& insert(size_type const pos, const StringLiteral<N>& str) & noexcept {
-        return replace(pos, 0, str);
-    }
-
-    CString& insert(size_type const pos, const CString& str) & noexcept {
-        return replace(pos, 0, str);
-    }
-
-    template<size_t N>
-    CString&& insert(size_type const pos, const StringLiteral<N>& str) && noexcept {
-        return std::move(*this).replace(pos, 0, str);
-    }
-
-    CString&& insert(size_type const pos, const CString& str) && noexcept {
-        return std::move(*this).replace(pos, 0, str);
-    }
-
-    // append
-    template<size_t N>
-    CString& append(const StringLiteral<N>& str) & noexcept {
-        return insert(length(), str);
-    }
-
-    CString& append(const CString& str) & noexcept {
-        return insert(length(), str);
-    }
-
-    template<size_t N>
-    CString&& append(const StringLiteral<N>& str) && noexcept {
-        return std::move(*this).insert(length(), str);
-    }
-
-    CString&& append(const CString& str) && noexcept {
-        return std::move(*this).insert(length(), str);
-    }
-
-
-    const_reference operator[](size_type const pos) const noexcept {
+    const_reference operator[](size_type pos) const noexcept {
         assert(pos < size());
         return begin()[pos];
     }
 
-    reference operator[](size_type const pos) noexcept {
+    reference operator[](size_type pos) noexcept {
         assert(pos < size());
         return begin()[pos];
     }
 
-    const_reference at(size_type const pos) const noexcept {
+    const_reference at(size_type pos) const noexcept {
         assert(pos < size());
         return begin()[pos];
     }
 
-    reference at(size_type const pos) noexcept {
+    reference at(size_type pos) noexcept {
         assert(pos < size());
         return begin()[pos];
     }
@@ -226,7 +171,7 @@ public:
     }
 
     // placement new declared as "throw" to avoid the compiler's null-check
-    void* operator new(size_t, void* ptr) {
+    inline void* operator new(size_t, void* ptr) {
         assert(ptr);
         return ptr;
     }
@@ -240,8 +185,6 @@ public:
     };
 
 private:
-    CString& replace(size_type pos, size_type len, char const* str, size_t l) & noexcept;
-
 #if !defined(NDEBUG)
     friend io::ostream& operator<<(io::ostream& out, const CString& rhs);
 #endif
@@ -282,7 +225,7 @@ private:
     }
 };
 
-// Implement this for your type for automatic conversion to CString. Failing to do so leads
+// implement this for your type for automatic conversion to CString. Failing to do so leads
 // to a compile-time failure.
 template<typename T>
 CString to_string(T value) noexcept;
@@ -306,7 +249,7 @@ public:
     pointer c_str() noexcept { return mData; }
 
 private:
-    value_type mData[N] = {};
+    value_type mData[N] = {0};
 };
 
 } // namespace utils

libs/utils/include/utils/CallStack.h

@@ -23,11 +23,9 @@
 
 #include <utils/CString.h>
 #include <utils/compiler.h>
+#include <utils/ostream.h>
 
 namespace utils {
-namespace io {
-class ostream;
-}
 
 /**
  * CallStack captures the current's thread call stack.
@@ -90,23 +88,23 @@ public:
 
     bool operator <(const CallStack& rhs) const;
 
-    bool operator >(const CallStack& rhs) const {
+    inline bool operator >(const CallStack& rhs) const {
         return rhs < *this;
     }
 
-    bool operator !=(const CallStack& rhs) const {
+    inline bool operator !=(const CallStack& rhs) const {
         return *this < rhs || rhs < *this;
     }
 
-    bool operator >=(const CallStack& rhs) const {
+    inline bool operator >=(const CallStack& rhs) const {
         return !operator <(rhs);
     }
 
-    bool operator <=(const CallStack& rhs) const {
+    inline bool operator <=(const CallStack& rhs) const {
         return !operator >(rhs);
     }
 
-    bool operator ==(const CallStack& rhs) const {
+    inline bool operator ==(const CallStack& rhs) const {
         return !operator !=(rhs);
     }
 

libs/utils/include/utils/FixedCapacityVector.h

@@ -19,8 +19,8 @@
 
 #include <utils/compiler.h>
 #include <utils/compressed_pair.h>
+#include <utils/Panic.h>
 
-#include <algorithm>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
@@ -40,11 +40,6 @@
 
 namespace utils {
 
-class FixedCapacityVectorBase {
-protected:
-    UTILS_NORETURN static void capacityCheckFailed(size_t capacity, size_t size);
-};
-
 /**
  * FixedCapacityVector is (almost) a drop-in replacement for std::vector<> except it has a
  * fixed capacity decided at runtime. The vector storage is never reallocated unless reserve()
@@ -61,7 +56,7 @@ protected:
  * the optional value argument, e.g. FixedCapacityVector<int>(4, 0) or foo.resize(4, 0).
  */
 template<typename T, typename A = std::allocator<T>, bool CapacityCheck = true>
-class UTILS_PUBLIC FixedCapacityVector : protected FixedCapacityVectorBase {
+class UTILS_PUBLIC FixedCapacityVector {
 public:
     using allocator_type = A;
     using value_type = T;
@@ -271,7 +266,7 @@ public:
         mSize = 0;
     }
 
-    void resize(size_type const count) {
+    void resize(size_type count) {
         assertCapacityForSize(count);
         if constexpr(std::is_trivially_constructible_v<value_type> &&
                      std::is_trivially_destructible_v<value_type>) {
@@ -282,12 +277,12 @@ public:
         }
     }
 
-    void resize(size_type const count, const_reference v) {
+    void resize(size_type count, const_reference v) {
         assertCapacityForSize(count);
         resize_non_trivial(count, v);
     }
 
-    void swap(FixedCapacityVector& other) noexcept {
+    void swap(FixedCapacityVector& other) {
         using std::swap;
         swap(mData, other.mData);
         swap(mSize, other.mSize);
@@ -331,16 +326,16 @@ private:
         return mCapacityAllocator.second();
     }
 
-    iterator assertCapacityForSize(size_type const s) {
+    iterator assertCapacityForSize(size_type s) {
         if constexpr(CapacityCheck || FILAMENT_FORCE_CAPACITY_CHECK) {
-            if (UTILS_VERY_UNLIKELY(capacity() < s)) {
-                capacityCheckFailed(capacity(), s);
-            }
+            FILAMENT_CHECK_PRECONDITION(capacity() >= s)
+                    << "capacity exceeded: requested size " << (unsigned long)s
+                    << "u, available capacity " << (unsigned long)capacity() << "u.";
         }
         return end();
     }
 
-    void construct(iterator const first, iterator const last) noexcept {
+    inline void construct(iterator first, iterator last) noexcept {
         // we check for triviality here so that the implementation could be non-inline
         if constexpr(!std::is_trivially_constructible_v<value_type>) {
             construct_non_trivial(first, last);
@@ -363,7 +358,7 @@ private:
     }
 
 
-    void destroy(iterator const first, iterator const last) noexcept {
+    inline void destroy(iterator first, iterator last) noexcept {
         // we check for triviality here so that the implementation could be non-inline
         if constexpr(!std::is_trivially_destructible_v<value_type>) {
             destroy_non_trivial(first, last);
@@ -424,7 +419,7 @@ private:
         explicit  SizeTypeWrapper(TYPE value) noexcept : value(value) { }
         SizeTypeWrapper& operator=(TYPE rhs) noexcept { value = rhs; return *this; }
         SizeTypeWrapper& operator=(SizeTypeWrapper& rhs) noexcept = delete;
-        operator TYPE() const noexcept { return value; } // NOLINT(*-explicit-constructor)
+        operator TYPE() const noexcept { return value; }
     };
 
     pointer mData{};

libs/utils/include/utils/Invocable.h

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 
-#ifndef TNT_UTILS_INVOCABLE_H
-#define TNT_UTILS_INVOCABLE_H
+#ifndef TNT_UTILS_INVOKABLE_H
+#define TNT_UTILS_INVOKABLE_H
+
+#include <utils/ostream.h>
 
 #include <type_traits>
 #include <utility>
@@ -23,9 +25,6 @@
 #include <assert.h>
 
 namespace utils {
-namespace io {
-class ostream;
-}
 
 /*
  * Invocable is a move-only general purpose function wrapper. Instances can
@@ -51,16 +50,11 @@ template<typename Fn, typename R, typename... Args>
 using EnableIfFnMatchesInvocable = std::enable_if_t<true, int>;
 #endif
 
-class InvocableBase {
-protected:
-    static io::ostream& printInvocable(io::ostream& out, const char* name);
-};
-
 template<typename Signature>
 class Invocable;
 
 template<typename R, typename... Args>
-class Invocable<R(Args...)> : protected InvocableBase {
+class Invocable<R(Args...)> {
 public:
     // Creates an Invocable that does not contain a functor.
     // Will evaluate to false.
@@ -91,7 +85,7 @@ public:
 private:
 #if !defined(NDEBUG)
     friend io::ostream& operator<<(io::ostream& out, const Invocable&) {
-        return printInvocable(out, "Invocable<>"); // TODO: is there a way to do better here?
+        return out << "Invocable<>"; // TODO: is there a way to do better here?
     }
 #endif
     void* mInvocable = nullptr;
@@ -162,4 +156,4 @@ Invocable<R(Args...)>::operator bool() const noexcept {
 
 } // namespace utils
 
-#endif // TNT_UTILS_INVOCABLE_H
+#endif // TNT_UTILS_INVOKABLE_H

libs/utils/include/utils/Panic.h

@@ -353,7 +353,7 @@ public:
  * The TPanic<> class implements the std::exception protocol as well as the Panic
  * interface common to all exceptions thrown by the framework.
  */
-template <typename>
+template <typename T>
 class UTILS_PUBLIC TPanic : public Panic {
 public:
     // std::exception protocol
@@ -398,11 +398,12 @@ public:
      * @see PANIC_PRECONDITION, PANIC_POSTCONDITION, PANIC_ARITHMETIC
      * @see setMode()
      */
-    static void panic(
+    static inline void panic(
             char const* function, char const* file, int line, char const* literal,
             std::string reason) UTILS_NORETURN;
 
-private:
+protected:
+
     /**
      * Creates a Panic with extra information about the error-site.
      * @param function the name of the function where the error was detected
@@ -414,14 +415,11 @@ private:
     TPanic(char const* function, char const* file, int line, char const* literal,
             std::string reason);
 
-    friend class PreconditionPanic;
-    friend class PostconditionPanic;
-    friend class ArithmeticPanic;
-
-protected:
     ~TPanic() override;
 
 private:
+    void buildMessage();
+
     char const* const mFile = nullptr;      // file where the panic happened
     char const* const mFunction = nullptr;  // function where the panic happened
     int const mLine = -1;                   // line where the panic happened
@@ -445,7 +443,7 @@ void panicLog(
  * ASSERT_PRECONDITION uses this Panic to report a precondition failure.
  * @see ASSERT_PRECONDITION
  */
-class UTILS_PUBLIC PreconditionPanic final : public TPanic<PreconditionPanic> {
+class UTILS_PUBLIC PreconditionPanic : public TPanic<PreconditionPanic> {
     // Programming error, can be avoided
     // e.g.: invalid arguments
     using TPanic<PreconditionPanic>::TPanic;
@@ -459,9 +457,9 @@ class UTILS_PUBLIC PreconditionPanic final : public TPanic<PreconditionPanic> {
  * ASSERT_POSTCONDITION uses this Panic to report a postcondition failure.
  * @see ASSERT_POSTCONDITION
  */
-class UTILS_PUBLIC PostconditionPanic final : public TPanic<PostconditionPanic> {
+class UTILS_PUBLIC PostconditionPanic : public TPanic<PostconditionPanic> {
     // Usually only detectable at runtime
-    // e.g.: deadlock would occur, arithmetic errors
+    // e.g.: dead-lock would occur, arithmetic errors
     using TPanic<PostconditionPanic>::TPanic;
     friend class TPanic<PostconditionPanic>;
     constexpr static auto type = "Postcondition";
@@ -473,7 +471,7 @@ class UTILS_PUBLIC PostconditionPanic final : public TPanic<PostconditionPanic>
  * ASSERT_ARITHMETIC uses this Panic to report an arithmetic (postcondition) failure.
  * @see ASSERT_ARITHMETIC
  */
-class UTILS_PUBLIC ArithmeticPanic final : public TPanic<ArithmeticPanic> {
+class UTILS_PUBLIC ArithmeticPanic : public TPanic<ArithmeticPanic> {
     // A common case of post-condition error
     // e.g.: underflow, overflow, internal computations errors
     using TPanic<ArithmeticPanic>::TPanic;
@@ -521,11 +519,11 @@ public:
 
     PanicStream& operator<<(const void* value) noexcept;
 
-    PanicStream& operator<<(const char* value) noexcept;
-    PanicStream& operator<<(const unsigned char* value) noexcept;
+    PanicStream& operator<<(const char* string) noexcept;
+    PanicStream& operator<<(const unsigned char* string) noexcept;
 
-    PanicStream& operator<<(std::string const& value) noexcept;
-    PanicStream& operator<<(std::string_view const& value) noexcept;
+    PanicStream& operator<<(std::string const& s) noexcept;
+    PanicStream& operator<<(std::string_view const& s) noexcept;
 
 protected:
     io::sstream mStream;

libs/utils/include/utils/StaticString.h

@@ -19,8 +19,11 @@
 
 #include <utils/compiler.h>
 
+#include <type_traits>
 #include <string_view>
 
+#include <stddef.h>
+
 namespace utils {
 
 /**
@@ -38,7 +41,7 @@ public:
     using const_iterator = std::string_view::const_iterator;
 
     // Constructor from string literal
-    template<unsigned int M>
+    template <size_t M>
     constexpr StaticString(const char (&str)[M]) noexcept : mString(str, M - 1) {} // NOLINT(*-explicit-constructor)
 
     constexpr StaticString() noexcept = default;
@@ -58,7 +61,7 @@ public:
         return mString[pos];
     }
 
-    constexpr const_reference at(size_type const pos) const {
+    constexpr const_reference at(size_type pos) const {
         return mString[pos];
     }
 

libs/utils/src/CString.cpp

@@ -20,30 +20,27 @@
 #include <utils/ostream.h>
 
 #include <algorithm>
-#include <cstdlib>
 #include <memory>
 
-
 namespace utils {
 
 UTILS_NOINLINE
-CString::CString(const char* cstr, size_t const length) {
+CString::CString(const char* cstr, size_t length) {
     if (length && cstr) {
-
-        Data* const p = static_cast<Data*>(std::malloc(sizeof(Data) + length + 1));
-        p->length = size_type(length);
-        mCStr = reinterpret_cast<value_type*>(p + 1);
+        Data* p = (Data*)malloc(sizeof(Data) + length + 1);
+        p->length = (size_type)length;
+        mCStr = (value_type*)(p + 1);
         // we don't use memcpy here to avoid a call to libc, the generated code is pretty good.
         std::uninitialized_copy_n(cstr, length, mCStr);
         mCStr[length] = '\0';
     }
 }
 
-CString::CString(size_t const length) {
+CString::CString(size_t length) {
     if (length) {
-        Data* const p = static_cast<Data*>(std::malloc(sizeof(Data) + length + 1));
-        p->length = size_type(length);
-        mCStr = reinterpret_cast<value_type*>(p + 1);
+        Data* p = (Data*)malloc(sizeof(Data) + length + 1);
+        p->length = (size_type)length;
+        mCStr = (value_type*)(p + 1);
         std::fill_n(mCStr, length, 0);
         mCStr[length] = '\0';
     }
@@ -61,30 +58,24 @@ CString& CString::operator=(const CString& rhs) {
     if (this != &rhs) {
         auto *const p = mData ? mData - 1 : nullptr;
         new(this) CString(rhs);
-        std::free(p);
+        free(p);
     }
     return *this;
 }
 
-CString::~CString() noexcept {
-    if (mData) {
-        std::free(mData - 1);
-    }
-}
-
-CString& CString::replace(size_type const pos, size_type len, char const* str, size_t const l) & noexcept {
+CString& CString::replace(size_type pos, size_type len, const CString& str) noexcept {
     assert(pos <= size());
 
     len = std::min(len, size() - pos);
 
     // The new size of the string, after the replacement.
-    const size_type newSize = size() - len + l;
+    const size_type newSize = size() - len + str.size();
 
     // Allocate enough memory to hold the new string.
-    Data* const p = static_cast<Data*>(std::malloc(sizeof(Data) + newSize + 1));
+    Data* p = (Data*) malloc(sizeof(Data) + newSize + 1);
     assert(p);
     p->length = newSize;
-    value_type* newStr = reinterpret_cast<value_type*>(p + 1);
+    value_type* newStr = (value_type*) (p + 1);
 
     const value_type* beginning = mCStr;
     const value_type* replacementStart = mCStr + pos;
@@ -93,7 +84,7 @@ CString& CString::replace(size_type const pos, size_type len, char const* str, s
 
     value_type* ptr = newStr;
     ptr = std::uninitialized_copy(beginning, replacementStart, ptr);
-    ptr = std::uninitialized_copy_n(str, l, ptr);
+    ptr = std::uninitialized_copy_n(str.c_str_safe(), str.length(), ptr);
     ptr = std::uninitialized_copy(replacementEnd, end, ptr);
 
     // null-terminator
@@ -101,14 +92,14 @@ CString& CString::replace(size_type const pos, size_type len, char const* str, s
 
     std::swap(mCStr, newStr);
     if (newStr) {
-        std::free(reinterpret_cast<Data*>(newStr) - 1);
+        free((Data*) newStr - 1);
     }
 
     return *this;
 }
 
 #if !defined(NDEBUG)
-io::ostream& operator<<(io::ostream& out, const CString& rhs) {
+io::ostream& operator<<(io::ostream& out, const utils::CString& rhs) {
     return out << rhs.c_str_safe();
 }
 #endif

libs/utils/src/FixedCapacityVectorBase.cpp

@@ -1,36 +0,0 @@
-/*
- * Copyright (C) 2025 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 <utils/FixedCapacityVector.h>
-#include <utils/compiler.h>
-#include <utils/Panic.h>
-
-#include <stddef.h>
-#include <stdlib.h>
-
-namespace utils {
-
-void FixedCapacityVectorBase::capacityCheckFailed(size_t const capacity, size_t const size) {
-    UTILS_ASSUME(capacity < size);
-    FILAMENT_CHECK_PRECONDITION(capacity >= size)
-             << "capacity exceeded: requested size " << size
-             << "u, available capacity " << capacity << "u.";
-
-    // In practice, we will never reach this.
-    abort();
-}
-
-} // namespace utils

libs/utils/src/Invocable.cpp

@@ -1,24 +0,0 @@
-/*
- * Copyright (C) 2025 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 <utils/Invocable.h>
-#include <utils/ostream.h>
-
-namespace utils {
-io::ostream& InvocableBase::printInvocable(io::ostream& out, const char* name) {
-    return out << name;
-}
-} // namespace utils

libs/utils/src/Panic.cpp

@@ -18,7 +18,6 @@
 
 #include "ostream_.h"
 
-#include <utils/CallStack.h>
 #include <utils/compiler.h>
 #include <utils/Log.h>
 #include <utils/ostream.h>
@@ -69,7 +68,7 @@ public:
         getCallback().call(panic);
     }
 
-    void set(Panic::PanicHandlerCallback const handler, void* user) noexcept {
+    void set(Panic::PanicHandlerCallback handler, void* user) noexcept {
         std::lock_guard const lock(mLock);
         mCallBack = { handler, user };
     }
@@ -97,7 +96,7 @@ static std::string sprintfToString(const char* format, va_list args) noexcept {
     return s;
 }
 
-static std::string sprintfToString(const char* format, ...) noexcept {
+static inline std::string sprintfToString(const char* format, ...) noexcept {
     va_list args;
     va_start(args, format);
     std::string const s{ sprintfToString(format, args) };
@@ -121,14 +120,14 @@ static std::string buildPanicString(
 
 Panic::~Panic() noexcept = default;
 
-void Panic::setPanicHandler(PanicHandlerCallback const handler, void* user) noexcept {
+void Panic::setPanicHandler(PanicHandlerCallback handler, void* user) noexcept {
     UserPanicHandler::get().set(handler, user);
 }
 
 // ------------------------------------------------------------------------------------------------
 
 template<typename T>
-TPanic<T>::TPanic(const char* function, const char* file, int const line, char const* literal,
+TPanic<T>::TPanic(const char* function, const char* file, int line, char const* literal,
         std::string reason)
         : mFile(file),
           mFunction(function),
@@ -189,13 +188,13 @@ void TPanic<T>::log() const noexcept {
 }
 
 UTILS_ALWAYS_INLINE
-static const char* formatFile(char const* file) noexcept {
+inline static const char* formatFile(char const* file) noexcept {
     const char * p = std::strstr(file, "filament/");
     return p ? p : file;
 }
 
 template<typename T>
-void TPanic<T>::panic(char const* function, char const* file, int const line, char const* literal,
+void TPanic<T>::panic(char const* function, char const* file, int line, char const* literal,
         const char* format, ...) {
     va_list args;
     va_start(args, format);
@@ -234,7 +233,7 @@ void TPanic<T>::panic(char const* function, char const* file, int line, char con
 
 namespace details {
 
-void panicLog(char const* function, char const* file, int const line, const char* format, ...) noexcept {
+void panicLog(char const* function, char const* file, int line, const char* format, ...) noexcept {
     va_list args;
     va_start(args, format);
     std::string const reason{ sprintfToString(format, args) };
@@ -250,79 +249,79 @@ void panicLog(char const* function, char const* file, int const line, const char
 PanicStream::PanicStream(
         char const* function,
         char const* file,
-        int const line,
+        int line,
         char const* condition) noexcept
         : mFunction(function), mFile(file), mLine(line), mLiteral(condition) {
 }
 
 PanicStream::~PanicStream() = default;
 
-PanicStream& PanicStream::operator<<(short const value) noexcept {
+PanicStream& PanicStream::operator<<(short value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(unsigned short const value) noexcept {
+PanicStream& PanicStream::operator<<(unsigned short value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(char const value) noexcept {
+PanicStream& PanicStream::operator<<(char value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(unsigned char const value) noexcept {
+PanicStream& PanicStream::operator<<(unsigned char value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(int const value) noexcept {
+PanicStream& PanicStream::operator<<(int value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(unsigned int const value) noexcept {
+PanicStream& PanicStream::operator<<(unsigned int value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(long const value) noexcept {
+PanicStream& PanicStream::operator<<(long value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(unsigned long const value) noexcept {
+PanicStream& PanicStream::operator<<(unsigned long value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(long long int const value) noexcept {
+PanicStream& PanicStream::operator<<(long long int value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(unsigned long long int const value) noexcept {
+PanicStream& PanicStream::operator<<(unsigned long long int value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(float const value) noexcept {
+PanicStream& PanicStream::operator<<(float value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(double const value) noexcept {
+PanicStream& PanicStream::operator<<(double value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(long double const value) noexcept {
+PanicStream& PanicStream::operator<<(long double value) noexcept {
     mStream << value;
     return *this;
 }
 
-PanicStream& PanicStream::operator<<(bool const value) noexcept {
+PanicStream& PanicStream::operator<<(bool value) noexcept {
     mStream << value;
     return *this;
 }

libs/utils/src/ostream_.h

@@ -18,8 +18,6 @@
 #define TNT_UTILS_OSTREAM__H
 
 #include <utils/ostream.h>
-
-#include <utility>
 #include <mutex>
 
 namespace utils::io {

libs/utils/test/test_FixedCapacityVector.cpp

@@ -17,7 +17,6 @@
 #include <gtest/gtest.h>
 
 #include <utils/FixedCapacityVector.h>
-#include <utils/Panic.h>
 
 using namespace utils;