omar/panopainter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Export equirectangular PNGs through paint renderer

Browse Source
This commit is contained in:
omigamedev
2026-06-05 20:31:35 +02:00
parent ebc84373e6
commit 77268a28fb
8 changed files with 378 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
src/legacy_document_export_services.cpp
View File

@@ -25,6 +25,19 @@ void show_export_success_dialog(
}
}
bool is_png_export_target(std::string_view path) noexcept
{
if (path.size() < 4U) {
return false;
}
const auto extension = path.substr(path.size() - 4U);
return extension[0] == '.'
&& (extension[1] == 'p' || extension[1] == 'P')
&& (extension[2] == 'n' || extension[2] == 'N')
&& (extension[3] == 'g' || extension[3] == 'G');
}
struct LegacyDocumentExportSnapshotReports {
pp::app::DocumentCanvasSnapshotResult snapshot;
pp::paint_renderer::DocumentFrameFacePngExportResult face_pngs;
@@ -174,6 +187,40 @@ pp::foundation::Status export_cube_faces_from_document_snapshot(
return pp::app::execute_document_cube_face_export_write(target.value(), payloads, services);
}
pp::foundation::Status export_equirectangular_png_from_document_snapshot(
App& app,
const pp::app::DocumentExportFileTarget& target,
const LegacyDocumentExportSnapshotReports& reports)
{
if (!is_png_export_target(target.path)) {
return pp::foundation::Status::invalid_argument(
"document snapshot equirectangular export currently supports PNG targets only");
}
auto exported = pp::paint_renderer::export_document_frame_equirectangular_png(reports.face_pngs.composite);
if (!exported) {
return exported.status();
}
auto exported_value = std::move(exported.value());
LOG(
"export-equirectangular document export PNG writer: %ux%u bytes=%llu facePayloads=%zu compositedLayerFaces=%zu",
exported_value.equirectangular_extent.width,
exported_value.equirectangular_extent.height,
static_cast<unsigned long long>(exported_value.encoded_bytes),
exported_value.face_payload_count,
exported_value.composited_layer_face_count);
const auto write_status = write_export_binary_file(
target.path,
std::span<const std::byte>(exported_value.png.data(), exported_value.png.size()));
if (!write_status.ok()) {
return write_status;
}
app.publish_exported_image(target.path);
return pp::foundation::Status::success();
}
class LegacyDocumentExportServices final : public pp::app::DocumentExportServices {
public:
explicit LegacyDocumentExportServices(App& app) noexcept
@@ -189,7 +236,34 @@ public:
void export_equirectangular(const pp::app::DocumentExportFileTarget& target) override
{
auto* app = &app_;
prepare_legacy_document_export_snapshot_or_continue(app_, "export-equirectangular");
#if !__WEB__
if (is_png_export_target(target.path)) {
const auto prepared = prepare_legacy_document_export_snapshot(app_, "export-equirectangular");
if (prepared) {
const auto exported = export_equirectangular_png_from_document_snapshot(app_, target, prepared.value());
if (exported.ok()) {
show_export_success_dialog(
app_,
pp::app::plan_document_export_success_dialog(
pp::app::DocumentExportSuccessKind::equirectangular,
pp::app::document_export_equirectangular_platform_destination(),
app_.work_path));
return;
}
LOG(
"export-equirectangular document export writer retained legacy export after failure: %s",
exported.message);
} else {
LOG(
"export-equirectangular document export snapshot bridge retained legacy export after failure: %s",
prepared.status().message);
}
} else
#endif
{
prepare_legacy_document_export_snapshot_or_continue(app_, "export-equirectangular");
}
app_.canvas->m_canvas->export_equirectangular(target.path, [app, target] {
#if __WEB__
app->ui_task([app, target] {

131
src/paint_renderer/compositor.cpp
View File

@@ -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)
{

15
src/paint_renderer/compositor.h
View File

@@ -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);