Merge branch 'main' into ebridgewater/RequiredFeatures

.clang-format

@@ -57,7 +57,7 @@ SpaceBeforeInheritanceColon: true
 SpaceBeforeParens: ControlStatements
 SpaceBeforeRangeBasedForLoopColon: false
 SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
+SpacesBeforeTrailingComments: 0
 SpacesInAngles: false
 SpacesInCStyleCastParentheses: false
 SpacesInContainerLiterals: false

.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/get-commit-msg/action.yml

@@ -1,45 +0,0 @@
-name: 'Get commit message'
-outputs:
-  msg:
-    value: ${{ steps.action_output.outputs.msg }}
-runs:
-  using: "composite"
-  steps:
-    - name: Find commit message (on push)
-      if: github.event_name == 'push'
-      shell: bash
-      run: |
-        AUTHOR_NAME="${{ github.event.head_commit.author.name }}"
-        AUTHOR_EMAIL="${{ github.event.head_commit.author.email }}"
-        TSTAMP="${{ github.event.head_commit.timestamp }}"
-        echo "commit ${{ github.event.head_commit.id }}" >> /tmp/commit_msg.txt
-        echo "Author: ${AUTHOR_NAME}<${AUTHOR_EMAIL}>" >> /tmp/commit_msg.txt
-        echo "Date: ${TSTAMP}" >> /tmp/commit_msg.txt
-        echo "" >> /tmp/commit_msg.txt
-        echo "${{ github.event.head_commit.message }}" >> /tmp/commit_msg.txt
-    - name: Find commit message (PR)
-      shell: bash
-      id: checkout_code
-      if: github.event_name == 'pull_request'
-      run: |
-        echo "+++++ head commit message +++++"
-        echo "$(git log -1 --no-merges)"
-        echo "+++++++++++++++++++++++++++++++"
-        echo "hash=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
-        git checkout ${{ github.event.pull_request.head.sha }}
-        echo "$(git log -1 --no-merges)" >> /tmp/commit_msg.txt
-    - shell: bash
-      id: action_output
-      run: |
-        DELIMITER="EOF_FILE_CONTENT_$(date +%s)" # Using timestamp to make it more unique
-        echo "msg<<$DELIMITER" >> "$GITHUB_OUTPUT"
-        cat /tmp/commit_msg.txt >> "$GITHUB_OUTPUT"
-        echo "$DELIMITER" >> "$GITHUB_OUTPUT"
-        echo "----- got commit message ---"
-        cat /tmp/commit_msg.txt
-        echo "----------------------------"
-    - name: Cleanup Find commit message (PR)
-      shell: bash
-      if: github.event_name == 'pull_request'
-      run: |
-        git checkout ${{ steps.checkout_code.outputs.hash }}

.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/postsubmit.yml

@@ -1,35 +0,0 @@
-name: 'Post-submit tasks'
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  update-renderdiff-goldens:
-    name: update-renderdiff-goldens
-    runs-on: 'ubuntu-24.04-4core'
-    steps:
-      - uses: actions/checkout@v4.1.6
-        with:
-          fetch-depth: 0
-      - uses: ./.github/actions/linux-prereq
-      - id: get_commit_msg
-        uses: ./.github/actions/get-commit-msg
-      - name: Prerequisites
-        run: pip install tifffile numpy
-      - name: Run update script
-        env:
-          GH_TOKEN: ${{ secrets.FILAMENTBOT_TOKEN }}
-        run: |
-          GOLDEN_BRANCH=$(echo "${{ steps.get_commit_msg.outputs.msg }}" | python3 test/renderdiff/src/commit_msg.py)
-          COMMIT_HASH=$(echo "${{ steps.get_commit_msg.outputs.msg }}" | head -n 1 | tr -d 'commit ')
-          if [[ "${GOLDEN_BRANCH}" != "main" ]]; then
-              git config --global user.email "filament.bot@gmail.com"
-              git config --global user.name "Filament Bot"
-              git config --global credential.helper cache
-              echo "branch==${GOLDEN_BRANCH}"
-              echo "hash==${COMMIT_HASH}"
-              python3 test/renderdiff/src/update_golden.py --branch=${GOLDEN_BRANCH} \
-                  --merge-to-main --filament-tag=${COMMIT_HASH} --golden-repo-token=${GH_TOKEN}
-          fi

.github/workflows/presubmit.yml

@@ -3,10 +3,10 @@ name: Presubmit
 on:
   push:
     branches:
-      - main
+    - main
   pull_request:
     branches:
-      - main
+    - main
 
 jobs:
   build-desktop-mac:
@@ -41,7 +41,8 @@ jobs:
 
   build-windows:
     name: build-windows
-    runs-on: windows-2022-32core
+    runs-on: win-2019-16core
+
     steps:
       - uses: actions/checkout@v4.1.6
         with:
@@ -95,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
@@ -109,9 +109,9 @@ jobs:
           fetch-depth: 0
       - name: Check for manual edits to /docs
         run: |
-          echo "${{ github.event.pull_request.head.sha }} -- ${{ github.event.pull_request.head.sha }}"
-          # disable for now
-          # bash docs_src/build/presubmit_check.sh ${{ github.event.pull_request.head.sha }}
+           echo "${{ github.event.pull_request.head.sha }} -- ${{ github.event.pull_request.head.sha }}"
+           # disable for now
+           # bash docs_src/build/presubmit_check.sh ${{ github.event.pull_request.head.sha }}
 
   test-renderdiff:
     name: test-renderdiff
@@ -120,21 +120,18 @@ jobs:
       - uses: actions/checkout@v4.1.6
         with:
           fetch-depth: 0
-      - id: get_commit_msg
-        uses: ./.github/actions/get-commit-msg
       - uses: ./.github/actions/mac-prereq
       - name: Cache Mesa and deps
-        uses: actions/cache@v4
+        id: mesa-cache
+        uses: actions/cache@v4 # Use a specific version
         with:
           path: mesa
           key: ${{ runner.os }}-mesa-deps-2-${{ vars.MESA_VERSION }}
-      - name: Prerequisites
-        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: |
-          echo "${{ steps.get_commit_msg.outputs.msg }}" | bash test/renderdiff/test.sh
+        run: bash test/renderdiff/test.sh
       - uses: actions/upload-artifact@v4
         with:
           name: presubmit-renderdiff-result
@@ -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:
@@ -226,7 +226,7 @@ jobs:
 
   build-windows:
     name: build-windows
-    runs-on: windows-2022-32core
+    runs-on: windows-2019-32core
     if: github.event_name == 'release' || github.event.inputs.platform == 'windows'
 
     steps:

.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

.github/workflows/windows-continuous.yml

@@ -10,7 +10,7 @@ on:
 jobs:
   build-windows:
     name: build-windows
-    runs-on: windows-2022-32core
+    runs-on: windows-2019-32core
 
     steps:
       - uses: actions/checkout@v4.1.6

BUILDING.md

@@ -97,10 +97,6 @@ Make sure you've installed the following dependencies:
 - `libxcomposite-dev` (`libXcomposite-devel` on Fedora)
 - `libxxf86vm-dev` (`libXxf86vm-devel` on Fedora)
 
-```shell
-sudo apt install clang-14 libglu1-mesa-dev libc++-14-dev libc++abi-14-dev ninja-build libxi-dev libxcomposite-dev libxxf86vm-dev -y
-```
-
 After dependencies have been installed, we highly recommend using the [easy build](#easy-build)
 script.
 
@@ -367,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

CMakeLists.txt

@@ -49,12 +49,6 @@ option(FILAMENT_SUPPORTS_OSMESA "Enable OSMesa (headless GL context) for Filamen
 
 option(FILAMENT_ENABLE_FGVIEWER "Enable the frame graph viewer" OFF)
 
-option(FILAMENT_USE_ABSEIL_LOGGING "Use Abseil to log, may increase binary size" OFF)
-
-# This is to disable GTAO for the short-term while we investigate a way to better manage size increases.
-# On the regular filament build (where size is of less concern), we enable GTAO by default.
-option(FILAMENT_DISABLE_GTAO "Disable GTAO" OFF)
-
 set(FILAMENT_NDK_VERSION "" CACHE STRING
     "Android NDK version or version prefix to be used when building for Android."
 )
@@ -593,10 +587,6 @@ if (CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT FILAMENT_BACKEND_DEBUG_FLAG STREQU
     unset(FILAMENT_BACKEND_DEBUG_FLAG)
 endif()
 
-if (FILAMENT_USE_ABSEIL_LOGGING)
-    add_definitions(-DFILAMENT_USE_ABSEIL_LOGGING)
-endif()
-
 # ==================================================================================================
 # Material compilation flags
 # ==================================================================================================

NEW_RELEASE_NOTES.md

@@ -1,9 +1,11 @@
 # Filament Release Notes log
 
 **If you are merging a PR into main**: please add the release note below, under the *Release notes
-We are chaning the way Vulkan buffers are handled. We need to switch over to a managed (or view-based) model where the data stored inside the object is a proxy to a Vulkan object that can dynamically be swapped around.
+for next branch cut* header.
 
 **If you are cherry-picking a commit into an rc/ branch**: add the release note under the
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).
 
-## Release notes for next branch cut
+## 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.61.2'
+    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.61.2'
+pod 'Filament', '~> 1.59.4'
 ```
 
 ## Documentation

RELEASE_NOTES.md

@@ -7,29 +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.61.2
-
-- samples: samples now have a CLI to select backend api
-
-## v1.61.1
-
-
-## v1.61.0
-
-- materials: sampler now export their type in the material binary [⚠️ **New Material Version**]
-- samples/texturedquad.cpp now has CLI to select backend api
-- samples/hellopbr.cpp CLI now allows for selecting webgpu
-
-## 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/filament-android/CMakeLists.txt

@@ -59,10 +59,6 @@ add_library(smol-v STATIC IMPORTED)
 set_target_properties(smol-v PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libsmol-v.a)
 
-add_library(abseil STATIC IMPORTED)
-set_target_properties(abseil PROPERTIES IMPORTED_LOCATION
-        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libabseil.a)
-
 if (FILAMENT_ENABLE_FGVIEWER)
     add_library(fgviewer STATIC IMPORTED)
     set_target_properties(fgviewer PROPERTIES IMPORTED_LOCATION
@@ -132,7 +128,6 @@ target_link_libraries(filament-jni
     PRIVATE jnigraphics
     PRIVATE utils
     PRIVATE perfetto
-    PRIVATE abseil
 
     # libgeometry is PUBLIC because gltfio uses it.
     PUBLIC geometry

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

@@ -1801,22 +1801,6 @@ public class View {
      * @see setAmbientOcclusionOptions()
      */
     public static class AmbientOcclusionOptions {
-        public enum AmbientOcclusionType {
-            /**
-             * use Scalable Ambient Occlusion
-             */
-            SAO,
-            /**
-             * use Ground Truth-Based Ambient Occlusion
-             */
-            GTAO,
-        }
-
-        /**
-         * Type of ambient occlusion algorithm.
-         */
-        @NonNull
-        public AmbientOcclusionOptions.AmbientOcclusionType aoType = AmbientOcclusionOptions.AmbientOcclusionType.SAO;
         /**
          * Ambient Occlusion radius in meters, between 0 and ~10.
          */
@@ -1826,8 +1810,7 @@ public class View {
          */
         public float power = 1.0f;
         /**
-         * Self-occlusion bias in meters. Use to avoid self-occlusion.
-         * Between 0 and a few mm. No effect when aoType set to GTAO
+         * Self-occlusion bias in meters. Use to avoid self-occlusion. Between 0 and a few mm.
          */
         public float bias = 0.0005f;
         /**
@@ -1843,12 +1826,12 @@ public class View {
          */
         public float bilateralThreshold = 0.05f;
         /**
-         * affects # of samples used for AO and params for filtering
+         * affects # of samples used for AO.
          */
         @NonNull
         public QualityLevel quality = QualityLevel.LOW;
         /**
-         * affects AO smoothness. Recommend setting to HIGH when aoType set to GTAO.
+         * affects AO smoothness
          */
         @NonNull
         public QualityLevel lowPassFilter = QualityLevel.MEDIUM;
@@ -1866,7 +1849,7 @@ public class View {
          */
         public boolean bentNormals = false;
         /**
-         * min angle in radian to consider. No effect when aoType set to GTAO.
+         * min angle in radian to consider
          */
         public float minHorizonAngleRad = 0.0f;
         /**
@@ -1921,19 +1904,6 @@ public class View {
          */
         public boolean ssctEnabled = false;
 
-        /**
-         * Ground Truth-base Ambient Occlusion (GTAO) options
-         */
-        public int gtaoSampleSliceCount = 4;
-        /**
-         * Ground Truth-base Ambient Occlusion (GTAO) options
-         */
-        public int gtaoSampleStepsPerSlice = 3;
-        /**
-         * Ground Truth-base Ambient Occlusion (GTAO) options
-         */
-        public float gtaoThicknessHeuristic = 0.004f;
-
     }
 
     /**

android/gradle.properties

@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.61.2
+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 ..

build/windows/build-github.bat

@@ -47,11 +47,7 @@ if "%RUNNING_LOCALLY%" == "1" (
     set "PATH=%PATH%;C:\Program Files\7-Zip"
 )
 
-:: Outdated windows-2019 pattern
-:: call "C:\Program Files (x86)\Microsoft Visual Studio\2019\%VISUAL_STUDIO_VERSION%\VC\Auxiliary\Build\vcvars64.bat"
-
-call "C:\Program Files\Microsoft Visual Studio\2022\%VISUAL_STUDIO_VERSION%\VC\Auxiliary\Build\vcvars64.bat"
-echo Passed vcvars64.bat
+call "C:\Program Files (x86)\Microsoft Visual Studio\2019\%VISUAL_STUDIO_VERSION%\VC\Auxiliary\Build\vcvars64.bat"
 if errorlevel 1 exit /b %errorlevel%
 
 msbuild /version
@@ -111,7 +107,7 @@ cd out\cmake-%variant%
 if errorlevel 1 exit /b %errorlevel%
 
 cmake ..\.. ^
-    -G "Visual Studio 17 2022" ^
+    -G "Visual Studio 16 2019" ^
     -A x64 ^
     %flag% ^
     -DCMAKE_INSTALL_PREFIX=..\%variant% ^

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,8 +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)
-    - [Using Instruments on macOS](./notes/instruments.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".

docs_src/src/notes/instruments.md

@@ -1,36 +0,0 @@
-# Using Instruments on macOS
-
-When running a binary under Instruments on macOS, you may run into the following issue when
-launching or attaching to an executable:
-
-```
-Failed to gain authorization
-Recovery Suggestion: Target binary needs to be debuggable and signed with 'get-task-allow'
-```
-
-This is a security precaution; the solution is to code sign the binary with the
-`com.apple.security.get-task-allow` entitlement.
-
-1. Create an `entitlements.plist` file with the following contents:
-
-```
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>com.apple.security.get-task-allow</key>
-    <true/>
-</dict>
-</plist>
-```
-
-2. Run the following command:
-
-```
-codesign -s - --entitlements entitlements.plist <binary>
-```
-
-Replace `<binary>` with the name of the binary, for example: `out/cmake-debug/samples/gltf_viewer`.
-
-Afterwards, you should be able to successfully launch and attach to the executable using
-Instruments.

filament/CMakeLists.txt

@@ -265,13 +265,6 @@ set(MATERIAL_SRCS
         src/materials/vsmMipmap.mat
 )
 
-if (NOT FILAMENT_DISABLE_GTAO)
-    list(APPEND MATERIAL_SRCS
-        src/materials/ssao/gtao.mat
-        src/materials/ssao/gtaoBentNormals.mat
-    )
-endif()
-
 set(MATERIAL_FL0_SRCS
         src/materials/defaultMaterial.mat
         src/materials/skybox.mat
@@ -321,14 +314,12 @@ if (FILAMENT_FORCE_PROFILING_MODE)
     add_definitions(-DFILAMENT_FORCE_PROFILING_MODE)
 endif()
 
-if (FILAMENT_DISABLE_GTAO)
-    add_definitions(-DFILAMENT_DISABLE_GTAO)
-endif()
-
 # ==================================================================================================
 # Definitions
 # ==================================================================================================
 
+# "2" corresponds to SYSTRACE_TAG_FILEMENT (See: utils/Systrace.h)
+add_definitions(-DSYSTRACE_TAG=2)
 add_definitions(-DFILAMENT_DFG_LUT_SIZE=${DFG_LUT_SIZE})
 add_definitions(
     -DFILAMENT_PER_RENDER_PASS_ARENA_SIZE_IN_MB=${FILAMENT_PER_RENDER_PASS_ARENA_SIZE_IN_MB}
@@ -472,30 +463,6 @@ add_custom_command(
         APPEND
 )
 
-if (NOT FILAMENT_DISABLE_GTAO)
-    add_custom_command(
-            OUTPUT "${MATERIAL_DIR}/gtao.filamat"
-            DEPENDS src/materials/ssao/ssaoUtils.fs
-            DEPENDS src/materials/ssao/ssct.fs
-            DEPENDS src/materials/utils/depthUtils.fs
-            DEPENDS src/materials/utils/geometry.fs
-            DEPENDS src/materials/ssao/gtaoImpl.fs
-            DEPENDS src/materials/ssao/ssctImpl.fs
-            APPEND
-    )
-
-    add_custom_command(
-            OUTPUT "${MATERIAL_DIR}/gtaoBentNormals.filamat"
-            DEPENDS src/materials/ssao/ssaoUtils.fs
-            DEPENDS src/materials/ssao/ssct.fs
-            DEPENDS src/materials/utils/depthUtils.fs
-            DEPENDS src/materials/utils/geometry.fs
-            DEPENDS src/materials/ssao/gtaoImpl.fs
-            DEPENDS src/materials/ssao/ssctImpl.fs
-            APPEND
-    )
-endif()
-
 add_custom_command(
         OUTPUT "${MATERIAL_DIR}/bilateralBlur.filamat"
         DEPENDS src/materials/ssao/ssaoUtils.fs
@@ -601,10 +568,6 @@ target_link_libraries(${TARGET} PUBLIC filaflat)
 target_link_libraries(${TARGET} PUBLIC filabridge)
 target_link_libraries(${TARGET} PUBLIC ibl-lite)
 
-if (FILAMENT_USE_ABSEIL_LOGGING)
-    target_link_libraries(${TARGET} PUBLIC absl::log)
-endif()
-
 if (FILAMENT_ENABLE_FGVIEWER)
     target_link_libraries(${TARGET} PUBLIC fgviewer)
     add_definitions(-DFILAMENT_ENABLE_FGVIEWER=1)

filament/README.md

@@ -92,7 +92,7 @@ Copy your platform's Makefile below into a `Makefile` inside the same directory.
 ### Linux
 
 ```make
-FILAMENT_LIBS=-lfilament -lbackend -lbluegl -lbluevk -lfilabridge -lfilaflat -lutils -lgeometry -lsmol-v -lvkshaders -libl -labseil
+FILAMENT_LIBS=-lfilament -lbackend -lbluegl -lbluevk -lfilabridge -lfilaflat -lutils -lgeometry -lsmol-v -lvkshaders -libl
 CC=clang++
 
 main: main.o
@@ -110,13 +110,12 @@ clean:
 ### macOS
 
 ```make
-FILAMENT_LIBS=-lfilament -lbackend -lbluegl -lbluevk -lfilabridge -lfilaflat -lutils -lgeometry -lsmol-v -lvkshaders -libl -labseil
+FILAMENT_LIBS=-lfilament -lbackend -lbluegl -lbluevk -lfilabridge -lfilaflat -lutils -lgeometry -lsmol-v -lvkshaders -libl
 FRAMEWORKS=-framework Cocoa -framework Metal -framework CoreVideo
 CC=clang++
-ARCH ?= $(shell uname -m)
 
 main: main.o
-	$(CC) -Llib/$(ARCH)/ main.o $(FILAMENT_LIBS) $(FRAMEWORKS) -o main
+	$(CC) -Llib/x86_64/ main.o $(FILAMENT_LIBS) $(FRAMEWORKS) -o main
 
 main.o: main.cpp
 	$(CC) -Iinclude/ -std=c++17 -c main.cpp
@@ -140,7 +139,7 @@ used to change the run-time library version.
 
 ```make
 FILAMENT_LIBS=filament.lib backend.lib bluegl.lib bluevk.lib filabridge.lib filaflat.lib \
-              utils.lib geometry.lib smol-v.lib ibl.lib vkshaders.lib abseil.lib
+              utils.lib geometry.lib smol-v.lib ibl.lib vkshaders.lib
 CC=cl.exe
 
 main.exe: main.obj

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
 # ==================================================================================================
@@ -180,11 +192,8 @@ if (FILAMENT_SUPPORTS_VULKAN)
             src/vulkan/VulkanAsyncHandles.h
             src/vulkan/VulkanBlitter.cpp
             src/vulkan/VulkanBlitter.h
+            src/vulkan/VulkanBuffer.cpp
             src/vulkan/VulkanBuffer.h
-            src/vulkan/VulkanBufferCache.h
-            src/vulkan/VulkanBufferCache.cpp
-            src/vulkan/VulkanBufferProxy.h
-            src/vulkan/VulkanBufferProxy.cpp
             src/vulkan/VulkanCommands.cpp
             src/vulkan/VulkanCommands.h
             src/vulkan/VulkanConstants.h
@@ -257,35 +266,16 @@ if (FILAMENT_SUPPORTS_WEBGPU)
     list(APPEND SRCS
             include/backend/platforms/WebGPUPlatform.h
             src/webgpu/platform/WebGPUPlatform.cpp
-            src/webgpu/WebGPUBufferBase.cpp
-            src/webgpu/WebGPUBufferBase.h
-            src/webgpu/WebGPUBufferObject.cpp
-            src/webgpu/WebGPUBufferObject.h
             src/webgpu/WebGPUConstants.h
-            src/webgpu/WebGPUDescriptorSet.cpp
-            src/webgpu/WebGPUDescriptorSet.h
-            src/webgpu/WebGPUDescriptorSetLayout.cpp
-            src/webgpu/WebGPUDescriptorSetLayout.h
             src/webgpu/WebGPUDriver.cpp
             src/webgpu/WebGPUDriver.h
-            src/webgpu/WebGPUIndexBuffer.cpp
-            src/webgpu/WebGPUIndexBuffer.h
+            src/webgpu/WebGPUHandles.cpp
+            src/webgpu/WebGPUHandles.h
             src/webgpu/WebGPUPipelineCreation.cpp
             src/webgpu/WebGPUPipelineCreation.h
-            src/webgpu/WebGPUProgram.cpp
-            src/webgpu/WebGPUProgram.h
-            src/webgpu/WebGPURenderPrimitive.h
-            src/webgpu/WebGPURenderTarget.cpp
-            src/webgpu/WebGPURenderTarget.h
-            src/webgpu/WebGPUStrings.h
             src/webgpu/WebGPUSwapChain.cpp
             src/webgpu/WebGPUSwapChain.h
-            src/webgpu/WebGPUTexture.cpp
-            src/webgpu/WebGPUTexture.h
-            src/webgpu/WebGPUVertexBuffer.cpp
-            src/webgpu/WebGPUVertexBuffer.h
-            src/webgpu/WebGPUVertexBufferInfo.cpp
-            src/webgpu/WebGPUVertexBufferInfo.h
+            src/webgpu/WGPUProgram.cpp
     )
     if (WIN32)
         list(APPEND SRCS src/webgpu/platform/WebGPUPlatformWindows.cpp)
@@ -312,6 +302,12 @@ if (ANDROID)
     list(APPEND SRCS src/BackendUtilsAndroid.cpp)
 endif()
 
+# ==================================================================================================
+# Definitions
+# ==================================================================================================
+# "2" corresponds to SYSTRACE_TAG_FILEMENT (See: utils/Systrace.h)
+add_definitions(-DSYSTRACE_TAG=2 )
+
 # ==================================================================================================
 # Includes & target definition
 # ==================================================================================================
@@ -403,10 +399,6 @@ endif()
 target_link_libraries(${TARGET} PUBLIC math)
 target_link_libraries(${TARGET} PUBLIC utils)
 
-if (FILAMENT_USE_ABSEIL_LOGGING)
-    target_link_libraries(${TARGET} PRIVATE absl::log)
-endif()
-
 # Android, iOS, and WebGL do not use bluegl.
 if(FILAMENT_SUPPORTS_OPENGL AND NOT IOS AND NOT ANDROID AND NOT WEBGL)
     target_link_libraries(${TARGET} PRIVATE bluegl)
@@ -492,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)
@@ -502,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}>
@@ -571,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
@@ -609,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)
@@ -618,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,26 +25,22 @@
 #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>
 
 #include <array>
 #include <type_traits>
 #include <variant>
-#include <string_view>
 
 #include <stddef.h>
 #include <stdint.h>
 
-namespace utils::io {
-class ostream;
-} // namespace utils::io
-
 /**
  * Types and enums used by filament's driver.
  *
@@ -163,7 +159,7 @@ enum class TimerQueryResult : int8_t {
     AVAILABLE = 1,  // result is available
 };
 
-constexpr std::string_view to_string(Backend const backend) noexcept {
+static constexpr const char* backendToString(Backend backend) {
     switch (backend) {
         case Backend::NOOP:
             return "Noop";
@@ -175,10 +171,9 @@ constexpr std::string_view to_string(Backend const backend) noexcept {
             return "Metal";
         case Backend::WEBGPU:
             return "WebGPU";
-        case Backend::DEFAULT:
-            return "Default";
+        default:
+            return "Unknown";
     }
-    return "Unknown";
 }
 
 /**
@@ -195,7 +190,7 @@ enum class ShaderLanguage {
     WGSL = 5,
 };
 
-constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguage) noexcept {
+static constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguage) {
     switch (shaderLanguage) {
         case ShaderLanguage::ESSL1:
             return "ESSL 1.0";
@@ -210,7 +205,6 @@ constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguage) noex
         case ShaderLanguage::WGSL:
             return "WGSL";
     }
-    return "UNKNOWN";
 }
 
 enum class ShaderStage : uint8_t {
@@ -228,7 +222,7 @@ enum class ShaderStageFlags : uint8_t {
     ALL_SHADER_STAGE_FLAGS = VERTEX | FRAGMENT | COMPUTE
 };
 
-constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage type) noexcept {
+static inline constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage type) noexcept {
     switch (type) {
         case ShaderStage::VERTEX:
             return bool(uint8_t(flags) & uint8_t(ShaderStageFlags::VERTEX));
@@ -239,239 +233,14 @@ constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage type) noexcept
     }
 }
 
-enum class TextureType : uint8_t {
-    FLOAT,
-    INT,
-    UINT,
-    DEPTH,
-    STENCIL,
-    DEPTH_STENCIL
+enum class DescriptorType : uint8_t {
+    UNIFORM_BUFFER,
+    SHADER_STORAGE_BUFFER,
+    SAMPLER,
+    INPUT_ATTACHMENT,
+    SAMPLER_EXTERNAL
 };
 
-constexpr std::string_view to_string(TextureType type) noexcept {
-    switch (type) {
-        case TextureType::FLOAT:            return "FLOAT";
-        case TextureType::INT:              return "INT";
-        case TextureType::UINT:             return "UINT";
-        case TextureType::DEPTH:            return "DEPTH";
-        case TextureType::STENCIL:          return "STENCIL";
-        case TextureType::DEPTH_STENCIL:    return "DEPTH_STENCIL";
-    }
-    return "UNKNOWN";
-}
-
- enum class DescriptorType : uint8_t {
-     SAMPLER_2D_FLOAT,
-     SAMPLER_2D_INT,
-     SAMPLER_2D_UINT,
-     SAMPLER_2D_DEPTH,
-
-     SAMPLER_2D_ARRAY_FLOAT,
-     SAMPLER_2D_ARRAY_INT,
-     SAMPLER_2D_ARRAY_UINT,
-     SAMPLER_2D_ARRAY_DEPTH,
-
-     SAMPLER_CUBE_FLOAT,
-     SAMPLER_CUBE_INT,
-     SAMPLER_CUBE_UINT,
-     SAMPLER_CUBE_DEPTH,
-
-     SAMPLER_CUBE_ARRAY_FLOAT,
-     SAMPLER_CUBE_ARRAY_INT,
-     SAMPLER_CUBE_ARRAY_UINT,
-     SAMPLER_CUBE_ARRAY_DEPTH,
-
-     SAMPLER_3D_FLOAT,
-     SAMPLER_3D_INT,
-     SAMPLER_3D_UINT,
-
-     SAMPLER_2D_MS_FLOAT,
-     SAMPLER_2D_MS_INT,
-     SAMPLER_2D_MS_UINT,
-
-     SAMPLER_2D_MS_ARRAY_FLOAT,
-     SAMPLER_2D_MS_ARRAY_INT,
-     SAMPLER_2D_MS_ARRAY_UINT,
-
-     SAMPLER_EXTERNAL,
-     UNIFORM_BUFFER,
-     SHADER_STORAGE_BUFFER,
-     INPUT_ATTACHMENT,
- };
-
-constexpr bool isDepthDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_DEPTH:
-        case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-        case DescriptorType::SAMPLER_CUBE_DEPTH:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isFloatDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_FLOAT:
-        case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_CUBE_FLOAT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_3D_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isIntDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_INT:
-        case DescriptorType::SAMPLER_2D_ARRAY_INT:
-        case DescriptorType::SAMPLER_CUBE_INT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-        case DescriptorType::SAMPLER_3D_INT:
-        case DescriptorType::SAMPLER_2D_MS_INT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isUnsignedIntDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_UINT:
-        case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-        case DescriptorType::SAMPLER_CUBE_UINT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-        case DescriptorType::SAMPLER_3D_UINT:
-        case DescriptorType::SAMPLER_2D_MS_UINT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool is3dTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_3D_FLOAT:
-        case DescriptorType::SAMPLER_3D_INT:
-        case DescriptorType::SAMPLER_3D_UINT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool is2dTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_FLOAT:
-        case DescriptorType::SAMPLER_2D_INT:
-        case DescriptorType::SAMPLER_2D_UINT:
-        case DescriptorType::SAMPLER_2D_DEPTH:
-        case DescriptorType::SAMPLER_2D_MS_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_INT:
-        case DescriptorType::SAMPLER_2D_MS_UINT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool is2dArrayTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_2D_ARRAY_INT:
-        case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-        case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isCubeTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_CUBE_FLOAT:
-        case DescriptorType::SAMPLER_CUBE_INT:
-        case DescriptorType::SAMPLER_CUBE_UINT:
-        case DescriptorType::SAMPLER_CUBE_DEPTH:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isCubeArrayTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isMultiSampledTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_MS_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_INT:
-        case DescriptorType::SAMPLER_2D_MS_UINT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr std::string_view to_string(DescriptorType type) noexcept {
-    #define DESCRIPTOR_TYPE_CASE(TYPE)  case DescriptorType::TYPE: return #TYPE;
-    switch (type) {
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_DEPTH)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_DEPTH)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_DEPTH)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_DEPTH)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_3D_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_3D_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_3D_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_ARRAY_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_ARRAY_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_ARRAY_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_EXTERNAL)
-        DESCRIPTOR_TYPE_CASE(UNIFORM_BUFFER)
-        DESCRIPTOR_TYPE_CASE(SHADER_STORAGE_BUFFER)
-        DESCRIPTOR_TYPE_CASE(INPUT_ATTACHMENT)
-    }
-    return "UNKNOWN";
-    #undef DESCRIPTOR_TYPE_CASE
-}
-
 enum class DescriptorFlags : uint8_t {
     NONE = 0x00,
     DYNAMIC_OFFSET = 0x01
@@ -482,13 +251,6 @@ using descriptor_set_t = uint8_t;
 using descriptor_binding_t = uint8_t;
 
 struct DescriptorSetLayoutBinding {
-    static bool isSampler(DescriptorType type) noexcept {
-        return int(type) <= int(DescriptorType::SAMPLER_EXTERNAL);
-    }
-    static bool isBuffer(DescriptorType type) noexcept {
-        return type == DescriptorType::UNIFORM_BUFFER ||
-               type == DescriptorType::SHADER_STORAGE_BUFFER;
-    }
     DescriptorType type;
     ShaderStageFlags stageFlags;
     descriptor_binding_t binding;
@@ -499,7 +261,7 @@ struct DescriptorSetLayoutBinding {
     //  no uninitialized padding bytes.
     //    uint8_t externalSamplerDataIndex = EXTERNAL_SAMPLER_DATA_INDEX_UNUSED;
 
-    friend bool operator==(DescriptorSetLayoutBinding const& lhs,
+    friend inline bool operator==(DescriptorSetLayoutBinding const& lhs,
             DescriptorSetLayoutBinding const& rhs) noexcept {
         return lhs.type == rhs.type &&
                lhs.flags == rhs.flags &&
@@ -532,7 +294,7 @@ enum class TargetBufferFlags : uint32_t {
     ALL = COLOR_ALL | DEPTH | STENCIL       //!< Color, depth and stencil buffer selected.
 };
 
-constexpr TargetBufferFlags getTargetBufferFlagsAt(size_t index) noexcept {
+inline constexpr TargetBufferFlags getTargetBufferFlagsAt(size_t index) noexcept {
     if (index == 0u) return TargetBufferFlags::COLOR0;
     if (index == 1u) return TargetBufferFlags::COLOR1;
     if (index == 2u) return TargetBufferFlags::COLOR2;
@@ -689,24 +451,6 @@ enum class SamplerType : uint8_t {
     SAMPLER_CUBEMAP_ARRAY,  //!< Cube map array texture (feature level 2)
 };
 
-constexpr std::string_view to_string(SamplerType const type) noexcept {
-    switch (type) {
-        case SamplerType::SAMPLER_2D:
-            return "SAMPLER_2D";
-        case SamplerType::SAMPLER_2D_ARRAY:
-            return "SAMPLER_2D_ARRAY";
-        case SamplerType::SAMPLER_CUBEMAP:
-            return "SAMPLER_CUBEMAP";
-        case SamplerType::SAMPLER_EXTERNAL:
-            return "SAMPLER_EXTERNAL";
-        case SamplerType::SAMPLER_3D:
-            return "SAMPLER_3D";
-        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
-            return "SAMPLER_CUBEMAP_ARRAY";
-    }
-    return "Unknown";
-}
-
 //! Subpass type
 enum class SubpassType : uint8_t {
     SUBPASS_INPUT
@@ -720,20 +464,6 @@ enum class SamplerFormat : uint8_t {
     SHADOW = 3      //!< shadow sampler (PCF)
 };
 
-constexpr std::string_view to_string(SamplerFormat const format) noexcept {
-    switch (format) {
-        case SamplerFormat::INT:
-            return "INT";
-        case SamplerFormat::UINT:
-            return "UINT";
-        case SamplerFormat::FLOAT:
-            return "FLOAT";
-        case SamplerFormat::SHADOW:
-            return "SHADOW";
-    }
-    return "Unknown";
-}
-
 /**
  * Supported element types
  */
@@ -773,15 +503,6 @@ enum class BufferObjectBinding : uint8_t {
     SHADER_STORAGE
 };
 
-constexpr std::string_view to_string(BufferObjectBinding type) noexcept {
-    switch (type) {
-        case BufferObjectBinding::VERTEX:           return "VERTEX";
-        case BufferObjectBinding::UNIFORM:          return "UNIFORM";
-        case BufferObjectBinding::SHADER_STORAGE:   return "SHADER_STORAGE";
-    }
-    return "UNKNOWN";
-}
-
 //! Face culling Mode
 enum class CullingMode : uint8_t {
     NONE,               //!< No culling, front and back faces are visible
@@ -1043,8 +764,6 @@ enum class TextureFormat : uint16_t {
     SRGB_ALPHA_BPTC_UNORM,  // BC7 sRGB
 };
 
-TextureType getTextureType(TextureFormat format) noexcept;
-
 //! Bitmask describing the intended Texture Usage
 enum class TextureUsage : uint16_t {
     NONE                = 0x0000,
@@ -1072,7 +791,7 @@ enum class TextureSwizzle : uint8_t {
 };
 
 //! returns whether this format a depth format
-constexpr bool isDepthFormat(TextureFormat format) noexcept {
+static constexpr bool isDepthFormat(TextureFormat format) noexcept {
     switch (format) {
         case TextureFormat::DEPTH32F:
         case TextureFormat::DEPTH24:
@@ -1085,7 +804,7 @@ constexpr bool isDepthFormat(TextureFormat format) noexcept {
     }
 }
 
-constexpr bool isStencilFormat(TextureFormat format) noexcept {
+static constexpr bool isStencilFormat(TextureFormat format) noexcept {
     switch (format) {
         case TextureFormat::STENCIL8:
         case TextureFormat::DEPTH24_STENCIL8:
@@ -1096,7 +815,7 @@ constexpr bool isStencilFormat(TextureFormat format) noexcept {
     }
 }
 
-constexpr bool isColorFormat(TextureFormat format) noexcept {
+inline constexpr bool isColorFormat(TextureFormat format) noexcept {
     switch (format) {
         // Standard color formats
         case TextureFormat::R8:
@@ -1123,7 +842,7 @@ constexpr bool isColorFormat(TextureFormat format) noexcept {
     return false;
 }
 
-constexpr bool isUnsignedIntFormat(TextureFormat format) {
+static constexpr bool isUnsignedIntFormat(TextureFormat format) {
     switch (format) {
         case TextureFormat::R8UI:
         case TextureFormat::R16UI:
@@ -1144,7 +863,7 @@ constexpr bool isUnsignedIntFormat(TextureFormat format) {
     }
 }
 
-constexpr bool isSignedIntFormat(TextureFormat format) {
+static constexpr bool isSignedIntFormat(TextureFormat format) {
     switch (format) {
         case TextureFormat::R8I:
         case TextureFormat::R16I:
@@ -1166,35 +885,35 @@ constexpr bool isSignedIntFormat(TextureFormat format) {
 }
 
 //! returns whether this format is a compressed format
-constexpr bool isCompressedFormat(TextureFormat format) noexcept {
+static constexpr bool isCompressedFormat(TextureFormat format) noexcept {
     return format >= TextureFormat::EAC_R11;
 }
 
 //! returns whether this format is an ETC2 compressed format
-constexpr bool isETC2Compression(TextureFormat format) noexcept {
+static constexpr bool isETC2Compression(TextureFormat format) noexcept {
     return format >= TextureFormat::EAC_R11 && format <= TextureFormat::ETC2_EAC_SRGBA8;
 }
 
 //! returns whether this format is an S3TC compressed format
-constexpr bool isS3TCCompression(TextureFormat format) noexcept {
+static constexpr bool isS3TCCompression(TextureFormat format) noexcept {
     return format >= TextureFormat::DXT1_RGB && format <= TextureFormat::DXT5_SRGBA;
 }
 
-constexpr bool isS3TCSRGBCompression(TextureFormat format) noexcept {
+static constexpr bool isS3TCSRGBCompression(TextureFormat format) noexcept {
     return format >= TextureFormat::DXT1_SRGB && format <= TextureFormat::DXT5_SRGBA;
 }
 
 //! returns whether this format is an RGTC compressed format
-constexpr bool isRGTCCompression(TextureFormat format) noexcept {
+static constexpr bool isRGTCCompression(TextureFormat format) noexcept {
     return format >= TextureFormat::RED_RGTC1 && format <= TextureFormat::SIGNED_RED_GREEN_RGTC2;
 }
 
 //! returns whether this format is an BPTC compressed format
-constexpr bool isBPTCCompression(TextureFormat format) noexcept {
+static constexpr bool isBPTCCompression(TextureFormat format) noexcept {
     return format >= TextureFormat::RGB_BPTC_SIGNED_FLOAT && format <= TextureFormat::SRGB_ALPHA_BPTC_UNORM;
 }
 
-constexpr bool isASTCCompression(TextureFormat format) noexcept {
+static constexpr bool isASTCCompression(TextureFormat format) noexcept {
     return format >= TextureFormat::RGBA_ASTC_4x4 && format <= TextureFormat::SRGB8_ALPHA8_ASTC_12x12;
 }
 
@@ -1315,23 +1034,19 @@ struct SamplerParams {             // NOLINT
             assert_invariant(lhs.padding2 == 0);
             auto* pLhs = reinterpret_cast<uint32_t const*>(reinterpret_cast<char const*>(&lhs));
             auto* pRhs = reinterpret_cast<uint32_t const*>(reinterpret_cast<char const*>(&rhs));
-            return *pLhs < *pRhs;
+            return *pLhs == *pRhs;
         }
     };
 
-    bool isFiltered() const noexcept {
-        return filterMag != SamplerMagFilter::NEAREST || filterMin != SamplerMinFilter::NEAREST;
-    }
-
 private:
-    friend bool operator == (SamplerParams lhs, SamplerParams rhs) noexcept {
-        return EqualTo{}(lhs, rhs);
+    friend inline bool operator == (SamplerParams lhs, SamplerParams rhs) noexcept {
+        return SamplerParams::EqualTo{}(lhs, rhs);
     }
-    friend bool operator != (SamplerParams lhs, SamplerParams rhs) noexcept {
-        return  !EqualTo{}(lhs, rhs);
+    friend inline bool operator != (SamplerParams lhs, SamplerParams rhs) noexcept {
+        return  !SamplerParams::EqualTo{}(lhs, rhs);
     }
-    friend bool operator < (SamplerParams lhs, SamplerParams rhs) noexcept {
-        return LessThan{}(lhs, rhs);
+    friend inline bool operator < (SamplerParams lhs, SamplerParams rhs) noexcept {
+        return SamplerParams::LessThan{}(lhs, rhs);
     }
 };
 
@@ -1381,15 +1096,15 @@ struct SamplerYcbcrConversion {// NOLINT
     };
 
 private:
-    friend bool operator == (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+    friend inline bool operator == (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
             noexcept {
         return SamplerYcbcrConversion::EqualTo{}(lhs, rhs);
     }
-    friend bool operator != (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+    friend inline bool operator != (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
             noexcept {
         return  !SamplerYcbcrConversion::EqualTo{}(lhs, rhs);
     }
-    friend bool operator < (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+    friend inline bool operator < (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
             noexcept {
         return SamplerYcbcrConversion::LessThan{}(lhs, rhs);
     }

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 {
 
 /**
@@ -204,15 +201,23 @@ public:
                 }, new T(std::forward<T>(functor))
         };
     }
+
+    // --------------------------------------------------------------------------------------------
+
     /**
-     * Computes the size in bytes for a pixel of given dimensions and format
+     * Computes the size in bytes needed to fit an image of given dimensions and format
      *
      * @param format    Format of the image pixels
      * @param type      Type of the image pixels
-     * @return The size of the specified pixel in bytes
+     * @param stride    Stride of a row in pixels
+     * @param height    Height of the image in rows
+     * @param alignment Alignment in bytes of pixel rows
+     * @return The buffer size needed to fit this image in bytes
      */
+    static constexpr size_t computeDataSize(PixelDataFormat format, PixelDataType type,
+            size_t stride, size_t height, size_t alignment) noexcept {
+        assert_invariant(alignment);
 
-    static constexpr size_t computePixelSize(PixelDataFormat format, PixelDataType type) noexcept {
         if (type == PixelDataType::COMPRESSED) {
             return 0;
         }
@@ -234,7 +239,7 @@ public:
             case PixelDataFormat::RGB_INTEGER:
                 n = 3;
                 break;
-            case PixelDataFormat::UNUSED:// shouldn't happen (used to be rgbm)
+            case PixelDataFormat::UNUSED: // shouldn't happen (used to be rgbm)
             case PixelDataFormat::RGBA:
             case PixelDataFormat::RGBA_INTEGER:
                 n = 4;
@@ -243,7 +248,7 @@ public:
 
         size_t bpp = n;
         switch (type) {
-            case PixelDataType::COMPRESSED:// Impossible -- to squash the IDE warnings
+            case PixelDataType::COMPRESSED: // Impossible -- to squash the IDE warnings
             case PixelDataType::UBYTE:
             case PixelDataType::BYTE:
                 // nothing to do
@@ -274,35 +279,16 @@ public:
                 bpp = 2;
                 break;
         }
-        return bpp;
-    }
 
-    // --------------------------------------------------------------------------------------------
-
-    /**
-     * Computes the size in bytes needed to fit an image of given dimensions and format
-     *
-     * @param format    Format of the image pixels
-     * @param type      Type of the image pixels
-     * @param stride    Stride of a row in pixels
-     * @param height    Height of the image in rows
-     * @param alignment Alignment in bytes of pixel rows
-     * @return The buffer size needed to fit this image in bytes
-     */
-    static constexpr size_t computeDataSize(PixelDataFormat format, PixelDataType type,
-            size_t stride, size_t height, size_t alignment) noexcept {
-        assert_invariant(alignment);
-
-        size_t bpp = computePixelSize(format, type);
         size_t const bpr = bpp * stride;
         size_t const bprAligned = (bpr + (alignment - 1)) & (~alignment + 1);
         return bprAligned * height;
     }
 
     //! left coordinate in pixels
-    uint32_t left = 0;
+    uint32_t left   = 0;
     //! top coordinate in pixels
-    uint32_t top = 0;
+    uint32_t top    = 0;
     union {
         struct {
             //! stride in pixels

filament/backend/include/backend/Platform.h

@@ -149,13 +149,6 @@ public:
          *      - PlatformEGLAndroid
          */
         bool assertNativeWindowIsValid = false;
-
-        /**
-         * The action to take if a Drawable cannot be acquired. If true, the
-         * frame is aborted instead of panic. This is only supported for:
-         *      - PlatformMetal
-         */
-        bool metalDisablePanicOnDrawableFailure = false;
     };
 
     Platform() noexcept;

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/OpenGLPlatform.h

@@ -199,7 +199,7 @@ public:
      */
     virtual bool makeCurrent(ContextType type,
             SwapChain* UTILS_NONNULL drawSwapChain,
-            SwapChain* UTILS_NONNULL readSwapChain) = 0;
+            SwapChain* UTILS_NONNULL readSwapChain) noexcept = 0;
 
     /**
      * Called by the driver to make the OpenGL context active on the calling thread and bind
@@ -219,7 +219,7 @@ public:
             SwapChain* UTILS_NONNULL drawSwapChain,
             SwapChain* UTILS_NONNULL readSwapChain,
             utils::Invocable<void()> preContextChange,
-            utils::Invocable<void(size_t index)> postContextChange);
+            utils::Invocable<void(size_t index)> postContextChange) noexcept;
 
     /**
      * Called by the backend just before calling commit()

filament/backend/include/backend/platforms/PlatformCocoaGL.h

@@ -58,7 +58,7 @@ protected:
     SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
     SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
     void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) override;
+    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
     void commit(SwapChain* swapChain) noexcept override;
     ExternalTexture* createExternalImageTexture() noexcept override;
     void destroyExternalImageTexture(ExternalTexture* texture) noexcept override;

filament/backend/include/backend/platforms/PlatformCocoaTouchGL.h

@@ -55,7 +55,7 @@ public:
     SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
     SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
     void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) override;
+    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
     void commit(SwapChain* swapChain) noexcept override;
 
     ExternalTexture* createExternalImageTexture() noexcept override;

filament/backend/include/backend/platforms/PlatformEGL.h

@@ -109,11 +109,11 @@ protected:
 
     bool makeCurrent(ContextType type,
             SwapChain* drawSwapChain,
-            SwapChain* readSwapChain) override;
+            SwapChain* readSwapChain) noexcept override;
 
     void makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain,
             utils::Invocable<void()> preContextChange,
-            utils::Invocable<void(size_t index)> postContextChange) override;
+            utils::Invocable<void(size_t index)> postContextChange) noexcept override;
 
     void commit(SwapChain* swapChain) noexcept override;
 
@@ -128,7 +128,7 @@ protected:
     bool setExternalImage(ExternalImageHandleRef externalImage, ExternalTexture* texture) noexcept override;
 
     /**
-     * Logs glGetError() to LOG(ERROR)
+     * Logs glGetError() to slog.e
      * @param name a string giving some context on the error. Typically __func__.
      */
     static void logEglError(const char* name) noexcept;
@@ -148,12 +148,12 @@ protected:
     EGLContext getContextForType(ContextType type) const noexcept;
 
     // makes the draw and read surface current without changing the current context
-    EGLBoolean makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) {
+    EGLBoolean makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) noexcept {
         return egl.makeCurrent(drawSurface, readSurface);
     }
 
     // makes context current and set draw and read surfaces to EGL_NO_SURFACE
-    EGLBoolean makeCurrent(EGLContext context) {
+    EGLBoolean makeCurrent(EGLContext context) noexcept {
         return egl.makeCurrent(context, mEGLDummySurface, mEGLDummySurface);
     }
 
@@ -211,9 +211,9 @@ private:
     public:
         explicit EGL(EGLDisplay& dpy) : mEGLDisplay(dpy) {}
         EGLBoolean makeCurrent(EGLContext context,
-                EGLSurface drawSurface, EGLSurface readSurface);
+                EGLSurface drawSurface, EGLSurface readSurface) noexcept;
 
-        EGLBoolean makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) {
+        EGLBoolean makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) noexcept {
             return makeCurrent(mCurrentContext, drawSurface, readSurface);
         }
     } egl{ mEGLDisplay };

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

@@ -127,7 +127,7 @@ protected:
 protected:
     bool makeCurrent(ContextType type,
             SwapChain* drawSwapChain,
-            SwapChain* readSwapChain) override;
+            SwapChain* readSwapChain) noexcept override;
 
 private:
     struct InitializeJvmForPerformanceManagerIfNeeded {

filament/backend/include/backend/platforms/PlatformGLX.h

@@ -51,7 +51,7 @@ protected:
     SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
     SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
     void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) override;
+    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
     void commit(SwapChain* swapChain) noexcept override;
 
 private:

filament/backend/include/backend/platforms/PlatformMetal.h

@@ -39,40 +39,18 @@ public:
     Driver* createDriver(void* sharedContext, const Platform::DriverConfig& driverConfig) noexcept override;
     int getOSVersion() const noexcept override { return 0; }
 
-    /**
-     * Optionally initializes the Metal platform by acquiring resources necessary for rendering.
-     *
-     * This method attempts to acquire a Metal device and command queue, returning true if both are
-     * successfully obtained, or false otherwise. Typically, these objects are acquired when
-     * the Metal backend is initialized. This method allows clients to check for their availability
-     * earlier.
-     *
-     * Calling initialize() is optional and safe to do so multiple times. After initialize() returns
-     * true, subsequent calls will continue to return true but have no effect.
-     *
-     * initialize() must be called from the main thread.
-     *
-     * @returns true if the device and command queue have been successfully obtained; false
-     * otherwise.
-     */
-    bool initialize() noexcept;
-
     /**
      * Obtain the preferred Metal device object for the backend to use.
      *
      * On desktop platforms, there may be multiple GPUs suitable for rendering, and this method is
      * free to decide which one to use. On mobile systems with a single GPU, implementations should
      * simply return the result of MTLCreateSystemDefaultDevice();
-     *
-     * createDevice is called by the Metal backend from the backend thread.
      */
     virtual void createDevice(MetalDevice& outDevice) noexcept;
 
     /**
      * Create a command submission queue on the Metal device object.
      *
-     * createCommandQueue is called by the Metal backend from the backend thread.
-     *
      * @param device The device which was returned from createDevice()
      */
     virtual void createCommandQueue(
@@ -82,8 +60,6 @@ public:
      * Obtain a MTLCommandBuffer enqueued on this Platform's MTLCommandQueue. The command buffer is
      * guaranteed to execute before all subsequent command buffers created either by Filament, or
      * further calls to this method.
-     *
-     * createAndEnqueueCommandBuffer must be called from the main thread.
      */
     void createAndEnqueueCommandBuffer(MetalCommandBuffer& outCommandBuffer) noexcept;
 
@@ -92,8 +68,6 @@ public:
      *
      * Each frame rendered requires a CAMetalDrawable texture, which is presented on-screen at the
      * completion of each frame. These are limited and provided round-robin style by the system.
-     *
-     * setDrawableFailureBehavior must be called from the main thread.
      */
     enum class DrawableFailureBehavior : uint8_t {
         /**

filament/backend/include/backend/platforms/PlatformOSMesa.h

@@ -56,7 +56,7 @@ protected:
     SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
     void destroySwapChain(SwapChain* swapChain) noexcept override;
     bool makeCurrent(ContextType type, SwapChain* drawSwapChain,
-            SwapChain* readSwapChain) override;
+            SwapChain* readSwapChain) noexcept override;
     void commit(SwapChain* swapChain) noexcept override;
 
 private:

filament/backend/include/backend/platforms/PlatformWGL.h

@@ -53,7 +53,7 @@ protected:
     SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
     SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
     void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) override;
+    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
     void commit(SwapChain* swapChain) noexcept override;
 
 protected:

filament/backend/include/backend/platforms/PlatformWebGL.h

@@ -46,7 +46,7 @@ protected:
     SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
     SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
     void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) override;
+    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
     void commit(SwapChain* swapChain) noexcept override;
 };
 

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/include/backend/platforms/WebGPUPlatform.h

@@ -22,7 +22,6 @@
 #include <webgpu/webgpu_cpp.h>
 
 #include <cstdint>
-#include <vector>
 
 namespace filament::backend {
 
@@ -57,10 +56,6 @@ protected:
             const Platform::DriverConfig& driverConfig) noexcept override;
 
 private:
-    // returns adapter request option variations applicable for the particular
-    // platform
-    [[nodiscard]] static std::vector<wgpu::RequestAdapterOptions> getAdapterOptions();
-
     // we may consider having the driver own this in the future
     wgpu::Instance mInstance;
 };

filament/backend/include/private/backend/CircularBuffer.h

@@ -72,7 +72,7 @@ public:
     Range getBuffer() noexcept;
 
 private:
-    void* alloc(size_t size);
+    void* alloc(size_t size) noexcept;
     void dealloc() noexcept;
 
     // pointer to the beginning of the circular buffer (constant)

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

@@ -76,7 +76,7 @@ public:
 
     // all commands buffers (Slices) written to this point are returned by waitForCommand(). This
     // call blocks until the CircularBuffer has at least mRequiredSize bytes available.
-    void flush();
+    void flush() noexcept;
 
     // returns from waitForCommands() immediately.
     void requestExit();

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

@@ -39,7 +39,7 @@
 #define FILAMENT_DEBUG_COMMANDS_NONE         0x0
 // Command debugging enabled. No logging by default.
 #define FILAMENT_DEBUG_COMMANDS_ENABLE       0x1
-// Command debugging enabled. Every command logged to DLOG(INFO)
+// Command debugging enabled. Every command logged to slog.d
 #define FILAMENT_DEBUG_COMMANDS_LOG          0x2
 // Command debugging enabled. Every command logged to systrace
 #define FILAMENT_DEBUG_COMMANDS_SYSTRACE     0x4

filament/backend/include/private/backend/VirtualMachineEnv.h

@@ -27,13 +27,13 @@ namespace filament {
 class VirtualMachineEnv {
 public:
     // must be called before VirtualMachineEnv::get() from a thread that is attached to the JavaVM
-    static jint JNI_OnLoad(JavaVM* vm);
+    static jint JNI_OnLoad(JavaVM* vm) noexcept;
 
     // must be called on backend thread
     static VirtualMachineEnv& get() noexcept;
 
     // can be called from any thread that already has a JniEnv
-    static JNIEnv* getThreadEnvironment();
+    static JNIEnv* getThreadEnvironment() noexcept;
 
     // must be called from the backend thread
     JNIEnv* getEnvironment() noexcept {
@@ -49,7 +49,7 @@ public:
 private:
     explicit VirtualMachineEnv(JavaVM* vm) noexcept;
     ~VirtualMachineEnv() noexcept;
-    JNIEnv* getEnvironmentSlow();
+    JNIEnv* getEnvironmentSlow() noexcept;
 
     static utils::Mutex sLock;
     static JavaVM* sVirtualMachine;

filament/backend/src/BackendUtils.cpp

@@ -18,8 +18,6 @@
 
 #include "DataReshaper.h"
 
-#include <backend/DriverEnums.h>
-
 #include <utils/CString.h>
 
 #include <string_view>
@@ -225,143 +223,6 @@ size_t getFormatSize(TextureFormat format) noexcept {
     }
 }
 
-TextureType getTextureType(TextureFormat const format) noexcept {
-    switch (format) {
-        case TextureFormat::UNUSED:
-            // should not happen
-            return TextureType::FLOAT;
-
-        case TextureFormat::R8:
-        case TextureFormat::R16F:
-        case TextureFormat::RG8:
-        case TextureFormat::RGB565:
-        case TextureFormat::RGB5_A1:
-        case TextureFormat::RGBA4:
-        case TextureFormat::R32F:
-        case TextureFormat::RGB8:
-        case TextureFormat::SRGB8:
-        case TextureFormat::RG16F:
-        case TextureFormat::R11F_G11F_B10F:
-        case TextureFormat::RGB9_E5:
-        case TextureFormat::RGBA8:
-        case TextureFormat::SRGB8_A8:
-        case TextureFormat::RGB10_A2:
-        case TextureFormat::RGB16F:
-        case TextureFormat::RG32F:
-        case TextureFormat::RGBA16F:
-        case TextureFormat::RGB32F:
-        case TextureFormat::RGBA32F:
-            return TextureType::FLOAT;
-
-        case TextureFormat::R8_SNORM:
-        case TextureFormat::RG8_SNORM:
-        case TextureFormat::RGB8_SNORM:
-        case TextureFormat::RGBA8_SNORM:
-            // SNORM are treated as float
-            return TextureType::FLOAT;
-
-        case TextureFormat::R8UI:
-        case TextureFormat::R16UI:
-        case TextureFormat::RG8UI:
-        case TextureFormat::RGB8UI:
-        case TextureFormat::R32UI:
-        case TextureFormat::RG16UI:
-        case TextureFormat::RGBA8UI:
-        case TextureFormat::RGB16UI:
-        case TextureFormat::RG32UI:
-        case TextureFormat::RGBA16UI:
-        case TextureFormat::RGB32UI:
-        case TextureFormat::RGBA32UI:
-            return TextureType::UINT;
-
-        case TextureFormat::R8I:
-        case TextureFormat::R16I:
-        case TextureFormat::RG8I:
-        case TextureFormat::RGB8I:
-        case TextureFormat::R32I:
-        case TextureFormat::RG16I:
-        case TextureFormat::RGBA8I:
-        case TextureFormat::RGB16I:
-        case TextureFormat::RG32I:
-        case TextureFormat::RGBA16I:
-        case TextureFormat::RGB32I:
-        case TextureFormat::RGBA32I:
-            return TextureType::INT;
-
-        case TextureFormat::DEPTH16:
-        case TextureFormat::DEPTH24:
-        case TextureFormat::DEPTH32F:
-            return TextureType::DEPTH;
-
-        case TextureFormat::STENCIL8:
-            return TextureType::STENCIL;
-
-        case TextureFormat::DEPTH24_STENCIL8:
-        case TextureFormat::DEPTH32F_STENCIL8:
-            return TextureType::DEPTH_STENCIL;
-
-        // Compressed formats ---------------------------------------------------------------------
-
-        case TextureFormat::EAC_RG11:
-        case TextureFormat::EAC_RG11_SIGNED:
-        case TextureFormat::ETC2_EAC_RGBA8:
-        case TextureFormat::ETC2_EAC_SRGBA8:
-        case TextureFormat::EAC_R11:
-        case TextureFormat::EAC_R11_SIGNED:
-        case TextureFormat::ETC2_RGB8:
-        case TextureFormat::ETC2_SRGB8:
-        case TextureFormat::ETC2_RGB8_A1:
-        case TextureFormat::ETC2_SRGB8_A1:
-        case TextureFormat::DXT1_RGB:
-        case TextureFormat::DXT1_RGBA:
-        case TextureFormat::DXT1_SRGB:
-        case TextureFormat::DXT1_SRGBA:
-        case TextureFormat::DXT3_RGBA:
-        case TextureFormat::DXT3_SRGBA:
-        case TextureFormat::DXT5_RGBA:
-        case TextureFormat::DXT5_SRGBA:
-        case TextureFormat::RED_RGTC1:
-        case TextureFormat::SIGNED_RED_RGTC1:
-        case TextureFormat::RED_GREEN_RGTC2:
-        case TextureFormat::SIGNED_RED_GREEN_RGTC2:
-        case TextureFormat::RGB_BPTC_SIGNED_FLOAT:
-        case TextureFormat::RGB_BPTC_UNSIGNED_FLOAT:
-        case TextureFormat::RGBA_BPTC_UNORM:
-        case TextureFormat::SRGB_ALPHA_BPTC_UNORM:
-        case TextureFormat::RGBA_ASTC_4x4:
-        case TextureFormat::RGBA_ASTC_5x4:
-        case TextureFormat::RGBA_ASTC_5x5:
-        case TextureFormat::RGBA_ASTC_6x5:
-        case TextureFormat::RGBA_ASTC_6x6:
-        case TextureFormat::RGBA_ASTC_8x5:
-        case TextureFormat::RGBA_ASTC_8x6:
-        case TextureFormat::RGBA_ASTC_8x8:
-        case TextureFormat::RGBA_ASTC_10x5:
-        case TextureFormat::RGBA_ASTC_10x6:
-        case TextureFormat::RGBA_ASTC_10x8:
-        case TextureFormat::RGBA_ASTC_10x10:
-        case TextureFormat::RGBA_ASTC_12x10:
-        case TextureFormat::RGBA_ASTC_12x12:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_4x4:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_5x4:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_5x5:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_6x5:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_6x6:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_8x5:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_8x6:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_8x8:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_10x5:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_10x6:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_10x8:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_10x10:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_12x10:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_12x12:
-            return TextureType::FLOAT;
-    }
-
-    return TextureType::FLOAT;
-}
-
 size_t getFormatComponentCount(TextureFormat format) noexcept {
     switch (format) {
         case TextureFormat::R8:

filament/backend/src/CircularBuffer.cpp

@@ -16,7 +16,7 @@
 
 #include "private/backend/CircularBuffer.h"
 
-#include <utils/Logger.h>
+#include <utils/Log.h>
 #include <utils/Panic.h>
 #include <utils/architecture.h>
 #include <utils/ashmem.h>
@@ -65,7 +65,7 @@ CircularBuffer::~CircularBuffer() noexcept {
 // to each others and a special case in circularize()
 
 UTILS_NOINLINE
-void* CircularBuffer::alloc(size_t size) {
+void* CircularBuffer::alloc(size_t size) noexcept {
 #if HAS_MMAP
     void* data = nullptr;
     void* vaddr = MAP_FAILED;
@@ -127,7 +127,7 @@ void* CircularBuffer::alloc(size_t size) {
                 "couldn't allocate " << (size * 2 / 1024) <<
                 " KiB of virtual address space for the command buffer";
 
-        LOG(WARNING) << "Using 'soft' CircularBuffer (" << (size * 2 / 1024) << " KiB)";
+        slog.w << "Using 'soft' CircularBuffer (" << (size * 2 / 1024) << " KiB)" << io::endl;
 
         // guard page at the end
         void* guard = (void*)(uintptr_t(data) + size * 2);

filament/backend/src/CommandBufferQueue.cpp

@@ -18,14 +18,13 @@
 #include "private/backend/CircularBuffer.h"
 #include "private/backend/CommandStream.h"
 
-#include <private/utils/Tracing.h>
-
-#include <utils/Logger.h>
-#include <utils/Mutex.h>
-#include <utils/Panic.h>
 #include <utils/compiler.h>
-#include <utils/debug.h>
+#include <utils/Log.h>
+#include <utils/Mutex.h>
 #include <utils/ostream.h>
+#include <utils/Panic.h>
+#include <utils/Systrace.h>
+#include <utils/debug.h>
 
 #include <algorithm>
 #include <mutex>
@@ -53,18 +52,18 @@ CommandBufferQueue::~CommandBufferQueue() {
 }
 
 void CommandBufferQueue::requestExit() {
-    std::lock_guard const lock(mLock);
+    std::lock_guard<utils::Mutex> const lock(mLock);
     mExitRequested = EXIT_REQUESTED;
     mCondition.notify_one();
 }
 
 bool CommandBufferQueue::isPaused() const noexcept {
-    std::lock_guard const lock(mLock);
+    std::lock_guard<utils::Mutex> const lock(mLock);
     return mPaused;
 }
 
 void CommandBufferQueue::setPaused(bool paused) {
-    std::lock_guard const lock(mLock);
+    std::lock_guard<utils::Mutex> const lock(mLock);
     if (paused) {
         mPaused = true;
     } else {
@@ -74,13 +73,13 @@ void CommandBufferQueue::setPaused(bool paused) {
 }
 
 bool CommandBufferQueue::isExitRequested() const {
-    std::lock_guard const lock(mLock);
-    return bool(mExitRequested);
+    std::lock_guard<utils::Mutex> const lock(mLock);
+    return (bool)mExitRequested;
 }
 
 
-void CommandBufferQueue::flush() {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+void CommandBufferQueue::flush() noexcept {
+    SYSTRACE_CALL();
 
     CircularBuffer& circularBuffer = mCircularBuffer;
     if (circularBuffer.empty()) {
@@ -103,7 +102,7 @@ void CommandBufferQueue::flush() {
             static_cast<char const*>(begin), static_cast<char const*>(end));
 
 
-    std::unique_lock lock(mLock);
+    std::unique_lock<utils::Mutex> lock(mLock);
 
     // circular buffer is too small, we corrupted the stream
     FILAMENT_CHECK_POSTCONDITION(used <= mFreeSpace) <<
@@ -121,15 +120,16 @@ void CommandBufferQueue::flush() {
 
 #ifndef NDEBUG
         size_t const totalUsed = circularBuffer.size() - mFreeSpace;
-        DLOG(INFO) << "CommandStream used too much space (will block): "
-                   << "needed space " << requiredSize << " out of " << mFreeSpace
-                   << ", totalUsed=" << totalUsed << ", current=" << used
-                   << ", queue size=" << mCommandBuffersToExecute.size() << " buffers";
+        slog.d << "CommandStream used too much space (will block): "
+                << "needed space " << requiredSize << " out of " << mFreeSpace
+                << ", totalUsed=" << totalUsed << ", current=" << used
+                << ", queue size=" << mCommandBuffersToExecute.size() << " buffers"
+                << io::endl;
 
         mHighWatermark = std::max(mHighWatermark, totalUsed);
 #endif
 
-        FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "waiting: CircularBuffer::flush()");
+        SYSTRACE_NAME("waiting: CircularBuffer::flush()");
 
         FILAMENT_CHECK_POSTCONDITION(!mPaused) <<
                 "CommandStream is full, but since the rendering thread is paused, "
@@ -146,7 +146,7 @@ std::vector<CommandBufferQueue::Range> CommandBufferQueue::waitForCommands() con
     if (!UTILS_HAS_THREADING) {
         return std::move(mCommandBuffersToExecute);
     }
-    std::unique_lock lock(mLock);
+    std::unique_lock<utils::Mutex> lock(mLock);
     while ((mCommandBuffersToExecute.empty() || mPaused) && !mExitRequested) {
         mCondition.wait(lock);
     }
@@ -156,7 +156,7 @@ std::vector<CommandBufferQueue::Range> CommandBufferQueue::waitForCommands() con
 void CommandBufferQueue::releaseBuffer(CommandBufferQueue::Range const& buffer) {
     size_t const used = std::distance(
             static_cast<char const*>(buffer.begin), static_cast<char const*>(buffer.end));
-    std::lock_guard const lock(mLock);
+    std::lock_guard<utils::Mutex> const lock(mLock);
     mFreeSpace += used;
     mCondition.notify_one();
 }

filament/backend/src/CommandStream.cpp

@@ -16,19 +16,15 @@
 
 #include "private/backend/CommandStream.h"
 
-#include <private/utils/Tracing.h>
-
 #if DEBUG_COMMAND_STREAM
 #include <utils/CallStack.h>
 #endif
 
-#include <private/utils/Tracing.h>
-
-#include <utils/Logger.h>
-#include <utils/Profiler.h>
 #include <utils/compiler.h>
+#include <utils/Log.h>
 #include <utils/ostream.h>
-#include <utils/sstream.h>
+#include <utils/Profiler.h>
+#include <utils/Systrace.h>
 
 #include <cstddef>
 #include <functional>
@@ -83,13 +79,12 @@ CommandStream::CommandStream(Driver& driver, CircularBuffer& buffer) noexcept
 }
 
 void CommandStream::execute(void* buffer) {
-    // NOTE: we can't use FILAMENT_TRACING_CALL() or similar here because, execute() below, also
+    // NOTE: we can't use SYSTRACE_CALL() or similar here because, execute() below, also
     // uses systrace BEGIN/END and the END is not guaranteed to be happening in this scope.
 
     Profiler profiler;
 
-
-    if constexpr (FILAMENT_TRACING_ENABLED) {
+    if (SYSTRACE_TAG) {
         if (UTILS_UNLIKELY(mUsePerformanceCounter)) {
             // we want to remove all this when tracing is completely disabled
             profiler.resetEvents(Profiler::EV_CPU_CYCLES  | Profiler::EV_BPU_MISSES);
@@ -105,17 +100,17 @@ void CommandStream::execute(void* buffer) {
         }
     });
 
-    if constexpr (FILAMENT_TRACING_ENABLED) {
+    if (SYSTRACE_TAG) {
         if (UTILS_UNLIKELY(mUsePerformanceCounter)) {
             // we want to remove all this when tracing is completely disabled
             profiler.stop();
             UTILS_UNUSED Profiler::Counters const counters = profiler.readCounters();
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (I)", counters.getInstructions());
-            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (C)", counters.getCpuCycles());
-            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (CPI x10)", counters.getCPI() * 10);
-            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (BPU miss)", counters.getBranchMisses());
-            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (I / BPU miss)",
+            SYSTRACE_CONTEXT();
+            SYSTRACE_VALUE32("GLThread (I)", counters.getInstructions());
+            SYSTRACE_VALUE32("GLThread (C)", counters.getCpuCycles());
+            SYSTRACE_VALUE32("GLThread (CPI x10)", counters.getCPI() * 10);
+            SYSTRACE_VALUE32("GLThread (BPU miss)", counters.getBranchMisses());
+            SYSTRACE_VALUE32("GLThread (I / BPU miss)",
                     counters.getInstructions() / counters.getBranchMisses());
         }
     }
@@ -132,10 +127,9 @@ void CommandType<void (Driver::*)(ARGS...)>::Command<METHOD>::log(std::index_seq
 #if DEBUG_COMMAND_STREAM
     static_assert(UTILS_HAS_RTTI, "DEBUG_COMMAND_STREAM can only be used with RTTI");
     std::string command = utils::CallStack::demangleTypeName(typeid(Command).name()).c_str();
-    DLOG(INFO) << extractMethodName(command) << " : size=" << sizeof(Command);
-    utils::io::sstream parameterPack;
-    printParameterPack(parameterPack, std::get<I>(mArgs)...);
-    DLOG(INFO) << "\t" << parameterPack.c_str();
+    slog.d << extractMethodName(command) << " : size=" << sizeof(Command) << "\n\t";
+    printParameterPack(slog.d, std::get<I>(mArgs)...);
+    slog.d << io::endl;
 #endif
 }
 

filament/backend/src/CommandStreamDispatcher.h

@@ -20,9 +20,8 @@
 #include "private/backend/Driver.h"
 #include "private/backend/CommandStream.h"
 
-#include <private/utils/Tracing.h>
-
 #include <utils/compiler.h>
+#include <utils/Systrace.h>
 
 #include <utility>
 
@@ -39,7 +38,7 @@
 #if DEBUG_LEVEL == DEBUG_LEVEL_NONE
 #   define SYSTRACE()
 #elif DEBUG_LEVEL == DEBUG_LEVEL_SYSTRACE
-#   define SYSTRACE() FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+#   define SYSTRACE() SYSTRACE_CALL();
 #else
 #   error "invalid debug level"
 #endif

filament/backend/src/CompilerThreadPool.cpp

@@ -16,7 +16,7 @@
 
 #include "CompilerThreadPool.h"
 
-#include <private/utils/Tracing.h>
+#include <utils/Systrace.h>
 
 #include <memory>
 
@@ -41,7 +41,7 @@ void CompilerThreadPool::init(uint32_t threadCount,
 
     for (size_t i = 0; i < threadCount; i++) {
         mCompilerThreads.emplace_back([this, setup, cleanup]() {
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+            SYSTRACE_CONTEXT();
 
             (*setup)();
 
@@ -54,7 +54,7 @@ void CompilerThreadPool::init(uint32_t threadCount,
                                     [](auto&& q) { return q.empty(); }));
                 });
 
-                FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "CompilerThreadPool Jobs",
+                SYSTRACE_VALUE32("CompilerThreadPool Jobs",
                         mQueues[0].size() + mQueues[1].size());
 
                 if (UTILS_LIKELY(!mExitRequested)) {

filament/backend/src/Driver.cpp

@@ -23,12 +23,11 @@
 #include <backend/BufferDescriptor.h>
 #include <backend/DriverEnums.h>
 
-#include <private/utils/Tracing.h>
-
-#include <utils/Logger.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
+#include <utils/Log.h>
 #include <utils/ostream.h>
+#include <utils/Systrace.h>
 
 #include <math/half.h>
 #include <math/vec2.h>
@@ -149,34 +148,33 @@ void DriverBase::scheduleRelease(AcquiredImage const& image) noexcept {
 void DriverBase::debugCommandBegin(CommandStream* cmds, bool synchronous, const char* methodName) noexcept {
     if constexpr (bool(FILAMENT_DEBUG_COMMANDS > FILAMENT_DEBUG_COMMANDS_NONE)) {
         if constexpr (bool(FILAMENT_DEBUG_COMMANDS & FILAMENT_DEBUG_COMMANDS_LOG)) {
-            DLOG(INFO) << methodName;
+            utils::slog.d << methodName << utils::io::endl;
         }
         if constexpr (bool(FILAMENT_DEBUG_COMMANDS & FILAMENT_DEBUG_COMMANDS_SYSTRACE)) {
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-            FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, methodName);
+            SYSTRACE_CONTEXT();
+            SYSTRACE_NAME_BEGIN(methodName);
 
             if (!synchronous) {
                 cmds->queueCommand([=]() {
-                    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-                    FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, methodName);
+                    SYSTRACE_CONTEXT();
+                    SYSTRACE_NAME_BEGIN(methodName);
                 });
             }
         }
     }
 }
 
-void DriverBase::debugCommandEnd(CommandStream* cmds, bool synchronous,
-        const char* methodName) noexcept {
+void DriverBase::debugCommandEnd(CommandStream* cmds, bool synchronous, const char* methodName) noexcept {
     if constexpr (bool(FILAMENT_DEBUG_COMMANDS > FILAMENT_DEBUG_COMMANDS_NONE)) {
         if constexpr (bool(FILAMENT_DEBUG_COMMANDS & FILAMENT_DEBUG_COMMANDS_SYSTRACE)) {
             if (!synchronous) {
                 cmds->queueCommand([]() {
-                    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-                    FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
+                    SYSTRACE_CONTEXT();
+                    SYSTRACE_NAME_END();
                 });
             }
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-            FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
+            SYSTRACE_CONTEXT();
+            SYSTRACE_NAME_END();
         }
     }
 }

filament/backend/src/HandleAllocator.cpp

@@ -20,7 +20,7 @@
 
 #include <utils/Allocator.h>
 #include <utils/CString.h>
-#include <utils/Logger.h>
+#include <utils/Log.h>
 #include <utils/Panic.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
@@ -57,8 +57,8 @@ HandleAllocator<P0, P1, P2>::Allocator::Allocator(AreaPolicy::HeapArea const& ar
     size_t const maxHeapSize = std::min(area.size(), HANDLE_INDEX_MASK * getAlignment());
 
     if (UTILS_UNLIKELY(maxHeapSize != area.size())) {
-        LOG(WARNING) << "HandleAllocator heap size reduced to " << maxHeapSize << " from "
-                     << area.size();
+        slog.w << "HandleAllocator heap size reduced to "
+               << maxHeapSize << " from " << area.size() << io::endl;
     }
 
     // make sure we start with a clean arena. This is needed to ensure that all blocks start

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/PlatformFactory.cpp

@@ -16,8 +16,7 @@
 
 #include <private/backend/PlatformFactory.h>
 
-#include <private/utils/Tracing.h>
-
+#include <utils/Systrace.h>
 #include <utils/debug.h>
 
 // We need to keep this up top for the linux (X11) name collisions.
@@ -86,7 +85,7 @@ namespace filament::backend {
 // responsible for destroying it. Initialization of the backend API is deferred until
 // createDriver(). The passed-in backend hint is replaced with the resolved backend.
 Platform* PlatformFactory::create(Backend* backend) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
     assert_invariant(backend);
 
 #if defined(__ANDROID__)

filament/backend/src/SystraceProfile.h

@@ -17,7 +17,7 @@
 #ifndef TNT_FILAMENT_BACKEND_SYSTRACEPROFILE_H
 #define TNT_FILAMENT_BACKEND_SYSTRACEPROFILE_H
 
-#include <private/utils/Tracing.h>
+#include <utils/Systrace.h>
 
 #define PROFILE_SCOPE(marker)       SYSTRACE_NAME(marker)
 

filament/backend/src/VirtualMachineEnv.cpp

@@ -50,7 +50,7 @@ JavaVM* VirtualMachineEnv::getVirtualMachine() {
  */
 UTILS_PUBLIC
 UTILS_NOINLINE
-jint VirtualMachineEnv::JNI_OnLoad(JavaVM* vm) {
+jint VirtualMachineEnv::JNI_OnLoad(JavaVM* vm) noexcept {
     std::lock_guard const lock(sLock);
     if (sVirtualMachine) {
         // It doesn't make sense for JNI_OnLoad() to be called more than once
@@ -77,7 +77,7 @@ VirtualMachineEnv& VirtualMachineEnv::get() noexcept {
 }
 
 UTILS_NOINLINE
-JNIEnv* VirtualMachineEnv::getThreadEnvironment() {
+JNIEnv* VirtualMachineEnv::getThreadEnvironment() noexcept {
     JavaVM* const vm = getVirtualMachine();
     JNIEnv* env = nullptr;
     jint const result = vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);
@@ -101,7 +101,7 @@ VirtualMachineEnv::~VirtualMachineEnv() noexcept {
 }
 
 UTILS_NOINLINE
-JNIEnv* VirtualMachineEnv::getEnvironmentSlow() {
+JNIEnv* VirtualMachineEnv::getEnvironmentSlow() noexcept {
     FILAMENT_CHECK_PRECONDITION(mVirtualMachine)
             << "JNI_OnLoad() has not been called";
 

filament/backend/src/metal/MetalBlitter.mm

@@ -19,8 +19,8 @@
 #include "MetalContext.h"
 #include "MetalUtils.h"
 
-#include <utils/Logger.h>
 #include <utils/Panic.h>
+#include <utils/Log.h>
 
 namespace filament::backend {
 
@@ -323,7 +323,7 @@ id<MTLFunction> MetalBlitter::compileFragmentFunction(BlitFunctionKey key) const
     if (!library || !function) {
         if (error) {
             auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
-            LOG(ERROR) << description;
+            utils::slog.e << description << utils::io::endl;
         }
     }
     FILAMENT_CHECK_POSTCONDITION(library && function)
@@ -349,7 +349,7 @@ id<MTLFunction> MetalBlitter::getBlitVertexFunction() {
     if (!library || !function) {
         if (error) {
             auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
-            LOG(ERROR) << description;
+            utils::slog.e << description << utils::io::endl;
         }
     }
     FILAMENT_CHECK_POSTCONDITION(library && function)

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/MetalBufferPool.mm

@@ -18,8 +18,8 @@
 
 #include "MetalContext.h"
 
-#include <utils/Logger.h>
 #include <utils/Panic.h>
+#include <utils/Log.h>
 #include <utils/trap.h>
 
 #include <thread>
@@ -77,7 +77,8 @@ void MetalBufferPool::releaseBuffer(MetalBufferPoolEntry const *stage) noexcept
 
     auto iter = mUsedStages.find(stage);
     if (iter == mUsedStages.end()) {
-        LOG(ERROR) << "Unknown Metal buffer: " << stage->capacity << " bytes";
+        utils::slog.e << "Unknown Metal buffer: " << stage->capacity << " bytes"
+                << utils::io::endl;
         return;
     }
     stage->lastAccessed = mCurrentFrame;

filament/backend/src/metal/MetalContext.mm

@@ -18,9 +18,8 @@
 
 #include "MetalHandles.h"
 
-#include <utils/FixedCapacityVector.h>
-#include <utils/Logger.h>
 #include <utils/debug.h>
+#include <utils/FixedCapacityVector.h>
 
 #include <utility>
 
@@ -113,8 +112,8 @@ id<MTLCommandBuffer> getPendingCommandBuffer(MetalContext* context) {
         auto errorCode = (MTLCommandBufferError)buffer.error.code;
         if (@available(macOS 11.0, *)) {
             if (errorCode == MTLCommandBufferErrorMemoryless) {
-                LOG(WARNING) << "Metal: memoryless geometry limit reached. Continuing with private "
-                                "storage mode.";
+                utils::slog.w << "Metal: memoryless geometry limit reached. "
+                        "Continuing with private storage mode." << utils::io::endl;
                 context->memorylessLimitsReached = true;
             }
         }

filament/backend/src/metal/MetalDriver.mm

@@ -38,10 +38,10 @@
 #include <Metal/Metal.h>
 #include <QuartzCore/QuartzCore.h>
 
-#include <utils/Invocable.h>
-#include <utils/Logger.h>
+#include <utils/Log.h>
 #include <utils/Panic.h>
 #include <utils/sstream.h>
+#include <utils/Invocable.h>
 
 #include <algorithm>
 
@@ -78,18 +78,20 @@ Driver* MetalDriverFactory::create(PlatformMetal* const platform, const Platform
     //    MetalVertexBufferInfo        : 552       moderate
     // -- less than or equal to 552 bytes
 
-    DLOG(INFO) << "MetalSwapChain: " << sizeof(MetalSwapChain);
-    DLOG(INFO) << "MetalBufferObject: " << sizeof(MetalBufferObject);
-    DLOG(INFO) << "MetalVertexBuffer: " << sizeof(MetalVertexBuffer);
-    DLOG(INFO) << "MetalVertexBufferInfo: " << sizeof(MetalVertexBufferInfo);
-    DLOG(INFO) << "MetalIndexBuffer: " << sizeof(MetalIndexBuffer);
-    DLOG(INFO) << "MetalRenderPrimitive: " << sizeof(MetalRenderPrimitive);
-    DLOG(INFO) << "MetalTexture: " << sizeof(MetalTexture);
-    DLOG(INFO) << "MetalTimerQuery: " << sizeof(MetalTimerQuery);
-    DLOG(INFO) << "HwStream: " << sizeof(HwStream);
-    DLOG(INFO) << "MetalRenderTarget: " << sizeof(MetalRenderTarget);
-    DLOG(INFO) << "MetalFence: " << sizeof(MetalFence);
-    DLOG(INFO) << "MetalProgram: " << sizeof(MetalProgram);
+    utils::slog.d
+           << "\nMetalSwapChain: " << sizeof(MetalSwapChain)
+           << "\nMetalBufferObject: " << sizeof(MetalBufferObject)
+           << "\nMetalVertexBuffer: " << sizeof(MetalVertexBuffer)
+           << "\nMetalVertexBufferInfo: " << sizeof(MetalVertexBufferInfo)
+           << "\nMetalIndexBuffer: " << sizeof(MetalIndexBuffer)
+           << "\nMetalRenderPrimitive: " << sizeof(MetalRenderPrimitive)
+           << "\nMetalTexture: " << sizeof(MetalTexture)
+           << "\nMetalTimerQuery: " << sizeof(MetalTimerQuery)
+           << "\nHwStream: " << sizeof(HwStream)
+           << "\nMetalRenderTarget: " << sizeof(MetalRenderTarget)
+           << "\nMetalFence: " << sizeof(MetalFence)
+           << "\nMetalProgram: " << sizeof(MetalProgram)
+           << utils::io::endl;
 #endif
     return MetalDriver::create(platform, driverConfig);
 }
@@ -133,18 +135,19 @@ MetalDriver::MetalDriver(
 
     initializeSupportedGpuFamilies(mContext);
 
-    LOG(INFO) << "Supported GPU families: ";
+    utils::slog.v << "Supported GPU families: " << utils::io::endl;
     if (mContext->highestSupportedGpuFamily.common > 0) {
-        LOG(INFO) << "  MTLGPUFamilyCommon" << (int) mContext->highestSupportedGpuFamily.common;
+        utils::slog.v << "  MTLGPUFamilyCommon" << (int) mContext->highestSupportedGpuFamily.common << utils::io::endl;
     }
     if (mContext->highestSupportedGpuFamily.apple > 0) {
-        LOG(INFO) << "  MTLGPUFamilyApple" << (int) mContext->highestSupportedGpuFamily.apple;
+        utils::slog.v << "  MTLGPUFamilyApple" << (int) mContext->highestSupportedGpuFamily.apple << utils::io::endl;
     }
     if (mContext->highestSupportedGpuFamily.mac > 0) {
-        LOG(INFO) << "  MTLGPUFamilyMac" << (int) mContext->highestSupportedGpuFamily.mac;
+        utils::slog.v << "  MTLGPUFamilyMac" << (int) mContext->highestSupportedGpuFamily.mac << utils::io::endl;
     }
-    LOG(INFO) << "Features:";
-    LOG(INFO) << "  readWriteTextureSupport: " << (bool) mContext->device.readWriteTextureSupport;
+    utils::slog.v << "Features:" << utils::io::endl;
+    utils::slog.v << "  readWriteTextureSupport: " <<
+            (bool) mContext->device.readWriteTextureSupport << utils::io::endl;
 
     // In order to support texture swizzling, the GPU needs to support it and the system be running
     // iOS 13+.
@@ -585,7 +588,7 @@ void MetalDriver::createProgramR(Handle<HwProgram> rph, Program&& program) {
 #if FILAMENT_METAL_DEBUG_LOG
     auto handleId = rph.getId();
     DEBUG_LOG("createProgramR(rph = %d, program = ", handleId);
-    DLOG(INFO) << program;
+    utils::slog.d << program << utils::io::endl;
 #endif
     construct_handle<MetalProgram>(rph, *mContext, std::move(program));
 }
@@ -669,8 +672,22 @@ void MetalDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {
     // nothing to do, timer query was constructed in createTimerQueryS
 }
 
-UTILS_UNUSED
-static const char* toString(ShaderStageFlags flags) {
+const char* toString(DescriptorType type) {
+    switch (type) {
+        case DescriptorType::UNIFORM_BUFFER:
+            return "UNIFORM_BUFFER";
+        case DescriptorType::SHADER_STORAGE_BUFFER:
+            return "SHADER_STORAGE_BUFFER";
+        case DescriptorType::SAMPLER:
+            return "SAMPLER";
+        case DescriptorType::INPUT_ATTACHMENT:
+            return "INPUT_ATTACHMENT";
+        case DescriptorType::SAMPLER_EXTERNAL:
+            return "SAMPLER_EXTERNAL";
+    }
+}
+
+const char* toString(ShaderStageFlags flags) {
     std::vector<const char*> stages;
     if (any(flags & ShaderStageFlags::VERTEX)) {
         stages.push_back("VERTEX");
@@ -704,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));
 }
 
@@ -2074,7 +2081,7 @@ void MetalDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGro
                                                             error:&error];
     if (error) {
         auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
-        LOG(ERROR) << description;
+        utils::slog.e << description << utils::io::endl;
     }
     assert_invariant(!error);
 

filament/backend/src/metal/MetalExternalImage.mm

@@ -20,14 +20,14 @@
 #include "MetalEnums.h"
 #include "MetalUtils.h"
 
-#include <utils/Logger.h>
 #include <utils/Panic.h>
+#include <utils/Log.h>
 #include <utils/trap.h>
 
 #define NSERROR_CHECK(message)                                                                     \
     if (error) {                                                                                   \
         auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding]; \
-        LOG(ERROR) << description;                                                                 \
+        utils::slog.e << description << utils::io::endl;                                           \
     }                                                                                              \
     FILAMENT_CHECK_POSTCONDITION(error == nil) << message;
 

filament/backend/src/metal/MetalHandles.mm

@@ -27,11 +27,10 @@
 
 #include "private/backend/BackendUtils.h"
 
-#include <utils/Logger.h>
-#include <utils/Panic.h>
 #include <utils/compiler.h>
-#include <utils/debug.h>
+#include <utils/Panic.h>
 #include <utils/trap.h>
+#include <utils/debug.h>
 
 #include <math/scalar.h>
 
@@ -116,14 +115,14 @@ MetalSwapChain::MetalSwapChain(
       type(SwapChainType::CAMETALLAYER) {
 
     if (!(flags & SwapChain::CONFIG_TRANSPARENT) && !nativeWindow.opaque) {
-        LOG(WARNING) << "Warning: Filament SwapChain has no CONFIG_TRANSPARENT flag, but the "
-                        "CAMetaLayer("
-                     << (__bridge void*) nativeWindow << ") has .opaque set to NO.";
+        utils::slog.w << "Warning: Filament SwapChain has no CONFIG_TRANSPARENT flag, "
+                         "but the CAMetaLayer(" << (__bridge void*) nativeWindow << ")"
+                         " has .opaque set to NO." << utils::io::endl;
     }
     if ((flags & SwapChain::CONFIG_TRANSPARENT) && nativeWindow.opaque) {
-        LOG(WARNING) << "Warning: Filament SwapChain has the CONFIG_TRANSPARENT flag, but the "
-                        "CAMetaLayer("
-                     << (__bridge void*) nativeWindow << ") has .opaque set to YES.";
+        utils::slog.w << "Warning: Filament SwapChain has the CONFIG_TRANSPARENT flag, "
+                         "but the CAMetaLayer(" << (__bridge void*) nativeWindow << ")"
+                         " has .opaque set to YES." << utils::io::endl;
     }
 
     // Needed so we can use the SwapChain as a blit source.
@@ -1357,31 +1356,7 @@ id<MTLArgumentEncoder> MetalDescriptorSetLayout::getArgumentEncoderSlow(id<MTLDe
                 [arguments addObject:bufferArgument];
                 break;
             }
-            case DescriptorType::SAMPLER_2D_FLOAT:
-            case DescriptorType::SAMPLER_2D_INT:
-            case DescriptorType::SAMPLER_2D_UINT:
-            case DescriptorType::SAMPLER_2D_DEPTH:
-            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_INT:
-            case DescriptorType::SAMPLER_CUBE_UINT:
-            case DescriptorType::SAMPLER_CUBE_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_3D_FLOAT:
-            case DescriptorType::SAMPLER_3D_INT:
-            case DescriptorType::SAMPLER_3D_UINT:
-            case DescriptorType::SAMPLER_2D_MS_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_INT:
-            case DescriptorType::SAMPLER_2D_MS_UINT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
+            case DescriptorType::SAMPLER:
             case DescriptorType::SAMPLER_EXTERNAL: {
                 MTLArgumentDescriptor* textureArgument = [MTLArgumentDescriptor argumentDescriptor];
                 textureArgument.index = binding.binding * 2;
@@ -1407,9 +1382,6 @@ id<MTLArgumentEncoder> MetalDescriptorSetLayout::getArgumentEncoderSlow(id<MTLDe
                 break;
         }
     }
-    if (arguments.count == 0) {
-        return nil;
-    }
     return [device newArgumentEncoderWithArguments:arguments];
 }
 
@@ -1470,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");
@@ -1503,31 +1472,7 @@ id<MTLBuffer> MetalDescriptorSet::finalizeAndGetBuffer(MetalDriver* driver, Shad
                            atIndex:binding.binding * 2];
                 break;
             }
-            case DescriptorType::SAMPLER_2D_FLOAT:
-            case DescriptorType::SAMPLER_2D_INT:
-            case DescriptorType::SAMPLER_2D_UINT:
-            case DescriptorType::SAMPLER_2D_DEPTH:
-            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_INT:
-            case DescriptorType::SAMPLER_CUBE_UINT:
-            case DescriptorType::SAMPLER_CUBE_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_3D_FLOAT:
-            case DescriptorType::SAMPLER_3D_INT:
-            case DescriptorType::SAMPLER_3D_UINT:
-            case DescriptorType::SAMPLER_2D_MS_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_INT:
-            case DescriptorType::SAMPLER_2D_MS_UINT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
+            case DescriptorType::SAMPLER:
             case DescriptorType::SAMPLER_EXTERNAL: {
                 auto found = textures.find(binding.binding);
                 if (found == textures.end()) {

filament/backend/src/metal/MetalShaderCompiler.mm

@@ -21,7 +21,6 @@
 #include <backend/Program.h>
 
 #include <utils/JobSystem.h>
-#include <utils/Logger.h>
 #include <utils/Mutex.h>
 
 #include <chrono>
@@ -148,7 +147,7 @@ bool MetalShaderCompiler::isParallelShaderCompileSupported() const noexcept {
             if (error) {
                 auto description =
                         [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
-                LOG(WARNING) << description;
+                utils::slog.w << description << utils::io::endl;
                 errorMessage = error.localizedDescription;
             }
             PANIC_LOG("Failed to compile Metal program.");
@@ -179,7 +178,7 @@ bool MetalShaderCompiler::isParallelShaderCompileSupported() const noexcept {
             if (error) {
                 auto description =
                         [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
-                LOG(WARNING) << description;
+                utils::slog.w << description << utils::io::endl;
                 errorMessage = error.localizedDescription;
             }
             PANIC_LOG("Failed to load main0 in Metal program.");

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/metal/MetalState.mm

@@ -18,7 +18,7 @@
 
 #include "MetalEnums.h"
 
-#include <utils/Logger.h>
+#include <utils/Log.h>
 
 namespace filament {
 namespace backend {
@@ -95,7 +95,7 @@ id<MTLRenderPipelineState> PipelineStateCreator::operator()(id<MTLDevice> device
             [NSString stringWithFormat:@"Could not create Metal pipeline state: %@",
                 error ? error.localizedDescription : @"unknown error"];
         auto description = [errorMessage cStringUsingEncoding:NSUTF8StringEncoding];
-        LOG(ERROR) << description;
+        utils::slog.e << description << utils::io::endl;
         [[NSException exceptionWithName:@"MetalRenderPipelineFailure"
                                  reason:errorMessage
                                userInfo:nil] raise];
@@ -155,7 +155,7 @@ id<MTLSamplerState> SamplerStateCreator::operator()(id<MTLDevice> device,
     // MTLSamplerDescriptor.
     // In practice, this means shadows are not supported when running in the simulator.
     if (![device supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily3_v1]) {
-        LOG(WARNING) << "Warning: sample comparison not supported by this GPU";
+        utils::slog.w << "Warning: sample comparison not supported by this GPU" << utils::io::endl;
         samplerDescriptor.compareFunction = MTLCompareFunctionNever;
     }
 #endif

filament/backend/src/metal/PlatformMetal.mm

@@ -19,27 +19,19 @@
 
 #include "MetalDriverFactory.h"
 
-#include <utils/Logger.h>
+#include <utils/Log.h>
 
 #import <Foundation/Foundation.h>
 
 #include <atomic>
-#include <mutex>
 
 namespace filament::backend {
 
 struct PlatformMetalImpl {
-    std::mutex mLock;   // locks mDevice and mCommandQueue
-    id<MTLDevice> mDevice = nil;
     id<MTLCommandQueue> mCommandQueue = nil;
-
     // read form driver thread, read/written to from client thread
     std::atomic<PlatformMetal::DrawableFailureBehavior> mDrawableFailureBehavior =
             PlatformMetal::DrawableFailureBehavior::PANIC;
-
-    // These methods must be called with mLock held
-    void createDeviceImpl(MetalDevice& outDevice);
-    void createCommandQueueImpl(MetalDevice& device, MetalCommandQueue& outCommandQueue);
 };
 
 Platform* createDefaultMetalPlatform() {
@@ -53,65 +45,10 @@ PlatformMetal::~PlatformMetal() noexcept {
 }
 
 Driver* PlatformMetal::createDriver(void* /*sharedContext*/, const Platform::DriverConfig& driverConfig) noexcept {
-    pImpl->mDrawableFailureBehavior = driverConfig.metalDisablePanicOnDrawableFailure
-            ? DrawableFailureBehavior::ABORT_FRAME
-            : DrawableFailureBehavior::PANIC;
     return MetalDriverFactory::create(this, driverConfig);
 }
 
-
-bool PlatformMetal::initialize() noexcept {
-    std::lock_guard<std::mutex> lock(pImpl->mLock);
-
-    MetalDevice device{};
-    pImpl->createDeviceImpl(device);
-    if (device.device == nil) {
-        return false;
-    }
-
-    MetalCommandQueue commandQueue{};
-    pImpl->createCommandQueueImpl(device, commandQueue);
-    if (commandQueue.commandQueue == nil) {
-        return false;
-    }
-
-    return true;
-}
-
 void PlatformMetal::createDevice(MetalDevice& outDevice) noexcept {
-    std::lock_guard<std::mutex> lock(pImpl->mLock);
-    pImpl->createDeviceImpl(outDevice);
-}
-
-void PlatformMetal::createCommandQueue(
-        MetalDevice& device, MetalCommandQueue& outCommandQueue) noexcept {
-    std::lock_guard<std::mutex> lock(pImpl->mLock);
-    pImpl->createCommandQueueImpl(device, outCommandQueue);
-}
-
-void PlatformMetal::createAndEnqueueCommandBuffer(MetalCommandBuffer& outCommandBuffer) noexcept {
-    std::lock_guard<std::mutex> lock(pImpl->mLock);
-    id<MTLCommandBuffer> commandBuffer = [pImpl->mCommandQueue commandBuffer];
-    [commandBuffer enqueue];
-    outCommandBuffer.commandBuffer = commandBuffer;
-}
-
-void PlatformMetal::setDrawableFailureBehavior(DrawableFailureBehavior behavior) noexcept {
-    pImpl->mDrawableFailureBehavior = behavior;
-}
-
-PlatformMetal::DrawableFailureBehavior PlatformMetal::getDrawableFailureBehavior() const noexcept {
-    return pImpl->mDrawableFailureBehavior;
-}
-
-// -------------------------------------------------------------------------------------------------
-
-void PlatformMetalImpl::createDeviceImpl(MetalDevice& outDevice) {
-    if (mDevice) {
-        outDevice.device = mDevice;
-        return;
-    }
-
     id<MTLDevice> result;
 
 #if !defined(FILAMENT_IOS)
@@ -132,21 +69,32 @@ void PlatformMetalImpl::createDeviceImpl(MetalDevice& outDevice) {
         result = MTLCreateSystemDefaultDevice();
     }
 
-    LOG(INFO) << "Selected physical device '"
-              << [result.name cStringUsingEncoding:NSUTF8StringEncoding] << "'";
+    utils::slog.i << "Selected physical device '"
+                  << [result.name cStringUsingEncoding:NSUTF8StringEncoding] << "'"
+                  << utils::io::endl;
 
     outDevice.device = result;
-    mDevice = result;
 }
 
-void PlatformMetalImpl::createCommandQueueImpl(MetalDevice& device, MetalCommandQueue& outCommandQueue) {
-    if (mCommandQueue) {
-        outCommandQueue.commandQueue = mCommandQueue;
-        return;
-    }
-    mCommandQueue = [device.device newCommandQueue];
-    mCommandQueue.label = @"Filament";
-    outCommandQueue.commandQueue = mCommandQueue;
+void PlatformMetal::createCommandQueue(
+        MetalDevice& device, MetalCommandQueue& outCommandQueue) noexcept {
+    pImpl->mCommandQueue = [device.device newCommandQueue];
+    pImpl->mCommandQueue.label = @"Filament";
+    outCommandQueue.commandQueue = pImpl->mCommandQueue;
+}
+
+void PlatformMetal::createAndEnqueueCommandBuffer(MetalCommandBuffer& outCommandBuffer) noexcept {
+    id<MTLCommandBuffer> commandBuffer = [pImpl->mCommandQueue commandBuffer];
+    [commandBuffer enqueue];
+    outCommandBuffer.commandBuffer = commandBuffer;
+}
+
+void PlatformMetal::setDrawableFailureBehavior(DrawableFailureBehavior behavior) noexcept {
+    pImpl->mDrawableFailureBehavior = behavior;
+}
+
+PlatformMetal::DrawableFailureBehavior PlatformMetal::getDrawableFailureBehavior() const noexcept {
+    return pImpl->mDrawableFailureBehavior;
 }
 
 } // namespace filament

filament/backend/src/opengl/BindingMap.h

@@ -69,8 +69,9 @@ public:
         assert_invariant(set < MAX_DESCRIPTOR_SET_COUNT);
         assert_invariant(binding < MAX_DESCRIPTOR_COUNT);
         assert_invariant(entry.binding < 128); // we reserve 1 bit for the type right now
-        mStorage[set][binding] = { uint8_t(entry.binding),
-                                   DescriptorSetLayoutBinding::isSampler(entry.type) };
+        mStorage[set][binding] = { (uint8_t)entry.binding,
+                                   entry.type == DescriptorType::SAMPLER ||
+                                   entry.type == DescriptorType::SAMPLER_EXTERNAL };
         mActiveDescriptors[set].set(binding);
     }
 

filament/backend/src/opengl/GLDescriptorSet.cpp

@@ -95,32 +95,7 @@ GLDescriptorSet::GLDescriptorSet(OpenGLContext& gl, DescriptorSetLayoutHandle ds
                 }
                 break;
             }
-
-            case DescriptorType::SAMPLER_2D_FLOAT:
-            case DescriptorType::SAMPLER_2D_INT:
-            case DescriptorType::SAMPLER_2D_UINT:
-            case DescriptorType::SAMPLER_2D_DEPTH:
-            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_INT:
-            case DescriptorType::SAMPLER_CUBE_UINT:
-            case DescriptorType::SAMPLER_CUBE_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_3D_FLOAT:
-            case DescriptorType::SAMPLER_3D_INT:
-            case DescriptorType::SAMPLER_3D_UINT:
-            case DescriptorType::SAMPLER_2D_MS_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_INT:
-            case DescriptorType::SAMPLER_2D_MS_UINT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
+            case DescriptorType::SAMPLER:
             case DescriptorType::SAMPLER_EXTERNAL:
                 if (UTILS_UNLIKELY(gl.isES2())) {
                     desc.emplace<SamplerGLES2>();
@@ -162,11 +137,8 @@ void GLDescriptorSet::update(OpenGLContext&,
     }, descriptors[binding].desc);
 }
 
-void GLDescriptorSet::update(OpenGLContext& gl, HandleAllocatorGL& handleAllocator,
-        descriptor_binding_t binding, TextureHandle th, SamplerParams params) noexcept {
-
-    GLTexture* t = th ? handleAllocator.handle_cast<GLTexture*>(th) : nullptr;
-
+void GLDescriptorSet::update(OpenGLContext& gl,
+        descriptor_binding_t binding, GLTexture* t, SamplerParams params) noexcept {
     assert_invariant(binding < descriptors.size());
     std::visit([=, &gl](auto&& arg) mutable {
         using T = std::decay_t<decltype(arg)>;
@@ -199,12 +171,20 @@ void GLDescriptorSet::update(OpenGLContext& gl, HandleAllocatorGL& handleAllocat
                 }
             }
 
-            arg.handle = th;
+            arg.target = t ? t->gl.target : 0;
+            arg.id = t ? t->gl.id : 0;
+            arg.external = t ? t->gl.external :  false;
             if constexpr (std::is_same_v<T, Sampler> ||
                           std::is_same_v<T, SamplerWithAnisotropyWorkaround>) {
                 if constexpr (std::is_same_v<T, SamplerWithAnisotropyWorkaround>) {
                     arg.anisotropy = float(1u << params.anisotropyLog2);
                 }
+                if (t) {
+                    arg.ref = t->ref;
+                    arg.baseLevel = t->gl.baseLevel;
+                    arg.maxLevel = t->gl.maxLevel;
+                    arg.swizzle = t->gl.swizzle;
+                }
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
                 arg.sampler = gl.getSampler(params);
 #else
@@ -220,39 +200,39 @@ void GLDescriptorSet::update(OpenGLContext& gl, HandleAllocatorGL& handleAllocat
     }, descriptors[binding].desc);
 }
 
+template<typename T>
 void GLDescriptorSet::updateTextureView(OpenGLContext& gl,
-        HandleAllocatorGL& handleAllocator, GLuint unit, GLTexture const* t) noexcept {
+        HandleAllocatorGL& handleAllocator, GLuint unit, T const& desc) noexcept {
     // The common case is that we don't have a ref handle (we only have one if
     // the texture ever had a View on it).
-    assert_invariant(t);
-    assert_invariant(t->ref);
-    GLTextureRef* const ref = handleAllocator.handle_cast<GLTextureRef*>(t->ref);
-    if (UTILS_UNLIKELY((t->gl.baseLevel != ref->baseLevel || t->gl.maxLevel != ref->maxLevel))) {
+    assert_invariant(desc.ref);
+    GLTextureRef* const ref = handleAllocator.handle_cast<GLTextureRef*>(desc.ref);
+    if (UTILS_UNLIKELY((desc.baseLevel != ref->baseLevel || desc.maxLevel != ref->maxLevel))) {
         // If we have views, then it's still uncommon that we'll switch often
         // handle the case where we reset to the original texture
-        GLint baseLevel = GLint(t->gl.baseLevel); // NOLINT(*-signed-char-misuse)
-        GLint maxLevel = GLint(t->gl.maxLevel); // NOLINT(*-signed-char-misuse)
+        GLint baseLevel = GLint(desc.baseLevel); // NOLINT(*-signed-char-misuse)
+        GLint maxLevel = GLint(desc.maxLevel); // NOLINT(*-signed-char-misuse)
         if (baseLevel > maxLevel) {
             baseLevel = 0;
             maxLevel = 1000; // per OpenGL spec
         }
         // that is very unfortunate that we have to call activeTexture here
         gl.activeTexture(unit);
-        glTexParameteri(t->gl.target, GL_TEXTURE_BASE_LEVEL, baseLevel);
-        glTexParameteri(t->gl.target, GL_TEXTURE_MAX_LEVEL,  maxLevel);
-        ref->baseLevel = t->gl.baseLevel;
-        ref->maxLevel = t->gl.maxLevel;
+        glTexParameteri(desc.target, GL_TEXTURE_BASE_LEVEL, baseLevel);
+        glTexParameteri(desc.target, GL_TEXTURE_MAX_LEVEL,  maxLevel);
+        ref->baseLevel = desc.baseLevel;
+        ref->maxLevel = desc.maxLevel;
     }
-    if (UTILS_UNLIKELY(t->gl.swizzle != ref->swizzle)) {
+    if (UTILS_UNLIKELY(desc.swizzle != ref->swizzle)) {
         using namespace GLUtils;
         gl.activeTexture(unit);
 #if !defined(__EMSCRIPTEN__)  && !defined(FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2)
-        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_R, (GLint)getSwizzleChannel(t->gl.swizzle[0]));
-        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_G, (GLint)getSwizzleChannel(t->gl.swizzle[1]));
-        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_B, (GLint)getSwizzleChannel(t->gl.swizzle[2]));
-        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_A, (GLint)getSwizzleChannel(t->gl.swizzle[3]));
+        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_R, (GLint)getSwizzleChannel(desc.swizzle[0]));
+        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_G, (GLint)getSwizzleChannel(desc.swizzle[1]));
+        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_B, (GLint)getSwizzleChannel(desc.swizzle[2]));
+        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_A, (GLint)getSwizzleChannel(desc.swizzle[3]));
 #endif
-        ref->swizzle = t->gl.swizzle;
+        ref->swizzle = desc.swizzle;
     }
 }
 
@@ -305,31 +285,27 @@ void GLDescriptorSet::bind(
                 }
             } else if constexpr (std::is_same_v<T, Sampler>) {
                 GLuint const unit = p.getTextureUnit(set, binding);
-
-
-                if (arg.handle) {
-                    GLTexture const* const t = handleAllocator.handle_cast<GLTexture*>(arg.handle);
-                    gl.bindTexture(unit, t->gl.target, t->gl.id, t->gl.external);
+                if (arg.target) {
+                    gl.bindTexture(unit, arg.target, arg.id, arg.external);
                     gl.bindSampler(unit, arg.sampler);
-                    if (UTILS_UNLIKELY(t->ref)) {
-                        updateTextureView(gl, handleAllocator, unit, t);
+                    if (UTILS_UNLIKELY(arg.ref)) {
+                        updateTextureView(gl, handleAllocator, unit, arg);
                     }
                 } else {
                     gl.unbindTextureUnit(unit);
                 }
             } else if constexpr (std::is_same_v<T, SamplerWithAnisotropyWorkaround>) {
                 GLuint const unit = p.getTextureUnit(set, binding);
-                if (arg.handle) {
-                    GLTexture const* const t = handleAllocator.handle_cast<GLTexture*>(arg.handle);
-                    gl.bindTexture(unit, t->gl.target, t->gl.id, t->gl.external);
+                if (arg.target) {
+                    gl.bindTexture(unit, arg.target, arg.id, arg.external);
                     gl.bindSampler(unit, arg.sampler);
-                    if (UTILS_UNLIKELY(t->ref)) {
-                        updateTextureView(gl, handleAllocator, unit, t);
+                    if (UTILS_UNLIKELY(arg.ref)) {
+                        updateTextureView(gl, handleAllocator, unit, arg);
                     }
 #if defined(GL_EXT_texture_filter_anisotropic)
                     // Driver claims to support anisotropic filtering, but it fails when set on
                     // the sampler, we have to set it on the texture instead.
-                    glTexParameterf(t->gl.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
+                    glTexParameterf(arg.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
                             std::min(gl.gets.max_anisotropy, float(arg.anisotropy)));
 #endif
                 } else {
@@ -338,20 +314,19 @@ void GLDescriptorSet::bind(
             } else if constexpr (std::is_same_v<T, SamplerGLES2>) {
                 // in ES2 the sampler parameters need to be set on the texture itself
                 GLuint const unit = p.getTextureUnit(set, binding);
-                if (arg.handle) {
-                    GLTexture const* const t = handleAllocator.handle_cast<GLTexture*>(arg.handle);
-                    gl.bindTexture(unit, t->gl.target, t->gl.id, t->gl.external);
+                if (arg.target) {
+                    gl.bindTexture(unit, arg.target, arg.id, arg.external);
                     SamplerParams const params = arg.params;
-                    glTexParameteri(t->gl.target, GL_TEXTURE_MIN_FILTER,
+                    glTexParameteri(arg.target, GL_TEXTURE_MIN_FILTER,
                             (GLint)GLUtils::getTextureFilter(params.filterMin));
-                    glTexParameteri(t->gl.target, GL_TEXTURE_MAG_FILTER,
+                    glTexParameteri(arg.target, GL_TEXTURE_MAG_FILTER,
                             (GLint)GLUtils::getTextureFilter(params.filterMag));
-                    glTexParameteri(t->gl.target, GL_TEXTURE_WRAP_S,
+                    glTexParameteri(arg.target, GL_TEXTURE_WRAP_S,
                             (GLint)GLUtils::getWrapMode(params.wrapS));
-                    glTexParameteri(t->gl.target, GL_TEXTURE_WRAP_T,
+                    glTexParameteri(arg.target, GL_TEXTURE_WRAP_T,
                             (GLint)GLUtils::getWrapMode(params.wrapT));
 #if defined(GL_EXT_texture_filter_anisotropic)
-                    glTexParameterf(t->gl.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
+                    glTexParameterf(arg.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
                             std::min(gl.gets.max_anisotropy, arg.anisotropy));
 #endif
                 } else {
@@ -360,7 +335,7 @@ void GLDescriptorSet::bind(
             }
         }, entry.desc);
     });
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void GLDescriptorSet::validate(HandleAllocatorGL& allocator,

filament/backend/src/opengl/GLDescriptorSet.h

@@ -59,8 +59,8 @@ struct GLDescriptorSet : public HwDescriptorSet {
             descriptor_binding_t binding, GLBufferObject* bo, size_t offset, size_t size) noexcept;
 
     // update a sampler descriptor in the set
-    void update(OpenGLContext& gl, HandleAllocatorGL& handleAllocator,
-            descriptor_binding_t binding, TextureHandle th, SamplerParams params) noexcept;
+    void update(OpenGLContext& gl,
+            descriptor_binding_t binding, GLTexture* t, SamplerParams params) noexcept;
 
     // conceptually bind the set to the command buffer
     void bind(
@@ -111,19 +111,46 @@ private:
 
     // A sampler descriptor
     struct Sampler {
-        TextureHandle handle;                   // 4
+        uint16_t target;                        // 2 (GLenum)
+        bool external = false;                  // 1
+        bool reserved = false;                  // 1
+        GLuint id = 0;                          // 4
         GLuint sampler = 0;                     // 4
+        Handle<GLTextureRef> ref;               // 4
+        int8_t baseLevel = 0x7f;                // 1
+        int8_t maxLevel = -1;                   // 1
+        std::array<TextureSwizzle, 4> swizzle{  // 4
+                TextureSwizzle::CHANNEL_0,
+                TextureSwizzle::CHANNEL_1,
+                TextureSwizzle::CHANNEL_2,
+                TextureSwizzle::CHANNEL_3
+        };
     };
 
     struct SamplerWithAnisotropyWorkaround {
-        TextureHandle handle;                   // 4
+        uint16_t target;                        // 2 (GLenum)
+        bool external = false;                  // 1
+        bool reserved = false;                  // 1
+        GLuint id = 0;                          // 4
         GLuint sampler = 0;                     // 4
+        Handle<GLTextureRef> ref;               // 4
         math::half anisotropy = 1.0f;           // 2
+        int8_t baseLevel = 0x7f;                // 1
+        int8_t maxLevel = -1;                   // 1
+        std::array<TextureSwizzle, 4> swizzle{  // 4
+                TextureSwizzle::CHANNEL_0,
+                TextureSwizzle::CHANNEL_1,
+                TextureSwizzle::CHANNEL_2,
+                TextureSwizzle::CHANNEL_3
+        };
     };
 
     // A sampler descriptor for ES2
     struct SamplerGLES2 {
-        TextureHandle handle;                   // 4
+        uint16_t target;                        // 2 (GLenum)
+        bool external = false;                  // 1
+        bool reserved = false;                  // 1
+        GLuint id = 0;                          // 4
         SamplerParams params{};                 // 4
         float anisotropy = 1.0f;                // 4
     };
@@ -138,8 +165,9 @@ private:
     };
     static_assert(sizeof(Descriptor) <= 32);
 
+    template<typename T>
     static void updateTextureView(OpenGLContext& gl,
-            HandleAllocatorGL& handleAllocator, GLuint unit, GLTexture const* t) noexcept;
+            HandleAllocatorGL& handleAllocator, GLuint unit, T const& desc) noexcept;
 
     utils::FixedCapacityVector<Descriptor> descriptors;     // 16
     utils::bitset64 dynamicBuffers;                         // 8

filament/backend/src/opengl/GLUtils.cpp

@@ -18,7 +18,6 @@
 
 #include "private/backend/Driver.h"
 
-#include <utils/Logger.h>
 #include <utils/compiler.h>
 #include <utils/ostream.h>
 #include <utils/trap.h>
@@ -26,7 +25,6 @@
 #include <string_view>
 
 #include <stddef.h>
-#include <cstdio>
 
 namespace filament::backend {
 
@@ -57,21 +55,19 @@ std::string_view getGLErrorString(GLenum error) noexcept {
 }
 
 UTILS_NOINLINE
-GLenum checkGLError(const char* function, size_t line) noexcept {
+GLenum checkGLError(io::ostream& out, const char* function, size_t line) noexcept {
     GLenum const error = glGetError();
     if (UTILS_VERY_UNLIKELY(error != GL_NO_ERROR)) {
         auto const string = getGLErrorString(error);
-        char hexError[16];
-        snprintf(hexError, sizeof(hexError), "%#x", error);
-        LOG(ERROR) << "OpenGL error " << hexError << " (" << string << ") in \"" << function
-                   << "\" at line " << line;
+        out << "OpenGL error " << io::hex << error << " (" << string << ") in \""
+            << function << "\" at line " << io::dec << line << io::endl;
     }
     return error;
 }
 
 UTILS_NOINLINE
-void assertGLError(const char* function, size_t line) noexcept {
-    GLenum const err = checkGLError(function, line);
+void assertGLError(io::ostream& out, const char* function, size_t line) noexcept {
+    GLenum const err = checkGLError(out, function, line);
     if (UTILS_VERY_UNLIKELY(err != GL_NO_ERROR)) {
         debug_trap();
     }
@@ -101,21 +97,19 @@ std::string_view getFramebufferStatusString(GLenum status) noexcept {
 }
 
 UTILS_NOINLINE
-GLenum checkFramebufferStatus(GLenum target, const char* function, size_t line) noexcept {
+GLenum checkFramebufferStatus(io::ostream& out, GLenum target, const char* function, size_t line) noexcept {
     GLenum const status = glCheckFramebufferStatus(target);
     if (UTILS_VERY_UNLIKELY(status != GL_FRAMEBUFFER_COMPLETE)) {
         auto const string = getFramebufferStatusString(status);
-        char hexStatus[16];
-        snprintf(hexStatus, sizeof(hexStatus), "%#x", status);
-        LOG(ERROR) << "OpenGL framebuffer error " << hexStatus << " (" << string << ") in \""
-                   << function << "\" at line " << line;
+        out << "OpenGL framebuffer error " << io::hex << status << " (" << string << ") in \""
+            << function << "\" at line " << io::dec << line << io::endl;
     }
     return status;
 }
 
 UTILS_NOINLINE
-void assertFramebufferStatus(GLenum target, const char* function, size_t line) noexcept {
-    GLenum const status = checkFramebufferStatus(target, function, line);
+void assertFramebufferStatus(io::ostream& out, GLenum target, const char* function, size_t line) noexcept {
+    GLenum const status = checkFramebufferStatus(out, target, function, line);
     if (UTILS_VERY_UNLIKELY(status != GL_FRAMEBUFFER_COMPLETE)) {
         debug_trap();
     }

filament/backend/src/opengl/GLUtils.h

@@ -33,21 +33,21 @@
 namespace filament::backend::GLUtils {
 
 std::string_view getGLErrorString(GLenum error) noexcept;
-GLenum checkGLError(const char* function, size_t line) noexcept;
-void assertGLError(const char* function, size_t line) noexcept;
+GLenum checkGLError(utils::io::ostream& out, const char* function, size_t line) noexcept;
+void assertGLError(utils::io::ostream& out, const char* function, size_t line) noexcept;
 
 std::string_view getFramebufferStatusString(GLenum err) noexcept;
-GLenum checkFramebufferStatus(GLenum target, const char* function, size_t line) noexcept;
-void assertFramebufferStatus(GLenum target, const char* function, size_t line) noexcept;
+GLenum checkFramebufferStatus(utils::io::ostream& out, GLenum target, const char* function, size_t line) noexcept;
+void assertFramebufferStatus(utils::io::ostream& out, GLenum target, const char* function, size_t line) noexcept;
 
 #ifdef NDEBUG
-#   define CHECK_GL_ERROR()
-#   define CHECK_GL_ERROR_NON_FATAL()
-#   define CHECK_GL_FRAMEBUFFER_STATUS(target)
+#   define CHECK_GL_ERROR(out)
+#   define CHECK_GL_ERROR_NON_FATAL(out)
+#   define CHECK_GL_FRAMEBUFFER_STATUS(out, target)
 #else
-#   define CHECK_GL_ERROR() { GLUtils::assertGLError(__func__, __LINE__); }
-#   define CHECK_GL_ERROR_NON_FATAL() { GLUtils::checkGLError(__func__, __LINE__); }
-#   define CHECK_GL_FRAMEBUFFER_STATUS(target) { GLUtils::checkFramebufferStatus( target, __func__, __LINE__); }
+#   define CHECK_GL_ERROR(out) { GLUtils::assertGLError(out, __func__, __LINE__); }
+#   define CHECK_GL_ERROR_NON_FATAL(out) { GLUtils::checkGLError(out, __func__, __LINE__); }
+#   define CHECK_GL_FRAMEBUFFER_STATUS(out, target) { GLUtils::checkFramebufferStatus(out, target, __func__, __LINE__); }
 #endif
 
 constexpr GLuint getComponentCount(ElementType const type) noexcept {

filament/backend/src/opengl/OpenGLBlobCache.cpp

@@ -21,7 +21,7 @@
 #include <backend/Platform.h>
 #include <backend/Program.h>
 
-#include <private/utils/Tracing.h>
+#include <utils/Systrace.h>
 
 namespace filament::backend {
 
@@ -36,7 +36,7 @@ OpenGLBlobCache::OpenGLBlobCache(OpenGLContext& gl) noexcept
 
 GLuint OpenGLBlobCache::retrieve(BlobCacheKey* outKey, Platform& platform,
         Program const& program) const noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
     if (!mCachingSupported || !platform.hasRetrieveBlobFunc()) {
         // the key is never updated in that case
         return 0;
@@ -68,7 +68,7 @@ GLuint OpenGLBlobCache::retrieve(BlobCacheKey* outKey, Platform& platform,
         programId = glCreateProgram();
 
         { // scope for systrace
-            FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glProgramBinary");
+            SYSTRACE_NAME("glProgramBinary");
             glProgramBinary(programId, blob->format, blob->data, programBinarySize);
         }
 
@@ -90,7 +90,7 @@ GLuint OpenGLBlobCache::retrieve(BlobCacheKey* outKey, Platform& platform,
 
 void OpenGLBlobCache::insert(Platform& platform,
         BlobCacheKey const& key, GLuint program) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
     if (!mCachingSupported || !platform.hasInsertBlobFunc()) {
         // the key is never updated in that case
         return;
@@ -100,7 +100,7 @@ void OpenGLBlobCache::insert(Platform& platform,
     GLenum format;
     GLint programBinarySize = 0;
     { // scope for systrace
-        FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glGetProgramiv");
+        SYSTRACE_NAME("glGetProgramiv");
         glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &programBinarySize);
     }
     if (programBinarySize) {
@@ -108,7 +108,7 @@ void OpenGLBlobCache::insert(Platform& platform,
         std::unique_ptr<Blob, decltype(&::free)> blob{ (Blob*)malloc(size), &::free };
         if (UTILS_LIKELY(blob)) {
             { // scope for systrace
-                FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glGetProgramBinary");
+                SYSTRACE_NAME("glGetProgramBinary");
                 glGetProgramBinary(program, programBinarySize,
                         &programBinarySize, &format, blob->data);
             }

filament/backend/src/opengl/OpenGLContext.cpp

@@ -22,9 +22,9 @@
 #include <backend/platforms/OpenGLPlatform.h>
 #include <backend/DriverEnums.h>
 
-#include <utils/Logger.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
+#include <utils/Log.h>
 #include <utils/ostream.h>
 
 #include <functional>
@@ -77,8 +77,8 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
     state.version  = (char const*)glGetString(GL_VERSION);
     state.shader   = (char const*)glGetString(GL_SHADING_LANGUAGE_VERSION);
 
-    LOG(INFO) << "[" << state.vendor << "], [" << state.renderer << "], "
-                 "[" << state.version << "], [" << state.shader << "]";
+    slog.v << "[" << state.vendor << "], [" << state.renderer << "], "
+              "[" << state.version << "], [" << state.shader << "]" << io::endl;
 
     /*
      * Figure out GL / GLES version, extensions and capabilities we need to
@@ -164,33 +164,51 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
     }
 #endif
 
-    LOG(INFO) << "Feature level: " << +mFeatureLevel;
-    LOG(INFO) << "Active workarounds: ";
+    slog.v << "Feature level: " << +mFeatureLevel << '\n';
+    slog.v << "Active workarounds: " << '\n';
     UTILS_NOUNROLL
     for (auto [enabled, name, _] : mBugDatabase) {
         if (enabled) {
-            LOG(INFO) << name;
+            slog.v << name << '\n';
         }
     }
+    flush(slog.v);
 
 #ifndef NDEBUG
     // this is useful for development
-    LOG(INFO) << "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = " << gets.max_anisotropy;
-    LOG(INFO) << "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = " << gets.max_combined_texture_image_units;
-    LOG(INFO) << "GL_MAX_TEXTURE_SIZE = " << gets.max_texture_size;
-    LOG(INFO) << "GL_MAX_CUBE_MAP_TEXTURE_SIZE = " << gets.max_cubemap_texture_size;
-    LOG(INFO) << "GL_MAX_3D_TEXTURE_SIZE = " << gets.max_3d_texture_size;
-    LOG(INFO) << "GL_MAX_ARRAY_TEXTURE_LAYERS = " << gets.max_array_texture_layers;
-    LOG(INFO) << "GL_MAX_DRAW_BUFFERS = " << gets.max_draw_buffers;
-    LOG(INFO) << "GL_MAX_RENDERBUFFER_SIZE = " << gets.max_renderbuffer_size;
-    LOG(INFO) << "GL_MAX_SAMPLES = " << gets.max_samples;
-    LOG(INFO) << "GL_MAX_TEXTURE_IMAGE_UNITS = " << gets.max_texture_image_units;
-    LOG(INFO) << "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = "
-              << gets.max_transform_feedback_separate_attribs;
-    LOG(INFO) << "GL_MAX_UNIFORM_BLOCK_SIZE = " << gets.max_uniform_block_size;
-    LOG(INFO) << "GL_MAX_UNIFORM_BUFFER_BINDINGS = " << gets.max_uniform_buffer_bindings;
-    LOG(INFO) << "GL_NUM_PROGRAM_BINARY_FORMATS = " << gets.num_program_binary_formats;
-    LOG(INFO) << "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = " << gets.uniform_buffer_offset_alignment;
+    slog.v
+            << "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = "
+                    << gets.max_anisotropy << '\n'
+            << "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = "
+                    << gets.max_combined_texture_image_units << '\n'
+            << "GL_MAX_TEXTURE_SIZE = "
+                    << gets.max_texture_size << '\n'
+            << "GL_MAX_CUBE_MAP_TEXTURE_SIZE = "
+                    << gets.max_cubemap_texture_size << '\n'
+            << "GL_MAX_3D_TEXTURE_SIZE = "
+                    << gets.max_3d_texture_size << '\n'
+            << "GL_MAX_ARRAY_TEXTURE_LAYERS = "
+                    << gets.max_array_texture_layers << '\n'
+            << "GL_MAX_DRAW_BUFFERS = "
+                    << gets.max_draw_buffers << '\n'
+            << "GL_MAX_RENDERBUFFER_SIZE = "
+                    << gets.max_renderbuffer_size << '\n'
+            << "GL_MAX_SAMPLES = "
+                    << gets.max_samples << '\n'
+            << "GL_MAX_TEXTURE_IMAGE_UNITS = "
+                    << gets.max_texture_image_units << '\n'
+            << "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = "
+                    << gets.max_transform_feedback_separate_attribs << '\n'
+            << "GL_MAX_UNIFORM_BLOCK_SIZE = "
+                    << gets.max_uniform_block_size << '\n'
+            << "GL_MAX_UNIFORM_BUFFER_BINDINGS = "
+                    << gets.max_uniform_buffer_bindings << '\n'
+            << "GL_NUM_PROGRAM_BINARY_FORMATS = "
+                    << gets.num_program_binary_formats << '\n'
+            << "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = "
+                    << gets.uniform_buffer_offset_alignment << '\n'
+            ;
+    flush(slog.v);
 #endif
 
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
@@ -224,14 +242,15 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
     if (ext.KHR_debug) {
         auto cb = +[](GLenum, GLenum type, GLuint, GLenum severity, GLsizei length,
                 const GLchar* message, const void *) {
-            auto logSeverity = utils::LogSeverity::kInfo;
+            io::ostream* stream = &slog.i;
             switch (severity) {
-                case GL_DEBUG_SEVERITY_HIGH:    logSeverity = utils::LogSeverity::kError;   break;
-                case GL_DEBUG_SEVERITY_MEDIUM:  logSeverity = utils::LogSeverity::kWarning; break;
-                case GL_DEBUG_SEVERITY_LOW:     logSeverity = utils::LogSeverity::kInfo;    break;
+                case GL_DEBUG_SEVERITY_HIGH:    stream = &slog.e;   break;
+                case GL_DEBUG_SEVERITY_MEDIUM:  stream = &slog.w;   break;
+                case GL_DEBUG_SEVERITY_LOW:     stream = &slog.d;   break;
                 case GL_DEBUG_SEVERITY_NOTIFICATION:
                 default: break;
             }
+            io::ostream& out = *stream;
             const char* level = ": ";
             switch (type) {
                 case GL_DEBUG_TYPE_ERROR:               level = "ERROR: ";               break;
@@ -243,7 +262,7 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
                 case GL_DEBUG_TYPE_MARKER:              level = "MARKER: ";              break;
                 default: break;
             }
-            LOG(LEVEL(logSeverity)) << "KHR_debug " << level << std::string_view{ message, size_t(length) };
+            out << "KHR_debug " << level << std::string_view{ message, size_t(length) } << io::endl;
         };
         glEnable(GL_DEBUG_OUTPUT);
         glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
@@ -523,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,
@@ -688,8 +700,9 @@ void OpenGLContext::initExtensionsGLES(Extensions* ext, GLint major, GLint minor
     GLUtils::unordered_string_set const exts = GLUtils::split(extensions);
     if constexpr (DEBUG_PRINT_EXTENSIONS) {
         for (auto extension: exts) {
-            DLOG(INFO) << "\"" << std::string_view(extension) << "\"";
+            slog.d << "\"" << std::string_view(extension) << "\"\n";
         }
+        flush(slog.d);
     }
 
     // figure out and initialize the extensions we need
@@ -763,8 +776,9 @@ void OpenGLContext::initExtensionsGL(Extensions* ext, GLint major, GLint minor)
     }
     if constexpr (DEBUG_PRINT_EXTENSIONS) {
         for (auto extension: exts) {
-            DLOG(INFO) << "\"" << std::string_view(extension) << "\"";
+            slog.d << "\"" << std::string_view(extension) << "\"\n";
         }
+        flush(slog.d);
     }
 
     using namespace std::literals;
@@ -1024,7 +1038,7 @@ GLuint OpenGLContext::getSamplerSlow(SamplerParams params) const noexcept {
                 std::min(gets.max_anisotropy, anisotropy));
     }
 #endif
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
     mSamplerMap[params] = s;
     return s;
 }

filament/backend/src/opengl/OpenGLDriver.cpp

@@ -44,17 +44,15 @@
 #include "private/backend/Dispatcher.h"
 #include "private/backend/DriverApi.h"
 
-#include <private/utils/Tracing.h>
-
 #include <type_traits>
 #include <utils/BitmaskEnum.h>
-#include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
+#include <utils/CString.h>
 #include <utils/Invocable.h>
-#include <utils/Logger.h>
+#include <utils/Log.h>
 #include <utils/Panic.h>
-#include <utils/Slice.h>
 #include <utils/Systrace.h>
+#include <utils/Slice.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/ostream.h>
@@ -100,13 +98,13 @@
 
 #define DEBUG_GROUP_MARKER_NONE       0x00    // no debug marker
 #define DEBUG_GROUP_MARKER_OPENGL     0x01    // markers in the gl command queue (req. driver support)
-#define DEBUG_GROUP_MARKER_BACKEND    0x02    // markers on the backend side (perfetto)
+#define DEBUG_GROUP_MARKER_BACKEND    0x02    // markers on the backend side (systrace)
 #define DEBUG_GROUP_MARKER_ALL        0xFF    // all markers
 
 #define DEBUG_MARKER_NONE             0x00    // no debug marker
 #define DEBUG_MARKER_OPENGL           0x01    // markers in the gl command queue (req. driver support)
-#define DEBUG_MARKER_BACKEND          0x02    // markers on the backend side (perfetto)
-#define DEBUG_MARKER_PROFILE          0x04    // profiling on the backend side (perfetto)
+#define DEBUG_MARKER_BACKEND          0x02    // markers on the backend side (systrace)
+#define DEBUG_MARKER_PROFILE          0x04    // profiling on the backend side (systrace)
 #define DEBUG_MARKER_ALL              (0xFF & ~DEBUG_MARKER_PROFILE) // all markers
 
 // set to the desired debug marker level (for user markers [default: All])
@@ -185,18 +183,20 @@ OpenGLDriver* OpenGLDriver::create(OpenGLPlatform* platform,
     //    GLVertexBufferInfo        : 132       moderate
     // -- less than or equal to 136 bytes
 
-    DLOG(INFO) << "GLSwapChain: " << sizeof(GLSwapChain);
-    DLOG(INFO) << "GLBufferObject: " << sizeof(GLBufferObject);
-    DLOG(INFO) << "GLVertexBuffer: " << sizeof(GLVertexBuffer);
-    DLOG(INFO) << "GLVertexBufferInfo: " << sizeof(GLVertexBufferInfo);
-    DLOG(INFO) << "GLIndexBuffer: " << sizeof(GLIndexBuffer);
-    DLOG(INFO) << "GLRenderPrimitive: " << sizeof(GLRenderPrimitive);
-    DLOG(INFO) << "GLTexture: " << sizeof(GLTexture);
-    DLOG(INFO) << "GLTimerQuery: " << sizeof(GLTimerQuery);
-    DLOG(INFO) << "GLStream: " << sizeof(GLStream);
-    DLOG(INFO) << "GLRenderTarget: " << sizeof(GLRenderTarget);
-    DLOG(INFO) << "GLFence: " << sizeof(GLFence);
-    DLOG(INFO) << "OpenGLProgram: " << sizeof(OpenGLProgram);
+    slog.d
+           << "\nGLSwapChain: " << sizeof(GLSwapChain)
+           << "\nGLBufferObject: " << sizeof(GLBufferObject)
+           << "\nGLVertexBuffer: " << sizeof(GLVertexBuffer)
+           << "\nGLVertexBufferInfo: " << sizeof(GLVertexBufferInfo)
+           << "\nGLIndexBuffer: " << sizeof(GLIndexBuffer)
+           << "\nGLRenderPrimitive: " << sizeof(GLRenderPrimitive)
+           << "\nGLTexture: " << sizeof(GLTexture)
+           << "\nGLTimerQuery: " << sizeof(GLTimerQuery)
+           << "\nGLStream: " << sizeof(GLStream)
+           << "\nGLRenderTarget: " << sizeof(GLRenderTarget)
+           << "\nGLFence: " << sizeof(GLFence)
+           << "\nOpenGLProgram: " << sizeof(OpenGLProgram)
+           << io::endl;
 #endif
 
     // here we check we're on a supported version of GL before initializing the driver
@@ -248,8 +248,8 @@ OpenGLDriver::DebugMarker::DebugMarker(OpenGLDriver& driver, const char* string)
 #endif
 
 #if DEBUG_MARKER_LEVEL & DEBUG_MARKER_BACKEND
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, string);
+    SYSTRACE_CONTEXT();
+    SYSTRACE_NAME_BEGIN(string);
 #endif
 #endif
 }
@@ -265,8 +265,8 @@ OpenGLDriver::DebugMarker::~DebugMarker() noexcept {
 #endif
 
 #if DEBUG_MARKER_LEVEL & DEBUG_MARKER_BACKEND
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CONTEXT();
+    SYSTRACE_NAME_END();
 #endif
 #endif
 }
@@ -288,7 +288,7 @@ OpenGLDriver::OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfi
     mStreamsWithPendingAcquiredImage.reserve(8);
 
 #ifndef NDEBUG
-    LOG(INFO) << "OS version: " << mPlatform.getOSVersion();
+    slog.i << "OS version: " << mPlatform.getOSVersion() << io::endl;
 #endif
 
     // Timer queries are core in GL 3.3, otherwise we need EXT_disjoint_timer_query
@@ -667,7 +667,7 @@ void OpenGLDriver::createIndexBufferR(
     gl.bindVertexArray(nullptr);
     gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, ib->gl.buffer);
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, nullptr, getBufferUsage(usage));
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::createBufferObjectR(Handle<HwBufferObject> boh,
@@ -692,7 +692,7 @@ void OpenGLDriver::createBufferObjectR(Handle<HwBufferObject> boh,
         glBufferData(bo->gl.binding, byteCount, nullptr, getBufferUsage(usage));
     }
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph,
@@ -729,7 +729,7 @@ void OpenGLDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph,
     // this records the index buffer into the currently bound VAO
     gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, ib->gl.buffer);
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {
@@ -759,7 +759,7 @@ void OpenGLDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {
     }
 
     construct<OpenGLProgram>(ph, *this, std::move(program));
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 UTILS_NOINLINE
@@ -931,12 +931,7 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
 #if defined(BACKEND_OPENGL_LEVEL_GLES31)
                 if (gl.features.multisample_texture) {
                     // multi-sample texture on GL 3.2 / GLES 3.1 and above
-                    if (depth <= 1) {
-                        // We forcibly change the target to 2D-multisample only for flat texture.
-                        // A depth value greater than 1 may indicate multiview usage, which requires
-                        // GL_TEXTURE_2D_ARRAY. Also 2D MSAA won't work with non-flat texture anyway.
-                        t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
-                    }
+                    t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
                 } else {
                     // Turn off multi-sampling for that texture. It's just not supported.
                 }
@@ -952,7 +947,7 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
         renderBufferStorage(t->gl.id, internalFormat, w, h, samples);
     }
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::createTextureViewR(Handle<HwTexture> th,
@@ -998,7 +993,7 @@ void OpenGLDriver::createTextureViewR(Handle<HwTexture> th,
     assert_invariant(ref);
     ref->count++;
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::createTextureViewSwizzleR(Handle<HwTexture> th, Handle<HwTexture> srch,
@@ -1061,7 +1056,7 @@ void OpenGLDriver::createTextureViewSwizzleR(Handle<HwTexture> th, Handle<HwText
     assert_invariant(ref);
     ref->count++;
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::createTextureExternalImage2R(Handle<HwTexture> th, SamplerType target,
@@ -1212,19 +1207,14 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
 #if defined(BACKEND_OPENGL_LEVEL_GLES31)
         if (gl.features.multisample_texture) {
             // multi-sample texture on GL 3.2 / GLES 3.1 and above
-            if (depth <= 1) {
-                // We forcibly change the target to 2D-multisample only for flat texture.
-                // A depth value greater than 1 may indicate multiview usage, which requires
-                // GL_TEXTURE_2D_ARRAY. Also 2D MSAA won't work with non-flat texture anyway.
-                t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
-            }
+            t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
         } else {
             // Turn off multi-sampling for that texture. It's just not supported.
         }
 #endif
     }
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::updateVertexArrayObject(GLRenderPrimitive* rp, GLVertexBuffer const* vb) {
@@ -1462,15 +1452,8 @@ void OpenGLDriver::framebufferTexture(TargetBufferInfo const& binfo,
 #if !defined(__EMSCRIPTEN__) && !defined(FILAMENT_IOS)
                 if (layerCount > 1) {
                     // if layerCount > 1, it means we use the multiview extension.
-                    if (rt->gl.samples > 1) {
-                        // For MSAA
-                        glFramebufferTextureMultisampleMultiviewOVR(GL_FRAMEBUFFER, attachment,
-                                t->gl.id, 0, rt->gl.samples, binfo.layer, layerCount);
-                    }
-                    else {
-                        glFramebufferTextureMultiviewOVR(GL_FRAMEBUFFER, attachment, t->gl.id, 0,
-                                binfo.layer, layerCount);
-                    }
+                    glFramebufferTextureMultiviewOVR(GL_FRAMEBUFFER, attachment,
+                        t->gl.id, 0, binfo.layer, layerCount);
                 } else
 #endif // !defined(__EMSCRIPTEN__) && !defined(FILAMENT_IOS)
                 {
@@ -1484,7 +1467,7 @@ void OpenGLDriver::framebufferTexture(TargetBufferInfo const& binfo,
                 // we shouldn't be here
                 break;
         }
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
     } else
 #ifndef __EMSCRIPTEN__
 #ifdef GL_EXT_multisampled_render_to_texture
@@ -1505,7 +1488,7 @@ void OpenGLDriver::framebufferTexture(TargetBufferInfo const& binfo,
             glFramebufferRenderbuffer(GL_FRAMEBUFFER, attachment,
                     GL_RENDERBUFFER, t->gl.id);
         }
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
     } else
 #endif // GL_EXT_multisampled_render_to_texture
 #endif // __EMSCRIPTEN__
@@ -1587,13 +1570,13 @@ void OpenGLDriver::framebufferTexture(TargetBufferInfo const& binfo,
                 break;
         }
 
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
     }
 
     rt->gl.resolve |= resolveFlags;
 
-    CHECK_GL_ERROR()
-    CHECK_GL_FRAMEBUFFER_STATUS(GL_FRAMEBUFFER)
+    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_FRAMEBUFFER)
 }
 
 void OpenGLDriver::renderBufferStorage(GLuint rbo, GLenum internalformat, uint32_t width, // NOLINT(readability-convert-member-functions-to-static)
@@ -1622,7 +1605,7 @@ void OpenGLDriver::renderBufferStorage(GLuint rbo, GLenum internalformat, uint32
     // unbind the renderbuffer, to avoid any later confusion
     glBindRenderbuffer(GL_RENDERBUFFER, 0);
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::createDefaultRenderTargetR(
@@ -1719,7 +1702,7 @@ void OpenGLDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
         if (UTILS_LIKELY(!getContext().isES2())) {
             glDrawBuffers((GLsizei)maxDrawBuffers, bufs);
         }
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
     }
 #endif
 
@@ -1759,7 +1742,7 @@ void OpenGLDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
     assert_invariant(any(targets & TargetBufferFlags::ALL));
     assert_invariant(tmin == tmax);
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::createFenceR(Handle<HwFence> fh, int) {
@@ -2110,7 +2093,7 @@ void OpenGLDriver::setAcquiredImage(Handle<HwStream> sh, void* hwbuffer, const m
 
     if (UTILS_UNLIKELY(glstream->user_thread.pending.image)) {
         scheduleRelease(glstream->user_thread.pending);
-        LOG(WARNING) << "Acquired image is set more than once per frame.";
+        slog.w << "Acquired image is set more than once per frame." << io::endl;
     }
 
     glstream->user_thread.pending = mPlatform.transformAcquiredImage({
@@ -2530,36 +2513,13 @@ void OpenGLDriver::makeCurrent(Handle<HwSwapChain> schDraw, Handle<HwSwapChain>
 
     mPlatform.makeCurrent(scDraw->swapChain, scRead->swapChain,
             [this]() {
-                for (auto t: mTexturesWithStreamsAttached) {
-                    if (t->hwStream->streamType == StreamType::NATIVE) {
-                        mPlatform.detach(t->hwStream->stream);
-                    }
-                }
                 // OpenGL context is about to change, unbind everything
                 mContext.unbindEverything();
             },
             [this](size_t index) {
-                for (auto t: mTexturesWithStreamsAttached) {
-                    if (t->hwStream->streamType == StreamType::NATIVE) {
-                        if (t->externalTexture) {
-                            glGenTextures(1, &t->externalTexture->id);
-                            t->gl.id = t->externalTexture->id;
-                        } else {
-                            glGenTextures(1, &t->gl.id);
-                        }
-                        mPlatform.attach(t->hwStream->stream, t->gl.id);
-                        mContext.updateTexImage(GL_TEXTURE_EXTERNAL_OES, t->gl.id);
-                    }
-                }
-
-                // force invalidation of all bound descriptor sets
-                decltype(mInvalidDescriptorSetBindings) changed;
-                changed.setValue((1 << MAX_DESCRIPTOR_SET_COUNT) - 1);
-                mInvalidDescriptorSetBindings |= changed;
-
                 // OpenGL context has changed, resynchronize the state with the cache
                 mContext.synchronizeStateAndCache(index);
-                DLOG(INFO) << "*** OpenGL context change : " << (index ? "protected" : "default");
+                slog.d << "*** OpenGL context change : " << (index ? "protected" : "default") << io::endl;
             });
 
     mCurrentDrawSwapChain = scDraw;
@@ -2600,7 +2560,7 @@ void OpenGLDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh,
         vb->bufferObjectsVersion = (version + 1) % kMaxVersion;
     }
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::updateIndexBuffer(
@@ -2617,7 +2577,7 @@ void OpenGLDriver::updateIndexBuffer(
 
     scheduleDestroy(std::move(p));
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::registerBufferObjectStreams(Handle<HwBufferObject> boh, BufferObjectStreamDescriptor&& streams) {
@@ -2697,7 +2657,7 @@ void OpenGLDriver::updateBufferObject(
 
     scheduleDestroy(std::move(bd));
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::updateBufferObjectUnsynchronized(
@@ -2744,7 +2704,7 @@ retry:
             scheduleDestroy(std::move(bd));
         }
     }
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 #endif
 }
 
@@ -2794,7 +2754,7 @@ void OpenGLDriver::generateMipmaps(Handle<HwTexture> th) {
 
     glGenerateMipmap(t->gl.target);
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::setTextureData(GLTexture const* t, uint32_t level,
@@ -2903,7 +2863,7 @@ void OpenGLDriver::setTextureData(GLTexture const* t, uint32_t level,
 
     scheduleDestroy(std::move(p));
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::setCompressedTextureData(GLTexture const* t, uint32_t level,
@@ -2989,7 +2949,7 @@ void OpenGLDriver::setCompressedTextureData(GLTexture const* t, uint32_t level,
 
     scheduleDestroy(std::move(p));
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::setupExternalImage2(Platform::ExternalImageHandleRef image) {
@@ -3031,7 +2991,6 @@ void OpenGLDriver::attachStream(GLTexture* t, GLStream* hwStream) noexcept {
     switch (hwStream->streamType) {
         case StreamType::NATIVE:
             mPlatform.attach(hwStream->stream, t->gl.id);
-            mContext.updateTexImage(GL_TEXTURE_EXTERNAL_OES, t->gl.id);
             break;
         case StreamType::ACQUIRED:
             break;
@@ -3060,12 +3019,7 @@ void OpenGLDriver::detachStream(GLTexture* t) noexcept {
             break;
     }
 
-    if (t->externalTexture) {
-        glGenTextures(1, &t->externalTexture->id);
-        t->gl.id = t->externalTexture->id;
-    } else {
-        glGenTextures(1, &t->gl.id);
-    }
+    glGenTextures(1, &t->gl.id);
 
     t->hwStream = nullptr;
 }
@@ -3089,14 +3043,8 @@ void OpenGLDriver::replaceStream(GLTexture* texture, GLStream* newStream) noexce
 
     switch (newStream->streamType) {
         case StreamType::NATIVE:
-            if (texture->externalTexture) {
-                glGenTextures(1, &texture->externalTexture->id);
-                texture->gl.id = texture->externalTexture->id;
-            } else {
-                glGenTextures(1, &texture->gl.id);
-            }
+            glGenTextures(1, &texture->gl.id);
             mPlatform.attach(newStream->stream, texture->gl.id);
-            mContext.updateTexImage(GL_TEXTURE_EXTERNAL_OES, texture->gl.id);
             break;
         case StreamType::ACQUIRED:
             // Just re-use the old texture id.
@@ -3152,7 +3100,7 @@ void OpenGLDriver::beginRenderPass(Handle<HwRenderTarget> rth,
     TargetBufferFlags discardFlags = params.flags.discardStart & rt->targets;
 
     GLuint const fbo = gl.bindFramebuffer(GL_FRAMEBUFFER, rt->gl.fbo);
-    CHECK_GL_FRAMEBUFFER_STATUS(GL_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_FRAMEBUFFER)
 
     // each render-pass starts with a disabled scissor
     gl.disable(GL_SCISSOR_TEST);
@@ -3164,7 +3112,7 @@ void OpenGLDriver::beginRenderPass(Handle<HwRenderTarget> rth,
         if (attachmentCount) {
             gl.procs.invalidateFramebuffer(GL_FRAMEBUFFER, attachmentCount, attachments.data());
         }
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
     } else {
         // It's important to clear the framebuffer before drawing, as it resets
         // the fb to a known state (resets fb compression and possibly other things).
@@ -3251,7 +3199,7 @@ void OpenGLDriver::endRenderPass(int) {
             if (attachmentCount) {
                 gl.procs.invalidateFramebuffer(GL_FRAMEBUFFER, attachmentCount, attachments.data());
             }
-           CHECK_GL_ERROR()
+           CHECK_GL_ERROR(utils::slog.e)
         }
     }
 
@@ -3297,13 +3245,13 @@ void OpenGLDriver::resolvePass(ResolveAction action, GLRenderTarget const* rt,
         gl.bindFramebuffer(GL_READ_FRAMEBUFFER, read);
         gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, draw);
 
-        CHECK_GL_FRAMEBUFFER_STATUS(GL_READ_FRAMEBUFFER)
-        CHECK_GL_FRAMEBUFFER_STATUS(GL_DRAW_FRAMEBUFFER)
+        CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)
+        CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)
 
         gl.disable(GL_SCISSOR_TEST);
         glBlitFramebuffer(0, 0, (GLint)rt->width, (GLint)rt->height,
                 0, 0, (GLint)rt->width, (GLint)rt->height, mask, GL_NEAREST);
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
     }
 #endif
 }
@@ -3400,8 +3348,8 @@ void OpenGLDriver::pushGroupMarker(char const* string) {
 #endif
 
 #if DEBUG_GROUP_MARKER_LEVEL & DEBUG_GROUP_MARKER_BACKEND
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, string);
+    SYSTRACE_CONTEXT();
+    SYSTRACE_NAME_BEGIN(string);
 #endif
 #endif
 }
@@ -3417,8 +3365,8 @@ void OpenGLDriver::popGroupMarker(int) {
 #endif
 
 #if DEBUG_GROUP_MARKER_LEVEL & DEBUG_GROUP_MARKER_BACKEND
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CONTEXT();
+    SYSTRACE_NAME_END();
 #endif
 #endif
 }
@@ -3482,7 +3430,7 @@ void OpenGLDriver::readPixels(Handle<HwRenderTarget> src,
         if (buffer) {
             gl.bindFramebuffer(GL_FRAMEBUFFER, s->gl.fbo_read ? s->gl.fbo_read : s->gl.fbo);
             glReadPixels(GLint(x), GLint(y), GLint(width), GLint(height), glFormat, glType, buffer);
-            CHECK_GL_ERROR()
+            CHECK_GL_ERROR(utils::slog.e)
 
             // now we need to flip the buffer vertically to match our API
             size_t const stride = p.stride ? p.stride : width;
@@ -3514,7 +3462,7 @@ void OpenGLDriver::readPixels(Handle<HwRenderTarget> src,
     glBufferData(GL_PIXEL_PACK_BUFFER, pboSize, nullptr, GL_STATIC_DRAW);
     glReadPixels(GLint(x), GLint(y), GLint(width), GLint(height), glFormat, glType, nullptr);
     gl.bindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 
     // we're forced to make a copy on the heap because otherwise it deletes std::function<> copy
     // constructor.
@@ -3554,7 +3502,7 @@ void OpenGLDriver::readPixels(Handle<HwRenderTarget> src,
         glDeleteBuffers(1, &pbo);
         scheduleDestroy(std::move(p));
         delete pUserBuffer;
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
     });
 #endif
 }
@@ -3579,7 +3527,7 @@ void OpenGLDriver::readBufferSubData(BufferObjectHandle boh,
         glCopyBufferSubData(bo->gl.binding, GL_PIXEL_PACK_BUFFER, offset, 0, size);
         gl.bindBuffer(bo->gl.binding, 0);
         gl.bindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
 
         // then, we schedule a mapBuffer of the PBO later, once the fence has signaled
         auto* pUserBuffer = new BufferDescriptor(std::move(p));
@@ -3596,7 +3544,7 @@ void OpenGLDriver::readBufferSubData(BufferObjectHandle boh,
             glDeleteBuffers(1, &pbo);
             scheduleDestroy(std::move(p));
             delete pUserBuffer;
-            CHECK_GL_ERROR()
+            CHECK_GL_ERROR(utils::slog.e)
         });
     } else {
         gl.bindBuffer(bo->gl.binding, bo->gl.id);
@@ -3609,7 +3557,7 @@ void OpenGLDriver::readBufferSubData(BufferObjectHandle boh,
         }
         gl.bindBuffer(bo->gl.binding, 0);
         scheduleDestroy(std::move(p));
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
     }
 #endif
 }
@@ -3639,7 +3587,7 @@ void OpenGLDriver::whenFrameComplete(const std::function<void()>& fn) noexcept {
 void OpenGLDriver::whenGpuCommandsComplete(const std::function<void()>& fn) noexcept {
     GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
     mGpuCommandCompleteOps.emplace_back(sync, fn);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::executeGpuCommandsCompleteOps() noexcept {
@@ -3737,7 +3685,7 @@ void OpenGLDriver::endFrame(UTILS_UNUSED uint32_t frameId) {
     gl.depthFunc(GL_LESS);
     gl.disable(GL_SCISSOR_TEST);
 #endif
-    //FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glFinish");
+    //SYSTRACE_NAME("glFinish");
     //glFinish();
     mPlatform.endFrame(frameId);
     insertEventMarker("endFrame");
@@ -3759,7 +3707,8 @@ void OpenGLDriver::updateDescriptorSetTexture(
         TextureHandle th,
         SamplerParams params) {
     GLDescriptorSet* ds = handle_cast<GLDescriptorSet*>(dsh);
-    ds->update(mContext, mHandleAllocator, binding, th, params);
+    GLTexture* t = th ? handle_cast<GLTexture*>(th) : nullptr;
+    ds->update(mContext, binding, t, params);
 }
 
 void OpenGLDriver::flush(int) {
@@ -3857,7 +3806,7 @@ void OpenGLDriver::clearWithRasterPipe(TargetBufferFlags clearFlags,
         }
     }
 
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void OpenGLDriver::resolve(
@@ -3968,7 +3917,7 @@ void OpenGLDriver::blit(
         case SamplerType::SAMPLER_EXTERNAL:
             break;
     }
-    CHECK_GL_FRAMEBUFFER_STATUS(GL_DRAW_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)
 
     gl.bindFramebuffer(GL_READ_FRAMEBUFFER, fbo[1]);
     switch (s->target) {
@@ -3994,14 +3943,14 @@ void OpenGLDriver::blit(
         case SamplerType::SAMPLER_EXTERNAL:
             break;
     }
-    CHECK_GL_FRAMEBUFFER_STATUS(GL_READ_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)
 
     gl.disable(GL_SCISSOR_TEST);
     glBlitFramebuffer(
             srcOrigin.x, srcOrigin.y, srcOrigin.x + size.x, srcOrigin.y + size.y,
             dstOrigin.x, dstOrigin.y, dstOrigin.x + size.x, dstOrigin.y + size.y,
             mask, GL_NEAREST);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 
     gl.unbindFramebuffer(GL_DRAW_FRAMEBUFFER);
     gl.unbindFramebuffer(GL_READ_FRAMEBUFFER);
@@ -4064,15 +4013,15 @@ void OpenGLDriver::blitDEPRECATED(TargetBufferFlags buffers,
     gl.bindFramebuffer(GL_READ_FRAMEBUFFER, s->gl.fbo);
     gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, d->gl.fbo);
 
-    CHECK_GL_FRAMEBUFFER_STATUS(GL_READ_FRAMEBUFFER)
-    CHECK_GL_FRAMEBUFFER_STATUS(GL_DRAW_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)
 
     gl.disable(GL_SCISSOR_TEST);
     glBlitFramebuffer(
             srcRect.left, srcRect.bottom, srcRect.right(), srcRect.top(),
             dstRect.left, dstRect.bottom, dstRect.right(), dstRect.top(),
             GL_COLOR_BUFFER_BIT, glFilterMode);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 #endif
 }
 
@@ -4199,9 +4148,9 @@ void OpenGLDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
 #endif
 
 #if FILAMENT_ENABLE_MATDBG
-    CHECK_GL_ERROR_NON_FATAL()
+    CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
 #else
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 #endif
 }
 
@@ -4231,9 +4180,9 @@ void OpenGLDriver::draw2GLES2(uint32_t indexOffset, uint32_t indexCount, uint32_
             reinterpret_cast<const void*>(indexOffset << rp->gl.indicesShift));
 
 #if FILAMENT_ENABLE_MATDBG
-    CHECK_GL_ERROR_NON_FATAL()
+    CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
 #else
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 #endif
 }
 
@@ -4283,9 +4232,9 @@ void OpenGLDriver::dispatchCompute(Handle<HwProgram> program, uint3 workGroupCou
 #endif // BACKEND_OPENGL_LEVEL_GLES31
 
 #if FILAMENT_ENABLE_MATDBG
-    CHECK_GL_ERROR_NON_FATAL()
+    CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
 #else
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 #endif
 }
 

filament/backend/src/opengl/OpenGLPlatform.cpp

@@ -64,7 +64,7 @@ utils::CString OpenGLPlatform::getRendererString(Driver const* driver) {
 }
 
 void OpenGLPlatform::makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain,
-        utils::Invocable<void()>, utils::Invocable<void(size_t)>) {
+        utils::Invocable<void()>, utils::Invocable<void(size_t)>) noexcept {
     makeCurrent(getCurrentContextType(), drawSwapChain, readSwapChain);
 }
 

filament/backend/src/opengl/OpenGLProgram.cpp

@@ -25,13 +25,12 @@
 #include <backend/Program.h>
 #include <backend/Handle.h>
 
-#include <private/utils/Tracing.h>
-
 #include <utils/BitmaskEnum.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/Log.h>
+#include <utils/Systrace.h>
 
 #include <algorithm>
 #include <array>
@@ -97,7 +96,8 @@ OpenGLProgram::~OpenGLProgram() noexcept {
 }
 
 void OpenGLProgram::initialize(OpenGLDriver& gld) {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+
+    SYSTRACE_CALL();
 
     assert_invariant(gl.program == 0);
     assert_invariant(mToken);
@@ -122,7 +122,8 @@ void OpenGLProgram::initialize(OpenGLDriver& gld) {
  */
 void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint program,
         LazyInitializationData& lazyInitializationData) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+
+    SYSTRACE_CALL();
 
     // from the pipeline layout we compute a mapping from {set, binding} to {binding}
     // for both buffers and textures
@@ -174,31 +175,7 @@ void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint progra
                     }
                     break;
                 }
-                case DescriptorType::SAMPLER_2D_FLOAT:
-                case DescriptorType::SAMPLER_2D_INT:
-                case DescriptorType::SAMPLER_2D_UINT:
-                case DescriptorType::SAMPLER_2D_DEPTH:
-                case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-                case DescriptorType::SAMPLER_2D_ARRAY_INT:
-                case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-                case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-                case DescriptorType::SAMPLER_CUBE_FLOAT:
-                case DescriptorType::SAMPLER_CUBE_INT:
-                case DescriptorType::SAMPLER_CUBE_UINT:
-                case DescriptorType::SAMPLER_CUBE_DEPTH:
-                case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-                case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-                case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-                case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-                case DescriptorType::SAMPLER_3D_FLOAT:
-                case DescriptorType::SAMPLER_3D_INT:
-                case DescriptorType::SAMPLER_3D_UINT:
-                case DescriptorType::SAMPLER_2D_MS_FLOAT:
-                case DescriptorType::SAMPLER_2D_MS_INT:
-                case DescriptorType::SAMPLER_2D_MS_UINT:
-                case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-                case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-                case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
+                case DescriptorType::SAMPLER:
                 case DescriptorType::SAMPLER_EXTERNAL: {
                     if (!entry.name.empty()) {
                         GLint const loc = glGetUniformLocation(program, entry.name.c_str());
@@ -214,7 +191,7 @@ void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint progra
                 case DescriptorType::INPUT_ATTACHMENT:
                     break;
             }
-            CHECK_GL_ERROR()
+            CHECK_GL_ERROR(utils::slog.e)
         }
     }
 

filament/backend/src/opengl/OpenGLTimerQuery.cpp

@@ -23,13 +23,12 @@
 #include <backend/platforms/OpenGLPlatform.h>
 #include <backend/DriverEnums.h>
 
-#include <private/utils/Tracing.h>
-
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/JobSystem.h>
 #include <utils/Log.h>
 #include <utils/Mutex.h>
+#include <utils/Systrace.h>
 
 #include <atomic>
 #include <memory>
@@ -114,14 +113,14 @@ void TimerQueryNativeFactory::createTimerQuery(GLTimerQuery* tq) {
 
     tq->state = std::make_shared<GLTimerQuery::State>();
     mContext.procs.genQueries(1u, &tq->state->gl.query);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void TimerQueryNativeFactory::destroyTimerQuery(GLTimerQuery* tq) {
     assert_invariant(tq->state);
 
     mContext.procs.deleteQueries(1u, &tq->state->gl.query);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 
     tq->state.reset();
 }
@@ -131,14 +130,14 @@ void TimerQueryNativeFactory::beginTimeElapsedQuery(GLTimerQuery* tq) {
 
     tq->state->elapsed.store(int64_t(TimerQueryResult::NOT_READY), std::memory_order_relaxed);
     mContext.procs.beginQuery(GL_TIME_ELAPSED, tq->state->gl.query);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }
 
 void TimerQueryNativeFactory::endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQuery* tq) {
     assert_invariant(tq->state);
 
     mContext.procs.endQuery(GL_TIME_ELAPSED);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 
     std::weak_ptr<GLTimerQuery::State> const weak = tq->state;
 
@@ -153,7 +152,7 @@ void TimerQueryNativeFactory::endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQ
 
         GLuint available = 0;
         context.procs.getQueryObjectuiv(state->gl.query, GL_QUERY_RESULT_AVAILABLE, &available);
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
         if (!available) {
             // we need to try this one again later
             return false;
@@ -241,8 +240,8 @@ void TimerQueryFenceFactory::beginTimeElapsedQuery(GLTimerQuery* tq) {
         if (state) {
             platform.waitFence(fence, FENCE_WAIT_FOR_EVER);
             state->then = clock::now().time_since_epoch().count();
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-            FILAMENT_TRACING_ASYNC_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, "OpenGLTimerQueryFence", intptr_t(state.get()));
+            SYSTRACE_CONTEXT();
+            SYSTRACE_ASYNC_BEGIN("OpenGLTimerQueryFence", intptr_t(state.get()));
         }
         platform.destroyFence(fence);
     });
@@ -258,8 +257,8 @@ void TimerQueryFenceFactory::endTimeElapsedQuery(OpenGLDriver&, GLTimerQuery* tq
             platform.waitFence(fence, FENCE_WAIT_FOR_EVER);
             int64_t const now = clock::now().time_since_epoch().count();
             state->elapsed.store(now - state->then, std::memory_order_relaxed);
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-            FILAMENT_TRACING_ASYNC_END(FILAMENT_TRACING_CATEGORY_FILAMENT, "OpenGLTimerQueryFence", intptr_t(state.get()));
+            SYSTRACE_CONTEXT();
+            SYSTRACE_ASYNC_END("OpenGLTimerQueryFence", intptr_t(state.get()));
         }
         platform.destroyFence(fence);
     });

filament/backend/src/opengl/ShaderCompilerService.cpp

@@ -23,22 +23,20 @@
 #include "OpenGLDriver.h"
 
 #include <iterator>
-#include <optional>
 #include <private/backend/BackendUtils.h>
 
 #include <backend/DriverEnums.h>
 #include <backend/Program.h>
 
-#include <private/utils/Tracing.h>
-
+#include <utils/compiler.h>
 #include <utils/CString.h>
+#include <utils/debug.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/JobSystem.h>
-#include <utils/Logger.h>
-#include <utils/Panic.h>
-#include <utils/compiler.h>
-#include <utils/debug.h>
+#include <utils/Log.h>
 #include <utils/ostream.h>
+#include <utils/Panic.h>
+#include <utils/Systrace.h>
 
 #include <algorithm>
 #include <array>
@@ -65,9 +63,9 @@ static std::string to_string(bool const b) { return b ? "true" : "false"; }
 static std::string to_string(int const i) { return std::to_string(i); }
 static std::string to_string(float const f) { return "float(" + std::to_string(f) + ")"; }
 
-static void logCompilationError(ShaderStage shaderType, const char* name, GLuint shaderId,
-        CString const& sourceCode) noexcept;
-static void logProgramLinkError(char const* name, GLuint program) noexcept;
+static void logCompilationError(io::ostream& out, ShaderStage shaderType, const char* name,
+        GLuint shaderId, CString const& sourceCode) noexcept;
+static void logProgramLinkError(io::ostream& out, char const* name, GLuint program) noexcept;
 
 static void process_GOOGLE_cpp_style_line_directive(OpenGLContext const& context, char* source,
         size_t len) noexcept;
@@ -111,33 +109,17 @@ struct ShaderCompilerService::OpenGLProgramToken : ProgramToken {
         cond.wait(l, [this] { return signaled; });
     }
 
-    // This is invoked upon token completion, which occurs after a successful `gl.program`
-    // population or upon cancellation. In either scenario, the callback handle must be submitted
-    // to notify the caller that resource loading has concluded.
-    void trySubmittingCallback() noexcept {
-        if (handle) {
-            compiler.submitCallbackHandle(*handle);
-            handle = std::nullopt;
-        }
-    }
-
-    std::optional<CallbackManager::Handle> handle{};
-
-    // Only valid when the blob functions are provided by users. The validity of this variable
-    // doesn't guarantee that the program was created from the cache blob.
+    CallbackManager::Handle handle{};
     BlobCacheKey key;
 
     // Used for the `THREAD_POOL` mode.
     mutable Mutex lock;
     mutable Condition cond;
     bool signaled = false;
-
-    // Indicate this program was created from the cache blob.
-    bool retrievedFromBlobCache = false;
 };
 
 ShaderCompilerService::OpenGLProgramToken::~OpenGLProgramToken() {
-    trySubmittingCallback();
+    compiler.submitCallbackHandle(handle);
 }
 
 /* static */ void ShaderCompilerService::setUserData(const program_token_t& token,
@@ -265,7 +247,6 @@ ShaderCompilerService::program_token_t ShaderCompilerService::createProgram(
     // Try retrieving the cached program blob if available.
     token->gl.program = mBlobCache.retrieve(&token->key, mDriver.mPlatform, program);
     if (token->gl.program) {
-        token->retrievedFromBlobCache = true;
         return token;
     }
 
@@ -344,15 +325,12 @@ GLuint ShaderCompilerService::getProgram(program_token_t& token) {
 
     assert_invariant(token);// This function should be called when the token is still alive.
 
-    // Finalize any pending shader compilation tasks only when the token was created without cache.
-    if (!token->retrievedFromBlobCache) {
-        if (token->compiler.mMode == Mode::THREAD_POOL) {
-            auto const job = token->compiler.mCompilerThreadPool.dequeue(token);
-            if (!job) {
-                // It's likely that the job was already completed. But it may be still being
-                // executed at this moment. Just try waiting for it to avoid a race.
-                token->wait();
-            }
+    if (token->compiler.mMode == Mode::THREAD_POOL) {
+        auto const job = token->compiler.mCompilerThreadPool.dequeue(token);
+        if (!job) {
+            // It's likely that the job was already completed. But it may be still being
+            // executed at this moment. Just try waiting for it to avoid a race.
+            token->wait();
         }
     }
 
@@ -360,7 +338,7 @@ GLuint ShaderCompilerService::getProgram(program_token_t& token) {
 
     // Cleanup the token.
     token->compiler.cancelTickOp(token);
-    token = nullptr; // This will try submitting a callback handle to the callback manager.
+    token = nullptr;// This will submit a callback condition (handle) to the callback manager.
 }
 
 void ShaderCompilerService::tick() {
@@ -389,7 +367,7 @@ void ShaderCompilerService::notifyWhenAllProgramsAreReady(
 
 GLuint ShaderCompilerService::initialize(program_token_t& token) {
 
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     assert_invariant(token);// This function should be called when the token is still alive.
 
@@ -413,7 +391,7 @@ GLuint ShaderCompilerService::initialize(program_token_t& token) {
 
     // Cleanup the token.
     token->compiler.cancelTickOp(token);
-    token = nullptr;
+    token = nullptr;// This will submit a callback condition (handle) to the callback manager.
 
     return program;
 }
@@ -443,9 +421,8 @@ void ShaderCompilerService::ensureTokenIsReady(program_token_t const& token) {
             // just log warnings here instead of repeatedly checking compile status. If this turns
             // out to be a real issue later, we would need to consider doing the canonical way.
             if (!isCompileCompleted(token)) {
-                LOG(WARNING)
-                        << "Shader compilation for OpenGL program " << token->name.c_str_safe()
-                        << " is not completed yet. The following program link may not succeed.";
+                slog.w << "Shader compilation for OpenGL program " << token->name.c_str_safe()
+                       << " is not completed yet. The following program link may not succeed.";
             }
 
             linkProgram(mDriver.getContext(), token);
@@ -477,8 +454,8 @@ void ShaderCompilerService::runAtNextTick(CompilerPriorityQueue priority,
             });
     ops.emplace(pos, priority, token, std::move(job));
 
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "ShaderCompilerService Jobs", mRunAtNextTickOps.size());
+    SYSTRACE_CONTEXT();
+    SYSTRACE_VALUE32("ShaderCompilerService Jobs", mRunAtNextTickOps.size());
 }
 
 bool ShaderCompilerService::cancelTickOp(program_token_t const& token) noexcept {
@@ -491,8 +468,8 @@ bool ShaderCompilerService::cancelTickOp(program_token_t const& token) noexcept
         ops.erase(pos);
         return true;
     }
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "ShaderCompilerService Jobs", ops.size());
+    SYSTRACE_CONTEXT();
+    SYSTRACE_VALUE32("ShaderCompilerService Jobs", ops.size());
     return false;
 }
 
@@ -508,15 +485,15 @@ void ShaderCompilerService::executeTickOps() noexcept {
             ++it;
         }
     }
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "ShaderCompilerService Jobs", ops.size());
+    SYSTRACE_CONTEXT();
+    SYSTRACE_VALUE32("ShaderCompilerService Jobs", ops.size());
 }
 
 /* static */ void ShaderCompilerService::compileShaders(OpenGLContext& context,
         Program::ShaderSource shadersSource,
         FixedCapacityVector<Program::SpecializationConstant> const& specializationConstants,
         bool multiview, program_token_t const& token) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     auto const appendSpecConstantString = +[](std::string& s, Program::SpecializationConstant const& sc) {
         s += "#define SPIRV_CROSS_CONSTANT_ID_" + std::to_string(sc.id) + ' ';
@@ -639,7 +616,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
 }
 
 /* static */ void ShaderCompilerService::checkCompileStatus(program_token_t const& token) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     UTILS_NOUNROLL
     for (size_t i = 0; i < Program::SHADER_TYPE_COUNT; i++) {
@@ -655,13 +632,14 @@ void ShaderCompilerService::executeTickOps() noexcept {
         }
         // Something went wrong. Log the error message.
         const ShaderStage type = static_cast<ShaderStage>(i);
-        logCompilationError(type, token->name.c_str_safe(), shader, token->shaderSourceCode[i]);
+        logCompilationError(slog.e, type, token->name.c_str_safe(), shader,
+                token->shaderSourceCode[i]);
     }
 }
 
 /* static */ void ShaderCompilerService::linkProgram(OpenGLContext const& context,
         program_token_t const& token) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     // Shader compilation should be completed by now. Check the status and log errors on failure.
     checkCompileStatus(token);
@@ -680,7 +658,6 @@ void ShaderCompilerService::executeTickOps() noexcept {
     }
     glLinkProgram(program);
     token->gl.program = program;
-    token->trySubmittingCallback();
 }
 
 /* static */ bool ShaderCompilerService::isLinkCompleted(program_token_t const& token) noexcept {
@@ -698,7 +675,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
 
 /* static */ bool ShaderCompilerService::checkLinkStatusAndCleanupShaders(
         program_token_t const& token) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
     assert_invariant(token->gl.program);
 
     bool linked = true;
@@ -707,7 +684,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
     glGetProgramiv(token->gl.program, GL_LINK_STATUS, &status);
     if (UTILS_UNLIKELY(status != GL_TRUE)) {
         // Something went wrong. Log the error message.
-        logProgramLinkError(token->name.c_str_safe(), token->gl.program);
+        logProgramLinkError(slog.e, token->name.c_str_safe(), token->gl.program);
         linked = false;
     }
     // No need to keep the shaders around regardless of the result of the program linking.
@@ -757,7 +734,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
 // ------------------------------------------------------------------------------------------------
 
 UTILS_NOINLINE
-/* static */ void logCompilationError(ShaderStage shaderType, const char* name,
+/* static */ void logCompilationError(io::ostream& out, ShaderStage shaderType, const char* name,
         GLuint const shaderId, UTILS_UNUSED_IN_RELEASE CString const& sourceCode) noexcept {
 
     { // scope for the temporary string storage
@@ -779,9 +756,8 @@ UTILS_NOINLINE
         CString infoLog(length);
         glGetShaderInfoLog(shaderId, length, nullptr, infoLog.data());
 
-        LOG(ERROR) << "Compilation error in " << to_string(shaderType) << " shader \"" << name
-                   << "\":";
-        LOG(ERROR) << "\"" << infoLog.c_str() << "\"";
+        out << "Compilation error in " << to_string(shaderType) << " shader \"" << name << "\":\n"
+            << "\"" << infoLog.c_str() << "\"" << io::endl;
     }
 
 #ifndef NDEBUG
@@ -796,25 +772,26 @@ UTILS_NOINLINE
         } else {
             line = shader.substr(start, end - start);
         }
-        LOG(ERROR) << lc++ << ":   " << line.c_str();
+        out << lc++ << ":   " << line.c_str() << '\n';
         if (end == std::string::npos) {
             break;
         }
         start = end + 1;
     }
-    LOG(ERROR) << "";
+    out << io::endl;
 #endif
 }
 
 UTILS_NOINLINE
-/* static */ void logProgramLinkError(char const* name, GLuint program) noexcept {
+/* static */ void logProgramLinkError(io::ostream& out, char const* name, GLuint program) noexcept {
     GLint length = 0;
     glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length);
 
     CString infoLog(length);
     glGetProgramInfoLog(program, length, nullptr, infoLog.data());
 
-    LOG(ERROR) << "Link error in \"" << name << "\":\n" << "\"" << infoLog.c_str() << "\"";
+    out << "Link error in \"" << name << "\":\n"
+        << "\"" << infoLog.c_str() << "\"" << io::endl;
 }
 
 // If usages of the Google-style line directive are present, remove them, as some