Quick fix for descriptor set types.

Minor fixes to branch hacks. Use unfilterable float instead of float (Might need to vary this depending on eventual filtering bit)
Filament's compareMode function should be checked before using any of the comparison related enums it provides. This also lets us use the descriptor now.
2025-05-15 15:33:47 -04:00 · 2025-05-15 15:33:36 -04:00 · 2025-05-15 15:32:19 -04:00 · 2025-05-14 20:13:42 -04:00 · 2025-05-14 20:13:42 -04:00 · 2025-05-14 15:39:16 -04:00
518 changed files with 21357 additions and 30294 deletions
@@ -57,7 +57,7 @@ SpaceBeforeInheritanceColon: true
 SpaceBeforeParens: ControlStatements
 SpaceBeforeRangeBasedForLoopColon: false
 SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
+SpacesBeforeTrailingComments: 0
 SpacesInAngles: false
 SpacesInCStyleCastParentheses: false
 SpacesInContainerLiterals: false
@@ -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 }}
@@ -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
@@ -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:
@@ -109,9 +110,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 +121,20 @@ 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
+        id: mesa-cache
        uses: actions/cache@v4
        with:
          path: mesa
          key: ${{ runner.os }}-mesa-deps-2-${{ vars.MESA_VERSION }}
      - name: Prerequisites
+        id: prereqs
        run: |
          bash build/common/get-mesa.sh
          pip install tifffile numpy
      - name: 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
@@ -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:
@@ -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
@@ -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.

@@ -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
 # ==================================================================================================
@@ -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: sampler now export their type in the material binary [⚠️ **New Material Version**]
@@ -31,7 +31,7 @@ repositories {
 }

 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.61.1'
+    implementation 'com.google.android.filament:filament-android:1.59.5'
 }
 ```

@@ -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.1'
+pod 'Filament', '~> 1.59.5'
 ```

 ## Documentation
@@ -7,28 +7,10 @@ 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.
-
+- `ColorGrading::Builder::toneMapper` now takes a `shared_ptr<ToneMapper>`

 ## v1.59.5

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

 #include <filament/ColorGrading.h>
 #include <filament/ToneMapper.h>
+#include <memory>

 #include <math/vec3.h>
 #include <math/vec4.h>
@@ -67,8 +68,9 @@ extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_ColorGrading_nBuilderToneMapper(JNIEnv*, jclass,
        jlong nativeBuilder, jlong toneMapper_) {
    ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
-    const ToneMapper* toneMapper = (const ToneMapper*) toneMapper_;
-    builder->toneMapper(toneMapper);
+    ToneMapper* toneMapper = reinterpret_cast<ToneMapper*>(toneMapper_);
+    std::shared_ptr<ToneMapper> toneMapperCopy(toneMapper->clone());
+    builder->toneMapper(toneMapperCopy);
 }

 #pragma clang diagnostic push
@@ -214,9 +214,9 @@ public class ColorGrading {
         *
         * The default tone mapping operator is {@link ToneMapper.ACESLegacy}.
         *
-         * The specified tone mapper must have a lifecycle that exceeds the lifetime of
-         * this builder. Since the build(Engine&) method is synchronous, it is safe to
-         * delete the tone mapper object after that finishes executing.
+         * The copy of the specified tone mapper is set to this builder. It is safe to delete
+         * the original tone mapper object while the copied one is held by the built ColorGrading
+         * object.
         *
         * @param toneMapper The tone mapping operator to apply to the HDR color buffer
         *
@@ -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;
-
    }

    /**
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.61.1
+VERSION_NAME=1.59.5

 POM_DESCRIPTION=Real-time physically based rendering engine for Android.

@@ -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/common/versions | grep GITHUB_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 {
@@ -41,8 +41,6 @@ for cmd in "${NEEDED_PYTHON_DEPS[@]}"; do
 done
 deactivate

-LOCAL_PKG_CONFIG_PATH=
-
 # Install system deps
 if [[ "$OS_NAME" == "Linux" ]]; then
    if [[ "$GITHUB_WORKFLOW" ]]; then
@@ -84,9 +82,6 @@ elif [[ "$OS_NAME" == "Darwin" ]]; then
        fi
    fi
    HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=true brew install autoconf automake libx11 libxext libxrandr llvm@${LLVM_VERSION} ninja meson pkg-config libxshmfence
-
-    # For reasons unknown, this is necessary for pkg-config to find homebrew's packages
-    LOCAL_PKG_CONFIG_PATH="/opt/homebrew/lib/pkgconfig:$PKG_CONFIG_PATH"
 fi # [[ "$OS_NAME" == x ]]

 LOCAL_LDFLAGS=${LDFLAGS}
@@ -139,11 +134,9 @@ fi
 # -Dgallium-drivers=swrast  => builds GL software rasterizer
 # -Dvulkan-drivers=swrast   => builds VK software rasterizer
 # -Dgallium-drivers=llvmpipe is needed for GL >= 4.1 pipe-screen (see src/gallium/auxiliary/target-helpers/inline_sw_helper.h)
-PKG_CONFIG_PATH=${LOCAL_PKG_CONFIG_PATH} PATH=${LOCAL_PATH} \
-CXX=${LOCAL_CXX} CC=${LOCAL_CC} LDFLAGS=${LOCAL_LDFLAGS} CPPFLAGS=${LOCAL_CPPFLAGS} \
+CXX=${LOCAL_CXX} CC=${LOCAL_CC} PATH=${LOCAL_PATH} LDFLAGS=${LOCAL_LDFLAGS} CPPFLAGS=${LOCAL_CPPFLAGS} \
   meson setup --wipe builddir/ -Dprefix="${MESA_DIR}/out" -Dglx=xlib -Dosmesa=true -Dgallium-drivers=llvmpipe,swrast -Dvulkan-drivers=swrast
-PKG_CONFIG_PATH=${LOCAL_PKG_CONFIG_PATH} PATH=${LOCAL_PATH} \
-CXX=${LOCAL_CXX} CC=${LOCAL_CC} LDFLAGS=${LOCAL_LDFLAGS} CPPFLAGS=${LOCAL_CPPFLAGS} \
+CXX=${LOCAL_CXX} CC=${LOCAL_CC} PATH=${LOCAL_PATH} LDFLAGS=${LOCAL_LDFLAGS} CPPFLAGS=${LOCAL_CPPFLAGS} \
   meson install -C builddir/

 # Disable python venv
@@ -204,10 +204,9 @@
      "license": "Apache-2.0"
    },
    "node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
-      "license": "MIT",
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
      "dependencies": {
        "balanced-match": "^1.0.0",
        "concat-map": "0.0.1"
@@ -410,9 +409,9 @@
      "integrity": "sha512-Nik3Sc0ncrMK4UUdXQmAnRtzmNQTAAXmXIopizwZ1W1t8QmfJj+zL4OA2I7XPTPW5z5TDqv4hRo/JzouDJnX3A=="
    },
    "brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
      "requires": {
        "balanced-match": "^1.0.0",
        "concat-map": "0.0.1"
@@ -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% ^
@@ -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
@@ -19,7 +19,6 @@
    - [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)
@@ -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.
@@ -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)
@@ -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
@@ -180,11 +180,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,38 +254,16 @@ if (FILAMENT_SUPPORTS_WEBGPU)
    list(APPEND SRCS
            include/backend/platforms/WebGPUPlatform.h
            src/webgpu/platform/WebGPUPlatform.cpp
-            src/webgpu/SpdMipmapGenerator/SpdMipmapGenerator.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/WebGPUTimerQuery.cpp
-            src/webgpu/WebGPUTimerQuery.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)
@@ -315,6 +290,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
 # ==================================================================================================
@@ -406,10 +387,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)
@@ -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;
@@ -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;
@@ -25,11 +25,12 @@
 #include <backend/PresentCallable.h>

 #include <utils/BitmaskEnum.h>
-#include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/Invocable.h>
-#include <utils/StaticString.h>
+#include <utils/compiler.h>
 #include <utils/debug.h>
+#include <utils/ostream.h>
+#include <utils/StaticString.h>

 #include <math/vec4.h>

@@ -41,10 +42,6 @@
 #include <stddef.h>
 #include <stdint.h>

-namespace utils::io {
-class ostream;
-} // namespace utils::io
-
 /**
 * Types and enums used by filament's driver.
 *
@@ -163,7 +160,7 @@ enum class TimerQueryResult : int8_t {
    AVAILABLE = 1,  // result is available
 };

-constexpr std::string_view to_string(Backend const backend) noexcept {
+ constexpr std::string_view to_string(Backend const backend) noexcept {
    switch (backend) {
        case Backend::NOOP:
            return "Noop";
@@ -177,6 +174,7 @@ constexpr std::string_view to_string(Backend const backend) noexcept {
            return "WebGPU";
        case Backend::DEFAULT:
            return "Default";
+            break;
    }
    return "Unknown";
 }
@@ -228,7 +226,7 @@ enum class ShaderStageFlags : uint8_t {
    ALL_SHADER_STAGE_FLAGS = VERTEX | FRAGMENT | COMPUTE
 };

-constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage type) noexcept {
+ constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage type) noexcept {
    switch (type) {
        case ShaderStage::VERTEX:
            return bool(uint8_t(flags) & uint8_t(ShaderStageFlags::VERTEX));
@@ -248,7 +246,7 @@ enum class TextureType : uint8_t {
    DEPTH_STENCIL
 };

-constexpr std::string_view to_string(TextureType type) noexcept {
+ constexpr std::string_view to_string(TextureType type) noexcept {
    switch (type) {
        case TextureType::FLOAT:            return "FLOAT";
        case TextureType::INT:              return "INT";
@@ -285,155 +283,36 @@ constexpr std::string_view to_string(TextureType type) noexcept {
     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 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 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:
+             return true;
+         default: ;
+     }
+     return false;
+ }

 constexpr std::string_view to_string(DescriptorType type) noexcept {
    #define DESCRIPTOR_TYPE_CASE(TYPE)  case DescriptorType::TYPE: return #TYPE;
@@ -457,12 +336,6 @@ constexpr std::string_view to_string(DescriptorType type) noexcept {
        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)
@@ -495,12 +368,18 @@ struct DescriptorSetLayoutBinding {
    DescriptorFlags flags = DescriptorFlags::NONE;
    uint16_t count = 0;

+    //  TODO: uncomment when needed.  Note that this class is used as hash key.  We need to ensure
+    //  no uninitialized padding bytes.
+    //    uint8_t externalSamplerDataIndex = EXTERNAL_SAMPLER_DATA_INDEX_UNUSED;
+
    friend bool operator==(DescriptorSetLayoutBinding const& lhs,
            DescriptorSetLayoutBinding const& rhs) noexcept {
        return lhs.type == rhs.type &&
               lhs.flags == rhs.flags &&
               lhs.count == rhs.count &&
               lhs.stageFlags == rhs.stageFlags;
+//               lhs.stageFlags == rhs.stageFlags &&
+//               lhs.externalSamplerDataIndex == rhs.externalSamplerDataIndex;
    }
 };

@@ -526,7 +405,7 @@ enum class TargetBufferFlags : uint32_t {
    ALL = COLOR_ALL | DEPTH | STENCIL       //!< Color, depth and stencil buffer selected.
 };

-constexpr TargetBufferFlags getTargetBufferFlagsAt(size_t index) noexcept {
+ 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;
@@ -767,15 +646,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
@@ -1066,7 +936,7 @@ enum class TextureSwizzle : uint8_t {
 };

 //! returns whether this format a depth format
-constexpr bool isDepthFormat(TextureFormat format) noexcept {
+ constexpr bool isDepthFormat(TextureFormat format) noexcept {
    switch (format) {
        case TextureFormat::DEPTH32F:
        case TextureFormat::DEPTH24:
@@ -1079,7 +949,7 @@ constexpr bool isDepthFormat(TextureFormat format) noexcept {
    }
 }

-constexpr bool isStencilFormat(TextureFormat format) noexcept {
+ constexpr bool isStencilFormat(TextureFormat format) noexcept {
    switch (format) {
        case TextureFormat::STENCIL8:
        case TextureFormat::DEPTH24_STENCIL8:
@@ -1090,7 +960,7 @@ constexpr bool isStencilFormat(TextureFormat format) noexcept {
    }
 }

-constexpr bool isColorFormat(TextureFormat format) noexcept {
+ constexpr bool isColorFormat(TextureFormat format) noexcept {
    switch (format) {
        // Standard color formats
        case TextureFormat::R8:
@@ -1117,7 +987,7 @@ constexpr bool isColorFormat(TextureFormat format) noexcept {
    return false;
 }

-constexpr bool isUnsignedIntFormat(TextureFormat format) {
+ constexpr bool isUnsignedIntFormat(TextureFormat format) {
    switch (format) {
        case TextureFormat::R8UI:
        case TextureFormat::R16UI:
@@ -1138,7 +1008,7 @@ constexpr bool isUnsignedIntFormat(TextureFormat format) {
    }
 }

-constexpr bool isSignedIntFormat(TextureFormat format) {
+ constexpr bool isSignedIntFormat(TextureFormat format) {
    switch (format) {
        case TextureFormat::R8I:
        case TextureFormat::R16I:
@@ -1160,26 +1030,26 @@ constexpr bool isSignedIntFormat(TextureFormat format) {
 }

 //! returns whether this format is a compressed format
-constexpr bool isCompressedFormat(TextureFormat format) noexcept {
+ 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 {
+ 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 {
+ constexpr bool isS3TCCompression(TextureFormat format) noexcept {
    return format >= TextureFormat::DXT1_RGB && format <= TextureFormat::DXT5_SRGBA;
 }

-constexpr bool isS3TCSRGBCompression(TextureFormat format) noexcept {
+ 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 {
+ constexpr bool isRGTCCompression(TextureFormat format) noexcept {
    return format >= TextureFormat::RED_RGTC1 && format <= TextureFormat::SIGNED_RED_GREEN_RGTC2;
 }

@@ -1248,6 +1118,26 @@ enum class SamplerCompareFunc : uint8_t {
    N           //!< Never. The depth / stencil test always fails.
 };

+//! this API is copied from (and only applies to) the Vulkan spec.
+//! These specify YUV to RGB conversions.
+enum class SamplerYcbcrModelConversion : uint8_t {
+    RGB_IDENTITY = 0,
+    YCBCR_IDENTITY = 1,
+    YCBCR_709 = 2,
+    YCBCR_601 = 3,
+    YCBCR_2020 = 4,
+};
+
+enum class SamplerYcbcrRange : uint8_t {
+    ITU_FULL = 0,
+    ITU_NARROW = 1,
+};
+
+enum class ChromaLocation : uint8_t {
+    COSITED_EVEN = 0,
+    MIDPOINT = 1,
+};
+
 //! Sampler parameters
 struct SamplerParams {             // NOLINT
    SamplerMagFilter filterMag      : 1;    //!< magnification filter (NEAREST)
@@ -1289,7 +1179,7 @@ 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;
        }
    };

@@ -1316,9 +1206,94 @@ static_assert(sizeof(SamplerParams) == 4);
 static_assert(sizeof(SamplerParams) <= sizeof(uint64_t),
        "SamplerParams must be no more than 64 bits");

+//! Sampler parameters
+struct SamplerYcbcrConversion {// NOLINT
+    SamplerYcbcrModelConversion ycbcrModel : 4;
+    TextureSwizzle r : 4;
+    TextureSwizzle g : 4;
+    TextureSwizzle b : 4;
+    TextureSwizzle a : 4;
+    SamplerYcbcrRange ycbcrRange : 1;
+    ChromaLocation xChromaOffset : 1;
+    ChromaLocation yChromaOffset : 1;
+    SamplerMagFilter chromaFilter : 1;
+    uint8_t padding;
+
+    struct Hasher {
+        size_t operator()(const SamplerYcbcrConversion p) const noexcept {
+            // we don't use std::hash<> here, so we don't have to include <functional>
+            return *reinterpret_cast<uint32_t const*>(reinterpret_cast<char const*>(&p));
+        }
+    };
+
+    struct EqualTo {
+        bool operator()(SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs) const noexcept {
+            assert_invariant(lhs.padding == 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;
+        }
+    };
+
+    struct LessThan {
+        bool operator()(SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs) const noexcept {
+            assert_invariant(lhs.padding == 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;
+        }
+    };
+
+private:
+    friend bool operator == (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+            noexcept {
+        return SamplerYcbcrConversion::EqualTo{}(lhs, rhs);
+    }
+    friend bool operator != (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+            noexcept {
+        return  !SamplerYcbcrConversion::EqualTo{}(lhs, rhs);
+    }
+    friend bool operator < (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+            noexcept {
+        return SamplerYcbcrConversion::LessThan{}(lhs, rhs);
+    }
+};
+
+static_assert(sizeof(SamplerYcbcrConversion) == 4);
+
+static_assert(sizeof(SamplerYcbcrConversion) <= sizeof(uint64_t),
+        "SamplerYcbcrConversion must be no more than 64 bits");
+
+struct ExternalSamplerDatum {
+    ExternalSamplerDatum(SamplerYcbcrConversion ycbcr, SamplerParams spm, uint32_t extFmt)
+        : YcbcrConversion(ycbcr),
+          samplerParams(spm),
+          externalFormat(extFmt) {}
+    bool operator==(ExternalSamplerDatum const& rhs) const {
+        return (YcbcrConversion == rhs.YcbcrConversion && samplerParams == rhs.samplerParams &&
+                externalFormat == rhs.externalFormat);
+    }
+    struct EqualTo {
+        bool operator()(const ExternalSamplerDatum& lhs,
+                const ExternalSamplerDatum& rhs) const noexcept {
+            return (lhs.YcbcrConversion == rhs.YcbcrConversion &&
+                lhs.samplerParams == rhs.samplerParams &&
+                lhs.externalFormat == rhs.externalFormat);
+        }
+    };
+    SamplerYcbcrConversion YcbcrConversion;
+    SamplerParams samplerParams;
+    uint32_t externalFormat;
+};
+// No implicit padding allowed due to it being a hash key.
+static_assert(sizeof(ExternalSamplerDatum) == 12);
+
 struct DescriptorSetLayout {
    std::variant<utils::StaticString, utils::CString, std::monostate> label;
    utils::FixedCapacityVector<DescriptorSetLayoutBinding> bindings;
+
+//  TODO: uncomment when needed
+//    utils::FixedCapacityVector<ExternalSamplerDatum> externalSamplerData;
 };

 //! blending equation function
@@ -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;
@@ -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
@@ -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
@@ -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;
@@ -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 {
@@ -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];
    }

@@ -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()
@@ -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;
@@ -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;
@@ -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 };
@@ -127,7 +127,7 @@ protected:
 protected:
    bool makeCurrent(ContextType type,
            SwapChain* drawSwapChain,
-            SwapChain* readSwapChain) override;
+            SwapChain* readSwapChain) noexcept override;

 private:
    struct InitializeJvmForPerformanceManagerIfNeeded {
@@ -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:
@@ -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 {
        /**
@@ -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:
@@ -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:
@@ -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;
 };

@@ -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>
@@ -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;
 };
@@ -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)
@@ -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();
@@ -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
@@ -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;
@@ -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);
@@ -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();
 }
@@ -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
 }

@@ -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
@@ -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)) {
@@ -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();
        }
    }
 }
@@ -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
@@ -17,7 +17,6 @@
 #include <backend/Platform.h>

 #include <utils/compiler.h>
-#include <utils/ostream.h>

 #include <atomic>
 #include <utility>
@@ -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__)
@@ -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)

@@ -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";

@@ -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)
@@ -19,8 +19,6 @@

 #include "MetalContext.h"

-#include <utils/Panic.h>
-
 namespace filament {
 namespace backend {

@@ -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;
@@ -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;
            }
        }
@@ -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));
 }
@@ -704,25 +707,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 +2067,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);

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

@@ -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.
@@ -1376,12 +1375,6 @@ id<MTLArgumentEncoder> MetalDescriptorSetLayout::getArgumentEncoderSlow(id<MTLDe
            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_EXTERNAL: {
                MTLArgumentDescriptor* textureArgument = [MTLArgumentDescriptor argumentDescriptor];
                textureArgument.index = binding.binding * 2;
@@ -1407,9 +1400,6 @@ id<MTLArgumentEncoder> MetalDescriptorSetLayout::getArgumentEncoderSlow(id<MTLDe
                break;
        }
    }
-    if (arguments.count == 0) {
-        return nil;
-    }
    return [device newArgumentEncoderWithArguments:arguments];
 }

@@ -1470,9 +1460,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");
@@ -1522,12 +1509,6 @@ id<MTLBuffer> MetalDescriptorSet::finalizeAndGetBuffer(MetalDriver* driver, Shad
            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_EXTERNAL: {
                auto found = textures.find(binding.binding);
                if (found == textures.end()) {
@@ -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.");
@@ -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 {
@@ -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
@@ -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
@@ -115,12 +115,6 @@ GLDescriptorSet::GLDescriptorSet(OpenGLContext& gl, DescriptorSetLayoutHandle ds
            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_EXTERNAL:
                if (UTILS_UNLIKELY(gl.isES2())) {
                    desc.emplace<SamplerGLES2>();
@@ -162,11 +156,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 +190,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 +219,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 +304,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 +333,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 +354,7 @@ void GLDescriptorSet::bind(
            }
        }, entry.desc);
    });
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }

 void GLDescriptorSet::validate(HandleAllocatorGL& allocator,
@@ -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
@@ -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();
    }
@@ -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 {
@@ -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);
            }
@@ -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;
 }
@@ -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
 }

@@ -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);
 }

@@ -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
@@ -193,12 +194,6 @@ void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint progra
                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_EXTERNAL: {
                    if (!entry.name.empty()) {
                        GLint const loc = glGetUniformLocation(program, entry.name.c_str());
@@ -214,7 +209,7 @@ void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint progra
                case DescriptorType::INPUT_ATTACHMENT:
                    break;
            }
-            CHECK_GL_ERROR()
+            CHECK_GL_ERROR(utils::slog.e)
        }
    }

@@ -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);
    });
@@ -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
@@ -70,9 +70,6 @@ PFNGLMAXSHADERCOMPILERTHREADSKHRPROC glMaxShaderCompilerThreadsKHR;
 #ifdef GL_OVR_multiview
 PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC glFramebufferTextureMultiviewOVR;
 #endif
-#ifdef GL_OVR_multiview_multisampled_render_to_texture
-PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC glFramebufferTextureMultisampleMultiviewOVR;
-#endif

 #if defined(__ANDROID__) && !defined(FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2)
 // On Android, If we want to support a build system less than ANDROID_API 21, we need to
@@ -126,9 +123,6 @@ void importGLESExtensionsEntryPoints() {
 #ifdef GL_OVR_multiview
        getProcAddress(glFramebufferTextureMultiviewOVR, "glFramebufferTextureMultiviewOVR");
 #endif
-#ifdef GL_OVR_multiview_multisampled_render_to_texture
-        getProcAddress(glFramebufferTextureMultisampleMultiviewOVR, "glFramebufferTextureMultisampleMultiviewOVR");
-#endif
 #if defined(__ANDROID__) && !defined(FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2)
        getProcAddress(glDispatchCompute, "glDispatchCompute");
 #endif
@@ -154,9 +154,6 @@ extern PFNGLMAXSHADERCOMPILERTHREADSKHRPROC glMaxShaderCompilerThreadsKHR;
 #ifdef GL_OVR_multiview
 extern PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC glFramebufferTextureMultiviewOVR;
 #endif
-#ifdef GL_OVR_multiview_multisampled_render_to_texture
-extern PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC glFramebufferTextureMultisampleMultiviewOVR;
-#endif
 #if defined(__ANDROID__) && !defined(FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2)
 extern PFNGLDISPATCHCOMPUTEPROC glDispatchCompute;
 #endif
@@ -96,7 +96,7 @@ CocoaExternalImage::SharedGl::~SharedGl() noexcept {
 CocoaExternalImage::CocoaExternalImage(const CVOpenGLTextureCacheRef textureCache,
        const SharedGl &sharedGl) noexcept : mSharedGl(sharedGl), mTextureCache(textureCache) {
    glGenFramebuffers(1, &mFBO);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }

 CocoaExternalImage::~CocoaExternalImage() noexcept {
@@ -125,7 +125,7 @@ bool CocoaExternalImage::set(CVPixelBufferRef image) noexcept {
    mTexture = createTextureFromImage(image);
    mRgbaTexture = encodeCopyRectangleToTexture2D(CVOpenGLTextureGetName(mTexture),
            CVPixelBufferGetWidth(image), CVPixelBufferGetHeight(image));
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)

    return true;
 }
@@ -182,33 +182,33 @@ GLuint CocoaExternalImage::encodeCopyRectangleToTexture2D(GLuint rectangle,
    // Create a texture to hold the result of the blit image.
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, width, height);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)

    // source textures
    glBindSampler(0, mSharedGl.sampler);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_RECTANGLE, rectangle);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)

    // destination texture
    glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)

-    CHECK_GL_FRAMEBUFFER_STATUS(GL_FRAMEBUFFER)
-    CHECK_GL_ERROR()
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_FRAMEBUFFER)
+    CHECK_GL_ERROR(utils::slog.e)

    // draw
    glViewport(0, 0, width, height);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
    glUseProgram(mSharedGl.program);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
    glDisableVertexAttribArray(0);
    glDrawArrays(GL_TRIANGLES, 0, 3);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)

    mState.restore();
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)

    return texture;
 }
@@ -119,7 +119,7 @@ CocoaTouchExternalImage::CocoaTouchExternalImage(const CVOpenGLESTextureCacheRef

    glGenFramebuffers(1, &mFBO);

-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }

 CocoaTouchExternalImage::~CocoaTouchExternalImage() noexcept {
@@ -247,7 +247,7 @@ GLuint CocoaTouchExternalImage::encodeColorConversionPass(GLuint yPlaneTexture,
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, width, height);

-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)

    // source textures
    glBindSampler(0, mSharedGl.sampler);
@@ -261,8 +261,8 @@ GLuint CocoaTouchExternalImage::encodeColorConversionPass(GLuint yPlaneTexture,
    glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);

-    CHECK_GL_ERROR()
-    CHECK_GL_FRAMEBUFFER_STATUS(GL_FRAMEBUFFER)
+    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_FRAMEBUFFER)

    // geometry
    glBindVertexArray(0);
@@ -275,7 +275,7 @@ GLuint CocoaTouchExternalImage::encodeColorConversionPass(GLuint yPlaneTexture,
    glUseProgram(mSharedGl.program);
    glDrawArrays(GL_TRIANGLES, 0, 3);

-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)

    mState.restore();

@@ -20,9 +20,9 @@

 #include <backend/Platform.h>

-#include <utils/Logger.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
+#include <utils/Log.h>
 #include <utils/ostream.h>

 #if __has_include(<android/surface_texture.h>)
@@ -59,7 +59,7 @@ void ExternalStreamManagerAndroid::destroy(ExternalStreamManagerAndroid* pExtern
 ExternalStreamManagerAndroid::ExternalStreamManagerAndroid() noexcept
        : mVm(VirtualMachineEnv::get()) {
    if (__builtin_available(android 28, *)) {
-        DLOG(INFO) << "Using ASurfaceTexture";
+        slog.d << "Using ASurfaceTexture" << io::endl;
    }
 }

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

 bool PlatformCocoaGL::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) {
+        SwapChain* readSwapChain) noexcept {
    ASSERT_PRECONDITION_NON_FATAL(drawSwapChain == readSwapChain,
            "ContextManagerCocoa does not support using distinct draw/read swap chains.");
    CocoaGLSwapChain* swapChain = (CocoaGLSwapChain*)drawSwapChain;
@@ -155,7 +155,7 @@ uint32_t PlatformCocoaTouchGL::getDefaultFramebufferObject() noexcept {
 }

 bool PlatformCocoaTouchGL::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) {
+        SwapChain* readSwapChain) noexcept {
    ASSERT_PRECONDITION_NON_FATAL(drawSwapChain == readSwapChain,
            "PlatformCocoaTouchGL does not support using distinct draw/read swap chains.");
    CAEAGLLayer* const glLayer = (__bridge CAEAGLLayer*) drawSwapChain;
@@ -32,9 +32,9 @@
 #endif
 #include <utils/compiler.h>

-#include <utils/Invocable.h>
-#include <utils/Logger.h>
 #include <utils/debug.h>
+#include <utils/Invocable.h>
+#include <utils/Log.h>
 #include <utils/ostream.h>

 #include <algorithm>
@@ -74,7 +74,7 @@ void PlatformEGL::logEglError(const char* name) noexcept {
 }

 void PlatformEGL::logEglError(const char* name, EGLint error) noexcept {
-    LOG(ERROR) << name << " failed with " << getEglErrorName(error);
+    slog.e << name << " failed with " << getEglErrorName(error) << io::endl;
 }

 const char* PlatformEGL::getEglErrorName(EGLint error) noexcept {
@@ -101,7 +101,7 @@ void PlatformEGL::clearGlError() noexcept {
    // clear GL error that may have been set by previous calls
    GLenum const error = glGetError();
    if (error != GL_NO_ERROR) {
-        LOG(WARNING) << "Ignoring pending GL error " << io::hex << error;
+        slog.w << "Ignoring pending GL error " << io::hex << error << io::endl;
    }
 }

@@ -142,7 +142,7 @@ Driver* PlatformEGL::createDriver(void* sharedContext, const DriverConfig& drive
    }

    if (UTILS_UNLIKELY(!initialized)) {
-        LOG(ERROR) << "eglInitialize failed";
+        slog.e << "eglInitialize failed" << io::endl;
        return nullptr;
    }

@@ -577,18 +577,18 @@ OpenGLPlatform::ContextType PlatformEGL::getCurrentContextType() const noexcept
 }

 bool PlatformEGL::makeCurrent(ContextType type,
-        SwapChain* drawSwapChain, SwapChain* readSwapChain) {
+        SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept {
    SwapChainEGL const* const dsc = static_cast<SwapChainEGL const*>(drawSwapChain);
    SwapChainEGL const* const rsc = static_cast<SwapChainEGL const*>(readSwapChain);
    EGLContext context = getContextForType(type);
    EGLBoolean const success = egl.makeCurrent(context, dsc->sur, rsc->sur);
-    return success == EGL_TRUE;
+    return success == EGL_TRUE ? true : false;
 }

 void PlatformEGL::makeCurrent(SwapChain* drawSwapChain,
        SwapChain* readSwapChain,
        Invocable<void()> preContextChange,
-        Invocable<void(size_t index)> postContextChange) {
+        Invocable<void(size_t index)> postContextChange) noexcept {

    assert_invariant(drawSwapChain);
    assert_invariant(readSwapChain);
@@ -796,7 +796,7 @@ void PlatformEGL::Config::erase(EGLint name) noexcept {
 // ------------------------------------------------------------------------------------------------

 EGLBoolean PlatformEGL::EGL::makeCurrent(EGLContext context, EGLSurface drawSurface,
-        EGLSurface readSurface) {
+        EGLSurface readSurface) noexcept {
    if (UTILS_UNLIKELY((
            mCurrentContext != context ||
            drawSurface != mCurrentDrawSurface || readSurface != mCurrentReadSurface))) {
@@ -29,12 +29,13 @@
 #include <android/native_window.h>
 #include <android/hardware_buffer.h>

-#include <utils/Logger.h>
-#include <utils/Panic.h>
 #include <utils/android/PerformanceHintManager.h>
-#include <utils/compiler.h>
+
 #include <utils/compiler.h>
 #include <utils/ostream.h>
+#include <utils/Panic.h>
+#include <utils/Log.h>
+#include <utils/compiler.h>
 #include <utils/ostream.h>

 #include <EGL/egl.h>
@@ -134,7 +135,7 @@ static constexpr const std::string_view kNativeWindowInvalidMsg =

 bool PlatformEGLAndroid::makeCurrent(ContextType type,
        SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) {
+        SwapChain* readSwapChain) noexcept {

    // fast & safe path
    if (UTILS_LIKELY(!mAssertNativeWindowIsValid)) {
@@ -254,7 +255,6 @@ Platform::ExternalImageHandle PlatformEGLAndroid::createExternalImage(AHardwareB
        p->height = hardwareBufferDescription.height;
        p->width = hardwareBufferDescription.width;
        auto textureFormat = mapToFilamentFormat(hardwareBufferDescription.format, sRGB);
-        p->format = textureFormat;
        p->usage = mapToFilamentUsage(hardwareBufferDescription.usage, textureFormat);
        return ExternalImageHandle{ p };
    }
@@ -326,7 +326,7 @@ bool PlatformEGLAndroid::setImage(ExternalImageEGLAndroid const* eglExternalImag
            EGL_NATIVE_BUFFER_ANDROID, clientBuffer, imageAttrs);
    if (eglImage == EGL_NO_IMAGE_KHR) {
        // Handle error
-        LOG(ERROR) << "Failed to create EGL image";
+        slog.e << "Failed to create EGL image" << io::endl;
        glDeleteTextures(1, &texture->id);
        return false;
    }
@@ -339,7 +339,7 @@ bool PlatformEGLAndroid::setImage(ExternalImageEGLAndroid const* eglExternalImag
    glBindTexture(texture->target, texture->id);
    GLenum error = glGetError();
    if (UTILS_UNLIKELY(error != GL_NO_ERROR)) {
-        LOG(ERROR) << "Error after glBindTexture: " << error;
+        slog.e << "Error after glBindTexture: " << error << io::endl;
        glDeleteTextures(1, &texture->id);
        eglDestroyImageKHR(eglGetCurrentDisplay(), eglImage);
        glActiveTexture(prevActiveTexture);
@@ -349,7 +349,7 @@ bool PlatformEGLAndroid::setImage(ExternalImageEGLAndroid const* eglExternalImag
    glEGLImageTargetTexture2DOES(texture->target, static_cast<GLeglImageOES>(eglImage));
    error = glGetError();
    if (UTILS_UNLIKELY(error != GL_NO_ERROR)) {
-        LOG(ERROR) << "Error after glEGLImageTargetTexture2DOES: " << error;
+        slog.e << "Error after glEGLImageTargetTexture2DOES: " << error << io::endl;
        glDeleteTextures(1, &texture->id);
        eglDestroyImageKHR(eglGetCurrentDisplay(), eglImage);
        glActiveTexture(prevActiveTexture);
@@ -407,7 +407,7 @@ AcquiredImage PlatformEGLAndroid::transformAcquiredImage(AcquiredImage source) n

    EGLClientBuffer clientBuffer = eglGetNativeClientBufferANDROID(pHardwareBuffer);
    if (!clientBuffer) {
-        LOG(ERROR) << "Unable to get EGLClientBuffer from AHardwareBuffer.";
+        slog.e << "Unable to get EGLClientBuffer from AHardwareBuffer." << io::endl;
        return {};
    }

@@ -426,7 +426,7 @@ AcquiredImage PlatformEGLAndroid::transformAcquiredImage(AcquiredImage source) n
    EGLImageKHR eglImage = eglCreateImageKHR(mEGLDisplay,
            EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, clientBuffer, attributes.data());
    if (eglImage == EGL_NO_IMAGE_KHR) {
-        LOG(ERROR) << "eglCreateImageKHR returned no image.";
+        slog.e << "eglCreateImageKHR returned no image." << io::endl;
        return {};
    }

@@ -441,7 +441,7 @@ AcquiredImage PlatformEGLAndroid::transformAcquiredImage(AcquiredImage source) n
    auto patchedCallback = [](void* image, void* userdata) {
        Closure* closure = (Closure*)userdata;
        if (eglDestroyImageKHR(closure->display, (EGLImageKHR) image) == EGL_FALSE) {
-            LOG(ERROR) << "eglDestroyImageKHR failed.";
+            slog.e << "eglDestroyImageKHR failed." << io::endl;
        }
        closure->acquiredImage.callback(closure->acquiredImage.image, closure->acquiredImage.userData);
        delete closure;
@@ -21,9 +21,9 @@
 #include <EGL/egl.h>
 #include <EGL/eglext.h>

-#include <utils/Logger.h>
-#include <utils/Panic.h>
 #include <utils/compiler.h>
+#include <utils/Log.h>
+#include <utils/Panic.h>

 using namespace utils;

@@ -42,12 +42,12 @@ backend::Driver* PlatformEGLHeadless::createDriver(void* sharedContext,
        const Platform::DriverConfig& driverConfig) noexcept {
    EGLBoolean bindAPI = eglBindAPI(EGL_OPENGL_API);
    if (UTILS_UNLIKELY(!bindAPI)) {
-        LOG(ERROR) << "eglBindAPI EGL_OPENGL_API failed";
+        slog.e << "eglBindAPI EGL_OPENGL_API failed" << io::endl;
        return nullptr;
    }
    int bindBlueGL = bluegl::bind();
    if (UTILS_UNLIKELY(bindBlueGL != 0)) {
-        LOG(ERROR) << "bluegl bind failed";
+        slog.e << "bluegl bind failed" << io::endl;
        return nullptr;
    }

@@ -16,7 +16,7 @@

 #include <backend/platforms/PlatformGLX.h>

-#include <utils/Logger.h>
+#include <utils/Log.h>
 #include <utils/Panic.h>

 #include <X11/Xlib.h>
@@ -84,7 +84,7 @@ static PFNGLXGETPROCADDRESSPROC getProcAddress;
 static bool loadLibraries() {
    g_glx.library = dlopen(LIBRARY_GLX, RTLD_LOCAL | RTLD_NOW);
    if (!g_glx.library) {
-        LOG(ERROR) << "Could not find library " << LIBRARY_GLX;
+        utils::slog.e << "Could not find library " << LIBRARY_GLX << utils::io::endl;
        return false;
    }

@@ -115,7 +115,7 @@ static bool loadLibraries() {

    g_x11.library = dlopen(LIBRARY_X11, RTLD_LOCAL | RTLD_NOW);
    if (!g_x11.library) {
-        LOG(ERROR) << "Could not find library " << LIBRARY_X11;
+        utils::slog.e << "Could not find library " << LIBRARY_X11 << utils::io::endl;
        return false;
    }

@@ -134,7 +134,7 @@ Driver* PlatformGLX::createDriver(void* sharedGLContext,
    // Get the display device
    mGLXDisplay = g_x11.openDisplay(NULL);
    if (mGLXDisplay == nullptr) {
-        LOG(ERROR) << "Failed to open X display. (exiting).";
+        utils::slog.e << "Failed to open X display. (exiting)." << utils::io::endl;
        exit(1);
    }

@@ -145,7 +145,8 @@ Driver* PlatformGLX::createDriver(void* sharedGLContext,

        r = g_glx.queryContext(mGLXDisplay, sharedCtx, GLX_FBCONFIG_ID, &usedFbId);
        if (r != 0) {
-            LOG(ERROR) << "Failed to get GLX_FBCONFIG_ID from shared GL context.";
+            utils::slog.e << "Failed to get GLX_FBCONFIG_ID from shared GL context."
+                          << utils::io::endl;
            return nullptr;
        }

@@ -153,7 +154,7 @@ Driver* PlatformGLX::createDriver(void* sharedGLContext,
        GLXFBConfig* fbConfigs = g_glx.getFbConfigs(mGLXDisplay, 0, &numConfigs);

        if (fbConfigs == nullptr) {
-            LOG(ERROR) << "Failed to get the available GLXFBConfigs.";
+            utils::slog.e << "Failed to get the available GLXFBConfigs." << utils::io::endl;
            return nullptr;
        }

@@ -163,7 +164,8 @@ Driver* PlatformGLX::createDriver(void* sharedGLContext,
        for (int i = 0; i < numConfigs; ++i) {
            r = g_glx.getFbConfigAttrib(mGLXDisplay, fbConfigs[i], GLX_FBCONFIG_ID, &fbId);
            if (r != 0) {
-                LOG(ERROR) << "Failed to get GLX_FBCONFIG_ID for entry " << i << ".";
+                utils::slog.e << "Failed to get GLX_FBCONFIG_ID for entry " << i << "."
+                              << utils::io::endl;
                continue;
            }

@@ -174,7 +176,8 @@ Driver* PlatformGLX::createDriver(void* sharedGLContext,
        }

        if (fbIndex < 0) {
-            LOG(ERROR) << "Failed to find an `GLXFBConfig` with the requested ID.";
+            utils::slog.e << "Failed to find an `GLXFBConfig` with the requested ID."
+                          << utils::io::endl;
            return nullptr;
        }

@@ -199,7 +202,8 @@ Driver* PlatformGLX::createDriver(void* sharedGLContext,
            getProcAddress((GLubyte*)"glXCreateContextAttribsARB");

    if (glXCreateContextAttribs == nullptr) {
-        LOG(INFO) << "Unable to retrieve function pointer for `glXCreateContextAttribs()`.";
+        utils::slog.i << "Unable to retrieve function pointer for `glXCreateContextAttribs()`."
+                      << utils::io::endl;
        return nullptr;
    }

@@ -262,7 +266,7 @@ void PlatformGLX::destroySwapChain(Platform::SwapChain* swapChain) noexcept {
 }

 bool PlatformGLX::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) {
+        SwapChain* readSwapChain) noexcept {
    g_glx.setCurrentContext(mGLXDisplay,
            (GLXDrawable)drawSwapChain, (GLXDrawable)readSwapChain, mGLXContext);
    return true;
@@ -169,7 +169,7 @@ void PlatformOSMesa::destroySwapChain(Platform::SwapChain* swapChain) noexcept {
 }

 bool PlatformOSMesa::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) {
+        SwapChain* readSwapChain) noexcept {
    OSMesaAPI* api = (OSMesaAPI*) mOsMesaApi;
    OSMesaSwapchain* impl = (OSMesaSwapchain*) drawSwapChain;

@@ -32,7 +32,7 @@
 #include "GL/glext.h"
 #include "GL/wglext.h"

-#include <utils/Logger.h>
+#include <utils/Log.h>
 #include <utils/Panic.h>

 namespace {
@@ -55,7 +55,8 @@ void reportWindowsError(DWORD dwError) {
        0, nullptr
 	);

-    LOG(ERROR) << "Windows error code: " << dwError << ". " << lpMessageBuffer;
+    utils::slog.e << "Windows error code: " << dwError << ". " << lpMessageBuffer
+            << utils::io::endl;

    LocalFree(lpMessageBuffer);
 }
@@ -105,7 +106,7 @@ Driver* PlatformWGL::createDriver(void* sharedGLContext,
    HDC whdc = mWhdc = GetDC(mHWnd);
    if (whdc == NULL) {
        dwError = GetLastError();
-        LOG(ERROR) << "CreateWindowA() failed";
+        utils::slog.e << "CreateWindowA() failed" << utils::io::endl;
        goto error;
    }

@@ -116,7 +117,8 @@ Driver* PlatformWGL::createDriver(void* sharedGLContext,
    tempContext = wglCreateContext(whdc);
    if (!wglMakeCurrent(whdc, tempContext)) {
        dwError = GetLastError();
-        LOG(ERROR) << "wglMakeCurrent() failed, whdc=" << whdc << ", tempContext=" << tempContext;
+        utils::slog.e << "wglMakeCurrent() failed, whdc=" << whdc << ", tempContext=" <<
+                tempContext << utils::io::endl;
        goto error;
    }

@@ -140,7 +142,7 @@ Driver* PlatformWGL::createDriver(void* sharedGLContext,
    }

    if (!mContext) {
-        LOG(ERROR) << "wglCreateContextAttribs() failed, whdc=" << whdc;
+        utils::slog.e << "wglCreateContextAttribs() failed, whdc=" << whdc << utils::io::endl;
        goto error;
    }

@@ -150,7 +152,8 @@ Driver* PlatformWGL::createDriver(void* sharedGLContext,

    if (!wglMakeCurrent(whdc, mContext)) {
        dwError = GetLastError();
-        LOG(ERROR) << "wglMakeCurrent() failed, whdc=" << whdc << ", mContext=" << mContext;
+        utils::slog.e << "wglMakeCurrent() failed, whdc=" << whdc << ", mContext=" <<
+                mContext << utils::io::endl;
        goto error;
    }

@@ -259,7 +262,7 @@ void PlatformWGL::destroySwapChain(Platform::SwapChain* swapChain) noexcept {
 }

 bool PlatformWGL::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) {
+        SwapChain* readSwapChain) noexcept {
    ASSERT_PRECONDITION_NON_FATAL(drawSwapChain == readSwapChain,
                                  "PlatformWGL does not support distinct draw/read swap chains.");

@@ -47,7 +47,7 @@ void PlatformWebGL::destroySwapChain(Platform::SwapChain* swapChain) noexcept {
 }

 bool PlatformWebGL::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) {
+        SwapChain* readSwapChain) noexcept {
    return true;
 }

@@ -40,7 +40,7 @@ inline void blitFast(VulkanCommandBuffer* commands, VkImageAspectFlags aspect, V
        FVK_LOGD << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                      << " layout=" << src.getLayout()
                      << " to=" << dst.texture->getVkImage() << ",level=" << (int) dst.level
-                      << " layout=" << dst.getLayout();
+                      << " layout=" << dst.getLayout() << utils::io::endl;
    }

    VkImageSubresourceRange const srcRange = src.getSubresourceRange();
@@ -80,7 +80,7 @@ inline void resolveFast(VulkanCommandBuffer* commands, VkImageAspectFlags aspect
        FVK_LOGD << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                      << " layout=" << src.getLayout()
                      << " to=" << dst.texture->getVkImage() << ",level=" << (int) dst.level
-                      << " layout=" << dst.getLayout();
+                      << " layout=" << dst.getLayout() << utils::io::endl;
    }

    VkImageSubresourceRange const srcRange = src.getSubresourceRange();
@@ -14,75 +14,88 @@
 * limitations under the License.
 */

-#include "VulkanBufferProxy.h"
-#include "VulkanCommands.h"
+#include "VulkanBuffer.h"
 #include "VulkanMemory.h"

-#include "VulkanBufferCache.h"
-#include "VulkanMemory.h"
+#include <utils/Panic.h>

 using namespace bluevk;

 namespace filament::backend {

-VulkanBufferProxy::VulkanBufferProxy(VmaAllocator allocator, VulkanStagePool& stagePool,
-        VulkanBufferCache& bufferCache, VulkanBufferUsage usage, uint32_t numBytes)
+VulkanBuffer::VulkanBuffer(VmaAllocator allocator, VulkanStagePool& stagePool,
+        VkBufferUsageFlags usage, uint32_t numBytes)
    : mAllocator(allocator),
      mStagePool(stagePool),
-      mBufferCache(bufferCache),
-      mBuffer(mBufferCache.acquire(usage, numBytes)),
-      mUpdatedOffset(0),
-      mUpdatedBytes(0) {}
+      mUsage(usage),
+	  mUpdatedOffset(0),
+      mUpdatedBytes(0) {
+    // for now make sure that only 1 bit is set in usage
+    // (because loadFromCpu() assumes that somewhat)
+    assert_invariant(usage && !(usage & (usage - 1)));

-void VulkanBufferProxy::loadFromCpu(VulkanCommandBuffer& commands, const void* cpuData,
-        uint32_t byteOffset, uint32_t numBytes) {
-    // Note: this should be stored within the command buffer before going out of
-    // scope, so that the command buffer can manage its lifecycle.
-    fvkmemory::resource_ptr<VulkanStage::Segment> stage = mStagePool.acquireStage(numBytes);
-    assert_invariant(stage->memory());
-    commands.acquire(stage);
-    memcpy(stage->mapping(), cpuData, numBytes);
-    vmaFlushAllocation(mAllocator, stage->memory(), stage->offset(), numBytes);
+    // Create the VkBuffer.
+    VkBufferCreateInfo bufferInfo {
+        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+        .size = numBytes,
+        .usage = usage | VK_BUFFER_USAGE_TRANSFER_DST_BIT
+    };
+
+    VmaAllocationCreateInfo allocInfo { .usage = VMA_MEMORY_USAGE_GPU_ONLY };
+    vmaCreateBuffer(mAllocator, &bufferInfo, &allocInfo, &mGpuBuffer, &mGpuMemory, nullptr);
+}
+
+VulkanBuffer::~VulkanBuffer() {
+    vmaDestroyBuffer(mAllocator, mGpuBuffer, mGpuMemory);
+}
+
+void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint32_t byteOffset,
+        uint32_t numBytes) {
+    VulkanStage const* stage = mStagePool.acquireStage(numBytes);
+    void* mapped;
+    vmaMapMemory(mAllocator, stage->memory, &mapped);
+    memcpy(mapped, cpuData, numBytes);
+    vmaUnmapMemory(mAllocator, stage->memory);
+    vmaFlushAllocation(mAllocator, stage->memory, byteOffset, numBytes);

    // If there was a previous update, then we need to make sure the following write is properly
    // synced with the previous read.
-    if (mUpdatedBytes > 0 &&
-            (byteOffset >= mUpdatedOffset && byteOffset <= (mUpdatedOffset + mUpdatedBytes))) {
+    if (mUpdatedBytes > 0) {
        VkAccessFlags srcAccess = 0;
        VkPipelineStageFlags srcStage = 0;
-        if (getUsage() == VulkanBufferUsage::UNIFORM) {
+        if (mUsage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
            srcAccess = VK_ACCESS_SHADER_READ_BIT;
            srcStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-        } else if (getUsage() == VulkanBufferUsage::VERTEX) {
+        } else if (mUsage & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) {
            srcAccess = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
            srcStage = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
-        } else if (getUsage() == VulkanBufferUsage::INDEX) {
+        } else if (mUsage & VK_BUFFER_USAGE_INDEX_BUFFER_BIT) {
            srcAccess = VK_ACCESS_INDEX_READ_BIT;
            srcStage = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
        }

-        VkBufferMemoryBarrier barrier = {
+        VkBufferMemoryBarrier barrier{
            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
            .srcAccessMask = srcAccess,
            .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .buffer = getVkBuffer(),
-            .offset = byteOffset,
-            .size = numBytes,
+            .buffer = mGpuBuffer,
+			.offset = mUpdatedOffset,
+            .size = mUpdatedBytes,
        };
-        vkCmdPipelineBarrier(commands.buffer(), srcStage, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0,
-                nullptr, 1, &barrier, 0, nullptr);
+        vkCmdPipelineBarrier(cmdbuf, srcStage, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1,
+                &barrier, 0, nullptr);
    }

-    VkBufferCopy region = {
-        .srcOffset = stage->offset(),
-        .dstOffset = byteOffset,
-        .size = numBytes,
+    VkBufferCopy region {
+            .srcOffset = 0,
+            .dstOffset = byteOffset,
+            .size = numBytes,
    };
-    vkCmdCopyBuffer(commands.buffer(), stage->buffer(), getVkBuffer(), 1, &region);
+    vkCmdCopyBuffer(cmdbuf, stage->buffer, mGpuBuffer, 1, &region);

-    mUpdatedOffset = byteOffset;
+	mUpdatedOffset = byteOffset;
    mUpdatedBytes = numBytes;

    // Firstly, ensure that the copy finishes before the next draw call.
@@ -92,40 +105,32 @@ void VulkanBufferProxy::loadFromCpu(VulkanCommandBuffer& commands, const void* c
    VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;

-    if (getUsage() == VulkanBufferUsage::VERTEX) {
+    if (mUsage & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) {
        dstAccessMask |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
        dstStageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
-    } else if (getUsage() == VulkanBufferUsage::INDEX) {
+    } else if (mUsage & VK_BUFFER_USAGE_INDEX_BUFFER_BIT) {
        dstAccessMask |= VK_ACCESS_INDEX_READ_BIT;
        dstStageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
-    } else if (getUsage() == VulkanBufferUsage::UNIFORM) {
-        dstAccessMask |= VK_ACCESS_SHADER_READ_BIT;
-        dstStageMask |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
-    } else if (getUsage() == VulkanBufferUsage::SHADER_STORAGE) {
+    } else if (mUsage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
+        dstAccessMask |= VK_ACCESS_UNIFORM_READ_BIT;
+        dstStageMask |=
+                (VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
+    } else if (mUsage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) {
        // TODO: implement me
    }

-    VkBufferMemoryBarrier barrier = {
+    VkBufferMemoryBarrier barrier{
        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
        .dstAccessMask = dstAccessMask,
        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-        .buffer = getVkBuffer(),
-        .offset = byteOffset,
-        .size = numBytes,
+        .buffer = mGpuBuffer,
+        .size = VK_WHOLE_SIZE,
    };

-    vkCmdPipelineBarrier(commands.buffer(), VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageMask, 0, 0,
-            nullptr, 1, &barrier, 0, nullptr);
+    vkCmdPipelineBarrier(cmdbuf, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageMask, 0, 0, nullptr, 1,
+            &barrier, 0, nullptr);
 }

-VkBuffer VulkanBufferProxy::getVkBuffer() const noexcept {
-    return mBuffer->getGpuBuffer()->vkbuffer;
-}
-
-VulkanBufferUsage VulkanBufferProxy::getUsage() const noexcept {
-    return mBuffer->getGpuBuffer()->usage;
-}
-
-}// namespace filament::backend
+} // namespace filament::backend
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
bridgewaterrobbie	815629f14e	Quick fix for descriptor set types.	2025-05-15 15:33:47 -04:00
bridgewaterrobbie	c05a446e10	Minor fixes to branch hacks. Use unfilterable float instead of float (Might need to vary this depending on eventual filtering bit)	2025-05-15 15:33:36 -04:00
bridgewaterrobbie	9d49205844	Filament's compareMode function should be checked before using any of the comparison related enums it provides. This also lets us use the descriptor now.	2025-05-15 15:32:19 -04:00
bridgewaterrobbie	7099b6dd6f	Quick and dirty hack to log where dummies are needed to work still	2025-05-14 20:13:42 -04:00
Mathias Agopian	18becfc656	Make sure that all descriptors are always initialized	2025-05-14 20:13:42 -04:00
bridgewaterrobbie	cd2d499e25	Tinkering with new descriptortype info	2025-05-14 15:39:16 -04:00
Mathias Agopian	3bb72cefe9	fix fog sampler descriptor type	2025-05-14 15:39:16 -04:00
Mathias Agopian	1a67f9233b	DescriptorType now includes the "dimension" of the texture DescriptorType now also encodes wether the descriptor expects a 2D, 3D, Cubemap and/or Array. This is needed by both Metal and WebGPU. [New Material Version]	2025-05-12 14:10:20 -04:00
Mathias Agopian	f7e20562a8	select the proper descriptor set layout in the rendering loop Now that the per-view layout can be different based on the type of shadow, we need to make sure we set the proper layout in the pipeline and use the corresponding descriptor set. There are now 16 "per-view" layouts and their corresponding descriptor set. There are two sets of 8, the current set is determined by the shadow type on the view. Then during rendering, when we set the pipeline we need to select the corresponding layout; each material now offers both versions of the layout and we just pick the right one. DescriptorSet::setBuffer and setSampler now need the layout in order to do some validation that the correct type of descriptor is used. This will help catch problems earlier.	2025-05-12 14:10:19 -04:00
Mathias Agopian	08af16239c	add sampler type in DescriptorSetLayout [New Material Version]	2025-05-12 14:10:19 -04:00