DevTool.hpp

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "devtools/CallGraph.hpp"
#include "devtools/DebugAdapter.hpp"
#include "devtools/Debugger.hpp"
#include "devtools/RenderFlow.hpp"
#include "devtools/ScenarioRecorder.h"
#include "devtools/Snapshot.hpp"
 
#include <string>
#include <unordered_map>
#include <vector>
#include <chrono>
 
struct SQVM;
typedef struct SQVM* HSQUIRRELVM;
 
namespace ssq {
class VM;
}
 
namespace eve {
class Runtime;
}
 
namespace eve::dev {
 
class McpServer;
class AiPanel;
class ConsolePanel;
class FrameStatsPanel;
 
class EVENGINE_API_FOUNDATION DevTool {
public:
    static DevTool& instance();
 
    DevTool(const DevTool&)            = delete;
    DevTool& operator=(const DevTool&) = delete;
 
    void attach(ssq::VM& vm, bool sampleLocals = true);
    void attach(HSQUIRRELVM vm, bool sampleLocals = true);
    void attach(eve::Runtime& runtime, bool sampleLocals = true);
    void enableRenderTrace(bool on = true);
    void detach();
 
    void exposeScriptApi(ssq::VM& vm);
 
    int  startDap(uint16_t port);
    void stopDap();
    int  startMcp(uint16_t port);
    void stopMcp();
    void poll();
 
    void drawAiPanel();
    void drawConsolePanel();
    void drawFrameStatsPanel();
 
    bool isAttached() const { return vm_ != nullptr; }
    bool isRuntimeBound() const { return runtime_ != nullptr; }
    bool renderTraceEnabled() const { return renderTraceEnabled_; }
    bool sampleLocals() const { return sampleLocals_; }
    void setSampleLocals(bool on) { sampleLocals_ = on; }
 
    CallGraph&        graph() { return graph_; }
    const CallGraph&  graph() const { return graph_; }
    RenderFlow&       renderFlow() { return renderFlow_; }
    const RenderFlow& renderFlow() const { return renderFlow_; }
    Debugger&         debugger() { return Debugger::instance(); }
    Snapshot&         snapshot() { return Snapshot::instance(); }
    ScenarioRecorder& scenario() { return ScenarioRecorder::instance(); }
    DebugAdapter&     dap() { return DebugAdapter::instance(); }
    McpServer&        mcp();
    AiPanel&          ai();
    ConsolePanel&     console();
    FrameStatsPanel&  frameStats();
 
    SliceResult analyzeError(const std::string& errorMessage,
                             const std::vector<std::string>& hintVars = {}) const;
 
    std::string formatError(const std::string& errorMessage,
                            const std::vector<std::string>& hintVars = {}) const;
 
    const std::string& lastReport() const { return lastReport_; }
    const std::string& lastError() const { return lastError_; }
    const SliceResult& lastSlice() const { return lastSlice_; }
 
    struct ProfileEntry {
        int         calls = 0;
        int         lines = 0;
        long long   ns    = 0;
    };
    const std::unordered_map<std::string, ProfileEntry>& profile() const { return profile_; }
    void profileClear() {
        profile_.clear();
        profStack_.clear();
    }
    std::string formatProfileReport() const;
 
    std::string notifyError(const std::string& errorMessage,
                            const std::vector<std::string>& hintVars = {});
 
    void handleDebugEvent(HSQUIRRELVM vm, int type, const char* source, int line,
                          const char* funcname);
 
private:
    DevTool() = default;
 
    void sampleFrameLocals(HSQUIRRELVM vm, const SourceLoc& loc);
    void markErrorUses(const SourceLoc& loc, const std::vector<std::string>& hintVars);
    void installRenderTracer();
    void uninstallRenderTracer();
    void pumpWhilePaused();
    void handleDebugHotkey(const std::string& key);
    void profileLine(const std::string& func);
    void profileCall(const std::string& func);
    void profileReturn();
 
    HSQUIRRELVM vm_               = nullptr;
    bool        sampleLocals_     = true;
    bool        renderTraceEnabled_ = false;
    eve::Runtime* runtime_        = nullptr;
    CallGraph   graph_;
    RenderFlow  renderFlow_;
    std::string lastReport_;
    std::string lastError_;
    SliceResult lastSlice_;
    std::unordered_map<std::string, ProfileEntry> profile_;
    std::vector<std::pair<std::string, std::chrono::steady_clock::time_point>> profStack_;
 
    std::unordered_map<int, std::unordered_map<std::string, std::string>> localSnap_;
};
 
}  // namespace eve::dev