Browse Source
yuzu: Remove Maxwell debugger
yuzu: Remove Maxwell debugger
This was carried from Citra and wasn't really used on yuzu. It also adds some runtime overhead. This commit removes it from yuzu's codebase.nce_cpp
ReinUsesLisp
6 years ago
14 changed files with 0 additions and 640 deletions
-
10src/core/core.cpp
-
4src/core/core.h
-
2src/video_core/CMakeLists.txt
-
49src/video_core/debug_utils/debug_utils.cpp
-
157src/video_core/debug_utils/debug_utils.h
-
31src/video_core/engines/maxwell_3d.cpp
-
5src/yuzu/CMakeLists.txt
-
27src/yuzu/debugger/graphics/graphics_breakpoint_observer.cpp
-
33src/yuzu/debugger/graphics/graphics_breakpoint_observer.h
-
221src/yuzu/debugger/graphics/graphics_breakpoints.cpp
-
45src/yuzu/debugger/graphics/graphics_breakpoints.h
-
37src/yuzu/debugger/graphics/graphics_breakpoints_p.h
-
11src/yuzu/main.cpp
-
8src/yuzu/main.h
@ -1,49 +0,0 @@ |
|||||
// Copyright 2014 Citra Emulator Project
|
|
||||
// Licensed under GPLv2
|
|
||||
// Refer to the license.txt file included.
|
|
||||
|
|
||||
#include <mutex>
|
|
||||
|
|
||||
#include "video_core/debug_utils/debug_utils.h"
|
|
||||
|
|
||||
namespace Tegra { |
|
||||
|
|
||||
void DebugContext::DoOnEvent(Event event, void* data) { |
|
||||
{ |
|
||||
std::unique_lock lock{breakpoint_mutex}; |
|
||||
|
|
||||
// TODO(Subv): Commit the rasterizer's caches so framebuffers, render targets, etc. will
|
|
||||
// show on debug widgets
|
|
||||
|
|
||||
// TODO: Should stop the CPU thread here once we multithread emulation.
|
|
||||
|
|
||||
active_breakpoint = event; |
|
||||
at_breakpoint = true; |
|
||||
|
|
||||
// Tell all observers that we hit a breakpoint
|
|
||||
for (auto& breakpoint_observer : breakpoint_observers) { |
|
||||
breakpoint_observer->OnMaxwellBreakPointHit(event, data); |
|
||||
} |
|
||||
|
|
||||
// Wait until another thread tells us to Resume()
|
|
||||
resume_from_breakpoint.wait(lock, [&] { return !at_breakpoint; }); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
void DebugContext::Resume() { |
|
||||
{ |
|
||||
std::lock_guard lock{breakpoint_mutex}; |
|
||||
|
|
||||
// Tell all observers that we are about to resume
|
|
||||
for (auto& breakpoint_observer : breakpoint_observers) { |
|
||||
breakpoint_observer->OnMaxwellResume(); |
|
||||
} |
|
||||
|
|
||||
// Resume the waiting thread (i.e. OnEvent())
|
|
||||
at_breakpoint = false; |
|
||||
} |
|
||||
|
|
||||
resume_from_breakpoint.notify_one(); |
|
||||
} |
|
||||
|
|
||||
} // namespace Tegra
|
|
||||
@ -1,157 +0,0 @@ |
|||||
// Copyright 2014 Citra Emulator Project |
|
||||
// Licensed under GPLv2 |
|
||||
// Refer to the license.txt file included. |
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include <array> |
|
||||
#include <condition_variable> |
|
||||
#include <list> |
|
||||
#include <memory> |
|
||||
#include <mutex> |
|
||||
|
|
||||
namespace Tegra { |
|
||||
|
|
||||
class DebugContext { |
|
||||
public: |
|
||||
enum class Event { |
|
||||
FirstEvent = 0, |
|
||||
|
|
||||
MaxwellCommandLoaded = FirstEvent, |
|
||||
MaxwellCommandProcessed, |
|
||||
IncomingPrimitiveBatch, |
|
||||
FinishedPrimitiveBatch, |
|
||||
|
|
||||
NumEvents |
|
||||
}; |
|
||||
|
|
||||
/** |
|
||||
* Inherit from this class to be notified of events registered to some debug context. |
|
||||
* Most importantly this is used for our debugger GUI. |
|
||||
* |
|
||||
* To implement event handling, override the OnMaxwellBreakPointHit and OnMaxwellResume methods. |
|
||||
* @warning All BreakPointObservers need to be on the same thread to guarantee thread-safe state |
|
||||
* access |
|
||||
* @todo Evaluate an alternative interface, in which there is only one managing observer and |
|
||||
* multiple child observers running (by design) on the same thread. |
|
||||
*/ |
|
||||
class BreakPointObserver { |
|
||||
public: |
|
||||
/// Constructs the object such that it observes events of the given DebugContext. |
|
||||
explicit BreakPointObserver(std::shared_ptr<DebugContext> debug_context) |
|
||||
: context_weak(debug_context) { |
|
||||
std::unique_lock lock{debug_context->breakpoint_mutex}; |
|
||||
debug_context->breakpoint_observers.push_back(this); |
|
||||
} |
|
||||
|
|
||||
virtual ~BreakPointObserver() { |
|
||||
auto context = context_weak.lock(); |
|
||||
if (context) { |
|
||||
{ |
|
||||
std::unique_lock lock{context->breakpoint_mutex}; |
|
||||
context->breakpoint_observers.remove(this); |
|
||||
} |
|
||||
|
|
||||
// If we are the last observer to be destroyed, tell the debugger context that |
|
||||
// it is free to continue. In particular, this is required for a proper yuzu |
|
||||
// shutdown, when the emulation thread is waiting at a breakpoint. |
|
||||
if (context->breakpoint_observers.empty()) |
|
||||
context->Resume(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/** |
|
||||
* Action to perform when a breakpoint was reached. |
|
||||
* @param event Type of event which triggered the breakpoint |
|
||||
* @param data Optional data pointer (if unused, this is a nullptr) |
|
||||
* @note This function will perform nothing unless it is overridden in the child class. |
|
||||
*/ |
|
||||
virtual void OnMaxwellBreakPointHit(Event event, void* data) {} |
|
||||
|
|
||||
/** |
|
||||
* Action to perform when emulation is resumed from a breakpoint. |
|
||||
* @note This function will perform nothing unless it is overridden in the child class. |
|
||||
*/ |
|
||||
virtual void OnMaxwellResume() {} |
|
||||
|
|
||||
protected: |
|
||||
/** |
|
||||
* Weak context pointer. This need not be valid, so when requesting a shared_ptr via |
|
||||
* context_weak.lock(), always compare the result against nullptr. |
|
||||
*/ |
|
||||
std::weak_ptr<DebugContext> context_weak; |
|
||||
}; |
|
||||
|
|
||||
/** |
|
||||
* Simple structure defining a breakpoint state |
|
||||
*/ |
|
||||
struct BreakPoint { |
|
||||
bool enabled = false; |
|
||||
}; |
|
||||
|
|
||||
/** |
|
||||
* Static constructor used to create a shared_ptr of a DebugContext. |
|
||||
*/ |
|
||||
static std::shared_ptr<DebugContext> Construct() { |
|
||||
return std::shared_ptr<DebugContext>(new DebugContext); |
|
||||
} |
|
||||
|
|
||||
/** |
|
||||
* Used by the emulation core when a given event has happened. If a breakpoint has been set |
|
||||
* for this event, OnEvent calls the event handlers of the registered breakpoint observers. |
|
||||
* The current thread then is halted until Resume() is called from another thread (or until |
|
||||
* emulation is stopped). |
|
||||
* @param event Event which has happened |
|
||||
* @param data Optional data pointer (pass nullptr if unused). Needs to remain valid until |
|
||||
* Resume() is called. |
|
||||
*/ |
|
||||
void OnEvent(Event event, void* data) { |
|
||||
// This check is left in the header to allow the compiler to inline it. |
|
||||
if (!breakpoints[(int)event].enabled) |
|
||||
return; |
|
||||
// For the rest of event handling, call a separate function. |
|
||||
DoOnEvent(event, data); |
|
||||
} |
|
||||
|
|
||||
void DoOnEvent(Event event, void* data); |
|
||||
|
|
||||
/** |
|
||||
* Resume from the current breakpoint. |
|
||||
* @warning Calling this from the same thread that OnEvent was called in will cause a deadlock. |
|
||||
* Calling from any other thread is safe. |
|
||||
*/ |
|
||||
void Resume(); |
|
||||
|
|
||||
/** |
|
||||
* Delete all set breakpoints and resume emulation. |
|
||||
*/ |
|
||||
void ClearBreakpoints() { |
|
||||
for (auto& bp : breakpoints) { |
|
||||
bp.enabled = false; |
|
||||
} |
|
||||
Resume(); |
|
||||
} |
|
||||
|
|
||||
// TODO: Evaluate if access to these members should be hidden behind a public interface. |
|
||||
std::array<BreakPoint, static_cast<int>(Event::NumEvents)> breakpoints; |
|
||||
Event active_breakpoint{}; |
|
||||
bool at_breakpoint = false; |
|
||||
|
|
||||
private: |
|
||||
/** |
|
||||
* Private default constructor to make sure people always construct this through Construct() |
|
||||
* instead. |
|
||||
*/ |
|
||||
DebugContext() = default; |
|
||||
|
|
||||
/// Mutex protecting current breakpoint state and the observer list. |
|
||||
std::mutex breakpoint_mutex; |
|
||||
|
|
||||
/// Used by OnEvent to wait for resumption. |
|
||||
std::condition_variable resume_from_breakpoint; |
|
||||
|
|
||||
/// List of registered observers |
|
||||
std::list<BreakPointObserver*> breakpoint_observers; |
|
||||
}; |
|
||||
|
|
||||
} // namespace Tegra |
|
||||
@ -1,27 +0,0 @@ |
|||||
// Copyright 2014 Citra Emulator Project
|
|
||||
// Licensed under GPLv2 or any later version
|
|
||||
// Refer to the license.txt file included.
|
|
||||
|
|
||||
#include <QMetaType>
|
|
||||
#include "yuzu/debugger/graphics/graphics_breakpoint_observer.h"
|
|
||||
|
|
||||
BreakPointObserverDock::BreakPointObserverDock(std::shared_ptr<Tegra::DebugContext> debug_context, |
|
||||
const QString& title, QWidget* parent) |
|
||||
: QDockWidget(title, parent), BreakPointObserver(debug_context) { |
|
||||
qRegisterMetaType<Tegra::DebugContext::Event>("Tegra::DebugContext::Event"); |
|
||||
|
|
||||
connect(this, &BreakPointObserverDock::Resumed, this, &BreakPointObserverDock::OnResumed); |
|
||||
|
|
||||
// NOTE: This signal is emitted from a non-GUI thread, but connect() takes
|
|
||||
// care of delaying its handling to the GUI thread.
|
|
||||
connect(this, &BreakPointObserverDock::BreakPointHit, this, |
|
||||
&BreakPointObserverDock::OnBreakPointHit, Qt::BlockingQueuedConnection); |
|
||||
} |
|
||||
|
|
||||
void BreakPointObserverDock::OnMaxwellBreakPointHit(Tegra::DebugContext::Event event, void* data) { |
|
||||
emit BreakPointHit(event, data); |
|
||||
} |
|
||||
|
|
||||
void BreakPointObserverDock::OnMaxwellResume() { |
|
||||
emit Resumed(); |
|
||||
} |
|
||||
@ -1,33 +0,0 @@ |
|||||
// Copyright 2014 Citra Emulator Project |
|
||||
// Licensed under GPLv2 or any later version |
|
||||
// Refer to the license.txt file included. |
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include <QDockWidget> |
|
||||
#include "video_core/debug_utils/debug_utils.h" |
|
||||
|
|
||||
/** |
|
||||
* Utility class which forwards calls to OnMaxwellBreakPointHit and OnMaxwellResume to public slots. |
|
||||
* This is because the Maxwell breakpoint callbacks are called from a non-GUI thread, while |
|
||||
* the widget usually wants to perform reactions in the GUI thread. |
|
||||
*/ |
|
||||
class BreakPointObserverDock : public QDockWidget, |
|
||||
protected Tegra::DebugContext::BreakPointObserver { |
|
||||
Q_OBJECT |
|
||||
|
|
||||
public: |
|
||||
BreakPointObserverDock(std::shared_ptr<Tegra::DebugContext> debug_context, const QString& title, |
|
||||
QWidget* parent = nullptr); |
|
||||
|
|
||||
void OnMaxwellBreakPointHit(Tegra::DebugContext::Event event, void* data) override; |
|
||||
void OnMaxwellResume() override; |
|
||||
|
|
||||
signals: |
|
||||
void Resumed(); |
|
||||
void BreakPointHit(Tegra::DebugContext::Event event, void* data); |
|
||||
|
|
||||
private: |
|
||||
virtual void OnBreakPointHit(Tegra::DebugContext::Event event, void* data) = 0; |
|
||||
virtual void OnResumed() = 0; |
|
||||
}; |
|
||||
@ -1,221 +0,0 @@ |
|||||
// Copyright 2014 Citra Emulator Project
|
|
||||
// Licensed under GPLv2 or any later version
|
|
||||
// Refer to the license.txt file included.
|
|
||||
|
|
||||
#include <QLabel>
|
|
||||
#include <QMetaType>
|
|
||||
#include <QPushButton>
|
|
||||
#include <QTreeView>
|
|
||||
#include <QVBoxLayout>
|
|
||||
#include "common/assert.h"
|
|
||||
#include "yuzu/debugger/graphics/graphics_breakpoints.h"
|
|
||||
#include "yuzu/debugger/graphics/graphics_breakpoints_p.h"
|
|
||||
|
|
||||
BreakPointModel::BreakPointModel(std::shared_ptr<Tegra::DebugContext> debug_context, |
|
||||
QObject* parent) |
|
||||
: QAbstractListModel(parent), context_weak(debug_context), |
|
||||
at_breakpoint(debug_context->at_breakpoint), |
|
||||
active_breakpoint(debug_context->active_breakpoint) {} |
|
||||
|
|
||||
int BreakPointModel::columnCount(const QModelIndex& parent) const { |
|
||||
return 1; |
|
||||
} |
|
||||
|
|
||||
int BreakPointModel::rowCount(const QModelIndex& parent) const { |
|
||||
return static_cast<int>(Tegra::DebugContext::Event::NumEvents); |
|
||||
} |
|
||||
|
|
||||
QVariant BreakPointModel::data(const QModelIndex& index, int role) const { |
|
||||
const auto event = static_cast<Tegra::DebugContext::Event>(index.row()); |
|
||||
|
|
||||
switch (role) { |
|
||||
case Qt::DisplayRole: { |
|
||||
if (index.column() == 0) { |
|
||||
return DebugContextEventToString(event); |
|
||||
} |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Qt::CheckStateRole: { |
|
||||
if (index.column() == 0) |
|
||||
return data(index, Role_IsEnabled).toBool() ? Qt::Checked : Qt::Unchecked; |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Qt::BackgroundRole: { |
|
||||
if (at_breakpoint && index.row() == static_cast<int>(active_breakpoint)) { |
|
||||
return QBrush(QColor(0xE0, 0xE0, 0x10)); |
|
||||
} |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Role_IsEnabled: { |
|
||||
auto context = context_weak.lock(); |
|
||||
return context && context->breakpoints[(int)event].enabled; |
|
||||
} |
|
||||
|
|
||||
default: |
|
||||
break; |
|
||||
} |
|
||||
return QVariant(); |
|
||||
} |
|
||||
|
|
||||
Qt::ItemFlags BreakPointModel::flags(const QModelIndex& index) const { |
|
||||
if (!index.isValid()) |
|
||||
return 0; |
|
||||
|
|
||||
Qt::ItemFlags flags = Qt::ItemIsEnabled; |
|
||||
if (index.column() == 0) |
|
||||
flags |= Qt::ItemIsUserCheckable; |
|
||||
return flags; |
|
||||
} |
|
||||
|
|
||||
bool BreakPointModel::setData(const QModelIndex& index, const QVariant& value, int role) { |
|
||||
const auto event = static_cast<Tegra::DebugContext::Event>(index.row()); |
|
||||
|
|
||||
switch (role) { |
|
||||
case Qt::CheckStateRole: { |
|
||||
if (index.column() != 0) |
|
||||
return false; |
|
||||
|
|
||||
auto context = context_weak.lock(); |
|
||||
if (!context) |
|
||||
return false; |
|
||||
|
|
||||
context->breakpoints[(int)event].enabled = value == Qt::Checked; |
|
||||
QModelIndex changed_index = createIndex(index.row(), 0); |
|
||||
emit dataChanged(changed_index, changed_index); |
|
||||
return true; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return false; |
|
||||
} |
|
||||
|
|
||||
void BreakPointModel::OnBreakPointHit(Tegra::DebugContext::Event event) { |
|
||||
auto context = context_weak.lock(); |
|
||||
if (!context) |
|
||||
return; |
|
||||
|
|
||||
active_breakpoint = context->active_breakpoint; |
|
||||
at_breakpoint = context->at_breakpoint; |
|
||||
emit dataChanged(createIndex(static_cast<int>(event), 0), |
|
||||
createIndex(static_cast<int>(event), 0)); |
|
||||
} |
|
||||
|
|
||||
void BreakPointModel::OnResumed() { |
|
||||
auto context = context_weak.lock(); |
|
||||
if (!context) |
|
||||
return; |
|
||||
|
|
||||
at_breakpoint = context->at_breakpoint; |
|
||||
emit dataChanged(createIndex(static_cast<int>(active_breakpoint), 0), |
|
||||
createIndex(static_cast<int>(active_breakpoint), 0)); |
|
||||
active_breakpoint = context->active_breakpoint; |
|
||||
} |
|
||||
|
|
||||
QString BreakPointModel::DebugContextEventToString(Tegra::DebugContext::Event event) { |
|
||||
switch (event) { |
|
||||
case Tegra::DebugContext::Event::MaxwellCommandLoaded: |
|
||||
return tr("Maxwell command loaded"); |
|
||||
case Tegra::DebugContext::Event::MaxwellCommandProcessed: |
|
||||
return tr("Maxwell command processed"); |
|
||||
case Tegra::DebugContext::Event::IncomingPrimitiveBatch: |
|
||||
return tr("Incoming primitive batch"); |
|
||||
case Tegra::DebugContext::Event::FinishedPrimitiveBatch: |
|
||||
return tr("Finished primitive batch"); |
|
||||
case Tegra::DebugContext::Event::NumEvents: |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
return tr("Unknown debug context event"); |
|
||||
} |
|
||||
|
|
||||
GraphicsBreakPointsWidget::GraphicsBreakPointsWidget( |
|
||||
std::shared_ptr<Tegra::DebugContext> debug_context, QWidget* parent) |
|
||||
: QDockWidget(tr("Maxwell Breakpoints"), parent), Tegra::DebugContext::BreakPointObserver( |
|
||||
debug_context) { |
|
||||
setObjectName(QStringLiteral("TegraBreakPointsWidget")); |
|
||||
|
|
||||
status_text = new QLabel(tr("Emulation running")); |
|
||||
resume_button = new QPushButton(tr("Resume")); |
|
||||
resume_button->setEnabled(false); |
|
||||
|
|
||||
breakpoint_model = new BreakPointModel(debug_context, this); |
|
||||
breakpoint_list = new QTreeView; |
|
||||
breakpoint_list->setRootIsDecorated(false); |
|
||||
breakpoint_list->setHeaderHidden(true); |
|
||||
breakpoint_list->setModel(breakpoint_model); |
|
||||
|
|
||||
qRegisterMetaType<Tegra::DebugContext::Event>("Tegra::DebugContext::Event"); |
|
||||
|
|
||||
connect(breakpoint_list, &QTreeView::doubleClicked, this, |
|
||||
&GraphicsBreakPointsWidget::OnItemDoubleClicked); |
|
||||
|
|
||||
connect(resume_button, &QPushButton::clicked, this, |
|
||||
&GraphicsBreakPointsWidget::OnResumeRequested); |
|
||||
|
|
||||
connect(this, &GraphicsBreakPointsWidget::BreakPointHit, this, |
|
||||
&GraphicsBreakPointsWidget::OnBreakPointHit, Qt::BlockingQueuedConnection); |
|
||||
connect(this, &GraphicsBreakPointsWidget::Resumed, this, &GraphicsBreakPointsWidget::OnResumed); |
|
||||
|
|
||||
connect(this, &GraphicsBreakPointsWidget::BreakPointHit, breakpoint_model, |
|
||||
&BreakPointModel::OnBreakPointHit, Qt::BlockingQueuedConnection); |
|
||||
connect(this, &GraphicsBreakPointsWidget::Resumed, breakpoint_model, |
|
||||
&BreakPointModel::OnResumed); |
|
||||
|
|
||||
connect(this, &GraphicsBreakPointsWidget::BreakPointsChanged, |
|
||||
[this](const QModelIndex& top_left, const QModelIndex& bottom_right) { |
|
||||
breakpoint_model->dataChanged(top_left, bottom_right); |
|
||||
}); |
|
||||
|
|
||||
QWidget* main_widget = new QWidget; |
|
||||
auto main_layout = new QVBoxLayout; |
|
||||
{ |
|
||||
auto sub_layout = new QHBoxLayout; |
|
||||
sub_layout->addWidget(status_text); |
|
||||
sub_layout->addWidget(resume_button); |
|
||||
main_layout->addLayout(sub_layout); |
|
||||
} |
|
||||
main_layout->addWidget(breakpoint_list); |
|
||||
main_widget->setLayout(main_layout); |
|
||||
|
|
||||
setWidget(main_widget); |
|
||||
} |
|
||||
|
|
||||
void GraphicsBreakPointsWidget::OnMaxwellBreakPointHit(Event event, void* data) { |
|
||||
// Process in GUI thread
|
|
||||
emit BreakPointHit(event, data); |
|
||||
} |
|
||||
|
|
||||
void GraphicsBreakPointsWidget::OnBreakPointHit(Tegra::DebugContext::Event event, void* data) { |
|
||||
status_text->setText(tr("Emulation halted at breakpoint")); |
|
||||
resume_button->setEnabled(true); |
|
||||
} |
|
||||
|
|
||||
void GraphicsBreakPointsWidget::OnMaxwellResume() { |
|
||||
// Process in GUI thread
|
|
||||
emit Resumed(); |
|
||||
} |
|
||||
|
|
||||
void GraphicsBreakPointsWidget::OnResumed() { |
|
||||
status_text->setText(tr("Emulation running")); |
|
||||
resume_button->setEnabled(false); |
|
||||
} |
|
||||
|
|
||||
void GraphicsBreakPointsWidget::OnResumeRequested() { |
|
||||
if (auto context = context_weak.lock()) |
|
||||
context->Resume(); |
|
||||
} |
|
||||
|
|
||||
void GraphicsBreakPointsWidget::OnItemDoubleClicked(const QModelIndex& index) { |
|
||||
if (!index.isValid()) |
|
||||
return; |
|
||||
|
|
||||
QModelIndex check_index = breakpoint_list->model()->index(index.row(), 0); |
|
||||
QVariant enabled = breakpoint_list->model()->data(check_index, Qt::CheckStateRole); |
|
||||
QVariant new_state = Qt::Unchecked; |
|
||||
if (enabled == Qt::Unchecked) |
|
||||
new_state = Qt::Checked; |
|
||||
breakpoint_list->model()->setData(check_index, new_state, Qt::CheckStateRole); |
|
||||
} |
|
||||
@ -1,45 +0,0 @@ |
|||||
// Copyright 2014 Citra Emulator Project |
|
||||
// Licensed under GPLv2 or any later version |
|
||||
// Refer to the license.txt file included. |
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include <memory> |
|
||||
#include <QDockWidget> |
|
||||
#include "video_core/debug_utils/debug_utils.h" |
|
||||
|
|
||||
class QLabel; |
|
||||
class QPushButton; |
|
||||
class QTreeView; |
|
||||
|
|
||||
class BreakPointModel; |
|
||||
|
|
||||
class GraphicsBreakPointsWidget : public QDockWidget, Tegra::DebugContext::BreakPointObserver { |
|
||||
Q_OBJECT |
|
||||
|
|
||||
using Event = Tegra::DebugContext::Event; |
|
||||
|
|
||||
public: |
|
||||
explicit GraphicsBreakPointsWidget(std::shared_ptr<Tegra::DebugContext> debug_context, |
|
||||
QWidget* parent = nullptr); |
|
||||
|
|
||||
void OnMaxwellBreakPointHit(Tegra::DebugContext::Event event, void* data) override; |
|
||||
void OnMaxwellResume() override; |
|
||||
|
|
||||
signals: |
|
||||
void Resumed(); |
|
||||
void BreakPointHit(Tegra::DebugContext::Event event, void* data); |
|
||||
void BreakPointsChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight); |
|
||||
|
|
||||
private: |
|
||||
void OnBreakPointHit(Tegra::DebugContext::Event event, void* data); |
|
||||
void OnItemDoubleClicked(const QModelIndex&); |
|
||||
void OnResumeRequested(); |
|
||||
void OnResumed(); |
|
||||
|
|
||||
QLabel* status_text; |
|
||||
QPushButton* resume_button; |
|
||||
|
|
||||
BreakPointModel* breakpoint_model; |
|
||||
QTreeView* breakpoint_list; |
|
||||
}; |
|
||||
@ -1,37 +0,0 @@ |
|||||
// Copyright 2014 Citra Emulator Project |
|
||||
// Licensed under GPLv2 or any later version |
|
||||
// Refer to the license.txt file included. |
|
||||
|
|
||||
#pragma once |
|
||||
|
|
||||
#include <memory> |
|
||||
#include <QAbstractListModel> |
|
||||
#include "video_core/debug_utils/debug_utils.h" |
|
||||
|
|
||||
class BreakPointModel : public QAbstractListModel { |
|
||||
Q_OBJECT |
|
||||
|
|
||||
public: |
|
||||
enum { |
|
||||
Role_IsEnabled = Qt::UserRole, |
|
||||
}; |
|
||||
|
|
||||
BreakPointModel(std::shared_ptr<Tegra::DebugContext> context, QObject* parent); |
|
||||
|
|
||||
int columnCount(const QModelIndex& parent = QModelIndex()) const override; |
|
||||
int rowCount(const QModelIndex& parent = QModelIndex()) const override; |
|
||||
QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override; |
|
||||
Qt::ItemFlags flags(const QModelIndex& index) const override; |
|
||||
|
|
||||
bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override; |
|
||||
|
|
||||
void OnBreakPointHit(Tegra::DebugContext::Event event); |
|
||||
void OnResumed(); |
|
||||
|
|
||||
private: |
|
||||
static QString DebugContextEventToString(Tegra::DebugContext::Event event); |
|
||||
|
|
||||
std::weak_ptr<Tegra::DebugContext> context_weak; |
|
||||
bool at_breakpoint; |
|
||||
Tegra::DebugContext::Event active_breakpoint; |
|
||||
}; |
|
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue