basalt-win32 0.0.0-rc5

package/native/win32/Win32SkiaPeer.cpp

@@ -0,0 +1,358 @@
+#include "Win32SkiaPeer.h"
+
+#include "PlatformServices.h"
+#include "RnWin32View.h"
+#include "SkiaPictureViewComponent.h"
+#include "Win32SkiaModule.h"
+
+#include <windows.h>
+
+#include <d2d1.h>
+#include <wrl/client.h>
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkPixmap.h"
+#include "include/core/SkSurface.h"
+
+#include "RNSkPictureView.h"
+#include "RNSkView.h"
+
+#include <glog/logging.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <utility>
+
+namespace basalt {
+namespace {
+
+using Microsoft::WRL::ComPtr;
+
+// The surface a `<Canvas>` renders into, and the thing that draws it.
+//
+// Two interfaces on one object because they are two views of one buffer: the
+// package writes through `RNSkCanvasProvider` and the paint walk reads through
+// `RnWin32Painter`, and an object between them would only mean keeping two
+// pointers to the same pixels in step.
+//
+// Both halves run on the UI thread -- `renderToCanvas` arrives through the
+// platform context's `runOnMainThread`, `draw` from WM_PAINT -- so the buffer
+// needs no lock. That is checked rather than assumed; see renderToCanvas,
+// which is also where the package's Metal provider checks it.
+class Win32SkiaCanvas final : public RNSkia::RNSkCanvasProvider,
+                              public win32::RnWin32Painter {
+ public:
+  Win32SkiaCanvas(std::function<void()> requestRedraw,
+                  std::shared_ptr<RNSkia::RNSkPlatformContext> context,
+                  std::function<void()> requestRepaint)
+      : RNSkia::RNSkCanvasProvider(std::move(requestRedraw)),
+        context_(std::move(context)),
+        requestRepaint_(std::move(requestRepaint)) {}
+
+  // Replaced on every mutation rather than kept from the first one. A canvas
+  // that mounted before the host installed its repaint callback would
+  // otherwise hold an empty function for as long as it lives, render every
+  // frame perfectly and show none of them.
+  void setRequestRepaint(std::function<void()> requestRepaint) {
+    requestRepaint_ = std::move(requestRepaint);
+  }
+
+  // --- RNSkCanvasProvider ---------------------------------------------------
+  //
+  // "Scaled", in the package's vocabulary, means pixels rather than points:
+  // the Metal provider multiplies by the pixel density in setSize and reports
+  // the product here. Same here, so that `makeImageSnapshot` -- which builds
+  // an offscreen provider out of these two numbers -- gets the resolution it
+  // would have got on any other host.
+
+  int getWidth() override { return pixelWidth_; }
+
+  int getHeight() override { return pixelHeight_; }
+
+  bool renderToCanvas(const std::function<void(SkCanvas *)> &callback) override {
+    if (!isUiThread()) {
+      // Off the UI thread, a paint may already be reading the buffer, and
+      // drawing into it now would tear. Ask for a redraw and let it arrive on
+      // the thread that owns the pixels -- the answer the package's Metal
+      // provider gives when it finds itself off the main thread, and for the
+      // same reason.
+      _requestRedraw();
+      return false;
+    }
+    if (surface_ == nullptr) {
+      return false;
+    }
+    callback(surface_->getCanvas());
+    // The pixels changed, so the Direct2D copy of them is stale and the window
+    // is showing the frame before this one.
+    generation_++;
+    if (requestRepaint_) {
+      requestRepaint_();
+    }
+    return true;
+  }
+
+  // In points, as the package's own providers take it: the density is applied
+  // here rather than by the caller.
+  void setSize(int width, int height) {
+    const float density = context_->getPixelDensity();
+    const int pixelWidth =
+        std::max(0, static_cast<int>(std::lround(static_cast<float>(width) * density)));
+    const int pixelHeight =
+        std::max(0, static_cast<int>(std::lround(static_cast<float>(height) * density)));
+    if (pixelWidth == pixelWidth_ && pixelHeight == pixelHeight_) {
+      return;
+    }
+    pixelWidth_ = pixelWidth;
+    pixelHeight_ = pixelHeight;
+    surface_ = nullptr;
+    // A device bitmap is made for one size; the next draw makes another.
+    releaseDeviceBitmap();
+    if (pixelWidth_ > 0 && pixelHeight_ > 0) {
+      // N32Premul is premultiplied BGRA8888 on Windows, which is also the one
+      // pixel format a Direct2D bitmap takes here. The copy in `draw` is
+      // therefore a memcpy per row rather than a conversion -- worth stating,
+      // because the day that stops being true it will show up as a quietly
+      // halved frame rate and not as a compile error.
+      surface_ = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(pixelWidth_, pixelHeight_));
+      if (surface_ == nullptr) {
+        LOG(WARNING) << "react-native-skia: could not make a " << pixelWidth_ << "x"
+                     << pixelHeight_ << " surface for a <Canvas>";
+      } else {
+        // Cleared here and not only by the renderer. A raster surface is not
+        // promised zeroed pixels, and there is a window between this and the
+        // first picture -- a mount, a layout, a paint -- in which the canvas
+        // is drawn. Uninitialised memory is a striking thing to put on screen.
+        surface_->getCanvas()->clear(SK_ColorTRANSPARENT);
+      }
+    }
+    // The picture drawn at the old size has to be drawn again at this one, and
+    // nothing else would ask.
+    _requestRedraw();
+  }
+
+  // --- RnWin32Painter -------------------------------------------------------
+
+  void draw(ID2D1RenderTarget *target, float boxWidth, float boxHeight) override {
+    if (surface_ == nullptr || target == nullptr || pixelWidth_ <= 0 || pixelHeight_ <= 0) {
+      return;
+    }
+    if (boxWidth <= 0.0f || boxHeight <= 0.0f) {
+      return;
+    }
+    if (!ensureDeviceBitmap(target)) {
+      return;
+    }
+    // The destination is the view's box in points and the bitmap is in pixels,
+    // which is where the density applied in setSize comes back out. On a
+    // display at 1x the two are the same number and the draw is one to one.
+    target->DrawBitmap(deviceBitmap_.Get(),
+                       D2D1::RectF(0.0f, 0.0f, boxWidth, boxHeight),
+                       1.0f,
+                       D2D1_BITMAP_INTERPOLATION_MODE_LINEAR);
+  }
+
+ private:
+  void releaseDeviceBitmap() {
+    deviceBitmap_.Reset();
+    deviceTarget_ = nullptr;
+    deviceGeneration_ = 0;
+  }
+
+  // The Direct2D copy of the surface: made once, refilled per frame.
+  //
+  // Keyed on the target the way RnWin32Image's cache is, and for the same
+  // reason -- a bitmap belongs to the target that made it, and this host draws
+  // into a second one only for the offscreen snapshot. Refilled rather than
+  // remade because `CopyFromMemory` reuses the allocation, which is the
+  // difference between a copy per frame and a copy plus an allocation.
+  bool ensureDeviceBitmap(ID2D1RenderTarget *target) {
+    if (deviceBitmap_ == nullptr || deviceTarget_ != target) {
+      deviceBitmap_.Reset();
+      deviceTarget_ = nullptr;
+      const D2D1_BITMAP_PROPERTIES properties = D2D1::BitmapProperties(
+          D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED));
+      ComPtr<ID2D1Bitmap> created;
+      if (FAILED(target->CreateBitmap(
+              D2D1::SizeU(static_cast<UINT32>(pixelWidth_), static_cast<UINT32>(pixelHeight_)),
+              properties,
+              created.GetAddressOf()))) {
+        return false;
+      }
+      deviceBitmap_ = std::move(created);
+      deviceTarget_ = target;
+      // Nothing has been copied into it yet, whatever generation the surface
+      // happens to be on.
+      deviceGeneration_ = 0;
+    }
+    if (deviceGeneration_ == generation_) {
+      return true;
+    }
+    SkPixmap pixels;
+    if (!surface_->peekPixels(&pixels)) {
+      // Only a GPU-backed surface cannot be peeked, and this one is raster by
+      // construction. A line rather than a silent blank frame, for the day
+      // that changes.
+      LOG(WARNING) << "react-native-skia: a <Canvas> surface could not be read back";
+      return false;
+    }
+    if (FAILED(deviceBitmap_->CopyFromMemory(
+            nullptr, pixels.addr(), static_cast<UINT32>(pixels.rowBytes())))) {
+      return false;
+    }
+    deviceGeneration_ = generation_;
+    return true;
+  }
+
+  std::shared_ptr<RNSkia::RNSkPlatformContext> context_;
+  std::function<void()> requestRepaint_;
+
+  sk_sp<SkSurface> surface_;
+  int pixelWidth_ = 0;
+  int pixelHeight_ = 0;
+
+  // Bumped by every render. The device bitmap remembers which generation it
+  // holds, so a window that repaints for some other reason -- a resize, a
+  // sibling changing -- redraws the canvas without copying its pixels again.
+  uint64_t generation_ = 1;
+  uint64_t deviceGeneration_ = 0;
+
+  ComPtr<ID2D1Bitmap> deviceBitmap_;
+  ID2D1RenderTarget *deviceTarget_ = nullptr;
+};
+
+// The package's view, holding the canvas above.
+//
+// `RNSkAppleView.h` is this in template form and cannot be included here: its
+// first import is the Apple platform context, which is Objective-C++ over an
+// RCTBridge. A `<Canvas>` needs exactly one RNSkView subclass, so this is that
+// one rather than a template over the one.
+class Win32SkiaPictureView final : public RNSkia::RNSkPictureView {
+ public:
+  Win32SkiaPictureView(const std::shared_ptr<RNSkia::RNSkPlatformContext> &context,
+                       const std::function<void()> &requestRepaint)
+      : RNSkia::RNSkPictureView(
+            context,
+            std::make_shared<Win32SkiaCanvas>(
+                // Bound before the base class is constructed, exactly as the
+                // package's own views bind it: nothing calls it until a
+                // picture arrives, by which time this object is whole.
+                std::bind(&RNSkia::RNSkView::requestRedraw, this),
+                context,
+                requestRepaint)) {}
+
+  // `getCanvasProvider` is protected on RNSkView, which is why this is a
+  // member rather than a cast at the call site.
+  std::shared_ptr<Win32SkiaCanvas> canvas() {
+    return std::static_pointer_cast<Win32SkiaCanvas>(getCanvasProvider());
+  }
+};
+
+struct Attached {
+  std::shared_ptr<Win32SkiaPictureView> view;
+  // The id it was registered under, kept so the unregister matches: a view
+  // whose nativeID changed would otherwise leave the old registration behind,
+  // pointing at a surface nothing draws into.
+  size_t nativeId = 0;
+};
+
+std::unordered_map<facebook::react::Tag, Attached> &attached() {
+  static std::unordered_map<facebook::react::Tag, Attached> map;
+  return map;
+}
+
+// `<Canvas>` stringifies a counter into nativeID. Anything else on a
+// SkiaPictureView is not ours to interpret.
+bool parseNativeId(const std::string &text, size_t &out) {
+  if (text.empty()) {
+    return false;
+  }
+  try {
+    size_t consumed = 0;
+    const unsigned long long value = std::stoull(text, &consumed);
+    if (consumed != text.size()) {
+      return false;
+    }
+    out = static_cast<size_t>(value);
+    return true;
+  } catch (const std::exception &) {
+    return false;
+  }
+}
+
+} // namespace
+
+bool applySkiaCanvas(win32::RnWin32View *view,
+                     const facebook::react::ShadowView &shadowView,
+                     const std::function<void()> &requestRepaint) {
+  if (view == nullptr || shadowView.componentName == nullptr ||
+      std::string_view(shadowView.componentName) !=
+          facebook::react::SkiaPictureViewComponentName) {
+    return false;
+  }
+
+  const auto tag = shadowView.tag;
+  // In points, which is what the canvas wants: it applies the pixel density
+  // itself, and passing pixels would square it on a scaled display.
+  const auto &frame = shadowView.layoutMetrics.frame;
+  const int width = static_cast<int>(frame.size.width);
+  const int height = static_cast<int>(frame.size.height);
+
+  size_t nativeId = 0;
+  if (!parseNativeId(view->nativeId(), nativeId)) {
+    // Not an error: a SkiaPictureView can mount before its nativeID has been
+    // applied, and the next updateView carries it.
+    return true;
+  }
+
+  RNSkia::RNSkManager *manager = Win32SkiaModule::manager();
+  if (manager == nullptr) {
+    LOG(WARNING) << "SkiaPictureView tag " << tag
+                 << " mounted before RNSkiaModule.install ran, so it has no canvas";
+    return true;
+  }
+
+  auto &entry = attached()[tag];
+  if (entry.view == nullptr) {
+    entry.view =
+        std::make_shared<Win32SkiaPictureView>(manager->getPlatformContext(), requestRepaint);
+    entry.nativeId = nativeId;
+    // The view draws it; this file only keeps it alive and in step.
+    view->setPainter(entry.view->canvas());
+    manager->setSkiaView(nativeId, entry.view);
+    LOG(INFO) << "SkiaPictureView tag " << tag << " registered as Skia view " << nativeId;
+  } else if (entry.nativeId != nativeId) {
+    // The id moved. Re-register rather than leave the manager pointing the old
+    // surface at the new id's pictures.
+    manager->unregisterSkiaView(entry.nativeId);
+    entry.nativeId = nativeId;
+    manager->setSkiaView(nativeId, entry.view);
+  }
+
+  entry.view->canvas()->setRequestRepaint(requestRepaint);
+  if (width > 0 && height > 0) {
+    entry.view->canvas()->setSize(width, height);
+  }
+  return true;
+}
+
+void forgetSkiaCanvas(facebook::react::Tag tag) {
+  auto it = attached().find(tag);
+  if (it == attached().end()) {
+    return;
+  }
+  if (RNSkia::RNSkManager *manager = Win32SkiaModule::manager()) {
+    manager->unregisterSkiaView(it->second.nativeId);
+  }
+  attached().erase(it);
+}
+
+} // namespace basalt

package/native/win32/Win32SkiaPeer.h

@@ -0,0 +1,66 @@
+// The Win32 half of a `<Canvas>`: a raster surface drawn in the paint walk.
+//
+// The other two hosts give the package a layer of its own -- a CAMetalLayer on
+// macOS, a GL surface on GTK -- and let it present straight to the compositor.
+// This host has neither a layer tree nor a view that is a window (see the note
+// at the top of RnWin32View.h for why), so a canvas cannot present itself. What
+// it can do is render into memory and let the one Direct2D walk that draws
+// everything else draw it too, at the rect the shadow tree already resolved.
+//
+// That is a CPU renderer, and saying so plainly: every frame is drawn by Skia
+// into a raster surface and copied once into a Direct2D bitmap. It is the same
+// choice Win32SkiaContext.h already made for offscreen surfaces, for the same
+// reason -- there is no GL or Vulkan context in this host to render into yet --
+// and it is what makes the whole thing about two hundred lines instead of a
+// WGL bring-up. A GPU path would replace `Win32SkiaCanvas`, and nothing else
+// here: the seam it plugs into, `RnWin32Painter`, says nothing about pixels.
+//
+// What the walk buys, and why this is not a worse arrangement than a layer:
+// the canvas is clipped by `overflow: hidden`, moved by a ScrollView's offset,
+// faded by `opacity` and turned by `transform` because the view above it did
+// those things before calling down -- none of which a sibling layer gets for
+// free. It also appears in the offscreen snapshot, because the snapshot is the
+// same walk against a WIC target.
+//
+// What it costs: a frame is a copy, and the window repaints whole. Neither is
+// free and both are measured in the size of the canvas rather than the size of
+// the app, which is the part that matters for a preview pane.
+
+#pragma once
+
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/mounting/ShadowView.h>
+
+#include <functional>
+
+namespace basalt {
+
+namespace win32 {
+class RnWin32View;
+}
+
+// Gives `view` a Skia canvas if `shadowView` is a SkiaPictureView, updating its
+// size if it already has one. False when the component is something else, so
+// the caller can treat this as a filter rather than asking twice.
+//
+// `requestRepaint` is how a picture pushed from JavaScript reaches the screen.
+// Windows repaints on demand, so rendering a frame into the surface changes
+// nothing until something invalidates the window -- and a canvas renders
+// between mount transactions, which is exactly when nothing else will. It is
+// the mounting manager's own `onDidMount` callback, for want of a second way
+// to say "the screen is stale".
+//
+// Safe to call before `install` has run: without a manager there is nothing to
+// register with, so it says so in the log and leaves the view alone rather
+// than building a surface no picture could ever reach.
+bool applySkiaCanvas(win32::RnWin32View *view,
+                     const facebook::react::ShadowView &shadowView,
+                     const std::function<void()> &requestRepaint);
+
+// Unregisters the canvas for `tag`, if it had one. Called when the mounting
+// walk forgets a tag, which is after the view itself has been deleted -- so
+// this is only about the manager's registration and this file's own map. The
+// surface goes with the view, which held the last reference to it.
+void forgetSkiaCanvas(facebook::react::Tag tag);
+
+} // namespace basalt

package/native/win32/Win32SkiaUnicode.cpp

@@ -0,0 +1,42 @@
+// `SkUnicodes::ICU::Make`, answered with libgrapheme.
+//
+// One symbol, and it exists because of a disagreement between two reasonable
+// choices rather than a mistake by either.
+//
+// @shopify/react-native-skia picks its unicode backend by platform, in
+// cpp/api/JsiSkParagraphBuilder.h:
+//
+//     #ifdef __APPLE__
+//         unicode = SkUnicodes::Libgrapheme::Make();
+//     #else
+//         unicode = SkUnicodes::ICU::Make();
+//     #endif
+//
+// Windows is not __APPLE__, so it asks for ICU. This host cannot give it the
+// ICU-backed skunicode: basalt links the operating system's own ICU -- see
+// cmake/ThirdParty.cmake, which declines to vendor a second copy -- and Skia's
+// ICU-backed skunicode carries a static one, so the two collide on every
+// unsuffixed ICU symbol. The archives here are therefore built with
+// libgrapheme, exactly as the package's own published Apple archives are.
+//
+// Which leaves the package calling a factory nobody defines. Defining it here
+// is the smallest honest answer: the same backend Apple gets, under the name
+// this platform's branch of that #ifdef asks for. The alternative is patching
+// the package in every app that uses it, which is a worse version of this.
+//
+// It is not a stub. `SkUnicodes::Libgrapheme::Make()` is the real
+// implementation, shipped in skunicode_libgrapheme.lib, and paragraph layout
+// on this host is the same code Apple runs. What differs from an ICU build is
+// what libgrapheme does not do -- ICU's full line-breaking and bidi tables --
+// which is a difference Apple already lives with.
+
+#include "modules/skunicode/include/SkUnicode_icu.h"
+#include "modules/skunicode/include/SkUnicode_libgrapheme.h"
+
+namespace SkUnicodes::ICU {
+
+sk_sp<SkUnicode> Make() {
+  return SkUnicodes::Libgrapheme::Make();
+}
+
+} // namespace SkUnicodes::ICU

package/native/win32/Win32Snapshot.cpp

@@ -0,0 +1,201 @@
+#include "Win32Snapshot.h"
+
+#include "RnWin32View.h"
+
+#include <windows.h>
+
+#include <d2d1.h>
+#include <wincodec.h>
+#include <wrl/client.h>
+
+#include <cmath>
+#include <string>
+
+using Microsoft::WRL::ComPtr;
+
+namespace basalt::win32 {
+namespace {
+
+// COM, initialised once per thread and deliberately never uninitialised.
+//
+// A snapshot can be taken from a thread that already called CoInitializeEx --
+// the host's main thread will have -- and RPC_E_CHANGED_MODE says exactly that
+// and is not a failure. Balancing this with CoUninitialize would tear down the
+// apartment the caller set up, so it is left alone: nothing here owns the
+// thread it is called on.
+bool ensureCom() {
+  const HRESULT hr = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
+  return SUCCEEDED(hr) || hr == RPC_E_CHANGED_MODE;
+}
+
+std::wstring widen(const std::string &text) {
+  if (text.empty()) {
+    return {};
+  }
+  const int needed =
+      MultiByteToWideChar(CP_UTF8, 0, text.c_str(), static_cast<int>(text.size()), nullptr, 0);
+  if (needed <= 0) {
+    return {};
+  }
+  std::wstring wide(static_cast<size_t>(needed), L'\0');
+  MultiByteToWideChar(
+      CP_UTF8, 0, text.c_str(), static_cast<int>(text.size()), wide.data(), needed);
+  return wide;
+}
+
+// Renders the tree into a WIC bitmap. The one place the render is described, so
+// the pixels a test reads and the pixels a PNG carries cannot come out
+// different -- the same reason the text layout is built in one place and shared
+// by measurement and painting.
+bool renderToBitmap(const RnWin32View &root,
+                    ComPtr<IWICImagingFactory> &wic,
+                    ComPtr<IWICBitmap> &bitmap,
+                    UINT &width,
+                    UINT &height) {
+  const RnRect frame = root.frame();
+  width = static_cast<UINT>(std::lround(frame.width));
+  height = static_cast<UINT>(std::lround(frame.height));
+  if (width == 0 || height == 0) {
+    return false;
+  }
+
+  if (!ensureCom()) {
+    return false;
+  }
+
+  if (FAILED(CoCreateInstance(
+          CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&wic)))) {
+    return false;
+  }
+
+  // Premultiplied BGRA, which is what Direct2D's B8G8R8A8_UNORM target expects
+  // and what the PNG encoder can take straight back.
+  if (FAILED(wic->CreateBitmap(
+          width, height, GUID_WICPixelFormat32bppPBGRA, WICBitmapCacheOnLoad, bitmap.GetAddressOf()))) {
+    return false;
+  }
+
+  ComPtr<ID2D1Factory> d2d;
+  if (FAILED(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, d2d.GetAddressOf()))) {
+    return false;
+  }
+
+  // 96 dpi explicitly, so a render is the size the frames say regardless of
+  // what the machine taking it is set to. Every coordinate in this project is
+  // in React Native's density-independent pixels, and a snapshot that silently
+  // came out at 150% on one developer's laptop would compare as a difference
+  // against every other host.
+  const D2D1_RENDER_TARGET_PROPERTIES properties = D2D1::RenderTargetProperties(
+      D2D1_RENDER_TARGET_TYPE_DEFAULT,
+      D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED),
+      96.0f,
+      96.0f);
+
+  ComPtr<ID2D1RenderTarget> target;
+  if (FAILED(d2d->CreateWicBitmapRenderTarget(bitmap.Get(), properties, target.GetAddressOf()))) {
+    return false;
+  }
+
+  target->BeginDraw();
+  target->Clear(D2D1::ColorF(0.0f, 0.0f, 0.0f, 0.0f));
+  target->SetTransform(D2D1::Matrix3x2F::Identity());
+  // The root paints at its own frame's origin like any other view, and a
+  // surface root's origin is (0,0), so nothing here has to compensate.
+  root.paint(target.Get());
+  return SUCCEEDED(target->EndDraw());
+}
+
+} // namespace
+
+RnPixel RnPixels::at(unsigned x, unsigned y) const {
+  if (x >= width_ || y >= height_) {
+    return {};
+  }
+  const size_t offset = (static_cast<size_t>(y) * width_ + x) * 4;
+  if (offset + 3 >= bgra_.size()) {
+    return {};
+  }
+
+  const uint8_t blue = bgra_[offset + 0];
+  const uint8_t green = bgra_[offset + 1];
+  const uint8_t red = bgra_[offset + 2];
+  const uint8_t alpha = bgra_[offset + 3];
+  if (alpha == 0) {
+    return {};
+  }
+
+  // Unpremultiplied, so a test compares against the components it set rather
+  // than against those components times an alpha it has to work out.
+  const auto straight = [alpha](uint8_t component) {
+    const int value = (static_cast<int>(component) * 255 + alpha / 2) / alpha;
+    return static_cast<uint8_t>(value > 255 ? 255 : value);
+  };
+  return RnPixel{straight(red), straight(green), straight(blue), alpha};
+}
+
+RnPixels renderToPixels(const RnWin32View &root) {
+  ComPtr<IWICImagingFactory> wic;
+  ComPtr<IWICBitmap> bitmap;
+  UINT width = 0;
+  UINT height = 0;
+  if (!renderToBitmap(root, wic, bitmap, width, height)) {
+    return RnPixels{0, 0, {}};
+  }
+
+  const UINT stride = width * 4;
+  std::vector<uint8_t> buffer(static_cast<size_t>(stride) * height);
+  if (FAILED(bitmap->CopyPixels(
+          nullptr, stride, static_cast<UINT>(buffer.size()), buffer.data()))) {
+    return RnPixels{0, 0, {}};
+  }
+  return RnPixels{width, height, std::move(buffer)};
+}
+
+bool writeSnapshot(const RnWin32View &root, const std::string &path) {
+  ComPtr<IWICImagingFactory> wic;
+  ComPtr<IWICBitmap> bitmap;
+  UINT width = 0;
+  UINT height = 0;
+  if (!renderToBitmap(root, wic, bitmap, width, height)) {
+    return false;
+  }
+
+  const std::wstring widePath = widen(path);
+  if (widePath.empty()) {
+    return false;
+  }
+
+  ComPtr<IWICStream> stream;
+  if (FAILED(wic->CreateStream(stream.GetAddressOf())) ||
+      FAILED(stream->InitializeFromFilename(widePath.c_str(), GENERIC_WRITE))) {
+    return false;
+  }
+
+  ComPtr<IWICBitmapEncoder> encoder;
+  if (FAILED(wic->CreateEncoder(GUID_ContainerFormatPng, nullptr, encoder.GetAddressOf())) ||
+      FAILED(encoder->Initialize(stream.Get(), WICBitmapEncoderNoCache))) {
+    return false;
+  }
+
+  ComPtr<IWICBitmapFrameEncode> frameEncode;
+  if (FAILED(encoder->CreateNewFrame(frameEncode.GetAddressOf(), nullptr)) ||
+      FAILED(frameEncode->Initialize(nullptr)) || FAILED(frameEncode->SetSize(width, height))) {
+    return false;
+  }
+
+  // The encoder is allowed to answer with a format it prefers; PNG takes this
+  // one, and asking is the documented way rather than an optimisation.
+  WICPixelFormatGUID format = GUID_WICPixelFormat32bppPBGRA;
+  if (FAILED(frameEncode->SetPixelFormat(&format))) {
+    return false;
+  }
+
+  if (FAILED(frameEncode->WriteSource(bitmap.Get(), nullptr)) || FAILED(frameEncode->Commit()) ||
+      FAILED(encoder->Commit())) {
+    return false;
+  }
+
+  return true;
+}
+
+} // namespace basalt::win32