Moved loading code into separate functions based on source file type

Moved table view code into its own class that will handle modifications to the document

Signed-off-by: Guthrie Adams <[email protected]>

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Document/ShaderManagementConsoleDocument.cpp

@@ -9,8 +9,10 @@
 #include <AssetDatabase/AssetDatabaseConnection.h>
 #include <Atom/RPI.Edit/Common/AssetUtils.h>
 #include <Atom/RPI.Edit/Common/JsonUtils.h>
+#include <Atom/RPI.Edit/Material/MaterialTypeSourceData.h>
 #include <Atom/RPI.Public/Material/Material.h>
 #include <Atom/RPI.Reflect/Asset/AssetUtils.h>
+#include <Atom/RPI.Reflect/Material/MaterialAsset.h>
 #include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
 #include <AzCore/Utils/Utils.h>
 #include <AzFramework/StringFunc/StringFunc.h>
@@ -31,9 +33,10 @@ namespace ShaderManagementConsole
         ShaderManagementConsoleDocumentRequestBus::Handler::BusDisconnect();
     }
 
-    void ShaderManagementConsoleDocument::SetShaderVariantListSourceData(const AZ::RPI::ShaderVariantListSourceData& sourceData)
+    void ShaderManagementConsoleDocument::SetShaderVariantListSourceData(
+        const AZ::RPI::ShaderVariantListSourceData& shaderVariantListSourceData)
     {
-        m_shaderVariantListSourceData = sourceData;
+        m_shaderVariantListSourceData = shaderVariantListSourceData;
         AZStd::string shaderPath = m_shaderVariantListSourceData.m_shaderFilePath;
         AzFramework::StringFunc::Path::ReplaceExtension(shaderPath, AZ::RPI::ShaderAsset::Extension);
 
@@ -110,94 +113,14 @@ namespace ShaderManagementConsole
             return false;
         }
 
-        if (AzFramework::StringFunc::Path::IsExtension(m_absolutePath.c_str(), AZ::RPI::ShaderVariantListSourceData::Extension))
+        if (AzFramework::StringFunc::Path::IsExtension(m_absolutePath.c_str(), AZ::RPI::ShaderSourceData::Extension))
         {
-            // Load the shader config data and create a shader config asset from it
-            AZ::RPI::ShaderVariantListSourceData sourceData;
-            if (!AZ::RPI::JsonUtils::LoadObjectFromFile(m_absolutePath, sourceData))
-            {
-                AZ_Error(
-                    "ShaderManagementConsoleDocument", false, "Failed loading shader variant list data: '%s.'", m_absolutePath.c_str());
-                return OpenFailed();
-            }
-
-            SetShaderVariantListSourceData(sourceData);
-            return IsOpen() ? OpenSucceeded() : OpenFailed();
+            return LoadShaderSourceData();
         }
 
-        if (AzFramework::StringFunc::Path::IsExtension(m_absolutePath.c_str(), AZ::RPI::ShaderSourceData::Extension))
+        if (AzFramework::StringFunc::Path::IsExtension(m_absolutePath.c_str(), AZ::RPI::ShaderVariantListSourceData::Extension))
         {
-            // Get info such as relative path of the file and asset id
-            bool result = false;
-            AZ::Data::AssetInfo shaderAssetInfo;
-            AZStd::string watchFolder;
-            AzToolsFramework::AssetSystemRequestBus::BroadcastResult(
-                result, &AzToolsFramework::AssetSystem::AssetSystemRequest::GetSourceInfoBySourcePath, m_absolutePath.c_str(),
-                shaderAssetInfo, watchFolder);
-
-            if (!result)
-            {
-                AZ_Error(
-                    "ShaderManagementConsoleDocument", false, "Failed to get the asset info for the file: %s.", m_absolutePath.c_str());
-                return OpenFailed();
-            }
-
-            // retrieves a list of all material source files that use the shader. Note that materials inherit from materialtype files, which
-            // are actual files that refer to shader files.
-            const auto& materialAssetIds = FindMaterialAssetsUsingShader(shaderAssetInfo.m_relativePath);
-
-            // This loop collects all uniquely-identified shader items used by the materials based on its shader variant id.
-            AZStd::set<AZ::RPI::ShaderVariantId> shaderVariantIds;
-            AZStd::vector<AZ::RPI::ShaderOptionGroup> shaderVariantListShaderOptionGroups;
-            for (const auto& materialAssetId : materialAssetIds)
-            {
-                const auto& materialInstanceShaderItems = GetMaterialInstanceShaderItems(materialAssetId);
-                for (const auto& shaderItem : materialInstanceShaderItems)
-                {
-                    const auto& shaderAssetId = shaderItem.GetShaderAsset().GetId();
-                    if (shaderAssetInfo.m_assetId == shaderAssetId)
-                    {
-                        const auto& shaderVariantId = shaderItem.GetShaderVariantId();
-                        if (!shaderVariantId.IsEmpty() && shaderVariantIds.insert(shaderVariantId).second)
-                        {
-                            shaderVariantListShaderOptionGroups.push_back(shaderItem.GetShaderOptionGroup());
-                        }
-                    }
-                }
-            }
-
-            // Generate the shader variant list data by collecting shader option name-value pairs.s
-            AZ::RPI::ShaderVariantListSourceData shaderVariantList;
-            shaderVariantList.m_shaderFilePath = shaderAssetInfo.m_relativePath;
-            int stableId = 1;
-            for (const auto& shaderOptionGroup : shaderVariantListShaderOptionGroups)
-            {
-                AZ::RPI::ShaderVariantListSourceData::VariantInfo variantInfo;
-                variantInfo.m_stableId = stableId;
-
-                const auto& shaderOptionDescriptors = shaderOptionGroup.GetShaderOptionDescriptors();
-                for (const auto& shaderOptionDescriptor : shaderOptionDescriptors)
-                {
-                    const auto& optionName = shaderOptionDescriptor.GetName();
-                    const auto& optionValue = shaderOptionGroup.GetValue(optionName);
-                    if (!optionValue.IsValid())
-                    {
-                        continue;
-                    }
-
-                    const auto& valueName = shaderOptionDescriptor.GetValueName(optionValue);
-                    variantInfo.m_options[optionName.GetStringView()] = valueName.GetStringView();
-                }
-
-                if (!variantInfo.m_options.empty())
-                {
-                    shaderVariantList.m_shaderVariants.push_back(variantInfo);
-                    stableId++;
-                }
-            }
-
-            SetShaderVariantListSourceData(shaderVariantList);
-            return IsOpen() ? OpenSucceeded() : OpenFailed();
+            return LoadShaderVariantListSourceData();
         }
 
         AZ_Error("ShaderManagementConsoleDocument", false, "Document extension is not supported: '%s.'", m_absolutePath.c_str());
@@ -276,29 +199,115 @@ namespace ShaderManagementConsole
         return SaveSucceeded();
     }
 
-    AZStd::vector<AZ::Data::AssetId> ShaderManagementConsoleDocument::FindMaterialAssetsUsingShader(const AZStd::string& shaderFilePath)
+    bool ShaderManagementConsoleDocument::LoadShaderSourceData()
     {
-        // Collect the material types referencing the shader
-        AZStd::vector<AZStd::string> materialTypeSources;
+        // Get info such as relative path of the file and asset id
+        bool result = false;
+        AZ::Data::AssetInfo shaderAssetInfo;
+        AZStd::string watchFolder;
+        AzToolsFramework::AssetSystemRequestBus::BroadcastResult(
+            result, &AzToolsFramework::AssetSystem::AssetSystemRequest::GetSourceInfoBySourcePath, m_absolutePath.c_str(), shaderAssetInfo,
+            watchFolder);
+
+        if (!result)
+        {
+            AZ_Error("ShaderManagementConsoleDocument", false, "Failed to get the asset info for the file: %s.", m_absolutePath.c_str());
+            return OpenFailed();
+        }
 
+        // retrieves a list of all material source files that use the shader. Note that materials inherit from materialtype files, which
+        // are actual files that refer to shader files.
+        const auto& materialAssetIds = FindMaterialAssetsUsingShader(shaderAssetInfo.m_relativePath);
+
+        // This loop collects all uniquely-identified shader items used by the materials based on its shader variant id.
+        AZStd::set<AZ::RPI::ShaderVariantId> shaderVariantIds;
+        AZStd::vector<AZ::RPI::ShaderOptionGroup> shaderVariantListShaderOptionGroups;
+        for (const auto& materialAssetId : materialAssetIds)
+        {
+            const auto& materialInstanceShaderItems = GetMaterialInstanceShaderItems(materialAssetId);
+            for (const auto& shaderItem : materialInstanceShaderItems)
+            {
+                const auto& shaderAssetId = shaderItem.GetShaderAsset().GetId();
+                if (shaderAssetInfo.m_assetId == shaderAssetId)
+                {
+                    const auto& shaderVariantId = shaderItem.GetShaderVariantId();
+                    if (!shaderVariantId.IsEmpty() && shaderVariantIds.insert(shaderVariantId).second)
+                    {
+                        shaderVariantListShaderOptionGroups.push_back(shaderItem.GetShaderOptionGroup());
+                    }
+                }
+            }
+        }
+
+        // Generate the shader variant list data by collecting shader option name-value pairs.s
+        AZ::RPI::ShaderVariantListSourceData shaderVariantListSourceData;
+        shaderVariantListSourceData.m_shaderFilePath = shaderAssetInfo.m_relativePath;
+        int stableId = 1;
+        for (const auto& shaderOptionGroup : shaderVariantListShaderOptionGroups)
+        {
+            AZ::RPI::ShaderVariantListSourceData::VariantInfo variantInfo;
+            variantInfo.m_stableId = stableId;
+
+            const auto& shaderOptionDescriptors = shaderOptionGroup.GetShaderOptionDescriptors();
+            for (const auto& shaderOptionDescriptor : shaderOptionDescriptors)
+            {
+                const auto& optionName = shaderOptionDescriptor.GetName();
+                const auto& optionValue = shaderOptionGroup.GetValue(optionName);
+                if (!optionValue.IsValid())
+                {
+                    continue;
+                }
+
+                const auto& valueName = shaderOptionDescriptor.GetValueName(optionValue);
+                variantInfo.m_options[optionName.GetStringView()] = valueName.GetStringView();
+            }
+
+            if (!variantInfo.m_options.empty())
+            {
+                shaderVariantListSourceData.m_shaderVariants.push_back(variantInfo);
+                stableId++;
+            }
+        }
+
+        SetShaderVariantListSourceData(shaderVariantListSourceData);
+        return IsOpen() ? OpenSucceeded() : OpenFailed();
+    }
+
+    bool ShaderManagementConsoleDocument::LoadShaderVariantListSourceData()
+    {
+        // Load previously generated shader variant list source data 
+        AZ::RPI::ShaderVariantListSourceData shaderVariantListSourceData;
+        if (!AZ::RPI::JsonUtils::LoadObjectFromFile(m_absolutePath, shaderVariantListSourceData))
+        {
+            AZ_Error("ShaderManagementConsoleDocument", false, "Failed loading shader variant list data: '%s.'", m_absolutePath.c_str());
+            return OpenFailed();
+        }
+
+        SetShaderVariantListSourceData(shaderVariantListSourceData);
+        return IsOpen() ? OpenSucceeded() : OpenFailed();
+    }
+
+    AZStd::vector<AZ::Data::AssetId> ShaderManagementConsoleDocument::FindMaterialAssetsUsingShader(const AZStd::string& shaderFilePath)
+    {
         AzToolsFramework::AssetDatabase::AssetDatabaseConnection assetDatabaseConnection;
         assetDatabaseConnection.OpenDatabase();
 
+        // Find all material types that reference shaderFilePath
+        AZStd::vector<AZStd::string> materialTypeSources;
+
         assetDatabaseConnection.QuerySourceDependencyByDependsOnSource(
             shaderFilePath.c_str(), nullptr, AzToolsFramework::AssetDatabase::SourceFileDependencyEntry::DEP_Any,
             [&](AzToolsFramework::AssetDatabase::SourceFileDependencyEntry& sourceFileDependencyEntry)
             {
-                AZStd::string assetExtension;
-                if (AzFramework::StringFunc::Path::GetExtension(sourceFileDependencyEntry.m_source.c_str(), assetExtension, false))
+                if (AzFramework::StringFunc::Path::IsExtension(
+                        sourceFileDependencyEntry.m_source.c_str(), AZ::RPI::MaterialTypeSourceData::Extension))
                 {
-                    if (assetExtension == "materialtype")
-                    {
-                        materialTypeSources.push_back(sourceFileDependencyEntry.m_source);
-                    }
+                    materialTypeSources.push_back(sourceFileDependencyEntry.m_source);
                 }
                 return true;
             });
 
+        // Find all materials that reference any of the material types using this shader 
         AzToolsFramework::AssetDatabase::ProductDatabaseEntryContainer productDependencies;
         for (const auto& materialTypeSource : materialTypeSources)
         {
@@ -313,13 +322,9 @@ namespace ShaderManagementConsole
                 materialTypeSourceAssetInfo.m_assetId.m_guid, materialTypeSourceAssetInfo.m_assetId.m_subId,
                 [&](AzToolsFramework::AssetDatabase::ProductDatabaseEntry& entry)
                 {
-                    AZStd::string assetExtension;
-                    if (AzFramework::StringFunc::Path::GetExtension(entry.m_productName.c_str(), assetExtension, false))
+                    if (AzFramework::StringFunc::Path::IsExtension(entry.m_productName.c_str(), AZ::RPI::MaterialAsset::Extension))
                     {
-                        if (assetExtension == "azmaterial")
-                        {
-                            productDependencies.push_back(entry);
-                        }
+                        productDependencies.push_back(entry);
                     }
                     return true;
                 });
@@ -338,18 +343,20 @@ namespace ShaderManagementConsole
                 },
                 nullptr);
         }
+
         return results;
     }
 
     AZStd::vector<AZ::RPI::ShaderCollection::Item> ShaderManagementConsoleDocument::GetMaterialInstanceShaderItems(
-        const AZ::Data::AssetId& assetId)
+        const AZ::Data::AssetId& materialAssetId)
     {
-        auto materialAsset = AZ::RPI::AssetUtils::LoadAssetById<AZ::RPI::MaterialAsset>(assetId, AZ::RPI::AssetUtils::TraceLevel::Error);
+        auto materialAsset =
+            AZ::RPI::AssetUtils::LoadAssetById<AZ::RPI::MaterialAsset>(materialAssetId, AZ::RPI::AssetUtils::TraceLevel::Error);
         if (!materialAsset.IsReady())
         {
             AZ_Error(
                 "ShaderManagementConsoleDocument", false, "Failed to load material asset from asset id: %s",
-                assetId.ToString<AZStd::string>().c_str());
+                materialAssetId.ToString<AZStd::string>().c_str());
             return AZStd::vector<AZ::RPI::ShaderCollection::Item>();
         }
 

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Document/ShaderManagementConsoleDocument.h

@@ -5,6 +5,7 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #pragma once
 
 #include <Atom/RPI.Edit/Shader/ShaderVariantListSourceData.h>
@@ -42,7 +43,7 @@ namespace ShaderManagementConsole
         bool IsSavable() const override;
 
         // ShaderManagementConsoleDocumentRequestBus::Handler overridfes...
-        void SetShaderVariantListSourceData(const AZ::RPI::ShaderVariantListSourceData& sourceData) override;
+        void SetShaderVariantListSourceData(const AZ::RPI::ShaderVariantListSourceData& shaderVariantListSourceData) override;
         const AZ::RPI::ShaderVariantListSourceData& GetShaderVariantListSourceData() const override;
         size_t GetShaderVariantCount() const override;
         const AZ::RPI::ShaderVariantListSourceData::VariantInfo& GetShaderVariantInfo(size_t index) const override;
@@ -53,9 +54,20 @@ namespace ShaderManagementConsole
         // AtomToolsFramework::AtomToolsDocument overrides...
         void Clear() override;
 
+        // Write shader variant list source data to JSON
         bool SaveSourceData();
+
+        // Read shader variant list source data from JSON and initialize the document
+        bool LoadShaderSourceData();
+
+        // Read shader source data from JSON then find all references to to populate the shader variant list and initialize the document
+        bool LoadShaderVariantListSourceData();
+
+        // Find all material assets that reference material types using shaderFilePath
         AZStd::vector<AZ::Data::AssetId> FindMaterialAssetsUsingShader(const AZStd::string& shaderFilePath);
-        AZStd::vector<AZ::RPI::ShaderCollection::Item> GetMaterialInstanceShaderItems(const AZ::Data::AssetId& assetId);
+
+        // Retrieve all of the shader collection items from a material instance created from materialAssetId
+        AZStd::vector<AZ::RPI::ShaderCollection::Item> GetMaterialInstanceShaderItems(const AZ::Data::AssetId& materialAssetId);
 
         // Source data for shader variant list
         AZ::RPI::ShaderVariantListSourceData m_shaderVariantListSourceData;

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Document/ShaderManagementConsoleDocumentRequestBus.h

@@ -5,6 +5,7 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #pragma once
 
 #include <Atom/RPI.Edit/Shader/ShaderSourceData.h>
@@ -14,9 +15,7 @@
 
 namespace ShaderManagementConsole
 {
-
-    class ShaderManagementConsoleDocumentRequests
-        : public AZ::EBusTraits
+    class ShaderManagementConsoleDocumentRequests : public AZ::EBusTraits
     {
     public:
         static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
@@ -24,7 +23,7 @@ namespace ShaderManagementConsole
         typedef AZ::Uuid BusIdType;
 
         //! Set the shader variant list
-        virtual void SetShaderVariantListSourceData(const AZ::RPI::ShaderVariantListSourceData& sourceData) = 0;
+        virtual void SetShaderVariantListSourceData(const AZ::RPI::ShaderVariantListSourceData& shaderVariantListSourceData) = 0;
 
         //! Get the shader variant list
         virtual const AZ::RPI::ShaderVariantListSourceData& GetShaderVariantListSourceData() const = 0;

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Window/ShaderManagementConsoleTableView.cpp

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/Name/Name.h>
+#include <Document/ShaderManagementConsoleDocumentRequestBus.h>
+#include <Window/ShaderManagementConsoleTableView.h>
+
+#include <QHeaderView>
+
+namespace ShaderManagementConsole
+{
+    ShaderManagementConsoleTableView::ShaderManagementConsoleTableView(const AZ::Uuid& documentId, QWidget* parent)
+        : QTableView(parent)
+        , m_documentId(documentId)
+        , m_model(new QStandardItemModel(this))
+    {
+        setSelectionBehavior(QAbstractItemView::SelectRows);
+        setModel(m_model);
+
+        RebuildTable();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusConnect();
+    }
+
+    ShaderManagementConsoleTableView::~ShaderManagementConsoleTableView()
+    {
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusDisconnect();
+    }
+
+    void ShaderManagementConsoleTableView::OnDocumentOpened(const AZ::Uuid& documentId)
+    {
+        if (m_documentId == documentId)
+        {
+            RebuildTable();
+        }
+    }
+
+    void ShaderManagementConsoleTableView::OnDocumentModified(const AZ::Uuid& documentId)
+    {
+        if (m_documentId == documentId)
+        {
+            RebuildTable();
+        }
+    }
+
+    void ShaderManagementConsole::ShaderManagementConsoleTableView::RebuildTable()
+    {
+        AZStd::unordered_set<AZStd::string> optionNames;
+
+        size_t shaderOptionCount = 0;
+        ShaderManagementConsoleDocumentRequestBus::EventResult(
+            shaderOptionCount, m_documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderOptionCount);
+
+        for (size_t optionIndex = 0; optionIndex < shaderOptionCount; ++optionIndex)
+        {
+            AZ::RPI::ShaderOptionDescriptor shaderOptionDesc;
+            ShaderManagementConsoleDocumentRequestBus::EventResult(
+                shaderOptionDesc, m_documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderOptionDescriptor, optionIndex);
+            optionNames.insert(shaderOptionDesc.GetName().GetCStr());
+        }
+
+        size_t shaderVariantCount = 0;
+        ShaderManagementConsoleDocumentRequestBus::EventResult(
+            shaderVariantCount, m_documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderVariantCount);
+
+        m_model->clear();
+        m_model->setRowCount(static_cast<int>(shaderVariantCount));
+        m_model->setColumnCount(static_cast<int>(optionNames.size()));
+
+        int nameIndex = 0;
+        for (const auto& optionName : optionNames)
+        {
+            m_model->setHeaderData(nameIndex++, Qt::Horizontal, optionName.c_str());
+        }
+
+        for (int variantIndex = 0; variantIndex < shaderVariantCount; ++variantIndex)
+        {
+            AZ::RPI::ShaderVariantListSourceData::VariantInfo shaderVariantInfo;
+            ShaderManagementConsoleDocumentRequestBus::EventResult(
+                shaderVariantInfo, m_documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderVariantInfo, variantIndex);
+
+            m_model->setHeaderData(variantIndex, Qt::Vertical, QString::number(variantIndex));
+
+            for (const auto& shaderOption : shaderVariantInfo.m_options)
+            {
+                AZ::Name optionName{ shaderOption.first };
+                AZ::Name optionValue{ shaderOption.second };
+
+                auto optionIt = optionNames.find(optionName.GetCStr());
+                int optionIndex = static_cast<int>(AZStd::distance(optionNames.begin(), optionIt));
+
+                QStandardItem* item = new QStandardItem(optionValue.GetCStr());
+                m_model->setItem(variantIndex, optionIndex, item);
+            }
+        }
+    }
+} // namespace ShaderManagementConsole
+
+#include <Window/moc_ShaderManagementConsoleTableView.cpp>
+#include "ShaderManagementConsoleTableView.h"

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Window/ShaderManagementConsoleTableView.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#if !defined(Q_MOC_RUN)
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
+
+#include <QStandardItemModel>
+#include <QTableView>
+#endif
+
+namespace ShaderManagementConsole
+{
+    class ShaderManagementConsoleTableView
+        : public QTableView
+        , public AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(ShaderManagementConsoleTableView, AZ::SystemAllocator, 0);
+        ShaderManagementConsoleTableView(const AZ::Uuid& documentId, QWidget* parent = 0);
+        ~ShaderManagementConsoleTableView();
+
+    protected:
+        // AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler overrides...
+        void OnDocumentOpened(const AZ::Uuid& documentId) override;
+        void OnDocumentModified(const AZ::Uuid& documentId) override;
+
+        void RebuildTable();
+
+        AZ::Uuid m_documentId = AZ::Uuid::CreateNull();
+        QStandardItemModel* m_model = {};
+
+    };
+} // namespace ShaderManagementConsole

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Window/ShaderManagementConsoleWindow.cpp

@@ -6,23 +6,19 @@
  *
  */
 
+#include <Atom/RPI.Edit/Shader/ShaderSourceData.h>
+#include <Atom/RPI.Edit/Shader/ShaderVariantListSourceData.h>
+#include <Atom/RPI.Reflect/Shader/ShaderAsset.h>
 #include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
-#include <AtomToolsFramework/Util/Util.h>
-#include <AzCore/Name/Name.h>
 #include <AzCore/Utils/Utils.h>
 #include <AzQtComponents/Components/WindowDecorationWrapper.h>
-#include <Document/ShaderManagementConsoleDocumentRequestBus.h>
+#include <Window/ShaderManagementConsoleTableView.h>
 #include <Window/ShaderManagementConsoleWindow.h>
 
-AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
 #include <QDesktopServices>
 #include <QFileDialog>
-#include <QHeaderView>
-#include <QStandardItemModel>
-#include <QTableView>
 #include <QUrl>
 #include <QWindow>
-AZ_POP_DISABLE_WARNING
 
 namespace ShaderManagementConsole
 {
@@ -79,60 +75,7 @@ namespace ShaderManagementConsole
 
     QWidget* ShaderManagementConsoleWindow::CreateDocumentTabView(const AZ::Uuid& documentId)
     {
-        AZStd::unordered_set<AZStd::string> optionNames;
-
-        size_t shaderOptionCount = 0;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(
-            shaderOptionCount, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderOptionCount);
-
-        for (size_t optionIndex = 0; optionIndex < shaderOptionCount; ++optionIndex)
-        {
-            AZ::RPI::ShaderOptionDescriptor shaderOptionDesc;
-            ShaderManagementConsoleDocumentRequestBus::EventResult(
-                shaderOptionDesc, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderOptionDescriptor, optionIndex);
-            optionNames.insert(shaderOptionDesc.GetName().GetCStr());
-        }
-
-        size_t shaderVariantCount = 0;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(
-            shaderVariantCount, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderVariantCount);
-
-        auto model = new QStandardItemModel();
-        model->setRowCount(static_cast<int>(shaderVariantCount));
-        model->setColumnCount(static_cast<int>(optionNames.size()));
-
-        int nameIndex = 0;
-        for (const auto& optionName : optionNames)
-        {
-            model->setHeaderData(nameIndex++, Qt::Horizontal, optionName.c_str());
-        }
-
-        for (int variantIndex = 0; variantIndex < shaderVariantCount; ++variantIndex)
-        {
-            AZ::RPI::ShaderVariantListSourceData::VariantInfo shaderVariantInfo;
-            ShaderManagementConsoleDocumentRequestBus::EventResult(
-                shaderVariantInfo, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderVariantInfo, variantIndex);
-
-            model->setHeaderData(variantIndex, Qt::Vertical, QString::number(variantIndex));
-
-            for (const auto& shaderOption : shaderVariantInfo.m_options)
-            {
-                AZ::Name optionName{ shaderOption.first };
-                AZ::Name optionValue{ shaderOption.second };
-
-                auto optionIt = optionNames.find(optionName.GetCStr());
-                int optionIndex = static_cast<int>(AZStd::distance(optionNames.begin(), optionIt));
-
-                QStandardItem* item = new QStandardItem(optionValue.GetCStr());
-                model->setItem(variantIndex, optionIndex, item);
-            }
-        }
-
-        // The document tab contains a table view.
-        auto contentWidget = new QTableView(centralWidget());
-        contentWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
-        contentWidget->setModel(model);
-        return contentWidget;
+        return new ShaderManagementConsoleTableView(documentId, centralWidget());
     }
 } // namespace ShaderManagementConsole
 

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Window/ShaderManagementConsoleWindow.h

@@ -8,16 +8,8 @@
 
 #pragma once
 
-#if !defined(Q_MOC_RUN)
-#include <Atom/RPI.Edit/Shader/ShaderVariantListSourceData.h>
-#include <Atom/RPI.Public/Shader/Shader.h>
 #include <AtomToolsFramework/Document/AtomToolsDocumentMainWindow.h>
 
-AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
-#include <QStandardItemModel>
-AZ_POP_DISABLE_WARNING
-#endif
-
 namespace ShaderManagementConsole
 {
     //! ShaderManagementConsoleWindow is the main class. Its responsibility is limited to initializing and connecting

Gems/Atom/Tools/ShaderManagementConsole/Code/shadermanagementconsole_files.cmake

@@ -11,6 +11,8 @@ set(FILES
     Source/Document/ShaderManagementConsoleDocument.cpp
     Source/Document/ShaderManagementConsoleDocument.h
 
+    Source/Window/ShaderManagementConsoleTableView.h
+    Source/Window/ShaderManagementConsoleTableView.cpp
     Source/Window/ShaderManagementConsoleWindow.h
     Source/Window/ShaderManagementConsoleWindow.cpp
     Source/Window/ShaderManagementConsole.qrc