Removes mutable member

Author: GrantComm

ui/dive_tree_view.cpp

@@ -53,22 +53,101 @@ void DiveFilterModel::applyNewFilterMode(FilterMode new_mode)
     if (m_filter_mode == new_mode)
         return;
 
-    // Clear the collections of draw call indices
-    m_pm4_draw_call_indices.clear();
-
     beginResetModel();
     m_filter_mode = new_mode;
+
+    // Only collect the draw call indices if gfxr and pm4 data are present.
+    if (!m_gfxr_draw_call_indices.empty())
+    {
+        // Clear the vector of pm4 draw call indices.
+        m_pm4_draw_call_indices.clear();
+        // Recollect pm4 draw call indices when new filter is applied.
+        CollectPm4DrawCallIndices(QModelIndex());
+    }
     // invalidateFilter() doesn't invalidate all nodes
     // begin/endResetModel() will cause a full re-evaluation and rebuild of the proxy's internal
     // mapping.
     endResetModel();
 }
 
+bool DiveFilterModel::IncludeIndex(uint64_t node_index) const
+{
+    Dive::CommandHierarchy::FilterListType
+    filter_list_type = Dive::CommandHierarchy::kFilterListTypeCount;
+
+    switch (m_filter_mode)
+    {
+    case kBinningPassOnly:
+        filter_list_type = Dive::CommandHierarchy::kBinningPassOnly;
+        break;
+    case kFirstTilePassOnly:
+        filter_list_type = Dive::CommandHierarchy::kFirstTilePassOnly;
+        break;
+    case kBinningAndFirstTilePass:
+        filter_list_type = Dive::CommandHierarchy::kBinningAndFirstTilePass;
+        break;
+    default:
+        DIVE_ASSERT(false);
+        break;
+    }
+
+    const auto &filter_exclude_indices = m_command_hierarchy.GetFilterExcludeIndices(
+    filter_list_type);
+
+    // If the node index is in the exclude list, we exclude the index.
+    if (filter_exclude_indices.find(node_index) != filter_exclude_indices.end())
+    {
+        return false;
+    }
+
+    return true;
+}
+
 void DiveFilterModel::SetMode(FilterMode filter_mode)
 {
     applyNewFilterMode(filter_mode);
 }
 
+void DiveFilterModel::CollectPm4DrawCallIndices(const QModelIndex &parent_index)
+{
+    if (!parent_index.isValid())
+    {
+        m_pm4_draw_call_indices.clear();
+    }
+    else
+    {
+        // Check if the current parent node is filtered out.
+        uint64_t parent_node_index = (uint64_t)parent_index.internalPointer();
+
+        if (!IncludeIndex(parent_node_index))
+        {
+            return;
+        }
+    }
+
+    int row_count = sourceModel()->rowCount(parent_index);
+    for (int row = 0; row < row_count; ++row)
+    {
+        QModelIndex index = sourceModel()->index(row, 0, parent_index);
+        if (index.isValid())
+        {
+            uint64_t       node_index = (uint64_t)index.internalPointer();
+            Dive::NodeType node_type = m_command_hierarchy.GetNodeType(node_index);
+
+            if (node_type == Dive::NodeType::kDrawDispatchNode)
+            {
+                m_pm4_draw_call_indices.push_back(node_index);
+            }
+
+            // Only recurse into children if the current node is not a Vulkan submit node.
+            if (node_type != Dive::NodeType::kGfxrVulkanSubmitNode)
+            {
+                CollectPm4DrawCallIndices(index);
+            }
+        }
+    }
+}
+
 void DiveFilterModel::CollectGfxrDrawCallIndices(const QModelIndex &parent_index)
 {
     if (!parent_index.isValid())
@@ -101,6 +180,12 @@ void DiveFilterModel::CollectGfxrDrawCallIndices(const QModelIndex &parent_index
     }
 }
 
+void DiveFilterModel::ClearDrawCallIndices()
+{
+    m_pm4_draw_call_indices.clear();
+    m_gfxr_draw_call_indices.clear();
+}
+
 bool DiveFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
 {
     QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
@@ -123,37 +208,7 @@ bool DiveFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceP
         return true;
     }
 
-    Dive::CommandHierarchy::FilterListType
-    filter_list_type = Dive::CommandHierarchy::kFilterListTypeCount;
-    switch (m_filter_mode)
-    {
-    case kBinningPassOnly:
-        filter_list_type = Dive::CommandHierarchy::kBinningPassOnly;
-        break;
-    case kFirstTilePassOnly:
-        filter_list_type = Dive::CommandHierarchy::kFirstTilePassOnly;
-        break;
-    case kBinningAndFirstTilePass:
-        filter_list_type = Dive::CommandHierarchy::kBinningAndFirstTilePass;
-        break;
-    default:
-        DIVE_ASSERT(false);
-        break;
-    }
-    const auto &filter_exclude_indices = m_command_hierarchy.GetFilterExcludeIndices(
-    filter_list_type);
-    // If the node index is in the exclude list, we hide the row
-    if (filter_exclude_indices.find(node_index) != filter_exclude_indices.end())
-    {
-        return false;
-    }
-
-    if (current_node_type == Dive::NodeType::kDrawDispatchNode)
-    {
-        m_pm4_draw_call_indices.push_back(node_index);
-    }
-
-    return true;
+    return IncludeIndex(node_index);
 }
 
 // =================================================================================================

ui/dive_tree_view.h

@@ -52,9 +52,11 @@ class DiveFilterModel : public QSortFilterProxyModel
     };
 
     DiveFilterModel(const Dive::CommandHierarchy &command_hierarchy, QObject *parent = nullptr);
+    bool IncludeIndex(uint64_t node_index) const;
     void SetMode(FilterMode filter_mode);
+    void CollectPm4DrawCallIndices(const QModelIndex &parent_index = QModelIndex());
     void CollectGfxrDrawCallIndices(const QModelIndex &parent_index = QModelIndex());
-    void AddPm4DrawCallIndex(uint64_t index) const;
+    void ClearDrawCallIndices();
     const std::vector<uint64_t> &GetPm4DrawCallIndices() { return m_pm4_draw_call_indices; }
     const std::vector<uint64_t> &GetGfxrDrawCallIndices() { return m_gfxr_draw_call_indices; }
 public slots:

ui/main_window.cpp

@@ -904,6 +904,9 @@ bool MainWindow::LoadFile(const std::string &file_name, bool is_temp_file)
     // Disconnect the signals for all of the possible tabs.
     DisconnectAllTabs();
 
+    // Clear vectors of draw call indices as they are only used for a correlated view.
+    m_filter_model->ClearDrawCallIndices();
+
     if (m_gfxr_capture_loaded)
     {
         file_loaded = LoadGfxrFile(file_name);