527 lines
19 KiB
C++
527 lines
19 KiB
C++
#pragma once
|
|
|
|
#include "document/document.h"
|
|
#include "document/ppi_export.h"
|
|
#include "foundation/result.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <span>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace pp::app {
|
|
|
|
struct DocumentCanvasClearPlan {
|
|
float r = 0.0F;
|
|
float g = 0.0F;
|
|
float b = 0.0F;
|
|
float a = 0.0F;
|
|
bool clears_canvas = false;
|
|
bool records_undo = false;
|
|
bool marks_unsaved = false;
|
|
bool no_op = true;
|
|
};
|
|
|
|
struct DocumentCanvasFacePayloadInput {
|
|
std::uint32_t frame_index = 0;
|
|
std::uint32_t face_index = 0;
|
|
std::uint32_t x = 0;
|
|
std::uint32_t y = 0;
|
|
std::uint32_t width = 0;
|
|
std::uint32_t height = 0;
|
|
std::span<const std::uint8_t> rgba8;
|
|
};
|
|
|
|
struct DocumentCanvasLayerSnapshotInput {
|
|
std::string_view name;
|
|
bool visible = true;
|
|
bool alpha_locked = false;
|
|
float opacity = 1.0F;
|
|
int blend_mode = 0;
|
|
std::span<const std::uint32_t> frame_durations_ms;
|
|
std::size_t pending_face_payloads = 0;
|
|
std::span<const DocumentCanvasFacePayloadInput> captured_face_payloads;
|
|
};
|
|
|
|
struct DocumentCanvasSnapshotInput {
|
|
bool has_canvas = true;
|
|
std::uint32_t width = 0;
|
|
std::uint32_t height = 0;
|
|
std::size_t active_layer_index = 0;
|
|
std::size_t active_frame_index = 0;
|
|
std::span<const DocumentCanvasLayerSnapshotInput> layers;
|
|
};
|
|
|
|
struct DocumentCanvasSnapshotResult {
|
|
pp::document::CanvasDocument document;
|
|
std::size_t layer_count = 0;
|
|
std::size_t frame_count = 0;
|
|
std::size_t pending_face_payloads = 0;
|
|
std::size_t captured_face_payloads = 0;
|
|
bool metadata_only = false;
|
|
bool requires_renderer_payload_readback = false;
|
|
};
|
|
|
|
struct DocumentCanvasSaveSnapshotReport {
|
|
std::uint32_t width = 0;
|
|
std::uint32_t height = 0;
|
|
std::size_t layer_count = 0;
|
|
std::size_t frame_count = 0;
|
|
std::size_t captured_face_payloads = 0;
|
|
std::size_t pending_face_payloads = 0;
|
|
bool payload_complete = false;
|
|
bool can_export_ppi = false;
|
|
};
|
|
|
|
enum class DocumentCanvasSaveWriterAction {
|
|
use_document_ppi_writer,
|
|
use_legacy_project_save,
|
|
};
|
|
|
|
struct DocumentCanvasSaveWriterRoutePlan {
|
|
DocumentCanvasSaveWriterAction action = DocumentCanvasSaveWriterAction::use_legacy_project_save;
|
|
bool payload_complete = false;
|
|
bool can_export_ppi = false;
|
|
bool uses_document_ppi_writer = false;
|
|
std::string_view fallback_reason;
|
|
};
|
|
|
|
struct DocumentCanvasPpiExportResult {
|
|
DocumentCanvasSaveSnapshotReport report;
|
|
std::vector<std::byte> bytes;
|
|
};
|
|
|
|
struct DocumentCanvasProjectSaveTargetPlan {
|
|
std::string target_path;
|
|
std::string file_name;
|
|
std::string temporary_path;
|
|
std::string timelapse_path;
|
|
};
|
|
|
|
enum class DocumentCanvasProjectSaveWriteAction {
|
|
write_direct_to_target,
|
|
write_temporary_then_swap,
|
|
};
|
|
|
|
struct DocumentCanvasProjectSaveWritePlan {
|
|
DocumentCanvasProjectSaveWriteAction action = DocumentCanvasProjectSaveWriteAction::write_direct_to_target;
|
|
std::string write_path;
|
|
std::string target_path;
|
|
std::string temporary_path;
|
|
bool target_exists = false;
|
|
bool uses_temporary = false;
|
|
bool falls_back_to_direct_on_temporary_open_failure = false;
|
|
};
|
|
|
|
struct DocumentCanvasProjectSaveCommitInput {
|
|
bool used_temporary = false;
|
|
bool target_remove_attempted = false;
|
|
bool target_remove_succeeded = false;
|
|
bool temporary_rename_attempted = false;
|
|
bool temporary_rename_succeeded = false;
|
|
};
|
|
|
|
struct DocumentCanvasProjectSaveCommitPlan {
|
|
bool saved = false;
|
|
bool used_temporary = false;
|
|
bool target_removed = false;
|
|
bool temporary_renamed = false;
|
|
bool target_may_be_missing = false;
|
|
std::string_view log_message;
|
|
};
|
|
|
|
struct DocumentCanvasProjectSavePostCommitInput {
|
|
bool save_succeeded = false;
|
|
bool timelapse_encoder_available = false;
|
|
bool progress_ui_visible = false;
|
|
};
|
|
|
|
struct DocumentCanvasProjectSavePostCommitPlan {
|
|
bool marks_document_clean = false;
|
|
bool marks_new_document_committed = false;
|
|
bool saves_timelapse_sidecar = false;
|
|
bool flushes_platform_storage = false;
|
|
bool dismisses_progress_ui = false;
|
|
bool updates_title = true;
|
|
};
|
|
|
|
class DocumentCanvasClearServices {
|
|
public:
|
|
virtual ~DocumentCanvasClearServices() = default;
|
|
|
|
virtual void clear_current_canvas(float r, float g, float b, float a) = 0;
|
|
};
|
|
|
|
[[nodiscard]] inline pp::foundation::Status validate_clear_color_channel(float value) noexcept
|
|
{
|
|
if (!std::isfinite(value)) {
|
|
return pp::foundation::Status::invalid_argument("clear color channel must be finite");
|
|
}
|
|
if (value < 0.0F || value > 1.0F) {
|
|
return pp::foundation::Status::out_of_range("clear color channel must be within 0..1");
|
|
}
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
[[nodiscard]] inline pp::foundation::Result<DocumentCanvasSnapshotResult> plan_document_canvas_snapshot(
|
|
DocumentCanvasSnapshotInput input)
|
|
{
|
|
if (!input.has_canvas) {
|
|
return pp::foundation::Result<DocumentCanvasSnapshotResult>::failure(
|
|
pp::foundation::Status::invalid_argument("document canvas snapshot requires a canvas"));
|
|
}
|
|
|
|
if (input.layers.empty()) {
|
|
return pp::foundation::Result<DocumentCanvasSnapshotResult>::failure(
|
|
pp::foundation::Status::invalid_argument("document canvas snapshot requires at least one layer"));
|
|
}
|
|
|
|
std::size_t frame_count = 1U;
|
|
std::size_t pending_face_payloads = 0U;
|
|
std::size_t captured_face_payloads = 0U;
|
|
for (const auto& layer : input.layers) {
|
|
frame_count = std::max(frame_count, layer.frame_durations_ms.size());
|
|
pending_face_payloads += layer.pending_face_payloads;
|
|
captured_face_payloads += layer.captured_face_payloads.size();
|
|
}
|
|
|
|
if (input.active_layer_index >= input.layers.size()) {
|
|
return pp::foundation::Result<DocumentCanvasSnapshotResult>::failure(
|
|
pp::foundation::Status::out_of_range("active canvas layer is outside the document snapshot"));
|
|
}
|
|
|
|
if (input.active_frame_index >= frame_count) {
|
|
return pp::foundation::Result<DocumentCanvasSnapshotResult>::failure(
|
|
pp::foundation::Status::out_of_range("active canvas frame is outside the document snapshot"));
|
|
}
|
|
|
|
std::vector<pp::document::AnimationFrame> root_frames;
|
|
root_frames.reserve(frame_count);
|
|
for (std::size_t frame_index = 0; frame_index < frame_count; ++frame_index) {
|
|
std::uint32_t duration_ms = 100U;
|
|
for (const auto& layer : input.layers) {
|
|
if (frame_index < layer.frame_durations_ms.size()) {
|
|
duration_ms = layer.frame_durations_ms[frame_index];
|
|
break;
|
|
}
|
|
}
|
|
root_frames.push_back(pp::document::AnimationFrame { .duration_ms = duration_ms });
|
|
}
|
|
|
|
std::vector<std::string> layer_names;
|
|
std::vector<std::vector<pp::document::AnimationFrame>> layer_frames;
|
|
std::vector<pp::document::DocumentLayerConfig> layer_configs;
|
|
layer_names.reserve(input.layers.size());
|
|
layer_frames.reserve(input.layers.size());
|
|
layer_configs.reserve(input.layers.size());
|
|
|
|
for (std::size_t layer_index = 0; layer_index < input.layers.size(); ++layer_index) {
|
|
const auto& layer = input.layers[layer_index];
|
|
if (layer.name.empty()) {
|
|
layer_names.push_back("Layer " + std::to_string(layer_index + 1U));
|
|
} else {
|
|
layer_names.push_back(std::string(layer.name));
|
|
}
|
|
|
|
layer_frames.push_back({});
|
|
auto& frames = layer_frames.back();
|
|
frames.reserve(layer.frame_durations_ms.empty() ? root_frames.size() : layer.frame_durations_ms.size());
|
|
if (layer.frame_durations_ms.empty()) {
|
|
frames = root_frames;
|
|
} else {
|
|
for (const auto duration_ms : layer.frame_durations_ms) {
|
|
frames.push_back(pp::document::AnimationFrame { .duration_ms = duration_ms });
|
|
}
|
|
}
|
|
|
|
layer_configs.push_back(pp::document::DocumentLayerConfig {
|
|
.name = layer_names.back(),
|
|
.visible = layer.visible,
|
|
.alpha_locked = layer.alpha_locked,
|
|
.opacity = layer.opacity,
|
|
.blend_mode = static_cast<pp::paint::BlendMode>(layer.blend_mode),
|
|
.frames = std::span<const pp::document::AnimationFrame>(frames),
|
|
});
|
|
}
|
|
|
|
auto document = pp::document::CanvasDocument::create_from_snapshot(pp::document::DocumentSnapshotConfig {
|
|
.width = input.width,
|
|
.height = input.height,
|
|
.layers = std::span<const pp::document::DocumentLayerConfig>(layer_configs),
|
|
.frames = std::span<const pp::document::AnimationFrame>(root_frames),
|
|
});
|
|
if (!document) {
|
|
return pp::foundation::Result<DocumentCanvasSnapshotResult>::failure(document.status());
|
|
}
|
|
|
|
for (std::size_t layer_index = 0; layer_index < input.layers.size(); ++layer_index) {
|
|
for (const auto& payload : input.layers[layer_index].captured_face_payloads) {
|
|
pp::document::LayerFacePixels pixels {
|
|
.face_index = payload.face_index,
|
|
.x = payload.x,
|
|
.y = payload.y,
|
|
.width = payload.width,
|
|
.height = payload.height,
|
|
.rgba8 = std::vector<std::uint8_t>(payload.rgba8.begin(), payload.rgba8.end()),
|
|
};
|
|
const auto payload_status = document.value().set_layer_frame_face_pixels(
|
|
layer_index,
|
|
payload.frame_index,
|
|
std::move(pixels));
|
|
if (!payload_status.ok()) {
|
|
return pp::foundation::Result<DocumentCanvasSnapshotResult>::failure(payload_status);
|
|
}
|
|
}
|
|
}
|
|
|
|
auto active_status = document.value().set_active_layer(input.active_layer_index);
|
|
if (!active_status.ok()) {
|
|
return pp::foundation::Result<DocumentCanvasSnapshotResult>::failure(active_status);
|
|
}
|
|
|
|
active_status = document.value().set_active_frame(input.active_frame_index);
|
|
if (!active_status.ok()) {
|
|
return pp::foundation::Result<DocumentCanvasSnapshotResult>::failure(active_status);
|
|
}
|
|
|
|
return pp::foundation::Result<DocumentCanvasSnapshotResult>::success(DocumentCanvasSnapshotResult {
|
|
.document = std::move(document.value()),
|
|
.layer_count = input.layers.size(),
|
|
.frame_count = frame_count,
|
|
.pending_face_payloads = pending_face_payloads,
|
|
.captured_face_payloads = captured_face_payloads,
|
|
.metadata_only = captured_face_payloads == 0U,
|
|
.requires_renderer_payload_readback = pending_face_payloads > captured_face_payloads,
|
|
});
|
|
}
|
|
|
|
[[nodiscard]] inline DocumentCanvasSaveSnapshotReport make_document_canvas_save_snapshot_report(
|
|
const DocumentCanvasSnapshotResult& snapshot) noexcept
|
|
{
|
|
return DocumentCanvasSaveSnapshotReport {
|
|
.width = snapshot.document.width(),
|
|
.height = snapshot.document.height(),
|
|
.layer_count = snapshot.layer_count,
|
|
.frame_count = snapshot.frame_count,
|
|
.captured_face_payloads = snapshot.captured_face_payloads,
|
|
.pending_face_payloads = snapshot.pending_face_payloads,
|
|
.payload_complete = !snapshot.requires_renderer_payload_readback,
|
|
.can_export_ppi = !snapshot.requires_renderer_payload_readback,
|
|
};
|
|
}
|
|
|
|
[[nodiscard]] constexpr DocumentCanvasSaveWriterRoutePlan plan_document_canvas_save_writer_route(
|
|
DocumentCanvasSaveSnapshotReport report) noexcept
|
|
{
|
|
DocumentCanvasSaveWriterRoutePlan plan;
|
|
plan.payload_complete = report.payload_complete;
|
|
plan.can_export_ppi = report.can_export_ppi;
|
|
|
|
if (!report.payload_complete || !report.can_export_ppi) {
|
|
plan.fallback_reason = "canvas document snapshot still requires renderer payload readback";
|
|
return plan;
|
|
}
|
|
|
|
plan.action = DocumentCanvasSaveWriterAction::use_document_ppi_writer;
|
|
plan.uses_document_ppi_writer = true;
|
|
return plan;
|
|
}
|
|
|
|
[[nodiscard]] inline pp::foundation::Result<DocumentCanvasPpiExportResult>
|
|
export_document_canvas_save_snapshot_to_ppi(const DocumentCanvasSnapshotResult& snapshot)
|
|
{
|
|
const auto report = make_document_canvas_save_snapshot_report(snapshot);
|
|
const auto route = plan_document_canvas_save_writer_route(report);
|
|
if (!route.uses_document_ppi_writer) {
|
|
return pp::foundation::Result<DocumentCanvasPpiExportResult>::failure(
|
|
pp::foundation::Status::invalid_argument(route.fallback_reason.data()));
|
|
}
|
|
|
|
auto bytes = pp::document::export_ppi_project_document(snapshot.document);
|
|
if (!bytes) {
|
|
return pp::foundation::Result<DocumentCanvasPpiExportResult>::failure(bytes.status());
|
|
}
|
|
|
|
return pp::foundation::Result<DocumentCanvasPpiExportResult>::success(DocumentCanvasPpiExportResult {
|
|
.report = report,
|
|
.bytes = std::move(bytes.value()),
|
|
});
|
|
}
|
|
|
|
[[nodiscard]] inline pp::foundation::Result<DocumentCanvasProjectSaveTargetPlan>
|
|
plan_document_canvas_project_save_target(
|
|
std::string_view data_directory,
|
|
std::string_view target_path)
|
|
{
|
|
if (data_directory.empty()) {
|
|
return pp::foundation::Result<DocumentCanvasProjectSaveTargetPlan>::failure(
|
|
pp::foundation::Status::invalid_argument("project save data directory must not be empty"));
|
|
}
|
|
if (target_path.empty()) {
|
|
return pp::foundation::Result<DocumentCanvasProjectSaveTargetPlan>::failure(
|
|
pp::foundation::Status::invalid_argument("project save target path must not be empty"));
|
|
}
|
|
|
|
const auto basename_start = target_path.find_last_of("/\\");
|
|
const auto file_name_start = basename_start == std::string_view::npos ? 0U : basename_start + 1U;
|
|
auto file_name = target_path.substr(file_name_start);
|
|
if (file_name.empty()) {
|
|
return pp::foundation::Result<DocumentCanvasProjectSaveTargetPlan>::failure(
|
|
pp::foundation::Status::invalid_argument("project save target file name must not be empty"));
|
|
}
|
|
|
|
constexpr std::string_view ppi_extension = ".ppi";
|
|
if (file_name.size() > ppi_extension.size()
|
|
&& file_name.substr(file_name.size() - ppi_extension.size()) == ppi_extension) {
|
|
file_name.remove_suffix(ppi_extension.size());
|
|
}
|
|
|
|
DocumentCanvasProjectSaveTargetPlan plan;
|
|
plan.target_path = std::string(target_path);
|
|
plan.file_name = std::string(file_name);
|
|
plan.temporary_path.reserve(data_directory.size() + plan.file_name.size() + 10U);
|
|
plan.temporary_path += data_directory;
|
|
plan.temporary_path += "/";
|
|
plan.temporary_path += plan.file_name;
|
|
plan.temporary_path += ".tmp.ppi";
|
|
plan.timelapse_path.reserve(data_directory.size() + plan.file_name.size() + 6U);
|
|
plan.timelapse_path += data_directory;
|
|
plan.timelapse_path += "/";
|
|
plan.timelapse_path += plan.file_name;
|
|
plan.timelapse_path += ".pptl";
|
|
return pp::foundation::Result<DocumentCanvasProjectSaveTargetPlan>::success(std::move(plan));
|
|
}
|
|
|
|
[[nodiscard]] inline pp::foundation::Result<DocumentCanvasProjectSaveWritePlan>
|
|
plan_document_canvas_project_save_write(
|
|
const DocumentCanvasProjectSaveTargetPlan& target,
|
|
bool target_exists)
|
|
{
|
|
if (target.target_path.empty()) {
|
|
return pp::foundation::Result<DocumentCanvasProjectSaveWritePlan>::failure(
|
|
pp::foundation::Status::invalid_argument("project save write target path must not be empty"));
|
|
}
|
|
|
|
DocumentCanvasProjectSaveWritePlan plan;
|
|
plan.target_exists = target_exists;
|
|
plan.target_path = target.target_path;
|
|
plan.temporary_path = target.temporary_path;
|
|
|
|
if (!target_exists) {
|
|
plan.write_path = target.target_path;
|
|
return pp::foundation::Result<DocumentCanvasProjectSaveWritePlan>::success(std::move(plan));
|
|
}
|
|
|
|
if (target.temporary_path.empty()) {
|
|
return pp::foundation::Result<DocumentCanvasProjectSaveWritePlan>::failure(
|
|
pp::foundation::Status::invalid_argument("project save temporary path must not be empty"));
|
|
}
|
|
|
|
plan.action = DocumentCanvasProjectSaveWriteAction::write_temporary_then_swap;
|
|
plan.write_path = target.temporary_path;
|
|
plan.uses_temporary = true;
|
|
plan.falls_back_to_direct_on_temporary_open_failure = true;
|
|
return pp::foundation::Result<DocumentCanvasProjectSaveWritePlan>::success(std::move(plan));
|
|
}
|
|
|
|
[[nodiscard]] constexpr DocumentCanvasProjectSaveCommitPlan plan_document_canvas_project_save_commit(
|
|
DocumentCanvasProjectSaveCommitInput input) noexcept
|
|
{
|
|
DocumentCanvasProjectSaveCommitPlan plan;
|
|
plan.used_temporary = input.used_temporary;
|
|
|
|
if (!input.used_temporary) {
|
|
plan.saved = true;
|
|
plan.log_message = "project saved to target";
|
|
return plan;
|
|
}
|
|
|
|
if (!input.target_remove_attempted || !input.target_remove_succeeded) {
|
|
plan.log_message = "could not remove target project before temporary swap";
|
|
return plan;
|
|
}
|
|
|
|
plan.target_removed = true;
|
|
if (!input.temporary_rename_attempted || !input.temporary_rename_succeeded) {
|
|
plan.target_may_be_missing = true;
|
|
plan.log_message = "temporary project not swapped after original removal";
|
|
return plan;
|
|
}
|
|
|
|
plan.saved = true;
|
|
plan.temporary_renamed = true;
|
|
plan.log_message = "temporary project swapped successfully";
|
|
return plan;
|
|
}
|
|
|
|
[[nodiscard]] constexpr DocumentCanvasProjectSavePostCommitPlan plan_document_canvas_project_save_post_commit(
|
|
DocumentCanvasProjectSavePostCommitInput input) noexcept
|
|
{
|
|
DocumentCanvasProjectSavePostCommitPlan plan;
|
|
plan.dismisses_progress_ui = input.progress_ui_visible;
|
|
|
|
if (!input.save_succeeded) {
|
|
return plan;
|
|
}
|
|
|
|
plan.marks_document_clean = true;
|
|
plan.marks_new_document_committed = true;
|
|
plan.saves_timelapse_sidecar = input.timelapse_encoder_available;
|
|
plan.flushes_platform_storage = true;
|
|
return plan;
|
|
}
|
|
|
|
[[nodiscard]] inline pp::foundation::Result<DocumentCanvasClearPlan> plan_document_canvas_clear(
|
|
bool has_canvas,
|
|
float r = 0.0F,
|
|
float g = 0.0F,
|
|
float b = 0.0F,
|
|
float a = 0.0F) noexcept
|
|
{
|
|
const float channels[] { r, g, b, a };
|
|
for (const float channel : channels) {
|
|
const auto status = validate_clear_color_channel(channel);
|
|
if (!status.ok()) {
|
|
return pp::foundation::Result<DocumentCanvasClearPlan>::failure(status);
|
|
}
|
|
}
|
|
|
|
DocumentCanvasClearPlan plan;
|
|
plan.r = r;
|
|
plan.g = g;
|
|
plan.b = b;
|
|
plan.a = a;
|
|
plan.clears_canvas = has_canvas;
|
|
plan.records_undo = has_canvas;
|
|
plan.marks_unsaved = has_canvas;
|
|
plan.no_op = !has_canvas;
|
|
return pp::foundation::Result<DocumentCanvasClearPlan>::success(plan);
|
|
}
|
|
|
|
[[nodiscard]] inline pp::foundation::Status execute_document_canvas_clear_plan(
|
|
const DocumentCanvasClearPlan& plan,
|
|
DocumentCanvasClearServices& services)
|
|
{
|
|
const float channels[] { plan.r, plan.g, plan.b, plan.a };
|
|
for (const float channel : channels) {
|
|
const auto status = validate_clear_color_channel(channel);
|
|
if (!status.ok()) {
|
|
return status;
|
|
}
|
|
}
|
|
|
|
if (plan.no_op || !plan.clears_canvas) {
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
services.clear_current_canvas(plan.r, plan.g, plan.b, plan.a);
|
|
return pp::foundation::Status::success();
|
|
}
|
|
|
|
} // namespace pp::app
|