vk: update vulkan memory allocator lib

webgpu: texture changes to better support mipmap generation later
Release Filament 1.61.1
2025-06-12 15:23:38 -07:00 · 2025-06-11 22:35:42 -05:00 · 2025-06-12 00:31:33 +00:00 · 2025-06-11 23:09:59 +00:00 · 2025-06-11 10:08:52 -07:00 · 2025-06-10 20:06:00 -07:00
145 changed files with 22478 additions and 22097 deletions
@@ -17,15 +17,17 @@ runs:
        echo "Date: ${TSTAMP}" >> /tmp/commit_msg.txt
        echo "" >> /tmp/commit_msg.txt
        echo "${{ github.event.head_commit.message }}" >> /tmp/commit_msg.txt
-    - name: Checkout code
+    - 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.ref }}
-        COMMIT_MESSAGE=$(git log -1)
-        echo "$(git log -1)" >> /tmp/commit_msg.txt
+        git checkout ${{ github.event.pull_request.head.sha }}
+        echo "$(git log -1 --no-merges)" >> /tmp/commit_msg.txt
    - shell: bash
      id: action_output
      run: |
@@ -36,8 +38,8 @@ runs:
        echo "----- got commit message ---"
        cat /tmp/commit_msg.txt
        echo "----------------------------"
-    - name: Uncheckout code
+    - name: Cleanup Find commit message (PR)
      shell: bash
      if: github.event_name == 'pull_request'
      run: |
-        git checkout ${{ steps.checkout_code.outputs.hash }}
+        git checkout ${{ steps.checkout_code.outputs.hash }}
@@ -122,9 +122,6 @@ jobs:
          fetch-depth: 0
      - id: get_commit_msg
        uses: ./.github/actions/get-commit-msg
-      - uses: actions/checkout@v4.1.6
-        with:
-          fetch-depth: 0
      - uses: ./.github/actions/mac-prereq
      - name: Cache Mesa and deps
        uses: actions/cache@v4
@@ -49,6 +49,8 @@ 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)
@@ -591,6 +593,10 @@ 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
 # ==================================================================================================
@@ -7,7 +7,3 @@ We are chaning the way Vulkan buffers are handled. We need to switch over to a m
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).

 ## Release notes for next branch cut
-
- samples: samples now have a CLI to select backend api
- materials: sampler now export their type in the material binary [⚠️ **New Material Version**]
- materials: new mutable specialization constants feature. See the [materials documentation](https://google.github.io/filament/Materials.html) for details. [⚠️ **New Material Version**]
@@ -31,7 +31,7 @@ repositories {
 }

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

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

 ## Documentation
@@ -7,6 +7,12 @@ 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.62.0
+
+- samples: samples now have a CLI to select backend api
+- materials: sampler now export their type in the material binary [⚠️ **New Material Version**]
+- materials: new mutable specialization constants feature. See the [materials documentation](https://google.github.io/filament/Materials.html) for details. [⚠️ **New Material Version**]
+
 ## v1.61.1


@@ -59,6 +59,10 @@ 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
@@ -128,6 +132,7 @@ target_link_libraries(filament-jni
    PRIVATE jnigraphics
    PRIVATE utils
    PRIVATE perfetto
+    PRIVATE abseil

    # libgeometry is PUBLIC because gltfio uses it.
    PUBLIC geometry
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.61.0
+VERSION_NAME=1.61.1

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

@@ -601,6 +601,10 @@ 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
+FILAMENT_LIBS=-lfilament -lbackend -lbluegl -lbluevk -lfilabridge -lfilaflat -lutils -lgeometry -lsmol-v -lvkshaders -libl -labseil
 CC=clang++

 main: main.o
@@ -110,12 +110,13 @@ clean:
 ### macOS

 ```make
-FILAMENT_LIBS=-lfilament -lbackend -lbluegl -lbluevk -lfilabridge -lfilaflat -lutils -lgeometry -lsmol-v -lvkshaders -libl
+FILAMENT_LIBS=-lfilament -lbackend -lbluegl -lbluevk -lfilabridge -lfilaflat -lutils -lgeometry -lsmol-v -lvkshaders -libl -labseil
 FRAMEWORKS=-framework Cocoa -framework Metal -framework CoreVideo
 CC=clang++
+ARCH ?= $(shell uname -m)

 main: main.o
-	$(CC) -Llib/x86_64/ main.o $(FILAMENT_LIBS) $(FRAMEWORKS) -o main
+	$(CC) -Llib/$(ARCH)/ main.o $(FILAMENT_LIBS) $(FRAMEWORKS) -o main

 main.o: main.cpp
 	$(CC) -Iinclude/ -std=c++17 -c main.cpp
@@ -139,7 +140,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
+              utils.lib geometry.lib smol-v.lib ibl.lib vkshaders.lib abseil.lib
 CC=cl.exe

 main.exe: main.obj
@@ -286,7 +286,6 @@ if (FILAMENT_SUPPORTS_WEBGPU)
            src/webgpu/WebGPUVertexBuffer.h
            src/webgpu/WebGPUVertexBufferInfo.cpp
            src/webgpu/WebGPUVertexBufferInfo.h
-            src/webgpu/SpdMipmapGenerator.cpp
    )
    if (WIN32)
        list(APPEND SRCS src/webgpu/platform/WebGPUPlatformWindows.cpp)
@@ -404,6 +403,10 @@ 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)
@@ -128,7 +128,7 @@ protected:
    bool setExternalImage(ExternalImageHandleRef externalImage, ExternalTexture* texture) noexcept override;

    /**
-     * Logs glGetError() to slog.e
+     * Logs glGetError() to LOG(ERROR)
     * @param name a string giving some context on the error. Typically __func__.
     */
    static void logEglError(const char* name) noexcept;
@@ -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 slog.d
+// Command debugging enabled. Every command logged to DLOG(INFO)
 #define FILAMENT_DEBUG_COMMANDS_LOG          0x2
 // Command debugging enabled. Every command logged to systrace
 #define FILAMENT_DEBUG_COMMANDS_SYSTRACE     0x4
@@ -16,7 +16,7 @@

 #include "private/backend/CircularBuffer.h"

-#include <utils/Log.h>
+#include <utils/Logger.h>
 #include <utils/Panic.h>
 #include <utils/architecture.h>
 #include <utils/ashmem.h>
@@ -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";

-        slog.w << "Using 'soft' CircularBuffer (" << (size * 2 / 1024) << " KiB)" << io::endl;
+        LOG(WARNING) << "Using 'soft' CircularBuffer (" << (size * 2 / 1024) << " KiB)";

        // guard page at the end
        void* guard = (void*)(uintptr_t(data) + size * 2);
@@ -20,12 +20,12 @@

 #include <private/utils/Tracing.h>

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

 #include <algorithm>
 #include <mutex>
@@ -121,11 +121,10 @@ void CommandBufferQueue::flush() {

 #ifndef NDEBUG
        size_t const totalUsed = circularBuffer.size() - mFreeSpace;
-        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;
+        DLOG(INFO) << "CommandStream used too much space (will block): "
+                   << "needed space " << requiredSize << " out of " << mFreeSpace
+                   << ", totalUsed=" << totalUsed << ", current=" << used
+                   << ", queue size=" << mCommandBuffersToExecute.size() << " buffers";

        mHighWatermark = std::max(mHighWatermark, totalUsed);
 #endif
@@ -22,10 +22,13 @@
 #include <utils/CallStack.h>
 #endif

-#include <utils/compiler.h>
-#include <utils/Log.h>
-#include <utils/ostream.h>
+#include <private/utils/Tracing.h>
+
+#include <utils/Logger.h>
 #include <utils/Profiler.h>
+#include <utils/compiler.h>
+#include <utils/ostream.h>
+#include <utils/sstream.h>

 #include <cstddef>
 #include <functional>
@@ -129,9 +132,10 @@ 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();
-    slog.d << extractMethodName(command) << " : size=" << sizeof(Command) << "\n\t";
-    printParameterPack(slog.d, std::get<I>(mArgs)...);
-    slog.d << io::endl;
+    DLOG(INFO) << extractMethodName(command) << " : size=" << sizeof(Command);
+    utils::io::sstream parameterPack;
+    printParameterPack(parameterPack, std::get<I>(mArgs)...);
+    DLOG(INFO) << "\t" << parameterPack.c_str();
 #endif
 }

@@ -25,9 +25,9 @@

 #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 <math/half.h>
@@ -149,7 +149,7 @@ 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)) {
-            utils::slog.d << methodName << utils::io::endl;
+            DLOG(INFO) << methodName;
        }
        if constexpr (bool(FILAMENT_DEBUG_COMMANDS & FILAMENT_DEBUG_COMMANDS_SYSTRACE)) {
            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
@@ -20,7 +20,7 @@

 #include <utils/Allocator.h>
 #include <utils/CString.h>
-#include <utils/Log.h>
+#include <utils/Logger.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())) {
-        slog.w << "HandleAllocator heap size reduced to "
-               << maxHeapSize << " from " << area.size() << io::endl;
+        LOG(WARNING) << "HandleAllocator heap size reduced to " << maxHeapSize << " from "
+                     << area.size();
    }

    // make sure we start with a clean arena. This is needed to ensure that all blocks start
@@ -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];
-            utils::slog.e << description << utils::io::endl;
+            LOG(ERROR) << description;
        }
    }
    FILAMENT_CHECK_POSTCONDITION(library && function)
@@ -349,7 +349,7 @@ id<MTLFunction> MetalBlitter::getBlitVertexFunction() {
    if (!library || !function) {
        if (error) {
            auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
-            utils::slog.e << description << utils::io::endl;
+            LOG(ERROR) << description;
        }
    }
    FILAMENT_CHECK_POSTCONDITION(library && function)
@@ -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,8 +77,7 @@ void MetalBufferPool::releaseBuffer(MetalBufferPoolEntry const *stage) noexcept

    auto iter = mUsedStages.find(stage);
    if (iter == mUsedStages.end()) {
-        utils::slog.e << "Unknown Metal buffer: " << stage->capacity << " bytes"
-                << utils::io::endl;
+        LOG(ERROR) << "Unknown Metal buffer: " << stage->capacity << " bytes";
        return;
    }
    stage->lastAccessed = mCurrentFrame;
@@ -18,8 +18,9 @@

 #include "MetalHandles.h"

-#include <utils/debug.h>
 #include <utils/FixedCapacityVector.h>
+#include <utils/Logger.h>
+#include <utils/debug.h>

 #include <utility>

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

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

 #include <algorithm>

@@ -78,20 +78,18 @@ Driver* MetalDriverFactory::create(PlatformMetal* const platform, const Platform
    //    MetalVertexBufferInfo        : 552       moderate
    // -- less than or equal to 552 bytes

-    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;
+    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);
 #endif
    return MetalDriver::create(platform, driverConfig);
 }
@@ -135,19 +133,18 @@ MetalDriver::MetalDriver(

    initializeSupportedGpuFamilies(mContext);

-    utils::slog.v << "Supported GPU families: " << utils::io::endl;
+    LOG(INFO) << "Supported GPU families: ";
    if (mContext->highestSupportedGpuFamily.common > 0) {
-        utils::slog.v << "  MTLGPUFamilyCommon" << (int) mContext->highestSupportedGpuFamily.common << utils::io::endl;
+        LOG(INFO) << "  MTLGPUFamilyCommon" << (int) mContext->highestSupportedGpuFamily.common;
    }
    if (mContext->highestSupportedGpuFamily.apple > 0) {
-        utils::slog.v << "  MTLGPUFamilyApple" << (int) mContext->highestSupportedGpuFamily.apple << utils::io::endl;
+        LOG(INFO) << "  MTLGPUFamilyApple" << (int) mContext->highestSupportedGpuFamily.apple;
    }
    if (mContext->highestSupportedGpuFamily.mac > 0) {
-        utils::slog.v << "  MTLGPUFamilyMac" << (int) mContext->highestSupportedGpuFamily.mac << utils::io::endl;
+        LOG(INFO) << "  MTLGPUFamilyMac" << (int) mContext->highestSupportedGpuFamily.mac;
    }
-    utils::slog.v << "Features:" << utils::io::endl;
-    utils::slog.v << "  readWriteTextureSupport: " <<
-            (bool) mContext->device.readWriteTextureSupport << utils::io::endl;
+    LOG(INFO) << "Features:";
+    LOG(INFO) << "  readWriteTextureSupport: " << (bool) mContext->device.readWriteTextureSupport;

    // In order to support texture swizzling, the GPU needs to support it and the system be running
    // iOS 13+.
@@ -588,7 +585,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);
-    utils::slog.d << program << utils::io::endl;
+    DLOG(INFO) << program;
 #endif
    construct_handle<MetalProgram>(rph, *mContext, std::move(program));
 }
@@ -2077,7 +2074,7 @@ void MetalDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGro
                                                            error:&error];
    if (error) {
        auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
-        utils::slog.e << description << utils::io::endl;
+        LOG(ERROR) << description;
    }
    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]; \
-        utils::slog.e << description << utils::io::endl;                                           \
+        LOG(ERROR) << description;                                                                 \
    }                                                                                              \
    FILAMENT_CHECK_POSTCONDITION(error == nil) << message;

@@ -27,10 +27,11 @@

 #include "private/backend/BackendUtils.h"

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

 #include <math/scalar.h>

@@ -115,14 +116,14 @@ MetalSwapChain::MetalSwapChain(
      type(SwapChainType::CAMETALLAYER) {

    if (!(flags & SwapChain::CONFIG_TRANSPARENT) && !nativeWindow.opaque) {
-        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;
+        LOG(WARNING) << "Warning: Filament SwapChain has no CONFIG_TRANSPARENT flag, but the "
+                        "CAMetaLayer("
+                     << (__bridge void*) nativeWindow << ") has .opaque set to NO.";
    }
    if ((flags & SwapChain::CONFIG_TRANSPARENT) && nativeWindow.opaque) {
-        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;
+        LOG(WARNING) << "Warning: Filament SwapChain has the CONFIG_TRANSPARENT flag, but the "
+                        "CAMetaLayer("
+                     << (__bridge void*) nativeWindow << ") has .opaque set to YES.";
    }

    // Needed so we can use the SwapChain as a blit source.
@@ -21,6 +21,7 @@
 #include <backend/Program.h>

 #include <utils/JobSystem.h>
+#include <utils/Logger.h>
 #include <utils/Mutex.h>

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

 #include "MetalEnums.h"

-#include <utils/Log.h>
+#include <utils/Logger.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];
-        utils::slog.e << description << utils::io::endl;
+        LOG(ERROR) << description;
        [[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]) {
-        utils::slog.w << "Warning: sample comparison not supported by this GPU" << utils::io::endl;
+        LOG(WARNING) << "Warning: sample comparison not supported by this GPU";
        samplerDescriptor.compareFunction = MTLCompareFunctionNever;
    }
 #endif
@@ -19,7 +19,7 @@

 #include "MetalDriverFactory.h"

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

 #import <Foundation/Foundation.h>

@@ -129,9 +129,8 @@ void PlatformMetalImpl::createDeviceImpl(MetalDevice& outDevice) {
        result = MTLCreateSystemDefaultDevice();
    }

-    utils::slog.i << "Selected physical device '"
-                  << [result.name cStringUsingEncoding:NSUTF8StringEncoding] << "'"
-                  << utils::io::endl;
+    LOG(INFO) << "Selected physical device '"
+              << [result.name cStringUsingEncoding:NSUTF8StringEncoding] << "'";

    outDevice.device = result;
    mDevice = result;
@@ -360,7 +360,7 @@ void GLDescriptorSet::bind(
            }
        }, entry.desc);
    });
-    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_ERROR()
 }

 void GLDescriptorSet::validate(HandleAllocatorGL& allocator,
@@ -18,6 +18,7 @@

 #include "private/backend/Driver.h"

+#include <utils/Logger.h>
 #include <utils/compiler.h>
 #include <utils/ostream.h>
 #include <utils/trap.h>
@@ -25,6 +26,7 @@
 #include <string_view>

 #include <stddef.h>
+#include <cstdio>

 namespace filament::backend {

@@ -55,19 +57,21 @@ std::string_view getGLErrorString(GLenum error) noexcept {
 }

 UTILS_NOINLINE
-GLenum checkGLError(io::ostream& out, const char* function, size_t line) noexcept {
+GLenum checkGLError(const char* function, size_t line) noexcept {
    GLenum const error = glGetError();
    if (UTILS_VERY_UNLIKELY(error != GL_NO_ERROR)) {
        auto const string = getGLErrorString(error);
-        out << "OpenGL error " << io::hex << error << " (" << string << ") in \""
-            << function << "\" at line " << io::dec << line << io::endl;
+        char hexError[16];
+        snprintf(hexError, sizeof(hexError), "%#x", error);
+        LOG(ERROR) << "OpenGL error " << hexError << " (" << string << ") in \"" << function
+                   << "\" at line " << line;
    }
    return error;
 }

 UTILS_NOINLINE
-void assertGLError(io::ostream& out, const char* function, size_t line) noexcept {
-    GLenum const err = checkGLError(out, function, line);
+void assertGLError(const char* function, size_t line) noexcept {
+    GLenum const err = checkGLError(function, line);
    if (UTILS_VERY_UNLIKELY(err != GL_NO_ERROR)) {
        debug_trap();
    }
@@ -97,19 +101,21 @@ std::string_view getFramebufferStatusString(GLenum status) noexcept {
 }

 UTILS_NOINLINE
-GLenum checkFramebufferStatus(io::ostream& out, GLenum target, const char* function, size_t line) noexcept {
+GLenum checkFramebufferStatus(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);
-        out << "OpenGL framebuffer error " << io::hex << status << " (" << string << ") in \""
-            << function << "\" at line " << io::dec << line << io::endl;
+        char hexStatus[16];
+        snprintf(hexStatus, sizeof(hexStatus), "%#x", status);
+        LOG(ERROR) << "OpenGL framebuffer error " << hexStatus << " (" << string << ") in \""
+                   << function << "\" at line " << line;
    }
    return status;
 }

 UTILS_NOINLINE
-void assertFramebufferStatus(io::ostream& out, GLenum target, const char* function, size_t line) noexcept {
-    GLenum const status = checkFramebufferStatus(out, target, function, line);
+void assertFramebufferStatus(GLenum target, const char* function, size_t line) noexcept {
+    GLenum const status = checkFramebufferStatus(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(utils::io::ostream& out, const char* function, size_t line) noexcept;
-void assertGLError(utils::io::ostream& out, const char* function, size_t line) noexcept;
+GLenum checkGLError(const char* function, size_t line) noexcept;
+void assertGLError(const char* function, size_t line) noexcept;

 std::string_view getFramebufferStatusString(GLenum err) 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;
+GLenum checkFramebufferStatus(GLenum target, const char* function, size_t line) noexcept;
+void assertFramebufferStatus(GLenum target, const char* function, size_t line) noexcept;

 #ifdef NDEBUG
-#   define CHECK_GL_ERROR(out)
-#   define CHECK_GL_ERROR_NON_FATAL(out)
-#   define CHECK_GL_FRAMEBUFFER_STATUS(out, target)
+#   define CHECK_GL_ERROR()
+#   define CHECK_GL_ERROR_NON_FATAL()
+#   define CHECK_GL_FRAMEBUFFER_STATUS(target)
 #else
-#   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__); }
+#   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__); }
 #endif

 constexpr GLuint getComponentCount(ElementType const type) noexcept {
@@ -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);

-    slog.v << "[" << state.vendor << "], [" << state.renderer << "], "
-              "[" << state.version << "], [" << state.shader << "]" << io::endl;
+    LOG(INFO) << "[" << state.vendor << "], [" << state.renderer << "], "
+                 "[" << state.version << "], [" << state.shader << "]";

    /*
     * Figure out GL / GLES version, extensions and capabilities we need to
@@ -164,51 +164,33 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
    }
 #endif

-    slog.v << "Feature level: " << +mFeatureLevel << '\n';
-    slog.v << "Active workarounds: " << '\n';
+    LOG(INFO) << "Feature level: " << +mFeatureLevel;
+    LOG(INFO) << "Active workarounds: ";
    UTILS_NOUNROLL
    for (auto [enabled, name, _] : mBugDatabase) {
        if (enabled) {
-            slog.v << name << '\n';
+            LOG(INFO) << name;
        }
    }
-    flush(slog.v);

 #ifndef NDEBUG
    // this is useful for development
-    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);
+    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;
 #endif

 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
@@ -242,15 +224,14 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
    if (ext.KHR_debug) {
        auto cb = +[](GLenum, GLenum type, GLuint, GLenum severity, GLsizei length,
                const GLchar* message, const void *) {
-            io::ostream* stream = &slog.i;
+            auto logSeverity = utils::LogSeverity::kInfo;
            switch (severity) {
-                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_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_NOTIFICATION:
                default: break;
            }
-            io::ostream& out = *stream;
            const char* level = ": ";
            switch (type) {
                case GL_DEBUG_TYPE_ERROR:               level = "ERROR: ";               break;
@@ -262,7 +243,7 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
                case GL_DEBUG_TYPE_MARKER:              level = "MARKER: ";              break;
                default: break;
            }
-            out << "KHR_debug " << level << std::string_view{ message, size_t(length) } << io::endl;
+            LOG(LEVEL(logSeverity)) << "KHR_debug " << level << std::string_view{ message, size_t(length) };
        };
        glEnable(GL_DEBUG_OUTPUT);
        glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
@@ -707,9 +688,8 @@ 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) {
-            slog.d << "\"" << std::string_view(extension) << "\"\n";
+            DLOG(INFO) << "\"" << std::string_view(extension) << "\"";
        }
-        flush(slog.d);
    }

    // figure out and initialize the extensions we need
@@ -783,9 +763,8 @@ void OpenGLContext::initExtensionsGL(Extensions* ext, GLint major, GLint minor)
    }
    if constexpr (DEBUG_PRINT_EXTENSIONS) {
        for (auto extension: exts) {
-            slog.d << "\"" << std::string_view(extension) << "\"\n";
+            DLOG(INFO) << "\"" << std::string_view(extension) << "\"";
        }
-        flush(slog.d);
    }

    using namespace std::literals;
@@ -1045,7 +1024,7 @@ GLuint OpenGLContext::getSamplerSlow(SamplerParams params) const noexcept {
                std::min(gets.max_anisotropy, anisotropy));
    }
 #endif
-    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_ERROR()
    mSamplerMap[params] = s;
    return s;
 }
@@ -48,12 +48,13 @@

 #include <type_traits>
 #include <utils/BitmaskEnum.h>
-#include <utils/FixedCapacityVector.h>
 #include <utils/CString.h>
+#include <utils/FixedCapacityVector.h>
 #include <utils/Invocable.h>
-#include <utils/Log.h>
+#include <utils/Logger.h>
 #include <utils/Panic.h>
 #include <utils/Slice.h>
+#include <utils/Systrace.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/ostream.h>
@@ -184,20 +185,18 @@ OpenGLDriver* OpenGLDriver::create(OpenGLPlatform* platform,
    //    GLVertexBufferInfo        : 132       moderate
    // -- less than or equal to 136 bytes

-    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;
+    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);
 #endif

    // here we check we're on a supported version of GL before initializing the driver
@@ -289,7 +288,7 @@ OpenGLDriver::OpenGLDriver(OpenGLPlatform* platform, const Platform::DriverConfi
    mStreamsWithPendingAcquiredImage.reserve(8);

 #ifndef NDEBUG
-    slog.i << "OS version: " << mPlatform.getOSVersion() << io::endl;
+    LOG(INFO) << "OS version: " << mPlatform.getOSVersion();
 #endif

    // Timer queries are core in GL 3.3, otherwise we need EXT_disjoint_timer_query
@@ -668,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(utils::slog.e)
+    CHECK_GL_ERROR()
 }

 void OpenGLDriver::createBufferObjectR(Handle<HwBufferObject> boh,
@@ -693,7 +692,7 @@ void OpenGLDriver::createBufferObjectR(Handle<HwBufferObject> boh,
        glBufferData(bo->gl.binding, byteCount, nullptr, getBufferUsage(usage));
    }

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

 void OpenGLDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph,
@@ -730,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(utils::slog.e)
+    CHECK_GL_ERROR()
 }

 void OpenGLDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {
@@ -760,7 +759,7 @@ void OpenGLDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {
    }

    construct<OpenGLProgram>(ph, *this, std::move(program));
-    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_ERROR()
 }

 UTILS_NOINLINE
@@ -953,7 +952,7 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
        renderBufferStorage(t->gl.id, internalFormat, w, h, samples);
    }

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

 void OpenGLDriver::createTextureViewR(Handle<HwTexture> th,
@@ -999,7 +998,7 @@ void OpenGLDriver::createTextureViewR(Handle<HwTexture> th,
    assert_invariant(ref);
    ref->count++;

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

 void OpenGLDriver::createTextureViewSwizzleR(Handle<HwTexture> th, Handle<HwTexture> srch,
@@ -1062,7 +1061,7 @@ void OpenGLDriver::createTextureViewSwizzleR(Handle<HwTexture> th, Handle<HwText
    assert_invariant(ref);
    ref->count++;

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

 void OpenGLDriver::createTextureExternalImage2R(Handle<HwTexture> th, SamplerType target,
@@ -1225,7 +1224,7 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
 #endif
    }

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

 void OpenGLDriver::updateVertexArrayObject(GLRenderPrimitive* rp, GLVertexBuffer const* vb) {
@@ -1485,7 +1484,7 @@ void OpenGLDriver::framebufferTexture(TargetBufferInfo const& binfo,
                // we shouldn't be here
                break;
        }
-        CHECK_GL_ERROR(utils::slog.e)
+        CHECK_GL_ERROR()
    } else
 #ifndef __EMSCRIPTEN__
 #ifdef GL_EXT_multisampled_render_to_texture
@@ -1506,7 +1505,7 @@ void OpenGLDriver::framebufferTexture(TargetBufferInfo const& binfo,
            glFramebufferRenderbuffer(GL_FRAMEBUFFER, attachment,
                    GL_RENDERBUFFER, t->gl.id);
        }
-        CHECK_GL_ERROR(utils::slog.e)
+        CHECK_GL_ERROR()
    } else
 #endif // GL_EXT_multisampled_render_to_texture
 #endif // __EMSCRIPTEN__
@@ -1588,13 +1587,13 @@ void OpenGLDriver::framebufferTexture(TargetBufferInfo const& binfo,
                break;
        }

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

    rt->gl.resolve |= resolveFlags;

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

 void OpenGLDriver::renderBufferStorage(GLuint rbo, GLenum internalformat, uint32_t width, // NOLINT(readability-convert-member-functions-to-static)
@@ -1623,7 +1622,7 @@ void OpenGLDriver::renderBufferStorage(GLuint rbo, GLenum internalformat, uint32
    // unbind the renderbuffer, to avoid any later confusion
    glBindRenderbuffer(GL_RENDERBUFFER, 0);

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

 void OpenGLDriver::createDefaultRenderTargetR(
@@ -1720,7 +1719,7 @@ void OpenGLDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
        if (UTILS_LIKELY(!getContext().isES2())) {
            glDrawBuffers((GLsizei)maxDrawBuffers, bufs);
        }
-        CHECK_GL_ERROR(utils::slog.e)
+        CHECK_GL_ERROR()
    }
 #endif

@@ -1760,7 +1759,7 @@ void OpenGLDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
    assert_invariant(any(targets & TargetBufferFlags::ALL));
    assert_invariant(tmin == tmax);

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

 void OpenGLDriver::createFenceR(Handle<HwFence> fh, int) {
@@ -2111,7 +2110,7 @@ void OpenGLDriver::setAcquiredImage(Handle<HwStream> sh, void* hwbuffer, const m

    if (UTILS_UNLIKELY(glstream->user_thread.pending.image)) {
        scheduleRelease(glstream->user_thread.pending);
-        slog.w << "Acquired image is set more than once per frame." << io::endl;
+        LOG(WARNING) << "Acquired image is set more than once per frame.";
    }

    glstream->user_thread.pending = mPlatform.transformAcquiredImage({
@@ -2560,7 +2559,7 @@ void OpenGLDriver::makeCurrent(Handle<HwSwapChain> schDraw, Handle<HwSwapChain>

                // OpenGL context has changed, resynchronize the state with the cache
                mContext.synchronizeStateAndCache(index);
-                slog.d << "*** OpenGL context change : " << (index ? "protected" : "default") << io::endl;
+                DLOG(INFO) << "*** OpenGL context change : " << (index ? "protected" : "default");
            });

    mCurrentDrawSwapChain = scDraw;
@@ -2601,7 +2600,7 @@ void OpenGLDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh,
        vb->bufferObjectsVersion = (version + 1) % kMaxVersion;
    }

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

 void OpenGLDriver::updateIndexBuffer(
@@ -2618,7 +2617,7 @@ void OpenGLDriver::updateIndexBuffer(

    scheduleDestroy(std::move(p));

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

 void OpenGLDriver::registerBufferObjectStreams(Handle<HwBufferObject> boh, BufferObjectStreamDescriptor&& streams) {
@@ -2698,7 +2697,7 @@ void OpenGLDriver::updateBufferObject(

    scheduleDestroy(std::move(bd));

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

 void OpenGLDriver::updateBufferObjectUnsynchronized(
@@ -2745,7 +2744,7 @@ retry:
            scheduleDestroy(std::move(bd));
        }
    }
-    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_ERROR()
 #endif
 }

@@ -2795,7 +2794,7 @@ void OpenGLDriver::generateMipmaps(Handle<HwTexture> th) {

    glGenerateMipmap(t->gl.target);

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

 void OpenGLDriver::setTextureData(GLTexture const* t, uint32_t level,
@@ -2904,7 +2903,7 @@ void OpenGLDriver::setTextureData(GLTexture const* t, uint32_t level,

    scheduleDestroy(std::move(p));

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

 void OpenGLDriver::setCompressedTextureData(GLTexture const* t, uint32_t level,
@@ -2990,7 +2989,7 @@ void OpenGLDriver::setCompressedTextureData(GLTexture const* t, uint32_t level,

    scheduleDestroy(std::move(p));

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

 void OpenGLDriver::setupExternalImage2(Platform::ExternalImageHandleRef image) {
@@ -3153,7 +3152,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(utils::slog.e, GL_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(GL_FRAMEBUFFER)

    // each render-pass starts with a disabled scissor
    gl.disable(GL_SCISSOR_TEST);
@@ -3165,7 +3164,7 @@ void OpenGLDriver::beginRenderPass(Handle<HwRenderTarget> rth,
        if (attachmentCount) {
            gl.procs.invalidateFramebuffer(GL_FRAMEBUFFER, attachmentCount, attachments.data());
        }
-        CHECK_GL_ERROR(utils::slog.e)
+        CHECK_GL_ERROR()
    } 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).
@@ -3252,7 +3251,7 @@ void OpenGLDriver::endRenderPass(int) {
            if (attachmentCount) {
                gl.procs.invalidateFramebuffer(GL_FRAMEBUFFER, attachmentCount, attachments.data());
            }
-           CHECK_GL_ERROR(utils::slog.e)
+           CHECK_GL_ERROR()
        }
    }

@@ -3298,13 +3297,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(utils::slog.e, GL_READ_FRAMEBUFFER)
-        CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)
+        CHECK_GL_FRAMEBUFFER_STATUS(GL_READ_FRAMEBUFFER)
+        CHECK_GL_FRAMEBUFFER_STATUS(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(utils::slog.e)
+        CHECK_GL_ERROR()
    }
 #endif
 }
@@ -3483,7 +3482,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(utils::slog.e)
+            CHECK_GL_ERROR()

            // now we need to flip the buffer vertically to match our API
            size_t const stride = p.stride ? p.stride : width;
@@ -3515,7 +3514,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(utils::slog.e)
+    CHECK_GL_ERROR()

    // we're forced to make a copy on the heap because otherwise it deletes std::function<> copy
    // constructor.
@@ -3555,7 +3554,7 @@ void OpenGLDriver::readPixels(Handle<HwRenderTarget> src,
        glDeleteBuffers(1, &pbo);
        scheduleDestroy(std::move(p));
        delete pUserBuffer;
-        CHECK_GL_ERROR(utils::slog.e)
+        CHECK_GL_ERROR()
    });
 #endif
 }
@@ -3580,7 +3579,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(utils::slog.e)
+        CHECK_GL_ERROR()

        // then, we schedule a mapBuffer of the PBO later, once the fence has signaled
        auto* pUserBuffer = new BufferDescriptor(std::move(p));
@@ -3597,7 +3596,7 @@ void OpenGLDriver::readBufferSubData(BufferObjectHandle boh,
            glDeleteBuffers(1, &pbo);
            scheduleDestroy(std::move(p));
            delete pUserBuffer;
-            CHECK_GL_ERROR(utils::slog.e)
+            CHECK_GL_ERROR()
        });
    } else {
        gl.bindBuffer(bo->gl.binding, bo->gl.id);
@@ -3610,7 +3609,7 @@ void OpenGLDriver::readBufferSubData(BufferObjectHandle boh,
        }
        gl.bindBuffer(bo->gl.binding, 0);
        scheduleDestroy(std::move(p));
-        CHECK_GL_ERROR(utils::slog.e)
+        CHECK_GL_ERROR()
    }
 #endif
 }
@@ -3640,7 +3639,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(utils::slog.e)
+    CHECK_GL_ERROR()
 }

 void OpenGLDriver::executeGpuCommandsCompleteOps() noexcept {
@@ -3858,7 +3857,7 @@ void OpenGLDriver::clearWithRasterPipe(TargetBufferFlags clearFlags,
        }
    }

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

 void OpenGLDriver::resolve(
@@ -3969,7 +3968,7 @@ void OpenGLDriver::blit(
        case SamplerType::SAMPLER_EXTERNAL:
            break;
    }
-    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(GL_DRAW_FRAMEBUFFER)

    gl.bindFramebuffer(GL_READ_FRAMEBUFFER, fbo[1]);
    switch (s->target) {
@@ -3995,14 +3994,14 @@ void OpenGLDriver::blit(
        case SamplerType::SAMPLER_EXTERNAL:
            break;
    }
-    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(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(utils::slog.e)
+    CHECK_GL_ERROR()

    gl.unbindFramebuffer(GL_DRAW_FRAMEBUFFER);
    gl.unbindFramebuffer(GL_READ_FRAMEBUFFER);
@@ -4065,15 +4064,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(utils::slog.e, GL_READ_FRAMEBUFFER)
-    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(GL_READ_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(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(utils::slog.e)
+    CHECK_GL_ERROR()
 #endif
 }

@@ -4200,9 +4199,9 @@ void OpenGLDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
 #endif

 #if FILAMENT_ENABLE_MATDBG
-    CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
+    CHECK_GL_ERROR_NON_FATAL()
 #else
-    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_ERROR()
 #endif
 }

@@ -4232,9 +4231,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(utils::slog.e)
+    CHECK_GL_ERROR_NON_FATAL()
 #else
-    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_ERROR()
 #endif
 }

@@ -4284,9 +4283,9 @@ void OpenGLDriver::dispatchCompute(Handle<HwProgram> program, uint3 workGroupCou
 #endif // BACKEND_OPENGL_LEVEL_GLES31

 #if FILAMENT_ENABLE_MATDBG
-    CHECK_GL_ERROR_NON_FATAL(utils::slog.e)
+    CHECK_GL_ERROR_NON_FATAL()
 #else
-    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_ERROR()
 #endif
 }

@@ -214,7 +214,7 @@ void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint progra
                case DescriptorType::INPUT_ATTACHMENT:
                    break;
            }
-            CHECK_GL_ERROR(utils::slog.e)
+            CHECK_GL_ERROR()
        }
    }

@@ -114,14 +114,14 @@ void TimerQueryNativeFactory::createTimerQuery(GLTimerQuery* tq) {

    tq->state = std::make_shared<GLTimerQuery::State>();
    mContext.procs.genQueries(1u, &tq->state->gl.query);
-    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_ERROR()
 }

 void TimerQueryNativeFactory::destroyTimerQuery(GLTimerQuery* tq) {
    assert_invariant(tq->state);

    mContext.procs.deleteQueries(1u, &tq->state->gl.query);
-    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_ERROR()

    tq->state.reset();
 }
@@ -131,14 +131,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(utils::slog.e)
+    CHECK_GL_ERROR()
 }

 void TimerQueryNativeFactory::endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQuery* tq) {
    assert_invariant(tq->state);

    mContext.procs.endQuery(GL_TIME_ELAPSED);
-    CHECK_GL_ERROR(utils::slog.e)
+    CHECK_GL_ERROR()

    std::weak_ptr<GLTimerQuery::State> const weak = tq->state;

@@ -153,7 +153,7 @@ void TimerQueryNativeFactory::endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQ

        GLuint available = 0;
        context.procs.getQueryObjectuiv(state->gl.query, GL_QUERY_RESULT_AVAILABLE, &available);
-        CHECK_GL_ERROR(utils::slog.e)
+        CHECK_GL_ERROR()
        if (!available) {
            // we need to try this one again later
            return false;
@@ -31,14 +31,14 @@

 #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/Log.h>
-#include <utils/ostream.h>
+#include <utils/Logger.h>
 #include <utils/Panic.h>
+#include <utils/compiler.h>
+#include <utils/debug.h>
+#include <utils/ostream.h>

 #include <algorithm>
 #include <array>
@@ -65,9 +65,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(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 logCompilationError(ShaderStage shaderType, const char* name, GLuint shaderId,
+        CString const& sourceCode) noexcept;
+static void logProgramLinkError(char const* name, GLuint program) noexcept;

 static void process_GOOGLE_cpp_style_line_directive(OpenGLContext const& context, char* source,
        size_t len) noexcept;
@@ -433,8 +433,9 @@ 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)) {
-                slog.w << "Shader compilation for OpenGL program " << token->name.c_str_safe()
-                       << " is not completed yet. The following program link may not succeed.";
+                LOG(WARNING)
+                        << "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);
@@ -644,8 +645,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
        }
        // Something went wrong. Log the error message.
        const ShaderStage type = static_cast<ShaderStage>(i);
-        logCompilationError(slog.e, type, token->name.c_str_safe(), shader,
-                token->shaderSourceCode[i]);
+        logCompilationError(type, token->name.c_str_safe(), shader, token->shaderSourceCode[i]);
    }
 }

@@ -697,7 +697,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(slog.e, token->name.c_str_safe(), token->gl.program);
+        logProgramLinkError(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.
@@ -747,7 +747,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
 // ------------------------------------------------------------------------------------------------

 UTILS_NOINLINE
-/* static */ void logCompilationError(io::ostream& out, ShaderStage shaderType, const char* name,
+/* static */ void logCompilationError(ShaderStage shaderType, const char* name,
        GLuint const shaderId, UTILS_UNUSED_IN_RELEASE CString const& sourceCode) noexcept {

    { // scope for the temporary string storage
@@ -769,8 +769,9 @@ UTILS_NOINLINE
        CString infoLog(length);
        glGetShaderInfoLog(shaderId, length, nullptr, infoLog.data());

-        out << "Compilation error in " << to_string(shaderType) << " shader \"" << name << "\":\n"
-            << "\"" << infoLog.c_str() << "\"" << io::endl;
+        LOG(ERROR) << "Compilation error in " << to_string(shaderType) << " shader \"" << name
+                   << "\":";
+        LOG(ERROR) << "\"" << infoLog.c_str() << "\"";
    }

 #ifndef NDEBUG
@@ -785,26 +786,25 @@ UTILS_NOINLINE
        } else {
            line = shader.substr(start, end - start);
        }
-        out << lc++ << ":   " << line.c_str() << '\n';
+        LOG(ERROR) << lc++ << ":   " << line.c_str();
        if (end == std::string::npos) {
            break;
        }
        start = end + 1;
    }
-    out << io::endl;
+    LOG(ERROR) << "";
 #endif
 }

 UTILS_NOINLINE
-/* static */ void logProgramLinkError(io::ostream& out, char const* name, GLuint program) noexcept {
+/* static */ void logProgramLinkError(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());

-    out << "Link error in \"" << name << "\":\n"
-        << "\"" << infoLog.c_str() << "\"" << io::endl;
+    LOG(ERROR) << "Link error in \"" << name << "\":\n" << "\"" << infoLog.c_str() << "\"";
 }

 // If usages of the Google-style line directive are present, remove them, as some
@@ -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(utils::slog.e)
+    CHECK_GL_ERROR()
 }

 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(utils::slog.e)
+    CHECK_GL_ERROR()

    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(utils::slog.e)
+    CHECK_GL_ERROR()

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

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

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

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

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

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

    glGenFramebuffers(1, &mFBO);

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

 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(utils::slog.e)
+    CHECK_GL_ERROR()

    // 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(utils::slog.e)
-    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_FRAMEBUFFER)
+    CHECK_GL_ERROR()
+    CHECK_GL_FRAMEBUFFER_STATUS(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(utils::slog.e)
+    CHECK_GL_ERROR()

    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, *)) {
-        slog.d << "Using ASurfaceTexture" << io::endl;
+        DLOG(INFO) << "Using ASurfaceTexture";
    }
 }

@@ -32,9 +32,9 @@
 #endif
 #include <utils/compiler.h>

-#include <utils/debug.h>
 #include <utils/Invocable.h>
-#include <utils/Log.h>
+#include <utils/Logger.h>
+#include <utils/debug.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 {
-    slog.e << name << " failed with " << getEglErrorName(error) << io::endl;
+    LOG(ERROR) << name << " failed with " << getEglErrorName(error);
 }

 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) {
-        slog.w << "Ignoring pending GL error " << io::hex << error << io::endl;
+        LOG(WARNING) << "Ignoring pending GL error " << io::hex << error;
    }
 }

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

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

@@ -29,13 +29,12 @@
 #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>
@@ -327,7 +326,7 @@ bool PlatformEGLAndroid::setImage(ExternalImageEGLAndroid const* eglExternalImag
            EGL_NATIVE_BUFFER_ANDROID, clientBuffer, imageAttrs);
    if (eglImage == EGL_NO_IMAGE_KHR) {
        // Handle error
-        slog.e << "Failed to create EGL image" << io::endl;
+        LOG(ERROR) << "Failed to create EGL image";
        glDeleteTextures(1, &texture->id);
        return false;
    }
@@ -340,7 +339,7 @@ bool PlatformEGLAndroid::setImage(ExternalImageEGLAndroid const* eglExternalImag
    glBindTexture(texture->target, texture->id);
    GLenum error = glGetError();
    if (UTILS_UNLIKELY(error != GL_NO_ERROR)) {
-        slog.e << "Error after glBindTexture: " << error << io::endl;
+        LOG(ERROR) << "Error after glBindTexture: " << error;
        glDeleteTextures(1, &texture->id);
        eglDestroyImageKHR(eglGetCurrentDisplay(), eglImage);
        glActiveTexture(prevActiveTexture);
@@ -350,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)) {
-        slog.e << "Error after glEGLImageTargetTexture2DOES: " << error << io::endl;
+        LOG(ERROR) << "Error after glEGLImageTargetTexture2DOES: " << error;
        glDeleteTextures(1, &texture->id);
        eglDestroyImageKHR(eglGetCurrentDisplay(), eglImage);
        glActiveTexture(prevActiveTexture);
@@ -408,7 +407,7 @@ AcquiredImage PlatformEGLAndroid::transformAcquiredImage(AcquiredImage source) n

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

@@ -427,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) {
-        slog.e << "eglCreateImageKHR returned no image." << io::endl;
+        LOG(ERROR) << "eglCreateImageKHR returned no image.";
        return {};
    }

@@ -442,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) {
-            slog.e << "eglDestroyImageKHR failed." << io::endl;
+            LOG(ERROR) << "eglDestroyImageKHR failed.";
        }
        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/compiler.h>
-#include <utils/Log.h>
+#include <utils/Logger.h>
 #include <utils/Panic.h>
+#include <utils/compiler.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)) {
-        slog.e << "eglBindAPI EGL_OPENGL_API failed" << io::endl;
+        LOG(ERROR) << "eglBindAPI EGL_OPENGL_API failed";
        return nullptr;
    }
    int bindBlueGL = bluegl::bind();
    if (UTILS_UNLIKELY(bindBlueGL != 0)) {
-        slog.e << "bluegl bind failed" << io::endl;
+        LOG(ERROR) << "bluegl bind failed";
        return nullptr;
    }

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

 #include <backend/platforms/PlatformGLX.h>

-#include <utils/Log.h>
+#include <utils/Logger.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) {
-        utils::slog.e << "Could not find library " << LIBRARY_GLX << utils::io::endl;
+        LOG(ERROR) << "Could not find library " << LIBRARY_GLX;
        return false;
    }

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

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

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

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

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

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

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

@@ -164,8 +163,7 @@ 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) {
-                utils::slog.e << "Failed to get GLX_FBCONFIG_ID for entry " << i << "."
-                              << utils::io::endl;
+                LOG(ERROR) << "Failed to get GLX_FBCONFIG_ID for entry " << i << ".";
                continue;
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -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() << utils::io::endl;
+                      << " layout=" << dst.getLayout();
    }

    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() << utils::io::endl;
+                      << " layout=" << dst.getLayout();
    }

    VkImageSubresourceRange const srcRange = src.getSubresourceRange();
@@ -27,8 +27,7 @@ namespace filament::backend {

 VulkanBufferProxy::VulkanBufferProxy(VmaAllocator allocator, VulkanStagePool& stagePool,
        VulkanBufferCache& bufferCache, VulkanBufferUsage usage, uint32_t numBytes)
-    : mAllocator(allocator),
-      mStagePool(stagePool),
+    : mStagePool(stagePool),
      mBufferCache(bufferCache),
      mBuffer(mBufferCache.acquire(usage, numBytes)),
      mUpdatedOffset(0),
@@ -39,10 +38,8 @@ void VulkanBufferProxy::loadFromCpu(VulkanCommandBuffer& commands, const void* c
    // 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);
+    stage->copy(0, cpuData, numBytes);

    // If there was a previous update, then we need to make sure the following write is properly
    // synced with the previous read.
@@ -40,7 +40,6 @@ public:
    VulkanBufferUsage getUsage() const noexcept;

 private:
-    VmaAllocator mAllocator;
    VulkanStagePool& mStagePool;
    VulkanBufferCache& mBufferCache;

@@ -215,7 +215,7 @@ VkSemaphore VulkanCommandBuffer::submit() {
    }
    FVK_LOGI << ") "
             << " signal=" << mSubmission
-             << " fence=" << mFence << utils::io::endl;
+             << " fence=" << mFence;
 #endif

    mFenceStatus->setStatus(VK_NOT_READY);
@@ -224,7 +224,7 @@ VkSemaphore VulkanCommandBuffer::submit() {

 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
    if (result != VK_SUCCESS) {
-        FVK_LOGD << "Failed command buffer submission result: " << result << utils::io::endl;
+        FVK_LOGD << "Failed command buffer submission result: " << result;
    }
 #endif
    assert_invariant(result == VK_SUCCESS);
@@ -490,7 +490,7 @@ void VulkanCommands::pushGroupMarker(char const* str, VulkanGroupMarkers::Timest
        mProtectedPool->pushMarker(str, timestamp);
    }
 #if FVK_ENABLED(FVK_DEBUG_PRINT_GROUP_MARKERS)
-    FVK_LOGD << "----> " << str << utils::io::endl;
+    FVK_LOGD << "----> " << str;
 #endif
 }

@@ -502,8 +502,7 @@ void VulkanCommands::popGroupMarker() {
    auto const& startTime = ret.second;
    auto const endTime = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff = endTime - startTime;
-    FVK_LOGD << "<---- " << marker << " elapsed: " << (diff.count() * 1000) << " ms"
-             << utils::io::endl;
+    FVK_LOGD << "<---- " << marker << " elapsed: " << (diff.count() * 1000) << " ms";
 #else
    mPool->popMarker();
 #endif // FVK_DEBUG_PRINT_GROUP_MARKERS
@@ -17,7 +17,7 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANCONSTANTS_H
 #define TNT_FILAMENT_BACKEND_VULKANCONSTANTS_H

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

 #include <stdint.h>

@@ -73,8 +73,8 @@
 #define FVK_DEBUG_RESOURCE_LEAK           0x00010000

 // Set this to enable logging "only" to one output stream. This is useful in the case where we want
-// to debug with print statements and want ordered logging (e.g slog.i and slog.e will not appear in
-// order of calls).
+// to debug with print statements and want ordered logging (e.g LOG(INFO) and LOG(ERROR) will not
+// appear in order of calls).
 #define FVK_DEBUG_FORCE_LOG_TO_I          0x00020000

 // Enable a minimal set of traces to assess the performance of the backend.
@@ -95,7 +95,7 @@
 #endif

 #ifndef NDEBUG
-#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE | FVK_DEBUG_FORWARDED_FLAG)
+#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE | FVK_DEBUG_FORWARDED_FLAG | FVK_DEBUG_DEBUG_UTILS | FVK_DEBUG_GROUP_MARKERS | FVK_DEBUG_VALIDATION)
 #else
 #define FVK_DEBUG_FLAGS 0
 #endif
@@ -174,15 +174,15 @@ static_assert(FVK_ENABLED(FVK_DEBUG_VALIDATION));
 #endif

 #if FVK_ENABLED(FVK_DEBUG_FORCE_LOG_TO_I)
-    #define FVK_LOGI (utils::slog.i)
+    #define FVK_LOGI LOG(INFO)
    #define FVK_LOGD FVK_LOGI
    #define FVK_LOGE FVK_LOGI
    #define FVK_LOGW FVK_LOGI
 #else
-    #define FVK_LOGE (utils::slog.e)
-    #define FVK_LOGW (utils::slog.w)
-    #define FVK_LOGD (utils::slog.d)
-    #define FVK_LOGI (utils::slog.i)
+    #define FVK_LOGE LOG(ERROR)
+    #define FVK_LOGW LOG(WARNING)
+    #define FVK_LOGD DLOG(INFO)
+    #define FVK_LOGI LOG(INFO)
 #endif

 // All vkCreate* functions take an optional allocator. For now we select the default allocator by
@@ -104,15 +104,15 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallback(VkDebugReportFlagsEXT flags,
        VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location,
        int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData) {
    if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
-        FVK_LOGE << "VULKAN ERROR: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
+        FVK_LOGE << "VULKAN ERROR: (" << pLayerPrefix << ") " << pMessage;
    } else {
        // TODO: emit best practices warnings about aggressive pipeline barriers.
        if (strstr(pMessage, "ALL_GRAPHICS_BIT") || strstr(pMessage, "ALL_COMMANDS_BIT")) {
            return VK_FALSE;
        }
-        FVK_LOGW << "VULKAN WARNING: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
+        FVK_LOGW << "VULKAN WARNING: (" << pLayerPrefix << ") " << pMessage;
    }
-    FVK_LOGE << utils::io::endl;
+    FVK_LOGE;
    return VK_FALSE;
 }
 #endif // FVK_ENABLED(FVK_DEBUG_VALIDATION)
@@ -122,18 +122,16 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugUtilsCallback(VkDebugUtilsMessageSeverityFla
        VkDebugUtilsMessageTypeFlagsEXT types, const VkDebugUtilsMessengerCallbackDataEXT* cbdata,
        void* pUserData) {
    if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
-        FVK_LOGE << "VULKAN ERROR: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
-                 << utils::io::endl;
+        FVK_LOGE << "VULKAN ERROR: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage;
    } else {
        // TODO: emit best practices warnings about aggressive pipeline barriers.
        if (strstr(cbdata->pMessage, "ALL_GRAPHICS_BIT")
                || strstr(cbdata->pMessage, "ALL_COMMANDS_BIT")) {
            return VK_FALSE;
        }
-        FVK_LOGW << "VULKAN WARNING: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
-                 << utils::io::endl;
+        FVK_LOGW << "VULKAN WARNING: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage;
    }
-    FVK_LOGE << utils::io::endl;
+    FVK_LOGE << "";
    return VK_FALSE;
 }
 #endif // FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
@@ -276,20 +274,18 @@ Driver* VulkanDriver::create(VulkanPlatform* platform, VulkanContext const& cont
    //    VulkanRenderTarget            : 312       few
    // -- less than or equal to 312 bytes

-    FVK_LOGD
-           << "\nVulkanSwapChain: " << sizeof(VulkanSwapChain)
-           << "\nVulkanBufferObject: " << sizeof(VulkanBufferObject)
-           << "\nVulkanVertexBuffer: " << sizeof(VulkanVertexBuffer)
-           << "\nVulkanVertexBufferInfo: " << sizeof(VulkanVertexBufferInfo)
-           << "\nVulkanIndexBuffer: " << sizeof(VulkanIndexBuffer)
-           << "\nVulkanRenderPrimitive: " << sizeof(VulkanRenderPrimitive)
-           << "\nVulkanTexture: " << sizeof(VulkanTexture)
-           << "\nVulkanTimerQuery: " << sizeof(VulkanTimerQuery)
-           << "\nHwStream: " << sizeof(HwStream)
-           << "\nVulkanRenderTarget: " << sizeof(VulkanRenderTarget)
-           << "\nVulkanFence: " << sizeof(VulkanFence)
-           << "\nVulkanProgram: " << sizeof(VulkanProgram)
-           << utils::io::endl;
+    FVK_LOGD << "VulkanSwapChain: " << sizeof(VulkanSwapChain);
+    FVK_LOGD << "VulkanBufferObject: " << sizeof(VulkanBufferObject);
+    FVK_LOGD << "VulkanVertexBuffer: " << sizeof(VulkanVertexBuffer);
+    FVK_LOGD << "VulkanVertexBufferInfo: " << sizeof(VulkanVertexBufferInfo);
+    FVK_LOGD << "VulkanIndexBuffer: " << sizeof(VulkanIndexBuffer);
+    FVK_LOGD << "VulkanRenderPrimitive: " << sizeof(VulkanRenderPrimitive);
+    FVK_LOGD << "VulkanTexture: " << sizeof(VulkanTexture);
+    FVK_LOGD << "VulkanTimerQuery: " << sizeof(VulkanTimerQuery);
+    FVK_LOGD << "HwStream: " << sizeof(HwStream);
+    FVK_LOGD << "VulkanRenderTarget: " << sizeof(VulkanRenderTarget);
+    FVK_LOGD << "VulkanFence: " << sizeof(VulkanFence);
+    FVK_LOGD << "VulkanProgram: " << sizeof(VulkanProgram);
 #endif

    assert_invariant(platform);
@@ -799,14 +795,12 @@ void VulkanDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
    mResourceManager.gc();

    if ((flags & backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0 && !isSRGBSwapChainSupported()) {
-        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it"
-                 << utils::io::endl;
+        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it";
        flags = flags | ~(backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE);
    }
    if (flags & backend::SWAP_CHAIN_CONFIG_PROTECTED_CONTENT) {
        if (!isProtectedContentSupported()) {
-            FVK_LOGW << "protected swapchain requested, but Platform does not support it"
-                << utils::io::endl;
+            FVK_LOGW << "protected swapchain requested, but Platform does not support it";
        }
    }
    auto swapChain = resource_ptr<VulkanSwapChain>::make(&mResourceManager, sch, mPlatform,
@@ -817,8 +811,7 @@ void VulkanDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
 void VulkanDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch, uint32_t width,
        uint32_t height, uint64_t flags) {
    if ((flags & backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0 && !isSRGBSwapChainSupported()) {
-        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it"
-                      << utils::io::endl;
+        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it";
        flags = flags | ~(backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE);
    }
    assert_invariant(width > 0 && height > 0 && "Vulkan requires non-zero swap chain dimensions.");
@@ -1306,7 +1299,7 @@ TimerQueryResult VulkanDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint
    uint64_t const end = results.endTime;
    if (begin >= end) {
        // TODO: queries might have ran on different command buffers.
-        FVK_LOGW << "Timestamps are not monotonically increasing. " << utils::io::endl;
+        FVK_LOGW << "Timestamps are not monotonically increasing. ";
        *elapsedTime = 0;
        return TimerQueryResult::ERROR;
    }
@@ -2044,7 +2037,7 @@ void VulkanDriver::debugCommandBegin(CommandStream* cmds, bool synchronous, cons
        assert_invariant(inRenderPass);
        inRenderPass = false;
    } else if (inRenderPass && OUTSIDE_COMMANDS.find(command) != OUTSIDE_COMMANDS.end()) {
-        FVK_LOGE << command.data() << " issued inside a render pass." << utils::io::endl;
+        FVK_LOGE << command.data() << " issued inside a render pass.";
    }
 #endif
 }
@@ -100,8 +100,7 @@ VkFramebuffer VulkanFboCache::getFramebuffer(FboKey const& config) noexcept {
        << "for render pass " << config.renderPass << ", "
        << "samples = " << int(config.samples) << ", "
        << "depth = " << (config.depth ? 1 : 0) << ", "
-        << "attachmentCount = " << attachmentCount
-        << utils::io::endl;
+        << "attachmentCount = " << attachmentCount;
    #endif

    VkFramebufferCreateInfo info {
@@ -341,8 +340,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey const& config) noexcept
             << "needsResolveMask = " << int(config.needsResolveMask) << ", "
             << "usesLazilyAllocatedMemory = " << int(config.usesLazilyAllocatedMemory) << ", "
             << "viewCount = " << int(config.viewCount) << ", "
-             << "colorAttachmentCount[0] = " << subpasses[0].colorAttachmentCount
-             << utils::io::endl;
+             << "colorAttachmentCount[0] = " << subpasses[0].colorAttachmentCount;
 #endif

    return renderPass;
@@ -287,7 +287,7 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept

 #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
    FVK_LOGD << "Created VulkanProgram " << builder << ", shaders = (" << modules[0]
-             << ", " << modules[1] << ")" << utils::io::endl;
+             << ", " << modules[1] << ")";
 #endif
 }

@@ -218,8 +218,7 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n

    #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
        FVK_LOGD << "vkCreateGraphicsPipelines with shaders = ("
-                 << shaderStages[0].module << ", " << shaderStages[1].module << ")"
-                 << utils::io::endl;
+                 << shaderStages[0].module << ", " << shaderStages[1].module << ")";
    #endif
    PipelineCacheEntry cacheEntry = {
        .lastUsed = mCurrentTime,
@@ -228,7 +227,7 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
            VKALLOC, &cacheEntry.handle);
    assert_invariant(error == VK_SUCCESS);
    if (error != VK_SUCCESS) {
-        FVK_LOGE << "vkCreateGraphicsPipelines error " << error << utils::io::endl;
+        FVK_LOGE << "vkCreateGraphicsPipelines error " << error;
        return nullptr;
    }
    return &mPipelines.emplace(mPipelineRequirements, cacheEntry).first.value();
@@ -242,7 +241,7 @@ void VulkanPipelineCache::bindProgram(fvkmemory::resource_ptr<VulkanProgram> pro
 #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
    if (mPipelineRequirements.shaders[0] == VK_NULL_HANDLE ||
            mPipelineRequirements.shaders[1] == VK_NULL_HANDLE) {
-        FVK_LOGE << "Binding missing shader: " << program->name.c_str() << utils::io::endl;
+        FVK_LOGE << "Binding missing shader: " << program->name.c_str();
    }
 #endif
 }
@@ -42,7 +42,7 @@ fvkmemory::resource_ptr<VulkanTimerQuery> VulkanQueryManager::getNextQuery(
        fvkmemory::ResourceManager* resourceManager) {
    auto unused = ~mUsed;
    if (unused.empty()) {
-        FVK_LOGE << "More than " << mUsed.size() << " timers are not supported." << utils::io::endl;
+        FVK_LOGE << "More than " << mUsed.size() << " timers are not supported.";
        return {};
    }

@@ -171,7 +171,7 @@ void VulkanReadPixels::run(fvkmemory::resource_ptr<VulkanRenderTarget> srcTarget
 #if FVK_ENABLED(FVK_DEBUG_READ_PIXELS)
    FVK_LOGD << "readPixels created image=" << stagingImage
             << " to copy from image=" << srcTexture->getVkImage()
-             << " src-layout=" << srcTexture->getLayout(0, 0) << utils::io::endl;
+             << " src-layout=" << srcTexture->getLayout(0, 0);
 #endif

    VkMemoryRequirements memReqs;
@@ -188,8 +188,7 @@ void VulkanReadPixels::run(fvkmemory::resource_ptr<VulkanRenderTarget> srcTarget
        memoryTypeIndex = selectMemoryFunc(memReqs.memoryTypeBits,
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
        FVK_LOGW
-                << "readPixels is slow because VK_MEMORY_PROPERTY_HOST_CACHED_BIT is not available"
-                << utils::io::endl;
+                << "readPixels is slow because VK_MEMORY_PROPERTY_HOST_CACHED_BIT is not available";
    }

    FILAMENT_CHECK_POSTCONDITION(memoryTypeIndex < VK_MAX_MEMORY_TYPES)
@@ -305,7 +304,7 @@ void VulkanReadPixels::run(fvkmemory::resource_ptr<VulkanRenderTarget> srcTarget
                                 fence = readCompleteFence]() mutable {
        VkResult status = vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX);
        if (status != VK_SUCCESS) {
-            FVK_LOGE << "Failed to wait for readPixels fence" << utils::io::endl;
+            FVK_LOGE << "Failed to wait for readPixels fence";
            return;
        }

@@ -323,7 +322,7 @@ void VulkanReadPixels::run(fvkmemory::resource_ptr<VulkanRenderTarget> srcTarget
                    fvkutils::getComponentCount(srcFormat), srcPixels,
                    static_cast<int>(subResourceLayout.rowPitch), static_cast<int>(width),
                    static_cast<int>(height), swizzle)) {
-            FVK_LOGE << "Unsupported PixelDataFormat or PixelDataType" << utils::io::endl;
+            FVK_LOGE << "Unsupported PixelDataFormat or PixelDataType";
        }

        vkUnmapMemory(device, stagingMemory);
@@ -38,15 +38,23 @@ constexpr uint32_t STAGE_SIZE = 1048576;

 fvkmemory::resource_ptr<VulkanStage::Segment> VulkanStage::acquireSegment(
        fvkmemory::ResourceManager* resManager, uint32_t numBytes) {
-    auto segment = fvkmemory::resource_ptr<Segment>::construct(
-        resManager, this, numBytes, mCurrentOffset, [this](uint32_t offset) {
-            mSegments.erase(offset);
-    });
-    mSegments.insert({mCurrentOffset, segment.get()});
+    auto segment = fvkmemory::resource_ptr<Segment>::construct(resManager, mAllocator, this,
+            mCurrentOffset, [this](uint32_t offset) { mSegments.erase(offset); });
+    mSegments.insert({ mCurrentOffset, segment.get() });
+    // constexpr uint32_t BLOCK_SIZE = 16;
+    // uint32_t const additional = BLOCK_SIZE - (numBytes % BLOCK_SIZE);
+    // numBytes += (additional != BLOCK_SIZE ? additional : 0);
    mCurrentOffset += numBytes;
    return segment;
 }

+VkResult VulkanStage::Segment::copy(size_t dstOffset, void const* src, size_t writeSize) {
+    //    uint8_t* mapped = ((uint8_t*) mapping()) + dstOffset;
+    //    memcpy(mapped, src, writeSize);
+    //    return vmaFlushAllocation(mAllocator, memory(), offset() + dstOffset, writeSize);
+    return vmaCopyMemoryToAllocation(mAllocator, src, memory(), offset() + dstOffset, writeSize);
+}
+
 VulkanStagePool::VulkanStagePool(VmaAllocator allocator, fvkmemory::ResourceManager* resManager,
        VulkanCommands* commands, const VkPhysicalDeviceLimits* deviceLimits)
    : mAllocator(allocator),
@@ -108,9 +116,9 @@ VulkanStage* VulkanStagePool::allocateNewStage(uint32_t capacity) {

 #if FVK_ENABLED(FVK_DEBUG_STAGING_ALLOCATION)
    if (result != VK_SUCCESS) {
-        FVK_LOGE << "Allocation error: " << result << utils::io::endl;
+        FVK_LOGE << "Allocation error: " << result;
    } else {
-        FVK_LOGD << "Allocated stage with hndl " << buffer << utils::io::endl;
+        FVK_LOGD << "Allocated stage with hndl " << buffer;
    }
 #endif

@@ -125,7 +133,7 @@ VulkanStage* VulkanStagePool::allocateNewStage(uint32_t capacity) {
 #endif
    }

-    return new VulkanStage(memory, buffer, capacity, pMapping);
+    return new VulkanStage(mAllocator, memory, buffer, capacity, pMapping);
 }

 void VulkanStagePool::destroyStage(VulkanStage const*&& stage) {
@@ -35,8 +35,10 @@ class VulkanCommands;
 // into smaller buffers as needed.
 class VulkanStage {
 public:
-    VulkanStage(VmaAllocation memory, VkBuffer buffer, uint32_t capacity, void* mapping)
-        : mMemory(memory),
+    VulkanStage(VmaAllocator allocator, VmaAllocation memory, VkBuffer buffer, uint32_t capacity,
+            void* mapping)
+        : mAllocator(allocator),
+          mMemory(memory),
          mBuffer(buffer),
          mCapacity(capacity),
          mMapping(mapping) {}
@@ -51,10 +53,10 @@ public:
    public:
        using OnRecycle = std::function<void(uint32_t offset)>;

-        Segment(VulkanStage* parentStage, uint32_t capacity, uint32_t offset,
+        Segment(VmaAllocator allocator, VulkanStage* parentStage, uint32_t offset,
                OnRecycle&& onRecycleFn)
-            : mParentStage(parentStage),
-              mCapacity(capacity),
+            : mAllocator(allocator),
+              mParentStage(parentStage),
              mOffset(offset),
              mOnRecycleFn(onRecycleFn) {}

@@ -70,12 +72,12 @@ public:
        Segment& operator=(const Segment& other) = delete;
        Segment& operator=(Segment&& other) = delete;

-        inline VulkanStage* parentStage() const { return mParentStage; }
-        inline VkBuffer buffer() const { return parentStage()->buffer(); }
-        inline VmaAllocation memory() const { return parentStage()->memory(); }
-        inline uint32_t capacity() const { return mCapacity; }
+        inline VkBuffer buffer() const { return mParentStage->buffer(); }
+        inline VmaAllocation memory() const { return mParentStage->memory(); }
        inline uint32_t offset() const { return mOffset; }

+        VkResult copy(size_t dstOffset, void const* src, size_t writeSize);
+
        inline void* mapping() const {
            return reinterpret_cast<void*>(
                    reinterpret_cast<char*>(mParentStage->mapping()) + offset());
@@ -85,9 +87,9 @@ public:
        // Ensure parent class can access the terminate method.
        friend class VulkanStage;

+        VmaAllocator const mAllocator;
        VulkanStage* const mParentStage;
-        const uint32_t mCapacity;
-        const uint32_t mOffset;
+        uint32_t const mOffset;
        OnRecycle mOnRecycleFn;
    };

@@ -109,6 +111,7 @@ public:
            uint32_t numBytes);

 private:
+    VmaAllocator const mAllocator;
    const VmaAllocation mMemory;
    const VkBuffer mBuffer;
    const uint32_t mCapacity;
@@ -188,8 +188,8 @@ VkImageUsageFlags getUsage(VulkanContext const& context, uint8_t samples,
            VkFormatProperties props;
            vkGetPhysicalDeviceFormatProperties(physicalDevice, vkFormat, &props);
            if (!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
-                FVK_LOGW << "Texture usage is SAMPLEABLE but format " << vkFormat << " is not "
-                        "sampleable with optimal tiling." << utils::io::endl;
+                FVK_LOGW << "Texture usage is SAMPLEABLE but format " << vkFormat
+                         << " is not sampleable with optimal tiling.";
            }
        }
 #endif
@@ -219,8 +219,8 @@ VkImageUsageFlags getUsage(VulkanContext const& context, uint8_t samples,
    return usage;
 }

-void adjustedMemcpy(void* mapped, PixelBufferDescriptor const& p, size_t width, size_t height,
-        size_t depth) {
+void adjustedMemcpy(PixelBufferDescriptor const& p, size_t width, size_t height,
+        size_t depth, std::function<void(size_t, uint8_t*, size_t)> cpy) {
    uint8_t* buf = (uint8_t*) p.buffer;
    size_t const pixelSize = PixelBufferDescriptor::computeDataSize(p.format, p.type, 1, 1, 1);
    size_t const pbdStride = p.stride ? p.stride : width;
@@ -243,13 +243,13 @@ void adjustedMemcpy(void* mapped, PixelBufferDescriptor const& p, size_t width,
            for (size_t y = p.top; y < pbdHeight; y++) {
                uint8_t* buf = (uint8_t*) p.buffer +
                               ((p.left * pixelSize) + (y * pbdRowSize) + (z * pbdLayerSize));
-                uint8_t* curMapped = (uint8_t*) mapped + ((y - p.top) * rowSize + z * layerSize);
-                memcpy(curMapped, buf, writeSize);
+                uint32_t const offset = (y - p.top) * rowSize + z * layerSize;
+                cpy(offset, buf, writeSize);
            }
        }
    } else {
        size_t const writeSize = pixelSize * (width * height * depth);
-        memcpy(mapped, buf, writeSize);
+        cpy(0, buf, writeSize);
    }
 }

@@ -361,7 +361,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
            imageInfo.flags = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT;
        } else {
            FVK_LOGW << "Note: creating 2D views on 3D image is not available on this platform. "
-                     << "i.e. we cannot render to slices of a 3D image" << utils::io::endl;
+                     << "i.e. we cannot render to slices of a 3D image";
        }
    } else if (target == SamplerType::SAMPLER_CUBEMAP) {
        imageInfo.arrayLayers = 6;
@@ -420,7 +420,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
            << "type = " << imageInfo.imageType << ", "
            << "flags = " << imageInfo.flags << ", "
            << "target = " << static_cast<int>(target) <<", "
-            << "format = " << vkFormat << utils::io::endl;
+            << "format = " << vkFormat;
    }
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to create image."
                                                       << " error=" << static_cast<int32_t>(result);
@@ -525,9 +525,12 @@ void VulkanTexture::updateImage(const PixelBufferDescriptor& data, uint32_t widt
    fvkmemory::resource_ptr<VulkanStage::Segment> stageSegment =
            mState->mStagePool.acquireStage(writeSize);
    assert_invariant(stageSegment->memory());
-    adjustedMemcpy(stageSegment->mapping(), *hostData, width, height, depth);
-    vmaFlushAllocation(mState->mAllocator, stageSegment->memory(), stageSegment->offset(),
-            writeSize);
+    adjustedMemcpy(*hostData, width, height, depth,
+            [&stageSegment](size_t dstOffset, uint8_t* src, size_t numBytes) {
+                stageSegment->copy(dstOffset, src, numBytes);
+            });
+//    vmaFlushAllocation(mState->mAllocator, stageSegment->memory(), stageSegment->offset(),
+//            writeSize);

    VulkanCommandBuffer& commands = mState->mCommands->get();
    VkCommandBuffer const cmdbuf = commands.buffer();
@@ -597,7 +600,10 @@ void VulkanTexture::updateImageWithBlit(const PixelBufferDescriptor& data, uint3
    VulkanStageImage const* stage
            = mState->mStagePool.acquireImage(data.format, data.type, width, height);
    vmaMapMemory(mState->mAllocator, stage->memory, &mapped);
-    adjustedMemcpy(mapped, data, width, height, depth);
+    adjustedMemcpy(data, width, height, depth,
+            [&mapped](size_t, uint8_t* src, size_t numBytes) {
+                memcpy(mapped, src, numBytes);
+            });
    vmaUnmapMemory(mState->mAllocator, stage->memory);
    vmaFlushAllocation(mState->mAllocator, stage->memory, 0, writeSize);

@@ -731,14 +737,14 @@ bool VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, VkImageSubresourceR
                 << range.levelCount << ")" << " from=" << oldLayout << " to=" << newLayout
                 << " format=" << mState->mVkFormat << " depth="
                 << fvkutils::isVkDepthFormat(mState->mVkFormat)
-                 << " slice-by-slice=" << transitionSliceBySlice << utils::io::endl;
+                 << " slice-by-slice=" << transitionSliceBySlice;
 #endif
    } else {
 #if FVK_ENABLED(FVK_DEBUG_LAYOUT_TRANSITION)
        FVK_LOGD << "transition texture=" << mState->mTextureImage << " (" << range.baseArrayLayer
                 << "," << range.baseMipLevel << ")" << " count=(" << range.layerCount << ","
                 << range.levelCount << ")" << " to=" << newLayout
-                 << " is skipped because of no change in layout" << utils::io::endl;
+                 << " is skipped because of no change in layout";
 #endif
    }

@@ -849,8 +855,7 @@ void VulkanTexture::print() const {
                level < (mPrimaryViewRange.baseMipLevel + mPrimaryViewRange.levelCount);
            FVK_LOGD << "[" << mState->mTextureImage << "]: (" << layer << "," << level
                          << ")=" << getLayout(layer, level)
-                          << " primary=" << primary
-                          << utils::io::endl;
+                          << " primary=" << primary;
        }
    }

@@ -859,8 +864,7 @@ void VulkanTexture::print() const {
        FVK_LOGD << "[" << mState->mTextureImage << ", imageView=" << view.second << "]=>"
                      << " (" << range.baseArrayLayer << "," << range.baseMipLevel << ")"
                      << " count=(" << range.layerCount << "," << range.levelCount << ")"
-                      << " aspect=" << range.aspectMask << " viewType=" << view.first.type
-                      << utils::io::endl;
+                      << " aspect=" << range.aspectMask << " viewType=" << view.first.type;
    }
 }
 #endif
@@ -17,6 +17,7 @@
 #include "vulkan/memory/ResourceManager.h"
 #include "vulkan/VulkanHandles.h"

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

 namespace filament::backend::fvkmemory {
@@ -127,11 +128,11 @@ void ResourceManager::traceConstruction(ResourceType type, HandleId id) {

 void ResourceManager::print() const noexcept {
 #if FVK_ENABLED(FVK_DEBUG_RESOURCE_LEAK)
-    utils::slog.e << "-------------------" << utils::io::endl;
+    LOG(ERROR) << "-------------------";
    for (size_t i = 0; i < (size_t) ResourceType::UNDEFINED_TYPE; ++i) {
-        utils::slog.e <<"    " << getTypeStr((ResourceType) i) << "=" << COUNTER[i] << utils::io::endl;
+        LOG(ERROR) << "    " << getTypeStr((ResourceType) i) << "=" << COUNTER[i];
    }
-    utils::slog.e << "+++++++++++++++++++" << utils::io::endl;
+    LOG(ERROR) << "+++++++++++++++++++";
 #endif
 }

@@ -25,8 +25,9 @@
 #include "vulkan/utils/Helper.h"

 #include <bluevk/BlueVK.h>
-#include <utils/PrivateImplementation-impl.h>
+#include <utils/Logger.h>
 #include <utils/Panic.h>
+#include <utils/PrivateImplementation-impl.h>

 #define SWAPCHAIN_RET_FUNC(func, handle, ...)                                                      \
    if (mImpl->mSurfaceSwapChains.find(handle) != mImpl->mSurfaceSwapChains.end()) {               \
@@ -114,7 +115,7 @@ void printDeviceInfo(VkInstance instance, VkPhysicalDevice device) {
        chainStruct(&physicalDeviceProperties2, &driverProperties);
        vkGetPhysicalDeviceProperties2(device, &physicalDeviceProperties2);
        FVK_LOGI << "Vulkan device driver: " << driverProperties.driverName << " "
-                      << driverProperties.driverInfo << utils::io::endl;
+                 << driverProperties.driverInfo;
    }

    VkPhysicalDeviceProperties deviceProperties;
@@ -151,7 +152,7 @@ void printDeviceInfo(VkInstance instance, VkPhysicalDevice device) {
                  << "(vendor " << utils::io::hex << vendorID << ", "
                  << "device " << deviceID << ", "
                  << "driver " << driverVersion << ", " << utils::io::dec << "api " << major << "."
-                  << minor << ")" << utils::io::endl;
+                  << minor << ")";
 }

 #if FVK_ENABLED(FVK_DEBUG_VALIDATION)
@@ -174,7 +175,7 @@ void printDepthFormats(VkPhysicalDevice device) {
            FVK_LOGI << format << " ";
        }
    }
-    FVK_LOGI << utils::io::endl;
+    FVK_LOGI << "";
 }
 #endif

@@ -294,10 +295,10 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
    } else {
 #if defined(__ANDROID__)
        FVK_LOGD << "Validation layers are not available; did you set jniLibs in your "
-                 << "gradle file?" << utils::io::endl;
+                 << "gradle file?";
 #else
        FVK_LOGD << "Validation layer not available; did you install the Vulkan SDK?\n"
-                 << "Please ensure that VK_LAYER_PATH is set correctly." << utils::io::endl;
+                 << "Please ensure that VK_LAYER_PATH is set correctly.";
 #endif // __ANDROID__

    }
@@ -984,8 +985,7 @@ SwapChainPtr VulkanPlatform::createSwapChain(void* nativeWindow, uint64_t flags,

    if (flags & backend::SWAP_CHAIN_CONFIG_PROTECTED_CONTENT) {
        if (!mImpl->mContext.mProtectedMemorySupported) {
-            utils::slog.w << "protected swapchain requested, but VulkanPlatform does not support it"
-                << utils::io::endl;
+            LOG(WARNING) << "protected swapchain requested, but VulkanPlatform does not support it";
        }
    }

@@ -163,8 +163,7 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
    // the number of images, though there may be limits related to the total amount of memory used
    // by presentable images."
    if (maxImageCount != 0 && desiredImageCount > maxImageCount) {
-        FVK_LOGE << "Swap chain does not support " << desiredImageCount << " images."
-                      << utils::io::endl;
+        FVK_LOGE << "Swap chain does not support " << desiredImageCount << " images.";
        desiredImageCount = caps.minImageCount;
    }

@@ -266,8 +265,7 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
           << "swapchain-size=" << mSwapChainBundle.colors.size() << ", "
           << "identity-transform=" << (caps.currentTransform == 1) << ", "
           << "depth=" << mSwapChainBundle.depthFormat << ", "
-           << "protected=" << mSwapChainBundle.isProtected
-           << io::endl;
+           << "protected=" << mSwapChainBundle.isProtected;

    VkSemaphoreCreateInfo const semaphoreCreateInfo = {
            .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
@@ -293,7 +291,7 @@ VkResult VulkanPlatformSurfaceSwapChain::acquire(VulkanPlatform::ImageSyncData*
    // Users should be notified of a suboptimal surface, but it should not cause a cascade of
    // log messages or a loop of re-creations.
    if (result == VK_SUBOPTIMAL_KHR && !mSuboptimal) {
-        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain." << io::endl;
+        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain.";
        mSuboptimal = true;
    }
    return result;
@@ -315,7 +313,7 @@ VkResult VulkanPlatformSurfaceSwapChain::present(uint32_t index, VkSemaphore fin
    // On Android Q and above, a suboptimal surface is always reported after screen rotation:
    // https://android-developers.googleblog.com/2020/02/handling-device-orientation-efficiently.html
    if (result == VK_SUBOPTIMAL_KHR && !mSuboptimal) {
-        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain." << utils::io::endl;
+        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain.";
        mSuboptimal = true;
    }
    return result;
@@ -1,795 +0,0 @@
-#include "SpdMipmapGenerator.h"
-#include <sstream>
-#include <stdexcept>
-// C++ port of https://github.com/JolifantoBambla/webgpu-spd for early experiments- do not merge like this
-namespace spd {
-
-    // Helper to convert enums to strings for map keys or shader code
-    const char* to_string(wgpu::TextureFormat format) {
-        switch (format) {
-            case wgpu::TextureFormat::RGBA8Unorm: return "rgba8unorm";
-            case wgpu::TextureFormat::BGRA8Unorm: return "bgra8unorm";
-            case wgpu::TextureFormat::R32Float: return "r32float";
-            case wgpu::TextureFormat::RG32Float: return "rg32float";
-            case wgpu::TextureFormat::RGBA32Float: return "rgba32float";
-            case wgpu::TextureFormat::R16Float: return "r16float";
-            case wgpu::TextureFormat::RG16Float: return "rg16float";
-            case wgpu::TextureFormat::RGBA16Float: return "rgba16float";
-            // Add other formats as needed
-            default: return "rgba8unorm";
-        }
-    }
-
-
-    std::string MipmapGenerator::GetFilterCode(SPDFilter filter) {
-        switch (filter) {
-            case SPDFilter::Min:
-                return R"(
-    fn spd_reduce_4(v0: vec4<SPDScalar>, v1: vec4<SPDScalar>, v2: vec4<SPDScalar>, v3: vec4<SPDScalar>) -> vec4<SPDScalar> {
-        return min(min(v0, v1), min(v2, v3));
-    }
-    )";
-            case SPDFilter::Max:
-                return R"(
-    fn spd_reduce_4(v0: vec4<SPDScalar>, v1: vec4<SPDScalar>, v2: vec4<SPDScalar>, v3: vec4<SPDScalar>) -> vec4<SPDScalar> {
-        return max(max(v0, v1), max(v2, v3));
-    }
-    )";
-            case SPDFilter::MinMax:
-                 return R"(
-    fn spd_reduce_4(v0: vec4<SPDScalar>, v1: vec4<SPDScalar>, v2: vec4<SPDScalar>, v3: vec4<SPDScalar>) -> vec4<SPDScalar> {
-        let max4 = max(max(v0.xy, v1.xy), max(v2.xy, v3.xy));
-        return vec4<SPDScalar>(min(min(v0.x, v1.x), min(v2.x, v3.x)), max(max4.x, max4.y), 0.0, 0.0);
-    }
-    )";
-            case SPDFilter::Average:
-            default:
-                return R"(
-    fn spd_reduce_4(v0: vec4<SPDScalar>, v1: vec4<SPDScalar>, v2: vec4<SPDScalar>, v3: vec4<SPDScalar>) -> vec4<SPDScalar> {
-        return (v0 + v1 + v2 + v3) * 0.25;
-    }
-    )";
-        }
-    }
-
-
-    MipmapGenerator::MipmapGenerator(const wgpu::Device& device) : m_device(device) {
-        wgpu::BindGroupLayoutEntry bglEntry{};
-        bglEntry.binding = 0;
-        bglEntry.visibility = wgpu::ShaderStage::Compute;
-        bglEntry.buffer.type = wgpu::BufferBindingType::Uniform;
-        bglEntry.buffer.minBindingSize = 16;
-
-        wgpu::BindGroupLayoutDescriptor bglDesc{};
-        bglDesc.entryCount = 1;
-        bglDesc.entries = &bglEntry;
-        m_internalResourcesBindGroupLayout = m_device.CreateBindGroupLayout(&bglDesc);
-    }
-
-    void MipmapGenerator::PreparePipelines(wgpu::TextureFormat format, SPDFilter filter, bool halfPrecision) {
-        SPDScalarType scalarType = SanitizeScalarType(format, halfPrecision);
-        // Prepare for a reasonable number of mips
-        for (uint32_t i = 1; i <= 4; ++i) {
-            GetOrCreatePipeline(format, filter, i, scalarType);
-        }
-    }
-    
-    SPDScalarType MipmapGenerator::SanitizeScalarType(wgpu::TextureFormat format, bool halfPrecision) {
-        std::string formatStr = to_string(format);
-        std::transform(formatStr.begin(), formatStr.end(), formatStr.begin(), ::tolower);
-
-        SPDScalarType texelType = SPDScalarType::F32;
-        if (formatStr.find("sint") != std::string::npos) {
-            texelType = SPDScalarType::I32;
-        } else if (formatStr.find("uint") != std::string::npos) {
-            texelType = SPDScalarType::U32;
-        }
-
-        if (halfPrecision) {
-            bool hasF16 = false;
-            // In a real Dawn app, you would check device.GetSupportedFeatures()
-            // For now, let's assume it's available if requested.
-             hasF16 = true; 
-
-            if (!hasF16) {
-                // Log warning: half precision requested but not supported
-            }
-            if (texelType != SPDScalarType::F32) {
-                // Log warning: half precision for non-float format
-            }
-            if (hasF16 && texelType == SPDScalarType::F32) {
-                return SPDScalarType::F16;
-            }
-        }
-        return texelType;
-    }
-
-    SPDPipeline& MipmapGenerator::GetOrCreatePipeline(wgpu::TextureFormat format, SPDFilter filter, uint32_t numMips, SPDScalarType scalarType) {
-        if (m_pipelines[format][scalarType][filter].count(numMips) == 0) {
-            // Create the pipeline
-            SPDPipeline spdPipeline;
-
-            std::vector<wgpu::BindGroupLayoutEntry> mipsBglEntries;
-            for (uint32_t i = 0; i <= numMips; ++i) {
-                wgpu::BindGroupLayoutEntry entry{};
-                entry.binding = i;
-                entry.visibility = wgpu::ShaderStage::Compute;
-                if (i == 0) {
-                    entry.texture.sampleType = (scalarType == SPDScalarType::I32) ? wgpu::TextureSampleType::Sint :
-                                               (scalarType == SPDScalarType::U32) ? wgpu::TextureSampleType::Uint :
-                                               wgpu::TextureSampleType::UnfilterableFloat;
-                    entry.texture.viewDimension = wgpu::TextureViewDimension::e2DArray;
-                } else {
-                    entry.storageTexture.access = wgpu::StorageTextureAccess::WriteOnly;
-                    entry.storageTexture.format = format;
-                    entry.storageTexture.viewDimension = wgpu::TextureViewDimension::e2DArray;
-                }
-                mipsBglEntries.push_back(entry);
-            }
-            
-            wgpu::BindGroupLayoutDescriptor mipsBglDesc{};
-            mipsBglDesc.entryCount = mipsBglEntries.size();
-            mipsBglDesc.entries = mipsBglEntries.data();
-            spdPipeline.mipsBindGroupLayout = m_device.CreateBindGroupLayout(&mipsBglDesc);
-
-            std::string shaderCode = MakeShaderCode(format, GetFilterCode(filter), numMips, scalarType);
-            wgpu::ShaderModuleWGSLDescriptor wgslDesc{};
-            wgslDesc.code = shaderCode.c_str();
-
-            wgpu::ShaderModuleDescriptor shaderModuleDesc{};
-            shaderModuleDesc.nextInChain = &wgslDesc;
-            wgpu::ShaderModule shaderModule = m_device.CreateShaderModule(&shaderModuleDesc);
-            
-            wgpu::BindGroupLayout bgls[] = { spdPipeline.mipsBindGroupLayout, m_internalResourcesBindGroupLayout };
-            wgpu::PipelineLayoutDescriptor layoutDesc{};
-            layoutDesc.bindGroupLayoutCount = 2;
-            layoutDesc.bindGroupLayouts = bgls;
-
-            wgpu::ComputePipelineDescriptor pipelineDesc{};
-            pipelineDesc.layout = m_device.CreatePipelineLayout(&layoutDesc);
-            pipelineDesc.compute.module = shaderModule;
-            pipelineDesc.compute.entryPoint = "downsample";
-
-            spdPipeline.pipeline = m_device.CreateComputePipeline(&pipelineDesc);
-            m_pipelines[format][scalarType][filter][numMips] = std::move(spdPipeline);
-        }
-        return m_pipelines[format][scalarType][filter][numMips];
-    }
-    
-    void MipmapGenerator::Generate(
-        wgpu::CommandEncoder& commandEncoder,
-        wgpu::Texture srcTexture,
-        const SPDPassConfig& config)
-    {
-        uint32_t width = srcTexture.GetWidth();
-        uint32_t height = srcTexture.GetHeight();
-        uint32_t arrayLayerCount = srcTexture.GetDepthOrArrayLayers();
-
-        wgpu::Texture target = config.targetTexture ? config.targetTexture : srcTexture;
-        uint32_t numMips = config.numMips > 0 ? config.numMips : target.GetMipLevelCount() - 1;
-
-        if (numMips == 0) return;
-
-        SPDScalarType scalarType = SanitizeScalarType(srcTexture.GetFormat(), config.halfPrecision);
-        SPDPipeline& spdPipeline = GetOrCreatePipeline(target.GetFormat(), config.filter, numMips, scalarType);
-        
-        // --- Create Bind Group 0 (Mips) ---
-        std::vector<wgpu::BindGroupEntry> mipEntries;
-
-        wgpu::TextureViewDescriptor srcViewDesc{};
-        srcViewDesc.dimension = wgpu::TextureViewDimension::e2DArray;
-        srcViewDesc.baseMipLevel = config.sourceMipLevel;
-        srcViewDesc.mipLevelCount = 1;
-        srcViewDesc.baseArrayLayer = 0;
-        srcViewDesc.arrayLayerCount = arrayLayerCount;
-        
-        wgpu::BindGroupEntry srcEntry{};
-        srcEntry.binding = 0;
-        srcEntry.textureView = srcTexture.CreateView(&srcViewDesc);
-        mipEntries.push_back(srcEntry);
-
-        for (uint32_t i = 0; i < numMips; ++i) {
-            wgpu::TextureViewDescriptor dstViewDesc{};
-            dstViewDesc.dimension = wgpu::TextureViewDimension::e2DArray;
-            dstViewDesc.baseMipLevel = config.sourceMipLevel + i + 1;
-            dstViewDesc.mipLevelCount = 1;
-            dstViewDesc.baseArrayLayer = 0;
-            dstViewDesc.arrayLayerCount = arrayLayerCount;
-           
-            wgpu::BindGroupEntry dstEntry{};
-            dstEntry.binding = i + 1;
-            dstEntry.textureView = target.CreateView(&dstViewDesc);
-            mipEntries.push_back(dstEntry);
-        }
-
-        wgpu::BindGroupDescriptor mipBindGroupDesc{};
-        mipBindGroupDesc.layout = spdPipeline.mipsBindGroupLayout;
-        mipBindGroupDesc.entryCount = mipEntries.size();
-        mipBindGroupDesc.entries = mipEntries.data();
-        wgpu::BindGroup mipsBindGroup = m_device.CreateBindGroup(&mipBindGroupDesc);
-
-        // --- Create Bind Group 1 (Internal Resources) ---
-        uint32_t numWorkGroupsX = (width + 63) / 64;
-        uint32_t numWorkGroupsY = (height + 63) / 64;
-        uint32_t numWorkGroups = numWorkGroupsX * numWorkGroupsY;
-
-        struct DownsamplePassMeta {
-            uint32_t work_group_offset[2] = {0, 0};
-            uint32_t num_work_groups;
-            uint32_t mips;
-            uint32_t padding[12]; // Ensure size is multiple of 16
-        } meta;
-        meta.num_work_groups = numWorkGroups;
-        meta.mips = numMips;
-        
-        wgpu::BufferDescriptor metaBufferDesc{};
-        metaBufferDesc.size = sizeof(DownsamplePassMeta);
-        metaBufferDesc.usage = wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopyDst;
-        wgpu::Buffer metaBuffer = m_device.CreateBuffer(&metaBufferDesc);
-        m_device.GetQueue().WriteBuffer(metaBuffer, 0, &meta, sizeof(meta));
-
-        wgpu::BindGroupEntry metaEntry{};
-        metaEntry.binding = 0;
-        metaEntry.buffer = metaBuffer;
-        
-        wgpu::BindGroupDescriptor internalBindGroupDesc{};
-        internalBindGroupDesc.layout = m_internalResourcesBindGroupLayout;
-        internalBindGroupDesc.entryCount = 1;
-        internalBindGroupDesc.entries = &metaEntry;
-        wgpu::BindGroup internalBindGroup = m_device.CreateBindGroup(&internalBindGroupDesc);
-        
-        // --- Dispatch ---
-        wgpu::ComputePassEncoder pass = commandEncoder.BeginComputePass();
-        pass.SetPipeline(spdPipeline.pipeline);
-        pass.SetBindGroup(0, mipsBindGroup);
-        pass.SetBindGroup(1, internalBindGroup);
-        pass.DispatchWorkgroups(numWorkGroupsX, numWorkGroupsY, arrayLayerCount);
-        pass.End();
-    }
-
-    // Main shader generation logic
-
-// Helper function to check if a string is in a vector of strings
-bool includes(const std::vector<std::string>& vec, const std::string& str) {
-    for (const auto& s : vec) {
-        if (s == str) {
-            return true;
-        }
-    }
-    return false;
-}
-
-std::string MakeShaderCode(wgpu::TextureFormat outputFormat,
-                           const std::string& filterOp,
-                           unsigned int numMips, // Assuming a default value for numMips
-                           SPDScalarType scalarType) { // Default scalarType
-    std::stringstream ss;
-
-    std::string texelType;
-    if (scalarType == SPDScalarType::I32) {
-        texelType = "i32";
-    } else if (scalarType == SPDScalarType::U32) {
-        texelType = "u32";
-    } else {
-        texelType = "f32";
-    }
-
-    bool useF16 = (scalarType == SPDScalarType::F16);
-
-    std::string filterCode = filterOp;
-    if (filterOp == SPD_FILTER_AVERAGE && !includes({"f32", "f16"}, texelType)) {
-        // Replace "* 0.25" with "/ 4"
-        size_t pos = filterCode.find("* 0.25");
-        if (pos != std::string::npos) {
-            filterCode.replace(pos, std::string("* 0.25").length(), "/ 4");
-        }
-    }
-
-    // Generate mipsBindings
-    std::string mipsBindings;
-    for (unsigned int i = 0; i < numMips; ++i) {
-        mipsBindings += "@group(0) @binding(" + std::to_string(i + 1) + ") var dst_mip_" + std::to_string(i + 1) + ": texture_storage_2d_array<" + to_string(outputFormat)  + ", write>;\n";
-    }
-
-    // Generate mipsAccessorBody
-    std::string mipsAccessorBody;
-    for (unsigned int i = 0; i < numMips; ++i) {
-        if (i == 5 && numMips > 6) {
-            mipsAccessorBody += " else if mip == 6 {\n";
-            mipsAccessorBody += "                textureStore(dst_mip_6, uv, slice, " + (useF16 ? "vec4<" + texelType + ">(value)" : "value") + ");\n";
-            mipsAccessorBody += "                mip_dst_6_buffer[slice][uv.y][uv.x] = value;\n";
-            mipsAccessorBody += "            }";
-        } else {
-            if (i != 0) {
-                mipsAccessorBody += " else ";
-            }
-            mipsAccessorBody += "if mip == " + std::to_string(i + 1) + " {\n";
-            mipsAccessorBody += "                textureStore(dst_mip_" + std::to_string(i + 1) + ", uv, slice, " + (useF16 ? "vec4<" + texelType + ">(value)" : "value") + ");\n";
-            mipsAccessorBody += "            }";
-        }
-    }
-
-    std::string mipsAccessor = "fn store_dst_mip(value: vec4<SPDScalar>, uv: vec2<u32>, slice: u32, mip: u32) {\n" + mipsAccessorBody + "\n}";
-    std::string midMipAccessor = "return mip_dst_6_buffer[slice][uv.y][uv.x];";
-
-    // Start building the final shader code string
-    ss << R"(
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (C) 2023 Advanced Micro Devices, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files(the “Software”), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions :
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
-// AUTHORS COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-
-// Definitions --------------------------------------------------------------------------------------------------------
-
-)";
-    if (useF16) {
-        ss << "enable f16;\n";
-    }
-    ss << "alias SPDScalar = " << texelType << ";\n\n"; // Using texelType here, assuming SPDScalar maps to it.
-
-    ss << R"(
-// Helpers ------------------------------------------------------------------------------------------------------------
-
-/**
- * A helper function performing a remap 64x1 to 8x8 remapping which is necessary for 2D wave reductions.
- * * The 64-wide lane indices to 8x8 remapping is performed as follows:
- * 00 01 08 09 10 11 18 19
- * 02 03 0a 0b 12 13 1a 1b
- * 04 05 0c 0d 14 15 1c 1d
- * 06 07 0e 0f 16 17 1e 1f
- * 20 21 28 29 30 31 38 39
- * 22 23 2a 2b 32 33 3a 3b
- * 24 25 2c 2d 34 35 3c 3d
- * 26 27 2e 2f 36 37 3e 3f
- * * @param a: The input 1D coordinate to remap.
- *
- * @returns The remapped 2D coordinates.
- */
-fn remap_for_wave_reduction(a: u32) -> vec2<u32> {
-    return vec2<u32>(
-        insertBits(extractBits(a, 2u, 3u), a, 0u, 1u),
-        insertBits(extractBits(a, 3u, 3u), extractBits(a, 1u, 2u), 0u, 2u)
-    );
-}
-
-fn map_to_xy(local_invocation_index: u32) -> vec2<u32> {
-    let sub_xy: vec2<u32> = remap_for_wave_reduction(local_invocation_index % 64);
-    return vec2<u32>(
-        sub_xy.x + 8 * ((local_invocation_index >> 6) % 2),
-        sub_xy.y + 8 * ((local_invocation_index >> 7))
-    );
-}
-
-/*
- * Compute a linear value from a SRGB value.
- * * @param value: The value to convert to linear from SRGB.
- * * @returns A value in SRGB space.
- */
-/*
-fn srgb_to_linear(value: SPDScalar) -> SPDScalar {
-    let j = vec3<SPDScalar>(0.0031308 * 12.92, 12.92, 1.0 / 2.4);
-    let k = vec2<SPDScalar>(1.055, -0.055);
-    return clamp(j.x, value * j.y, pow(value, j.z) * k.x + k.y);
-}
-*/
-
-// Resources & Accessors -----------------------------------------------------------------------------------------------
-struct DownsamplePassMeta {
-    work_group_offset: vec2<u32>,
-    num_work_groups: u32,
-    mips: u32,
-}
-
-// In the original version dst_mip_i is an image2Darray [SPD_MAX_MIP_LEVELS+1], i.e., 12+1, but WGSL doesn't support arrays of textures yet
-// Also these are read_write because for mips 7-13, the workgroup reads from mip level 6 - since most formats don't support read_write access in WGSL yet, we use a single read_write buffer in such cases instead
-@group(0) @binding(0) var src_mip_0: texture_2d_array<)" << texelType << R"(>;
-)" << mipsBindings << R"(
-
-@group(1) @binding(0) var<uniform> downsample_pass_meta : DownsamplePassMeta;
-@group(1) @binding(1) var<storage, read_write> spd_global_counter: array<atomic<u32>>;
-@group(1) @binding(2) var<storage, read_write> mip_dst_6_buffer: array<array<array<vec4<f32>, 64>, 64>>;
-
-fn get_mips() -> u32 {
-    return downsample_pass_meta.mips;
-}
-
-fn get_num_work_groups() -> u32 {
-    return downsample_pass_meta.num_work_groups;
-}
-
-fn get_work_group_offset() -> vec2<u32> {
-    return downsample_pass_meta.work_group_offset;
-}
-
-fn load_src_image(uv: vec2<u32>, slice: u32) -> vec4<SPDScalar> {
-    return vec4<SPDScalar>(textureLoad(src_mip_0, uv, slice, 0));
-}
-
-fn load_mid_mip_image(uv: vec2<u32>, slice: u32) -> vec4<SPDScalar> {
-    )";
-    if (numMips > 6) {
-        ss << midMipAccessor;
-    } else {
-        ss << "return vec4<SPDScalar>();";
-    }
-    ss << R"(
-}
-
-)" << mipsAccessor << R"(
-
-// Workgroup -----------------------------------------------------------------------------------------------------------
-
-var<workgroup> spd_intermediate: array<array<vec4<SPDScalar>, 16>, 16>;
-var<workgroup> spd_counter: atomic<u32>;
-
-fn spd_increase_atomic_counter(slice: u32) {
-    atomicStore(&spd_counter, atomicAdd(&spd_global_counter[slice], 1));
-}
-
-fn spd_get_atomic_counter() -> u32 {
-    return atomicLoad(&spd_counter);
-}
-
-fn spd_reset_atomic_counter(slice: u32) {
-    atomicStore(&spd_global_counter[slice], 0);
-}
-
-// Cotnrol flow --------------------------------------------------------------------------------------------------------
-
-fn spd_barrier() {
-    // in glsl this does: groupMemoryBarrier(); barrier();
-    workgroupBarrier();
-}
-
-// Only last active workgroup should proceed
-fn spd_exit_workgroup(num_work_groups: u32, local_invocation_index: u32, slice: u32) -> bool {
-    // global atomic counter
-    if (local_invocation_index == 0) {
-        spd_increase_atomic_counter(slice);
-    }
-    spd_barrier();
-    return spd_get_atomic_counter() != (num_work_groups - 1);
-}
-
-// Pixel access --------------------------------------------------------------------------------------------------------
-
-)" << filterCode << R"(
-
-fn spd_store(pix: vec2<u32>, out_value: vec4<SPDScalar>, mip: u32, slice: u32) {
-    store_dst_mip(out_value, pix, slice, mip + 1);
-}
-
-fn spd_load_intermediate(x: u32, y: u32) -> vec4<SPDScalar> {
-    return spd_intermediate[x][y];
-}
-
-fn spd_store_intermediate(x: u32, y: u32, value: vec4<SPDScalar>) {
-    spd_intermediate[x][y] = value;
-}
-
-fn spd_reduce_intermediate(i0: vec2<u32>, i1: vec2<u32>, i2: vec2<u32>, i3: vec2<u32>) -> vec4<SPDScalar> {
-    let v0 = spd_load_intermediate(i0.x, i0.y);
-    let v1 = spd_load_intermediate(i1.x, i1.y);
-    let v2 = spd_load_intermediate(i2.x, i2.y);
-    let v3 = spd_load_intermediate(i3.x, i3.y);
-    return spd_reduce_4(v0, v1, v2, v3);
-}
-
-fn spd_reduce_load_4(base: vec2<u32>, slice: u32) -> vec4<SPDScalar> {
-    let v0 = load_src_image(base + vec2<u32>(0, 0), slice);
-    let v1 = load_src_image(base + vec2<u32>(0, 1), slice);
-    let v2 = load_src_image(base + vec2<u32>(1, 0), slice);
-    let v3 = load_src_image(base + vec2<u32>(1, 1), slice);
-    return spd_reduce_4(v0, v1, v2, v3);
-}
-
-fn spd_reduce_load_mid_mip_4(base: vec2<u32>, slice: u32) -> vec4<SPDScalar> {
-    let v0 = load_mid_mip_image(base + vec2<u32>(0, 0), slice);
-    let v1 = load_mid_mip_image(base + vec2<u32>(0, 1), slice);
-    let v2 = load_mid_mip_image(base + vec2<u32>(1, 0), slice);
-    let v3 = load_mid_mip_image(base + vec2<u32>(1, 1), slice);
-    return spd_reduce_4(v0, v1, v2, v3);
-}
-
-// Main logic ---------------------------------------------------------------------------------------------------------
-
-fn spd_downsample_mips_0_1(x: u32, y: u32, workgroup_id: vec2<u32>, local_invocation_index: u32, mip: u32, slice: u32) {
-    var v: array<vec4<SPDScalar>, 4>;
-
-    let workgroup64 = workgroup_id.xy * 64;
-    let workgroup32 = workgroup_id.xy * 32;
-    let workgroup16 = workgroup_id.xy * 16;
-
-    var tex = workgroup64 + vec2<u32>(x * 2, y * 2);
-    var pix = workgroup32 + vec2<u32>(x, y);
-    v[0] = spd_reduce_load_4(tex, slice);
-    spd_store(pix, v[0], 0, slice);
-
-    tex = workgroup64 + vec2<u32>(x * 2 + 32, y * 2);
-    pix = workgroup32 + vec2<u32>(x + 16, y);
-    v[1] = spd_reduce_load_4(tex, slice);
-    spd_store(pix, v[1], 0, slice);
-
-    tex = workgroup64 + vec2<u32>(x * 2, y * 2 + 32);
-    pix = workgroup32 + vec2<u32>(x, y + 16);
-    v[2] = spd_reduce_load_4(tex, slice);
-    spd_store(pix, v[2], 0, slice);
-
-    tex = workgroup64 + vec2<u32>(x * 2 + 32, y * 2 + 32);
-    pix = workgroup32 + vec2<u32>(x + 16, y + 16);
-    v[3] = spd_reduce_load_4(tex, slice);
-    spd_store(pix, v[3], 0, slice);
-
-    if mip <= 1 {
-        return;
-    }
-
-    for (var i = 0u; i < 4u; i++) {
-        spd_store_intermediate(x, y, v[i]);
-        spd_barrier();
-        if local_invocation_index < 64 {
-            v[i] = spd_reduce_intermediate(
-                vec2<u32>(x * 2 + 0, y * 2 + 0),
-                vec2<u32>(x * 2 + 1, y * 2 + 0),
-                vec2<u32>(x * 2 + 0, y * 2 + 1),
-                vec2<u32>(x * 2 + 1, y * 2 + 1)
-            );
-            spd_store(workgroup16 + vec2<u32>(x + (i % 2) * 8, y + (i / 2) * 8), v[i], 1, slice);
-        }
-        spd_barrier();
-    }
-
-    if local_invocation_index < 64 {
-        spd_store_intermediate(x + 0, y + 0, v[0]);
-        spd_store_intermediate(x + 8, y + 0, v[1]);
-        spd_store_intermediate(x + 0, y + 8, v[2]);
-        spd_store_intermediate(x + 8, y + 8, v[3]);
-    }
-}
-
-fn spd_downsample_mip_2(x: u32, y: u32, workgroup_id: vec2<u32>, local_invocation_index: u32, mip: u32, slice: u32) {
-    if local_invocation_index < 64u {
-        let v = spd_reduce_intermediate(
-            vec2<u32>(x * 2 + 0, y * 2 + 0),
-            vec2<u32>(x * 2 + 1, y * 2 + 0),
-            vec2<u32>(x * 2 + 0, y * 2 + 1),
-            vec2<u32>(x * 2 + 1, y * 2 + 1)
-        );
-        spd_store(workgroup_id.xy * 8 + vec2<u32>(x, y), v, mip, slice);
-        // store to LDS, try to reduce bank conflicts
-        // x 0 x 0 x 0 x 0 x 0 x 0 x 0 x 0
-        // 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-        // 0 x 0 x 0 x 0 x 0 x 0 x 0 x 0 x
-        // 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-        // x 0 x 0 x 0 x 0 x 0 x 0 x 0 x 0
-        // ...
-        // x 0 x 0 x 0 x 0 x 0 x 0 x 0 x 0
-        spd_store_intermediate(x * 2 + y % 2, y * 2, v);
-    }
-}
-
-fn spd_downsample_mip_3(x: u32, y: u32, workgroup_id: vec2<u32>, local_invocation_index: u32, mip: u32, slice: u32) {
-    if local_invocation_index < 16u {
-        // x 0 x 0
-        // 0 0 0 0
-        // 0 x 0 x
-        // 0 0 0 0
-        let v = spd_reduce_intermediate(
-            vec2<u32>(x * 4 + 0 + 0, y * 4 + 0),
-            vec2<u32>(x * 4 + 2 + 0, y * 4 + 0),
-            vec2<u32>(x * 4 + 0 + 1, y * 4 + 2),
-            vec2<u32>(x * 4 + 2 + 1, y * 4 + 2)
-        );
-        spd_store(workgroup_id.xy * 4 + vec2<u32>(x, y), v, mip, slice);
-        // store to LDS
-        // x 0 0 0 x 0 0 0 x 0 0 0 x 0 0 0
-        // 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-        // 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-        // 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-        // 0 x 0 0 0 x 0 0 0 x 0 0 0 x 0 0
-        // ...
-        // 0 0 x 0 0 0 x 0 0 0 x 0 0 0 x 0
-        // ...
-        // 0 0 0 x 0 0 0 x 0 0 0 x 0 0 0 x
-        // ...
-        spd_store_intermediate(x * 4 + y, y * 4, v);
-    }
-}
-
-fn spd_downsample_mip_4(x: u32, y: u32, workgroup_id: vec2<u32>, local_invocation_index: u32, mip: u32, slice: u32) {
-    if local_invocation_index < 4u {
-        // x 0 0 0 x 0 0 0
-        // ...
-        // 0 x 0 0 0 x 0 0
-        let v = spd_reduce_intermediate(
-            vec2<u32>(x * 8 + 0 + 0 + y * 2, y * 8 + 0),
-            vec2<u32>(x * 8 + 4 + 0 + y * 2, y * 8 + 0),
-            vec2<u32>(x * 8 + 0 + 1 + y * 2, y * 8 + 4),
-            vec2<u32>(x * 8 + 4 + 1 + y * 2, y * 8 + 4)
-        );
-        spd_store(workgroup_id.xy * 2 + vec2<u32>(x, y), v, mip, slice);
-        // store to LDS
-        // x x x x 0 ...
-        // 0 ...
-        spd_store_intermediate(x + y * 2, 0, v);
-    }
-}
-
-fn spd_downsample_mip_5(workgroup_id: vec2<u32>, local_invocation_index: u32, mip: u32, slice: u32) {
-    if local_invocation_index < 1u {
-        // x x x x 0 ...
-        // 0 ...
-        let v = spd_reduce_intermediate(vec2<u32>(0, 0), vec2<u32>(1, 0), vec2<u32>(2, 0), vec2<u32>(3, 0));
-        spd_store(workgroup_id.xy, v, mip, slice);
-    }
-}
-
-fn spd_downsample_next_four(x: u32, y: u32, workgroup_id: vec2<u32>, local_invocation_index: u32, base_mip: u32, mips: u32, slice: u32) {
-    if mips <= base_mip {
-        return;
-    }
-    spd_barrier();
-    spd_downsample_mip_2(x, y, workgroup_id, local_invocation_index, base_mip, slice);
-
-    if mips <= base_mip + 1 {
-        return;
-    }
-    spd_barrier();
-    spd_downsample_mip_3(x, y, workgroup_id, local_invocation_index, base_mip + 1, slice);
-
-    if mips <= base_mip + 2 {
-        return;
-    }
-    spd_barrier();
-    spd_downsample_mip_4(x, y, workgroup_id, local_invocation_index, base_mip + 2, slice);
-
-    if mips <= base_mip + 3 {
-        return;
-    }
-    spd_barrier();
-    spd_downsample_mip_5(workgroup_id, local_invocation_index, base_mip + 3, slice);
-}
-
-fn spd_downsample_last_four(x: u32, y: u32, workgroup_id: vec2<u32>, local_invocation_index: u32, base_mip: u32, mips: u32, slice: u32, exit: bool) {
-    if mips <= base_mip {
-        return;
-    }
-    spd_barrier();
-    if !exit {
-        spd_downsample_mip_2(x, y, workgroup_id, local_invocation_index, base_mip, slice);
-    }
-
-    if mips <= base_mip + 1 {
-        return;
-    }
-    spd_barrier();
-    if !exit {
-        spd_downsample_mip_3(x, y, workgroup_id, local_invocation_index, base_mip + 1, slice);
-    }
-
-    if mips <= base_mip + 2 {
-        return;
-    }
-    spd_barrier();
-    if !exit {
-        spd_downsample_mip_4(x, y, workgroup_id, local_invocation_index, base_mip + 2, slice);
-    }
-
-    if mips <= base_mip + 3 {
-        return;
-    }
-    spd_barrier();
-    if !exit {
-        spd_downsample_mip_5(workgroup_id, local_invocation_index, base_mip + 3, slice);
-    }
-}
-
-fn spd_downsample_mips_6_7(x: u32, y: u32, mips: u32, slice: u32) {
-    var tex = vec2<u32>(x * 4 + 0, y * 4 + 0);
-    var pix = vec2<u32>(x * 2 + 0, y * 2 + 0);
-    let v0 = spd_reduce_load_mid_mip_4(tex, slice);
-    spd_store(pix, v0, 6, slice);
-
-    tex = vec2<u32>(x * 4 + 2, y * 4 + 0);
-    pix = vec2<u32>(x * 2 + 1, y * 2 + 0);
-    let v1 = spd_reduce_load_mid_mip_4(tex, slice);
-    spd_store(pix, v1, 6, slice);
-
-    tex = vec2<u32>(x * 4 + 0, y * 4 + 2);
-    pix = vec2<u32>(x * 2 + 0, y * 2 + 1);
-    let v2 = spd_reduce_load_mid_mip_4(tex, slice);
-    spd_store(pix, v2, 6, slice);
-
-    tex = vec2<u32>(x * 4 + 2, y * 4 + 2);
-    pix = vec2<u32>(x * 2 + 1, y * 2 + 1);
-    let v3 = spd_reduce_load_mid_mip_4(tex, slice);
-    spd_store(pix, v3, 6, slice);
-
-    if mips <= 7 {
-        return;
-    }
-    // no barrier needed, working on values only from the same thread
-
-    let v = spd_reduce_4(v0, v1, v2, v3);
-    spd_store(vec2<u32>(x, y), v, 7, slice);
-    spd_store_intermediate(x, y, v);
-}
-
-fn spd_downsample_last_6(x: u32, y: u32, local_invocation_index: u32, mips: u32, num_work_groups: u32, slice: u32) {
-    if mips <= 6 {
-        return;
-    }
-
-    // increase the global atomic counter for the given slice and check if it's the last remaining thread group:
-    // terminate if not, continue if yes.
-    let exit = spd_exit_workgroup(num_work_groups, local_invocation_index, slice);
-
-    // can't exit directly because subsequent barrier calls break uniform control flow...
-    if !exit {
-        // reset the global atomic counter back to 0 for the next spd dispatch
-        spd_reset_atomic_counter(slice);
-
-        // After mip 5 there is only a single workgroup left that downsamples the remaining up to 64x64 texels.
-        // compute MIP level 6 and 7
-        spd_downsample_mips_6_7(x, y, mips, slice);
-    }
-
-    // compute MIP level 8, 9, 10, 11
-    spd_downsample_last_four(x, y, vec2<u32>(0, 0), local_invocation_index, 8, mips, slice, exit);
-}
-
-/// Downsamples a 64x64 tile based on the work group id.
-/// If after downsampling it's the last active thread group, computes the remaining MIP levels.
-///
-/// @param [in] workGroupID        index of the work group / thread group
-/// @param [in] localInvocationIndex   index of the thread within the thread group in 1D
-/// @param [in] mips             the number of total MIP levels to compute for the input texture
-/// @param [in] numWorkGroups        the total number of dispatched work groups / thread groups for this slice
-/// @param [in] slice             the slice of the input texture
-fn spd_downsample(workgroup_id: vec2<u32>, local_invocation_index: u32, mips: u32, num_work_groups: u32, slice: u32) {
-    let xy = map_to_xy(local_invocation_index);
-    spd_downsample_mips_0_1(xy.x, xy.y, workgroup_id, local_invocation_index, mips, slice);
-    spd_downsample_next_four(xy.x, xy.y, workgroup_id, local_invocation_index, 2, mips, slice);
-)";
-    if (numMips > 6) {
-        ss << "    spd_downsample_last_6(xy.x, xy.y, local_invocation_index, mips, num_work_groups, slice);\n";
-    }
-    ss << R"(}
-
-// Entry points -------------------------------------------------------------------------------------------------------
-
-@compute
-@workgroup_size(256, 1, 1)
-fn downsample(@builtin(local_invocation_index) local_invocation_index: u32, @builtin(workgroup_id) workgroup_id: vec3<u32>) {
-    spd_downsample(
-        workgroup_id.xy + get_work_group_offset(),
-        local_invocation_index,
-        get_mips(),
-        get_num_work_groups(),
-        workgroup_id.z
-    );
-}
-)";
-    return ss.str();
-}
-
-
-} // namespace spd
@@ -1,83 +0,0 @@
-#pragma once
-
-#include <webgpu/webgpu_cpp.h>
-#include <string>
-#include <vector>
-#include <unordered_map>
-#include <optional>
-// C++ port of https://github.com/JolifantoBambla/webgpu-spd for early experiments- do not merge like this
-namespace spd {
-
-    // Enum for selecting the downsampling filter.
-    enum class SPDFilter {
-        Average,
-        Min,
-        Max,
-        MinMax
-    };
-
-    // Enum for shader scalar types.
-    enum class SPDScalarType {
-        F32,
-        F16,
-        I32,
-        U32
-    };
-
-    // Configuration for a single mipmap generation pass.
-struct SPDPassConfig {
-    SPDFilter filter = SPDFilter::Average;
-    wgpu::Texture targetTexture = nullptr;
-    uint32_t numMips = 0;
-    bool halfPrecision = false;
-    uint32_t sourceMipLevel = 0;
-};
-    
-    // Holds a pipeline and its corresponding bind group layout.
-    struct SPDPipeline {
-        wgpu::BindGroupLayout mipsBindGroupLayout = nullptr;
-        wgpu::ComputePipeline pipeline = nullptr;
-    };
-
-    // Manages pipeline creation, caching, and execution for mipmap generation.
-    class MipmapGenerator {
-    public:
-        MipmapGenerator(const wgpu::Device& device);
-
-        // Pre-creates pipelines for specified formats and filters.
-        void PreparePipelines(wgpu::TextureFormat format, SPDFilter filter, bool halfPrecision = false);
-
-        // Generates a compute pass for creating mipmaps.
-        void Generate(
-            wgpu::CommandEncoder& commandEncoder,
-            wgpu::Texture srcTexture,
-            const SPDPassConfig& config
-        );
-
-    private:
-        wgpu::Device m_device;
-        wgpu::BindGroupLayout m_internalResourcesBindGroupLayout;
-
-        // Cached pipelines: Map<TextureFormat, Map<SPDScalarType, Map<Filter, Map<NumMips, Pipeline>>>>
-        std::unordered_map<wgpu::TextureFormat,
-            std::unordered_map<SPDScalarType,
-                std::unordered_map<SPDFilter,
-                    std::unordered_map<uint32_t, SPDPipeline>>>> m_pipelines;
-        
-        // Helper methods
-        SPDPipeline& GetOrCreatePipeline(wgpu::TextureFormat format, SPDFilter filter, uint32_t numMips, SPDScalarType scalarType);
-        SPDScalarType SanitizeScalarType(wgpu::TextureFormat format, bool halfPrecision);
-        std::string GetFilterCode(SPDFilter filter);
-    };
-    // Assuming SPD_FILTER_AVERAGE is a string constant
-    const std::string SPD_FILTER_AVERAGE = "value * 0.25"; // Original filter operation
-
-    // Generates the WGSL shader code dynamically.
-    std::string MakeShaderCode(
-        wgpu::TextureFormat outputFormat,
-        const std::string& filterOp = SPD_FILTER_AVERAGE,
-        uint32_t numMips = 0,
-        SPDScalarType scalarType = SPDScalarType::F32
-    );
-
-} // namespace spd
@@ -17,7 +17,7 @@
 #ifndef TNT_FILAMENT_BACKEND_WEBGPUCONSTANTS_H
 #define TNT_FILAMENT_BACKEND_WEBGPUCONSTANTS_H

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

 #include <cstdint>

@@ -32,8 +32,8 @@ constexpr size_t WEBGPU_BUFFER_SIZE_MODULUS = 4;
 #define FWGPU_PRINT_SYSTEM         0x00000002

 // Set this to enable logging "only" to one output stream. This is useful in the case where we want
-// to debug with print statements and want ordered logging (e.g slog.i and slog.e will not appear in
-// order of calls).
+// to debug with print statements and want ordered logging (e.g LOG(INFO) and LOG(ERROR) will not
+// appear in order of calls).
 #define FWGPU_DEBUG_FORCE_LOG_TO_I 0x00000004

 // Useful default combinations
@@ -54,15 +54,15 @@ constexpr size_t WEBGPU_BUFFER_SIZE_MODULUS = 4;
 #define FWGPU_ENABLED(flags) (((FWGPU_DEBUG_FLAGS) & (flags)) == (flags))

 #if FWGPU_ENABLED(FWGPU_DEBUG_FORCE_LOG_TO_I)
-    #define FWGPU_LOGI (utils::slog.i)
+    #define FWGPU_LOGI LOG(INFO)
    #define FWGPU_LOGD FWGPU_LOGI
    #define FWGPU_LOGE FWGPU_LOGI
    #define FWGPU_LOGW FWGPU_LOGI
 #else
-    #define FWGPU_LOGE (utils::slog.e)
-    #define FWGPU_LOGW (utils::slog.w)
-    #define FWGPU_LOGD (utils::slog.d)
-    #define FWGPU_LOGI (utils::slog.i)
+    #define FWGPU_LOGE LOG(ERROR)
+    #define FWGPU_LOGW LOG(WARNING)
+    #define FWGPU_LOGD DLOG(INFO)
+    #define FWGPU_LOGI LOG(INFO)
 #endif

 constexpr uint64_t REQUEST_ADAPTER_TIMEOUT_NANOSECONDS =
@@ -28,7 +28,7 @@
 #include "WebGPUVertexBuffer.h"
 #include "WebGPUVertexBufferInfo.h"
 #include <backend/platforms/WebGPUPlatform.h>
-#include "SpdMipmapGenerator.h"
+
 #include "CommandStreamDispatcher.h"
 #include "DriverBase.h"
 #include "private/backend/Dispatcher.h"
@@ -336,15 +336,15 @@ void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,

    FWGPU_LOGW << "WebGPU support is highly experimental, in development, and tested for only a "
                  "small set of simple samples (e.g. hellotriangle and texturedquad), thus issues "
-                  "are likely to be encountered at this stage."
-               << utils::io::endl;
+                  "are likely to be encountered at this stage.";
 #if !FWGPU_ENABLED(FWGPU_PRINT_SYSTEM) && !defined(NDEBUG)
-    FWGPU_LOGI << "If the FILAMENT_BACKEND_DEBUG_FLAG variable were set with the " << utils::io::hex
-               << FWGPU_PRINT_SYSTEM << utils::io::dec
+    char printSystemHex[16];
+    snprintf(printSystemHex, sizeof(printSystemHex), "%#x", FWGPU_PRINT_SYSTEM);
+    FWGPU_LOGI << "If the FILAMENT_BACKEND_DEBUG_FLAG variable were set with the " << printSystemHex
               << " bit flag on during build time the application would print system details "
                  "about the selected graphics device, surface, etc. To see this try "
                  "rebuilding Filament with that flag, e.g. ./build.sh -x "
-               << FWGPU_PRINT_SYSTEM << " ..." << utils::io::endl;
+               << FWGPU_PRINT_SYSTEM << " ...";
 #endif
 }

@@ -529,8 +529,8 @@ bool WebGPUDriver::isTextureSwizzleSupported() {
 }

 bool WebGPUDriver::isTextureFormatMipmappable(const TextureFormat format) {
-    //todo
-    return true;
+    return WebGPUTexture::supportsMultipleMipLevelsViaStorageBinding(
+            WebGPUTexture::fToWGPUTextureFormat(format));
 }

 bool WebGPUDriver::isRenderTargetFormatSupported(const TextureFormat format) {
@@ -738,63 +738,67 @@ void WebGPUDriver::setExternalStream(Handle<HwTexture> textureHandle,
 }

 void WebGPUDriver::generateMipmaps(Handle<HwTexture> textureHandle) {
+    if (!mCommandEncoder) {
+        mMipQueue.push_back(textureHandle);
+        return;
+    }
    auto texture = handleCast<WebGPUTexture>(textureHandle);
    assert_invariant(texture);
    wgpu::Texture wgpuTexture = texture->getTexture();
    assert_invariant(wgpuTexture);

-//    const auto usage = wgpuTexture.GetUsage();
-//    FILAMENT_CHECK_PRECONDITION(usage & wgpu::TextureUsage::TextureBinding)
-//            << "Texture for mipmap generation must have TextureBinding usage.";
-//    FILAMENT_CHECK_PRECONDITION(usage & wgpu::TextureUsage::StorageBinding)
-//            << "Texture for mipmap generation must have StorageBinding usage.";
+    FILAMENT_CHECK_PRECONDITION(wgpuTexture.GetUsage() & wgpu::TextureUsage::CopySrc)
+            << "Texture intended for mipmap generation (as source) must have CopySrc usage.";
+    FILAMENT_CHECK_PRECONDITION(wgpuTexture.GetUsage() & wgpu::TextureUsage::CopyDst)
+            << "Texture intended for mipmap generation (as destination) must have CopyDst usage.";

-    const uint32_t totalMipLevels = wgpuTexture.GetMipLevelCount();
-    if (totalMipLevels <= 1) {
+    uint32_t mipLevelCount = wgpuTexture.GetMipLevelCount();
+    if (mipLevelCount <= 1) {
        return;
    }
+    FILAMENT_CHECK_PRECONDITION(texture->supportsMultipleMipLevels())
+            << "Calling generateMipmaps(...) on a texture that doesn't support generating them. "
+               "sampler type "
+            << to_string(texture->target) << " levels " << static_cast<uint32_t>(texture->levels)
+            << " wgpu format (enum value) "
+            << static_cast<uint32_t>(texture->getTexture().GetFormat()) << " width "
+            << texture->width << " height " << texture->height << " depth " << texture->depth
+            << " usage flags (as a number) " << static_cast<uint32_t>(texture->usage);

-    // Determine the maximum number of mips we can generate in a single pass.
-    // The limit is on *storage* textures, and we need 1 binding for the source texture.
-    const uint32_t maxMipsPerPass = 2;//mDeviceLimits.maxStorageTexturesPerShaderStage - 1;
-    FILAMENT_CHECK_POSTCONDITION(maxMipsPerPass > 0)
-            << "Device does not support enough storage textures for mipmapping.";
+    uint32_t width = wgpuTexture.GetWidth();
+    uint32_t height = wgpuTexture.GetHeight();
+    // For 3D textures, depth is > 1. For 2D/Cube/Array, effectively 1 for mip-level copies.
+    uint32_t depth =
+            (texture->target == SamplerType::SAMPLER_3D) ? wgpuTexture.GetDepthOrArrayLayers() : 1;

-    // The generator can be created once.
-    spd::MipmapGenerator mipmapGenerator(mDevice);
+    for (uint32_t mipLevel = 0; mipLevel < mipLevelCount - 1; ++mipLevel) {
+        wgpu::TexelCopyTextureInfo sourceCopyInfo{
+            .texture = wgpuTexture,
+            .mipLevel = mipLevel,
+            .aspect = texture->getAspect(),
+        };

-    // We will record all passes into a single command encoder.
-    wgpu::CommandEncoderDescriptor encoderDesc = {};
-    encoderDesc.label = "Mipmap Command Encoder";
-    wgpu::CommandEncoder encoder = mDevice.CreateCommandEncoder(&encoderDesc);
+        wgpu::TexelCopyTextureInfo destinationCopyInfo{
+            .texture = wgpuTexture,
+            .mipLevel = mipLevel + 1,
+            .aspect = texture->getAspect(),
+        };

-    uint32_t mipsLeftToGenerate = totalMipLevels - 1;
-    uint32_t currentSourceMipLevel = 0;
+        uint32_t dstWidth = std::max(1u, width >> 1);
+        uint32_t dstHeight = std::max(1u, height >> 1);
+        uint32_t dstDepth = std::max(1u, depth >> 1);

-    while (mipsLeftToGenerate > 0) {
-        uint32_t mipsThisPass = std::min(mipsLeftToGenerate, maxMipsPerPass);
+        wgpu::Extent3D copySize{ .width = dstWidth,
+            .height = dstHeight,
+            .depthOrArrayLayers = (texture->target == SamplerType::SAMPLER_3D)
+                                          ? dstDepth
+                                          : texture->getArrayLayerCount() };
+        mCommandEncoder.CopyTextureToTexture(&sourceCopyInfo, &destinationCopyInfo, &copySize);

-        spd::SPDPassConfig config = {};
-        config.filter = spd::SPDFilter::Average;
-        config.targetTexture = wgpuTexture;
-        config.numMips = mipsThisPass;
-        config.sourceMipLevel = currentSourceMipLevel;
-
-        // The generator needs to create pipelines for the number of mips in THIS pass.
-        mipmapGenerator.PreparePipelines(wgpuTexture.GetFormat(), config.filter);
-
-        // Generate one batch of mipmaps.
-        mipmapGenerator.Generate(encoder, wgpuTexture, config);
-
-        mipsLeftToGenerate -= mipsThisPass;
-        currentSourceMipLevel += mipsThisPass;
+        width = dstWidth;
+        height = dstHeight;
+        depth = dstDepth;
    }
-
-    // Finish the encoder and submit all the passes at once.
-    wgpu::CommandBufferDescriptor cmdBufferDesc = {};
-    cmdBufferDesc.label = "Mipmap Command Buffer";
-    wgpu::CommandBuffer commandBuffer = encoder.Finish(&cmdBufferDesc);
-    mQueue.Submit(1, &commandBuffer);
 }

 void WebGPUDriver::compilePrograms(CompilerPriorityQueue priority,
@@ -811,6 +815,7 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,

    wgpu::TextureView defaultColorView = nullptr;
    wgpu::TextureView defaultDepthStencilView = nullptr;
+    wgpu::TextureFormat defaultDepthStencilFormat = wgpu::TextureFormat::Undefined;

    std::array<wgpu::TextureView, MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT> customColorViews{};
    uint32_t customColorViewCount = 0;
@@ -824,6 +829,7 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,
        assert_invariant(mSwapChain && mTextureView);
        defaultColorView = mTextureView;
        defaultDepthStencilView = mSwapChain->getDepthTextureView();
+        defaultDepthStencilFormat = mSwapChain->getDepthFormat();
    } else {
        // Resolve views for custom render target
        const auto& colorInfos = renderTarget->getColorAttachmentInfos();
@@ -855,7 +861,7 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,
                const uint32_t depthArrayLayer = depthInfo.layer;
                customDepthView =
                        depthTexture->getOrMakeTextureView(depthMipLevel, depthArrayLayer);
-                customDepthFormat = depthTexture->getWebGPUFormat();
+                customDepthFormat = depthTexture->getViewFormat();
            }
        }

@@ -872,7 +878,7 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,
                const uint32_t stencilArrayLayer = stencilInfo.layer;
                customStencilView =
                        stencilTexture->getOrMakeTextureView(stencilMipLevel, stencilArrayLayer);
-                customStencilFormat = stencilTexture->getWebGPUFormat();
+                customStencilFormat = stencilTexture->getViewFormat();
            }
        }
    }
@@ -881,6 +887,7 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,
            params,
            defaultColorView,
            defaultDepthStencilView,
+            defaultDepthStencilFormat,
            customColorViews.data(),
            customColorViewCount,
            customDepthView,
@@ -29,6 +29,7 @@

 #include <utils/compiler.h>

+#include <tsl/robin_map.h>
 #include <webgpu/webgpu_cpp.h>

 #include <cstdint>
@@ -29,6 +29,7 @@
 #include <utils/ostream.h>

 #include <webgpu/webgpu_cpp.h>
+#include <dawn/webgpu_cpp_print.h>

 #include <array>
 #include <cstdint>
@@ -187,7 +188,7 @@ namespace {
                        switch (status) {
                            case wgpu::CompilationInfoRequestStatus::CallbackCancelled:
                                FWGPU_LOGW << "Shader compilation info callback cancelled for "
-                                           << descriptor.label << "?" << utils::io::endl;
+                                           << descriptor.label << "?";
                                return;
                            case wgpu::CompilationInfoRequestStatus::Success:
                                break;
@@ -203,8 +204,7 @@ namespace {
                                                   << " line#:" << message.lineNum
                                                   << " linePos:" << message.linePos
                                                   << " offset:" << message.offset
-                                                   << " length:" << message.length
-                                                   << utils::io::endl;
+                                                   << " length:" << message.length;
                                        break;
                                    case wgpu::CompilationMessageType::Warning:
                                        FWGPU_LOGW
@@ -212,7 +212,7 @@ namespace {
                                                << message.message << " line#:" << message.lineNum
                                                << " linePos:" << message.linePos
                                                << " offset:" << message.offset
-                                                << " length:" << message.length << utils::io::endl;
+                                                << " length:" << message.length;
                                        break;
                                    case wgpu::CompilationMessageType::Error:
                                        errorCount++;
@@ -231,8 +231,7 @@ namespace {
                                    << errorStream.str();
                        }
 #if FWGPU_ENABLED(FWGPU_DEBUG_VALIDATION)
-                        FWGPU_LOGD << descriptor.label << " compiled successfully"
-                                   << utils::io::endl;
+                        FWGPU_LOGD << descriptor.label << " compiled successfully";
 #endif
                    }),
            SHADER_COMPILATION_TIMEOUT_NANOSECONDS);
@@ -73,6 +73,7 @@ wgpu::StoreOp WebGPURenderTarget::getStoreOperation(RenderPassParams const& para
 void WebGPURenderTarget::setUpRenderPassAttachments(wgpu::RenderPassDescriptor& outDescriptor,
        RenderPassParams const& params, wgpu::TextureView const& defaultColorTextureView,
        wgpu::TextureView const& defaultDepthStencilTextureView,
+        wgpu::TextureFormat const& defaultDepthStencilFormat,
        wgpu::TextureView const* customColorTextureViews, uint32_t customColorTextureViewCount,
        wgpu::TextureView const& customDepthTextureView,
        wgpu::TextureView const& customStencilTextureView,
@@ -93,30 +94,39 @@ void WebGPURenderTarget::setUpRenderPassAttachments(wgpu::RenderPassDescriptor&
        if (defaultDepthStencilTextureView) {
            mDepthStencilAttachmentDescriptor = {
                .view = defaultDepthStencilTextureView,
-                .depthLoadOp = WebGPURenderTarget::getLoadOperation(params, TargetBufferFlags::DEPTH),
+                .depthLoadOp =
+                        WebGPURenderTarget::getLoadOperation(params, TargetBufferFlags::DEPTH),
                .depthStoreOp =
                        WebGPURenderTarget::getStoreOperation(params, TargetBufferFlags::DEPTH),
                .depthClearValue = static_cast<float>(params.clearDepth),
                .depthReadOnly =
                        (params.readOnlyDepthStencil & RenderPassParams::READONLY_DEPTH) > 0,
-                .stencilLoadOp =
-                        WebGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL),
-                .stencilStoreOp =
-                        WebGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL),
+                .stencilLoadOp = wgpu::LoadOp::Undefined,
+                .stencilStoreOp = wgpu::StoreOp::Undefined,
                .stencilClearValue = params.clearStencil,
                .stencilReadOnly =
                        (params.readOnlyDepthStencil & RenderPassParams::READONLY_STENCIL) > 0,
            };
+
+            if (defaultDepthStencilFormat == wgpu::TextureFormat::Depth24PlusStencil8 ||
+                    defaultDepthStencilFormat == wgpu::TextureFormat::Depth32FloatStencil8 ||
+                    defaultDepthStencilFormat == wgpu::TextureFormat::Stencil8) {
+                mDepthStencilAttachmentDescriptor.stencilLoadOp =
+                        WebGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL);
+                mDepthStencilAttachmentDescriptor.stencilStoreOp =
+                        WebGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL);
+            }
            mHasDepthStencilAttachment = true;
        }
-    } else {// Custom Render Target
+    } else { // Custom Render Target
        for (uint32_t i = 0; i < customColorTextureViewCount; ++i) {
            if (customColorTextureViews[i]) {
                mColorAttachmentDescriptors.push_back({ .view = customColorTextureViews[i],
                    // .resolveTarget = nullptr; // TODO: MSAA resolve for custom RT
-                    .loadOp = WebGPURenderTarget::getLoadOperation(params, getTargetBufferFlagsAt(i)),
-                    .storeOp =
-                            WebGPURenderTarget::getStoreOperation(params, getTargetBufferFlagsAt(i)),
+                    .loadOp =
+                            WebGPURenderTarget::getLoadOperation(params, getTargetBufferFlagsAt(i)),
+                    .storeOp = WebGPURenderTarget::getStoreOperation(params,
+                            getTargetBufferFlagsAt(i)),
                    .clearValue = { .r = params.clearColor.r,
                        .g = params.clearColor.g,
                        .b = params.clearColor.b,
@@ -46,6 +46,7 @@ public:
            // For default render target:
            wgpu::TextureView const& defaultColorTextureView,
            wgpu::TextureView const& defaultDepthStencilTextureView,
+            wgpu::TextureFormat const& defaultDepthStencilFormat,
            // For custom render targets:
            wgpu::TextureView const* customColorTextureViews, // Array of views
            uint32_t customColorTextureViewCount,
@@ -54,52 +54,50 @@ utils::io::ostream& operator<<(utils::io::ostream& out,
 }

 void printSurfaceCapabilitiesDetails(wgpu::SurfaceCapabilities const& capabilities) {
-    FWGPU_LOGI << "WebGPU surface capabilities:" << utils::io::endl;
-    FWGPU_LOGI << "  surface usages: " << capabilities.usages << utils::io::endl;
-    FWGPU_LOGI << "  surface formats (" << capabilities.formatCount << "):" << utils::io::endl;
+    FWGPU_LOGI << "WebGPU surface capabilities:";
+    FWGPU_LOGI << "  surface usages: " << capabilities.usages;
+    FWGPU_LOGI << "  surface formats (" << capabilities.formatCount << "):";
    if (capabilities.formatCount > 0 && capabilities.formats != nullptr) {
        std::for_each(capabilities.formats, capabilities.formats + capabilities.formatCount,
                [](wgpu::TextureFormat const format) {
-                    FWGPU_LOGI << "    " << format << utils::io::endl;
+                    FWGPU_LOGI << "    " << format;
                });
    }
-    FWGPU_LOGI << "  surface present modes (" << capabilities.presentModeCount
-               << "):" << utils::io::endl;
+    FWGPU_LOGI << "  surface present modes (" << capabilities.presentModeCount << "):";
    if (capabilities.presentModeCount > 0 && capabilities.presentModes != nullptr) {
        std::for_each(capabilities.presentModes,
                capabilities.presentModes + capabilities.presentModeCount,
                [](wgpu::PresentMode const presentMode) {
-                    FWGPU_LOGI << "    " << presentMode << utils::io::endl;
+                    FWGPU_LOGI << "    " << presentMode;
                });
    }
-    FWGPU_LOGI << "  surface alpha modes (" << capabilities.alphaModeCount
-               << "):" << utils::io::endl;
+    FWGPU_LOGI << "  surface alpha modes (" << capabilities.alphaModeCount << "):";
    if (capabilities.alphaModeCount > 0 && capabilities.alphaModes != nullptr) {
        std::for_each(capabilities.alphaModes,
                capabilities.alphaModes + capabilities.alphaModeCount,
                [](wgpu::CompositeAlphaMode const alphaMode) {
-                    FWGPU_LOGI << "    " << alphaMode << utils::io::endl;
+                    FWGPU_LOGI << "    " << alphaMode;
                });
    }
 }

 void printSurfaceConfiguration(wgpu::SurfaceConfiguration const& config,
        wgpu::TextureFormat depthFormat) {
-    FWGPU_LOGI << "WebGPU surface configuration:" << utils::io::endl;
-    FWGPU_LOGI << "  surface format: " << config.format << utils::io::endl;
-    FWGPU_LOGI << "  surface usage: " << config.usage << utils::io::endl;
-    FWGPU_LOGI << "  surface view formats (" << config.viewFormatCount << "):" << utils::io::endl;
+    FWGPU_LOGI << "WebGPU surface configuration:";
+    FWGPU_LOGI << "  surface format: " << config.format;
+    FWGPU_LOGI << "  surface usage: " << config.usage;
+    FWGPU_LOGI << "  surface view formats (" << config.viewFormatCount << "):";
    if (config.viewFormatCount > 0 && config.viewFormats != nullptr) {
        std::for_each(config.viewFormats, config.viewFormats + config.viewFormatCount,
                [](wgpu::TextureFormat const viewFormat) {
-                    FWGPU_LOGI << "    " << viewFormat << utils::io::endl;
+                    FWGPU_LOGI << "    " << viewFormat;
                });
    }
-    FWGPU_LOGI << "  surface alpha mode: " << config.alphaMode << utils::io::endl;
-    FWGPU_LOGI << "  surface width: " << config.width << utils::io::endl;
-    FWGPU_LOGI << "  surface height: " << config.height << utils::io::endl;
-    FWGPU_LOGI << "  surface present mode: " << config.presentMode << utils::io::endl;
-    FWGPU_LOGI << "WebGPU selected depth format: " << depthFormat << utils::io::endl;
+    FWGPU_LOGI << "  surface alpha mode: " << config.alphaMode;
+    FWGPU_LOGI << "  surface width: " << config.width;
+    FWGPU_LOGI << "  surface height: " << config.height;
+    FWGPU_LOGI << "  surface present mode: " << config.presentMode;
+    FWGPU_LOGI << "WebGPU selected depth format: " << depthFormat;
 }
 #endif// FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)

@@ -189,8 +187,7 @@ void printSurfaceConfiguration(wgpu::SurfaceConfiguration const& config,
        // We prefer premultiplied to unpremuliplied until that assumption should be adjusted.
        FWGPU_LOGW << "Auto, Inherit, & Opaque composite alpha modes not supported. Filament has "
                      "historically used these. Premultiplied alpha composite mode for "
-                      "transparency is being selected as a fallback, but may not work as expected."
-                   << utils::io::endl;
+                      "transparency is being selected as a fallback, but may not work as expected.";
        return wgpu::CompositeAlphaMode::Premultiplied;
    } else {
        FILAMENT_CHECK_POSTCONDITION(unpremultipliedAvailable)
@@ -200,8 +197,7 @@ void printSurfaceConfiguration(wgpu::SurfaceConfiguration const& config,
        FWGPU_LOGW << "Auto, Inherit, & Opaque composite alpha modes not supported. Filament has "
                      "historically used these. Unpremultiplied alpha composite mode for "
                      "transparency is being selected as a fallback "
-                      "(premulitipled is not available either), but may not work as expected."
-                   << utils::io::endl;
+                      "(premulitipled is not available either), but may not work as expected.";
        return wgpu::CompositeAlphaMode::Unpremultiplied;
    }
 }
@@ -274,7 +270,7 @@ WebGPUSwapChain::WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Extent2D const&
      mDepthTextureView(createDepthTextureView(mDepthTexture, mDepthFormat, mNeedStencil)) {
    wgpu::SurfaceCapabilities capabilities = {};
    if (!mSurface.GetCapabilities(adapter, &capabilities)) {
-        FWGPU_LOGW << "Failed to get WebGPU surface capabilities" << utils::io::endl;
+        FWGPU_LOGW << "Failed to get WebGPU surface capabilities";
    } else {
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
        printSurfaceCapabilitiesDetails(capabilities);
@@ -297,8 +293,7 @@ void WebGPUSwapChain::setExtent(wgpu::Extent2D const& currentSurfaceSize) {
    if (mConfig.width != currentSurfaceSize.width || mConfig.height != currentSurfaceSize.height) {
        mConfig.width = currentSurfaceSize.width;
        mConfig.height = currentSurfaceSize.height;
-        FWGPU_LOGD << "Resizing to width " << mConfig.width << " height " << mConfig.height
-                   << utils::io::endl;
+        FWGPU_LOGD << "Resizing to width " << mConfig.width << " height " << mConfig.height;
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
        printSurfaceConfiguration(mConfig, mDepthFormat);
 #endif
@@ -28,90 +28,16 @@
 #include <utils/ostream.h>

 #include <webgpu/webgpu_cpp.h>
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+#include <webgpu/webgpu_cpp_print.h>
+#include <sstream>
+#endif

 #include <cstdint>

 namespace filament::backend {

 namespace {
-[[nodiscard]] bool IsFormatStorageCompatible(wgpu::TextureFormat format) {
-    switch (format) {
-        // List of formats that support storage binding
-        case wgpu::TextureFormat::R32Float:
-        case wgpu::TextureFormat::R32Sint:
-        case wgpu::TextureFormat::R32Uint:
-        case wgpu::TextureFormat::RG32Float:
-        case wgpu::TextureFormat::RG32Sint:
-        case wgpu::TextureFormat::RG32Uint:
-        case wgpu::TextureFormat::RGBA16Float:
-        case wgpu::TextureFormat::RGBA16Sint:
-        case wgpu::TextureFormat::RGBA16Uint:
-        case wgpu::TextureFormat::RGBA32Float:
-        case wgpu::TextureFormat::RGBA32Sint:
-        case wgpu::TextureFormat::RGBA32Uint:
-        case wgpu::TextureFormat::RGBA8Unorm:
-        case wgpu::TextureFormat::RGBA8Snorm:
-        case wgpu::TextureFormat::RGBA8Uint:
-        case wgpu::TextureFormat::RGBA8Sint:
-            return true;
-        default:
-            // All other formats, including packed floats (RG11B10Ufloat),
-            // depth/stencil, and sRGB formats do not support storage.
-            return false;
-    }
-}
-wgpu::TextureFormat GetStorageCompatibleFormat(wgpu::TextureFormat srgbFormat) {
-    switch (srgbFormat) {
-        case wgpu::TextureFormat::RGBA8UnormSrgb:
-            return wgpu::TextureFormat::RGBA8Unorm;
-        case wgpu::TextureFormat::BGRA8UnormSrgb:
-            return wgpu::TextureFormat::BGRA8Unorm;
-        case wgpu::TextureFormat::BC1RGBAUnormSrgb:
-            return wgpu::TextureFormat::BC1RGBAUnorm;
-        case wgpu::TextureFormat::BC2RGBAUnormSrgb:
-            return wgpu::TextureFormat::BC2RGBAUnorm;
-        case wgpu::TextureFormat::BC3RGBAUnormSrgb:
-            return wgpu::TextureFormat::BC3RGBAUnorm;
-        case wgpu::TextureFormat::BC7RGBAUnormSrgb:
-            return wgpu::TextureFormat::BC7RGBAUnorm;
-        case wgpu::TextureFormat::ETC2RGB8UnormSrgb:
-            return wgpu::TextureFormat::ETC2RGB8Unorm;
-        case wgpu::TextureFormat::ETC2RGB8A1UnormSrgb:
-            return wgpu::TextureFormat::ETC2RGB8A1Unorm;
-        case wgpu::TextureFormat::ETC2RGBA8UnormSrgb:
-            return wgpu::TextureFormat::ETC2RGBA8Unorm;
-        case wgpu::TextureFormat::ASTC4x4UnormSrgb:
-            return wgpu::TextureFormat::ASTC4x4Unorm;
-        case wgpu::TextureFormat::ASTC5x4UnormSrgb:
-            return wgpu::TextureFormat::ASTC5x4Unorm;
-        case wgpu::TextureFormat::ASTC5x5UnormSrgb:
-            return wgpu::TextureFormat::ASTC5x5Unorm;
-        case wgpu::TextureFormat::ASTC6x5UnormSrgb:
-            return wgpu::TextureFormat::ASTC6x5Unorm;
-        case wgpu::TextureFormat::ASTC6x6UnormSrgb:
-            return wgpu::TextureFormat::ASTC6x6Unorm;
-        case wgpu::TextureFormat::ASTC8x5UnormSrgb:
-            return wgpu::TextureFormat::ASTC8x5Unorm;
-        case wgpu::TextureFormat::ASTC8x6UnormSrgb:
-            return wgpu::TextureFormat::ASTC8x6Unorm;
-        case wgpu::TextureFormat::ASTC8x8UnormSrgb:
-            return wgpu::TextureFormat::ASTC8x8Unorm;
-        case wgpu::TextureFormat::ASTC10x5UnormSrgb:
-            return wgpu::TextureFormat::ASTC10x5Unorm;
-        case wgpu::TextureFormat::ASTC10x6UnormSrgb:
-            return wgpu::TextureFormat::ASTC10x6Unorm;
-        case wgpu::TextureFormat::ASTC10x8UnormSrgb:
-            return wgpu::TextureFormat::ASTC10x8Unorm;
-        case wgpu::TextureFormat::ASTC10x10UnormSrgb:
-            return wgpu::TextureFormat::ASTC10x10Unorm;
-        case wgpu::TextureFormat::ASTC12x10UnormSrgb:
-            return wgpu::TextureFormat::ASTC12x10Unorm;
-        case wgpu::TextureFormat::ASTC12x12UnormSrgb:
-            return wgpu::TextureFormat::ASTC12x12Unorm;
-        default:
-            return srgbFormat; // If not an sRGB format, return the same input
-    }
-}

 [[nodiscard]] constexpr wgpu::StringView getUserTextureLabel(const SamplerType target) {
    // TODO will be helpful to get more useful info than this
@@ -137,21 +63,108 @@ wgpu::TextureFormat GetStorageCompatibleFormat(wgpu::TextureFormat srgbFormat) {
    }
 }

+/**
+ * @param format texture format to potentially be used for storage binding
+ * @return true if the format is compatible with wgpu::TextureUsage::StorageBinding
+ */
+[[nodiscard]] constexpr bool isFormatStorageCompatible(const wgpu::TextureFormat format) {
+    switch (format) {
+        // List of formats that support storage binding
+        case wgpu::TextureFormat::R32Float:
+        case wgpu::TextureFormat::R32Sint:
+        case wgpu::TextureFormat::R32Uint:
+        case wgpu::TextureFormat::RG32Float:
+        case wgpu::TextureFormat::RG32Sint:
+        case wgpu::TextureFormat::RG32Uint:
+        case wgpu::TextureFormat::RGBA16Float:
+        case wgpu::TextureFormat::RGBA16Sint:
+        case wgpu::TextureFormat::RGBA16Uint:
+        case wgpu::TextureFormat::RGBA32Float:
+        case wgpu::TextureFormat::RGBA32Sint:
+        case wgpu::TextureFormat::RGBA32Uint:
+        case wgpu::TextureFormat::RGBA8Unorm:
+        case wgpu::TextureFormat::RGBA8Snorm:
+        case wgpu::TextureFormat::RGBA8Uint:
+        case wgpu::TextureFormat::RGBA8Sint:
+            return true;
+        default:
+            // All other formats, including packed floats (RG11B10Ufloat),
+            // depth/stencil, and sRGB formats do not support storage.
+            return false;
+    }
+}
+
+/**
+ * @param viewFormat potential view format to a texture
+ * @return an underlying texture format that is storage binding compatible for which this view
+ *         texture format can be used. If no such format exists, Undefined is returned.
+ *         If the view texture is already storage binding compatible then the view texture itself
+ *         is returned.
+ */
+[[nodiscard]] constexpr wgpu::TextureFormat storageBindingCompatibleFormatForViewFormat(
+        const wgpu::TextureFormat viewFormat) {
+    switch (viewFormat) {
+        case wgpu::TextureFormat::RGBA8UnormSrgb:      return wgpu::TextureFormat::RGBA8Unorm;
+        case wgpu::TextureFormat::BGRA8UnormSrgb:      return wgpu::TextureFormat::BGRA8Unorm;
+        case wgpu::TextureFormat::BC1RGBAUnormSrgb:    return wgpu::TextureFormat::BC1RGBAUnorm;
+        case wgpu::TextureFormat::BC2RGBAUnormSrgb:    return wgpu::TextureFormat::BC2RGBAUnorm;
+        case  wgpu::TextureFormat::BC3RGBAUnormSrgb:   return wgpu::TextureFormat::BC3RGBAUnorm;
+        case wgpu::TextureFormat::BC7RGBAUnormSrgb:    return wgpu::TextureFormat::BC7RGBAUnorm;
+        case wgpu::TextureFormat::ETC2RGB8UnormSrgb:   return wgpu::TextureFormat::ETC2RGB8Unorm;
+        case wgpu::TextureFormat::ETC2RGB8A1UnormSrgb: return wgpu::TextureFormat::ETC2RGB8A1Unorm;
+        case wgpu::TextureFormat::ETC2RGBA8UnormSrgb:  return wgpu::TextureFormat::ETC2RGBA8Unorm;
+        case wgpu::TextureFormat::ASTC4x4UnormSrgb:    return wgpu::TextureFormat::ASTC4x4Unorm;
+        case wgpu::TextureFormat::ASTC5x4UnormSrgb:    return wgpu::TextureFormat::ASTC5x4Unorm;
+        case wgpu::TextureFormat::ASTC5x5UnormSrgb:    return wgpu::TextureFormat::ASTC5x5Unorm;
+        case wgpu::TextureFormat::ASTC6x5UnormSrgb:    return wgpu::TextureFormat::ASTC6x5Unorm;
+        case wgpu::TextureFormat::ASTC6x6UnormSrgb:    return wgpu::TextureFormat::ASTC6x6Unorm;
+        case wgpu::TextureFormat::ASTC8x5UnormSrgb:    return wgpu::TextureFormat::ASTC8x5Unorm;
+        case wgpu::TextureFormat::ASTC8x6UnormSrgb:    return wgpu::TextureFormat::ASTC8x6Unorm;
+        case wgpu::TextureFormat::ASTC8x8UnormSrgb:    return wgpu::TextureFormat::ASTC8x8Unorm;
+        case wgpu::TextureFormat::ASTC10x5UnormSrgb:   return wgpu::TextureFormat::ASTC10x5Unorm;
+        case wgpu::TextureFormat::ASTC10x6UnormSrgb:   return wgpu::TextureFormat::ASTC10x6Unorm;
+        case wgpu::TextureFormat::ASTC10x8UnormSrgb:   return wgpu::TextureFormat::ASTC10x8Unorm;
+        case wgpu::TextureFormat::ASTC10x10UnormSrgb:  return wgpu::TextureFormat::ASTC10x10Unorm;
+        case wgpu::TextureFormat::ASTC12x10UnormSrgb:  return wgpu::TextureFormat::ASTC12x10Unorm;
+        case wgpu::TextureFormat::ASTC12x12UnormSrgb:  return wgpu::TextureFormat::ASTC12x12Unorm;
+        default:
+            if (isFormatStorageCompatible(viewFormat)) {
+                return viewFormat; // view format is itself already storage binding compatible
+            } else {
+                return wgpu::TextureFormat::Undefined; // no valid format in this case
+            }
+    }
+}
+
+/**
+ * @param fUsage Filament's requested texture usage
+ * @param samples How many samples to use for MSAA
+ * @param needsComputeStorageSupport if we need to use this texture as storage binding in something
+ *                                   like a compute shader
+ * @return The appropriate texture usage flags for the underlying texture
+ */
 [[nodiscard]] wgpu::TextureUsage fToWGPUTextureUsage(TextureUsage const& fUsage,
-        const uint8_t samples) {
+        const uint8_t samples, const bool needsComputeStorageSupport) {
    wgpu::TextureUsage retUsage = wgpu::TextureUsage::None;

+    // if needsComputeStorageSupport we need to read and write to the texture in a shader and thus
+    // require CopySrc, CopyDst, TextureBinding, & StorageBinding
+
    // Basing this mapping off of VulkanTexture.cpp's getUsage func and suggestions from Gemini
    // TODO Validate assumptions, revisit if issues.
-    if (any(TextureUsage::BLIT_SRC & fUsage)) {
+    if (needsComputeStorageSupport || any(TextureUsage::BLIT_SRC & fUsage)) {
        retUsage |= wgpu::TextureUsage::CopySrc;
    }
-    if (any((TextureUsage::BLIT_DST | TextureUsage::UPLOADABLE) & fUsage)) {
+    if (needsComputeStorageSupport ||
+            any((TextureUsage::BLIT_DST | TextureUsage::UPLOADABLE) & fUsage)) {
        retUsage |= wgpu::TextureUsage::CopyDst;
    }
-    if (any(TextureUsage::SAMPLEABLE & fUsage)) {
+    if (needsComputeStorageSupport || any(TextureUsage::SAMPLEABLE & fUsage)) {
        retUsage |= wgpu::TextureUsage::TextureBinding;
    }
+    if (needsComputeStorageSupport) {
+        retUsage |= wgpu::TextureUsage::StorageBinding;
+    }
    // WGPU Render attachment covers either color or stencil situation dependant
    // NOTE: Depth attachment isn't used this way in Vulkan but logically maps to WGPU docs. If
    // issues, investigate here.
@@ -178,7 +191,6 @@ wgpu::TextureFormat GetStorageCompatibleFormat(wgpu::TextureFormat srgbFormat) {
        retUsage |= wgpu::TextureUsage::TransientAttachment;
    }
    // NOTE: Unused wgpu flags:
-    //  StorageBinding
    //  StorageAttachment

    // NOTE: Unused Filament flags:
@@ -283,16 +295,19 @@ WebGPUTexture::WebGPUTexture(const SamplerType samplerType, const uint8_t levels
        const uint32_t height, const uint32_t depth, const TextureUsage usage,
        wgpu::Device const& device) noexcept
    : HwTexture{ samplerType, levels, samples, width, height, depth, format, usage },
-      mWebGPUFormat{ fToWGPUTextureFormat(format) },
+      mViewFormat{ fToWGPUTextureFormat(format) },
+      mSupportsMultipleMipLevels{ levels > 1 &&
+                                  supportsMultipleMipLevelsViaStorageBinding(mViewFormat) },
+      mWebGPUFormat{ mSupportsMultipleMipLevels
+                             ? storageBindingCompatibleFormatForViewFormat(mViewFormat)
+                             : mViewFormat },
      mAspect{ fToWGPUTextureViewAspect(usage, format) },
-      mWebGPUUsage{ fToWGPUTextureUsage(usage, samples) },
+      mWebGPUUsage{ fToWGPUTextureUsage(usage, samples, mSupportsMultipleMipLevels) },
+      mViewUsage{ fToWGPUTextureUsage(usage, samples, false) },
      mBlockWidth{ filament::backend::getBlockWidth(format) },
-      mBlockHeight{ filament::backend::getBlockHeight(format) } {
-    mCompatFormat = GetStorageCompatibleFormat(mWebGPUFormat);
-        if(levels > 1 && (mWebGPUUsage & wgpu::TextureUsage::TextureBinding) && (mWebGPUUsage & wgpu::TextureUsage::CopyDst) && IsFormatStorageCompatible(mCompatFormat)){
-        mWebGPUUsage |= wgpu::TextureUsage::StorageBinding;
-    }
-
+      mBlockHeight{ filament::backend::getBlockHeight(format) },
+      mDefaultMipLevel{ 0 },
+      mDefaultBaseArrayLayer{ 0 } {
    assert_invariant(
            samples == 1 ||
            samples == 4 &&
@@ -300,7 +315,7 @@ WebGPUTexture::WebGPUTexture(const SamplerType samplerType, const uint8_t levels
                    "count to either be 1 (no multisampling) or 4, at least as of April 2025 of "
                    "the spec. See https://www.w3.org/TR/webgpu/#texture-creation or "
                    "https://gpuweb.github.io/gpuweb/#multisample-state");
-    wgpu::TextureDescriptor textureDescriptor{
+    const wgpu::TextureDescriptor textureDescriptor{
        .label = getUserTextureLabel(samplerType),
        .usage = mWebGPUUsage,
        .dimension = toWebGPUTextureDimension(samplerType),
@@ -308,21 +323,9 @@ WebGPUTexture::WebGPUTexture(const SamplerType samplerType, const uint8_t levels
        .format = mWebGPUFormat,
        .mipLevelCount = levels,
        .sampleCount = samples,
-        // TODO Is this fine? Could do all-the-things, a naive mapping or get something from
-        // Filament
-        .viewFormatCount = 0,
-        .viewFormats = nullptr,
+        .viewFormatCount = 1,
+        .viewFormats = &mViewFormat,
    };
-
-    //If our main format is not srgb, make the srgb a view into a non-srgb format
-    if(mCompatFormat != mWebGPUFormat){
-        textureDescriptor.viewFormatCount = 1;
-        std::swap(mCompatFormat, mWebGPUFormat);
-        textureDescriptor.format = mWebGPUFormat;
-        textureDescriptor.viewFormats = &mCompatFormat;
-        mWebGPUUsage|=wgpu::TextureUsage::StorageBinding;
-        textureDescriptor.usage = mWebGPUUsage;
-    }
    mArrayLayerCount = toArrayLayerCount(samplerType, textureDescriptor.size.depthOrArrayLayers);
    assert_invariant(textureDescriptor.format != wgpu::TextureFormat::Undefined &&
                     "Could not find appropriate WebGPU format");
@@ -333,23 +336,41 @@ WebGPUTexture::WebGPUTexture(const SamplerType samplerType, const uint8_t levels
            mArrayLayerCount, samplerType);
    FILAMENT_CHECK_POSTCONDITION(mDefaultTextureView)
            << "Failed to create default texture view for " << textureDescriptor.label;
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    if (mViewFormat != mWebGPUFormat) {
+        std::stringstream viewFormatStream;
+        viewFormatStream << mViewFormat;
+        std::stringstream textureFormatStream;
+        textureFormatStream << mWebGPUFormat;
+        FWGPU_LOGD << "Texture '" << textureDescriptor.label << "' has view format "
+                   << viewFormatStream.str() << " and texture format " << textureFormatStream.str()
+                   << utils::io::endl;
+    }
+#endif
 }

 WebGPUTexture::WebGPUTexture(WebGPUTexture const* src, const uint8_t baseLevel,
        const uint8_t levelCount) noexcept
    : HwTexture{ src->target, levelCount, src->samples, src->width, src->height, src->depth,
          src->format, src->usage },
-      mTexture{ src->mTexture },
+      mViewFormat{ src->mViewFormat },
+      mSupportsMultipleMipLevels{ src->mSupportsMultipleMipLevels },
      mWebGPUFormat{ src->mWebGPUFormat },
      mAspect{ src->mAspect },
      mWebGPUUsage{ src->mWebGPUUsage },
-      mArrayLayerCount{ src->mArrayLayerCount },
+      mViewUsage{ src->mViewUsage },
      mBlockWidth{ src->mBlockWidth },
      mBlockHeight{ src->mBlockHeight },
-      mDefaultTextureView{ makeTextureView(baseLevel, levelCount, 0, src->mArrayLayerCount,
-              src->target) },
+      mArrayLayerCount{ src->mArrayLayerCount },
+      mTexture{ src->mTexture },
      mDefaultMipLevel{ baseLevel },
-      mDefaultBaseArrayLayer{ src->mArrayLayerCount } {}
+      mDefaultBaseArrayLayer{ src->mArrayLayerCount },
+      mDefaultTextureView{ makeTextureView(mDefaultMipLevel, levelCount, 0, mDefaultBaseArrayLayer,
+              src->target) } {}
+
+bool WebGPUTexture::supportsMultipleMipLevelsViaStorageBinding(const wgpu::TextureFormat format) {
+    return storageBindingCompatibleFormatForViewFormat(format) != wgpu::TextureFormat::Undefined;
+}

 wgpu::TextureView WebGPUTexture::getOrMakeTextureView(const uint8_t mipLevel,
        const uint32_t arrayLayer) {
@@ -548,17 +569,23 @@ wgpu::TextureFormat WebGPUTexture::fToWGPUTextureFormat(TextureFormat const& fFo
 wgpu::TextureView WebGPUTexture::makeTextureView(const uint8_t& baseLevel,
        const uint8_t& levelCount, const uint32_t& baseArrayLayer, const uint32_t& arrayLayerCount,
        const SamplerType samplerType) const noexcept {
-    wgpu::TextureViewDescriptor textureViewDescriptor{
+#if FWGPU_ENABLED(FWGPU_DEBUG_VALIDATION)
+    if (baseLevel > 0 && !mSupportsMultipleMipLevels) {
+        FWGPU_LOGW << "Trying to make a texture view into a level ("
+                   << static_cast<uint32_t>(baseLevel)
+                   << ") for which we cannot generate mip levels." << utils::io::endl;
+    }
+#endif
+    const wgpu::TextureViewDescriptor textureViewDescriptor{
        .label = getUserTextureViewLabel(target),
-        .format = mCompatFormat,
+        .format = mViewFormat,
        .dimension = toWebGPUTextureViewDimension(samplerType),
        .baseMipLevel = baseLevel,
        .mipLevelCount = levelCount,
        .baseArrayLayer = baseArrayLayer,
        .arrayLayerCount = arrayLayerCount,
        .aspect = mAspect,
-        .usage = mWebGPUUsage };
-    textureViewDescriptor.usage &= (~wgpu::TextureUsage::StorageBinding);
+        .usage = mViewUsage };
    wgpu::TextureView textureView = mTexture.CreateView(&textureViewDescriptor);
    FILAMENT_CHECK_POSTCONDITION(textureView)
            << "Failed to create texture view " << textureViewDescriptor.label;
@@ -47,30 +47,46 @@ public:

    [[nodiscard]] wgpu::TextureView getOrMakeTextureView(uint8_t mipLevel, uint32_t arrayLayer);

-    [[nodiscard]] wgpu::TextureFormat getWebGPUFormat() const { return mWebGPUFormat; }
+    [[nodiscard]] wgpu::TextureFormat getViewFormat() const { return mViewFormat; }

    [[nodiscard]] uint32_t getArrayLayerCount() const { return mArrayLayerCount; }

+    [[nodiscard]] bool supportsMultipleMipLevels() const { return mSupportsMultipleMipLevels; }
+
    [[nodiscard]] static wgpu::TextureFormat fToWGPUTextureFormat(
            filament::backend::TextureFormat const& fFormat);

+    /**
+     * @param format a required texture format (can be a view to a different underlying texture
+     * format)
+     * @return true if multiple mip levels can be generated via a compute shader + storage binding
+     * on the texture, false otherwise.
+     */
+    [[nodiscard]] static bool supportsMultipleMipLevelsViaStorageBinding(
+            wgpu::TextureFormat format);
+
 private:
-    // CreateTextureR has info for a texture and sampler. Texture Views are needed for binding,
-    // along with a sampler Current plan: Inherit the sampler and Texture to always exist (It is a
-    // ref counted pointer) when making views. View is optional
-    wgpu::Texture mTexture = nullptr;
+    // the texture view's format, which may differ from the underlying texture's format itself,
+    // an example of when this is needed is when certain underlying shaders don't support
+    // certain formats (e.g. compute shaders), but we need a view to that format elsewhere
+    // (e.g. another shader or render target)
+    wgpu::TextureFormat mViewFormat = wgpu::TextureFormat::Undefined;
+    // this is true IFF levels > 1 AND we can actually generate mipmaps for the texture
+    bool mSupportsMultipleMipLevels = false;
    // format is inherited from HwTexture. This naming is to distinguish it from Filament's format
+    // this is the underlying texture's format, not necessarily the "view" of it... see mViewFormat
    wgpu::TextureFormat mWebGPUFormat = wgpu::TextureFormat::Undefined;
-    wgpu::TextureFormat mCompatFormat = wgpu::TextureFormat::Undefined;
    wgpu::TextureAspect mAspect = wgpu::TextureAspect::Undefined;
    // usage is inherited from HwTexture. This naming is to distinguish it from Filament's usage
    wgpu::TextureUsage mWebGPUUsage = wgpu::TextureUsage::None;
-    uint32_t mArrayLayerCount = 1;
+    wgpu::TextureUsage mViewUsage = wgpu::TextureUsage::None;
    size_t mBlockWidth = 0;
    size_t mBlockHeight = 0;
-    wgpu::TextureView mDefaultTextureView = nullptr;
+    uint32_t mArrayLayerCount = 1;
+    wgpu::Texture mTexture = nullptr;
    uint32_t mDefaultMipLevel = 0;
    uint32_t mDefaultBaseArrayLayer = 0;
+    wgpu::TextureView mDefaultTextureView = nullptr;

    [[nodiscard]] wgpu::TextureView makeTextureView(const uint8_t& baseLevel,
            const uint8_t& levelCount, const uint32_t& baseArrayLayer,
@@ -87,7 +87,6 @@ constexpr wgpu::Limits REQUIRED_LIMITS = {
    .maxBindingsPerBindGroup = filament::backend::MAX_DESCRIPTOR_COUNT,
    .maxSamplersPerShaderStage = 16, // TODO should be set to filament::backend::MAX_SAMPLER_COUNT,
    .maxStorageBuffersPerShaderStage = filament::backend::MAX_SSBO_COUNT,
-    .maxStorageTexturesPerShaderStage = 8,
    .maxVertexBuffers = 8, // TODO should be set to filament::backend::MAX_VERTEX_BUFFER_COUNT,
    .maxVertexAttributes = filament::backend::MAX_VERTEX_ATTRIBUTE_COUNT,
 };
@@ -250,18 +249,17 @@ void assertLimitsAreExpressedInRequirementsStruct() {
 void printInstanceDetails(wgpu::Instance const& instance) {
    wgpu::SupportedWGSLLanguageFeatures supportedWGSLLanguageFeatures{};
    if (!instance.GetWGSLLanguageFeatures(&supportedWGSLLanguageFeatures)) {
-        FWGPU_LOGW << "Failed to get WebGPU instance supported WGSL language features"
-                   << utils::io::endl;
+        FWGPU_LOGW << "Failed to get WebGPU instance supported WGSL language features";
    } else {
        FWGPU_LOGI << "WebGPU instance supported WGSL language features ("
-                   << supportedWGSLLanguageFeatures.featureCount << "):" << utils::io::endl;
+                   << supportedWGSLLanguageFeatures.featureCount << "):";
        if (supportedWGSLLanguageFeatures.featureCount > 0 &&
                supportedWGSLLanguageFeatures.features != nullptr) {
            std::for_each(supportedWGSLLanguageFeatures.features,
                    supportedWGSLLanguageFeatures.features +
                            supportedWGSLLanguageFeatures.featureCount,
                    [](wgpu::WGSLLanguageFeatureName const featureName) {
-                        FWGPU_LOGI << "  " << featureName << utils::io::endl;
+                        FWGPU_LOGI << "  " << featureName;
                    });
        }
    }
@@ -273,7 +271,7 @@ void printInstanceDetails(wgpu::Instance const& instance) {
    wgpu::DawnTogglesDescriptor dawnTogglesDescriptor{};
 #if defined(FILAMENT_WEBGPU_IMMEDIATE_ERROR_HANDLING)
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-    FWGPU_LOGI << "setting on toggle enable_immediate_error_handling" << utils::io::endl;
+    FWGPU_LOGI << "setting on toggle enable_immediate_error_handling";
 #endif
    /**
     * Have the un-captured error callback invoked immediately when an error occurs, rather than
@@ -317,7 +315,7 @@ void printLimit(std::string_view name, const std::variant<uint32_t, uint64_t> va
    if (undefined) {
        FWGPU_LOGI << "UNDEFINED";
    }
-    FWGPU_LOGI << utils::io::endl;
+    FWGPU_LOGI << "";
 }
 #endif// FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)

@@ -404,23 +402,23 @@ STREAM_TYPE& operator<<(STREAM_TYPE& out, AdapterDetails const& details) noexcep

 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
 void printAdapterDetails(AdapterDetails const& details) {
-    FWGPU_LOGI << "Selected WebGPU adapter info: " << details << utils::io::endl;
+    FWGPU_LOGI << "Selected WebGPU adapter info: " << details;
    wgpu::SupportedFeatures supportedFeatures{};
    details.adapter.GetFeatures(&supportedFeatures);
    FWGPU_LOGI << "WebGPU adapter supported features (" << supportedFeatures.featureCount
-               << "):" << utils::io::endl;
+               << "):";
    if (supportedFeatures.featureCount > 0 && supportedFeatures.features != nullptr) {
        std::for_each(supportedFeatures.features,
                supportedFeatures.features + supportedFeatures.featureCount,
                [](wgpu::FeatureName const featureName) {
-                    FWGPU_LOGI << "  " << featureName << utils::io::endl;
+                    FWGPU_LOGI << "  " << featureName;
                });
    }
    wgpu::Limits supportedLimits{};
    if (!details.adapter.GetLimits(&supportedLimits)) {
-        FWGPU_LOGW << "Failed to get WebGPU adapter supported limits" << utils::io::endl;
+        FWGPU_LOGW << "Failed to get WebGPU adapter supported limits";
    } else {
-        FWGPU_LOGI << "WebGPU adapter supported limits:" << utils::io::endl;
+        FWGPU_LOGI << "WebGPU adapter supported limits:";
        printLimits(supportedLimits);
    }
 }
@@ -447,14 +445,14 @@ struct AdapterDetailsHash final {
                })) {
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
        FWGPU_LOGI << "WebGPU adapter " << details
-                   << " does not have the minimum required features." << utils::io::endl;
-        FWGPU_LOGI << "  Missing required feature(s): ";
+                   << " does not have the minimum required features.";
+        FWGPU_LOGI << "Missing required feature(s): ";
        for (wgpu::FeatureName const& requiredFeature: REQUIRED_FEATURES) {
            if (!details.adapter.HasFeature(requiredFeature)) {
-                FWGPU_LOGI << requiredFeature << " ";
+                FWGPU_LOGI << requiredFeature;
            }
        }
-        FWGPU_LOGI << utils::io::endl;
+        FWGPU_LOGI << "";
 #endif
        return false;
    }
@@ -463,7 +461,7 @@ struct AdapterDetailsHash final {
            << "Failed to get limits for WebGPU adapter: " << details;
    if (!satisfiesLimits(supportedLimits)) {
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-        FWGPU_LOGI << " (for WebGPU adapter " << details << ")" << utils::io::endl;
+        FWGPU_LOGI << " (for WebGPU adapter " << details << ")";
 #endif
        return false;
    }
@@ -519,9 +517,9 @@ struct AdapterDetailsHash final {
    }
    FILAMENT_CHECK_POSTCONDITION(!compatibleAdapters.empty()) << "No WebGPU adapters found!";
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-    FWGPU_LOGI << compatibleAdapters.size() << " WebGPU adapter(s) found:" << utils::io::endl;
+    FWGPU_LOGI << compatibleAdapters.size() << " WebGPU adapter(s) found:";
    for (auto& details: compatibleAdapters) {
-        FWGPU_LOGI << "  WebGPU adapter: " << details << utils::io::endl;
+        FWGPU_LOGI << "  WebGPU adapter: " << details;
    }
 #endif
    return compatibleAdapters;
@@ -583,19 +581,19 @@ void printDeviceDetails(wgpu::Device const& device) {
    wgpu::SupportedFeatures supportedFeatures{};
    device.GetFeatures(&supportedFeatures);
    FWGPU_LOGI << "WebGPU device supported features (" << supportedFeatures.featureCount
-               << "):" << utils::io::endl;
+               << "):";
    if (supportedFeatures.featureCount > 0 && supportedFeatures.features != nullptr) {
        std::for_each(supportedFeatures.features,
                supportedFeatures.features + supportedFeatures.featureCount,
                [](wgpu::FeatureName const featureName) {
-                    FWGPU_LOGI << "  " << featureName << utils::io::endl;
+                    FWGPU_LOGI << "  " << featureName;
                });
    }
    wgpu::Limits supportedLimits{};
    if (!device.GetLimits(&supportedLimits)) {
-        FWGPU_LOGW << "Failed to get WebGPU supported device limits" << utils::io::endl;
+        FWGPU_LOGW << "Failed to get WebGPU supported device limits";
    } else {
-        FWGPU_LOGI << "WebGPU device supported limits:" << utils::io::endl;
+        FWGPU_LOGI << "WebGPU device supported limits:";
        printLimits(supportedLimits);
    }
 }
@@ -636,8 +634,7 @@ wgpu::Device WebGPUPlatform::requestDevice(wgpu::Adapter const& adapter) {
                    wgpu::StringView message) {
                if (reason == wgpu::DeviceLostReason::Destroyed) {
 #if FWGPU_ENABLED(FWGPU_DEBUG_VALIDATION)
-                    FWGPU_LOGD << "WebGPU device lost due to being destroyed (expected)"
-                               << utils::io::endl;
+                    FWGPU_LOGD << "WebGPU device lost due to being destroyed (expected)";
 #endif
                    return;
                }
@@ -649,7 +646,7 @@ wgpu::Device WebGPUPlatform::requestDevice(wgpu::Adapter const& adapter) {
    deviceDescriptor.SetUncapturedErrorCallback(
            [](wgpu::Device const&, wgpu::ErrorType errorType, wgpu::StringView message) {
                FWGPU_LOGE << "WebGPU device error: " << errorTypeToString(errorType) << " "
-                           << message.data << utils::io::endl;
+                           << message.data;
            });
    wgpu::Device device = nullptr;
    wgpu::WaitStatus status = mInstance.WaitAny(
@@ -702,8 +699,7 @@ Driver* WebGPUPlatform::createDriver(void* sharedContext,
        const Platform::DriverConfig& driverConfig) noexcept {
    if (sharedContext) {
        FWGPU_LOGW << "sharedContext is ignored/unused in the WebGPU backend. A non-null "
-                      "sharedContext was provided, but it will be ignored."
-                   << utils::io::endl;
+                      "sharedContext was provided, but it will be ignored.";
    }
    return WebGPUDriver::create(*this, driverConfig);
 }
@@ -84,6 +84,8 @@ std::string ScreenshotParams::expectedFilePath() const {
 }

 const std::string ScreenshotParams::filePrefix() const {
+    // TODO(b/422804941): If there are platform specific goldens, when on those platforms append a
+    //  unique platform identifying string to this.
    return mFileName;
 }

@@ -42,6 +42,7 @@ namespace test {
 */
 class ScreenshotParams {
 public:
+    // TODO(b/422804941): Add a set of environments where this test should use a different golden.
    ScreenshotParams(int width, int height, std::string fileName, uint32_t expectedPixelHash,
            bool isSrgb = false);

@@ -41,6 +41,8 @@ Shader::Shader(DriverApi& api, Cleanup& cleanup, ShaderConfig config) : mCleanup
        descriptors[kDescriptorSetIndex][i] = {
                config.uniforms[i].name, kLayouts[i], config.uniforms[i].samplerInfo };
    }
+    // TODO(b/422803382): When the shader language isn't GLSL dont' use the ShaderGenerator to
+    //  compile the shader.
    ShaderGenerator shaderGen(
            std::move(config.vertexShader), std::move(config.fragmentShader), BackendTest::sBackend,
            BackendTest::sIsMobilePlatform, std::move(descriptors));
@@ -31,7 +31,9 @@ struct UniformConfig {

 // All describing a shader that should be created.
 struct ShaderConfig {
+    filament::backend::ShaderLanguage vertexLanguage;
    std::string vertexShader;
+    filament::backend::ShaderLanguage fragmentLanguage;
    std::string fragmentShader;
    std::vector<UniformConfig> uniforms;
 };
@@ -215,18 +215,20 @@ Shader SharedShaders::makeShader(filament::backend::DriverApi& api, Cleanup& cle
    std::optional<ShaderText> fragment;
    std::optional<std::string> uniform;
    if (getShaderLanguage(BackendTest::sBackend) != ShaderLanguage::GLSL) {
-        // TODO: If any shaders need backend/shader language specific shaders rather than transpiled
-        // versions of the GLSL shader, check environment.
+        // TODO(b/422803382): If any shaders need backend/shader language specific shaders rather
+        //  than transpiled versions of the GLSL shader, check here and create a shader with that
+        //  config instead
    }
    vertex = GetGlslVertexShader(request.mVertexType);
    fragment = GetGlslFragmentShader(request.mFragmentType);
    uniform = GetGlslUniform(request.mUniformType);
    if (vertex.has_value() && fragment.has_value() && uniform.has_value()) {
-        return Shader(
-                api, cleanup, ShaderConfig{
-                        vertex->withUniform(*uniform), fragment->withUniform(*uniform),
-                        GetUniformConfig(request.mUniformType)}
-        );
+        return Shader(api, cleanup,
+                ShaderConfig{ .vertexLanguage = filament::backend::ShaderLanguage::ESSL3,
+                    .vertexShader = vertex->withUniform(*uniform),
+                    .fragmentLanguage = filament::backend::ShaderLanguage::ESSL3,
+                    .fragmentShader = fragment->withUniform(*uniform),
+                    .uniforms = GetUniformConfig(request.mUniformType) });
    }
    abort();
 }
@@ -25,7 +25,7 @@
 #include <backend/Handle.h>

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

 #include <fstream>
 #include <string>
@@ -137,8 +137,7 @@ TEST_F(BackendTest, FeedbackLoops) {
        // Create a RenderTarget for each miplevel.
        Handle<HwRenderTarget> renderTargets[kNumLevels];
        for (uint8_t level = 0; level < kNumLevels; level++) {
-            slog.i << "Level " << int(level) << ": " <<
-                    (kTexWidth >> level) << "x" << (kTexHeight >> level) << io::endl;
+            LOG(INFO) << "Level " << int(level) << ": " << (kTexWidth >> level) << "x" << (kTexHeight >> level);
            renderTargets[level] = cleanup.add(api.createRenderTarget( TargetBufferFlags::COLOR,
                    kTexWidth >> level, kTexHeight >> level, 1, 0, { texture, level, 0 }, {}, {}));
        }
@@ -139,30 +139,6 @@ TEST_F(ReadPixelsTest, ReadPixels) {
            return bufferDimension;
        }

-        void exportScreenshot(void* pixelData) const {
-#ifndef FILAMENT_IOS
-            const size_t width = readRect.width, height = readRect.height;
-            LinearImage image(width, height, 4);
-            if (format == PixelDataFormat::RGBA && type == PixelDataType::UBYTE) {
-                image = toLinearWithAlpha<uint8_t>(width, height, width * 4, (uint8_t*)pixelData);
-            }
-            if (format == PixelDataFormat::RGBA && type == PixelDataType::FLOAT) {
-                memcpy(image.getPixelRef(), pixelData, width * height * sizeof(math::float4));
-            }
-            std::string png = std::string(testName) + ".png";
-            std::ofstream outputStream(png.c_str(), std::ios::binary | std::ios::trunc);
-            ImageEncoder::encode(outputStream, ImageEncoder::Format::PNG, image, "",
-                    png.c_str());
-#endif
-        }
-
-        void exportRawBytes(void* pixelData) const {
-            std::string out = std::string(testName) + ".raw";
-            std::ofstream outputStream(out.c_str(), std::ios::binary | std::ios::trunc);
-            outputStream.write((char*)pixelData, getBufferSizeBytes());
-            outputStream.close();
-        }
-
        // The format and type for the readPixels call.
        PixelDataFormat format = PixelDataFormat::RGBA;
        PixelDataType type = PixelDataType::UBYTE;
@@ -335,9 +311,6 @@ TEST_F(ReadPixelsTest, ReadPixels) {
                    const auto* test = (const TestCase*)user;
                    assert_invariant(test);

-                    test->exportScreenshot(buffer);
-                    //test->exportRawBytes(buffer);
-
                    // Hash the contents of the buffer and check that they match.
                    uint32_t hash = utils::hash::murmur3((const uint32_t*)buffer, size / 4, 0);

@@ -22,10 +22,10 @@

 #include <private/utils/Tracing.h>

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

 #include <algorithm>
@@ -112,13 +112,11 @@ void FrameInfoManager::beginFrame(DriverApi& driver, Config const& config, uint3
        using namespace utils;
        auto h = getFrameInfoHistory(1);
        if (!h.empty()) {
-            slog.d << frameId << ": "
-                   << h[0].frameId << " (" << frameId - h[0].frameId << ")"
-                   << ", Dm=" << h[0].endFrame - h[0].beginFrame
-                   << ", L =" << h[0].backendBeginFrame - h[0].beginFrame
-                   << ", Db=" << h[0].backendEndFrame - h[0].backendBeginFrame
-                   << ", T =" << h[0].frameTime
-                   << io::endl;
+            DLOG(INFO) << frameId << ": " << h[0].frameId << " (" << frameId - h[0].frameId << ")"
+                       << ", Dm=" << h[0].endFrame - h[0].beginFrame
+                       << ", L =" << h[0].backendBeginFrame - h[0].beginFrame
+                       << ", Db=" << h[0].backendEndFrame - h[0].backendBeginFrame
+                       << ", T =" << h[0].frameTime;
        }
    }
 }
@@ -34,7 +34,7 @@

 #include <utils/BinaryTreeArray.h>
 #include <utils/JobSystem.h>
-#include <utils/Log.h>
+#include <utils/Logger.h>
 #include <utils/Slice.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
@@ -366,14 +366,12 @@ bool Froxelizer::update() noexcept {

        uniformsNeedUpdating = true;

-#ifndef NDEBUG
-        slog.d << "Froxel: " << viewport.width << "x" << viewport.height << " / "
-               << froxelDimension.x << "x" << froxelDimension.y << io::endl
-               << "Froxel: " << froxelCountX << "x" << froxelCountY << "x" << froxelCountZ
-               << " = " << (froxelCountX * froxelCountY * froxelCountZ)
-               << " (" << getFroxelBufferEntryCount() - froxelCountX * froxelCountY * froxelCountZ << " lost)"
-               << io::endl;
-#endif
+        DLOG(INFO) << "Froxel: " << viewport.width << "x" << viewport.height << " / "
+                   << froxelDimension.x << "x" << froxelDimension.y << io::endl
+                   << "Froxel: " << froxelCountX << "x" << froxelCountY << "x" << froxelCountZ
+                   << " = " << (froxelCountX * froxelCountY * froxelCountZ) << " ("
+                   << getFroxelBufferEntryCount() - froxelCountX * froxelCountY * froxelCountZ
+                   << " lost)";

        mFroxelCountX = froxelCountX;
        mFroxelCountY = froxelCountY;
@@ -712,9 +710,7 @@ void Froxelizer::froxelizeAssignRecordsCompress() noexcept {
        const size_t lightCount = entry.count();

        if (UTILS_UNLIKELY(offset + lightCount >= RECORD_BUFFER_ENTRY_COUNT)) {
-#ifndef NDEBUG
-            slog.d << "out of space: " << i << ", at " << offset << io::endl;
-#endif
+            DLOG(INFO) << "out of space: " << i << ", at " << offset;
            // note: instead of dropping froxels we could look for similar records we've already
            // filed up.
            do {
@@ -42,12 +42,12 @@

 #include <private/utils/Tracing.h>

-#include <utils/compiler.h>
-#include <utils/debug.h>
 #include <utils/JobSystem.h>
 #include <utils/Panic.h>
-#include <utils/Slice.h>
 #include <utils/Range.h>
+#include <utils/Slice.h>
+#include <utils/compiler.h>
+#include <utils/debug.h>

 #include <algorithm>
 #include <functional>
@@ -408,8 +408,8 @@ RenderPass::Command* RenderPass::instanceify(DriverApi& driver,
    }

    if (UTILS_UNLIKELY(firstSentinel)) {
-        //slog.d << "auto-instancing, saving " << drawCallsSavedCount << " draw calls, out of "
-        //       << count << io::endl;
+        // DLOG(INFO) << "auto-instancing, saving " << drawCallsSavedCount << " draw calls, out of "
+        //            << count;
        // we have instanced primitives
        // copy our instanced ubo data
        driver.updateBufferObjectUnsynchronized(mInstancedUboHandle, {
@@ -27,11 +27,11 @@

 #include "private/backend/DriverApi.h"

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

 #include <array>
@@ -291,17 +291,16 @@ void ResourceAllocator::gc(bool const skippedFrame) noexcept {
 UTILS_NOINLINE
 void ResourceAllocator::dump(bool const brief) const noexcept {
    constexpr float MiB = 1.0f / float(1u << 20u);
-    slog.d  << "# entries=" << mTextureCache.size()
-            << ", sz=" << (float)mCacheSize * MiB << " MiB"
-            << ", max=" << (float)mCacheSizeHiWaterMark * MiB << " MiB"
-            << io::endl;
+    DLOG(INFO) << "# entries=" << mTextureCache.size() << ", sz=" << (float) mCacheSize * MiB
+               << " MiB"
+               << ", max=" << (float) mCacheSizeHiWaterMark * MiB << " MiB";
    if (!brief) {
        for (auto const& it : mTextureCache) {
            auto w = it.first.width;
            auto h = it.first.height;
            auto f = FTexture::getFormatSize(it.first.format);
-            slog.d << it.first.name << ": w=" << w << ", h=" << h << ", f=" << f << ", sz="
-                   << (float)it.second.size * MiB << io::endl;
+            DLOG(INFO) << it.first.name << ": w=" << w << ", h=" << h << ", f=" << f
+                       << ", sz=" << (float) it.second.size * MiB;
        }
    }
 }
@@ -309,7 +308,7 @@ void ResourceAllocator::dump(bool const brief) const noexcept {
 ResourceAllocator::CacheContainer::iterator
 ResourceAllocator::purge(
        CacheContainer::iterator const& pos) {
-    //slog.d << "purging " << pos->second.handle.getId() << ", age=" << pos->second.age << io::endl;
+    // DLOG(INFO) << "purging " << pos->second.handle.getId() << ", age=" << pos->second.age;
    mBackend.destroyTexture(pos->second.handle);
    mCacheSize -= pos->second.size;
    return mTextureCache.erase(pos);
@@ -16,7 +16,7 @@

 #include "ResourceList.h"

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

 #include <algorithm>

@@ -32,7 +32,7 @@ ResourceListBase::ResourceListBase(const char* typeName)
 ResourceListBase::~ResourceListBase() noexcept {
 #ifndef NDEBUG
    if (!mList.empty()) {
-        utils::slog.d << "leaked " << mList.size() << " " << mTypeName << utils::io::endl;
+        DLOG(INFO) << "leaked " << mList.size() << " " << mTypeName;
    }
 #endif
 }
@@ -20,7 +20,7 @@
 #include "details/Camera.h"

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

 using namespace utils;
@@ -36,10 +36,7 @@ FCameraManager::~FCameraManager() noexcept = default;
 void FCameraManager::terminate(FEngine& engine) noexcept {
    auto& manager = mManager;
    if (!manager.empty()) {
-#ifndef NDEBUG
-        slog.d << "cleaning up " << manager.getComponentCount()
-               << " leaked Camera components" << io::endl;
-#endif
+        DLOG(INFO) << "cleaning up " << manager.getComponentCount() << " leaked Camera components";
        Slice<Entity> const entities{ manager.getEntities(), manager.getComponentCount() };
        for (Entity const e : entities) {
            destroy(engine, e);
@@ -23,9 +23,9 @@

 #include <filament/LightManager.h>

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

 #include <math/fast.h>
@@ -230,8 +230,7 @@ void FLightManager::terminate() noexcept {
    auto& manager = mManager;
    if (!manager.empty()) {
 #ifndef NDEBUG
-        slog.d << "cleaning up " << manager.getComponentCount()
-               << " leaked Light components" << io::endl;
+        DLOG(INFO) << "cleaning up " << manager.getComponentCount() << " leaked Light components";
 #endif
        while (!manager.empty()) {
            Instance const ci = manager.end() - 1;
@@ -39,14 +39,15 @@
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>

-#include <utils/compiler.h>
-#include <utils/debug.h>
 #include <utils/EntityManager.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/Log.h>
-#include <utils/ostream.h>
+#include <utils/Logger.h>
 #include <utils/Panic.h>
 #include <utils/Slice.h>
+#include <utils/compiler.h>
+#include <utils/debug.h>
+#include <utils/ostream.h>

 #include <math/mat4.h>
 #include <math/scalar.h>
@@ -396,10 +397,11 @@ void RenderableManager::BuilderDetails::processBoneIndicesAndWights(Engine& engi
                }
 #ifndef NDEBUG
                else {
-                    slog.w << "Warning of skinning: [entity=%" << entity.getId()
-                        << ", primitive @ %" << primitiveIndex
-                        << "] sum of bone weights of vertex=" << iVertex << " is " << boneWeightsSum
-                        << ", it should be one. Weights will be normalized." << io::endl;
+                    LOG(WARNING) << "Warning of skinning: [entity=%" << entity.getId()
+                                 << ", primitive @ %" << primitiveIndex
+                                 << "] sum of bone weights of vertex=" << iVertex << " is "
+                                 << boneWeightsSum
+                                 << ", it should be one. Weights will be normalized.";
                }
 #endif

@@ -498,9 +500,9 @@ RenderableManager::Builder::Result RenderableManager::Builder::build(Engine& eng
        AttributeBitset const declared = downcast(entry.vertices)->getDeclaredAttributes();
        AttributeBitset const required = material->getRequiredAttributes();
        if ((declared & required) != required) {
-            slog.w << "[entity=" << entity.getId() << ", primitive @ " << i
-                   << "] missing required attributes ("
-                   << required << "), declared=" << declared << io::endl;
+            LOG(WARNING) << "[entity=" << entity.getId() << ", primitive @ " << i
+                         << "] missing required attributes (" << required
+                         << "), declared=" << declared;
        }

        // we have at least one valid primitive
@@ -726,10 +728,8 @@ void FRenderableManager::destroy(Entity const e) noexcept {
 void FRenderableManager::terminate() noexcept {
    auto& manager = mManager;
    if (!manager.empty()) {
-#ifndef NDEBUG
-        slog.d << "cleaning up " << manager.getComponentCount()
-               << " leaked Renderable components" << io::endl;
-#endif
+        DLOG(INFO) << "cleaning up " << manager.getComponentCount()
+                   << " leaked Renderable components";
        while (!manager.empty()) {
            Instance const ci = manager.end() - 1;
            destroyComponent(ci);
@@ -811,9 +811,9 @@ void FRenderableManager::setMaterialInstanceAt(Instance const instance, uint8_t
            // emitting many invalid warnings as the `declared` bitset is not populated yet.
            bool const isPrimitiveInitialized = !!primitives[primitiveIndex].getHwHandle();
            if (UTILS_UNLIKELY(isPrimitiveInitialized && (declared & required) != required)) {
-                slog.w << "[instance=" << instance.asValue() << ", primitive @ " << primitiveIndex
-                       << "] missing required attributes ("
-                       << required << "), declared=" << declared << io::endl;
+                LOG(WARNING) << "[instance=" << instance.asValue() << ", primitive @ "
+                             << primitiveIndex << "] missing required attributes (" << required
+                             << "), declared=" << declared;
            }
        }
    }
@@ -868,7 +868,7 @@ FColorGrading::FColorGrading(FEngine& engine, const Builder& builder) {
    }

    //std::chrono::duration<float, std::milli> duration = std::chrono::steady_clock::now() - now;
-    //slog.d << "LUT generation time: " << duration.count() << " ms" << io::endl;
+    //DLOG(INFO) << "LUT generation time: " << duration.count() << " ms";

    if (converted) {
        free(data);
@@ -54,14 +54,14 @@

 #include <utils/Allocator.h>
 #include <utils/CallStack.h>
-#include <utils/compiler.h>
-#include <utils/debug.h>
 #include <utils/Invocable.h>
-#include <utils/Log.h>
-#include <utils/ostream.h>
+#include <utils/Logger.h>
 #include <utils/Panic.h>
 #include <utils/PrivateImplementation-impl.h>
 #include <utils/ThreadUtils.h>
+#include <utils/compiler.h>
+#include <utils/debug.h>
+#include <utils/ostream.h>

 #include <math/vec3.h>
 #include <math/vec4.h>
@@ -127,7 +127,7 @@ Engine* FEngine::create(Builder const& builder) {
            instance->mOwnPlatform = true;
        }
        if (platform == nullptr) {
-            slog.e << "Selected backend not supported in this build." << io::endl;
+            LOG(ERROR) << "Selected backend not supported in this build.";
            delete instance;
            return nullptr;
        }
@@ -280,8 +280,8 @@ FEngine::FEngine(Builder const& builder) :
    // (it may not be the case)
    mJobSystem.adopt();

-    slog.i << "FEngine (" << sizeof(void*) * 8 << " bits) created at " << this << " "
-           << "(threading is " << (UTILS_HAS_THREADING ? "enabled)" : "disabled)") << io::endl;
+    LOG(INFO) << "FEngine (" << sizeof(void*) * 8 << " bits) created at " << this << " "
+              << "(threading is " << (UTILS_HAS_THREADING ? "enabled)" : "disabled)");
 }

 uint32_t FEngine::getJobSystemThreadPoolSize(Config const& config) noexcept {
@@ -316,8 +316,8 @@ void FEngine::init() {
    assert_invariant(mActiveFeatureLevel > FeatureLevel::FEATURE_LEVEL_0);
 #endif

-    slog.i << "Backend feature level: " << int(driverApi.getFeatureLevel()) << io::endl;
-    slog.i << "FEngine feature level: " << int(mActiveFeatureLevel) << io::endl;
+    LOG(INFO) << "Backend feature level: " << int(driverApi.getFeatureLevel());
+    LOG(INFO) << "FEngine feature level: " << int(mActiveFeatureLevel);


    mResourceAllocatorDisposer = std::make_shared<ResourceAllocatorDisposer>(driverApi);
@@ -544,8 +544,7 @@ void FEngine::shutdown() {
    // print out some statistics about this run
    size_t const wm = mCommandBufferQueue.getHighWatermark();
    size_t const wmpct = wm / (getCommandBufferSize() / 100);
-    slog.d << "CircularBuffer: High watermark "
-           << wm / 1024 << " KiB (" << wmpct << "%)" << io::endl;
+    DLOG(INFO) << "CircularBuffer: High watermark " << wm / 1024 << " KiB (" << wmpct << "%)";
 #endif

    DriverApi& driver = getDriverApi();
@@ -740,9 +739,9 @@ int FEngine::loop() {
    if (mPlatform == nullptr) {
        mPlatform = PlatformFactory::create(&mBackend);
        mOwnPlatform = true;
-        slog.i << "FEngine resolved backend: " << to_string(mBackend) << io::endl;
+        LOG(INFO) << "FEngine resolved backend: " << to_string(mBackend);
        if (mPlatform == nullptr) {
-            slog.e << "Selected backend not supported in this build." << io::endl;
+            LOG(ERROR) << "Selected backend not supported in this build.";
            mDriverBarrier.latch();
            return 0;
        }
@@ -1042,8 +1041,8 @@ UTILS_NOINLINE
 void FEngine::cleanupResourceList(ResourceList<T>&& list) {
    if (UTILS_UNLIKELY(!list.empty())) {
 #ifndef NDEBUG
-        slog.d << "cleaning up " << list.size()
-               << " leaked " << CallStack::typeName<T>().c_str() << io::endl;
+        DLOG(INFO) << "cleaning up " << list.size() << " leaked "
+                   << CallStack::typeName<T>().c_str();
 #endif
        list.forEach([this, &allocator = mHeapAllocator](T* item) {
            item->terminate(*this);
@@ -1240,11 +1239,10 @@ bool FEngine::destroy(const FMaterialInstance* p) {
                            << ri.asValue() << ", index=" << j << ")";
                } else {
                    if (UTILS_UNLIKELY(mi == p)) {
-                        slog.e  << "destroying MaterialInstance \""
-                                << mi->getName() << "\" which is still in use by Renderable (entity="
-                                << entity.getId() << ", instance="
-                                << ri.asValue() << ", index=" << j << ")"
-                                << io::endl;
+                        LOG(ERROR) << "destroying MaterialInstance \"" << mi->getName()
+                                   << "\" which is still in use by Renderable (entity="
+                                   << entity.getId() << ", instance=" << ri.asValue()
+                                   << ", index=" << j << ")";
                    }
                }
            }
@@ -49,7 +49,7 @@
 #include <utils/FixedCapacityVector.h>
 #include <utils/Hash.h>
 #include <utils/Invocable.h>
-#include <utils/Log.h>
+#include <utils/Logger.h>
 #include <utils/Panic.h>
 #include <utils/bitset.h>
 #include <utils/compiler.h>
@@ -169,6 +169,16 @@ template Material::Builder& Material::Builder::constant<int32_t>(const char*, si
 template Material::Builder& Material::Builder::constant<float>(const char*, size_t, float);
 template Material::Builder& Material::Builder::constant<bool>(const char*, size_t, bool);

+
+const char* toString(ShaderModel model) {
+    switch (model) {
+        case ShaderModel::MOBILE:
+            return "mobile";
+        case ShaderModel::DESKTOP:
+            return "desktop";
+    }
+}
+
 Material* Material::Builder::build(Engine& engine) const {
    std::unique_ptr<MaterialParser> materialParser = createParser(
        downcast(engine).getBackend(), downcast(engine).getShaderLanguage(),
@@ -187,17 +197,11 @@ Material* Material::Builder::build(Engine& engine) const {
    if (!shaderModels.test(static_cast<uint32_t>(shaderModel))) {
        CString name;
        materialParser->getName(&name);
-        slog.e << "The material '" << name.c_str_safe() << "' was not built for ";
-        switch (shaderModel) {
-            case ShaderModel::MOBILE:
-                slog.e << "mobile.\n";
-                break;
-            case ShaderModel::DESKTOP:
-                slog.e << "desktop.\n";
-                break;
-        }
-        slog.e << "Compiled material contains shader models 0x"
-                << io::hex << shaderModels.getValue() << io::dec << "." << io::endl;
+        char shaderModelsString[16];
+        snprintf(shaderModelsString, sizeof(shaderModelsString), "%#x", shaderModels.getValue());
+        LOG(ERROR) << "The material '" << name.c_str_safe() << "' was not built for "
+                   << toString(shaderModel) << ".";
+        LOG(ERROR) << "Compiled material contains shader models " << shaderModelsString << ".";
        return nullptr;
    }

@@ -217,10 +221,10 @@ Material* Material::Builder::build(Engine& engine) const {
            if (materialStereoscopicType != engineStereoscopicType) {
                CString name;
                materialParser->getName(&name);
-                slog.w << "The stereoscopic type in the compiled material '" << name.c_str_safe()
-                        << "' is " << (int)materialStereoscopicType
-                        << ", which is not compatiable with the engine's setting "
-                        << (int)engineStereoscopicType << "." << io::endl;
+                LOG(WARNING) << "The stereoscopic type in the compiled material '"
+                             << name.c_str_safe() << "' is " << (int) materialStereoscopicType
+                             << ", which is not compatiable with the engine's setting "
+                             << (int) engineStereoscopicType << ".";
            }
        }
    }
@@ -378,9 +382,12 @@ void FMaterial::invalidate(Variant::type_t variantMask, Variant::type_t variantV
        !mHasCustomDepthShader) {
        // it would be unsafe to invalidate any of the cached depth variant
        if (UTILS_UNLIKELY(!((variantMask & Variant::DEP) && !(variantValue & Variant::DEP)))) {
-            slog.w << io::hex << "FMaterial::invalidate("
-                   << +variantMask << ", " << +variantValue
-                   << ") would corrupt the depth variant cache" << io::endl;
+            char variantMaskString[16];
+            snprintf(variantMaskString, sizeof(variantMaskString), "%#x", +variantMask);
+            char variantValueString[16];
+            snprintf(variantValueString, sizeof(variantValueString), "%#x", +variantValue);
+            LOG(WARNING) << "FMaterial::invalidate(" << variantMaskString << ", "
+                         << variantValueString << ") would corrupt the depth variant cache";
        }
        variantMask |= Variant::DEP;
        variantValue &= ~Variant::DEP;
@@ -406,8 +413,8 @@ void FMaterial::terminate(FEngine& engine) {
                    << pos->second.size() << " instances still alive.";
        } else {
            if (UTILS_UNLIKELY(!pos->second.empty())) {
-                slog.e << "destroying material \"" << this->getName().c_str_safe() << "\" but "
-                              << pos->second.size() << " instances still alive." << io::endl;
+                LOG(ERROR) << "destroying material \"" << this->getName().c_str_safe() << "\" but "
+                           << pos->second.size() << " instances still alive.";
            }
        }
    }
@@ -771,7 +778,7 @@ std::optional<uint32_t> FMaterial::getMutableConstantId(std::string_view name) c
 // source strings, so here we trigger a rebuild of the HwProgram objects.
 void FMaterial::applyPendingEdits() noexcept {
    const char* name = mName.c_str();
-    slog.d << "Applying edits to " << (name ? name : "(untitled)") << io::endl;
+    DLOG(INFO) << "Applying edits to " << (name ? name : "(untitled)");
    destroyPrograms(mEngine); // FIXME: this will not destroy the shared variants
    latchPendingEdits();
 }
@@ -35,12 +35,12 @@
 #include <backend/Handle.h>

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

 #include <math/scalar.h>

@@ -342,7 +342,7 @@ float FMaterialInstance::getSpecularAntiAliasingThreshold() const noexcept {

 void FMaterialInstance::setDoubleSided(bool const doubleSided) noexcept {
    if (UTILS_UNLIKELY(!mMaterial->hasDoubleSidedCapability())) {
-        slog.w << "Parent material does not have double-sided capability." << io::endl;
+        LOG(WARNING) << "Parent material does not have double-sided capability.";
        return;
    }
    setParameter("_doubleSided", doubleSided);
@@ -385,19 +385,18 @@ void FMaterialInstance::use(FEngine::DriverApi& driver) const {
    if (UTILS_UNLIKELY(mMissingSamplerDescriptors.any())) {
        std::call_once(mMissingSamplersFlag, [this] {
            auto const& list = mMaterial->getSamplerInterfaceBlock().getSamplerInfoList();
-            slog.w << "sampler parameters not set in MaterialInstance \""
-                   << mName.c_str_safe() << "\" or Material \""
-                   << mMaterial->getName().c_str_safe() << "\":\n";
+            LOG(WARNING) << "sampler parameters not set in MaterialInstance \""
+                         << mName.c_str_safe() << "\" or Material \""
+                         << mMaterial->getName().c_str_safe() << "\":";
            mMissingSamplerDescriptors.forEachSetBit([&list](descriptor_binding_t binding) {
                auto const pos = std::find_if(list.begin(), list.end(), [binding](const auto& item) {
                    return item.binding == binding;
                });
                // just safety-check, should never fail
                if (UTILS_LIKELY(pos != list.end())) {
-                    slog.w << "[" << +binding << "] " << pos->name.c_str() << '\n';
+                    LOG(WARNING) << "[" << +binding << "] " << pos->name.c_str();
                }
            });
-            flush(slog.w);
        });
        mMissingSamplerDescriptors.clear();
    }
@@ -52,12 +52,12 @@

 #include <private/utils/Tracing.h>

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

 #include <chrono>
 #include <limits>
@@ -155,14 +155,10 @@ FRenderer::FRenderer(FEngine& engine) :
 FRenderer::~FRenderer() noexcept {
    // There shouldn't be any resource left when we get here, but if there is, make sure
    // to free what we can (it would probably mean something when wrong).
-#ifndef NDEBUG
    size_t const wm = getCommandsHighWatermark();
    size_t const wmpct = wm / (mEngine.getPerFrameCommandsSize() / 100);
-    slog.d << "Renderer: Commands High watermark "
-    << wm / 1024 << " KiB (" << wmpct << "%), "
-    << wm / sizeof(Command) << " commands, " << sizeof(Command) << " bytes/command"
-    << io::endl;
-#endif
+    DLOG(INFO) << "Renderer: Commands High watermark " << wm / 1024 << " KiB (" << wmpct << "%), "
+               << wm / sizeof(Command) << " commands, " << sizeof(Command) << " bytes/command";
 }

 void FRenderer::terminate(FEngine& engine) {
@@ -463,10 +459,9 @@ void FRenderer::readPixels(FRenderTarget* renderTarget,

    // TODO: change the following to an assert when client call sites have addressed the issue.
    if (!renderTarget->supportsReadPixels()) {
-        slog.w << "readPixels() must be called with a renderTarget with COLOR0 created with "
-                         "TextureUsage::BLIT_SRC.  This precondition will be asserted in a later "
-                         "release of Filament."
-                      << io::endl;
+        LOG(WARNING) << "readPixels() must be called with a renderTarget with COLOR0 created with "
+                        "TextureUsage::BLIT_SRC. This precondition will be asserted in a later "
+                        "release of Filament.";
    }

    RendererUtils::readPixels(mEngine.getDriverApi(), renderTarget->getHwHandle(),
@@ -1481,7 +1476,9 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
    }
 #endif

-    //fg.export_graphviz(slog.d, view.getName());
+    //utils::io::sstream graphviz;
+    //fg.export_graphviz(graphviz, view.getName());
+    //DLOG(INFO) << graphviz.c_str();

    fg.execute(driver);

@@ -27,14 +27,14 @@
 #include <backend/DriverEnums.h>
 #include <backend/BufferDescriptor.h>

+#include <utils/CString.h>
+#include <utils/Logger.h>
+#include <utils/Panic.h>
+#include <utils/StaticString.h>
 #include <utils/bitset.h>
 #include <utils/compiler.h>
-#include <utils/CString.h>
-#include <utils/StaticString.h>
 #include <utils/debug.h>
-#include <utils/Log.h>
 #include <utils/ostream.h>
-#include <utils/Panic.h>

 #include <algorithm>
 #include <array>
@@ -120,8 +120,8 @@ VertexBuffer::Builder& VertexBuffer::Builder::attribute(VertexAttribute const at

        mImpl->mDeclaredAttributes.set(attribute);
    } else {
-        utils::slog.w << "Ignoring VertexBuffer attribute, the limit of " <<
-                MAX_VERTEX_ATTRIBUTE_COUNT << " attributes has been exceeded" << utils::io::endl;
+        LOG(WARNING) << "Ignoring VertexBuffer attribute, the limit of "
+                     << MAX_VERTEX_ATTRIBUTE_COUNT << " attributes has been exceeded";
    }
    return *this;
 }
@@ -25,12 +25,12 @@
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>

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

 #include <utility>
 #include <limits>
@@ -108,9 +108,8 @@ void DescriptorSet::commitSlow(DescriptorSetLayout const& layout,
    auto const unsetValidDescriptors = layout.getValidDescriptors() & ~mValid;
    if (UTILS_VERY_UNLIKELY(!unsetValidDescriptors.empty())) {
        unsetValidDescriptors.forEachSetBit([&](auto i) {
-            slog.w << (layout.isSampler(i) ? "Sampler" : "Buffer")
-                    << " descriptor " << i << " of " << mName.c_str() << " is not set. "
-                       "Please report this issue." << io::endl;
+            LOG(WARNING) << (layout.isSampler(i) ? "Sampler" : "Buffer") << " descriptor " << i
+                         << " of " << mName.c_str() << " is not set. Please report this issue.";
        });
    }
 }
@@ -131,9 +130,8 @@ void DescriptorSet::bind(FEngine::DriverApi& driver, DescriptorSetBindingPoints
    // assert_invariant(mDirty.none());
    if (UTILS_VERY_UNLIKELY(mDirty.any() && !mSetAfterCommitWarning)) {
        mDirty.forEachSetBit([&](uint8_t const binding) {
-            utils::slog.w << "Descriptor set (handle=" << mDescriptorSetHandle.getId()
-                          << ") binding=" << (int) binding
-                          << " was set between begin/endRenderPass" << utils::io::endl;
+            LOG(WARNING) << "Descriptor set (handle=" << mDescriptorSetHandle.getId()
+                         << ") binding=" << (int) binding << " was set between begin/endRenderPass";
        });
        mSetAfterCommitWarning = true;
    }
@@ -29,6 +29,8 @@

 #include "details/Texture.h"

+#include <utils/Logger.h>
+
 using namespace filament;
 using namespace backend;

@@ -76,7 +78,9 @@ protected:
    }

    void TearDown() override {
-        //fg.export_graphviz(utils::slog.d);
+        //utils::io::sstream graphviz;
+        //fg.export_graphviz(graphviz);
+        //DLOG(INFO) << graphviz.c_str();
    }

    Backend backend = Backend::NOOP;
@@ -107,7 +111,9 @@ TEST(DependencyGraphTest, Simple) {

    graph.cull();

-    //graph.export_graphviz(utils::slog.d);
+    //utils::io::sstream graphviz;
+    //graph.export_graphviz(graphviz);
+    //DLOG(INFO) << graphviz.c_str();

    EXPECT_FALSE(n2->isCulled());
    EXPECT_FALSE(n1->isCulled());
@@ -141,7 +147,9 @@ TEST(DependencyGraphTest, Culling1) {

    graph.cull();

-    //graph.export_graphviz(utils::slog.d);
+    //utils::io::sstream graphviz;
+    //graph.export_graphviz(graphviz);
+    //DLOG(INFO) << graphviz.c_str();

    EXPECT_TRUE(n1_0->isCulled());
    EXPECT_TRUE(n1_0->isCulledCalled());
@@ -182,7 +190,9 @@ TEST(DependencyGraphTest, Culling2) {

    graph.cull();

-    //graph.export_graphviz(utils::slog.d);
+    //utils::io::sstream graphviz;
+    //graph.export_graphviz(graphviz);
+    //DLOG(INFO) << graphviz.c_str();

    EXPECT_TRUE(n1_0->isCulled());
    EXPECT_TRUE(n1_0_0->isCulled());
@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
  spec.name = "Filament"
-  spec.version = "1.61.0"
+  spec.version = "1.61.1"
  spec.license = { :type => "Apache 2.0", :file => "LICENSE" }
  spec.homepage = "https://google.github.io/filament"
  spec.authors = "Google LLC."
  spec.summary = "Filament is a real-time physically based rendering engine for Android, iOS, Windows, Linux, macOS, and WASM/WebGL."
  spec.platform = :ios, "11.0"
-  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.61.0/filament-v1.61.0-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.61.1/filament-v1.61.1-ios.tgz" }

  # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
  spec.pod_target_xcconfig = {
@@ -88,7 +88,7 @@ from scratch.

 ## XcodeGen

-[XcodeGen](https://github.com/yonaskolb/XcodeGen) version 2.29.0 is used to generate the Xcode
+[XcodeGen](https://github.com/yonaskolb/XcodeGen) version 2.43.0 is used to generate the Xcode
 projects. While not required to run the samples, XcodeGen makes modifying them easier. Each sample
 folder contains the `project.yml` file used for the sample, which includes a global
 `app-template.yml` file. Simply run
@@ -20,7 +20,8 @@ targetTemplates:
        settings:
            base:
                OTHER_LDFLAGS: ["-lfilament", "-lbackend", "-lfilaflat", "-lktxreader",
-                                "-lfilabridge", "-lutils", "-lsmol-v", "-lgeometry", "-libl"]
+                                "-lfilabridge", "-lutils", "-lsmol-v", "-lgeometry", "-libl",
+                                "-labseil"]
                ENABLE_BITCODE: NO
                CLANG_CXX_LANGUAGE_STANDARD: gnu++17
                # This allows users to not have to specify a unique bundle ID when building the sample apps.
@@ -3,7 +3,7 @@
 	archiveVersion = 1;
 	classes = {
 	};
-	objectVersion = 51;
+	objectVersion = 54;
 	objects = {

 /* Begin PBXBuildFile section */
@@ -81,6 +81,8 @@
 			dependencies = (
 			);
 			name = "backend-test";
+			packageProductDependencies = (
+			);
 			productName = "backend-test";
 			productReference = 13DDE7723EC1A6EFCA4D2D58 /* backend-test.app */;
 			productType = "com.apple.product-type.application";
@@ -91,12 +93,13 @@
 		8A7A83D59A7827D3335343C2 /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
-				LastUpgradeCheck = 1200;
+				BuildIndependentTargetsInParallel = YES;
+				LastUpgradeCheck = 1430;
 				TargetAttributes = {
 				};
 			};
 			buildConfigurationList = E89E1EEA671E49DBAC9D5A9C /* Build configuration list for PBXProject "backend-test" */;
-			compatibilityVersion = "Xcode 11.0";
+			compatibilityVersion = "Xcode 14.0";
 			developmentRegion = en;
 			hasScannedForEncodings = 0;
 			knownRegions = (
@@ -104,6 +107,8 @@
 				en,
 			);
 			mainGroup = 3D2B936C924E0DB70941EE6D;
+			minimizedProjectReferenceProxies = 1;
+			preferredProjectObjectVersion = 54;
 			projectDirPath = "";
 			projectRoot = "";
 			targets = (
@@ -249,6 +254,7 @@
 					"-lsmol-v",
 					"-lgeometry",
 					"-libl",
+					"-labseil",
 					"-lfilamat",
 					"-force_load ../../../out/ios-debug/filament/lib/arm64/libbackend_test.a",
 				);
@@ -356,6 +362,7 @@
 					"-lsmol-v",
 					"-lgeometry",
 					"-libl",
+					"-labseil",
 					"-lfilamat",
 					"-force_load ../../../out/ios-debug/filament/lib/arm64/libbackend_test.a",
 				);
@@ -456,6 +463,7 @@
 					"-lsmol-v",
 					"-lgeometry",
 					"-libl",
+					"-labseil",
 					"-lfilamat",
 					"-force_load ../../../out/ios-debug/filament/lib/arm64/libbackend_test.a",
 				);
@@ -501,6 +509,7 @@
 					"-lsmol-v",
 					"-lgeometry",
 					"-libl",
+					"-labseil",
 					"-lfilamat",
 					"-force_load ../../../out/ios-debug/filament/lib/arm64/libbackend_test.a",
 				);
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "1200"
+   LastUpgradeVersion = "1430"
   version = "1.7">
   <BuildAction
      parallelizeBuildables = "YES"
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Powei Feng	f1a4c174c7	vk: update vulkan memory allocator lib	2025-06-12 15:23:38 -07:00
Andy Hovingh	6406d4602c	webgpu: texture changes to better support mipmap generation later	2025-06-11 22:35:42 -05:00
Sungun Park	880cd66166	Release Filament 1.61.1	2025-06-12 00:31:33 +00:00
Juan Caldas	f27ff203cf	webgpu: Enable multisampling in the sample (#8854 )	2025-06-11 23:09:59 +00:00
Ben Doherty	3ea8e529cc	Switch filament and backend to Abseil logging (#8691 )	2025-06-11 10:08:52 -07:00
Jeremy Nelson	572dd233d7	adding check for Stencil8	2025-06-10 20:06:00 -07:00
Jeremy Nelson	c19070e477	better default cases for loadOp and storeOp	2025-06-10 20:06:00 -07:00
Jeremy Nelson	64328b7388	pass through defaultDepthStencilFormat	2025-06-10 20:06:00 -07:00
Powei Feng	1414fdcd38	github: fix commit message action (#8846 ) Checkout sha instead of the branch	2025-06-10 22:55:48 +00:00
Matthew Hoffman	e607a035ae	Add TODOs for backend test features that shouldn't be made yet. (#8829 ) Some edge case handling features are possibly needed, but should only be made once they have use cases that exercise that behavior. So for now just leave TODOs explaining where to add it in the future. BUGS=[422804941,422803382]	2025-06-10 21:43:47 +00:00
Ben Doherty	0496e089c1	Remove old screenshot output for readPixels backend test (#8840 )	2025-06-10 13:30:00 -07:00