From cc3490d9d837fb4c9d8d35513805d6cff070e6db Mon Sep 17 00:00:00 2001 From: omigamedev Date: Tue, 2 Jun 2026 23:49:13 +0200 Subject: [PATCH] Plan recording session decisions in app core --- CMakeLists.txt | 1 + docs/modernization/build-inventory.md | 7 ++ docs/modernization/capability-map.md | 2 +- docs/modernization/debt.md | 2 +- docs/modernization/roadmap.md | 11 +++ src/app.cpp | 54 ++++++++---- src/app_core/document_recording.h | 63 ++++++++++++++ tests/CMakeLists.txt | 28 ++++++ tests/app_core/document_recording_tests.cpp | 69 +++++++++++++++ tools/pano_cli/main.cpp | 94 +++++++++++++++++++++ 10 files changed, 314 insertions(+), 17 deletions(-) create mode 100644 src/app_core/document_recording.h create mode 100644 tests/app_core/document_recording_tests.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 14e529e..f65c9f3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -213,6 +213,7 @@ target_link_libraries(pp_ui_core add_library(pp_app_core STATIC src/app_core/document_cloud.h src/app_core/document_export.cpp + src/app_core/document_recording.h src/app_core/document_route.cpp src/app_core/document_session.cpp) target_include_directories(pp_app_core diff --git a/docs/modernization/build-inventory.md b/docs/modernization/build-inventory.md index 10a7a53..b4bdc56 100644 --- a/docs/modernization/build-inventory.md +++ b/docs/modernization/build-inventory.md @@ -418,6 +418,10 @@ Known local toolchain state: the live image, layer, animation-frame, depth, and cube-face export dialogs plus MP4 animation and timelapse export dialogs consume the same start contract before reaching legacy canvas/recording export execution. +- `pano_cli plan-recording-session` exposes `pp_app_core` recording start, + stop, clear, platform cleanup, frame-count reset, and export progress-total + planning as JSON; the live recording controls consume those contracts before + reaching legacy recording threads, PBO readback, and MP4 encoder execution. - `pano_cli plan-cloud-upload` exposes `pp_app_core` cloud upload availability, new-document warning, publish prompt, and save-before-upload planning as JSON; the live cloud upload command consumes the same start contract before @@ -443,6 +447,9 @@ Known local toolchain state: directory/stem targets, picked-directory stems, MP4 suggested names, and invalid export naming inputs, plus export-start license/canvas availability decisions. +- `pp_app_core_document_recording_tests` covers recording start/stop, clear, + platform recorded-file cleanup, frame-count reset, export progress totals, + and oversized progress-total clamping. - `pp_app_core_document_cloud_tests` covers cloud upload no-canvas, new-document warning, clean publish prompt, and dirty save-before-upload decisions, plus cloud browse no-canvas/show-browser and selected-download diff --git a/docs/modernization/capability-map.md b/docs/modernization/capability-map.md index 2cf21d1..e79b4cf 100644 --- a/docs/modernization/capability-map.md +++ b/docs/modernization/capability-map.md @@ -48,7 +48,7 @@ and validation command. | Blend/opacity/visibility/alpha lock | `Layer`, UI panels, shaders | `pp_document`, `pp_paint_renderer` | CPU model and render golden | | Selection mask | `Canvas` mask layer | `pp_document`, `pp_paint_renderer` | Mask apply/clear edge cases | | Animation frames | `LayerFrame`, animation panel | `pp_document`, `pp_panopainter_ui` | Duration, duplicate, remove, seek | -| MP4/timelapse export | `MP4Encoder`, recording thread, export dialogs | `pp_assets`, `pp_paint_renderer`, `pp_app_core`, app | Smoke export, cancellation, suggested-name tests | +| MP4/timelapse export | `MP4Encoder`, recording thread, export dialogs | `pp_assets`, `pp_paint_renderer`, `pp_app_core`, app | Recording lifecycle/progress decision tests, smoke export, cancellation, suggested-name tests | ## UI And Workflow diff --git a/docs/modernization/debt.md b/docs/modernization/debt.md index eff589f..e470ba3 100644 --- a/docs/modernization/debt.md +++ b/docs/modernization/debt.md @@ -22,7 +22,7 @@ agent or engineer to remove them without reconstructing context from chat. | --- | --- | --- | --- | --- | --- | --- | | DEBT-0001 | Open | Modernization | Existing platform build files remain alongside new CMake | Required for incremental migration without losing platform coverage | Existing platform builds plus new CMake configure | Remove after all platform builds consume shared CMake targets | | DEBT-0002 | Open | Modernization | Vendored SDK and patched libraries retained initially | Some dependencies are SDK-only, patched, or have platform-specific binaries | Dependency inventory and platform build smoke tests | Replace with vcpkg packages or document permanent vendored status after triplet evaluation | -| DEBT-0003 | Open | Modernization | Existing singletons remain during initial split; `App::open_document`, `App::request_close`, `App::cloud_upload`, `App::cloud_upload_all`, `App::cloud_browse`, file-menu save actions, `NodeCanvas` save hotkeys, new/open/browse dirty-document workflow prompts, new-document target/resolution/overwrite decisions, save-as document file naming and overwrite decisions, save-version target decisions, export start/target naming/path decisions, cloud-upload prompt/save-before-upload decisions, cloud-browse availability and selected-download decisions, bulk cloud-upload progress decisions, `pano_cli classify-open`, `pano_cli plan-open-route`, `pano_cli plan-new-document`, `pano_cli plan-document-file`, `pano_cli plan-document-version`, `pano_cli plan-export-start`, `pano_cli plan-export-target`, `pano_cli plan-cloud-upload`, `pano_cli plan-cloud-browse`, `pano_cli plan-cloud-upload-all`, and `pano_cli simulate-app-session` now consume pure `pp_app_core` route/session/export/cloud contracts, but document creation/loading, brush import execution, saving, export execution, cloud upload execution, and cloud browse/download execution still reach legacy `Canvas::I`/UI/network singletons | Avoid behavior changes while introducing component boundaries | App launch and component tests; `pp_app_core_document_route_tests`; `pp_app_core_document_export_tests`; `pp_app_core_document_cloud_tests`; `pp_app_core_document_session_tests`; `pano_cli classify-open --path D:/Paint/demo.ppi`; `pano_cli plan-open-route --path D:/Paint/demo.ppi --unsaved`; `pano_cli plan-new-document --work-dir D:/Paint --name demo --resolution-index 3 --target-exists`; `pano_cli plan-document-file --work-dir D:/Paint --name demo --target-exists`; `pano_cli plan-document-version --directory D:/Paint --doc-name demo.01 --existing-path D:/Paint/demo.02.ppi`; `pano_cli plan-export-start --requires-license --demo`; `pano_cli plan-export-target --kind file --work-dir D:/Paint --doc-name demo --extension .png`; `pano_cli plan-cloud-upload --new-document --unsaved`; `pano_cli plan-cloud-browse --selected-file demo.ppi`; `pano_cli plan-cloud-upload-all --file-count 3`; `pano_cli simulate-app-session --unsaved --save-intent save-dirty-version`; `pano_cli simulate-app-session --no-canvas`; `ctest --preset desktop-fast --build-config Debug` | Replace singleton reaches with context/service injection at component boundaries | +| DEBT-0003 | Open | Modernization | Existing singletons remain during initial split; `App::open_document`, `App::request_close`, `App::cloud_upload`, `App::cloud_upload_all`, `App::cloud_browse`, `App::rec_start`, `App::rec_stop`, `App::rec_clear`, `App::rec_export`, file-menu save actions, `NodeCanvas` save hotkeys, new/open/browse dirty-document workflow prompts, new-document target/resolution/overwrite decisions, save-as document file naming and overwrite decisions, save-version target decisions, export start/target naming/path decisions, recording lifecycle/export progress decisions, cloud-upload prompt/save-before-upload decisions, cloud-browse availability and selected-download decisions, bulk cloud-upload progress decisions, `pano_cli classify-open`, `pano_cli plan-open-route`, `pano_cli plan-new-document`, `pano_cli plan-document-file`, `pano_cli plan-document-version`, `pano_cli plan-export-start`, `pano_cli plan-export-target`, `pano_cli plan-recording-session`, `pano_cli plan-cloud-upload`, `pano_cli plan-cloud-browse`, `pano_cli plan-cloud-upload-all`, and `pano_cli simulate-app-session` now consume pure `pp_app_core` route/session/export/recording/cloud contracts, but document creation/loading, brush import execution, saving, export execution, recording/MP4 execution, cloud upload execution, and cloud browse/download execution still reach legacy `Canvas::I`/UI/network/video singletons | Avoid behavior changes while introducing component boundaries | App launch and component tests; `pp_app_core_document_route_tests`; `pp_app_core_document_export_tests`; `pp_app_core_document_recording_tests`; `pp_app_core_document_cloud_tests`; `pp_app_core_document_session_tests`; `pano_cli classify-open --path D:/Paint/demo.ppi`; `pano_cli plan-open-route --path D:/Paint/demo.ppi --unsaved`; `pano_cli plan-new-document --work-dir D:/Paint --name demo --resolution-index 3 --target-exists`; `pano_cli plan-document-file --work-dir D:/Paint --name demo --target-exists`; `pano_cli plan-document-version --directory D:/Paint --doc-name demo.01 --existing-path D:/Paint/demo.02.ppi`; `pano_cli plan-export-start --requires-license --demo`; `pano_cli plan-export-target --kind file --work-dir D:/Paint --doc-name demo --extension .png`; `pano_cli plan-recording-session --running --frame-count 12`; `pano_cli plan-cloud-upload --new-document --unsaved`; `pano_cli plan-cloud-browse --selected-file demo.ppi`; `pano_cli plan-cloud-upload-all --file-count 3`; `pano_cli simulate-app-session --unsaved --save-intent save-dirty-version`; `pano_cli simulate-app-session --no-canvas`; `ctest --preset desktop-fast --build-config Debug` | Replace singleton reaches with context/service injection at component boundaries | | DEBT-0004 | Open | Modernization | Android, Linux, WebGL, Apple, and AppX build files remain platform-specific until root CMake alignment reaches them | Prevent platform regressions during incremental migration; raw Windows `.sln/.vcxproj` files were removed on 2026-05-31 by user decision | `cmake --preset windows-msvc-default`; platform-specific configure/build smoke checks as each platform is migrated | Root CMake owns every platform source list and package path | | DEBT-0005 | Open | Modernization | Temporary local CTest harness is used before Catch2 is wired through vcpkg | `vcpkg` is not currently on PATH, but headless tests need to run now | `ctest --preset desktop-fast --build-config Debug` | Replace `tests/test_harness.h` tests with Catch2 tests once vcpkg toolchain/presets are validated | | DEBT-0007 | Open | Modernization | `vcpkg.json` and `windows-msvc-vcpkg-headless` are validated for the headless Windows component matrix, but app targets still use vendored libraries and Android/Apple triplets are not proven | Dependency migration must stay incremental while SDK/patched/vendor dependencies remain in use | `$env:VCPKG_ROOT="C:\Program Files\Microsoft Visual Studio\2022\Community\VC\vcpkg"; cmake --preset windows-msvc-vcpkg-headless`; `ctest --preset desktop-fast-vcpkg --build-config Debug` | Component targets consume vcpkg packages where reliable and desktop app, Android, and Apple triplets are validated or explicitly documented as permanent vendor exceptions | diff --git a/docs/modernization/roadmap.md b/docs/modernization/roadmap.md index 31236bb..aa3d6f4 100644 --- a/docs/modernization/roadmap.md +++ b/docs/modernization/roadmap.md @@ -444,6 +444,10 @@ stems, and MP4 suggested names used by the live export dialogs. used by live image, layer, animation-frame, depth, and cube-face export dialogs plus MP4 animation and timelapse export dialogs before they call legacy canvas/recording export execution. +`pano_cli plan-recording-session` exposes the app-core recording start, stop, +clear, platform recorded-file cleanup, frame reset, and export progress-total +decisions used by the live recording controls before legacy recording threads, +PBO readback, and MP4 encoder execution continue. `pano_cli plan-cloud-upload` exposes the app-core cloud upload decision used by the live cloud upload command for missing-canvas, new-document warning, publish prompt, and dirty-document save-before-upload states before legacy UI, canvas, @@ -918,6 +922,13 @@ Results: `pano_cli_plan_cloud_browse_selected_smoke`, and `pano_cli_plan_cloud_browse_no_canvas_smoke` passed and expose app-core cloud browse/download-selection decisions as JSON. +- `pp_app_core_document_recording_tests` passed, covering recording start/stop, + clear, platform recorded-file cleanup, frame-count reset, export progress + totals, and oversized progress-total clamping. +- `pano_cli_plan_recording_session_stopped_smoke`, + `pano_cli_plan_recording_session_running_smoke`, and + `pano_cli_plan_recording_session_platform_cleanup_smoke` passed and expose + app-core recording lifecycle/export decisions as JSON. - `panopainter_validate_shaders` passed, validating 25 shader programs and 7 shader includes for stage markers and include graph integrity. - `pp_renderer_gl_capabilities_tests` passed on default MSVC, vcpkg-headless, diff --git a/src/app.cpp b/src/app.cpp index 1ee67ec..bbcf890 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -5,6 +5,7 @@ #include "node_dialog_open.h" #include "node_progress_bar.h" #include "mp4enc.h" +#include "app_core/document_recording.h" #include "app_core/document_route.h" #include "app_core/document_session.h" #include "renderer_gl/opengl_capabilities.h" @@ -880,47 +881,70 @@ void App::renderdoc_frame_end() void App::rec_clear() { - rec_stop(); + const auto plan = pp::app::plan_recording_clear( + rec_running, #if defined(__IOS__) || defined(__OSX__) - delete_all_files_in_path(rec_path); + true +#else + false #endif - rec_count = 0; + ); + if (plan.stop_running_recording) + rec_stop(); +#if defined(__IOS__) || defined(__OSX__) + if (plan.delete_recorded_files) + delete_all_files_in_path(rec_path); +#endif + rec_count = plan.frame_count_after_clear; update_rec_frames(); } void App::rec_start() { - if (!rec_running) + const auto plan = pp::app::plan_recording_start(rec_running); + switch (plan) { - update_rec_frames(); - rec_thread = std::thread(&App::rec_loop, this); + case pp::app::RecordingStartAction::start_thread: + break; + case pp::app::RecordingStartAction::no_op_already_running: + return; } + + update_rec_frames(); + rec_thread = std::thread(&App::rec_loop, this); } void App::rec_stop() { - if (rec_running) + const auto plan = pp::app::plan_recording_stop(rec_running); + switch (plan) { - rec_running = false; - rec_cv.notify_all(); - if (rec_thread.joinable()) - rec_thread.join(); - update_rec_frames(); + case pp::app::RecordingStopAction::stop_thread: + break; + case pp::app::RecordingStopAction::no_op_not_running: + return; } + + rec_running = false; + rec_cv.notify_all(); + if (rec_thread.joinable()) + rec_thread.join(); + update_rec_frames(); } void App::rec_export(std::string path) { - int progress = 0; - int tot = rec_count; + const auto plan = pp::app::plan_recording_export(static_cast(rec_count)); auto pb = layout[main_id]->add_child(); pb->m_progress->SetWidthP(0); pb->m_title->set_text("Exporting MP4 movie"); + pb->m_total = plan.progress_total; + pb->m_count = 0; /* #if defined(__IOS__) || defined(__OSX__) export_mp4(rec_path, width, height, rec_count, ^(float) { - pb->m_progress->SetWidthP((float)progress / tot * 100.f); + pb->increment(); }); #endif */ diff --git a/src/app_core/document_recording.h b/src/app_core/document_recording.h new file mode 100644 index 0000000..55d576c --- /dev/null +++ b/src/app_core/document_recording.h @@ -0,0 +1,63 @@ +#pragma once + +#include +#include + +namespace pp::app { + +enum class RecordingStartAction { + start_thread, + no_op_already_running, +}; + +enum class RecordingStopAction { + stop_thread, + no_op_not_running, +}; + +struct RecordingClearPlan { + bool stop_running_recording = false; + bool delete_recorded_files = false; + int frame_count_after_clear = 0; +}; + +struct RecordingExportPlan { + std::size_t frame_count = 0; + int progress_total = 0; +}; + +[[nodiscard]] constexpr RecordingStartAction plan_recording_start(bool is_running) noexcept +{ + return is_running + ? RecordingStartAction::no_op_already_running + : RecordingStartAction::start_thread; +} + +[[nodiscard]] constexpr RecordingStopAction plan_recording_stop(bool is_running) noexcept +{ + return is_running + ? RecordingStopAction::stop_thread + : RecordingStopAction::no_op_not_running; +} + +[[nodiscard]] constexpr RecordingClearPlan plan_recording_clear( + bool is_running, + bool platform_deletes_recorded_files) noexcept +{ + return { + is_running, + platform_deletes_recorded_files, + 0, + }; +} + +[[nodiscard]] constexpr RecordingExportPlan plan_recording_export(std::size_t frame_count) noexcept +{ + const auto max_progress_total = static_cast(std::numeric_limits::max()); + return { + frame_count, + frame_count > max_progress_total ? std::numeric_limits::max() : static_cast(frame_count), + }; +} + +} diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 769651d..f75c4e8 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -288,6 +288,16 @@ add_test(NAME pp_app_core_document_cloud_tests COMMAND pp_app_core_document_clou set_tests_properties(pp_app_core_document_cloud_tests PROPERTIES LABELS "app;desktop-fast;fuzz") +add_executable(pp_app_core_document_recording_tests + app_core/document_recording_tests.cpp) +target_link_libraries(pp_app_core_document_recording_tests PRIVATE + pp_app_core + pp_test_harness) + +add_test(NAME pp_app_core_document_recording_tests COMMAND pp_app_core_document_recording_tests) +set_tests_properties(pp_app_core_document_recording_tests PROPERTIES + LABELS "app;desktop-fast;fuzz") + add_executable(pp_app_core_document_session_tests app_core/document_session_tests.cpp) target_link_libraries(pp_app_core_document_session_tests PRIVATE @@ -543,6 +553,24 @@ if(TARGET pano_cli) LABELS "app;integration;desktop-fast" PASS_REGULAR_EXPRESSION "\"command\":\"plan-cloud-upload-all\".*\"fileCount\":3.*\"progressUiAvailable\":false.*\"progressTotal\":3.*\"showProgress\":false") + add_test(NAME pano_cli_plan_recording_session_stopped_smoke + COMMAND pano_cli plan-recording-session --frame-count 12) + set_tests_properties(pano_cli_plan_recording_session_stopped_smoke PROPERTIES + LABELS "app;integration;desktop-fast" + PASS_REGULAR_EXPRESSION "\"command\":\"plan-recording-session\".*\"running\":false.*\"frameCount\":12.*\"startDecision\":\"start-thread\".*\"stopDecision\":\"no-op-not-running\".*\"stopRunningRecording\":false.*\"deleteRecordedFiles\":false.*\"progressTotal\":12") + + add_test(NAME pano_cli_plan_recording_session_running_smoke + COMMAND pano_cli plan-recording-session --running --frame-count 12) + set_tests_properties(pano_cli_plan_recording_session_running_smoke PROPERTIES + LABELS "app;integration;desktop-fast" + PASS_REGULAR_EXPRESSION "\"command\":\"plan-recording-session\".*\"running\":true.*\"startDecision\":\"no-op-already-running\".*\"stopDecision\":\"stop-thread\".*\"stopRunningRecording\":true.*\"progressTotal\":12") + + add_test(NAME pano_cli_plan_recording_session_platform_cleanup_smoke + COMMAND pano_cli plan-recording-session --platform-deletes-recorded-files) + set_tests_properties(pano_cli_plan_recording_session_platform_cleanup_smoke PROPERTIES + LABELS "app;integration;desktop-fast;fuzz" + PASS_REGULAR_EXPRESSION "\"command\":\"plan-recording-session\".*\"platformDeletesRecordedFiles\":true.*\"deleteRecordedFiles\":true.*\"frameCountAfterClear\":0") + add_test(NAME pano_cli_simulate_app_session_clean_smoke COMMAND pano_cli simulate-app-session) set_tests_properties(pano_cli_simulate_app_session_clean_smoke PROPERTIES diff --git a/tests/app_core/document_recording_tests.cpp b/tests/app_core/document_recording_tests.cpp new file mode 100644 index 0000000..3d31aed --- /dev/null +++ b/tests/app_core/document_recording_tests.cpp @@ -0,0 +1,69 @@ +#include "app_core/document_recording.h" +#include "test_harness.h" + +#include + +namespace { + +void recording_start_only_starts_when_not_running(pp::tests::Harness& harness) +{ + PP_EXPECT( + harness, + pp::app::plan_recording_start(false) == pp::app::RecordingStartAction::start_thread); + PP_EXPECT( + harness, + pp::app::plan_recording_start(true) == pp::app::RecordingStartAction::no_op_already_running); +} + +void recording_stop_only_stops_when_running(pp::tests::Harness& harness) +{ + PP_EXPECT( + harness, + pp::app::plan_recording_stop(true) == pp::app::RecordingStopAction::stop_thread); + PP_EXPECT( + harness, + pp::app::plan_recording_stop(false) == pp::app::RecordingStopAction::no_op_not_running); +} + +void recording_clear_resets_frames_and_preserves_platform_delete_flag(pp::tests::Harness& harness) +{ + const auto running_desktop = pp::app::plan_recording_clear(true, false); + PP_EXPECT(harness, running_desktop.stop_running_recording); + PP_EXPECT(harness, !running_desktop.delete_recorded_files); + PP_EXPECT(harness, running_desktop.frame_count_after_clear == 0); + + const auto stopped_apple = pp::app::plan_recording_clear(false, true); + PP_EXPECT(harness, !stopped_apple.stop_running_recording); + PP_EXPECT(harness, stopped_apple.delete_recorded_files); + PP_EXPECT(harness, stopped_apple.frame_count_after_clear == 0); +} + +void recording_export_tracks_frame_count(pp::tests::Harness& harness) +{ + const auto plan = pp::app::plan_recording_export(120); + PP_EXPECT(harness, plan.frame_count == 120); + PP_EXPECT(harness, plan.progress_total == 120); +} + +void recording_export_clamps_progress_total(pp::tests::Harness& harness) +{ + const auto too_many_frames = static_cast(std::numeric_limits::max()) + 1U; + const auto plan = pp::app::plan_recording_export(too_many_frames); + PP_EXPECT(harness, plan.frame_count == too_many_frames); + PP_EXPECT(harness, plan.progress_total == std::numeric_limits::max()); +} + +} + +int main() +{ + pp::tests::Harness harness; + harness.run("recording start only starts when not running", recording_start_only_starts_when_not_running); + harness.run("recording stop only stops when running", recording_stop_only_stops_when_running); + harness.run( + "recording clear resets frames and preserves platform delete flag", + recording_clear_resets_frames_and_preserves_platform_delete_flag); + harness.run("recording export tracks frame count", recording_export_tracks_frame_count); + harness.run("recording export clamps progress total", recording_export_clamps_progress_total); + return harness.finish(); +} diff --git a/tools/pano_cli/main.cpp b/tools/pano_cli/main.cpp index 4c8d42c..78fb104 100644 --- a/tools/pano_cli/main.cpp +++ b/tools/pano_cli/main.cpp @@ -1,5 +1,6 @@ #include "app_core/document_export.h" #include "app_core/document_cloud.h" +#include "app_core/document_recording.h" #include "app_core/document_route.h" #include "app_core/document_session.h" #include "assets/image_format.h" @@ -153,6 +154,12 @@ struct PlanCloudUploadAllArgs { bool progress_ui_available = true; }; +struct PlanRecordingSessionArgs { + bool running = false; + std::uint32_t frame_count = 0; + bool platform_deletes_recorded_files = false; +}; + struct SimulateAppSessionArgs { bool has_canvas = true; bool new_document = false; @@ -450,6 +457,30 @@ const char* cloud_download_selection_action_name(pp::app::CloudDownloadSelection return "wait-for-selection"; } +const char* recording_start_action_name(pp::app::RecordingStartAction action) noexcept +{ + switch (action) { + case pp::app::RecordingStartAction::start_thread: + return "start-thread"; + case pp::app::RecordingStartAction::no_op_already_running: + return "no-op-already-running"; + } + + return "no-op-already-running"; +} + +const char* recording_stop_action_name(pp::app::RecordingStopAction action) noexcept +{ + switch (action) { + case pp::app::RecordingStopAction::stop_thread: + return "stop-thread"; + case pp::app::RecordingStopAction::no_op_not_running: + return "no-op-not-running"; + } + + return "no-op-not-running"; +} + pp::foundation::Result parse_float_arg(std::string_view text) { float value = 0.0F; @@ -489,6 +520,7 @@ void print_help() << " plan-cloud-upload [--no-canvas] [--new-document] [--unsaved]\n" << " plan-cloud-browse [--no-canvas] [--selected-file FILE]\n" << " plan-cloud-upload-all [--file-count N] [--no-progress-ui]\n" + << " plan-recording-session [--running] [--frame-count N] [--platform-deletes-recorded-files]\n" << " load-project --path FILE\n" << " parse-layout --path FILE\n" << " record-render [--width N] [--height N] [--exercise-clear]\n" @@ -1764,6 +1796,64 @@ int plan_cloud_upload_all(int argc, char** argv) return 0; } +pp::foundation::Status parse_plan_recording_session_args( + int argc, + char** argv, + PlanRecordingSessionArgs& args) +{ + for (int i = 2; i < argc; ++i) { + const std::string_view key(argv[i]); + if (key == "--running") { + args.running = true; + } else if (key == "--frame-count") { + if (i + 1 >= argc) { + return pp::foundation::Status::invalid_argument("missing value for option"); + } + const auto value = pp::foundation::parse_u32(argv[++i]); + if (!value) { + return value.status(); + } + args.frame_count = value.value(); + } else if (key == "--platform-deletes-recorded-files") { + args.platform_deletes_recorded_files = true; + } else { + return pp::foundation::Status::invalid_argument("unknown option"); + } + } + + return pp::foundation::Status::success(); +} + +int plan_recording_session(int argc, char** argv) +{ + PlanRecordingSessionArgs args; + const auto status = parse_plan_recording_session_args(argc, argv, args); + if (!status.ok()) { + print_error("plan-recording-session", status.message); + return 2; + } + + const auto start = pp::app::plan_recording_start(args.running); + const auto stop = pp::app::plan_recording_stop(args.running); + const auto clear = pp::app::plan_recording_clear( + args.running, + args.platform_deletes_recorded_files); + const auto export_plan = pp::app::plan_recording_export(args.frame_count); + std::cout << "{\"ok\":true,\"command\":\"plan-recording-session\"" + << ",\"state\":{\"running\":" << json_bool(args.running) + << ",\"frameCount\":" << args.frame_count + << ",\"platformDeletesRecordedFiles\":" << json_bool(args.platform_deletes_recorded_files) + << "},\"startDecision\":\"" << recording_start_action_name(start) + << "\",\"stopDecision\":\"" << recording_stop_action_name(stop) + << "\",\"clear\":{\"stopRunningRecording\":" << json_bool(clear.stop_running_recording) + << ",\"deleteRecordedFiles\":" << json_bool(clear.delete_recorded_files) + << ",\"frameCountAfterClear\":" << clear.frame_count_after_clear + << "},\"export\":{\"frameCount\":" << export_plan.frame_count + << ",\"progressTotal\":" << export_plan.progress_total + << "}}\n"; + return 0; +} + pp::foundation::Status parse_plan_export_target_args( int argc, char** argv, @@ -3927,6 +4017,10 @@ int main(int argc, char** argv) return plan_cloud_upload_all(argc, argv); } + if (command == "plan-recording-session") { + return plan_recording_session(argc, argv); + } + if (command == "load-project") { return load_project(argc, argv); }