RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-02-01 04:51:49 +01:00
Code Issues Releases Wiki Activity

rsx_debugger: layout refactoring for highdpi and resizeability

Browse Source
This commit is contained in:
Megamouse 2018-03-28 20:37:57 +02:00 committed by Ivan
parent 92ec846375
commit 4899e35fbb
4 changed files with 209 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
rpcs3/rpcs3qt/gui_settings.h
View File

@ -80,6 +80,7 @@ namespace gui
const QString game_list = "GameList";
const QString logger = "Logger";
const QString debugger = "Debugger";
const QString rsx = "RSX_Debugger";
const QString meta = "Meta";
const QString fs = "FileSystem";
const QString gs_frame = "GSFrame";
@ -148,6 +149,8 @@ namespace gui
const gui_save d_splitterState = gui_save(debugger, "splitterState", QByteArray());
const gui_save d_centerPC = gui_save(debugger, "centerPC", false);
const gui_save rsx_geometry = gui_save(rsx, "geometry", QByteArray());
const gui_save m_currentConfig = gui_save(meta, "currentConfig", QObject::tr("CurrentSettings"));
const gui_save m_currentStylesheet = gui_save(meta, "currentStylesheet", Default);
const gui_save m_saveNotes = gui_save(meta, "saveNotes", QVariantMap());

2
rpcs3/rpcs3qt/main_window.cpp
View File

@ -1153,7 +1153,7 @@ void main_window::CreateConnects()
connect(ui->toolsRsxDebuggerAct, &QAction::triggered, [=]
{
rsx_debugger* rsx = new rsx_debugger(this);
rsx_debugger* rsx = new rsx_debugger(guiSettings);
rsx->show();
});

371
rpcs3/rpcs3qt/rsx_debugger.cpp
View File

@ -9,70 +9,70 @@ enum GCMEnumTypes
constexpr auto qstr = QString::fromStdString;
rsx_debugger::rsx_debugger(QWidget* parent)
rsx_debugger::rsx_debugger(std::shared_ptr<gui_settings> gui_settings, QWidget* parent)
: QDialog(parent)
, m_item_count(37)
, m_gui_settings(gui_settings)
, m_addr(0x0)
, m_cur_texture(0)
, exit(false)
{
setWindowTitle(tr("RSX Debugger"));
setObjectName("rsx_debugger");
setAttribute(Qt::WA_DeleteOnClose);
setWindowFlags(Qt::Window);
//Fonts and Colors
QFont mono = QFontDatabase::systemFont(QFontDatabase::FixedFont);
mono.setPointSize(8);
QHBoxLayout* hbox_panel = new QHBoxLayout();
//Tools
QVBoxLayout* vbox_tools = new QVBoxLayout();
// Controls
QGroupBox* gb_controls = new QGroupBox(tr("RSX Debugger Controls"), this);
QHBoxLayout* hbox_controls = new QHBoxLayout();
QLabel l("000000000"); // hacky way to get the lineedit to resize properly
l.setFont(mono);
// Controls: Address
QGroupBox* gb_controls_addr = new QGroupBox(tr("Address:"), this);
QHBoxLayout* hbox_controls_addr = new QHBoxLayout();
m_addr_line = new QLineEdit();
m_addr_line->setFont(mono);
m_addr_line->setPlaceholderText("00000000");
m_addr_line->setMaxLength(8);
m_addr_line->setMaximumWidth(65);
m_addr_line->setFixedWidth(l.sizeHint().width());
setFocusProxy(m_addr_line);
QHBoxLayout* hbox_controls_addr = new QHBoxLayout();
hbox_controls_addr->addWidget(m_addr_line);
QGroupBox* gb_controls_addr = new QGroupBox(tr("Address:"));
gb_controls_addr->setLayout(hbox_controls_addr);
// Controls: Go to
QGroupBox* gb_controls_goto = new QGroupBox(tr("Go to:"), this);
QHBoxLayout* hbox_controls_goto = new QHBoxLayout();
QPushButton* b_goto_get = new QPushButton(tr("Get"), this);
QPushButton* b_goto_put = new QPushButton(tr("Put"), this);
QPushButton* b_goto_get = new QPushButton(tr("Get"));
QPushButton* b_goto_put = new QPushButton(tr("Put"));
b_goto_get->setAutoDefault(false);
b_goto_put->setAutoDefault(false);
QHBoxLayout* hbox_controls_goto = new QHBoxLayout();
hbox_controls_goto->addWidget(b_goto_get);
hbox_controls_goto->addWidget(b_goto_put);
QGroupBox* gb_controls_goto = new QGroupBox(tr("Go to:"));
gb_controls_goto->setLayout(hbox_controls_goto);
// Controls: Breaks
QGroupBox* gb_controls_breaks = new QGroupBox(tr("Break on:"), this);
QHBoxLayout* hbox_controls_breaks = new QHBoxLayout();
QPushButton* b_break_frame = new QPushButton(tr("Frame"), this);
QPushButton* b_break_text = new QPushButton(tr("Texture"), this);
QPushButton* b_break_draw = new QPushButton(tr("Draw"), this);
QPushButton* b_break_prim = new QPushButton(tr("Primitive"), this);
QPushButton* b_break_inst = new QPushButton(tr("Command"), this);
QPushButton* b_break_frame = new QPushButton(tr("Frame"));
QPushButton* b_break_text = new QPushButton(tr("Texture"));
QPushButton* b_break_draw = new QPushButton(tr("Draw"));
QPushButton* b_break_prim = new QPushButton(tr("Primitive"));
QPushButton* b_break_inst = new QPushButton(tr("Command"));
b_break_frame->setAutoDefault(false);
b_break_text->setAutoDefault(false);
b_break_draw->setAutoDefault(false);
b_break_prim->setAutoDefault(false);
b_break_inst->setAutoDefault(false);
QHBoxLayout* hbox_controls_breaks = new QHBoxLayout();
hbox_controls_breaks->addWidget(b_break_frame);
hbox_controls_breaks->addWidget(b_break_text);
hbox_controls_breaks->addWidget(b_break_draw);
hbox_controls_breaks->addWidget(b_break_prim);
hbox_controls_breaks->addWidget(b_break_inst);
QGroupBox* gb_controls_breaks = new QGroupBox(tr("Break on:"));
gb_controls_breaks->setLayout(hbox_controls_breaks);
// TODO: This feature is not yet implemented
@ -82,31 +82,31 @@ rsx_debugger::rsx_debugger(QWidget* parent)
b_break_prim->setEnabled(false);
b_break_inst->setEnabled(false);
QHBoxLayout* hbox_controls = new QHBoxLayout();
hbox_controls->addWidget(gb_controls_addr);
hbox_controls->addWidget(gb_controls_goto);
hbox_controls->addWidget(gb_controls_breaks);
gb_controls->setLayout(hbox_controls);
hbox_controls->addStretch(1);
QTabWidget* tw_rsx = new QTabWidget(this);
tw_rsx->setFixedSize(QSize(726, 660));
m_tw_rsx = new QTabWidget();
//adds a tab containing a list to the tabwidget
auto l_addRSXTab = [=](QTableWidget* table, QString tabname, int columns)
auto l_addRSXTab = [=](QTableWidget* table, const QString& tabname, int columns)
{
QWidget* tab = new QWidget(tw_rsx);
tw_rsx->addTab(tab, tabname);
table = new QTableWidget(tab);
table->setItemDelegate(new table_item_delegate(this));
table->setFixedSize(QSize(720, 634));
table = new QTableWidget();
table->setItemDelegate(new table_item_delegate);
table->setFont(mono);
table->setGridStyle(Qt::NoPen);
table->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContents);
table->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
table->setEditTriggers(QAbstractItemView::NoEditTriggers);
table->setSelectionBehavior(QAbstractItemView::SelectRows);
table->verticalHeader()->setVisible(false);
table->verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
table->verticalHeader()->setDefaultSectionSize(16);
table->horizontalHeader()->stretchLastSection();
table->setColumnCount(columns);
m_tw_rsx->addTab(table, tabname);
return table;
};
@ -119,6 +119,7 @@ rsx_debugger::rsx_debugger(QWidget* parent)
m_list_settings = l_addRSXTab(m_list_settings, tr("Settings"), 2);
//Tabs: List Columns
m_list_commands->installEventFilter(this);
m_list_commands->setHorizontalHeaderLabels(QStringList() << tr("Column") << tr("Value") << tr("Command") << tr("Count"));
m_list_commands->setColumnWidth(0, 70);
m_list_commands->setColumnWidth(1, 70);
@ -147,136 +148,66 @@ rsx_debugger::rsx_debugger(QWidget* parent)
m_list_settings->setColumnWidth(0, 170);
m_list_settings->setColumnWidth(1, 270);
// Fill list
for(u32 i=0; i<m_item_count; i++)
{
m_list_commands->insertRow(m_list_commands->rowCount());
}
for (u32 i = 0; i<frame_debug.command_queue.size(); i++)
m_list_captured_frame->insertRow(1);
//Tools: Tools = Controls + Notebook Tabs
vbox_tools->addWidget(gb_controls);
vbox_tools->addSpacing(10);
vbox_tools->addWidget(tw_rsx);
QVBoxLayout* vbox_tools = new QVBoxLayout();
vbox_tools->addLayout(hbox_controls);
vbox_tools->addWidget(m_tw_rsx);
// State explorer
QHBoxLayout* hbox_state_explorer = new QHBoxLayout();
QTabWidget* state_rsx = new QTabWidget(this);
state_rsx->setFixedSize(QSize(726,746)); // content fits nicely
QWidget* p_buffers = new QWidget(state_rsx);
QWidget* p_transform_program = new QWidget(state_rsx);
QWidget* p_shader_program = new QWidget(state_rsx);
QWidget* p_index_buffer = new QWidget(state_rsx);
state_rsx->addTab(p_buffers, tr("RTTs and DS"));
state_rsx->addTab(p_transform_program, tr("Transform program"));
state_rsx->addTab(p_shader_program, tr("Shader program"));
state_rsx->addTab(p_index_buffer, tr("Index buffer"));
m_text_transform_program = new QLabel(p_transform_program);
m_text_transform_program->setFixedSize(QSize(720, 720));
m_text_transform_program = new QLabel();
m_text_transform_program->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
m_text_transform_program->setFont(mono);
m_text_transform_program->setText("");
m_text_shader_program = new QLabel(p_shader_program);
m_text_shader_program->setFixedSize(QSize(720, 720));
m_text_shader_program = new QLabel();
m_text_shader_program->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
m_text_shader_program->setFont(mono);
m_text_shader_program->setText("");
m_list_index_buffer = new QListWidget(p_index_buffer);
m_list_index_buffer->setFixedSize(QSize(720, 720));
m_list_index_buffer = new QListWidget();
m_list_index_buffer->setFont(mono);
//Buffers
QVBoxLayout* vbox_buffers1 = new QVBoxLayout();
QVBoxLayout* vbox_buffers2 = new QVBoxLayout();
QGroupBox* gb_buffers_colorA = new QGroupBox(tr("Color Buffer A"), p_buffers);
QGroupBox* gb_buffers_colorB = new QGroupBox(tr("Color Buffer B"), p_buffers);
QGroupBox* gb_buffers_colorC = new QGroupBox(tr("Color Buffer C"), p_buffers);
QGroupBox* gb_buffers_colorD = new QGroupBox(tr("Color Buffer D"), p_buffers);
QGroupBox* gb_buffers_depth = new QGroupBox(tr("Depth Buffer"), p_buffers);
QGroupBox* gb_buffers_stencil = new QGroupBox(tr("Stencil Buffer"), p_buffers);
QGroupBox* gb_buffers_text = new QGroupBox(tr("Texture"), p_buffers);
QHBoxLayout* hbox_buffers_colorA = new QHBoxLayout();
QHBoxLayout* hbox_buffers_colorB = new QHBoxLayout();
QHBoxLayout* hbox_buffers_colorC = new QHBoxLayout();
QHBoxLayout* hbox_buffers_colorD = new QHBoxLayout();
QHBoxLayout* hbox_buffers_depth = new QHBoxLayout();
QHBoxLayout* hbox_buffers_stencil = new QHBoxLayout();
QHBoxLayout* hbox_buffers_text = new QHBoxLayout();
gb_buffers_colorA ->setLayout(hbox_buffers_colorA);
gb_buffers_colorB ->setLayout(hbox_buffers_colorB);
gb_buffers_colorC ->setLayout(hbox_buffers_colorC);
gb_buffers_colorD ->setLayout(hbox_buffers_colorD);
gb_buffers_depth ->setLayout(hbox_buffers_depth);
gb_buffers_stencil->setLayout(hbox_buffers_stencil);
gb_buffers_text ->setLayout(hbox_buffers_text);
//Buffers and textures
int m_panel_width = 108;
int m_panel_height = 108;
int m_text_width = 108;
int m_text_height = 108;
//Panels for displaying the buffers
m_buffer_colorA = new Buffer(p_buffers, false, 0);
m_buffer_colorB = new Buffer(p_buffers, false, 1);
m_buffer_colorC = new Buffer(p_buffers, false, 2);
m_buffer_colorD = new Buffer(p_buffers, false, 3);
m_buffer_depth = new Buffer(p_buffers, false);
m_buffer_stencil = new Buffer(p_buffers, false);
m_buffer_tex = new Buffer(p_buffers, true);
m_buffer_colorA ->setFixedSize(QSize(m_panel_width, m_panel_height));
m_buffer_colorB ->setFixedSize(QSize(m_panel_width, m_panel_height));
m_buffer_colorC ->setFixedSize(QSize(m_panel_width, m_panel_height));
m_buffer_colorD ->setFixedSize(QSize(m_panel_width, m_panel_height));
m_buffer_depth ->setFixedSize(QSize(m_panel_width, m_panel_height));
m_buffer_stencil->setFixedSize(QSize(m_panel_width, m_panel_height));
m_buffer_tex ->setFixedSize(QSize(m_text_width, m_text_height));
hbox_buffers_colorA ->addWidget(m_buffer_colorA);
hbox_buffers_colorB ->addWidget(m_buffer_colorB);
hbox_buffers_colorC ->addWidget(m_buffer_colorC);
hbox_buffers_colorD ->addWidget(m_buffer_colorD);
hbox_buffers_depth ->addWidget(m_buffer_depth);
hbox_buffers_stencil->addWidget(m_buffer_stencil);
hbox_buffers_text ->addWidget(m_buffer_tex);
m_buffer_colorA = new Buffer(false, 0, tr("Color Buffer A"));
m_buffer_colorB = new Buffer(false, 1, tr("Color Buffer B"));
m_buffer_colorC = new Buffer(false, 2, tr("Color Buffer C"));
m_buffer_colorD = new Buffer(false, 3, tr("Color Buffer D"));
m_buffer_depth = new Buffer(false, 4, tr("Depth Buffer"));
m_buffer_stencil = new Buffer(false, 4, tr("Stencil Buffer"));
m_buffer_tex = new Buffer(true, 4, tr("Texture"));
//Merge and display everything
vbox_buffers1->addSpacing(10);
vbox_buffers1->addWidget(gb_buffers_colorA);
vbox_buffers1->addSpacing(10);
vbox_buffers1->addWidget(gb_buffers_colorC);
vbox_buffers1->addSpacing(10);
vbox_buffers1->addWidget(gb_buffers_depth);
vbox_buffers1->addSpacing(10);
vbox_buffers1->addWidget(gb_buffers_text);
vbox_buffers1->addSpacing(10);
QVBoxLayout* vbox_buffers1 = new QVBoxLayout();
vbox_buffers1->addWidget(m_buffer_colorA);
vbox_buffers1->addWidget(m_buffer_colorC);
vbox_buffers1->addWidget(m_buffer_depth);
vbox_buffers1->addWidget(m_buffer_tex);
vbox_buffers1->addStretch();
vbox_buffers2->addSpacing(10);
vbox_buffers2->addWidget(gb_buffers_colorB);
vbox_buffers2->addSpacing(10);
vbox_buffers2->addWidget(gb_buffers_colorD);
vbox_buffers2->addSpacing(10);
vbox_buffers2->addWidget(gb_buffers_stencil);
vbox_buffers2->addSpacing(10);
QVBoxLayout* vbox_buffers2 = new QVBoxLayout();
vbox_buffers2->addWidget(m_buffer_colorB);
vbox_buffers2->addWidget(m_buffer_colorD);
vbox_buffers2->addWidget(m_buffer_stencil);
vbox_buffers2->addStretch();
hbox_state_explorer->addLayout(vbox_buffers1);
hbox_state_explorer->addSpacing(10);
hbox_state_explorer->addLayout(vbox_buffers2);
hbox_state_explorer->addStretch();
QHBoxLayout* buffer_layout = new QHBoxLayout();
buffer_layout->addLayout(vbox_buffers1);
buffer_layout->addLayout(vbox_buffers2);
buffer_layout->addStretch();
p_buffers->setLayout(hbox_state_explorer);
QWidget* buffers = new QWidget();
buffers->setLayout(buffer_layout);
hbox_panel->addLayout(vbox_tools);
hbox_panel->addSpacing(10);
hbox_panel->addWidget(state_rsx);
setLayout(hbox_panel);
QTabWidget* state_rsx = new QTabWidget();
state_rsx->addTab(buffers, tr("RTTs and DS"));
state_rsx->addTab(m_text_transform_program, tr("Transform program"));
state_rsx->addTab(m_text_shader_program, tr("Shader program"));
state_rsx->addTab(m_list_index_buffer, tr("Index buffer"));
QHBoxLayout* main_layout = new QHBoxLayout();
main_layout->addLayout(vbox_tools, 1);
main_layout->addWidget(state_rsx, 1);
setLayout(main_layout);
//Events
connect(b_goto_get, &QAbstractButton::clicked, [=]
@ -319,9 +250,11 @@ rsx_debugger::rsx_debugger(QWidget* parent)
connect(m_list_captured_draw_calls, &QTableWidget::itemClicked, this, &rsx_debugger::OnClickDrawCalls);
//Fill the frame
UpdateInformation();
setFixedSize(sizeHint());
setFocusProxy(m_addr_line);
for (u32 i = 0; i < frame_debug.command_queue.size(); i++)
m_list_captured_frame->insertRow(i);
if (!restoreGeometry(m_gui_settings->GetValue(gui::rsx_geometry).toByteArray()))
UpdateInformation();
}
rsx_debugger::~rsx_debugger()
@ -329,55 +262,108 @@ rsx_debugger::~rsx_debugger()
exit = true;
}
void rsx_debugger::closeEvent(QCloseEvent* event)
{
m_gui_settings->SetValue(gui::rsx_geometry, saveGeometry());
QDialog::closeEvent(event);
}
void rsx_debugger::keyPressEvent(QKeyEvent* event)
{
if(isActiveWindow())
{
switch(event->key())
{
case Qt::Key_F5: UpdateInformation(); return;
case Qt::Key_F5: UpdateInformation(); break;
}
}
QDialog::keyPressEvent(event);
}
void rsx_debugger::wheelEvent(QWheelEvent* event)
bool rsx_debugger::eventFilter(QObject* object, QEvent* event)
{
if (!m_list_commands->underMouse())
if (object == m_list_commands)
{
return;
}
QPoint numSteps = event->angleDelta() / 8 / 15; // http://doc.qt.io/qt-5/qwheelevent.html#pixelDelta
if(vm::check_addr(m_addr, 4))
{
int items = event->modifiers() & Qt::ControlModifier ? m_item_count : 1;
for(int i=0; i<items; ++i)
switch (event->type())
{
u32 offset;
if(vm::check_addr(m_addr, 4))
{
u32 cmd = vm::read32(m_addr);
u32 count = ((cmd & RSX_METHOD_OLD_JUMP_CMD_MASK) == RSX_METHOD_OLD_JUMP_CMD)
|| ((cmd & RSX_METHOD_NEW_JUMP_CMD_MASK) == RSX_METHOD_NEW_JUMP_CMD)
|| ((cmd & RSX_METHOD_CALL_CMD_MASK) == RSX_METHOD_CALL_CMD)
|| cmd == RSX_METHOD_RETURN_CMD ? 0 : (cmd >> 18) & 0x7ff;
case QEvent::Resize:
{
bool is_empty = m_list_commands->rowCount() < 1;
if (is_empty)
m_list_commands->insertRow(m_list_commands->rowCount());
offset = 1 + count;
int item_height = m_list_commands->rowHeight(0);
if (is_empty)
{
m_list_commands->clearContents();
m_list_commands->setRowCount(0);
}
int available_height = m_list_commands->rect().height() - m_list_commands->horizontalHeader()->height() - m_list_commands->frameWidth() * 2;
if (available_height < item_height || item_height < 1)
break;
int new_item_count = available_height / item_height;
if (new_item_count == m_item_count)
break;
m_item_count = new_item_count;
m_list_commands->clearContents();
m_list_commands->setRowCount(0);
for (u32 i = 0; i < m_item_count; ++i)
m_list_commands->insertRow(m_list_commands->rowCount());
if (m_list_commands->horizontalScrollBar())
m_list_commands->removeRow(--m_item_count);
UpdateInformation();
break;
}
case QEvent::Wheel:
{
QWheelEvent* wheelEvent = static_cast<QWheelEvent*>(event);
QPoint numSteps = wheelEvent->angleDelta() / 8 / 15; // http://doc.qt.io/qt-5/qwheelevent.html#pixelDelta
if (vm::check_addr(m_addr, 4))
{
int items = wheelEvent->modifiers() & Qt::ControlModifier ? m_item_count : 1;
for (int i = 0; i<items; ++i)
{
u32 offset;
if (vm::check_addr(m_addr, 4))
{
u32 cmd = vm::read32(m_addr);
u32 count = ((cmd & RSX_METHOD_OLD_JUMP_CMD_MASK) == RSX_METHOD_OLD_JUMP_CMD)
|| ((cmd & RSX_METHOD_NEW_JUMP_CMD_MASK) == RSX_METHOD_NEW_JUMP_CMD)
|| ((cmd & RSX_METHOD_CALL_CMD_MASK) == RSX_METHOD_CALL_CMD)
|| cmd == RSX_METHOD_RETURN_CMD ? 0 : (cmd >> 18) & 0x7ff;
offset = 1 + count;
}
else
{
offset = 1;
}
m_addr -= 4 * offset * numSteps.y();
}
}
else
{
offset = 1;
m_addr -= (wheelEvent->modifiers() & Qt::ControlModifier ? m_item_count : 1) * 4 * numSteps.y();
}
m_addr -= 4 * offset * numSteps.y();
UpdateInformation();
}
default:
break;
}
}
else
{
m_addr -= (event->modifiers() & Qt::ControlModifier ? m_item_count : 1) * 4 * numSteps.y();
}
UpdateInformation();
return QDialog::eventFilter(object, event);
}
namespace
@ -396,19 +382,32 @@ namespace
}
}
Buffer::Buffer(bool isTex, u32 id, const QString& name, QWidget* parent)
: QGroupBox(name, parent), m_isTex(isTex), m_id(id)
{
m_image_size = isTex ? Texture_Size : Panel_Size;
m_canvas = new QLabel();
m_canvas->setFixedSize(m_image_size);
QHBoxLayout* layout = new QHBoxLayout();
layout->setContentsMargins(1, 1, 1, 1);
layout->addWidget(m_canvas);
setLayout(layout);
};
// Draws a formatted and buffered <image> inside the Buffer Widget
void Buffer::showImage(const QImage& image)
{
if (image.isNull()) return;
m_image = image;
QImage scaled = m_image.scaled(size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
QLabel* m_canvas = new QLabel();
m_canvas->setFixedSize(size());
QImage scaled = m_image.scaled(m_image_size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
m_canvas->setPixmap(QPixmap::fromImage(scaled));
QHBoxLayout* layout = new QHBoxLayout();
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(m_canvas);
setLayout(layout);
QHBoxLayout* new_layout = new QHBoxLayout();
new_layout->setContentsMargins(1, 1, 1, 1);
new_layout->addWidget(m_canvas);
delete layout();
setLayout(new_layout);
}
void Buffer::mouseDoubleClickEvent(QMouseEvent* event)
@ -744,10 +743,10 @@ void rsx_debugger::GetBuffers()
Buffer* pnl;
switch(bufferId)
{
case 0: pnl = m_buffer_colorA; break;
case 1: pnl = m_buffer_colorB; break;
case 2: pnl = m_buffer_colorC; break;
default: pnl = m_buffer_colorD; break;
case 0: pnl = m_buffer_colorA; break;
case 1: pnl = m_buffer_colorB; break;
case 2: pnl = m_buffer_colorC; break;
default: pnl = m_buffer_colorD; break;
}
pnl->showImage(QImage(buffer, width, height, QImage::Format_RGB32));
}
@ -1109,7 +1108,7 @@ const char* rsx_debugger::ParseGCMEnum(u32 value, u32 type)
QString rsx_debugger::DisAsmCommand(u32 cmd, u32 count, u32 currentAddr, u32 ioAddr)
{
std::string disasm = "";
std::string disasm;
#define DISASM(string, ...) { if(disasm.empty()) disasm = fmt::format((string), ##__VA_ARGS__); else disasm += (' ' + fmt::format((string), ##__VA_ARGS__)); }
if((cmd & RSX_METHOD_OLD_JUMP_CMD_MASK) == RSX_METHOD_OLD_JUMP_CMD)

29
rpcs3/rpcs3qt/rsx_debugger.h
View File

@ -14,7 +14,6 @@
#include "table_item_delegate.h"
#include "gui_settings.h"
#include <QDialog>
#include <QLabel>
#include <QLineEdit>
#include <QHBoxLayout>
@ -27,19 +26,25 @@
#include <QSignalMapper>
#include <QPixmap>
class Buffer : public QWidget
class Buffer : public QGroupBox
{
Q_OBJECT
const QSize Panel_Size = QSize(108, 108);
const QSize Texture_Size = QSize(108, 108);
u32 m_id;
bool m_isTex;
QImage m_image;
QLabel* m_canvas;
QSize m_image_size;
public:
Buffer(QWidget* parent, bool isTex, u32 id = 4)
: QWidget(parent), m_isTex(isTex), m_id(id){};
Buffer(bool isTex, u32 id, const QString& name, QWidget* parent = 0);
void showImage(const QImage& image = QImage());
private:
void mouseDoubleClickEvent(QMouseEvent* event);
protected:
void mouseDoubleClickEvent(QMouseEvent* event) override;
};
class rsx_debugger : public QDialog
@ -59,6 +64,7 @@ class rsx_debugger : public QDialog
QTableWidget* m_list_texture;
QTableWidget* m_list_settings;
QListWidget* m_list_index_buffer;
QTabWidget* m_tw_rsx;
Buffer* m_buffer_colorA;
Buffer* m_buffer_colorB;
@ -73,9 +79,11 @@ class rsx_debugger : public QDialog
uint m_cur_texture;
std::shared_ptr<gui_settings> m_gui_settings;
public:
bool exit;
rsx_debugger(QWidget* parent);
rsx_debugger(std::shared_ptr<gui_settings> gui_settings, QWidget* parent = 0);
~rsx_debugger();
virtual void UpdateInformation();
@ -92,9 +100,12 @@ public:
void SetPC(const uint pc);
public Q_SLOTS:
virtual void keyPressEvent(QKeyEvent* event);
virtual void wheelEvent(QWheelEvent* event);
virtual void OnClickDrawCalls();
virtual void SetFlags();
virtual void SetPrograms();
protected:
virtual void closeEvent(QCloseEvent* event) override;
virtual void keyPressEvent(QKeyEvent* event) override;
virtual bool eventFilter(QObject* object, QEvent* event) override;
};