接入3D secene taskflow

web_server/app/render_3D/Gallery_Scene3D.cpp

@@ -1,8 +1,13 @@
 #include "Gallery_Scene3D.h"
 
+#include "../Gallery_Capture_Json.h"
+#include "../Gallery_Enum.h"
 #include "../common/Pixel_Frame.h"
 #include <render_3D/Point_Scene.h>
 
+#include "adminive/adminive.hpp"
+#include "adminive/adapters/nlohmann_json.hpp"
+
 #include <algorithm>
 #include <chrono>
 #include <cmath>
@@ -16,6 +21,44 @@
 #include <utility>
 #include <vector>
 
+namespace adminive {
+
+template <class Json>
+struct Value_Adapter<
+    renderive::render_3d::Renderable_Observer_Event, Json> {
+    using value_type = std::string;
+    static std::string read(
+        renderive::render_3d::Renderable_Observer_Event value) {
+        return renderive::web::gallery_enum_id(value);
+    }
+    static void write(
+        renderive::render_3d::Renderable_Observer_Event& target,
+        std::string value) {
+        const auto parsed = renderive::web::gallery_enum_cast<
+            renderive::render_3d::Renderable_Observer_Event>(value);
+        if (!parsed)
+            throw std::invalid_argument("unknown 3D observer event");
+        target = *parsed;
+    }
+};
+
+template <>
+struct Type_Descriptor<renderive::render_3d::Renderable_Observation> {
+    static auto get() {
+        using T = renderive::render_3d::Renderable_Observation;
+        return object<T>(
+            "renderable_3d_observer",
+            ADMINIVE_FIELD_LABEL(T, event, "事件"),
+            ADMINIVE_FIELD_LABEL(T, event_time_ns, "事件时间"),
+            ADMINIVE_FIELD_LABEL(T, cache_update_count, "缓存更新"),
+            ADMINIVE_FIELD_LABEL(T, publish_count, "发布"),
+            ADMINIVE_FIELD_LABEL(T, data_revision, "数据版本"),
+            ADMINIVE_FIELD_LABEL(T, item_count, "项目数"));
+    }
+};
+
+} // namespace adminive
+
 namespace renderive::web {
 namespace {
 using namespace renderive::render_3d;
@@ -119,6 +162,14 @@ Visual_Family visual_family(std::string_view case_id) {
     return Visual_Family::Point;
 }
 
+std::optional<double> action_number(
+    const Gallery_Action_Request& request) {
+    if (!request.argument ||
+        !std::holds_alternative<double>(*request.argument))
+        return std::nullopt;
+    return std::get<double>(*request.argument);
+}
+
 class Gallery_Scene3D final : public Gallery_Scene_Interface {
 public:
     Gallery_Scene3D(std::uint64_t session_id, std::string case_id,
@@ -133,6 +184,7 @@ public:
                  visual_) {
         if (!visual_)
             throw std::runtime_error("failed to create Point_Visual");
+        visual_->set_object_name("3D Visual");
         render_initial_frame();
     }
 
@@ -141,10 +193,21 @@ public:
     }
 
     [[nodiscard]] nlohmann::json controls() const override {
+        const auto observation = visual_->observation();
         return {{"resources", nlohmann::json::array()},
-                {"observers", nlohmann::json::array()},
-                {"render_plan", nullptr},
-                {"performance_capture", nullptr}};
+                {"observers",
+                 nlohmann::json::array({
+                     {{"descriptor", adminive::to_descriptor_json<
+                                           nlohmann::json,
+                                           Renderable_Observation>()},
+                      {"data", adminive::to_frontend_json<nlohmann::json>(
+                                   observation)},
+                      {"target", "point-visual"},
+                      {"title", "3D Visual"}}})},
+                {"render_plan",
+                 gallery_render_plan_json(scene_.render_scene())},
+                {"performance_capture",
+                 gallery_performance_capture_json(scene_.render_scene())}};
     }
 
     [[nodiscard]] Gallery_Frame_Mode frame_mode() const noexcept override {
@@ -267,6 +330,32 @@ public:
     [[nodiscard]] std::string action(const Gallery_Action_Request& request,
                                      bool& recognized) override {
         recognized = true;
+        if (request.id == "capture_next_frame") {
+            auto& scene = scene_.render_scene();
+            if (scene.capture_state().enabled())
+                return "A performance capture session is already active";
+            const auto session_id = scene.capture_next_frame();
+            last_action_result_ =
+                "capture session=" + std::to_string(session_id);
+            return "Next 3D frame capture requested";
+        }
+        if (request.id == "capture_frames") {
+            const auto argument = action_number(request);
+            if (!argument) {
+                recognized = false;
+                return {};
+            }
+            const std::size_t count = static_cast<std::size_t>(
+                std::clamp(std::llround(*argument), 1LL, 120LL));
+            auto& scene = scene_.render_scene();
+            if (scene.capture_state().enabled())
+                return "A performance capture session is already active";
+            const auto session_id = scene.capture_frames(count);
+            last_action_result_ = "capture session=" +
+                                  std::to_string(session_id) +
+                                  " frames=" + std::to_string(count);
+            return "Consecutive 3D frame capture requested";
+        }
         if (request.id == "mode_prepare" || request.id == "mode_enqueue") {
             if (frame_mode_ == Gallery_Frame_Mode::Playback) {
                 blue_offset_ = std::min(0.25F, blue_offset_ + 0.0125F);
@@ -366,6 +455,8 @@ public:
               {"websocket_buffered_bytes",
                client_performance_.websocket_buffered_bytes}}},
             {"session_id", session_id_},
+            {"performance_capture",
+             gallery_performance_capture_json(scene_.render_scene())},
             {"last_action", last_action_result_}}
             .dump();
     }