Extract grid UI operation planning

src/app_core/grid_ui.h

@@ -0,0 +1,145 @@
+#pragma once
+
+#include "foundation/result.h"
+
+#include <string>
+#include <string_view>
+#include <utility>
+
+namespace pp::app {
+
+enum class GridUiOperation {
+    request_heightmap_pick,
+    load_heightmap,
+    clear_heightmap,
+    reload_heightmap,
+    render_lightmap,
+    commit_heightmap,
+};
+
+struct GridUiPlan {
+    GridUiOperation operation = GridUiOperation::request_heightmap_pick;
+    std::string path;
+    int texture_resolution = 0;
+    int sample_count = 0;
+    bool opens_picker = false;
+    bool loads_heightmap = false;
+    bool clears_heightmap = false;
+    bool renders_lightmap = false;
+    bool commits_heightmap = false;
+    bool updates_preview = false;
+    bool updates_ground_opacity = false;
+    bool updates_shading_mode = false;
+    bool shows_unsupported_message = false;
+    bool shows_progress = false;
+    bool mutates_grid_state = false;
+};
+
+[[nodiscard]] inline pp::foundation::Status validate_grid_texture_resolution(int texture_resolution) noexcept
+{
+    if (texture_resolution <= 0 || texture_resolution > 16384) {
+        return pp::foundation::Status::out_of_range("grid texture resolution must be within 1..16384");
+    }
+
+    return pp::foundation::Status::success();
+}
+
+[[nodiscard]] inline pp::foundation::Status validate_grid_lightmap_samples(int sample_count) noexcept
+{
+    if (sample_count <= 0 || sample_count > 4096) {
+        return pp::foundation::Status::out_of_range("grid lightmap samples must be within 1..4096");
+    }
+
+    return pp::foundation::Status::success();
+}
+
+[[nodiscard]] inline constexpr GridUiPlan plan_grid_heightmap_pick() noexcept
+{
+    GridUiPlan plan;
+    plan.operation = GridUiOperation::request_heightmap_pick;
+    plan.opens_picker = true;
+    return plan;
+}
+
+[[nodiscard]] inline pp::foundation::Result<GridUiPlan> plan_grid_heightmap_load(std::string_view path)
+{
+    if (path.empty()) {
+        return pp::foundation::Result<GridUiPlan>::failure(
+            pp::foundation::Status::invalid_argument("heightmap path must not be empty"));
+    }
+
+    GridUiPlan plan;
+    plan.operation = GridUiOperation::load_heightmap;
+    plan.path = std::string(path);
+    plan.loads_heightmap = true;
+    plan.updates_preview = true;
+    plan.updates_ground_opacity = true;
+    plan.mutates_grid_state = true;
+    return pp::foundation::Result<GridUiPlan>::success(std::move(plan));
+}
+
+[[nodiscard]] inline constexpr GridUiPlan plan_grid_heightmap_clear(bool has_heightmap) noexcept
+{
+    GridUiPlan plan;
+    plan.operation = GridUiOperation::clear_heightmap;
+    plan.clears_heightmap = true;
+    plan.updates_preview = has_heightmap;
+    plan.mutates_grid_state = has_heightmap;
+    return plan;
+}
+
+[[nodiscard]] inline pp::foundation::Result<GridUiPlan> plan_grid_heightmap_reload(std::string_view path)
+{
+    auto plan = plan_grid_heightmap_load(path);
+    if (!plan) {
+        return pp::foundation::Result<GridUiPlan>::failure(plan.status());
+    }
+    plan.value().operation = GridUiOperation::reload_heightmap;
+    plan.value().updates_ground_opacity = false;
+    return plan;
+}
+
+[[nodiscard]] inline pp::foundation::Result<GridUiPlan> plan_grid_lightmap_render(
+    bool has_heightmap,
+    bool supports_float32,
+    bool supports_float16,
+    int texture_resolution,
+    int sample_count)
+{
+    const auto texture_status = validate_grid_texture_resolution(texture_resolution);
+    if (!texture_status.ok()) {
+        return pp::foundation::Result<GridUiPlan>::failure(texture_status);
+    }
+
+    const auto sample_status = validate_grid_lightmap_samples(sample_count);
+    if (!sample_status.ok()) {
+        return pp::foundation::Result<GridUiPlan>::failure(sample_status);
+    }
+
+    GridUiPlan plan;
+    plan.operation = GridUiOperation::render_lightmap;
+    plan.texture_resolution = texture_resolution;
+    plan.sample_count = sample_count;
+    if (!supports_float32 && !supports_float16) {
+        plan.shows_unsupported_message = true;
+        return pp::foundation::Result<GridUiPlan>::success(plan);
+    }
+
+    plan.renders_lightmap = has_heightmap;
+    plan.shows_progress = has_heightmap;
+    plan.updates_shading_mode = has_heightmap;
+    plan.mutates_grid_state = has_heightmap;
+    return pp::foundation::Result<GridUiPlan>::success(plan);
+}
+
+[[nodiscard]] inline constexpr GridUiPlan plan_grid_heightmap_commit(bool has_canvas) noexcept
+{
+    GridUiPlan plan;
+    plan.operation = GridUiOperation::commit_heightmap;
+    plan.commits_heightmap = has_canvas;
+    plan.updates_ground_opacity = has_canvas;
+    plan.mutates_grid_state = has_canvas;
+    return plan;
+}
+
+} // namespace pp::app

src/node_panel_grid.cpp

@@ -1,4 +1,5 @@
 #include "pch.h"
+#include "app_core/grid_ui.h"
 #include "log.h"
 #include "node_panel_grid.h"
 #include "canvas.h"
@@ -77,28 +78,19 @@ void NodePanelGrid::init_controls()
     };
 
     m_hm_load->on_click = [this](Node*) {
+        const auto plan = pp::app::plan_grid_heightmap_pick();
+        if (!plan.opens_picker)
+            return;
         App::I->pick_image([this](std::string path) {
-            Image img;
-            if (img.load_file(path))
-            {
-                m_file_path = path;
-                m_hm_image = img.resize(128, 128);
-                m_hm_preview->tex = std::make_shared<Texture2D>();
-                m_hm_preview->tex->create(m_hm_image);
-                m_hm_preview->tex->create_mipmaps();
-                auto sz = m_hm_preview->tex->size();
-                m_hm_preview->SetAspectRatio(sz.x / sz.y);
-                m_hm_plane.create(1, 1, m_hm_image, get_resolution(), get_height());
-                m_hm_preview->SetHeight(100);
-                if (m_groud_opacity->get_value() == 0.f)
-                    m_groud_opacity->set_value(1.f);
-                m_rt_dirty = true;
-            }
+            load_heightmap_file(path, true);
         });
     };
 
     m_hm_clear->on_click = [this](Node*)
     {
+        const auto plan = pp::app::plan_grid_heightmap_clear(static_cast<bool>(m_hm_image.data()));
+        if (!plan.clears_heightmap)
+            return;
         m_hm_plane.create(1, 1, 100 * get_resolution());
         m_hm_image.destroy();
         m_hm_preview->tex.reset();
@@ -107,24 +99,26 @@ void NodePanelGrid::init_controls()
 
     m_hm_reload->on_click = [this](Node*)
     {
-        Image img;
-        if (img.load_file(m_file_path))
-        {
-            m_hm_image = img.resize(128, 128);
-            m_hm_preview->tex = std::make_shared<Texture2D>();
-            m_hm_preview->tex->create(m_hm_image);
-            m_hm_preview->tex->create_mipmaps();
-            auto sz = m_hm_preview->tex->size();
-            m_hm_preview->SetAspectRatio(sz.x / sz.y);
-            m_hm_plane.create(1, 1, m_hm_image, get_resolution(), get_height());
-            m_hm_preview->SetHeight(100);
-            m_rt_dirty = true;
-        }
+        load_heightmap_file(m_file_path, false);
     };
 
     m_render->on_click = [this](Node*)
     {
-        if (ShaderManager::ext_float32 || ShaderManager::ext_float16)
+        const auto plan = pp::app::plan_grid_lightmap_render(
+            static_cast<bool>(m_hm_image.data()),
+            ShaderManager::ext_float32,
+            ShaderManager::ext_float16,
+            get_texres(),
+            get_samples());
+        if (!plan)
+            return;
+        if (plan.value().shows_unsupported_message)
+        {
+            App::I->message_box("Rendering failed",
+                "Your hardware does not support lightmap rendering.");
+            return;
+        }
+        if (plan.value().renders_lightmap)
         {
             std::thread([this] {
                 BT_SetTerminate();
@@ -133,18 +127,17 @@ void NodePanelGrid::init_controls()
                 m_shade_mode = ShadeMode::Textured;
             }).detach();
         }
-        else
-        {
-            App::I->message_box("Rendering failed", 
-                "Your hardware does not support lightmap rendering.");
-        }
     };
     m_commit->on_click = [this](Node*)
     {
+        const auto plan = pp::app::plan_grid_heightmap_commit(Canvas::I != nullptr);
+        if (!plan.commits_heightmap)
+            return;
         Canvas::I->draw_objects([this](const glm::mat4& camera, const glm::mat4& proj, int i) {
             draw_heightmap(proj, camera, true);
         }, Canvas::I->layer().m_frame_index, true);
-        m_groud_opacity->set_value(0);
+        if (plan.updates_ground_opacity)
+            m_groud_opacity->set_value(0);
     };
     m_hm_texres->on_select = [this](Node*, int index) {
         int texres = get_texres();
@@ -226,6 +219,33 @@ float NodePanelGrid::get_offset() const
     return glm::pow(m_groud_offset->get_value() - 0.5f, 3);
 }
 
+bool NodePanelGrid::load_heightmap_file(const std::string& path, bool raise_ground_opacity)
+{
+    const auto plan = raise_ground_opacity
+        ? pp::app::plan_grid_heightmap_load(path)
+        : pp::app::plan_grid_heightmap_reload(path);
+    if (!plan)
+        return false;
+
+    Image img;
+    if (!img.load_file(plan.value().path))
+        return false;
+
+    m_file_path = plan.value().path;
+    m_hm_image = img.resize(128, 128);
+    m_hm_preview->tex = std::make_shared<Texture2D>();
+    m_hm_preview->tex->create(m_hm_image);
+    m_hm_preview->tex->create_mipmaps();
+    auto sz = m_hm_preview->tex->size();
+    m_hm_preview->SetAspectRatio(sz.x / sz.y);
+    m_hm_plane.create(1, 1, m_hm_image, get_resolution(), get_height());
+    m_hm_preview->SetHeight(100);
+    if (plan.value().updates_ground_opacity && m_groud_opacity->get_value() == 0.f)
+        m_groud_opacity->set_value(1.f);
+    m_rt_dirty = true;
+    return true;
+}
+
 void NodePanelGrid::draw_heightmap(const glm::mat4& proj, const glm::mat4& camera, bool commit) const
 {
     assert(App::I->is_render_thread());

src/node_panel_grid.h

@@ -86,6 +86,7 @@ public:
     float get_resolution() const;
     float get_height() const;
     float get_offset() const;
+    bool load_heightmap_file(const std::string& path, bool raise_ground_opacity);
     void draw_heightmap(const glm::mat4& proj, const glm::mat4& camera, bool commit) const;
     void bake_uvs();
 };