Export equirectangular PNGs through paint renderer

src/paint_renderer/compositor.cpp

@@ -4,6 +4,7 @@
 #include "renderer_api/recording_renderer.h"
 
 #include <algorithm>
+#include <cmath>
 #include <limits>
 #include <utility>
 
@@ -115,6 +116,52 @@ namespace {
     return static_cast<std::byte>(static_cast<std::uint8_t>(clamped * 255.0F + 0.5F));
 }
 
+struct CubeFaceSample {
+    std::size_t face_index = 0;
+    float s = 0.0F;
+    float t = 0.0F;
+};
+
+[[nodiscard]] CubeFaceSample panopainter_cube_face_sample(float x, float y, float z) noexcept
+{
+    const auto ax = std::fabs(x);
+    const auto ay = std::fabs(y);
+    const auto az = std::fabs(z);
+
+    if (ax >= ay && ax >= az) {
+        if (x >= 0.0F) {
+            return CubeFaceSample { .face_index = 3U, .s = -z / ax, .t = -y / ax };
+        }
+        return CubeFaceSample { .face_index = 1U, .s = z / ax, .t = -y / ax };
+    }
+
+    if (ay >= ax && ay >= az) {
+        if (y >= 0.0F) {
+            return CubeFaceSample { .face_index = 5U, .s = x / ay, .t = z / ay };
+        }
+        return CubeFaceSample { .face_index = 4U, .s = x / ay, .t = -z / ay };
+    }
+
+    if (z >= 0.0F) {
+        return CubeFaceSample { .face_index = 2U, .s = x / az, .t = -y / az };
+    }
+    return CubeFaceSample { .face_index = 0U, .s = -x / az, .t = -y / az };
+}
+
+[[nodiscard]] pp::paint::Rgba sample_face_nearest(
+    const DocumentFaceCompositeResult& face,
+    float s,
+    float t) noexcept
+{
+    const auto width = face.extent.width;
+    const auto height = face.extent.height;
+    const auto u = std::clamp((s + 1.0F) * 0.5F, 0.0F, 1.0F);
+    const auto v = std::clamp((t + 1.0F) * 0.5F, 0.0F, 1.0F);
+    const auto x = std::min(static_cast<std::uint32_t>(u * static_cast<float>(width)), width - 1U);
+    const auto y = std::min(static_cast<std::uint32_t>(v * static_cast<float>(height)), height - 1U);
+    return face.pixels[static_cast<std::size_t>(y) * width + x];
+}
+
 void append_rgba8_bytes(std::vector<std::byte>& bytes, std::span<const pp::paint::Rgba> pixels)
 {
     bytes.clear();
@@ -481,6 +528,90 @@ pp::foundation::Result<DocumentFrameFacePngExportResult> export_document_frame_f
     return pp::foundation::Result<DocumentFrameFacePngExportResult>::success(std::move(result));
 }
 
+pp::foundation::Result<DocumentFrameEquirectangularPngExportResult>
+export_document_frame_equirectangular_png(const DocumentFrameCompositeResult& composite)
+{
+    const auto face_pixel_count = expected_pixel_count(composite.extent);
+    if (!face_pixel_count) {
+        return pp::foundation::Result<DocumentFrameEquirectangularPngExportResult>::failure(face_pixel_count.status());
+    }
+
+    for (const auto& face : composite.faces) {
+        if (face.extent.width != composite.extent.width || face.extent.height != composite.extent.height
+            || face.pixels.size() != face_pixel_count.value()) {
+            return pp::foundation::Result<DocumentFrameEquirectangularPngExportResult>::failure(
+                pp::foundation::Status::invalid_argument("document equirectangular export requires complete cube faces"));
+        }
+    }
+
+    const auto output_width = static_cast<std::uint64_t>(composite.extent.width) * 4U;
+    const auto output_height = static_cast<std::uint64_t>(composite.extent.height) * 2U;
+    if (output_width > std::numeric_limits<std::uint32_t>::max()
+        || output_height > std::numeric_limits<std::uint32_t>::max()) {
+        return pp::foundation::Result<DocumentFrameEquirectangularPngExportResult>::failure(
+            pp::foundation::Status::out_of_range("document equirectangular extent exceeds uint32"));
+    }
+
+    DocumentFrameEquirectangularPngExportResult result;
+    result.face_extent = composite.extent;
+    result.equirectangular_extent = pp::renderer::Extent2D {
+        .width = static_cast<std::uint32_t>(output_width),
+        .height = static_cast<std::uint32_t>(output_height),
+    };
+    result.face_payload_count = composite.face_payload_count;
+    result.composited_layer_face_count = composite.composited_layer_face_count;
+
+    const auto output_pixel_count = expected_pixel_count(result.equirectangular_extent);
+    if (!output_pixel_count) {
+        return pp::foundation::Result<DocumentFrameEquirectangularPngExportResult>::failure(output_pixel_count.status());
+    }
+
+    constexpr auto pi = 3.14159265358979323846F;
+    constexpr auto two_pi = 6.28318530717958647692F;
+    std::vector<pp::paint::Rgba> output(output_pixel_count.value());
+    for (std::uint32_t y = 0; y < result.equirectangular_extent.height; ++y) {
+        const auto v = (static_cast<float>(y) + 0.5F) / static_cast<float>(result.equirectangular_extent.height);
+        const auto angle_y = (1.0F - v) * pi;
+        const auto sin_y = std::sin(angle_y);
+        const auto cos_y = std::cos(angle_y);
+        for (std::uint32_t x = 0; x < result.equirectangular_extent.width; ++x) {
+            const auto u = (static_cast<float>(x) + 0.5F) / static_cast<float>(result.equirectangular_extent.width);
+            const auto angle_x = (1.25F - u) * two_pi;
+            const auto sample = panopainter_cube_face_sample(
+                sin_y * std::cos(angle_x),
+                cos_y,
+                sin_y * std::sin(angle_x));
+            output[static_cast<std::size_t>(y) * result.equirectangular_extent.width + x] =
+                sample_face_nearest(composite.faces[sample.face_index], sample.s, sample.t);
+        }
+    }
+
+    std::vector<std::uint8_t> rgba8;
+    append_rgba8_bytes(rgba8, output);
+    auto encoded = pp::assets::encode_png_rgba8(
+        result.equirectangular_extent.width,
+        result.equirectangular_extent.height,
+        rgba8);
+    if (!encoded) {
+        return pp::foundation::Result<DocumentFrameEquirectangularPngExportResult>::failure(encoded.status());
+    }
+
+    result.encoded_bytes = static_cast<std::uint64_t>(encoded.value().size());
+    result.png = std::move(encoded.value());
+    return pp::foundation::Result<DocumentFrameEquirectangularPngExportResult>::success(std::move(result));
+}
+
+pp::foundation::Result<DocumentFrameEquirectangularPngExportResult>
+export_document_frame_equirectangular_png(DocumentFrameCompositeRequest request)
+{
+    auto composite = composite_document_frame(request);
+    if (!composite) {
+        return pp::foundation::Result<DocumentFrameEquirectangularPngExportResult>::failure(composite.status());
+    }
+
+    return export_document_frame_equirectangular_png(composite.value());
+}
+
 pp::foundation::Result<DocumentFrameExportReadinessResult> prepare_document_frame_export_readiness(
     DocumentFrameCompositeRequest request)
 {

src/paint_renderer/compositor.h

@@ -146,6 +146,15 @@ struct DocumentFrameFacePngExportResult {
     std::uint64_t encoded_bytes = 0;
 };
 
+struct DocumentFrameEquirectangularPngExportResult {
+    pp::renderer::Extent2D face_extent {};
+    pp::renderer::Extent2D equirectangular_extent {};
+    std::vector<std::byte> png;
+    std::uint64_t encoded_bytes = 0;
+    std::size_t face_payload_count = 0;
+    std::size_t composited_layer_face_count = 0;
+};
+
 struct DocumentFrameExportReadinessResult {
     RecordedDocumentFrameUploadResult recorded_upload {};
     DocumentFrameFacePngExportResult face_pngs {};
@@ -172,6 +181,12 @@ struct DocumentFrameExportReadinessResult {
 [[nodiscard]] pp::foundation::Result<DocumentFrameFacePngExportResult> export_document_frame_face_pngs(
     DocumentFrameCompositeRequest request);
 
+[[nodiscard]] pp::foundation::Result<DocumentFrameEquirectangularPngExportResult>
+export_document_frame_equirectangular_png(const DocumentFrameCompositeResult& composite);
+
+[[nodiscard]] pp::foundation::Result<DocumentFrameEquirectangularPngExportResult>
+export_document_frame_equirectangular_png(DocumentFrameCompositeRequest request);
+
 [[nodiscard]] pp::foundation::Result<DocumentFrameExportReadinessResult> prepare_document_frame_export_readiness(
     DocumentFrameCompositeRequest request);