Hook up the counter capture and result display.

qrenderdoc/Code/CaptureContext.cpp

@@ -735,14 +735,14 @@ IDebugMessageView *CaptureContext::GetDebugMessageView()
 
 IPerformanceCounterViewer *CaptureContext::GetPerformanceCounterViewer()
 {
-  if(m_PerformanecCounterViewer)
-    return m_PerformanecCounterViewer;
+  if(m_PerformanceCounterViewer)
+    return m_PerformanceCounterViewer;
 
-  m_PerformanecCounterViewer = new PerformanceCounterViewer(*this, m_MainWindow);
-  m_PerformanecCounterViewer->setObjectName(lit("performanceCounterViewer"));
-  setupDockWindow(m_PerformanecCounterViewer);
+  m_PerformanceCounterViewer = new PerformanceCounterViewer(*this, m_MainWindow);
+  m_PerformanceCounterViewer->setObjectName(lit("performanceCounterViewer"));
+  setupDockWindow(m_PerformanceCounterViewer);
 
-  return m_PerformanecCounterViewer;
+  return m_PerformanceCounterViewer;
 }
 
 IStatisticsViewer *CaptureContext::GetStatisticsViewer()
@@ -963,6 +963,8 @@ void CaptureContext::BuiltinWindowClosed(QWidget *window)
     m_TimelineBar = NULL;
   else if(m_PythonShell && m_PythonShell->Widget() == window)
     m_PythonShell = NULL;
+  else if(m_PerformanceCounterViewer && m_PerformanceCounterViewer->Widget() == window)
+    m_PerformanceCounterViewer = NULL;
   else
     qCritical() << "Unrecognised window being closed: " << window;
 }

qrenderdoc/Code/CaptureContext.h

@@ -146,7 +146,7 @@ public:
   bool HasMeshPreview() override { return m_MeshPreview != NULL; }
   bool HasCaptureDialog() override { return m_CaptureDialog != NULL; }
   bool HasDebugMessageView() override { return m_DebugMessageView != NULL; }
-  bool HasPerformanceCounterViewer() override { return m_PerformanecCounterViewer != NULL; }
+  bool HasPerformanceCounterViewer() override { return m_PerformanceCounterViewer != NULL; }
   bool HasStatisticsViewer() override { return m_StatisticsViewer != NULL; }
   bool HasTimelineBar() override { return m_TimelineBar != NULL; }
   bool HasPythonShell() override { return m_PythonShell != NULL; }
@@ -282,7 +282,7 @@ private:
   PipelineStateViewer *m_PipelineViewer = NULL;
   CaptureDialog *m_CaptureDialog = NULL;
   DebugMessageView *m_DebugMessageView = NULL;
-  PerformanceCounterViewer *m_PerformanecCounterViewer = NULL;
+  PerformanceCounterViewer *m_PerformanceCounterViewer = NULL;
   StatisticsViewer *m_StatisticsViewer = NULL;
   TimelineBar *m_TimelineBar = NULL;
   PythonShell *m_PythonShell = NULL;

qrenderdoc/Windows/PerformanceCounterViewer.cpp

@@ -26,6 +26,48 @@
 #include "Windows/Dialogs/PerformanceCounterSelection.h"
 #include "ui_PerformanceCounterViewer.h"
 
+static QString FormatCounterResult(const CounterResult &result, const CounterDescription &description)
+{
+  QString returnValue;
+
+  switch(description.resultType)
+  {
+    case CompType::Float: returnValue += QString::number(result.value.f); break;
+
+    case CompType::Double: returnValue += QString::number(result.value.d); break;
+
+    case CompType::UInt:
+      if(description.resultByteWidth == 8)
+      {
+        returnValue += QString::number(result.value.u64);
+      }
+      else
+      {
+        returnValue += QString::number(result.value.u32);
+      }
+
+    default:
+      // assert (false)
+      break;
+  }
+
+  switch(description.unit)
+  {
+    case CounterUnit::Bytes: returnValue += QLatin1String{" bytes"}; break;
+
+    case CounterUnit::Cycles: returnValue += QLatin1String{" cycles"}; break;
+
+    case CounterUnit::Percentage: returnValue += QLatin1String{" %"}; break;
+
+    case CounterUnit::Seconds: returnValue += QLatin1String{" s"}; break;
+
+    case CounterUnit::Absolute:
+    case CounterUnit::Ratio: break;
+  }
+
+  return returnValue;
+}
+
 PerformanceCounterViewer::PerformanceCounterViewer(ICaptureContext &ctx, QWidget *parent)
     : QFrame(parent), ui(new Ui::PerformanceCounterViewer), m_Ctx(ctx)
 {
@@ -39,17 +81,66 @@ PerformanceCounterViewer::PerformanceCounterViewer(ICaptureContext &ctx, QWidget
     {
       const QList<uint32_t> selectedCounters = pcs.GetSelectedCounters();
 
-      m_Ctx.Replay().AsyncInvoke([=](IReplayController *controller) -> void {
+      bool done = false;
+      m_Ctx.Replay().AsyncInvoke([=, &done](IReplayController *controller) -> void {
         rdctype::array<GPUCounter> counters;
         counters.create(selectedCounters.size());
 
+        QMap<GPUCounter, CounterDescription> counterDescriptions;
+
         for(int i = 0; i < selectedCounters.size(); ++i)
         {
           counters[i] = (GPUCounter)selectedCounters[i];
+          counterDescriptions.insert(counters[i], controller->DescribeCounter(counters[i]));
         }
 
-        controller->FetchCounters(counters);
+        QMap<GPUCounter, int> counterIndex;
+        for(int i = 0; i < selectedCounters.size(); ++i)
+        {
+          counterIndex.insert((GPUCounter)selectedCounters[i], i);
+        }
+
+        const auto results = controller->FetchCounters(counters);
+
+        GUIInvoke::call([this, results, counterDescriptions, counterIndex]() -> void {
+          ui->counterResults->clear();
+
+          QStringList headers;
+          headers << QLatin1String{"EID"};
+          for(const auto &cd : counterDescriptions)
+          {
+            headers << cd.name;
+          }
+
+          QMap<uint32_t, int> eventIdToRow;
+          for(const auto &result : results)
+          {
+            if(eventIdToRow.contains(result.eventID))
+              continue;
+            eventIdToRow[result.eventID] = eventIdToRow.size();
+          }
+
+          ui->counterResults->setColumnCount(headers.size());
+          ui->counterResults->setHorizontalHeaderLabels(headers);
+          ui->counterResults->setRowCount(eventIdToRow.size());
+          ui->counterResults->verticalHeader()->hide();
+
+          for(int i = 0; i < (int)results.size(); ++i)
+          {
+            int row = eventIdToRow[results[i].eventID];
+            ui->counterResults->setItem(row, 0,
+                                        new QTableWidgetItem(QString::number(results[i].eventID)));
+            ui->counterResults->setItem(row, counterIndex[results[i].counterID] + 1,
+                                        new QTableWidgetItem(FormatCounterResult(
+                                            results[i], counterDescriptions[results[i].counterID])));
+          }
+        });
+
+        done = true;
       });
+
+      ShowProgressDialog(this, QLatin1String("Capturing counters"),
+                         [&done]() -> bool { return done; });
     }
   });
 }