Fixup shader code

Reduce the number of prepared mipmap pipelines- this should be configurable really if we want to preserve this logic in the long run.
Add check for if the format (Or non srgb format) is storage compatible
2025-06-10 18:04:41 -04:00 · 2025-06-10 16:54:28 -04:00 · 2025-06-10 16:54:03 -04:00 · 2025-06-10 16:18:17 -04:00 · 2025-06-10 15:58:02 -04:00 · 2025-06-10 15:57:48 -04:00
145 changed files with 22094 additions and 22475 deletions
@@ -17,17 +17,15 @@ runs:
        echo "Date: ${TSTAMP}" >> /tmp/commit_msg.txt
        echo "" >> /tmp/commit_msg.txt
        echo "${{ github.event.head_commit.message }}" >> /tmp/commit_msg.txt
-    - name: Find commit message (PR)
+    - name: Checkout code
      shell: bash
      id: checkout_code
      if: github.event_name == 'pull_request'
      run: |
-        echo "+++++ head commit message +++++"
-        echo "$(git log -1 --no-merges)"
-        echo "+++++++++++++++++++++++++++++++"
        echo "hash=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
-        git checkout ${{ github.event.pull_request.head.sha }}
-        echo "$(git log -1 --no-merges)" >> /tmp/commit_msg.txt
+        git checkout ${{ github.event.pull_request.head.ref }}
+        COMMIT_MESSAGE=$(git log -1)
+        echo "$(git log -1)" >> /tmp/commit_msg.txt
    - shell: bash
      id: action_output
      run: |
@@ -38,8 +36,8 @@ runs:
        echo "----- got commit message ---"
        cat /tmp/commit_msg.txt
        echo "----------------------------"
-    - name: Cleanup Find commit message (PR)
+    - name: Uncheckout code
      shell: bash
      if: github.event_name == 'pull_request'
      run: |
-        git checkout ${{ steps.checkout_code.outputs.hash }}
+        git checkout ${{ steps.checkout_code.outputs.hash }}
@@ -122,6 +122,9 @@ 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,8 +49,6 @@ option(FILAMENT_SUPPORTS_OSMESA "Enable OSMesa (headless GL context) for Filamen

 option(FILAMENT_ENABLE_FGVIEWER "Enable the frame graph viewer" OFF)

-option(FILAMENT_USE_ABSEIL_LOGGING "Use Abseil to log, may increase binary size" OFF)
-
 # This is to disable GTAO for the short-term while we investigate a way to better manage size increases.
 # On the regular filament build (where size is of less concern), we enable GTAO by default.
 option(FILAMENT_DISABLE_GTAO "Disable GTAO" OFF)
@@ -593,10 +591,6 @@ if (CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT FILAMENT_BACKEND_DEBUG_FLAG STREQU
    unset(FILAMENT_BACKEND_DEBUG_FLAG)
 endif()

-if (FILAMENT_USE_ABSEIL_LOGGING)
-    add_definitions(-DFILAMENT_USE_ABSEIL_LOGGING)
-endif()
-
 # ==================================================================================================
 # Material compilation flags
 # ==================================================================================================
@@ -7,3 +7,7 @@ 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.1'
+    implementation 'com.google.android.filament:filament-android:1.61.0'
 }
 ```

@@ -51,7 +51,7 @@ Here are all the libraries available in the group `com.google.android.filament`:
 iOS projects can use CocoaPods to install the latest release:

 ```shell
-pod 'Filament', '~> 1.61.1'
+pod 'Filament', '~> 1.61.0'
 ```

 ## Documentation
@@ -7,12 +7,6 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).

-## v1.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,10 +59,6 @@ add_library(smol-v STATIC IMPORTED)
 set_target_properties(smol-v PROPERTIES IMPORTED_LOCATION
        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libsmol-v.a)

-add_library(abseil STATIC IMPORTED)
-set_target_properties(abseil PROPERTIES IMPORTED_LOCATION
-        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libabseil.a)
-
 if (FILAMENT_ENABLE_FGVIEWER)
    add_library(fgviewer STATIC IMPORTED)
    set_target_properties(fgviewer PROPERTIES IMPORTED_LOCATION
@@ -132,7 +128,6 @@ target_link_libraries(filament-jni
    PRIVATE jnigraphics
    PRIVATE utils
    PRIVATE perfetto
-    PRIVATE abseil

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

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

@@ -601,10 +601,6 @@ target_link_libraries(${TARGET} PUBLIC filaflat)
 target_link_libraries(${TARGET} PUBLIC filabridge)
 target_link_libraries(${TARGET} PUBLIC ibl-lite)

-if (FILAMENT_USE_ABSEIL_LOGGING)
-    target_link_libraries(${TARGET} PUBLIC absl::log)
-endif()
-
 if (FILAMENT_ENABLE_FGVIEWER)
    target_link_libraries(${TARGET} PUBLIC fgviewer)
    add_definitions(-DFILAMENT_ENABLE_FGVIEWER=1)
@@ -92,7 +92,7 @@ Copy your platform's Makefile below into a `Makefile` inside the same directory.
 ### Linux

 ```make
-FILAMENT_LIBS=-lfilament -lbackend -lbluegl -lbluevk -lfilabridge -lfilaflat -lutils -lgeometry -lsmol-v -lvkshaders -libl -labseil
+FILAMENT_LIBS=-lfilament -lbackend -lbluegl -lbluevk -lfilabridge -lfilaflat -lutils -lgeometry -lsmol-v -lvkshaders -libl
 CC=clang++

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

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

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

 main.o: main.cpp
 	$(CC) -Iinclude/ -std=c++17 -c main.cpp
@@ -140,7 +139,7 @@ used to change the run-time library version.

 ```make
 FILAMENT_LIBS=filament.lib backend.lib bluegl.lib bluevk.lib filabridge.lib filaflat.lib \
-              utils.lib geometry.lib smol-v.lib ibl.lib vkshaders.lib abseil.lib
+              utils.lib geometry.lib smol-v.lib ibl.lib vkshaders.lib
 CC=cl.exe

 main.exe: main.obj
@@ -286,6 +286,7 @@ 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)
@@ -403,10 +404,6 @@ endif()
 target_link_libraries(${TARGET} PUBLIC math)
 target_link_libraries(${TARGET} PUBLIC utils)

-if (FILAMENT_USE_ABSEIL_LOGGING)
-    target_link_libraries(${TARGET} PRIVATE absl::log)
-endif()
-
 # Android, iOS, and WebGL do not use bluegl.
 if(FILAMENT_SUPPORTS_OPENGL AND NOT IOS AND NOT ANDROID AND NOT WEBGL)
    target_link_libraries(${TARGET} PRIVATE bluegl)
@@ -128,7 +128,7 @@ protected:
    bool setExternalImage(ExternalImageHandleRef externalImage, ExternalTexture* texture) noexcept override;

    /**
-     * Logs glGetError() to LOG(ERROR)
+     * Logs glGetError() to slog.e
     * @param name a string giving some context on the error. Typically __func__.
     */
    static void logEglError(const char* name) noexcept;
@@ -39,7 +39,7 @@
 #define FILAMENT_DEBUG_COMMANDS_NONE         0x0
 // Command debugging enabled. No logging by default.
 #define FILAMENT_DEBUG_COMMANDS_ENABLE       0x1
-// Command debugging enabled. Every command logged to DLOG(INFO)
+// Command debugging enabled. Every command logged to slog.d
 #define FILAMENT_DEBUG_COMMANDS_LOG          0x2
 // Command debugging enabled. Every command logged to systrace
 #define FILAMENT_DEBUG_COMMANDS_SYSTRACE     0x4
@@ -16,7 +16,7 @@

 #include "private/backend/CircularBuffer.h"

-#include <utils/Logger.h>
+#include <utils/Log.h>
 #include <utils/Panic.h>
 #include <utils/architecture.h>
 #include <utils/ashmem.h>
@@ -127,7 +127,7 @@ void* CircularBuffer::alloc(size_t size) {
                "couldn't allocate " << (size * 2 / 1024) <<
                " KiB of virtual address space for the command buffer";

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

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

 #include <private/utils/Tracing.h>

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

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

 #ifndef NDEBUG
        size_t const totalUsed = circularBuffer.size() - mFreeSpace;
-        DLOG(INFO) << "CommandStream used too much space (will block): "
-                   << "needed space " << requiredSize << " out of " << mFreeSpace
-                   << ", totalUsed=" << totalUsed << ", current=" << used
-                   << ", queue size=" << mCommandBuffersToExecute.size() << " buffers";
+        slog.d << "CommandStream used too much space (will block): "
+                << "needed space " << requiredSize << " out of " << mFreeSpace
+                << ", totalUsed=" << totalUsed << ", current=" << used
+                << ", queue size=" << mCommandBuffersToExecute.size() << " buffers"
+                << io::endl;

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

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

 #include <cstddef>
 #include <functional>
@@ -132,10 +129,9 @@ void CommandType<void (Driver::*)(ARGS...)>::Command<METHOD>::log(std::index_seq
 #if DEBUG_COMMAND_STREAM
    static_assert(UTILS_HAS_RTTI, "DEBUG_COMMAND_STREAM can only be used with RTTI");
    std::string command = utils::CallStack::demangleTypeName(typeid(Command).name()).c_str();
-    DLOG(INFO) << extractMethodName(command) << " : size=" << sizeof(Command);
-    utils::io::sstream parameterPack;
-    printParameterPack(parameterPack, std::get<I>(mArgs)...);
-    DLOG(INFO) << "\t" << parameterPack.c_str();
+    slog.d << extractMethodName(command) << " : size=" << sizeof(Command) << "\n\t";
+    printParameterPack(slog.d, std::get<I>(mArgs)...);
+    slog.d << io::endl;
 #endif
 }

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

 #include <utils/Allocator.h>
 #include <utils/CString.h>
-#include <utils/Logger.h>
+#include <utils/Log.h>
 #include <utils/Panic.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
@@ -57,8 +57,8 @@ HandleAllocator<P0, P1, P2>::Allocator::Allocator(AreaPolicy::HeapArea const& ar
    size_t const maxHeapSize = std::min(area.size(), HANDLE_INDEX_MASK * getAlignment());

    if (UTILS_UNLIKELY(maxHeapSize != area.size())) {
-        LOG(WARNING) << "HandleAllocator heap size reduced to " << maxHeapSize << " from "
-                     << area.size();
+        slog.w << "HandleAllocator heap size reduced to "
+               << maxHeapSize << " from " << area.size() << io::endl;
    }

    // make sure we start with a clean arena. This is needed to ensure that all blocks start
@@ -19,8 +19,8 @@
 #include "MetalContext.h"
 #include "MetalUtils.h"

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

 namespace filament::backend {

@@ -323,7 +323,7 @@ id<MTLFunction> MetalBlitter::compileFragmentFunction(BlitFunctionKey key) const
    if (!library || !function) {
        if (error) {
            auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
-            LOG(ERROR) << description;
+            utils::slog.e << description << utils::io::endl;
        }
    }
    FILAMENT_CHECK_POSTCONDITION(library && function)
@@ -349,7 +349,7 @@ id<MTLFunction> MetalBlitter::getBlitVertexFunction() {
    if (!library || !function) {
        if (error) {
            auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
-            LOG(ERROR) << description;
+            utils::slog.e << description << utils::io::endl;
        }
    }
    FILAMENT_CHECK_POSTCONDITION(library && function)
@@ -18,8 +18,8 @@

 #include "MetalContext.h"

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

 #include <thread>
@@ -77,7 +77,8 @@ void MetalBufferPool::releaseBuffer(MetalBufferPoolEntry const *stage) noexcept

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

 #include "MetalHandles.h"

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

 #include <utility>

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

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

 #include <algorithm>

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

-    DLOG(INFO) << "MetalSwapChain: " << sizeof(MetalSwapChain);
-    DLOG(INFO) << "MetalBufferObject: " << sizeof(MetalBufferObject);
-    DLOG(INFO) << "MetalVertexBuffer: " << sizeof(MetalVertexBuffer);
-    DLOG(INFO) << "MetalVertexBufferInfo: " << sizeof(MetalVertexBufferInfo);
-    DLOG(INFO) << "MetalIndexBuffer: " << sizeof(MetalIndexBuffer);
-    DLOG(INFO) << "MetalRenderPrimitive: " << sizeof(MetalRenderPrimitive);
-    DLOG(INFO) << "MetalTexture: " << sizeof(MetalTexture);
-    DLOG(INFO) << "MetalTimerQuery: " << sizeof(MetalTimerQuery);
-    DLOG(INFO) << "HwStream: " << sizeof(HwStream);
-    DLOG(INFO) << "MetalRenderTarget: " << sizeof(MetalRenderTarget);
-    DLOG(INFO) << "MetalFence: " << sizeof(MetalFence);
-    DLOG(INFO) << "MetalProgram: " << sizeof(MetalProgram);
+    utils::slog.d
+           << "\nMetalSwapChain: " << sizeof(MetalSwapChain)
+           << "\nMetalBufferObject: " << sizeof(MetalBufferObject)
+           << "\nMetalVertexBuffer: " << sizeof(MetalVertexBuffer)
+           << "\nMetalVertexBufferInfo: " << sizeof(MetalVertexBufferInfo)
+           << "\nMetalIndexBuffer: " << sizeof(MetalIndexBuffer)
+           << "\nMetalRenderPrimitive: " << sizeof(MetalRenderPrimitive)
+           << "\nMetalTexture: " << sizeof(MetalTexture)
+           << "\nMetalTimerQuery: " << sizeof(MetalTimerQuery)
+           << "\nHwStream: " << sizeof(HwStream)
+           << "\nMetalRenderTarget: " << sizeof(MetalRenderTarget)
+           << "\nMetalFence: " << sizeof(MetalFence)
+           << "\nMetalProgram: " << sizeof(MetalProgram)
+           << utils::io::endl;
 #endif
    return MetalDriver::create(platform, driverConfig);
 }
@@ -133,18 +135,19 @@ MetalDriver::MetalDriver(

    initializeSupportedGpuFamilies(mContext);

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

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

@@ -20,14 +20,14 @@
 #include "MetalEnums.h"
 #include "MetalUtils.h"

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

 #define NSERROR_CHECK(message)                                                                     \
    if (error) {                                                                                   \
        auto description = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding]; \
-        LOG(ERROR) << description;                                                                 \
+        utils::slog.e << description << utils::io::endl;                                           \
    }                                                                                              \
    FILAMENT_CHECK_POSTCONDITION(error == nil) << message;

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

 #include "private/backend/BackendUtils.h"

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

 #include <math/scalar.h>

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

    if (!(flags & SwapChain::CONFIG_TRANSPARENT) && !nativeWindow.opaque) {
-        LOG(WARNING) << "Warning: Filament SwapChain has no CONFIG_TRANSPARENT flag, but the "
-                        "CAMetaLayer("
-                     << (__bridge void*) nativeWindow << ") has .opaque set to NO.";
+        utils::slog.w << "Warning: Filament SwapChain has no CONFIG_TRANSPARENT flag, "
+                         "but the CAMetaLayer(" << (__bridge void*) nativeWindow << ")"
+                         " has .opaque set to NO." << utils::io::endl;
    }
    if ((flags & SwapChain::CONFIG_TRANSPARENT) && nativeWindow.opaque) {
-        LOG(WARNING) << "Warning: Filament SwapChain has the CONFIG_TRANSPARENT flag, but the "
-                        "CAMetaLayer("
-                     << (__bridge void*) nativeWindow << ") has .opaque set to YES.";
+        utils::slog.w << "Warning: Filament SwapChain has the CONFIG_TRANSPARENT flag, "
+                         "but the CAMetaLayer(" << (__bridge void*) nativeWindow << ")"
+                         " has .opaque set to YES." << utils::io::endl;
    }

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

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

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

 #include "MetalEnums.h"

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

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

 #include "MetalDriverFactory.h"

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

 #import <Foundation/Foundation.h>

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

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

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

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

 #include "private/backend/Driver.h"

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

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

 namespace filament::backend {

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

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

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

 UTILS_NOINLINE
-GLenum checkFramebufferStatus(GLenum target, const char* function, size_t line) noexcept {
+GLenum checkFramebufferStatus(io::ostream& out, GLenum target, const char* function, size_t line) noexcept {
    GLenum const status = glCheckFramebufferStatus(target);
    if (UTILS_VERY_UNLIKELY(status != GL_FRAMEBUFFER_COMPLETE)) {
        auto const string = getFramebufferStatusString(status);
-        char hexStatus[16];
-        snprintf(hexStatus, sizeof(hexStatus), "%#x", status);
-        LOG(ERROR) << "OpenGL framebuffer error " << hexStatus << " (" << string << ") in \""
-                   << function << "\" at line " << line;
+        out << "OpenGL framebuffer error " << io::hex << status << " (" << string << ") in \""
+            << function << "\" at line " << io::dec << line << io::endl;
    }
    return status;
 }

 UTILS_NOINLINE
-void assertFramebufferStatus(GLenum target, const char* function, size_t line) noexcept {
-    GLenum const status = checkFramebufferStatus(target, function, line);
+void assertFramebufferStatus(io::ostream& out, GLenum target, const char* function, size_t line) noexcept {
+    GLenum const status = checkFramebufferStatus(out, target, function, line);
    if (UTILS_VERY_UNLIKELY(status != GL_FRAMEBUFFER_COMPLETE)) {
        debug_trap();
    }
@@ -33,21 +33,21 @@
 namespace filament::backend::GLUtils {

 std::string_view getGLErrorString(GLenum error) noexcept;
-GLenum checkGLError(const char* function, size_t line) noexcept;
-void assertGLError(const char* function, size_t line) noexcept;
+GLenum checkGLError(utils::io::ostream& out, const char* function, size_t line) noexcept;
+void assertGLError(utils::io::ostream& out, const char* function, size_t line) noexcept;

 std::string_view getFramebufferStatusString(GLenum err) noexcept;
-GLenum checkFramebufferStatus(GLenum target, const char* function, size_t line) noexcept;
-void assertFramebufferStatus(GLenum target, const char* function, size_t line) noexcept;
+GLenum checkFramebufferStatus(utils::io::ostream& out, GLenum target, const char* function, size_t line) noexcept;
+void assertFramebufferStatus(utils::io::ostream& out, GLenum target, const char* function, size_t line) noexcept;

 #ifdef NDEBUG
-#   define CHECK_GL_ERROR()
-#   define CHECK_GL_ERROR_NON_FATAL()
-#   define CHECK_GL_FRAMEBUFFER_STATUS(target)
+#   define CHECK_GL_ERROR(out)
+#   define CHECK_GL_ERROR_NON_FATAL(out)
+#   define CHECK_GL_FRAMEBUFFER_STATUS(out, target)
 #else
-#   define CHECK_GL_ERROR() { GLUtils::assertGLError(__func__, __LINE__); }
-#   define CHECK_GL_ERROR_NON_FATAL() { GLUtils::checkGLError(__func__, __LINE__); }
-#   define CHECK_GL_FRAMEBUFFER_STATUS(target) { GLUtils::checkFramebufferStatus( target, __func__, __LINE__); }
+#   define CHECK_GL_ERROR(out) { GLUtils::assertGLError(out, __func__, __LINE__); }
+#   define CHECK_GL_ERROR_NON_FATAL(out) { GLUtils::checkGLError(out, __func__, __LINE__); }
+#   define CHECK_GL_FRAMEBUFFER_STATUS(out, target) { GLUtils::checkFramebufferStatus(out, target, __func__, __LINE__); }
 #endif

 constexpr GLuint getComponentCount(ElementType const type) noexcept {
@@ -22,9 +22,9 @@
 #include <backend/platforms/OpenGLPlatform.h>
 #include <backend/DriverEnums.h>

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

 #include <functional>
@@ -77,8 +77,8 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
    state.version  = (char const*)glGetString(GL_VERSION);
    state.shader   = (char const*)glGetString(GL_SHADING_LANGUAGE_VERSION);

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

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

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

 #ifndef NDEBUG
    // this is useful for development
-    LOG(INFO) << "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = " << gets.max_anisotropy;
-    LOG(INFO) << "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = " << gets.max_combined_texture_image_units;
-    LOG(INFO) << "GL_MAX_TEXTURE_SIZE = " << gets.max_texture_size;
-    LOG(INFO) << "GL_MAX_CUBE_MAP_TEXTURE_SIZE = " << gets.max_cubemap_texture_size;
-    LOG(INFO) << "GL_MAX_3D_TEXTURE_SIZE = " << gets.max_3d_texture_size;
-    LOG(INFO) << "GL_MAX_ARRAY_TEXTURE_LAYERS = " << gets.max_array_texture_layers;
-    LOG(INFO) << "GL_MAX_DRAW_BUFFERS = " << gets.max_draw_buffers;
-    LOG(INFO) << "GL_MAX_RENDERBUFFER_SIZE = " << gets.max_renderbuffer_size;
-    LOG(INFO) << "GL_MAX_SAMPLES = " << gets.max_samples;
-    LOG(INFO) << "GL_MAX_TEXTURE_IMAGE_UNITS = " << gets.max_texture_image_units;
-    LOG(INFO) << "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = "
-              << gets.max_transform_feedback_separate_attribs;
-    LOG(INFO) << "GL_MAX_UNIFORM_BLOCK_SIZE = " << gets.max_uniform_block_size;
-    LOG(INFO) << "GL_MAX_UNIFORM_BUFFER_BINDINGS = " << gets.max_uniform_buffer_bindings;
-    LOG(INFO) << "GL_NUM_PROGRAM_BINARY_FORMATS = " << gets.num_program_binary_formats;
-    LOG(INFO) << "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = " << gets.uniform_buffer_offset_alignment;
+    slog.v
+            << "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = "
+                    << gets.max_anisotropy << '\n'
+            << "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = "
+                    << gets.max_combined_texture_image_units << '\n'
+            << "GL_MAX_TEXTURE_SIZE = "
+                    << gets.max_texture_size << '\n'
+            << "GL_MAX_CUBE_MAP_TEXTURE_SIZE = "
+                    << gets.max_cubemap_texture_size << '\n'
+            << "GL_MAX_3D_TEXTURE_SIZE = "
+                    << gets.max_3d_texture_size << '\n'
+            << "GL_MAX_ARRAY_TEXTURE_LAYERS = "
+                    << gets.max_array_texture_layers << '\n'
+            << "GL_MAX_DRAW_BUFFERS = "
+                    << gets.max_draw_buffers << '\n'
+            << "GL_MAX_RENDERBUFFER_SIZE = "
+                    << gets.max_renderbuffer_size << '\n'
+            << "GL_MAX_SAMPLES = "
+                    << gets.max_samples << '\n'
+            << "GL_MAX_TEXTURE_IMAGE_UNITS = "
+                    << gets.max_texture_image_units << '\n'
+            << "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = "
+                    << gets.max_transform_feedback_separate_attribs << '\n'
+            << "GL_MAX_UNIFORM_BLOCK_SIZE = "
+                    << gets.max_uniform_block_size << '\n'
+            << "GL_MAX_UNIFORM_BUFFER_BINDINGS = "
+                    << gets.max_uniform_buffer_bindings << '\n'
+            << "GL_NUM_PROGRAM_BINARY_FORMATS = "
+                    << gets.num_program_binary_formats << '\n'
+            << "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = "
+                    << gets.uniform_buffer_offset_alignment << '\n'
+            ;
+    flush(slog.v);
 #endif

 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
@@ -224,14 +242,15 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
    if (ext.KHR_debug) {
        auto cb = +[](GLenum, GLenum type, GLuint, GLenum severity, GLsizei length,
                const GLchar* message, const void *) {
-            auto logSeverity = utils::LogSeverity::kInfo;
+            io::ostream* stream = &slog.i;
            switch (severity) {
-                case GL_DEBUG_SEVERITY_HIGH:    logSeverity = utils::LogSeverity::kError;   break;
-                case GL_DEBUG_SEVERITY_MEDIUM:  logSeverity = utils::LogSeverity::kWarning; break;
-                case GL_DEBUG_SEVERITY_LOW:     logSeverity = utils::LogSeverity::kInfo;    break;
+                case GL_DEBUG_SEVERITY_HIGH:    stream = &slog.e;   break;
+                case GL_DEBUG_SEVERITY_MEDIUM:  stream = &slog.w;   break;
+                case GL_DEBUG_SEVERITY_LOW:     stream = &slog.d;   break;
                case GL_DEBUG_SEVERITY_NOTIFICATION:
                default: break;
            }
+            io::ostream& out = *stream;
            const char* level = ": ";
            switch (type) {
                case GL_DEBUG_TYPE_ERROR:               level = "ERROR: ";               break;
@@ -243,7 +262,7 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
                case GL_DEBUG_TYPE_MARKER:              level = "MARKER: ";              break;
                default: break;
            }
-            LOG(LEVEL(logSeverity)) << "KHR_debug " << level << std::string_view{ message, size_t(length) };
+            out << "KHR_debug " << level << std::string_view{ message, size_t(length) } << io::endl;
        };
        glEnable(GL_DEBUG_OUTPUT);
        glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
@@ -688,8 +707,9 @@ void OpenGLContext::initExtensionsGLES(Extensions* ext, GLint major, GLint minor
    GLUtils::unordered_string_set const exts = GLUtils::split(extensions);
    if constexpr (DEBUG_PRINT_EXTENSIONS) {
        for (auto extension: exts) {
-            DLOG(INFO) << "\"" << std::string_view(extension) << "\"";
+            slog.d << "\"" << std::string_view(extension) << "\"\n";
        }
+        flush(slog.d);
    }

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

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

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

-    DLOG(INFO) << "GLSwapChain: " << sizeof(GLSwapChain);
-    DLOG(INFO) << "GLBufferObject: " << sizeof(GLBufferObject);
-    DLOG(INFO) << "GLVertexBuffer: " << sizeof(GLVertexBuffer);
-    DLOG(INFO) << "GLVertexBufferInfo: " << sizeof(GLVertexBufferInfo);
-    DLOG(INFO) << "GLIndexBuffer: " << sizeof(GLIndexBuffer);
-    DLOG(INFO) << "GLRenderPrimitive: " << sizeof(GLRenderPrimitive);
-    DLOG(INFO) << "GLTexture: " << sizeof(GLTexture);
-    DLOG(INFO) << "GLTimerQuery: " << sizeof(GLTimerQuery);
-    DLOG(INFO) << "GLStream: " << sizeof(GLStream);
-    DLOG(INFO) << "GLRenderTarget: " << sizeof(GLRenderTarget);
-    DLOG(INFO) << "GLFence: " << sizeof(GLFence);
-    DLOG(INFO) << "OpenGLProgram: " << sizeof(OpenGLProgram);
+    slog.d
+           << "\nGLSwapChain: " << sizeof(GLSwapChain)
+           << "\nGLBufferObject: " << sizeof(GLBufferObject)
+           << "\nGLVertexBuffer: " << sizeof(GLVertexBuffer)
+           << "\nGLVertexBufferInfo: " << sizeof(GLVertexBufferInfo)
+           << "\nGLIndexBuffer: " << sizeof(GLIndexBuffer)
+           << "\nGLRenderPrimitive: " << sizeof(GLRenderPrimitive)
+           << "\nGLTexture: " << sizeof(GLTexture)
+           << "\nGLTimerQuery: " << sizeof(GLTimerQuery)
+           << "\nGLStream: " << sizeof(GLStream)
+           << "\nGLRenderTarget: " << sizeof(GLRenderTarget)
+           << "\nGLFence: " << sizeof(GLFence)
+           << "\nOpenGLProgram: " << sizeof(OpenGLProgram)
+           << io::endl;
 #endif

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

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

    // Timer queries are core in GL 3.3, otherwise we need EXT_disjoint_timer_query
@@ -667,7 +668,7 @@ void OpenGLDriver::createIndexBufferR(
    gl.bindVertexArray(nullptr);
    gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, ib->gl.buffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, nullptr, getBufferUsage(usage));
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }

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

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

 void OpenGLDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph,
@@ -729,7 +730,7 @@ void OpenGLDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph,
    // this records the index buffer into the currently bound VAO
    gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, ib->gl.buffer);

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

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

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

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

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

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

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

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

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

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

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

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

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

    rt->gl.resolve |= resolveFlags;

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

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

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

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

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

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

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

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

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

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

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

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

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

    scheduleDestroy(std::move(p));

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

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

    scheduleDestroy(std::move(bd));

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

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

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

    glGenerateMipmap(t->gl.target);

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

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

    scheduleDestroy(std::move(p));

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

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

    scheduleDestroy(std::move(p));

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

 void OpenGLDriver::setupExternalImage2(Platform::ExternalImageHandleRef image) {
@@ -3152,7 +3153,7 @@ void OpenGLDriver::beginRenderPass(Handle<HwRenderTarget> rth,
    TargetBufferFlags discardFlags = params.flags.discardStart & rt->targets;

    GLuint const fbo = gl.bindFramebuffer(GL_FRAMEBUFFER, rt->gl.fbo);
-    CHECK_GL_FRAMEBUFFER_STATUS(GL_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_FRAMEBUFFER)

    // each render-pass starts with a disabled scissor
    gl.disable(GL_SCISSOR_TEST);
@@ -3164,7 +3165,7 @@ void OpenGLDriver::beginRenderPass(Handle<HwRenderTarget> rth,
        if (attachmentCount) {
            gl.procs.invalidateFramebuffer(GL_FRAMEBUFFER, attachmentCount, attachments.data());
        }
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
    } else {
        // It's important to clear the framebuffer before drawing, as it resets
        // the fb to a known state (resets fb compression and possibly other things).
@@ -3251,7 +3252,7 @@ void OpenGLDriver::endRenderPass(int) {
            if (attachmentCount) {
                gl.procs.invalidateFramebuffer(GL_FRAMEBUFFER, attachmentCount, attachments.data());
            }
-           CHECK_GL_ERROR()
+           CHECK_GL_ERROR(utils::slog.e)
        }
    }

@@ -3297,13 +3298,13 @@ void OpenGLDriver::resolvePass(ResolveAction action, GLRenderTarget const* rt,
        gl.bindFramebuffer(GL_READ_FRAMEBUFFER, read);
        gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, draw);

-        CHECK_GL_FRAMEBUFFER_STATUS(GL_READ_FRAMEBUFFER)
-        CHECK_GL_FRAMEBUFFER_STATUS(GL_DRAW_FRAMEBUFFER)
+        CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)
+        CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)

        gl.disable(GL_SCISSOR_TEST);
        glBlitFramebuffer(0, 0, (GLint)rt->width, (GLint)rt->height,
                0, 0, (GLint)rt->width, (GLint)rt->height, mask, GL_NEAREST);
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
    }
 #endif
 }
@@ -3482,7 +3483,7 @@ void OpenGLDriver::readPixels(Handle<HwRenderTarget> src,
        if (buffer) {
            gl.bindFramebuffer(GL_FRAMEBUFFER, s->gl.fbo_read ? s->gl.fbo_read : s->gl.fbo);
            glReadPixels(GLint(x), GLint(y), GLint(width), GLint(height), glFormat, glType, buffer);
-            CHECK_GL_ERROR()
+            CHECK_GL_ERROR(utils::slog.e)

            // now we need to flip the buffer vertically to match our API
            size_t const stride = p.stride ? p.stride : width;
@@ -3514,7 +3515,7 @@ void OpenGLDriver::readPixels(Handle<HwRenderTarget> src,
    glBufferData(GL_PIXEL_PACK_BUFFER, pboSize, nullptr, GL_STATIC_DRAW);
    glReadPixels(GLint(x), GLint(y), GLint(width), GLint(height), glFormat, glType, nullptr);
    gl.bindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)

    // we're forced to make a copy on the heap because otherwise it deletes std::function<> copy
    // constructor.
@@ -3554,7 +3555,7 @@ void OpenGLDriver::readPixels(Handle<HwRenderTarget> src,
        glDeleteBuffers(1, &pbo);
        scheduleDestroy(std::move(p));
        delete pUserBuffer;
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)
    });
 #endif
 }
@@ -3579,7 +3580,7 @@ void OpenGLDriver::readBufferSubData(BufferObjectHandle boh,
        glCopyBufferSubData(bo->gl.binding, GL_PIXEL_PACK_BUFFER, offset, 0, size);
        gl.bindBuffer(bo->gl.binding, 0);
        gl.bindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-        CHECK_GL_ERROR()
+        CHECK_GL_ERROR(utils::slog.e)

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

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

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

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

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

    gl.disable(GL_SCISSOR_TEST);
    glBlitFramebuffer(
            srcOrigin.x, srcOrigin.y, srcOrigin.x + size.x, srcOrigin.y + size.y,
            dstOrigin.x, dstOrigin.y, dstOrigin.x + size.x, dstOrigin.y + size.y,
            mask, GL_NEAREST);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)

    gl.unbindFramebuffer(GL_DRAW_FRAMEBUFFER);
    gl.unbindFramebuffer(GL_READ_FRAMEBUFFER);
@@ -4064,15 +4065,15 @@ void OpenGLDriver::blitDEPRECATED(TargetBufferFlags buffers,
    gl.bindFramebuffer(GL_READ_FRAMEBUFFER, s->gl.fbo);
    gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, d->gl.fbo);

-    CHECK_GL_FRAMEBUFFER_STATUS(GL_READ_FRAMEBUFFER)
-    CHECK_GL_FRAMEBUFFER_STATUS(GL_DRAW_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_READ_FRAMEBUFFER)
+    CHECK_GL_FRAMEBUFFER_STATUS(utils::slog.e, GL_DRAW_FRAMEBUFFER)

    gl.disable(GL_SCISSOR_TEST);
    glBlitFramebuffer(
            srcRect.left, srcRect.bottom, srcRect.right(), srcRect.top(),
            dstRect.left, dstRect.bottom, dstRect.right(), dstRect.top(),
            GL_COLOR_BUFFER_BIT, glFilterMode);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 #endif
 }

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

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

@@ -4231,9 +4232,9 @@ void OpenGLDriver::draw2GLES2(uint32_t indexOffset, uint32_t indexCount, uint32_
            reinterpret_cast<const void*>(indexOffset << rp->gl.indicesShift));

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

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

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

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

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

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

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

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

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

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

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

@@ -153,7 +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()
+        CHECK_GL_ERROR(utils::slog.e)
        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/Logger.h>
-#include <utils/Panic.h>
-#include <utils/compiler.h>
-#include <utils/debug.h>
+#include <utils/Log.h>
 #include <utils/ostream.h>
+#include <utils/Panic.h>

 #include <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(ShaderStage shaderType, const char* name, GLuint shaderId,
-        CString const& sourceCode) noexcept;
-static void logProgramLinkError(char const* name, GLuint program) noexcept;
+static void logCompilationError(io::ostream& out, ShaderStage shaderType, const char* name,
+        GLuint shaderId, CString const& sourceCode) noexcept;
+static void logProgramLinkError(io::ostream& out, char const* name, GLuint program) noexcept;

 static void process_GOOGLE_cpp_style_line_directive(OpenGLContext const& context, char* source,
        size_t len) noexcept;
@@ -433,9 +433,8 @@ void ShaderCompilerService::ensureTokenIsReady(program_token_t const& token) {
            // just log warnings here instead of repeatedly checking compile status. If this turns
            // out to be a real issue later, we would need to consider doing the canonical way.
            if (!isCompileCompleted(token)) {
-                LOG(WARNING)
-                        << "Shader compilation for OpenGL program " << token->name.c_str_safe()
-                        << " is not completed yet. The following program link may not succeed.";
+                slog.w << "Shader compilation for OpenGL program " << token->name.c_str_safe()
+                       << " is not completed yet. The following program link may not succeed.";
            }

            linkProgram(mDriver.getContext(), token);
@@ -645,7 +644,8 @@ void ShaderCompilerService::executeTickOps() noexcept {
        }
        // Something went wrong. Log the error message.
        const ShaderStage type = static_cast<ShaderStage>(i);
-        logCompilationError(type, token->name.c_str_safe(), shader, token->shaderSourceCode[i]);
+        logCompilationError(slog.e, type, token->name.c_str_safe(), shader,
+                token->shaderSourceCode[i]);
    }
 }

@@ -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(token->name.c_str_safe(), token->gl.program);
+        logProgramLinkError(slog.e, token->name.c_str_safe(), token->gl.program);
        linked = false;
    }
    // No need to keep the shaders around regardless of the result of the program linking.
@@ -747,7 +747,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
 // ------------------------------------------------------------------------------------------------

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

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

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

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

 UTILS_NOINLINE
-/* static */ void logProgramLinkError(char const* name, GLuint program) noexcept {
+/* static */ void logProgramLinkError(io::ostream& out, char const* name, GLuint program) noexcept {
    GLint length = 0;
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length);

    CString infoLog(length);
    glGetProgramInfoLog(program, length, nullptr, infoLog.data());

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

 // If usages of the Google-style line directive are present, remove them, as some
@@ -96,7 +96,7 @@ CocoaExternalImage::SharedGl::~SharedGl() noexcept {
 CocoaExternalImage::CocoaExternalImage(const CVOpenGLTextureCacheRef textureCache,
        const SharedGl &sharedGl) noexcept : mSharedGl(sharedGl), mTextureCache(textureCache) {
    glGenFramebuffers(1, &mFBO);
-    CHECK_GL_ERROR()
+    CHECK_GL_ERROR(utils::slog.e)
 }

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

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

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

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

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

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

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

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

    glGenFramebuffers(1, &mFBO);

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

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

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

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

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

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

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

    mState.restore();

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

 #include <backend/Platform.h>

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

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

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

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

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

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

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

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

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

@@ -29,12 +29,13 @@
 #include <android/native_window.h>
 #include <android/hardware_buffer.h>

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

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

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

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

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

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

 using namespace utils;

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

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

 #include <backend/platforms/PlatformGLX.h>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 VulkanBufferProxy::VulkanBufferProxy(VmaAllocator allocator, VulkanStagePool& stagePool,
        VulkanBufferCache& bufferCache, VulkanBufferUsage usage, uint32_t numBytes)
-    : mStagePool(stagePool),
+    : mAllocator(allocator),
+      mStagePool(stagePool),
      mBufferCache(bufferCache),
      mBuffer(mBufferCache.acquire(usage, numBytes)),
      mUpdatedOffset(0),
@@ -38,8 +39,10 @@ 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);
-    stage->copy(0, cpuData, numBytes);
+    memcpy(stage->mapping(), cpuData, numBytes);
+    vmaFlushAllocation(mAllocator, stage->memory(), stage->offset(), numBytes);

    // If there was a previous update, then we need to make sure the following write is properly
    // synced with the previous read.
@@ -40,6 +40,7 @@ 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;
+             << " fence=" << mFence << utils::io::endl;
 #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;
+        FVK_LOGD << "Failed command buffer submission result: " << result << utils::io::endl;
    }
 #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;
+    FVK_LOGD << "----> " << str << utils::io::endl;
 #endif
 }

@@ -502,7 +502,8 @@ 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";
+    FVK_LOGD << "<---- " << marker << " elapsed: " << (diff.count() * 1000) << " ms"
+             << utils::io::endl;
 #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/Logger.h>
+#include <utils/Log.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 LOG(INFO) and LOG(ERROR) will not
-// appear in order of calls).
+// to debug with print statements and want ordered logging (e.g slog.i and slog.e 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 | FVK_DEBUG_DEBUG_UTILS | FVK_DEBUG_GROUP_MARKERS | FVK_DEBUG_VALIDATION)
+#define FVK_DEBUG_FLAGS (FVK_DEBUG_PERFORMANCE | FVK_DEBUG_FORWARDED_FLAG)
 #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 LOG(INFO)
+    #define FVK_LOGI (utils::slog.i)
    #define FVK_LOGD FVK_LOGI
    #define FVK_LOGE FVK_LOGI
    #define FVK_LOGW FVK_LOGI
 #else
-    #define FVK_LOGE LOG(ERROR)
-    #define FVK_LOGW LOG(WARNING)
-    #define FVK_LOGD DLOG(INFO)
-    #define FVK_LOGI LOG(INFO)
+    #define FVK_LOGE (utils::slog.e)
+    #define FVK_LOGW (utils::slog.w)
+    #define FVK_LOGD (utils::slog.d)
+    #define FVK_LOGI (utils::slog.i)
 #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;
+        FVK_LOGE << "VULKAN ERROR: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
    } 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;
+        FVK_LOGW << "VULKAN WARNING: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
    }
-    FVK_LOGE;
+    FVK_LOGE << utils::io::endl;
    return VK_FALSE;
 }
 #endif // FVK_ENABLED(FVK_DEBUG_VALIDATION)
@@ -122,16 +122,18 @@ 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;
+        FVK_LOGE << "VULKAN ERROR: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
+                 << utils::io::endl;
    } 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;
+        FVK_LOGW << "VULKAN WARNING: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
+                 << utils::io::endl;
    }
-    FVK_LOGE << "";
+    FVK_LOGE << utils::io::endl;
    return VK_FALSE;
 }
 #endif // FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
@@ -274,18 +276,20 @@ Driver* VulkanDriver::create(VulkanPlatform* platform, VulkanContext const& cont
    //    VulkanRenderTarget            : 312       few
    // -- less than or equal to 312 bytes

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

    assert_invariant(platform);
@@ -795,12 +799,14 @@ 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";
+        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it"
+                 << utils::io::endl;
        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";
+            FVK_LOGW << "protected swapchain requested, but Platform does not support it"
+                << utils::io::endl;
        }
    }
    auto swapChain = resource_ptr<VulkanSwapChain>::make(&mResourceManager, sch, mPlatform,
@@ -811,7 +817,8 @@ 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";
+        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it"
+                      << utils::io::endl;
        flags = flags | ~(backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE);
    }
    assert_invariant(width > 0 && height > 0 && "Vulkan requires non-zero swap chain dimensions.");
@@ -1299,7 +1306,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. ";
+        FVK_LOGW << "Timestamps are not monotonically increasing. " << utils::io::endl;
        *elapsedTime = 0;
        return TimerQueryResult::ERROR;
    }
@@ -2037,7 +2044,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.";
+        FVK_LOGE << command.data() << " issued inside a render pass." << utils::io::endl;
    }
 #endif
 }
@@ -100,7 +100,8 @@ VkFramebuffer VulkanFboCache::getFramebuffer(FboKey const& config) noexcept {
        << "for render pass " << config.renderPass << ", "
        << "samples = " << int(config.samples) << ", "
        << "depth = " << (config.depth ? 1 : 0) << ", "
-        << "attachmentCount = " << attachmentCount;
+        << "attachmentCount = " << attachmentCount
+        << utils::io::endl;
    #endif

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

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

    #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
        FVK_LOGD << "vkCreateGraphicsPipelines with shaders = ("
-                 << shaderStages[0].module << ", " << shaderStages[1].module << ")";
+                 << shaderStages[0].module << ", " << shaderStages[1].module << ")"
+                 << utils::io::endl;
    #endif
    PipelineCacheEntry cacheEntry = {
        .lastUsed = mCurrentTime,
@@ -227,7 +228,7 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
            VKALLOC, &cacheEntry.handle);
    assert_invariant(error == VK_SUCCESS);
    if (error != VK_SUCCESS) {
-        FVK_LOGE << "vkCreateGraphicsPipelines error " << error;
+        FVK_LOGE << "vkCreateGraphicsPipelines error " << error << utils::io::endl;
        return nullptr;
    }
    return &mPipelines.emplace(mPipelineRequirements, cacheEntry).first.value();
@@ -241,7 +242,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();
+        FVK_LOGE << "Binding missing shader: " << program->name.c_str() << utils::io::endl;
    }
 #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.";
+        FVK_LOGE << "More than " << mUsed.size() << " timers are not supported." << utils::io::endl;
        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);
+             << " src-layout=" << srcTexture->getLayout(0, 0) << utils::io::endl;
 #endif

    VkMemoryRequirements memReqs;
@@ -188,7 +188,8 @@ 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";
+                << "readPixels is slow because VK_MEMORY_PROPERTY_HOST_CACHED_BIT is not available"
+                << utils::io::endl;
    }

    FILAMENT_CHECK_POSTCONDITION(memoryTypeIndex < VK_MAX_MEMORY_TYPES)
@@ -304,7 +305,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";
+            FVK_LOGE << "Failed to wait for readPixels fence" << utils::io::endl;
            return;
        }

@@ -322,7 +323,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";
+            FVK_LOGE << "Unsupported PixelDataFormat or PixelDataType" << utils::io::endl;
        }

        vkUnmapMemory(device, stagingMemory);
@@ -38,23 +38,15 @@ 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, 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);
+    auto segment = fvkmemory::resource_ptr<Segment>::construct(
+        resManager, this, numBytes, mCurrentOffset, [this](uint32_t offset) {
+            mSegments.erase(offset);
+    });
+    mSegments.insert({mCurrentOffset, segment.get()});
    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),
@@ -116,9 +108,9 @@ VulkanStage* VulkanStagePool::allocateNewStage(uint32_t capacity) {

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

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

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

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

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

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

-        inline VkBuffer buffer() const { return mParentStage->buffer(); }
-        inline VmaAllocation memory() const { return mParentStage->memory(); }
+        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 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());
@@ -87,9 +85,9 @@ public:
        // Ensure parent class can access the terminate method.
        friend class VulkanStage;

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

@@ -111,7 +109,6 @@ 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.";
+                FVK_LOGW << "Texture usage is SAMPLEABLE but format " << vkFormat << " is not "
+                        "sampleable with optimal tiling." << utils::io::endl;
            }
        }
 #endif
@@ -219,8 +219,8 @@ VkImageUsageFlags getUsage(VulkanContext const& context, uint8_t samples,
    return usage;
 }

-void adjustedMemcpy(PixelBufferDescriptor const& p, size_t width, size_t height,
-        size_t depth, std::function<void(size_t, uint8_t*, size_t)> cpy) {
+void adjustedMemcpy(void* mapped, PixelBufferDescriptor const& p, size_t width, size_t height,
+        size_t depth) {
    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(PixelBufferDescriptor const& p, size_t width, size_t height,
            for (size_t y = p.top; y < pbdHeight; y++) {
                uint8_t* buf = (uint8_t*) p.buffer +
                               ((p.left * pixelSize) + (y * pbdRowSize) + (z * pbdLayerSize));
-                uint32_t const offset = (y - p.top) * rowSize + z * layerSize;
-                cpy(offset, buf, writeSize);
+                uint8_t* curMapped = (uint8_t*) mapped + ((y - p.top) * rowSize + z * layerSize);
+                memcpy(curMapped, buf, writeSize);
            }
        }
    } else {
        size_t const writeSize = pixelSize * (width * height * depth);
-        cpy(0, buf, writeSize);
+        memcpy(mapped, 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";
+                     << "i.e. we cannot render to slices of a 3D image" << utils::io::endl;
        }
    } 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;
+            << "format = " << vkFormat << utils::io::endl;
    }
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Unable to create image."
                                                       << " error=" << static_cast<int32_t>(result);
@@ -525,12 +525,9 @@ void VulkanTexture::updateImage(const PixelBufferDescriptor& data, uint32_t widt
    fvkmemory::resource_ptr<VulkanStage::Segment> stageSegment =
            mState->mStagePool.acquireStage(writeSize);
    assert_invariant(stageSegment->memory());
-    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);
+    adjustedMemcpy(stageSegment->mapping(), *hostData, width, height, depth);
+    vmaFlushAllocation(mState->mAllocator, stageSegment->memory(), stageSegment->offset(),
+            writeSize);

    VulkanCommandBuffer& commands = mState->mCommands->get();
    VkCommandBuffer const cmdbuf = commands.buffer();
@@ -600,10 +597,7 @@ 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(data, width, height, depth,
-            [&mapped](size_t, uint8_t* src, size_t numBytes) {
-                memcpy(mapped, src, numBytes);
-            });
+    adjustedMemcpy(mapped, data, width, height, depth);
    vmaUnmapMemory(mState->mAllocator, stage->memory);
    vmaFlushAllocation(mState->mAllocator, stage->memory, 0, writeSize);

@@ -737,14 +731,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;
+                 << " slice-by-slice=" << transitionSliceBySlice << utils::io::endl;
 #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";
+                 << " is skipped because of no change in layout" << utils::io::endl;
 #endif
    }

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

@@ -864,7 +859,8 @@ 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;
+                      << " aspect=" << range.aspectMask << " viewType=" << view.first.type
+                      << utils::io::endl;
    }
 }
 #endif
@@ -17,7 +17,6 @@
 #include "vulkan/memory/ResourceManager.h"
 #include "vulkan/VulkanHandles.h"

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

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

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

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

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

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

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

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

@@ -295,10 +294,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?";
+                 << "gradle file?" << utils::io::endl;
 #else
        FVK_LOGD << "Validation layer not available; did you install the Vulkan SDK?\n"
-                 << "Please ensure that VK_LAYER_PATH is set correctly.";
+                 << "Please ensure that VK_LAYER_PATH is set correctly." << utils::io::endl;
 #endif // __ANDROID__

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

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

@@ -163,7 +163,8 @@ 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.";
+        FVK_LOGE << "Swap chain does not support " << desiredImageCount << " images."
+                      << utils::io::endl;
        desiredImageCount = caps.minImageCount;
    }

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

    VkSemaphoreCreateInfo const semaphoreCreateInfo = {
            .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
@@ -291,7 +293,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.";
+        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain." << io::endl;
        mSuboptimal = true;
    }
    return result;
@@ -313,7 +315,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.";
+        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain." << utils::io::endl;
        mSuboptimal = true;
    }
    return result;
@@ -0,0 +1,795 @@
+#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
@@ -0,0 +1,83 @@
+#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/Logger.h>
+#include <utils/Log.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 LOG(INFO) and LOG(ERROR) will not
-// appear in order of calls).
+// to debug with print statements and want ordered logging (e.g slog.i and slog.e 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 LOG(INFO)
+    #define FWGPU_LOGI (utils::slog.i)
    #define FWGPU_LOGD FWGPU_LOGI
    #define FWGPU_LOGE FWGPU_LOGI
    #define FWGPU_LOGW FWGPU_LOGI
 #else
-    #define FWGPU_LOGE LOG(ERROR)
-    #define FWGPU_LOGW LOG(WARNING)
-    #define FWGPU_LOGD DLOG(INFO)
-    #define FWGPU_LOGI LOG(INFO)
+    #define FWGPU_LOGE (utils::slog.e)
+    #define FWGPU_LOGW (utils::slog.w)
+    #define FWGPU_LOGD (utils::slog.d)
+    #define FWGPU_LOGI (utils::slog.i)
 #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.";
+                  "are likely to be encountered at this stage."
+               << utils::io::endl;
 #if !FWGPU_ENABLED(FWGPU_PRINT_SYSTEM) && !defined(NDEBUG)
-    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
+    FWGPU_LOGI << "If the FILAMENT_BACKEND_DEBUG_FLAG variable were set with the " << utils::io::hex
+               << FWGPU_PRINT_SYSTEM << utils::io::dec
               << " 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 << " ...";
+               << FWGPU_PRINT_SYSTEM << " ..." << utils::io::endl;
 #endif
 }

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

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

 bool WebGPUDriver::isRenderTargetFormatSupported(const TextureFormat format) {
@@ -738,67 +738,63 @@ 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);

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

-    uint32_t mipLevelCount = wgpuTexture.GetMipLevelCount();
-    if (mipLevelCount <= 1) {
+    const uint32_t totalMipLevels = wgpuTexture.GetMipLevelCount();
+    if (totalMipLevels <= 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);

-    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;
+    // 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.";

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

-        wgpu::TexelCopyTextureInfo destinationCopyInfo{
-            .texture = wgpuTexture,
-            .mipLevel = mipLevel + 1,
-            .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);

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

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

-        width = dstWidth;
-        height = dstHeight;
-        depth = dstDepth;
+        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;
    }
+
+    // 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,
@@ -815,7 +811,6 @@ 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;
@@ -829,7 +824,6 @@ 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();
@@ -861,7 +855,7 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> renderTargetHandle,
                const uint32_t depthArrayLayer = depthInfo.layer;
                customDepthView =
                        depthTexture->getOrMakeTextureView(depthMipLevel, depthArrayLayer);
-                customDepthFormat = depthTexture->getViewFormat();
+                customDepthFormat = depthTexture->getWebGPUFormat();
            }
        }

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

 #include <utils/compiler.h>

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

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

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

 #include <array>
 #include <cstdint>
@@ -188,7 +187,7 @@ namespace {
                        switch (status) {
                            case wgpu::CompilationInfoRequestStatus::CallbackCancelled:
                                FWGPU_LOGW << "Shader compilation info callback cancelled for "
-                                           << descriptor.label << "?";
+                                           << descriptor.label << "?" << utils::io::endl;
                                return;
                            case wgpu::CompilationInfoRequestStatus::Success:
                                break;
@@ -204,7 +203,8 @@ namespace {
                                                   << " line#:" << message.lineNum
                                                   << " linePos:" << message.linePos
                                                   << " offset:" << message.offset
-                                                   << " length:" << message.length;
+                                                   << " length:" << message.length
+                                                   << utils::io::endl;
                                        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;
+                                                << " length:" << message.length << utils::io::endl;
                                        break;
                                    case wgpu::CompilationMessageType::Error:
                                        errorCount++;
@@ -231,7 +231,8 @@ namespace {
                                    << errorStream.str();
                        }
 #if FWGPU_ENABLED(FWGPU_DEBUG_VALIDATION)
-                        FWGPU_LOGD << descriptor.label << " compiled successfully";
+                        FWGPU_LOGD << descriptor.label << " compiled successfully"
+                                   << utils::io::endl;
 #endif
                    }),
            SHADER_COMPILATION_TIMEOUT_NANOSECONDS);
@@ -73,7 +73,6 @@ 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,
@@ -94,39 +93,30 @@ 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 = wgpu::LoadOp::Undefined,
-                .stencilStoreOp = wgpu::StoreOp::Undefined,
+                .stencilLoadOp =
+                        WebGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL),
+                .stencilStoreOp =
+                        WebGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL),
                .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,7 +46,6 @@ 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,50 +54,52 @@ utils::io::ostream& operator<<(utils::io::ostream& out,
 }

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

 void printSurfaceConfiguration(wgpu::SurfaceConfiguration const& config,
        wgpu::TextureFormat depthFormat) {
-    FWGPU_LOGI << "WebGPU surface configuration:";
-    FWGPU_LOGI << "  surface format: " << config.format;
-    FWGPU_LOGI << "  surface usage: " << config.usage;
-    FWGPU_LOGI << "  surface view formats (" << config.viewFormatCount << "):";
+    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;
    if (config.viewFormatCount > 0 && config.viewFormats != nullptr) {
        std::for_each(config.viewFormats, config.viewFormats + config.viewFormatCount,
                [](wgpu::TextureFormat const viewFormat) {
-                    FWGPU_LOGI << "    " << viewFormat;
+                    FWGPU_LOGI << "    " << viewFormat << 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;
+    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;
 }
 #endif// FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)

@@ -187,7 +189,8 @@ 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.";
+                      "transparency is being selected as a fallback, but may not work as expected."
+                   << utils::io::endl;
        return wgpu::CompositeAlphaMode::Premultiplied;
    } else {
        FILAMENT_CHECK_POSTCONDITION(unpremultipliedAvailable)
@@ -197,7 +200,8 @@ 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.";
+                      "(premulitipled is not available either), but may not work as expected."
+                   << utils::io::endl;
        return wgpu::CompositeAlphaMode::Unpremultiplied;
    }
 }
@@ -270,7 +274,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";
+        FWGPU_LOGW << "Failed to get WebGPU surface capabilities" << utils::io::endl;
    } else {
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
        printSurfaceCapabilitiesDetails(capabilities);
@@ -293,7 +297,8 @@ 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;
+        FWGPU_LOGD << "Resizing to width " << mConfig.width << " height " << mConfig.height
+                   << utils::io::endl;
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
        printSurfaceConfiguration(mConfig, mDepthFormat);
 #endif
@@ -28,46 +28,13 @@
 #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]] constexpr wgpu::StringView getUserTextureLabel(const SamplerType target) {
-    // TODO will be helpful to get more useful info than this
-    switch (target) {
-        case SamplerType::SAMPLER_2D:            return "a_2D_user_texture";
-        case SamplerType::SAMPLER_2D_ARRAY:      return "a_2D_array_user_texture";
-        case SamplerType::SAMPLER_CUBEMAP:       return "a_cube_map_user_texture";
-        case SamplerType::SAMPLER_EXTERNAL:      return "an_external_user_texture";
-        case SamplerType::SAMPLER_3D:            return "a_3D_user_texture";
-        case SamplerType::SAMPLER_CUBEMAP_ARRAY: return "a_cube_map_array_user_texture";
-    }
-}
-
-[[nodiscard]] constexpr wgpu::StringView getUserTextureViewLabel(const SamplerType target) {
-    // TODO will be helpful to get more useful info than this
-    switch (target) {
-        case SamplerType::SAMPLER_2D:            return "a_2D_user_texture_view";
-        case SamplerType::SAMPLER_2D_ARRAY:      return "a_2D_array_user_texture_view";
-        case SamplerType::SAMPLER_CUBEMAP:       return "a_cube_map_user_texture_view";
-        case SamplerType::SAMPLER_EXTERNAL:      return "an_external_user_texture_view";
-        case SamplerType::SAMPLER_3D:            return "a_3D_user_texture_view";
-        case SamplerType::SAMPLER_CUBEMAP_ARRAY: return "a_cube_map_array_user_texture_view";
-    }
-}
-
-/**
- * @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) {
+[[nodiscard]] bool IsFormatStorageCompatible(wgpu::TextureFormat format) {
    switch (format) {
        // List of formats that support storage binding
        case wgpu::TextureFormat::R32Float:
@@ -93,78 +60,98 @@ namespace {
            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;
+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:
-            if (isFormatStorageCompatible(viewFormat)) {
-                return viewFormat; // view format is itself already storage binding compatible
-            } else {
-                return wgpu::TextureFormat::Undefined; // no valid format in this case
-            }
+            return srgbFormat; // If not an sRGB format, return the same input
    }
 }

-/**
- * @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 bool needsComputeStorageSupport) {
-    wgpu::TextureUsage retUsage = wgpu::TextureUsage::None;
+[[nodiscard]] constexpr wgpu::StringView getUserTextureLabel(const SamplerType target) {
+    // TODO will be helpful to get more useful info than this
+    switch (target) {
+        case SamplerType::SAMPLER_2D:            return "a_2D_user_texture";
+        case SamplerType::SAMPLER_2D_ARRAY:      return "a_2D_array_user_texture";
+        case SamplerType::SAMPLER_CUBEMAP:       return "a_cube_map_user_texture";
+        case SamplerType::SAMPLER_EXTERNAL:      return "an_external_user_texture";
+        case SamplerType::SAMPLER_3D:            return "a_3D_user_texture";
+        case SamplerType::SAMPLER_CUBEMAP_ARRAY: return "a_cube_map_array_user_texture";
+    }
+}

-    // if needsComputeStorageSupport we need to read and write to the texture in a shader and thus
-    // require CopySrc, CopyDst, TextureBinding, & StorageBinding
+[[nodiscard]] constexpr wgpu::StringView getUserTextureViewLabel(const SamplerType target) {
+    // TODO will be helpful to get more useful info than this
+    switch (target) {
+        case SamplerType::SAMPLER_2D:            return "a_2D_user_texture_view";
+        case SamplerType::SAMPLER_2D_ARRAY:      return "a_2D_array_user_texture_view";
+        case SamplerType::SAMPLER_CUBEMAP:       return "a_cube_map_user_texture_view";
+        case SamplerType::SAMPLER_EXTERNAL:      return "an_external_user_texture_view";
+        case SamplerType::SAMPLER_3D:            return "a_3D_user_texture_view";
+        case SamplerType::SAMPLER_CUBEMAP_ARRAY: return "a_cube_map_array_user_texture_view";
+    }
+}
+
+[[nodiscard]] wgpu::TextureUsage fToWGPUTextureUsage(TextureUsage const& fUsage,
+        const uint8_t samples) {
+    wgpu::TextureUsage retUsage = wgpu::TextureUsage::None;

    // Basing this mapping off of VulkanTexture.cpp's getUsage func and suggestions from Gemini
    // TODO Validate assumptions, revisit if issues.
-    if (needsComputeStorageSupport || any(TextureUsage::BLIT_SRC & fUsage)) {
+    if (any(TextureUsage::BLIT_SRC & fUsage)) {
        retUsage |= wgpu::TextureUsage::CopySrc;
    }
-    if (needsComputeStorageSupport ||
-            any((TextureUsage::BLIT_DST | TextureUsage::UPLOADABLE) & fUsage)) {
+    if (any((TextureUsage::BLIT_DST | TextureUsage::UPLOADABLE) & fUsage)) {
        retUsage |= wgpu::TextureUsage::CopyDst;
    }
-    if (needsComputeStorageSupport || any(TextureUsage::SAMPLEABLE & fUsage)) {
+    if (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.
@@ -191,6 +178,7 @@ namespace {
        retUsage |= wgpu::TextureUsage::TransientAttachment;
    }
    // NOTE: Unused wgpu flags:
+    //  StorageBinding
    //  StorageAttachment

    // NOTE: Unused Filament flags:
@@ -295,19 +283,16 @@ 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 },
-      mViewFormat{ fToWGPUTextureFormat(format) },
-      mSupportsMultipleMipLevels{ levels > 1 &&
-                                  supportsMultipleMipLevelsViaStorageBinding(mViewFormat) },
-      mWebGPUFormat{ mSupportsMultipleMipLevels
-                             ? storageBindingCompatibleFormatForViewFormat(mViewFormat)
-                             : mViewFormat },
+      mWebGPUFormat{ fToWGPUTextureFormat(format) },
      mAspect{ fToWGPUTextureViewAspect(usage, format) },
-      mWebGPUUsage{ fToWGPUTextureUsage(usage, samples, mSupportsMultipleMipLevels) },
-      mViewUsage{ fToWGPUTextureUsage(usage, samples, false) },
+      mWebGPUUsage{ fToWGPUTextureUsage(usage, samples) },
      mBlockWidth{ filament::backend::getBlockWidth(format) },
-      mBlockHeight{ filament::backend::getBlockHeight(format) },
-      mDefaultMipLevel{ 0 },
-      mDefaultBaseArrayLayer{ 0 } {
+      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;
+    }
+
    assert_invariant(
            samples == 1 ||
            samples == 4 &&
@@ -315,7 +300,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");
-    const wgpu::TextureDescriptor textureDescriptor{
+    wgpu::TextureDescriptor textureDescriptor{
        .label = getUserTextureLabel(samplerType),
        .usage = mWebGPUUsage,
        .dimension = toWebGPUTextureDimension(samplerType),
@@ -323,9 +308,21 @@ WebGPUTexture::WebGPUTexture(const SamplerType samplerType, const uint8_t levels
        .format = mWebGPUFormat,
        .mipLevelCount = levels,
        .sampleCount = samples,
-        .viewFormatCount = 1,
-        .viewFormats = &mViewFormat,
+        // TODO Is this fine? Could do all-the-things, a naive mapping or get something from
+        // Filament
+        .viewFormatCount = 0,
+        .viewFormats = nullptr,
    };
+
+    //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");
@@ -336,41 +333,23 @@ 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 },
-      mViewFormat{ src->mViewFormat },
-      mSupportsMultipleMipLevels{ src->mSupportsMultipleMipLevels },
+      mTexture{ src->mTexture },
      mWebGPUFormat{ src->mWebGPUFormat },
      mAspect{ src->mAspect },
      mWebGPUUsage{ src->mWebGPUUsage },
-      mViewUsage{ src->mViewUsage },
+      mArrayLayerCount{ src->mArrayLayerCount },
      mBlockWidth{ src->mBlockWidth },
      mBlockHeight{ src->mBlockHeight },
-      mArrayLayerCount{ src->mArrayLayerCount },
-      mTexture{ src->mTexture },
+      mDefaultTextureView{ makeTextureView(baseLevel, levelCount, 0, src->mArrayLayerCount,
+              src->target) },
      mDefaultMipLevel{ baseLevel },
-      mDefaultBaseArrayLayer{ src->mArrayLayerCount },
-      mDefaultTextureView{ makeTextureView(mDefaultMipLevel, levelCount, 0, mDefaultBaseArrayLayer,
-              src->target) } {}
-
-bool WebGPUTexture::supportsMultipleMipLevelsViaStorageBinding(const wgpu::TextureFormat format) {
-    return storageBindingCompatibleFormatForViewFormat(format) != wgpu::TextureFormat::Undefined;
-}
+      mDefaultBaseArrayLayer{ src->mArrayLayerCount } {}

 wgpu::TextureView WebGPUTexture::getOrMakeTextureView(const uint8_t mipLevel,
        const uint32_t arrayLayer) {
@@ -569,23 +548,17 @@ 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 {
-#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{
+    wgpu::TextureViewDescriptor textureViewDescriptor{
        .label = getUserTextureViewLabel(target),
-        .format = mViewFormat,
+        .format = mCompatFormat,
        .dimension = toWebGPUTextureViewDimension(samplerType),
        .baseMipLevel = baseLevel,
        .mipLevelCount = levelCount,
        .baseArrayLayer = baseArrayLayer,
        .arrayLayerCount = arrayLayerCount,
        .aspect = mAspect,
-        .usage = mViewUsage };
+        .usage = mWebGPUUsage };
+    textureViewDescriptor.usage &= (~wgpu::TextureUsage::StorageBinding);
    wgpu::TextureView textureView = mTexture.CreateView(&textureViewDescriptor);
    FILAMENT_CHECK_POSTCONDITION(textureView)
            << "Failed to create texture view " << textureViewDescriptor.label;
@@ -47,46 +47,30 @@ public:

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

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

    [[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:
-    // 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;
+    // 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;
    // 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;
-    wgpu::TextureUsage mViewUsage = wgpu::TextureUsage::None;
+    uint32_t mArrayLayerCount = 1;
    size_t mBlockWidth = 0;
    size_t mBlockHeight = 0;
-    uint32_t mArrayLayerCount = 1;
-    wgpu::Texture mTexture = nullptr;
+    wgpu::TextureView mDefaultTextureView = 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,6 +87,7 @@ 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,
 };
@@ -249,17 +250,18 @@ 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";
+        FWGPU_LOGW << "Failed to get WebGPU instance supported WGSL language features"
+                   << utils::io::endl;
    } else {
        FWGPU_LOGI << "WebGPU instance supported WGSL language features ("
-                   << supportedWGSLLanguageFeatures.featureCount << "):";
+                   << supportedWGSLLanguageFeatures.featureCount << "):" << utils::io::endl;
        if (supportedWGSLLanguageFeatures.featureCount > 0 &&
                supportedWGSLLanguageFeatures.features != nullptr) {
            std::for_each(supportedWGSLLanguageFeatures.features,
                    supportedWGSLLanguageFeatures.features +
                            supportedWGSLLanguageFeatures.featureCount,
                    [](wgpu::WGSLLanguageFeatureName const featureName) {
-                        FWGPU_LOGI << "  " << featureName;
+                        FWGPU_LOGI << "  " << featureName << utils::io::endl;
                    });
        }
    }
@@ -271,7 +273,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";
+    FWGPU_LOGI << "setting on toggle enable_immediate_error_handling" << utils::io::endl;
 #endif
    /**
     * Have the un-captured error callback invoked immediately when an error occurs, rather than
@@ -315,7 +317,7 @@ void printLimit(std::string_view name, const std::variant<uint32_t, uint64_t> va
    if (undefined) {
        FWGPU_LOGI << "UNDEFINED";
    }
-    FWGPU_LOGI << "";
+    FWGPU_LOGI << utils::io::endl;
 }
 #endif// FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)

@@ -402,23 +404,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;
+    FWGPU_LOGI << "Selected WebGPU adapter info: " << details << utils::io::endl;
    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;
+                    FWGPU_LOGI << "  " << featureName << utils::io::endl;
                });
    }
    wgpu::Limits supportedLimits{};
    if (!details.adapter.GetLimits(&supportedLimits)) {
-        FWGPU_LOGW << "Failed to get WebGPU adapter supported limits";
+        FWGPU_LOGW << "Failed to get WebGPU adapter supported limits" << utils::io::endl;
    } else {
-        FWGPU_LOGI << "WebGPU adapter supported limits:";
+        FWGPU_LOGI << "WebGPU adapter supported limits:" << utils::io::endl;
        printLimits(supportedLimits);
    }
 }
@@ -445,14 +447,14 @@ struct AdapterDetailsHash final {
                })) {
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
        FWGPU_LOGI << "WebGPU adapter " << details
-                   << " does not have the minimum required features.";
-        FWGPU_LOGI << "Missing required feature(s): ";
+                   << " does not have the minimum required features." << utils::io::endl;
+        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 << "";
+        FWGPU_LOGI << utils::io::endl;
 #endif
        return false;
    }
@@ -461,7 +463,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 << ")";
+        FWGPU_LOGI << " (for WebGPU adapter " << details << ")" << utils::io::endl;
 #endif
        return false;
    }
@@ -517,9 +519,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:";
+    FWGPU_LOGI << compatibleAdapters.size() << " WebGPU adapter(s) found:" << utils::io::endl;
    for (auto& details: compatibleAdapters) {
-        FWGPU_LOGI << "  WebGPU adapter: " << details;
+        FWGPU_LOGI << "  WebGPU adapter: " << details << utils::io::endl;
    }
 #endif
    return compatibleAdapters;
@@ -581,19 +583,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;
+                    FWGPU_LOGI << "  " << featureName << utils::io::endl;
                });
    }
    wgpu::Limits supportedLimits{};
    if (!device.GetLimits(&supportedLimits)) {
-        FWGPU_LOGW << "Failed to get WebGPU supported device limits";
+        FWGPU_LOGW << "Failed to get WebGPU supported device limits" << utils::io::endl;
    } else {
-        FWGPU_LOGI << "WebGPU device supported limits:";
+        FWGPU_LOGI << "WebGPU device supported limits:" << utils::io::endl;
        printLimits(supportedLimits);
    }
 }
@@ -634,7 +636,8 @@ 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)";
+                    FWGPU_LOGD << "WebGPU device lost due to being destroyed (expected)"
+                               << utils::io::endl;
 #endif
                    return;
                }
@@ -646,7 +649,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;
+                           << message.data << utils::io::endl;
            });
    wgpu::Device device = nullptr;
    wgpu::WaitStatus status = mInstance.WaitAny(
@@ -699,7 +702,8 @@ 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.";
+                      "sharedContext was provided, but it will be ignored."
+                   << utils::io::endl;
    }
    return WebGPUDriver::create(*this, driverConfig);
 }
@@ -84,8 +84,6 @@ 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,7 +42,6 @@ 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,8 +41,6 @@ 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,9 +31,7 @@ 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,20 +215,18 @@ 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(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
+        // TODO: If any shaders need backend/shader language specific shaders rather than transpiled
+        // versions of the GLSL shader, check environment.
    }
    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{ .vertexLanguage = filament::backend::ShaderLanguage::ESSL3,
-                    .vertexShader = vertex->withUniform(*uniform),
-                    .fragmentLanguage = filament::backend::ShaderLanguage::ESSL3,
-                    .fragmentShader = fragment->withUniform(*uniform),
-                    .uniforms = GetUniformConfig(request.mUniformType) });
+        return Shader(
+                api, cleanup, ShaderConfig{
+                        vertex->withUniform(*uniform), fragment->withUniform(*uniform),
+                        GetUniformConfig(request.mUniformType)}
+        );
    }
    abort();
 }
@@ -25,7 +25,7 @@
 #include <backend/Handle.h>

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

 #include <fstream>
 #include <string>
@@ -137,7 +137,8 @@ TEST_F(BackendTest, FeedbackLoops) {
        // Create a RenderTarget for each miplevel.
        Handle<HwRenderTarget> renderTargets[kNumLevels];
        for (uint8_t level = 0; level < kNumLevels; level++) {
-            LOG(INFO) << "Level " << int(level) << ": " << (kTexWidth >> level) << "x" << (kTexHeight >> level);
+            slog.i << "Level " << int(level) << ": " <<
+                    (kTexWidth >> level) << "x" << (kTexHeight >> level) << io::endl;
            renderTargets[level] = cleanup.add(api.createRenderTarget( TargetBufferFlags::COLOR,
                    kTexWidth >> level, kTexHeight >> level, 1, 0, { texture, level, 0 }, {}, {}));
        }
@@ -139,6 +139,30 @@ 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;
@@ -311,6 +335,9 @@ 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,11 +112,13 @@ void FrameInfoManager::beginFrame(DriverApi& driver, Config const& config, uint3
        using namespace utils;
        auto h = getFrameInfoHistory(1);
        if (!h.empty()) {
-            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;
+            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;
        }
    }
 }
@@ -34,7 +34,7 @@

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

        uniformsNeedUpdating = true;

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

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

        if (UTILS_UNLIKELY(offset + lightCount >= RECORD_BUFFER_ENTRY_COUNT)) {
-            DLOG(INFO) << "out of space: " << i << ", at " << offset;
+#ifndef NDEBUG
+            slog.d << "out of space: " << i << ", at " << offset << io::endl;
+#endif
            // 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/JobSystem.h>
-#include <utils/Panic.h>
-#include <utils/Range.h>
-#include <utils/Slice.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 <algorithm>
 #include <functional>
@@ -408,8 +408,8 @@ RenderPass::Command* RenderPass::instanceify(DriverApi& driver,
    }

    if (UTILS_UNLIKELY(firstSentinel)) {
-        // DLOG(INFO) << "auto-instancing, saving " << drawCallsSavedCount << " draw calls, out of "
-        //            << count;
+        //slog.d << "auto-instancing, saving " << drawCallsSavedCount << " draw calls, out of "
+        //       << count << io::endl;
        // 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,16 +291,17 @@ 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);
-    DLOG(INFO) << "# entries=" << mTextureCache.size() << ", sz=" << (float) mCacheSize * MiB
-               << " MiB"
-               << ", max=" << (float) mCacheSizeHiWaterMark * MiB << " MiB";
+    slog.d  << "# entries=" << mTextureCache.size()
+            << ", sz=" << (float)mCacheSize * MiB << " MiB"
+            << ", max=" << (float)mCacheSizeHiWaterMark * MiB << " MiB"
+            << io::endl;
    if (!brief) {
        for (auto const& it : mTextureCache) {
            auto w = it.first.width;
            auto h = it.first.height;
            auto f = FTexture::getFormatSize(it.first.format);
-            DLOG(INFO) << it.first.name << ": w=" << w << ", h=" << h << ", f=" << f
-                       << ", sz=" << (float) it.second.size * MiB;
+            slog.d << it.first.name << ": w=" << w << ", h=" << h << ", f=" << f << ", sz="
+                   << (float)it.second.size * MiB << io::endl;
        }
    }
 }
@@ -308,7 +309,7 @@ void ResourceAllocator::dump(bool const brief) const noexcept {
 ResourceAllocator::CacheContainer::iterator
 ResourceAllocator::purge(
        CacheContainer::iterator const& pos) {
-    // DLOG(INFO) << "purging " << pos->second.handle.getId() << ", age=" << pos->second.age;
+    //slog.d << "purging " << pos->second.handle.getId() << ", age=" << pos->second.age << io::endl;
    mBackend.destroyTexture(pos->second.handle);
    mCacheSize -= pos->second.size;
    return mTextureCache.erase(pos);
@@ -16,7 +16,7 @@

 #include "ResourceList.h"

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

 #include <algorithm>

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

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

 using namespace utils;
@@ -36,7 +36,10 @@ FCameraManager::~FCameraManager() noexcept = default;
 void FCameraManager::terminate(FEngine& engine) noexcept {
    auto& manager = mManager;
    if (!manager.empty()) {
-        DLOG(INFO) << "cleaning up " << manager.getComponentCount() << " leaked Camera components";
+#ifndef NDEBUG
+        slog.d << "cleaning up " << manager.getComponentCount()
+               << " leaked Camera components" << io::endl;
+#endif
        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,7 +230,8 @@ void FLightManager::terminate() noexcept {
    auto& manager = mManager;
    if (!manager.empty()) {
 #ifndef NDEBUG
-        DLOG(INFO) << "cleaning up " << manager.getComponentCount() << " leaked Light components";
+        slog.d << "cleaning up " << manager.getComponentCount()
+               << " leaked Light components" << io::endl;
 #endif
        while (!manager.empty()) {
            Instance const ci = manager.end() - 1;
@@ -39,15 +39,14 @@
 #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/Logger.h>
+#include <utils/ostream.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>
@@ -397,11 +396,10 @@ void RenderableManager::BuilderDetails::processBoneIndicesAndWights(Engine& engi
                }
 #ifndef NDEBUG
                else {
-                    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.";
+                    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;
                }
 #endif

@@ -500,9 +498,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) {
-            LOG(WARNING) << "[entity=" << entity.getId() << ", primitive @ " << i
-                         << "] missing required attributes (" << required
-                         << "), declared=" << declared;
+            slog.w << "[entity=" << entity.getId() << ", primitive @ " << i
+                   << "] missing required attributes ("
+                   << required << "), declared=" << declared << io::endl;
        }

        // we have at least one valid primitive
@@ -728,8 +726,10 @@ void FRenderableManager::destroy(Entity const e) noexcept {
 void FRenderableManager::terminate() noexcept {
    auto& manager = mManager;
    if (!manager.empty()) {
-        DLOG(INFO) << "cleaning up " << manager.getComponentCount()
-                   << " leaked Renderable components";
+#ifndef NDEBUG
+        slog.d << "cleaning up " << manager.getComponentCount()
+               << " leaked Renderable components" << io::endl;
+#endif
        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)) {
-                LOG(WARNING) << "[instance=" << instance.asValue() << ", primitive @ "
-                             << primitiveIndex << "] missing required attributes (" << required
-                             << "), declared=" << declared;
+                slog.w << "[instance=" << instance.asValue() << ", primitive @ " << primitiveIndex
+                       << "] missing required attributes ("
+                       << required << "), declared=" << declared << io::endl;
            }
        }
    }
@@ -868,7 +868,7 @@ FColorGrading::FColorGrading(FEngine& engine, const Builder& builder) {
    }

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

    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/Logger.h>
+#include <utils/Log.h>
+#include <utils/ostream.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) {
-            LOG(ERROR) << "Selected backend not supported in this build.";
+            slog.e << "Selected backend not supported in this build." << io::endl;
            delete instance;
            return nullptr;
        }
@@ -280,8 +280,8 @@ FEngine::FEngine(Builder const& builder) :
    // (it may not be the case)
    mJobSystem.adopt();

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

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

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


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

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

@@ -221,10 +217,10 @@ Material* Material::Builder::build(Engine& engine) const {
            if (materialStereoscopicType != engineStereoscopicType) {
                CString name;
                materialParser->getName(&name);
-                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 << ".";
+                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;
            }
        }
    }
@@ -382,12 +378,9 @@ 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)))) {
-            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";
+            slog.w << io::hex << "FMaterial::invalidate("
+                   << +variantMask << ", " << +variantValue
+                   << ") would corrupt the depth variant cache" << io::endl;
        }
        variantMask |= Variant::DEP;
        variantValue &= ~Variant::DEP;
@@ -413,8 +406,8 @@ void FMaterial::terminate(FEngine& engine) {
                    << pos->second.size() << " instances still alive.";
        } else {
            if (UTILS_UNLIKELY(!pos->second.empty())) {
-                LOG(ERROR) << "destroying material \"" << this->getName().c_str_safe() << "\" but "
-                           << pos->second.size() << " instances still alive.";
+                slog.e << "destroying material \"" << this->getName().c_str_safe() << "\" but "
+                              << pos->second.size() << " instances still alive." << io::endl;
            }
        }
    }
@@ -778,7 +771,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();
-    DLOG(INFO) << "Applying edits to " << (name ? name : "(untitled)");
+    slog.d << "Applying edits to " << (name ? name : "(untitled)") << io::endl;
    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())) {
-        LOG(WARNING) << "Parent material does not have double-sided capability.";
+        slog.w << "Parent material does not have double-sided capability." << io::endl;
        return;
    }
    setParameter("_doubleSided", doubleSided);
@@ -385,18 +385,19 @@ void FMaterialInstance::use(FEngine::DriverApi& driver) const {
    if (UTILS_UNLIKELY(mMissingSamplerDescriptors.any())) {
        std::call_once(mMissingSamplersFlag, [this] {
            auto const& list = mMaterial->getSamplerInterfaceBlock().getSamplerInfoList();
-            LOG(WARNING) << "sampler parameters not set in MaterialInstance \""
-                         << mName.c_str_safe() << "\" or Material \""
-                         << mMaterial->getName().c_str_safe() << "\":";
+            slog.w << "sampler parameters not set in MaterialInstance \""
+                   << mName.c_str_safe() << "\" or Material \""
+                   << mMaterial->getName().c_str_safe() << "\":\n";
            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())) {
-                    LOG(WARNING) << "[" << +binding << "] " << pos->name.c_str();
+                    slog.w << "[" << +binding << "] " << pos->name.c_str() << '\n';
                }
            });
+            flush(slog.w);
        });
        mMissingSamplerDescriptors.clear();
    }
@@ -52,12 +52,12 @@

 #include <private/utils/Tracing.h>

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

 #include <chrono>
 #include <limits>
@@ -155,10 +155,14 @@ 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);
-    DLOG(INFO) << "Renderer: Commands High watermark " << wm / 1024 << " KiB (" << wmpct << "%), "
-               << wm / sizeof(Command) << " commands, " << sizeof(Command) << " bytes/command";
+    slog.d << "Renderer: Commands High watermark "
+    << wm / 1024 << " KiB (" << wmpct << "%), "
+    << wm / sizeof(Command) << " commands, " << sizeof(Command) << " bytes/command"
+    << io::endl;
+#endif
 }

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

    // TODO: change the following to an assert when client call sites have addressed the issue.
    if (!renderTarget->supportsReadPixels()) {
-        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.";
+        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;
    }

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

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

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

 #include "details/Texture.h"

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

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

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

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

    graph.cull();

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

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

    graph.cull();

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

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

    graph.cull();

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

    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.1"
+  spec.version = "1.61.0"
  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.1/filament-v1.61.1-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.61.0/filament-v1.61.0-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.43.0 is used to generate the Xcode
+[XcodeGen](https://github.com/yonaskolb/XcodeGen) version 2.29.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,8 +20,7 @@ targetTemplates:
        settings:
            base:
                OTHER_LDFLAGS: ["-lfilament", "-lbackend", "-lfilaflat", "-lktxreader",
-                                "-lfilabridge", "-lutils", "-lsmol-v", "-lgeometry", "-libl",
-                                "-labseil"]
+                                "-lfilabridge", "-lutils", "-lsmol-v", "-lgeometry", "-libl"]
                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 = 54;
+	objectVersion = 51;
 	objects = {

 /* Begin PBXBuildFile section */
@@ -81,8 +81,6 @@
 			dependencies = (
 			);
 			name = "backend-test";
-			packageProductDependencies = (
-			);
 			productName = "backend-test";
 			productReference = 13DDE7723EC1A6EFCA4D2D58 /* backend-test.app */;
 			productType = "com.apple.product-type.application";
@@ -93,13 +91,12 @@
 		8A7A83D59A7827D3335343C2 /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
-				BuildIndependentTargetsInParallel = YES;
-				LastUpgradeCheck = 1430;
+				LastUpgradeCheck = 1200;
 				TargetAttributes = {
 				};
 			};
 			buildConfigurationList = E89E1EEA671E49DBAC9D5A9C /* Build configuration list for PBXProject "backend-test" */;
-			compatibilityVersion = "Xcode 14.0";
+			compatibilityVersion = "Xcode 11.0";
 			developmentRegion = en;
 			hasScannedForEncodings = 0;
 			knownRegions = (
@@ -107,8 +104,6 @@
 				en,
 			);
 			mainGroup = 3D2B936C924E0DB70941EE6D;
-			minimizedProjectReferenceProxies = 1;
-			preferredProjectObjectVersion = 54;
 			projectDirPath = "";
 			projectRoot = "";
 			targets = (
@@ -254,7 +249,6 @@
 					"-lsmol-v",
 					"-lgeometry",
 					"-libl",
-					"-labseil",
 					"-lfilamat",
 					"-force_load ../../../out/ios-debug/filament/lib/arm64/libbackend_test.a",
 				);
@@ -362,7 +356,6 @@
 					"-lsmol-v",
 					"-lgeometry",
 					"-libl",
-					"-labseil",
 					"-lfilamat",
 					"-force_load ../../../out/ios-debug/filament/lib/arm64/libbackend_test.a",
 				);
@@ -463,7 +456,6 @@
 					"-lsmol-v",
 					"-lgeometry",
 					"-libl",
-					"-labseil",
 					"-lfilamat",
 					"-force_load ../../../out/ios-debug/filament/lib/arm64/libbackend_test.a",
 				);
@@ -509,7 +501,6 @@
 					"-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 = "1430"
+   LastUpgradeVersion = "1200"
   version = "1.7">
   <BuildAction
      parallelizeBuildables = "YES"
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
bridgewaterrobbie	c611b4df6f	Fixup shader code	2025-06-10 18:04:41 -04:00
bridgewaterrobbie	6b91d7ca2d	Reduce the number of prepared mipmap pipelines- this should be configurable really if we want to preserve this logic in the long run.	2025-06-10 16:54:28 -04:00
bridgewaterrobbie	df264372d9	Add check for if the format (Or non srgb format) is storage compatible	2025-06-10 16:54:03 -04:00
bridgewaterrobbie	bf9435d0fd	Never merge: Arbitrarilly raise max storage texutres per stage for easier tinkering, though this s houldn't be relied upon, spec limit is 4	2025-06-10 16:18:17 -04:00
bridgewaterrobbie	726177fead	Hacky version of playing with formats and usages.	2025-06-10 15:58:02 -04:00
bridgewaterrobbie	2ef01ae1e8	Try to go in multiple passes to avoid hitting limits	2025-06-10 15:57:48 -04:00
bridgewaterrobbie	1374e8acef	tinker2	2025-06-10 14:20:27 -04:00
bridgewaterrobbie	622beb211a	WIP: Use converted JS library for compute pass mipmap generation	2025-06-10 14:16:57 -04:00