diff --git a/src/citra_qt/CMakeLists.txt b/src/citra_qt/CMakeLists.txt
index 549f69217..7f880df8b 100644
--- a/src/citra_qt/CMakeLists.txt
+++ b/src/citra_qt/CMakeLists.txt
@@ -2,6 +2,8 @@ set(SRCS
bootmanager.cpp
debugger/callstack.cpp
debugger/disassembler.cpp
+ debugger/graphics.cpp
+ debugger/graphics_cmdlists.cpp
debugger/ramview.cpp
debugger/registers.cpp
hotkeys.cpp
@@ -38,6 +40,8 @@ qt4_wrap_cpp(MOC_SRCS
bootmanager.hxx
debugger/callstack.hxx
debugger/disassembler.hxx
+ debugger/graphics.hxx
+ debugger/graphics_cmdlists.hxx
debugger/registers.hxx
debugger/ramview.hxx
hotkeys.hxx
diff --git a/src/citra_qt/citra_qt.vcxproj b/src/citra_qt/citra_qt.vcxproj
index 3f24bbfbf..c99c8eeee 100644
--- a/src/citra_qt/citra_qt.vcxproj
+++ b/src/citra_qt/citra_qt.vcxproj
@@ -130,6 +130,8 @@
+
+
@@ -143,9 +145,11 @@
-
+
+
+
@@ -182,4 +186,4 @@
-
\ No newline at end of file
+
diff --git a/src/citra_qt/citra_qt.vcxproj.filters b/src/citra_qt/citra_qt.vcxproj.filters
index 2b3838e29..903082c3c 100644
--- a/src/citra_qt/citra_qt.vcxproj.filters
+++ b/src/citra_qt/citra_qt.vcxproj.filters
@@ -36,10 +36,16 @@
debugger
-
+
debugger
-
+
+ debugger
+
+
+ debugger
+
+
debugger
@@ -65,10 +71,16 @@
debugger
-
+
debugger
-
+
+ debugger
+
+
+ debugger
+
+
debugger
@@ -106,4 +118,4 @@
-
\ No newline at end of file
+
diff --git a/src/citra_qt/debugger/graphics.cpp b/src/citra_qt/debugger/graphics.cpp
new file mode 100644
index 000000000..9aaade8f9
--- /dev/null
+++ b/src/citra_qt/debugger/graphics.cpp
@@ -0,0 +1,83 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "graphics.hxx"
+#include
+#include
+#include
+
+extern GraphicsDebugger g_debugger;
+
+GPUCommandStreamItemModel::GPUCommandStreamItemModel(QObject* parent) : QAbstractListModel(parent), command_count(0)
+{
+ connect(this, SIGNAL(GXCommandFinished(int)), this, SLOT(OnGXCommandFinishedInternal(int)));
+}
+
+int GPUCommandStreamItemModel::rowCount(const QModelIndex& parent) const
+{
+ return command_count;
+}
+
+QVariant GPUCommandStreamItemModel::data(const QModelIndex& index, int role) const
+{
+ if (!index.isValid())
+ return QVariant();
+
+ int command_index = index.row();
+ const GSP_GPU::GXCommand& command = GetDebugger()->ReadGXCommandHistory(command_index);
+ if (role == Qt::DisplayRole)
+ {
+ std::map command_names;
+ command_names[GSP_GPU::GXCommandId::REQUEST_DMA] = "REQUEST_DMA";
+ command_names[GSP_GPU::GXCommandId::SET_COMMAND_LIST_FIRST] = "SET_COMMAND_LIST_FIRST";
+ command_names[GSP_GPU::GXCommandId::SET_MEMORY_FILL] = "SET_MEMORY_FILL";
+ command_names[GSP_GPU::GXCommandId::SET_DISPLAY_TRANSFER] = "SET_DISPLAY_TRANSFER";
+ command_names[GSP_GPU::GXCommandId::SET_TEXTURE_COPY] = "SET_TEXTURE_COPY";
+ command_names[GSP_GPU::GXCommandId::SET_COMMAND_LIST_LAST] = "SET_COMMAND_LIST_LAST";
+ QString str = QString("%1 %2 %3 %4 %5 %6 %7 %8 %9").arg(command_names[static_cast(command.id)])
+ .arg(command.data[0], 8, 16, QLatin1Char('0'))
+ .arg(command.data[1], 8, 16, QLatin1Char('0'))
+ .arg(command.data[2], 8, 16, QLatin1Char('0'))
+ .arg(command.data[3], 8, 16, QLatin1Char('0'))
+ .arg(command.data[4], 8, 16, QLatin1Char('0'))
+ .arg(command.data[5], 8, 16, QLatin1Char('0'))
+ .arg(command.data[6], 8, 16, QLatin1Char('0'))
+ .arg(command.data[7], 8, 16, QLatin1Char('0'));
+ return QVariant(str);
+ }
+ else
+ {
+ return QVariant();
+ }
+}
+
+void GPUCommandStreamItemModel::GXCommandProcessed(int total_command_count)
+{
+ emit GXCommandFinished(total_command_count);
+}
+
+void GPUCommandStreamItemModel::OnGXCommandFinishedInternal(int total_command_count)
+{
+ if (total_command_count == 0)
+ return;
+
+ int prev_command_count = command_count;
+ command_count = total_command_count;
+ emit dataChanged(index(prev_command_count,0), index(total_command_count-1,0));
+}
+
+
+GPUCommandStreamWidget::GPUCommandStreamWidget(QWidget* parent) : QDockWidget(tr("Graphics Debugger"), parent)
+{
+ // TODO: set objectName!
+
+ GPUCommandStreamItemModel* command_model = new GPUCommandStreamItemModel(this);
+ g_debugger.RegisterObserver(command_model);
+
+ QListView* command_list = new QListView;
+ command_list->setModel(command_model);
+ command_list->setFont(QFont("monospace"));
+
+ setWidget(command_list);
+}
diff --git a/src/citra_qt/debugger/graphics.hxx b/src/citra_qt/debugger/graphics.hxx
new file mode 100644
index 000000000..72656f93c
--- /dev/null
+++ b/src/citra_qt/debugger/graphics.hxx
@@ -0,0 +1,43 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include
+#include
+
+#include "video_core/gpu_debugger.h"
+
+class GPUCommandStreamItemModel : public QAbstractListModel, public GraphicsDebugger::DebuggerObserver
+{
+ Q_OBJECT
+
+public:
+ GPUCommandStreamItemModel(QObject* parent);
+
+ int rowCount(const QModelIndex& parent = QModelIndex()) const override;
+ QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
+
+public:
+ void GXCommandProcessed(int total_command_count) override;
+
+public slots:
+ void OnGXCommandFinishedInternal(int total_command_count);
+
+signals:
+ void GXCommandFinished(int total_command_count);
+
+private:
+ int command_count;
+};
+
+class GPUCommandStreamWidget : public QDockWidget
+{
+ Q_OBJECT
+
+public:
+ GPUCommandStreamWidget(QWidget* parent = 0);
+
+private:
+};
diff --git a/src/citra_qt/debugger/graphics_cmdlists.cpp b/src/citra_qt/debugger/graphics_cmdlists.cpp
new file mode 100644
index 000000000..195197ef5
--- /dev/null
+++ b/src/citra_qt/debugger/graphics_cmdlists.cpp
@@ -0,0 +1,139 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "graphics_cmdlists.hxx"
+#include
+
+extern GraphicsDebugger g_debugger;
+
+GPUCommandListModel::GPUCommandListModel(QObject* parent) : QAbstractItemModel(parent)
+{
+ root_item = new TreeItem(TreeItem::ROOT, 0, NULL, this);
+
+ connect(this, SIGNAL(CommandListCalled()), this, SLOT(OnCommandListCalledInternal()), Qt::UniqueConnection);
+}
+
+QModelIndex GPUCommandListModel::index(int row, int column, const QModelIndex& parent) const
+{
+ TreeItem* item;
+
+ if (!parent.isValid()) {
+ item = root_item;
+ } else {
+ item = (TreeItem*)parent.internalPointer();
+ }
+
+ return createIndex(row, column, item->children[row]);
+}
+
+QModelIndex GPUCommandListModel::parent(const QModelIndex& child) const
+{
+ if (!child.isValid())
+ return QModelIndex();
+
+ TreeItem* item = (TreeItem*)child.internalPointer();
+
+ if (item->parent == NULL)
+ return QModelIndex();
+
+ return createIndex(item->parent->index, 0, item->parent);
+}
+
+int GPUCommandListModel::rowCount(const QModelIndex& parent) const
+{
+ TreeItem* item;
+ if (!parent.isValid()) {
+ item = root_item;
+ } else {
+ item = (TreeItem*)parent.internalPointer();
+ }
+ return item->children.size();
+}
+
+int GPUCommandListModel::columnCount(const QModelIndex& parent) const
+{
+ return 2;
+}
+
+QVariant GPUCommandListModel::data(const QModelIndex& index, int role) const
+{
+ if (!index.isValid())
+ return QVariant();
+
+ const TreeItem* item = (const TreeItem*)index.internalPointer();
+
+ if (item->type == TreeItem::COMMAND_LIST)
+ {
+ const GraphicsDebugger::PicaCommandList& cmdlist = command_lists[item->index].second;
+ u32 address = command_lists[item->index].first;
+
+ if (role == Qt::DisplayRole && index.column() == 0)
+ {
+ return QVariant(QString("0x%1 bytes at 0x%2").arg(cmdlist.size(), 0, 16).arg(address, 8, 16, QLatin1Char('0')));
+ }
+ }
+ else
+ {
+ // index refers to a specific command
+ const GraphicsDebugger::PicaCommandList& cmdlist = command_lists[item->parent->index].second;
+ const GraphicsDebugger::PicaCommand& cmd = cmdlist[item->index];
+ const Pica::CommandHeader& header = cmd.GetHeader();
+
+ if (role == Qt::DisplayRole) {
+ QString content;
+ if (index.column() == 0) {
+ content = Pica::command_names[header.cmd_id];
+ content.append(" ");
+ } else if (index.column() == 1) {
+ for (int j = 0; j < cmd.size(); ++j)
+ content.append(QString("%1 ").arg(cmd[j], 8, 16, QLatin1Char('0')));
+ }
+
+ return QVariant(content);
+ }
+ }
+
+ return QVariant();
+}
+
+void GPUCommandListModel::OnCommandListCalled(const GraphicsDebugger::PicaCommandList& lst, bool is_new)
+{
+ emit CommandListCalled();
+}
+
+
+void GPUCommandListModel::OnCommandListCalledInternal()
+{
+ beginResetModel();
+
+ command_lists = GetDebugger()->GetCommandLists();
+
+ // delete root item and rebuild tree
+ delete root_item;
+ root_item = new TreeItem(TreeItem::ROOT, 0, NULL, this);
+
+ for (int command_list_idx = 0; command_list_idx < command_lists.size(); ++command_list_idx) {
+ TreeItem* command_list_item = new TreeItem(TreeItem::COMMAND_LIST, command_list_idx, root_item, root_item);
+ root_item->children.push_back(command_list_item);
+
+ const GraphicsDebugger::PicaCommandList& command_list = command_lists[command_list_idx].second;
+ for (int command_idx = 0; command_idx < command_list.size(); ++command_idx) {
+ TreeItem* command_item = new TreeItem(TreeItem::COMMAND, command_idx, command_list_item, command_list_item);
+ command_list_item->children.push_back(command_item);
+ }
+ }
+
+ endResetModel();
+}
+
+GPUCommandListWidget::GPUCommandListWidget(QWidget* parent) : QDockWidget(tr("Pica Command List"), parent)
+{
+ GPUCommandListModel* model = new GPUCommandListModel(this);
+ g_debugger.RegisterObserver(model);
+
+ QTreeView* tree_widget = new QTreeView;
+ tree_widget->setModel(model);
+ tree_widget->setFont(QFont("monospace"));
+ setWidget(tree_widget);
+}
diff --git a/src/citra_qt/debugger/graphics_cmdlists.hxx b/src/citra_qt/debugger/graphics_cmdlists.hxx
new file mode 100644
index 000000000..b4e6e3c8a
--- /dev/null
+++ b/src/citra_qt/debugger/graphics_cmdlists.hxx
@@ -0,0 +1,64 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include
+#include
+
+#include "video_core/gpu_debugger.h"
+
+// TODO: Rename class, since it's not actually a list model anymore...
+class GPUCommandListModel : public QAbstractItemModel, public GraphicsDebugger::DebuggerObserver
+{
+ Q_OBJECT
+
+public:
+ GPUCommandListModel(QObject* parent);
+
+ QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const;
+ QModelIndex parent(const QModelIndex& child) const;
+ int columnCount(const QModelIndex& parent = QModelIndex()) const;
+ int rowCount(const QModelIndex& parent = QModelIndex()) const override;
+ QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
+
+public:
+ void OnCommandListCalled(const GraphicsDebugger::PicaCommandList& lst, bool is_new) override;
+
+public slots:
+ void OnCommandListCalledInternal();
+
+signals:
+ void CommandListCalled();
+
+private:
+ struct TreeItem : public QObject
+ {
+ enum Type {
+ ROOT,
+ COMMAND_LIST,
+ COMMAND
+ };
+
+ TreeItem(Type type, int index, TreeItem* item_parent, QObject* parent) : QObject(parent), type(type), index(index), parent(item_parent) {}
+
+ Type type;
+ int index;
+ std::vector children;
+ TreeItem* parent;
+ };
+
+ std::vector> command_lists;
+ TreeItem* root_item;
+};
+
+class GPUCommandListWidget : public QDockWidget
+{
+ Q_OBJECT
+
+public:
+ GPUCommandListWidget(QWidget* parent = 0);
+
+private:
+};
diff --git a/src/citra_qt/main.cpp b/src/citra_qt/main.cpp
index 9be982909..087716c01 100644
--- a/src/citra_qt/main.cpp
+++ b/src/citra_qt/main.cpp
@@ -19,6 +19,8 @@
#include "debugger/registers.hxx"
#include "debugger/callstack.hxx"
#include "debugger/ramview.hxx"
+#include "debugger/graphics.hxx"
+#include "debugger/graphics_cmdlists.hxx"
#include "core/system.h"
#include "core/loader.h"
@@ -47,10 +49,20 @@ GMainWindow::GMainWindow()
addDockWidget(Qt::RightDockWidgetArea, callstackWidget);
callstackWidget->hide();
+ graphicsWidget = new GPUCommandStreamWidget(this);
+ addDockWidget(Qt::RightDockWidgetArea, graphicsWidget);
+ callstackWidget->hide();
+
+ graphicsCommandsWidget = new GPUCommandListWidget(this);
+ addDockWidget(Qt::RightDockWidgetArea, graphicsCommandsWidget);
+ callstackWidget->hide();
+
QMenu* debug_menu = ui.menu_View->addMenu(tr("Debugging"));
debug_menu->addAction(disasmWidget->toggleViewAction());
debug_menu->addAction(registersWidget->toggleViewAction());
debug_menu->addAction(callstackWidget->toggleViewAction());
+ debug_menu->addAction(graphicsWidget->toggleViewAction());
+ debug_menu->addAction(graphicsCommandsWidget->toggleViewAction());
// Set default UI state
// geometry: 55% of the window contents are in the upper screen half, 45% in the lower half
diff --git a/src/citra_qt/main.hxx b/src/citra_qt/main.hxx
index fa122f76e..6bcb37a30 100644
--- a/src/citra_qt/main.hxx
+++ b/src/citra_qt/main.hxx
@@ -10,6 +10,8 @@ class GRenderWindow;
class DisassemblerWidget;
class RegistersWidget;
class CallstackWidget;
+class GPUCommandStreamWidget;
+class GPUCommandListWidget;
class GMainWindow : public QMainWindow
{
@@ -50,6 +52,8 @@ private:
DisassemblerWidget* disasmWidget;
RegistersWidget* registersWidget;
CallstackWidget* callstackWidget;
+ GPUCommandStreamWidget* graphicsWidget;
+ GPUCommandListWidget* graphicsCommandsWidget;
};
#endif // _CITRA_QT_MAIN_HXX_
diff --git a/src/common/common.vcxproj b/src/common/common.vcxproj
index 86295a480..1f5c714c3 100644
--- a/src/common/common.vcxproj
+++ b/src/common/common.vcxproj
@@ -182,6 +182,7 @@
+
@@ -221,4 +222,4 @@
-
\ No newline at end of file
+
diff --git a/src/common/common.vcxproj.filters b/src/common/common.vcxproj.filters
index 84cfa8837..e8c4ce360 100644
--- a/src/common/common.vcxproj.filters
+++ b/src/common/common.vcxproj.filters
@@ -4,6 +4,7 @@
+
@@ -28,6 +29,7 @@
+
@@ -39,7 +41,6 @@
-
@@ -65,4 +66,4 @@
-
\ No newline at end of file
+
diff --git a/src/common/log.h b/src/common/log.h
index 8b39b03a1..d0da68aad 100644
--- a/src/common/log.h
+++ b/src/common/log.h
@@ -60,7 +60,7 @@ enum LOG_TYPE {
NDMA,
HLE,
RENDER,
- LCD,
+ GPU,
HW,
TIME,
NETPLAY,
diff --git a/src/common/log_manager.cpp b/src/common/log_manager.cpp
index 146472888..b4a761c75 100644
--- a/src/common/log_manager.cpp
+++ b/src/common/log_manager.cpp
@@ -65,7 +65,7 @@ LogManager::LogManager()
m_Log[LogTypes::WII_IPC_ES] = new LogContainer("WII_IPC_ES", "WII IPC ES");
m_Log[LogTypes::WII_IPC_FILEIO] = new LogContainer("WII_IPC_FILEIO", "WII IPC FILEIO");
m_Log[LogTypes::RENDER] = new LogContainer("RENDER", "RENDER");
- m_Log[LogTypes::LCD] = new LogContainer("LCD", "LCD");
+ m_Log[LogTypes::GPU] = new LogContainer("GPU", "GPU");
m_Log[LogTypes::SVC] = new LogContainer("SVC", "Supervisor Call HLE");
m_Log[LogTypes::NDMA] = new LogContainer("NDMA", "NDMA");
m_Log[LogTypes::HLE] = new LogContainer("HLE", "High Level Emulation");
diff --git a/src/common/register_set.h b/src/common/register_set.h
new file mode 100644
index 000000000..0418551b3
--- /dev/null
+++ b/src/common/register_set.h
@@ -0,0 +1,161 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+// Copyright 2014 Tony Wasserka
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the owner nor the names of its contributors may
+// be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/*
+ * Standardized way to define a group of registers and corresponding data structures. To define
+ * a new register set, first define struct containing an enumeration called "Id" containing
+ * all register IDs and a template union called "Struct". Specialize the Struct union for any
+ * register ID which needs to be accessed in a specialized way. You can then declare the object
+ * containing all register values using the RegisterSet type, where
+ * BaseType is the underlying type of each register (e.g. u32).
+ * Of course, you'll usually want to implement the Struct template such that they are of the same
+ * size as BaseType. However, it's also possible to make it larger, e.g. when you want to describe
+ * multiple registers with the same structure.
+ *
+ * Example:
+ *
+ * struct Regs {
+ * enum Id : u32 {
+ * Value1 = 0,
+ * Value2 = 1,
+ * Value3 = 2,
+ * NumIds = 3
+ * };
+ *
+ * // declare register definition structures
+ * template
+ * union Struct;
+ * };
+ *
+ * // Define register set object
+ * RegisterSet registers;
+ *
+ * // define register definition structures
+ * template<>
+ * union Regs::Struct {
+ * BitField<0, 4, u32> some_field;
+ * BitField<4, 3, u32> some_other_field;
+ * };
+ *
+ * Usage in external code (within SomeNamespace scope):
+ *
+ * For a register which maps to a single index:
+ * registers.Get().some_field = some_value;
+ *
+ * For a register which maps to different indices, e.g. a group of similar registers
+ * registers.Get(index).some_field = some_value;
+ *
+ *
+ * @tparam BaseType Base type used for storing individual registers, e.g. u32
+ * @tparam RegDefinition Class defining an enumeration called "Id" and a template union, as described above.
+ * @note RegDefinition::Id needs to have an enum value called NumIds defining the number of registers to be allocated.
+ */
+template
+struct RegisterSet {
+ // Register IDs
+ using Id = typename RegDefinition::Id;
+
+ // type used for *this
+ using ThisType = RegisterSet;
+
+ // Register definition structs, defined in RegDefinition
+ template
+ using Struct = typename RegDefinition::template Struct;
+
+
+ /*
+ * Lookup register with the given id and return it as the corresponding structure type.
+ * @note This just forwards the arguments to Get(Id).
+ */
+ template
+ const Struct& Get() const {
+ return Get(id);
+ }
+
+ /*
+ * Lookup register with the given id and return it as the corresponding structure type.
+ * @note This just forwards the arguments to Get(Id).
+ */
+ template
+ Struct& Get() {
+ return Get(id);
+ }
+
+ /*
+ * Lookup register with the given index and return it as the corresponding structure type.
+ * @todo Is this portable with regards to structures larger than BaseType?
+ * @note if index==id, you don't need to specify the function parameter.
+ */
+ template
+ const Struct& Get(const Id& index) const {
+ const int idx = static_cast(index);
+ return *reinterpret_cast*>(&raw[idx]);
+ }
+
+ /*
+ * Lookup register with the given index and return it as the corresponding structure type.
+ * @note This just forwards the arguments to the const version of Get(Id).
+ * @note if index==id, you don't need to specify the function parameter.
+ */
+ template
+ Struct& Get(const Id& index) {
+ return const_cast&>(GetThis().Get(index));
+ }
+
+ /*
+ * Plain array access.
+ * @note If you want to have this casted to a register defininition struct, use Get() instead.
+ */
+ const BaseType& operator[] (const Id& id) const {
+ return raw[static_cast(id)];
+ }
+
+ /*
+ * Plain array access.
+ * @note If you want to have this casted to a register defininition struct, use Get() instead.
+ * @note This operator just forwards its argument to the const version.
+ */
+ BaseType& operator[] (const Id& id) {
+ return const_cast(GetThis()[id]);
+ }
+
+private:
+ /*
+ * Returns a const reference to "this".
+ */
+ const ThisType& GetThis() const {
+ return static_cast(*this);
+ }
+
+ BaseType raw[Id::NumIds];
+};
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 4086b415b..1c1a2eeb3 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -42,8 +42,8 @@ set(SRCS core.cpp
hle/service/hid.cpp
hle/service/service.cpp
hle/service/srv.cpp
+ hw/gpu.cpp
hw/hw.cpp
- hw/lcd.cpp
hw/ndma.cpp)
set(HEADERS core.h
@@ -88,8 +88,8 @@ set(HEADERS core.h
hle/service/hid.h
hle/service/service.h
hle/service/srv.h
+ hw/gpu.h
hw/hw.h
- hw/lcd.h
hw/ndma.h)
add_library(core STATIC ${SRCS} ${HEADERS})
diff --git a/src/core/core.vcxproj b/src/core/core.vcxproj
index f271d336e..8a3ad83ea 100644
--- a/src/core/core.vcxproj
+++ b/src/core/core.vcxproj
@@ -177,8 +177,8 @@
+
-
@@ -226,8 +226,8 @@
+
-
@@ -239,4 +239,4 @@
-
\ No newline at end of file
+
diff --git a/src/core/core.vcxproj.filters b/src/core/core.vcxproj.filters
index b6c1d5b93..f7b342f98 100644
--- a/src/core/core.vcxproj.filters
+++ b/src/core/core.vcxproj.filters
@@ -102,7 +102,7 @@
hw
-
+
hw
@@ -244,7 +244,7 @@
hw
-
+
hw
@@ -299,4 +299,4 @@
-
\ No newline at end of file
+
diff --git a/src/core/hle/service/gsp.cpp b/src/core/hle/service/gsp.cpp
index 50cee2c41..aabcb48db 100644
--- a/src/core/hle/service/gsp.cpp
+++ b/src/core/hle/service/gsp.cpp
@@ -10,25 +10,29 @@
#include "core/hle/hle.h"
#include "core/hle/service/gsp.h"
-#include "core/hw/lcd.h"
+#include "core/hw/gpu.h"
+
+#include "video_core/gpu_debugger.h"
////////////////////////////////////////////////////////////////////////////////////////////////////
+// Main graphics debugger object - TODO: Here is probably not the best place for this
+GraphicsDebugger g_debugger;
+
/// GSP shared memory GX command buffer header
union GX_CmdBufferHeader {
u32 hex;
- // Current command index. This index is updated by GSP module after loading the command data,
- // right before the command is processed. When this index is updated by GSP module, the total
+ // Current command index. This index is updated by GSP module after loading the command data,
+ // right before the command is processed. When this index is updated by GSP module, the total
// commands field is decreased by one as well.
BitField<0,8,u32> index;
-
+
// Total commands to process, must not be value 0 when GSP module handles commands. This must be
- // <=15 when writing a command to shared memory. This is incremented by the application when
- // writing a command to shared memory, after increasing this value TriggerCmdReqQueue is only
+ // <=15 when writing a command to shared memory. This is incremented by the application when
+ // writing a command to shared memory, after increasing this value TriggerCmdReqQueue is only
// used if this field is value 1.
BitField<8,8,u32> number_commands;
-
};
/// Gets the address of the start (header) of a command buffer in GSP shared memory
@@ -44,7 +48,11 @@ static inline u8* GX_GetCmdBufferPointer(u32 thread_id, u32 offset=0) {
/// Finishes execution of a GSP command
void GX_FinishCommand(u32 thread_id) {
GX_CmdBufferHeader* header = (GX_CmdBufferHeader*)GX_GetCmdBufferPointer(thread_id);
+
+ g_debugger.GXCommandProcessed(GX_GetCmdBufferPointer(thread_id, 0x20 + (header->index * 0x20)));
+
header->number_commands = header->number_commands - 1;
+ // TODO: Increment header->index?
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -54,10 +62,6 @@ namespace GSP_GPU {
u32 g_thread_id = 0;
-enum {
- CMD_GX_REQUEST_DMA = 0x00000000,
-};
-
enum {
REG_FRAMEBUFFER_1 = 0x00400468,
REG_FRAMEBUFFER_2 = 0x00400494,
@@ -65,14 +69,14 @@ enum {
/// Read a GSP GPU hardware register
void ReadHWRegs(Service::Interface* self) {
- static const u32 framebuffer_1[] = {LCD::PADDR_VRAM_TOP_LEFT_FRAME1, LCD::PADDR_VRAM_TOP_RIGHT_FRAME1};
- static const u32 framebuffer_2[] = {LCD::PADDR_VRAM_TOP_LEFT_FRAME2, LCD::PADDR_VRAM_TOP_RIGHT_FRAME2};
+ static const u32 framebuffer_1[] = {GPU::PADDR_VRAM_TOP_LEFT_FRAME1, GPU::PADDR_VRAM_TOP_RIGHT_FRAME1};
+ static const u32 framebuffer_2[] = {GPU::PADDR_VRAM_TOP_LEFT_FRAME2, GPU::PADDR_VRAM_TOP_RIGHT_FRAME2};
u32* cmd_buff = Service::GetCommandBuffer();
u32 reg_addr = cmd_buff[1];
u32 size = cmd_buff[2];
u32* dst = (u32*)Memory::GetPointer(cmd_buff[0x41]);
-
+
switch (reg_addr) {
// NOTE: Calling SetFramebufferLocation here is a hack... Not sure the correct way yet to set
@@ -81,13 +85,13 @@ void ReadHWRegs(Service::Interface* self) {
// Top framebuffer 1 addresses
case REG_FRAMEBUFFER_1:
- LCD::SetFramebufferLocation(LCD::FRAMEBUFFER_LOCATION_VRAM);
+ GPU::SetFramebufferLocation(GPU::FRAMEBUFFER_LOCATION_VRAM);
memcpy(dst, framebuffer_1, size);
break;
// Top framebuffer 2 addresses
case REG_FRAMEBUFFER_2:
- LCD::SetFramebufferLocation(LCD::FRAMEBUFFER_LOCATION_VRAM);
+ GPU::SetFramebufferLocation(GPU::FRAMEBUFFER_LOCATION_VRAM);
memcpy(dst, framebuffer_2, size);
break;
@@ -101,25 +105,54 @@ void RegisterInterruptRelayQueue(Service::Interface* self) {
u32* cmd_buff = Service::GetCommandBuffer();
u32 flags = cmd_buff[1];
u32 event_handle = cmd_buff[3]; // TODO(bunnei): Implement event handling
+
cmd_buff[2] = g_thread_id; // ThreadID
}
+
/// This triggers handling of the GX command written to the command buffer in shared memory.
void TriggerCmdReqQueue(Service::Interface* self) {
GX_CmdBufferHeader* header = (GX_CmdBufferHeader*)GX_GetCmdBufferPointer(g_thread_id);
u32* cmd_buff = (u32*)GX_GetCmdBufferPointer(g_thread_id, 0x20 + (header->index * 0x20));
- switch (cmd_buff[0]) {
+ switch (static_cast(cmd_buff[0])) {
// GX request DMA - typically used for copying memory from GSP heap to VRAM
- case CMD_GX_REQUEST_DMA:
+ case GXCommandId::REQUEST_DMA:
memcpy(Memory::GetPointer(cmd_buff[2]), Memory::GetPointer(cmd_buff[1]), cmd_buff[3]);
break;
+ case GXCommandId::SET_COMMAND_LIST_LAST:
+ GPU::Write(GPU::Registers::CommandListAddress, cmd_buff[1] >> 3);
+ GPU::Write(GPU::Registers::CommandListSize, cmd_buff[2] >> 3);
+ GPU::Write(GPU::Registers::ProcessCommandList, 1); // TODO: Not sure if we are supposed to always write this
+
+ // TODO: Move this to GPU
+ // TODO: Not sure what units the size is measured in
+ g_debugger.CommandListCalled(cmd_buff[1], (u32*)Memory::GetPointer(cmd_buff[1]), cmd_buff[2]);
+ break;
+
+ case GXCommandId::SET_MEMORY_FILL:
+ break;
+
+ case GXCommandId::SET_DISPLAY_TRANSFER:
+ break;
+
+ case GXCommandId::SET_TEXTURE_COPY:
+ break;
+
+ case GXCommandId::SET_COMMAND_LIST_FIRST:
+ {
+ //u32* buf0_data = (u32*)Memory::GetPointer(cmd_buff[1]);
+ //u32* buf1_data = (u32*)Memory::GetPointer(cmd_buff[3]);
+ //u32* buf2_data = (u32*)Memory::GetPointer(cmd_buff[5]);
+ break;
+ }
+
default:
ERROR_LOG(GSP, "TriggerCmdReqQueue unknown command 0x%08X", cmd_buff[0]);
}
-
+
GX_FinishCommand(g_thread_id);
}
diff --git a/src/core/hle/service/gsp.h b/src/core/hle/service/gsp.h
index eb5786cd1..214de140f 100644
--- a/src/core/hle/service/gsp.h
+++ b/src/core/hle/service/gsp.h
@@ -11,6 +11,23 @@
namespace GSP_GPU {
+enum class GXCommandId : u32 {
+ REQUEST_DMA = 0x00000000,
+ SET_COMMAND_LIST_LAST = 0x00000001,
+ SET_MEMORY_FILL = 0x00000002, // TODO: Confirm? (lictru uses 0x01000102)
+ SET_DISPLAY_TRANSFER = 0x00000003,
+ SET_TEXTURE_COPY = 0x00000004,
+ SET_COMMAND_LIST_FIRST = 0x00000005,
+};
+
+union GXCommand {
+ struct {
+ GXCommandId id;
+ };
+
+ u32 data[0x20];
+};
+
/// Interface to "srv:" service
class Interface : public Service::Interface {
public:
diff --git a/src/core/hw/lcd.cpp b/src/core/hw/gpu.cpp
similarity index 72%
rename from src/core/hw/lcd.cpp
rename to src/core/hw/gpu.cpp
index b57563a73..ec2d0e156 100644
--- a/src/core/hw/lcd.cpp
+++ b/src/core/hw/gpu.cpp
@@ -7,13 +7,13 @@
#include "core/core.h"
#include "core/mem_map.h"
-#include "core/hw/lcd.h"
+#include "core/hle/kernel/thread.h"
+#include "core/hw/gpu.h"
#include "video_core/video_core.h"
-#include "core/hle/kernel/thread.h"
-namespace LCD {
+namespace GPU {
Registers g_regs;
@@ -61,7 +61,7 @@ const FramebufferLocation GetFramebufferLocation() {
} else if ((g_regs.framebuffer_top_right_1 & ~Memory::FCRAM_MASK) == Memory::FCRAM_PADDR) {
return FRAMEBUFFER_LOCATION_FCRAM;
} else {
- ERROR_LOG(LCD, "unknown framebuffer location!");
+ ERROR_LOG(GPU, "unknown framebuffer location!");
}
return FRAMEBUFFER_LOCATION_UNKNOWN;
}
@@ -78,7 +78,7 @@ const u8* GetFramebufferPointer(const u32 address) {
case FRAMEBUFFER_LOCATION_VRAM:
return (const u8*)Memory::GetPointer(Memory::VirtualAddressFromPhysical_VRAM(address));
default:
- ERROR_LOG(LCD, "unknown framebuffer location");
+ ERROR_LOG(GPU, "unknown framebuffer location");
}
return NULL;
}
@@ -86,34 +86,73 @@ const u8* GetFramebufferPointer(const u32 address) {
template
inline void Read(T &var, const u32 addr) {
switch (addr) {
- case REG_FRAMEBUFFER_TOP_LEFT_1:
+ case Registers::FramebufferTopLeft1:
var = g_regs.framebuffer_top_left_1;
break;
- case REG_FRAMEBUFFER_TOP_LEFT_2:
+
+ case Registers::FramebufferTopLeft2:
var = g_regs.framebuffer_top_left_2;
break;
- case REG_FRAMEBUFFER_TOP_RIGHT_1:
+
+ case Registers::FramebufferTopRight1:
var = g_regs.framebuffer_top_right_1;
break;
- case REG_FRAMEBUFFER_TOP_RIGHT_2:
+
+ case Registers::FramebufferTopRight2:
var = g_regs.framebuffer_top_right_2;
break;
- case REG_FRAMEBUFFER_SUB_LEFT_1:
+
+ case Registers::FramebufferSubLeft1:
var = g_regs.framebuffer_sub_left_1;
break;
- case REG_FRAMEBUFFER_SUB_RIGHT_1:
+
+ case Registers::FramebufferSubRight1:
var = g_regs.framebuffer_sub_right_1;
break;
+
+ case Registers::CommandListSize:
+ var = g_regs.command_list_size;
+ break;
+
+ case Registers::CommandListAddress:
+ var = g_regs.command_list_address;
+ break;
+
+ case Registers::ProcessCommandList:
+ var = g_regs.command_processing_enabled;
+ break;
+
default:
- ERROR_LOG(LCD, "unknown Read%d @ 0x%08X", sizeof(var) * 8, addr);
+ ERROR_LOG(GPU, "unknown Read%d @ 0x%08X", sizeof(var) * 8, addr);
break;
}
-
}
template
inline void Write(u32 addr, const T data) {
- ERROR_LOG(LCD, "unknown Write%d 0x%08X @ 0x%08X", sizeof(data) * 8, data, addr);
+ switch (static_cast(addr)) {
+ case Registers::CommandListSize:
+ g_regs.command_list_size = data;
+ break;
+
+ case Registers::CommandListAddress:
+ g_regs.command_list_address = data;
+ break;
+
+ case Registers::ProcessCommandList:
+ g_regs.command_processing_enabled = data;
+ if (g_regs.command_processing_enabled & 1)
+ {
+ // u32* buffer = (u32*)Memory::GetPointer(g_regs.command_list_address << 3);
+ ERROR_LOG(GPU, "Beginning %x bytes of commands from address %x", g_regs.command_list_size, g_regs.command_list_address << 3);
+ // TODO: Process command list!
+ }
+ break;
+
+ default:
+ ERROR_LOG(GPU, "unknown Write%d 0x%08X @ 0x%08X", sizeof(data) * 8, data, addr);
+ break;
+ }
}
// Explicitly instantiate template functions because we aren't defining this in the header:
@@ -144,12 +183,12 @@ void Update() {
void Init() {
g_last_ticks = Core::g_app_core->GetTicks();
SetFramebufferLocation(FRAMEBUFFER_LOCATION_FCRAM);
- NOTICE_LOG(LCD, "initialized OK");
+ NOTICE_LOG(GPU, "initialized OK");
}
/// Shutdown hardware
void Shutdown() {
- NOTICE_LOG(LCD, "shutdown OK");
+ NOTICE_LOG(GPU, "shutdown OK");
}
} // namespace
diff --git a/src/core/hw/lcd.h b/src/core/hw/gpu.h
similarity index 75%
rename from src/core/hw/lcd.h
rename to src/core/hw/gpu.h
index 2dd3b4adc..f26f25e98 100644
--- a/src/core/hw/lcd.h
+++ b/src/core/hw/gpu.h
@@ -6,9 +6,24 @@
#include "common/common_types.h"
-namespace LCD {
+namespace GPU {
struct Registers {
+ enum Id : u32 {
+ FramebufferTopLeft1 = 0x1EF00468, // Main LCD, first framebuffer for 3D left
+ FramebufferTopLeft2 = 0x1EF0046C, // Main LCD, second framebuffer for 3D left
+ FramebufferTopRight1 = 0x1EF00494, // Main LCD, first framebuffer for 3D right
+ FramebufferTopRight2 = 0x1EF00498, // Main LCD, second framebuffer for 3D right
+ FramebufferSubLeft1 = 0x1EF00568, // Sub LCD, first framebuffer
+ FramebufferSubLeft2 = 0x1EF0056C, // Sub LCD, second framebuffer
+ FramebufferSubRight1 = 0x1EF00594, // Sub LCD, unused first framebuffer
+ FramebufferSubRight2 = 0x1EF00598, // Sub LCD, unused second framebuffer
+
+ CommandListSize = 0x1EF018E0,
+ CommandListAddress = 0x1EF018E8,
+ ProcessCommandList = 0x1EF018F0,
+ };
+
u32 framebuffer_top_left_1;
u32 framebuffer_top_left_2;
u32 framebuffer_top_right_1;
@@ -17,6 +32,10 @@ struct Registers {
u32 framebuffer_sub_left_2;
u32 framebuffer_sub_right_1;
u32 framebuffer_sub_right_2;
+
+ u32 command_list_size;
+ u32 command_list_address;
+ u32 command_processing_enabled;
};
extern Registers g_regs;
@@ -24,7 +43,7 @@ extern Registers g_regs;
enum {
TOP_ASPECT_X = 0x5,
TOP_ASPECT_Y = 0x3,
-
+
TOP_HEIGHT = 240,
TOP_WIDTH = 400,
BOTTOM_WIDTH = 320,
@@ -48,21 +67,10 @@ enum {
PADDR_VRAM_SUB_FRAME2 = 0x18249CF0,
};
-enum {
- REG_FRAMEBUFFER_TOP_LEFT_1 = 0x1EF00468, // Main LCD, first framebuffer for 3D left
- REG_FRAMEBUFFER_TOP_LEFT_2 = 0x1EF0046C, // Main LCD, second framebuffer for 3D left
- REG_FRAMEBUFFER_TOP_RIGHT_1 = 0x1EF00494, // Main LCD, first framebuffer for 3D right
- REG_FRAMEBUFFER_TOP_RIGHT_2 = 0x1EF00498, // Main LCD, second framebuffer for 3D right
- REG_FRAMEBUFFER_SUB_LEFT_1 = 0x1EF00568, // Sub LCD, first framebuffer
- REG_FRAMEBUFFER_SUB_LEFT_2 = 0x1EF0056C, // Sub LCD, second framebuffer
- REG_FRAMEBUFFER_SUB_RIGHT_1 = 0x1EF00594, // Sub LCD, unused first framebuffer
- REG_FRAMEBUFFER_SUB_RIGHT_2 = 0x1EF00598, // Sub LCD, unused second framebuffer
-};
-
/// Framebuffer location
enum FramebufferLocation {
FRAMEBUFFER_LOCATION_UNKNOWN, ///< Framebuffer location is unknown
- FRAMEBUFFER_LOCATION_FCRAM, ///< Framebuffer is in the GSP heap
+ FRAMEBUFFER_LOCATION_FCRAM, ///< Framebuffer is in the GSP heap
FRAMEBUFFER_LOCATION_VRAM, ///< Framebuffer is in VRAM
};
diff --git a/src/core/hw/hw.cpp b/src/core/hw/hw.cpp
index 85669ae7f..ed70486e6 100644
--- a/src/core/hw/hw.cpp
+++ b/src/core/hw/hw.cpp
@@ -6,7 +6,7 @@
#include "common/log.h"
#include "core/hw/hw.h"
-#include "core/hw/lcd.h"
+#include "core/hw/gpu.h"
#include "core/hw/ndma.h"
namespace HW {
@@ -34,7 +34,7 @@ enum {
VADDR_CDMA = 0xFFFDA000, // CoreLink DMA-330? Info
VADDR_DSP_2 = 0x1ED03000,
VADDR_HASH_2 = 0x1EE01000,
- VADDR_LCD = 0x1EF00000,
+ VADDR_GPU = 0x1EF00000,
};
template
@@ -46,8 +46,8 @@ inline void Read(T &var, const u32 addr) {
// NDMA::Read(var, addr);
// break;
- case VADDR_LCD:
- LCD::Read(var, addr);
+ case VADDR_GPU:
+ GPU::Read(var, addr);
break;
default:
@@ -64,8 +64,8 @@ inline void Write(u32 addr, const T data) {
// NDMA::Write(addr, data);
// break;
- case VADDR_LCD:
- LCD::Write(addr, data);
+ case VADDR_GPU:
+ GPU::Write(addr, data);
break;
default:
@@ -87,13 +87,13 @@ template void Write(u32 addr, const u8 data);
/// Update hardware
void Update() {
- LCD::Update();
+ GPU::Update();
NDMA::Update();
}
/// Initialize hardware
void Init() {
- LCD::Init();
+ GPU::Init();
NDMA::Init();
NOTICE_LOG(HW, "initialized OK");
}
diff --git a/src/core/hw/ndma.cpp b/src/core/hw/ndma.cpp
index 52e459ebd..f6aa72d16 100644
--- a/src/core/hw/ndma.cpp
+++ b/src/core/hw/ndma.cpp
@@ -37,12 +37,12 @@ void Update() {
/// Initialize hardware
void Init() {
- NOTICE_LOG(LCD, "initialized OK");
+ NOTICE_LOG(GPU, "initialized OK");
}
/// Shutdown hardware
void Shutdown() {
- NOTICE_LOG(LCD, "shutdown OK");
+ NOTICE_LOG(GPU, "shutdown OK");
}
} // namespace
diff --git a/src/video_core/gpu_debugger.h b/src/video_core/gpu_debugger.h
new file mode 100644
index 000000000..6a1e04244
--- /dev/null
+++ b/src/video_core/gpu_debugger.h
@@ -0,0 +1,157 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include
+#include
+#include
+
+#include "common/log.h"
+
+#include "core/hle/service/gsp.h"
+#include "pica.h"
+
+class GraphicsDebugger
+{
+public:
+ // A few utility structs used to expose data
+ // A vector of commands represented by their raw byte sequence
+ struct PicaCommand : public std::vector
+ {
+ Pica::CommandHeader& GetHeader()
+ {
+ u32& val = at(1);
+ return *(Pica::CommandHeader*)&val;
+ }
+ };
+
+ typedef std::vector PicaCommandList;
+
+ // Base class for all objects which need to be notified about GPU events
+ class DebuggerObserver
+ {
+ public:
+ DebuggerObserver() : observed(nullptr) { }
+
+ virtual ~DebuggerObserver()
+ {
+ if (observed)
+ observed->UnregisterObserver(this);
+ }
+
+ /**
+ * Called when a GX command has been processed and is ready for being
+ * read via GraphicsDebugger::ReadGXCommandHistory.
+ * @param total_command_count Total number of commands in the GX history
+ * @note All methods in this class are called from the GSP thread
+ */
+ virtual void GXCommandProcessed(int total_command_count)
+ {
+ const GSP_GPU::GXCommand& cmd = observed->ReadGXCommandHistory(total_command_count-1);
+ ERROR_LOG(GSP, "Received command: id=%x", cmd.id);
+ }
+
+ /**
+ * @param lst command list which triggered this call
+ * @param is_new true if the command list was called for the first time
+ * @todo figure out how to make sure called functions don't keep references around beyond their life time
+ */
+ virtual void OnCommandListCalled(const PicaCommandList& lst, bool is_new)
+ {
+ ERROR_LOG(GSP, "Command list called: %d", (int)is_new);
+ }
+
+ protected:
+ GraphicsDebugger* GetDebugger()
+ {
+ return observed;
+ }
+
+ private:
+ GraphicsDebugger* observed;
+ bool in_destruction;
+
+ friend class GraphicsDebugger;
+ };
+
+ void GXCommandProcessed(u8* command_data)
+ {
+ gx_command_history.push_back(GSP_GPU::GXCommand());
+ GSP_GPU::GXCommand& cmd = gx_command_history[gx_command_history.size()-1];
+
+ const int cmd_length = sizeof(GSP_GPU::GXCommand);
+ memcpy(cmd.data, command_data, cmd_length);
+
+ ForEachObserver([this](DebuggerObserver* observer) {
+ observer->GXCommandProcessed(this->gx_command_history.size());
+ } );
+ }
+
+ void CommandListCalled(u32 address, u32* command_list, u32 size_in_words)
+ {
+ PicaCommandList cmdlist;
+ for (u32* parse_pointer = command_list; parse_pointer < command_list + size_in_words;)
+ {
+ const Pica::CommandHeader header = static_cast(parse_pointer[1]);
+
+ cmdlist.push_back(PicaCommand());
+ auto& cmd = cmdlist.back();
+
+ size_t size = 2 + header.extra_data_length;
+ size = (size + 1) / 2 * 2; // align to 8 bytes
+ cmd.reserve(size);
+ std::copy(parse_pointer, parse_pointer + size, std::back_inserter(cmd));
+
+ parse_pointer += size;
+ }
+
+ auto obj = std::pair(address, cmdlist);
+ auto it = std::find(command_lists.begin(), command_lists.end(), obj);
+ bool is_new = (it == command_lists.end());
+ if (is_new)
+ command_lists.push_back(obj);
+
+ ForEachObserver([&](DebuggerObserver* observer) {
+ observer->OnCommandListCalled(obj.second, is_new);
+ } );
+ }
+
+ const GSP_GPU::GXCommand& ReadGXCommandHistory(int index) const
+ {
+ // TODO: Is this thread-safe?
+ return gx_command_history[index];
+ }
+
+ const std::vector>& GetCommandLists() const
+ {
+ return command_lists;
+ }
+
+ void RegisterObserver(DebuggerObserver* observer)
+ {
+ // TODO: Check for duplicates
+ observers.push_back(observer);
+ observer->observed = this;
+ }
+
+ void UnregisterObserver(DebuggerObserver* observer)
+ {
+ std::remove(observers.begin(), observers.end(), observer);
+ observer->observed = nullptr;
+ }
+
+private:
+ void ForEachObserver(std::function func)
+ {
+ std::for_each(observers.begin(),observers.end(), func);
+ }
+
+ std::vector observers;
+
+ std::vector gx_command_history;
+
+ // vector of pairs of command lists and their storage address
+ std::vector> command_lists;
+};
diff --git a/src/video_core/pica.h b/src/video_core/pica.h
new file mode 100644
index 000000000..f0fa3aba9
--- /dev/null
+++ b/src/video_core/pica.h
@@ -0,0 +1,130 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include
+#include
+
+
-
+
@@ -128,4 +130,4 @@
-
\ No newline at end of file
+
diff --git a/src/video_core/video_core.vcxproj.filters b/src/video_core/video_core.vcxproj.filters
index 4eb2ef0a4..b89ac1ac4 100644
--- a/src/video_core/video_core.vcxproj.filters
+++ b/src/video_core/video_core.vcxproj.filters
@@ -16,6 +16,8 @@
renderer_opengl
+
+
@@ -23,4 +25,4 @@
-
\ No newline at end of file
+