Add basic vertex data viewer (with the same flaws as the old one)

GPU/Common/DrawEngineCommon.cpp

@@ -691,6 +691,9 @@ bool DrawEngineCommon::GetCurrentSimpleVertices(int count, std::vector<GPUDebugV
 	Matrix4ByMatrix4(worldview, world, view);
 	Matrix4ByMatrix4(worldviewproj, worldview, gstate.projMatrix);
 
+	// This transforms the vertices.
+	// NOTE: We really should just run the full software transform?
+
 	vertices.resize(indexUpperBound + 1);
 	uint32_t vertType = gstate.vertType;
 	for (int i = indexLowerBound; i <= indexUpperBound; ++i) {

GPU/Common/GPUDebugInterface.h

@@ -200,7 +200,7 @@ class GPUDebugInterface {
 public:
 	virtual ~GPUDebugInterface() {}
 	virtual bool GetCurrentDisplayList(DisplayList &list) = 0;
-	virtual bool GetCurrentCommand(u32 *cmd) = 0;
+	virtual int GetCurrentPrimCount() = 0;
 	virtual std::vector<DisplayList> ActiveDisplayLists() = 0;
 	virtual void ResetListPC(int listID, u32 pc) = 0;
 	virtual void ResetListStall(int listID, u32 stall) = 0;

GPU/Debugger/State.h

@@ -59,11 +59,11 @@ enum VertexListCols {
 	VERTEXLIST_COL_NX,
 	VERTEXLIST_COL_NY,
 	VERTEXLIST_COL_NZ,
+	VERTEXLIST_COL_COUNT,
 };
 
 class GPUDebugInterface;
 
-
 struct TabStateRow {
 	std::string_view title;
 	uint8_t cmd;

GPU/GPUCommon.cpp

@@ -1581,13 +1581,21 @@ bool GPUCommon::GetCurrentDisplayList(DisplayList &list) {
 	return true;
 }
 
-bool GPUCommon::GetCurrentCommand(u32 *cmd) {
+int GPUCommon::GetCurrentPrimCount() {
 	DisplayList list;
 	if (GetCurrentDisplayList(list)) {
-		*cmd = Memory::Read_U32(list.pc);
+		u32 cmd = Memory::Read_U32(list.pc);
+		if ((cmd >> 24) == GE_CMD_PRIM || (cmd >> 24) == GE_CMD_BOUNDINGBOX) {
+			return cmd & 0xFFFF;
+		} else if ((cmd >> 24) == GE_CMD_BEZIER || (cmd >> 24) == GE_CMD_SPLINE) {
+			u32 u = (cmd & 0x00FF) >> 0;
+			u32 v = (cmd & 0xFF00) >> 8;
+			return u * v;
+		}
 		return true;
 	} else {
-		return false;
+		// Current prim value.
+		return gstate.cmdmem[GE_CMD_PRIM] & 0xFFFF;
 	}
 }
 

GPU/GPUCommon.h

@@ -328,7 +328,7 @@ public:
 	// From GPUDebugInterface.
 	bool GetCurrentDisplayList(DisplayList &list) override;
 	bool GetCurrentSimpleVertices(int count, std::vector<GPUDebugVertex> &vertices, std::vector<u16> &indices) override;
-	bool GetCurrentCommand(u32 *cmd) override;
+	int GetCurrentPrimCount() override;
 	FramebufferManagerCommon *GetFramebufferManagerCommon() override {
 		return nullptr;
 	}

UI/ImDebugger/ImGe.cpp

@@ -5,6 +5,7 @@
 #include "GPU/Common/GPUDebugInterface.h"
 #include "GPU/Common/FramebufferManagerCommon.h"
 #include "GPU/Common/TextureCacheCommon.h"
+#include "GPU/Common/VertexDecoderCommon.h"
 
 #include "Core/HLE/sceDisplay.h"
 #include "Core/HW/Display.h"
@@ -96,7 +97,6 @@ void DrawGeStateWindow(ImConfig &cfg, GPUDebugInterface *gpuDebug) {
 		ImGui::End();
 		return;
 	}
-
 	if (ImGui::BeginTabBar("GeRegs", ImGuiTabBarFlags_None)) {
 		auto buildStateTab = [&](const char *tabName, const TabStateRow *rows, size_t numRows) {
 			if (ImGui::BeginTabItem(tabName)) {
@@ -135,6 +135,94 @@ void DrawGeStateWindow(ImConfig &cfg, GPUDebugInterface *gpuDebug) {
 		buildStateTab("Texture", g_stateTextureRows, g_stateTextureRowsSize);
 		buildStateTab("Settings", g_stateSettingsRows, g_stateSettingsRowsSize);
 
+		// Do a vertex tab (maybe later a separate window)
+		if (ImGui::BeginTabItem("Vertices")) {
+			const ImGuiTableFlags tableFlags =
+				ImGuiTableFlags_Resizable | ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersV | ImGuiTableFlags_NoBordersInBody | ImGuiTableFlags_ScrollY;
+			if (ImGui::BeginTabBar("vertexmode", ImGuiTabBarFlags_None)) {
+				auto state = gpuDebug->GetGState();
+				char fmtTemp[256];
+				FormatStateRow(gpuDebug, fmtTemp, sizeof(fmtTemp), CMD_FMT_VERTEXTYPE, state.vertType, true, false, false);
+				ImGui::TextUnformatted(fmtTemp);
+				// Let's see if it's fast enough to just do all this each frame.
+				int rowCount_ = gpuDebug->GetCurrentPrimCount();
+				std::vector<GPUDebugVertex> vertices;
+				std::vector<u16> indices;
+				if (!gpuDebug->GetCurrentSimpleVertices(rowCount_, vertices, indices)) {
+					rowCount_ = 0;
+				}
+				VertexDecoderOptions options{};
+				// TODO: Maybe an option?
+				options.applySkinInDecode = true;
+
+				auto buildVertexTable = [&](bool raw) {
+					// Ignore indices for now.
+					if (ImGui::BeginTable("rawverts", VERTEXLIST_COL_COUNT + 1, tableFlags)) {
+						static VertexDecoder decoder;
+						decoder.SetVertexType(state.vertType, options);
+
+						static const char *colNames[] = {
+							"Index",
+							"X",
+							"Y",
+							"Z",
+							"U",
+							"V",
+							"Color",
+							"NX",
+							"NY",
+							"NZ",
+						};
+						for (int i = 0; i < ARRAY_SIZE(colNames); i++) {
+							ImGui::TableSetupColumn(colNames[i], ImGuiTableColumnFlags_WidthFixed, 0.0f, i);
+						}
+						ImGui::TableSetupScrollFreeze(0, 1); // Make header row always visible
+						ImGui::TableHeadersRow();
+
+						ImGuiListClipper clipper;
+						_dbg_assert_(rowCount_ >= 0);
+						clipper.Begin(rowCount_);
+						while (clipper.Step()) {
+							for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++) {
+								int index = indices.empty() ? i : indices[i];
+								ImGui::PushID(i);
+
+								ImGui::TableNextRow();
+								ImGui::TableNextColumn();
+								ImGui::Text("%d", index);
+								for (int column = 0; column < VERTEXLIST_COL_COUNT; column++) {
+									ImGui::TableNextColumn();
+									char temp[36];
+									if (raw) {
+										FormatVertColRaw(&decoder, temp, sizeof(temp), index, column);
+									} else {
+										FormatVertCol(temp, sizeof(temp), vertices[index], column);
+									}
+									ImGui::TextUnformatted(temp);
+								}
+								ImGui::PopID();
+							}
+						}
+						clipper.End();
+
+						ImGui::EndTable();
+					}
+				};
+
+				if (ImGui::BeginTabItem("Raw")) {
+					buildVertexTable(true);
+					ImGui::EndTabItem();
+				}
+				if (ImGui::BeginTabItem("Transformed")) {
+					buildVertexTable(false);
+					ImGui::EndTabItem();
+				}
+				// TODO: Let's not include columns for which we have no data.
+				ImGui::EndTabBar();
+			}
+			ImGui::EndTabItem();
+		}
+
 		ImGui::EndTabBar();
 	}
 	ImGui::End();

Windows/GEDebugger/TabVertices.cpp

@@ -168,19 +168,8 @@ int CtrlVertexList::GetRowCount() {
 
 	// TODO: Maybe there are smarter ways?  Also, is this the best place to recalc?
 	auto state = gpuDebug->GetGState();
-	rowCount_ = state.prim & 0xFFFF;
 
-	// Override if we're on a prim command.
-	u32 cmd;
-	if (gpuDebug->GetCurrentCommand(&cmd)) {
-		if ((cmd >> 24) == GE_CMD_PRIM || (cmd >> 24) == GE_CMD_BOUNDINGBOX) {
-			rowCount_ = cmd & 0xFFFF;
-		} else if ((cmd >> 24) == GE_CMD_BEZIER || (cmd >> 24) == GE_CMD_SPLINE) {
-			u32 u = (cmd & 0x00FF) >> 0;
-			u32 v = (cmd & 0xFF00) >> 8;
-			rowCount_ = u * v;
-		}
-	}
+	int rowCount_ = gpuDebug->GetCurrentPrimCount();
 	if (!gpuDebug->GetCurrentSimpleVertices(rowCount_, vertices, indices)) {
 		rowCount_ = 0;
 	}