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

Route app thread orchestration through app core

Browse Source
This commit is contained in:
omigamedev
2026-06-05 07:01:51 +02:00
parent 32c95b224f
commit c50ea14a2a
12 changed files with 749 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

209
tools/pano_cli/main.cpp
View File

@@ -5,6 +5,7 @@
#include "app_core/app_shutdown.h"
#include "app_core/app_status.h"
#include "app_core/app_startup.h"
#include "app_core/app_thread.h"
#include "app_core/brush_package_import.h"
#include "app_core/brush_package_export.h"
#include "app_core/brush_ui.h"
@@ -264,6 +265,25 @@ struct PlanAppFrameArgs {
bool bad_resize = false;
};
struct PlanAppThreadArgs {
std::string kind = "dispatch";
bool on_target_thread = false;
bool unique = false;
bool worker_running = true;
bool wait = false;
bool request_redraw = false;
bool redraw = false;
bool live_reload = false;
bool joinable = true;
std::uint32_t queued_tasks = 0;
int rendered_frames = 0;
float delta_time_seconds = 0.25F;
float frame_accumulator = 0.5F;
float fps_accumulator = 0.9F;
float reload_accumulator = 0.9F;
bool bad_timer = false;
};
struct PlanAppInputArgs {
std::string kind = "pointer";
float x0 = 100.0F;
@@ -2075,6 +2095,7 @@ void print_help()
<< " plan-app-startup [--run-counter N] [--auto-timelapse-disabled] [--vr-controllers-disabled] [--license-invalid]\n"
<< " plan-app-startup-resources [--width N] [--height N] [--bad-size]\n"
<< " plan-app-frame [--redraw] [--animate] [--no-designer-layout] [--no-main-layout] [--no-canvas] [--no-canvas-document] [--vr-active] [--ui-hidden] [--vr-only] [--resize-width N] [--resize-height N] [--bad-resize]\n"
<< " plan-app-thread --kind dispatch|render-drain|ui-drain|ui-tick|ui-loop|redraw|start|stop [--on-target-thread] [--unique] [--worker-stopped] [--wait] [--request-redraw] [--redraw] [--live-reload] [--not-joinable] [--queued-tasks N] [--rendered-frames N] [--dt N] [--frame-accumulator N] [--fps-accumulator N] [--reload-accumulator N] [--bad-timer]\n"
<< " plan-app-input --kind pointer|gesture|cancel|main|key|ui-toggle|stylus [--x N] [--y N] [--x1 N] [--y1 N] [--prev-x N] [--prev-y N] [--prev-x1 N] [--prev-y1 N] [--zoom N] [--no-designer-layout] [--no-main-layout] [--spacebar] [--vr-active] [--key-up] [--ui-hidden] [--no-canvas] [--main-child-count N] [--panel-child-count N] [--bad-float]\n"
<< " plan-app-shutdown\n"
<< " plan-command-convert [--project FILE] [--output FILE] [--canvas-resolution N]\n"
@@ -3885,6 +3906,190 @@ int plan_app_frame(int argc, char** argv)
return 0;
}
pp::foundation::Status parse_plan_app_thread_args(
int argc,
char** argv,
PlanAppThreadArgs& args)
{
for (int i = 2; i < argc; ++i) {
const std::string_view key(argv[i]);
if (key == "--kind") {
if (i + 1 >= argc) {
return pp::foundation::Status::invalid_argument("missing value for option");
}
args.kind = argv[++i];
} else if (key == "--on-target-thread") {
args.on_target_thread = true;
} else if (key == "--unique") {
args.unique = true;
} else if (key == "--worker-stopped") {
args.worker_running = false;
} else if (key == "--wait") {
args.wait = true;
} else if (key == "--request-redraw") {
args.request_redraw = true;
} else if (key == "--redraw") {
args.redraw = true;
} else if (key == "--live-reload") {
args.live_reload = true;
} else if (key == "--not-joinable") {
args.joinable = false;
} else if (key == "--bad-timer") {
args.bad_timer = true;
} else if (key == "--queued-tasks") {
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.queued_tasks = value.value();
} else if (key == "--rendered-frames") {
if (i + 1 >= argc) {
return pp::foundation::Status::invalid_argument("missing value for option");
}
const auto value = parse_i32_arg(argv[++i]);
if (!value) {
return value.status();
}
args.rendered_frames = value.value();
} else if (key == "--dt" || key == "--frame-accumulator"
|| key == "--fps-accumulator" || key == "--reload-accumulator") {
if (i + 1 >= argc) {
return pp::foundation::Status::invalid_argument("missing value for option");
}
const auto value = parse_float_arg(argv[++i]);
if (!value) {
return value.status();
}
if (key == "--dt") {
args.delta_time_seconds = value.value();
} else if (key == "--frame-accumulator") {
args.frame_accumulator = value.value();
} else if (key == "--fps-accumulator") {
args.fps_accumulator = value.value();
} else {
args.reload_accumulator = value.value();
}
} else {
return pp::foundation::Status::invalid_argument("unknown option");
}
}
return pp::foundation::Status::success();
}
int plan_app_thread(int argc, char** argv)
{
PlanAppThreadArgs args;
const auto status = parse_plan_app_thread_args(argc, argv, args);
if (!status.ok()) {
print_error("plan-app-thread", status.message);
return 2;
}
std::cout << "{\"ok\":true,\"command\":\"plan-app-thread\",\"kind\":\""
<< json_escape(args.kind) << "\"";
if (args.kind == "dispatch") {
const auto plan = pp::app::plan_app_task_dispatch(
args.on_target_thread,
args.unique,
args.queued_tasks,
args.worker_running,
args.wait,
args.request_redraw);
std::cout << ",\"plan\":{\"executeImmediately\":" << json_bool(plan.execute_immediately)
<< ",\"queueTask\":" << json_bool(plan.queue_task)
<< ",\"removeMatchingUniqueTask\":" << json_bool(plan.remove_matching_unique_task)
<< ",\"notifyWorker\":" << json_bool(plan.notify_worker)
<< ",\"waitForCompletion\":" << json_bool(plan.wait_for_completion)
<< ",\"requestRedraw\":" << json_bool(plan.request_redraw)
<< "}}\n";
return 0;
}
if (args.kind == "render-drain" || args.kind == "ui-drain") {
const auto plan = args.kind == "render-drain"
? pp::app::plan_app_render_queue_drain(args.queued_tasks)
: pp::app::plan_app_ui_queue_drain(args.queued_tasks);
std::cout << ",\"plan\":{\"markRunning\":" << json_bool(plan.mark_running)
<< ",\"drainTasks\":" << json_bool(plan.drain_tasks)
<< ",\"wrapInRenderContext\":" << json_bool(plan.wrap_in_render_context)
<< ",\"taskCount\":" << plan.task_count
<< "}}\n";
return 0;
}
if (args.kind == "ui-tick") {
const auto plan = pp::app::plan_app_ui_thread_tick(args.queued_tasks, args.redraw);
std::cout << ",\"plan\":{\"markRunning\":" << json_bool(plan.mark_running)
<< ",\"executeTasks\":" << json_bool(plan.execute_tasks)
<< ",\"tickApp\":" << json_bool(plan.tick_app)
<< ",\"updateBeforeRender\":" << json_bool(plan.update_before_render)
<< ",\"enqueueRenderFrame\":" << json_bool(plan.enqueue_render_frame)
<< ",\"taskCount\":" << plan.task_count
<< "}}\n";
return 0;
}
if (args.kind == "ui-loop") {
const auto plan = pp::app::plan_app_ui_loop_timers(
args.bad_timer ? -1.0F : args.delta_time_seconds,
args.frame_accumulator,
args.fps_accumulator,
args.reload_accumulator,
args.rendered_frames,
args.live_reload);
if (!plan) {
print_error("plan-app-thread", plan.status().message);
return 2;
}
std::cout << ",\"plan\":{\"updatePlatformFrame\":" << json_bool(plan.value().update_platform_frame)
<< ",\"frameAccumulator\":" << plan.value().frame_accumulator
<< ",\"fpsAccumulator\":" << plan.value().fps_accumulator
<< ",\"reloadAccumulator\":" << plan.value().reload_accumulator
<< ",\"reportRenderedFrames\":" << json_bool(plan.value().report_rendered_frames)
<< ",\"reportedFrameCount\":" << plan.value().reported_frame_count
<< ",\"renderedFramesAfterReport\":" << plan.value().rendered_frames_after_report
<< ",\"checkLiveAssetReload\":" << json_bool(plan.value().check_live_asset_reload)
<< "}}\n";
return 0;
}
if (args.kind == "redraw") {
const auto plan = pp::app::plan_app_ui_loop_redraw(args.redraw, args.rendered_frames);
std::cout << ",\"plan\":{\"tickApp\":" << json_bool(plan.tick_app)
<< ",\"updateBeforeRender\":" << json_bool(plan.update_before_render)
<< ",\"enqueueRenderFrame\":" << json_bool(plan.enqueue_render_frame)
<< ",\"resetFrameAccumulator\":" << json_bool(plan.reset_frame_accumulator)
<< ",\"renderedFrames\":" << plan.rendered_frames
<< "}}\n";
return 0;
}
if (args.kind == "start") {
const auto plan = pp::app::plan_app_thread_start();
std::cout << ",\"plan\":{\"startThread\":" << json_bool(plan.start_thread)
<< ",\"markRunning\":" << json_bool(plan.mark_running)
<< "}}\n";
return 0;
}
if (args.kind == "stop") {
const auto plan = pp::app::plan_app_thread_stop(args.joinable);
std::cout << ",\"plan\":{\"markNotRunning\":" << json_bool(plan.mark_not_running)
<< ",\"notifyWorker\":" << json_bool(plan.notify_worker)
<< ",\"joinThread\":" << json_bool(plan.join_thread)
<< "}}\n";
return 0;
}
print_error("plan-app-thread", "unknown app thread plan kind");
return 2;
}
pp::foundation::Status parse_plan_app_input_args(
int argc,
char** argv,
@@ -10469,6 +10674,10 @@ int main(int argc, char** argv)
return plan_app_frame(argc, argv);
}
if (command == "plan-app-thread") {
return plan_app_thread(argc, argv);
}
if (command == "plan-app-input") {
return plan_app_input(argc, argv);
}