Extend app frame planning to tick and resize

src/app_core/app_frame.h

@@ -1,5 +1,10 @@
 #pragma once
 
+#include "foundation/result.h"
+
+#include <cmath>
+#include <limits>
+
 namespace pp::app {
 
 struct AppInitialSurfacePlan {
@@ -20,6 +25,20 @@ struct AppFrameDrawPlan {
     bool reset_redraw = true;
 };
 
+struct AppFrameTickPlan {
+    bool tick_designer_layout = false;
+    bool tick_main_layout = false;
+};
+
+struct AppResizePlan {
+    float width = 0.0F;
+    float height = 0.0F;
+    int render_target_width = 0;
+    int render_target_height = 0;
+    bool recreate_ui_render_target = true;
+    bool request_redraw = true;
+};
+
 [[nodiscard]] constexpr AppInitialSurfacePlan plan_app_initial_surface() noexcept
 {
     return AppInitialSurfacePlan {
@@ -53,4 +72,42 @@ struct AppFrameDrawPlan {
     };
 }
 
+[[nodiscard]] constexpr AppFrameTickPlan plan_app_frame_tick(
+    bool has_designer_layout,
+    bool has_main_layout) noexcept
+{
+    return AppFrameTickPlan {
+        .tick_designer_layout = has_designer_layout,
+        .tick_main_layout = has_main_layout,
+    };
+}
+
+[[nodiscard]] inline pp::foundation::Result<AppResizePlan> plan_app_resize(float width, float height)
+{
+    if (!std::isfinite(width) || !std::isfinite(height)) {
+        return pp::foundation::Result<AppResizePlan>::failure(
+            pp::foundation::Status::invalid_argument("resize dimensions must be finite"));
+    }
+
+    if (width < 1.0F || height < 1.0F) {
+        return pp::foundation::Result<AppResizePlan>::failure(
+            pp::foundation::Status::invalid_argument("resize dimensions must be positive"));
+    }
+
+    if (width > static_cast<float>(std::numeric_limits<int>::max())
+        || height > static_cast<float>(std::numeric_limits<int>::max())) {
+        return pp::foundation::Result<AppResizePlan>::failure(
+            pp::foundation::Status::out_of_range("resize dimensions exceed integer range"));
+    }
+
+    return pp::foundation::Result<AppResizePlan>::success(AppResizePlan {
+        .width = width,
+        .height = height,
+        .render_target_width = static_cast<int>(width),
+        .render_target_height = static_cast<int>(height),
+        .recreate_ui_render_target = true,
+        .request_redraw = true,
+    });
+}
+
 } // namespace pp::app

src/app_events.cpp

@@ -1,5 +1,6 @@
 #include "pch.h"
 #include "app.h"
+#include "app_core/app_frame.h"
 #include "app_core/document_platform_io.h"
 #include "app_core/document_sharing.h"
 #include "platform_api/platform_services.h"
@@ -89,19 +90,35 @@ void App::crash_test()
 
 void App::tick(float dt)
 {
-    if (auto* main = layout_designer[main_id])
+    const auto tick_plan = pp::app::plan_app_frame_tick(
+        layout_designer.get(main_id) != nullptr,
+        layout.get(main_id) != nullptr);
+    if (auto* main = layout_designer[main_id]; tick_plan.tick_designer_layout && main)
         main->tick(dt);
-    if (auto* main = layout[main_id])
+    if (auto* main = layout[main_id]; tick_plan.tick_main_layout && main)
         main->tick(dt);
 }
 
 void App::resize(float w, float h)
 {
     LOG("App::resize %d %d", (int)w, (int)h);
-    uirtt.create(static_cast<int>(w), static_cast<int>(h), -1, rgba8_internal_format(), true);
-    redraw = true;
-    width = w;
-    height = h;
+    const auto resize_plan = pp::app::plan_app_resize(w, h);
+    if (!resize_plan) {
+        LOG("App resize plan failed: %s", resize_plan.status().message);
+        return;
+    }
+
+    if (resize_plan.value().recreate_ui_render_target) {
+        uirtt.create(
+            resize_plan.value().render_target_width,
+            resize_plan.value().render_target_height,
+            -1,
+            rgba8_internal_format(),
+            true);
+    }
+    redraw = resize_plan.value().request_redraw;
+    width = resize_plan.value().width;
+    height = resize_plan.value().height;
 }
 
 void App::show_cursor()