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 <guthadam@amazon.com>
monroegm-disable-blank-issue-2
Guthrie Adams 4 years ago
parent 2b16f6860f
commit 2b49b5eefe

@ -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>();
}

@ -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;

@ -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;

@ -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"

@ -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

@ -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

@ -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

@ -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

Loading…
Cancel
Save