feat: 添加调试器功能，支持多次调用和等待命令，更新版本号至8.2.123

Author: GengGode

source/CMakeLists.txt

@@ -98,6 +98,7 @@ find_package(fmt REQUIRED)
 find_package(imgui REQUIRED)
 find_package(OpenCV REQUIRED)
 find_package(cereal REQUIRED)
+target_include_directories(cvAutoTrack PRIVATE ${OpenCV_INCLUDE_DIRS})
 target_link_libraries(cvAutoTrack
 PRIVATE  
     tianli::frame
@@ -107,7 +108,6 @@ PRIVATE
     imgui::imgui
     opengl32
     )
-target_include_directories(cvAutoTrack PRIVATE ${OpenCV_INCLUDE_DIRS})
 
 add_custom_target(copy_version_file ALL COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_CURRENT_SOURCE_DIR}/resource/version.ver" "$<TARGET_FILE_DIR:cvAutoTrack>/version")
 set_target_properties(copy_version_file PROPERTIES FOLDER "scripts")

source/cvAutoTrack.cpp

@@ -271,6 +271,20 @@ cvAutoTrackContextV2* create_cvAutoTrack_context_v2()
                     gui->destory();
                 }
             }
+            else if (args == "wait")
+            {
+                if (auto gui = global::shareder<debugger>::get(); gui)
+                {
+                    gui->wait_exit();
+                }
+            }
+        }
+        else
+        {
+            if (auto gui = global::shareder<debugger>::get(); gui)
+            {
+                gui->call(cmd, args);
+            }
         }
         return true;
     };

source/global/debugger.cpp

@@ -118,13 +118,69 @@ void window_opengl::shutdown()
     ::UnregisterClassW(wc.lpszClassName, wc.hInstance);
 }
 
+#include "one_call_function.hpp"
 #include "single_async_executor.hpp"
+#include "syncer.hpp"
 #include <atomic>
 #include <iostream>
+
+#include <mutex>
+
+struct async_ogl
+{
+    HWND hwnd;
+    HDC hdc;
+    HGLRC hglrc;
+    std::mutex mutex;
+    void init(HWND hwnd, HGLRC main_hglrc)
+    {
+        this->hwnd = hwnd;
+        hdc = ::GetDC(hwnd);
+        hglrc = wglCreateContext(hdc);
+        if (main_hglrc)
+            wglShareLists(main_hglrc, hglrc);
+    }
+    void destory(HWND hwnd)
+    {
+        std::unique_lock lock(mutex);
+        if (hglrc)
+        {
+            wglMakeCurrent(hdc, nullptr);
+            wglDeleteContext(hglrc);
+            hglrc = nullptr;
+        }
+        if (hdc)
+        {
+            ReleaseDC(hwnd, hdc);
+            hdc = nullptr;
+        }
+    }
+};
+
+struct unique_ogl_lock
+{
+    async_ogl& async;
+    bool ret = {};
+    unique_ogl_lock(async_ogl& async) : async(async)
+    {
+        async.mutex.lock();
+        ret = wglMakeCurrent(async.hdc, async.hglrc);
+    }
+    ~unique_ogl_lock()
+    {
+        wglMakeCurrent(async.hdc, nullptr);
+        wglMakeCurrent(nullptr, nullptr);
+        async.mutex.unlock();
+    }
+};
+
 struct imapp
 {
     window_opengl window;
+    stdex::one_call_function<void()> one_call;
     stdex::single_async_executor<void> executor;
+    stdex::syncer<std::function<void()>, true> render_syncer;
+    std::function<void()> render;
     std::atomic_flag is_running = ATOMIC_FLAG_INIT;
 
     void async_execute()
@@ -135,28 +191,48 @@ struct imapp
                 create();
                 while (is_running.test_and_set())
                 {
+                    one_call();
+
                     event_process();
                     new_frame();
-                    render();
+
+                    render_syncer.try_sync(render);
+                    if (render)
+                        render();
+
+                    render_and_swap();
                 }
                 destory();
             }
             catch (const std::exception& e)
             {
-                std::cerr << "Exception: " << e.what() << std::endl;
+                // std::cerr << "Exception: " << e.what() << std::endl;
             }
             catch (...)
             {
-                std::cerr << "Unknown exception occurred." << std::endl;
+                // std::cerr << "Unknown exception occurred." << std::endl;
             }
         });
     }
 
     void create();
     void event_process();
     void new_frame();
-    void render();
+    void render_and_swap();
     void destory();
+
+    std::shared_ptr<async_ogl> create_async_ogl()
+    {
+        auto async = std::make_shared<async_ogl>();
+        std::promise<void> promise;
+        std::future<void> future = promise.get_future();
+        one_call = [&promise = std::move(promise), async, this]() {
+            async->init(window.hwnd, window.hglrc);
+            promise.set_value();
+        };
+        future.wait();
+        return async;
+    }
 };
 void imapp::create()
 {
@@ -166,6 +242,7 @@ void imapp::create()
     IMGUI_CHECKVERSION();
     ImGui::CreateContext();
     ImGuiIO& io = ImGui::GetIO();
+    io.IniFilename = nullptr;                             // Disable .ini file
     io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
     io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;  // Enable Gamepad Controls
 
@@ -187,18 +264,23 @@ void imapp::event_process()
         ::TranslateMessage(&msg);
         ::DispatchMessage(&msg);
         if (msg.message == WM_QUIT)
-            is_running.clear();
+        {
+            std::cout << "Quit message received." << std::endl;
+            // is_running.clear();
+        }
     }
     if (::IsIconic(window.hwnd))
         ::Sleep(10);
+    if (::IsWindow(window.hwnd) == false)
+        is_running.clear();
 }
 void imapp::new_frame()
 {
     ImGui_ImplOpenGL3_NewFrame();
     ImGui_ImplWin32_NewFrame();
     ImGui::NewFrame();
 }
-void imapp::render()
+void imapp::render_and_swap()
 {
     ImGui::Render();
     glViewport(0, 0, window.width, window.height);
@@ -216,30 +298,127 @@ void imapp::destory()
     window.shutdown();
 }
 
+#include <opencv2/core/opengl.hpp>
+
 struct debugger::impl_t
 {
     imapp app;
+    std::vector<unique_render_image> render_images;
+    stdex::syncer<std::vector<unique_render_image>, true> render_image_syncer;
 
     void setup() { app.async_execute(); }
     void shutdown()
     {
         app.is_running.clear();
-        app.executor.wait();
+        wait_exit();
     }
+    void wait_exit() { app.executor.wait(); }
+    void update_render(std::function<void()> render) { app.render_syncer.set(render); }
 };
 
 debugger::debugger() : impl(std::make_unique<impl_t>()) {}
-debugger::~debugger() { impl->shutdown(); }
+debugger::~debugger()
+{
+    impl->shutdown();
+}
+#include "pool.hpp"
 
 void debugger::initlize()
 {
     impl->setup();
+
+    set_render([this]() {
+        ImGui::Begin("Debugger");
+        ImGui::Text("Render Images");
+        ImGui::Text("Press 'R' to refresh");
+        if (ImGui::Button("Refresh"))
+        {
+            static stdex::single_async_executor<void> async_executor;
+            async_executor.submit_exclusive([this]() {
+                auto ogl = impl->app.create_async_ogl();
+                unique_ogl_lock lock(*ogl);
+
+                std::vector<unique_render_image> images;
+                for (int i = 0; i < 1; ++i)
+                {
+                    cv::Mat image = cv::Mat::zeros(200, 200, CV_8UC3);
+                    cv::rectangle(image, cv::Point(rand() % 50 + 2, 50), cv::Point(150, 150), cv::Scalar(0, 255, 0), -1);
+                    unique_render_image render_image;
+                    render_image.tex_ref = std::make_shared<cv::ogl::Texture2D>(image, true);
+                    render_image.texture_id = render_image.tex_ref->texId();
+                    render_image.width = image.cols;
+                    render_image.height = image.rows;
+                    images.push_back(render_image);
+                }
+                impl->render_image_syncer.set(images);
+            });
+        }
+        impl->render_image_syncer.try_sync(impl->render_images);
+        for (auto& image : impl->render_images)
+        {
+            ImGui::Image((intptr_t)image.texture_id, ImVec2(image.width, image.height));
+        }
+        ImGui::End();
+    });
 }
 void debugger::destory()
 {
     impl->shutdown();
 }
+void debugger::wait_exit()
+{
+    impl->wait_exit();
+}
+void debugger::set_render(std::function<void()> render)
+{
+    impl->update_render(render);
+}
+// #include "self_releasing_async.hpp"
+
+#include <frame/frame.include.h>
+#include <global/record/record.stdlog.h>
 std::string debugger::call(std::string command, std::string args)
 {
+    if (command == "capture")
+    {
+        if (args == "current")
+        {
+
+            auto logger = std::make_shared<tianli::global::record::std_logger>();
+            auto capture = tianli::frame::frame_source::create(tianli::frame::frame_source::source_type::bitblt, logger);
+            cv::Mat frame;
+
+            capture->set_capture_handle(GetDesktopWindow());
+            while (frame.empty())
+            {
+                std::this_thread::sleep_for(std::chrono::milliseconds(18));
+                capture->get_frame(frame);
+                std::cout << "Capture current frame" << std::endl;
+                if (frame.empty())
+                {
+                    std::cout << "Capture failed" << std::endl;
+                }
+            }
+            static stdex::single_async_executor<void> async_executor;
+            async_executor.submit_exclusive([frame, this]() {
+                auto ogl = impl->app.create_async_ogl();
+                unique_ogl_lock lock(*ogl);
+                std::vector<unique_render_image> images;
+                {
+                    unique_render_image render_image;
+                    render_image.tex_ref = std::make_shared<cv::ogl::Texture2D>(frame.clone(), true);
+                    render_image.texture_id = render_image.tex_ref->texId();
+                    render_image.width = render_image.tex_ref->cols();
+                    render_image.height = render_image.tex_ref->rows();
+                    images.push_back(render_image);
+                }
+                impl->render_image_syncer.set(images);
+            });
+        }
+    }
+    else
+    {
+        return "Unknown command";
+    }
     return {};
 }

source/global/debugger.h

@@ -1,6 +1,17 @@
 #pragma once
 #include <memory>
 #include <string>
+
+#include <opencv2/core/opengl.hpp>
+
+struct unique_render_image
+{
+    int texture_id;
+    int width;
+    int height;
+    std::shared_ptr<cv::ogl::Texture2D> tex_ref;
+};
+
 struct debugger
 {
     struct impl_t;
@@ -10,5 +21,7 @@ struct debugger
 
     void initlize();
     void destory();
+    void wait_exit();
+    void set_render(std::function<void()> render);
     std::string call(std::string command, std::string args);
-};
+};

source/global/global.include.h

@@ -68,11 +68,11 @@ namespace tianli::global
         return index;
     }
 
-    #define error(msg)                                                                                                                                                                          \
+    #define errreg(msg)                                                                                                                                                                          \
         tianli::global::error_proxy<tianli::global::error_invoker, tianli::global::source_location(__FILE__, std::source_location::current().line(), std::source_location::current().column()), \
                                     tianli::global::error_message(msg)>::callback(tianli::global::error_impl, msg)
 #else
-    #define error(msg)
+    #define errreg(msg)
 #endif
 
     class error_type