webgpu: fix logging

Author: AndyHovingh

filament/backend/src/webgpu/WebGPUStrings.h

@@ -21,50 +21,27 @@
 
 #include <backend/DriverEnums.h>
 
-#include <utils/Panic.h>
-#include <utils/ostream.h>
-
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
 #include <dawn/webgpu_cpp_print.h>
-#endif
 #include <webgpu/webgpu_cpp.h>
 
 #include <cstdint>
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
 #include <sstream>
-#endif
+#include <string>
 #include <string_view>
 
 /**
  * Reusable set of convenience functions for strings -- generally string views, literals, &
- * streaming -- used in the WebGPU backend
+ * strings -- used in the WebGPU backend
  */
 
 namespace filament::backend {
 
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-/**
- * Convenience template to print WGPU types (which don't support Filament's utils::io::ostream)
- * @tparam WebGPUPrintable e.g. wgpu::FeatureName type
- * @param out stream to print to
- * @param printable the instance to print
- * @return the stream printed to
- *
- * Example usage (because including the template operator override itself does not compile):
- * #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
- * utils::io::ostream& operator<<(utils::io::ostream& out,
- *       const wgpu::FeatureName featureName) noexcept {
- *   return streamInsertWebGPUPrintable(out, featureName);
- * }
- * #endif
- */
 template<typename WebGPUPrintable>
-utils::io::ostream& streamInsertWebGPUPrintable(utils::io::ostream& out,
-        const WebGPUPrintable printable) {
-    std::stringstream printableStream;
-    printableStream << printable;
-    out << printableStream.str();
-    return out;
+[[nodiscard]] inline std::string webGPUPrintableToString(const WebGPUPrintable printable) {
+    std::stringstream out;
+    out << printable;
+    return out.str();
 }
 #endif
 
@@ -115,54 +92,25 @@ utils::io::ostream& streamInsertWebGPUPrintable(utils::io::ostream& out,
     }
 }
 
-/**
- * Convenience template to print wgpu::RequestAdapterOptions
- * @tparam STREAM_TYPE useful namely for streaming to either an utils::io::ostream OR
- * utils::details::PanicStream, but also for any kind of stream
- * @param out stream to print to
- * @param options instance to be printed
- * @return stream printed to
- *
- * Example usage (because including the template operator override itself does not compile):
- * template<typename STREAM_TYPE>
- * STREAM_TYPE& operator<<(STREAM_TYPE& out, wgpu::RequestAdapterOptions const& options) noexcept {
- *   return streamInsertRequestAdapterOptions(out, options);
- * }
- */
-template<typename STREAM_TYPE>
-STREAM_TYPE& streamInsertRequestAdapterOptions(STREAM_TYPE& out,
-        wgpu::RequestAdapterOptions const& options) noexcept {
+[[nodiscard]] inline std::string adapterOptionsToString(
+        wgpu::RequestAdapterOptions const& options) {
+    std::stringstream out;
     out << "power preference " << powerPreferenceToString(options.powerPreference)
         << " force fallback adapter " << bool(options.forceFallbackAdapter) << " backend type "
         << backendTypeToString(options.backendType);
-    return out;
+    return out.str();
 }
 
-/**
- * Convenience template to print wgpu::AdapterInfo
- * @tparam STREAM_TYPE useful namely for streaming to either an utils::io::ostream OR
- * utils::details::PanicStream, but also for any kind of stream
- * @param out stream to print to
- * @param options instance to be printed
- * @return stream printed to
- *
- * Example usage (because including the template operator override itself does not compile):
- * template<typename STREAM_TYPE>
- * STREAM_TYPE& operator<<(STREAM_TYPE& out, wgpu::AdapterInfo const& info) noexcept {
- *   return streamInsertRequestAdapterInfo(out, info);
- * }
- */
-template<class STREAM_TYPE>
-STREAM_TYPE& streamInsertRequestAdapterInfo(STREAM_TYPE& out,
-        wgpu::AdapterInfo const& info) noexcept {
+[[nodiscard]] std::string adapterInfoToString(wgpu::AdapterInfo const& info) {
+    std::stringstream out;
     out << "vendor (" << info.vendorID << ") '" << info.vendor
         << "' device (" << info.deviceID << ") '" << info.device
         << "' adapter " << adapterTypeToString(info.adapterType)
         << " backend " << backendTypeToString(info.backendType)
         << " architecture '" << info.architecture
         << "' subgroupMinSize " << info.subgroupMinSize
         << " subgroupMaxSize " << info.subgroupMaxSize;
-    return out;
+    return out.str();
 }
 
 [[nodiscard]] constexpr std::string_view deviceLostReasonToString(
@@ -175,7 +123,7 @@ STREAM_TYPE& streamInsertRequestAdapterInfo(STREAM_TYPE& out,
     }
 }
 
-[[nodiscard]] constexpr std::string_view filamentShaderStageToString(ShaderStage stage) {
+[[nodiscard]] constexpr std::string_view filamentShaderStageToString(const ShaderStage stage) {
     switch (stage) {
         case ShaderStage::VERTEX:   return "vertex";
         case ShaderStage::FRAGMENT: return "fragment";

filament/backend/src/webgpu/WebGPUSwapChain.cpp

@@ -24,80 +24,62 @@
 #include "backend/DriverEnums.h"
 
 #include <utils/Panic.h>
-#include <utils/ostream.h>
 
 #include <webgpu/webgpu_cpp.h>
 
 #include <algorithm>
 #include <cstdint>
 
+namespace filament::backend {
+
 namespace {
 
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-utils::io::ostream& operator<<(utils::io::ostream& out, const wgpu::TextureFormat format) noexcept {
-    return filament::backend::streamInsertWebGPUPrintable(out, format);
-}
-
-utils::io::ostream& operator<<(utils::io::ostream& out,
-        const wgpu::TextureUsage textureUsage) noexcept {
-    return filament::backend::streamInsertWebGPUPrintable(out, textureUsage);
-}
-
-utils::io::ostream& operator<<(utils::io::ostream& out,
-        const wgpu::PresentMode presentMode) noexcept {
-    return filament::backend::streamInsertWebGPUPrintable(out, presentMode);
-}
-
-utils::io::ostream& operator<<(utils::io::ostream& out,
-        const wgpu::CompositeAlphaMode alphaMode) noexcept {
-    return filament::backend::streamInsertWebGPUPrintable(out, alphaMode);
-}
-
 void printSurfaceCapabilitiesDetails(wgpu::SurfaceCapabilities const& capabilities) {
     FWGPU_LOGI << "WebGPU surface capabilities:";
-    FWGPU_LOGI << "  surface usages: " << capabilities.usages;
+    FWGPU_LOGI << "  surface usages: " << webGPUPrintableToString(capabilities.usages);
     FWGPU_LOGI << "  surface formats (" << capabilities.formatCount << "):";
     if (capabilities.formatCount > 0 && capabilities.formats != nullptr) {
         std::for_each(capabilities.formats, capabilities.formats + capabilities.formatCount,
                 [](wgpu::TextureFormat const format) {
-                    FWGPU_LOGI << "    " << format;
+                    FWGPU_LOGI << "    " << webGPUPrintableToString(format);
                 });
     }
     FWGPU_LOGI << "  surface present modes (" << capabilities.presentModeCount << "):";
     if (capabilities.presentModeCount > 0 && capabilities.presentModes != nullptr) {
         std::for_each(capabilities.presentModes,
                 capabilities.presentModes + capabilities.presentModeCount,
                 [](wgpu::PresentMode const presentMode) {
-                    FWGPU_LOGI << "    " << presentMode;
+                    FWGPU_LOGI << "    " << webGPUPrintableToString(presentMode);
                 });
     }
     FWGPU_LOGI << "  surface alpha modes (" << capabilities.alphaModeCount << "):";
     if (capabilities.alphaModeCount > 0 && capabilities.alphaModes != nullptr) {
         std::for_each(capabilities.alphaModes,
                 capabilities.alphaModes + capabilities.alphaModeCount,
                 [](wgpu::CompositeAlphaMode const alphaMode) {
-                    FWGPU_LOGI << "    " << alphaMode;
+                    FWGPU_LOGI << "    " << webGPUPrintableToString(alphaMode);
                 });
     }
 }
 
 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 format: " << webGPUPrintableToString(config.format);
+    FWGPU_LOGI << "  surface usage: " << webGPUPrintableToString(config.usage);
     FWGPU_LOGI << "  surface view formats (" << config.viewFormatCount << "):";
     if (config.viewFormatCount > 0 && config.viewFormats != nullptr) {
         std::for_each(config.viewFormats, config.viewFormats + config.viewFormatCount,
                 [](wgpu::TextureFormat const viewFormat) {
-                    FWGPU_LOGI << "    " << viewFormat;
+                    FWGPU_LOGI << "    " << webGPUPrintableToString(viewFormat);
                 });
     }
-    FWGPU_LOGI << "  surface alpha mode: " << config.alphaMode;
+    FWGPU_LOGI << "  surface alpha mode: " << webGPUPrintableToString(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 present mode: " << webGPUPrintableToString(config.presentMode);
+    FWGPU_LOGI << "WebGPU selected depth format: " << webGPUPrintableToString(depthFormat);
 }
 #endif// FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
 
@@ -257,8 +239,6 @@ void initConfig(wgpu::SurfaceConfiguration& config, wgpu::Device const& device,
 
 }// namespace
 
-namespace filament::backend {
-
 WebGPUSwapChain::WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Extent2D const& surfaceSize,
         wgpu::Adapter const& adapter, wgpu::Device const& device, uint64_t flags)
     : mDevice(device),

filament/backend/src/webgpu/WebGPUTexture.cpp

@@ -25,7 +25,6 @@
 #include <utils/BitmaskEnum.h>
 #include <utils/Panic.h>
 #include <utils/debug.h>
-#include <utils/ostream.h>
 
 #include <webgpu/webgpu_cpp.h>
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
@@ -343,8 +342,7 @@ WebGPUTexture::WebGPUTexture(const SamplerType samplerType, const uint8_t levels
         std::stringstream textureFormatStream;
         textureFormatStream << mWebGPUFormat;
         FWGPU_LOGD << "Texture '" << textureDescriptor.label << "' has view format "
-                   << viewFormatStream.str() << " and texture format " << textureFormatStream.str()
-                   << utils::io::endl;
+                   << viewFormatStream.str() << " and texture format " << textureFormatStream.str();
     }
 #endif
 }
@@ -470,90 +468,76 @@ wgpu::TextureFormat WebGPUTexture::fToWGPUTextureFormat(TextureFormat const& fFo
             // No direct mapping in wgpu. Could potentially map to RGBA8Unorm
             // and discard the alpha and lower precision.
             FWGPU_LOGW << "Requested Filament texture format RGB565 but getting "
-                          "wgpu::TextureFormat::Undefined (no direct mapping in wgpu)"
-                       << utils::io::endl;
+                          "wgpu::TextureFormat::Undefined (no direct mapping in wgpu)";
             return wgpu::TextureFormat::Undefined;
         case TextureFormat::RGB9_E5: return wgpu::TextureFormat::RGB9E5Ufloat;
         case TextureFormat::RGB5_A1:
             // No direct mapping in wgpu. Could potentially map to RGBA8Unorm
             // and handle the packing/unpacking in shaders.
             FWGPU_LOGW << "Requested Filament texture format RGB5_A1 but getting "
-                          "wgpu::TextureFormat::Undefined (no direct mapping in wgpu)"
-                       << utils::io::endl;
+                          "wgpu::TextureFormat::Undefined (no direct mapping in wgpu)";
             return wgpu::TextureFormat::Undefined;
         case TextureFormat::RGBA4:
             // No direct mapping in wgpu. Could potentially map to RGBA8Unorm
             // and handle the packing/unpacking in shaders.
             FWGPU_LOGW << "Requested Filament texture format RGBA4 but getting "
-                          "wgpu::TextureFormat::Undefined (no direct mapping in wgpu)"
-                       << utils::io::endl;
+                          "wgpu::TextureFormat::Undefined (no direct mapping in wgpu)";
             return wgpu::TextureFormat::Undefined;
         case TextureFormat::RGB8:
             FWGPU_LOGW << "Requested Filament texture format RGB8 but getting "
                           "wgpu::TextureFormat::RGBA8Unorm (no direct sRGB equivalent in wgpu "
-                          "without alpha)"
-                       << utils::io::endl;
+                          "without alpha)";
             return wgpu::TextureFormat::RGBA8Unorm;
         case TextureFormat::SRGB8:
             FWGPU_LOGW << "Requested Filament texture format SRGB8 but getting "
                           "wgpu::TextureFormat::RGBA8UnormSrgb (no direct sRGB equivalent in wgpu "
-                          "without alpha)"
-                       << utils::io::endl;
+                          "without alpha)";
             return wgpu::TextureFormat::RGBA8UnormSrgb;
         case TextureFormat::RGB8_SNORM:
             FWGPU_LOGW
                     << "Requested Filament texture format RGB8_SNORM but getting "
-                       "wgpu::TextureFormat::RGBA8Snorm (no direct mapping in wgpu without alpha)"
-                    << utils::io::endl;
+                       "wgpu::TextureFormat::RGBA8Snorm (no direct mapping in wgpu without alpha)";
             return wgpu::TextureFormat::RGBA8Snorm;
         case TextureFormat::RGB8UI:
             FWGPU_LOGW << "Requested Filament texture format RGB8UI but getting "
-                          "wgpu::TextureFormat::RGBA8Uint (no direct mapping in wgpu without alpha)"
-                       << utils::io::endl;
+                          "wgpu::TextureFormat::RGBA8Uint (no direct mapping in wgpu without alpha)";
             return wgpu::TextureFormat::RGBA8Uint;
         case TextureFormat::RGB8I:
             FWGPU_LOGW << "Requested Filament texture format RGB8I but getting "
-                          "wgpu::TextureFormat::RGBA8Sint (no direct mapping in wgpu without alpha)"
-                       << utils::io::endl;
+                          "wgpu::TextureFormat::RGBA8Sint (no direct mapping in wgpu without alpha)";
             return wgpu::TextureFormat::RGBA8Sint;
         case TextureFormat::R11F_G11F_B10F:          return wgpu::TextureFormat::RG11B10Ufloat;
         case TextureFormat::UNUSED:                  return wgpu::TextureFormat::Undefined;
         case TextureFormat::RGB10_A2:                return wgpu::TextureFormat::RGB10A2Unorm;
         case TextureFormat::RGB16F:
             FWGPU_LOGW
                     << "Requested Filament texture format RGB16F but getting "
-                       "wgpu::TextureFormat::RGBA16Float (no direct mapping in wgpu without alpha)"
-                    << utils::io::endl;
+                       "wgpu::TextureFormat::RGBA16Float (no direct mapping in wgpu without alpha)";
             return wgpu::TextureFormat::RGBA16Float;
         case TextureFormat::RGB16UI:
             FWGPU_LOGW
                     << "Requested Filament texture format RGB16UI but getting "
-                       "wgpu::TextureFormat::RGBA16Uint (no direct mapping in wgpu without alpha)"
-                    << utils::io::endl;
+                       "wgpu::TextureFormat::RGBA16Uint (no direct mapping in wgpu without alpha)";
             return wgpu::TextureFormat::RGBA16Uint;
         case TextureFormat::RGB16I:
             FWGPU_LOGW
                     << "Requested Filament texture format RGB16I but getting "
-                       "wgpu::TextureFormat::RGBA16Sint (no direct mapping in wgpu without alpha)"
-                    << utils::io::endl;
+                       "wgpu::TextureFormat::RGBA16Sint (no direct mapping in wgpu without alpha)";
             return wgpu::TextureFormat::RGBA16Sint;
         case TextureFormat::RGB32F:
             FWGPU_LOGW
                     << "Requested Filament texture format RGB32F but getting "
-                       "wgpu::TextureFormat::RGBA32Float (no direct mapping in wgpu without alpha)"
-                    << utils::io::endl;
+                       "wgpu::TextureFormat::RGBA32Float (no direct mapping in wgpu without alpha)";
             return wgpu::TextureFormat::RGBA32Float;
         case TextureFormat::RGB32UI:
             FWGPU_LOGW
                     << "Requested Filament texture format RGB32UI but getting "
-                       "wgpu::TextureFormat::RGBA32Uint (no direct mapping in wgpu without alpha)"
-                    << utils::io::endl;
+                       "wgpu::TextureFormat::RGBA32Uint (no direct mapping in wgpu without alpha)";
             return wgpu::TextureFormat::RGBA32Uint;
         case TextureFormat::RGB32I:
             FWGPU_LOGW
                     << "Requested Filament texture format RGB32I but getting "
-                       "wgpu::TextureFormat::RGBA32Sint (no direct mapping in wgpu without alpha)"
-                    << utils::io::endl;
+                       "wgpu::TextureFormat::RGBA32Sint (no direct mapping in wgpu without alpha)";
             return wgpu::TextureFormat::RGBA32Sint;
         case TextureFormat::DXT1_RGB:                return wgpu::TextureFormat::BC1RGBAUnorm;
         case TextureFormat::DXT1_RGBA:               return wgpu::TextureFormat::BC1RGBAUnorm;
@@ -573,7 +557,7 @@ wgpu::TextureView WebGPUTexture::makeTextureView(const uint8_t& baseLevel,
     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;
+                   << ") for which we cannot generate mip levels.";
     }
 #endif
     const wgpu::TextureViewDescriptor textureViewDescriptor{