birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merging from development

Browse Source 
Signed-off-by: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>
This commit is contained in:
Esteban Papp
2021-12-07 12:35:41 -08:00
parent b1eeebb6b6
commit cd5306febf
334 changed files with 9946 additions and 3757 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Gems/ScriptCanvas/Code/Editor/View/Windows/MainWindow.cpp
+592 -914
View File
File diff suppressed because it is too large Load Diff
Gems/ScriptCanvas/Code/Editor/View/Windows/MainWindow.h
+70 -103
View File
@@ -43,7 +43,6 @@
#include <ScriptCanvas/Bus/EditorScriptCanvasBus.h>
#include <ScriptCanvas/Core/ScriptCanvasBus.h>
#include <ScriptCanvas/Debugger/ClientTransceiver.h>
#include <Editor/Assets/ScriptCanvasAssetHolder.h>
#include <Editor/Undo/ScriptCanvasGraphCommand.h>
#include <Editor/Utilities/RecentFiles.h>
@@ -53,6 +52,7 @@
#include <Editor/View/Widgets/AssetGraphSceneDataBus.h>
#include <Editor/View/Windows/Tools/UpgradeTool/Controller.h>
#include <Editor/View/Windows/Tools/UpgradeTool/FileSaver.h>
#if SCRIPTCANVAS_EDITOR
#include <Include/EditorCoreAPI.h>
@@ -153,7 +153,7 @@ namespace ScriptCanvasEditor
}
};
//! Manages the Save/Restore operations of the user's las topened and focused graphs
//! Manages the Save/Restore operations of the user's last opened and focused graphs
class Workspace
: AssetTrackerNotificationBus::MultiHandler
{
@@ -175,9 +175,9 @@ namespace ScriptCanvasEditor
private:
void OnAssetReady(const ScriptCanvasMemoryAsset::pointer asset) override;
void SignalAssetComplete(const AZ::Data::AssetId& fileAssetId);
void SignalAssetComplete(const ScriptCanvasEditor::SourceHandle& fileAssetId);
AZ::Data::AssetId GetSourceAssetId(const AZ::Data::AssetId& memoryAssetId) const;
ScriptCanvasEditor::SourceHandle GetSourceAssetId(const ScriptCanvasEditor::SourceHandle& memoryAssetId) const;
bool m_rememberOpenCanvases;
MainWindow* m_mainWindow;
@@ -185,10 +185,10 @@ namespace ScriptCanvasEditor
//! Setting focus is problematic unless it is done until after all currently loading graphs have finished loading
//! This vector is used to track the list of graphs being opened to restore the workspace and as assets are fully
//! ready and activated they are removed from this list.
AZStd::vector<AZ::Data::AssetId> m_loadingAssets;
AZStd::vector<ScriptCanvasEditor::SourceHandle> m_loadingAssets;
//! During restore we queue the asset Id to focus in order to do it last
AZ::Data::AssetId m_queuedAssetFocus;
ScriptCanvasEditor::SourceHandle m_queuedAssetFocus;
};
enum class UnsavedChangesOptions;
@@ -230,7 +230,6 @@ namespace ScriptCanvasEditor
, private VariablePaletteRequestBus::Handler
, private ScriptCanvas::BatchOperationNotificationBus::Handler
, private AssetGraphSceneBus::Handler
, private AssetTrackerNotificationBus::MultiHandler
#if SCRIPTCANVAS_EDITOR
//, public IEditorNotifyListener
#endif
@@ -239,6 +238,7 @@ namespace ScriptCanvasEditor
, private GraphCanvas::ViewNotificationBus::Handler
, public AZ::SystemTickBus::Handler
, private AzToolsFramework::ToolsApplicationNotificationBus::Handler
, private AzToolsFramework::AssetSystemBus::Handler
, private ScriptCanvas::ScriptCanvasSettingsRequestBus::Handler
{
Q_OBJECT
@@ -269,7 +269,7 @@ namespace ScriptCanvasEditor
// Undo Handlers
void PostUndoPoint(ScriptCanvas::ScriptCanvasId scriptCanvasId) override;
void SignalSceneDirty(AZ::Data::AssetId assetId) override;
void SignalSceneDirty(ScriptCanvasEditor::SourceHandle assetId) override;
void PushPreventUndoStateUpdate() override;
void PopPreventUndoStateUpdate() override;
@@ -325,12 +325,17 @@ namespace ScriptCanvasEditor
// File menu
void OnFileNew();
bool OnFileSave(const Callbacks::OnSave& saveCB);
bool OnFileSaveAs(const Callbacks::OnSave& saveCB);
bool OnFileSaveCaller(){return OnFileSave(nullptr);};
bool OnFileSaveAsCaller(){return OnFileSaveAs(nullptr);};
bool SaveAssetImpl(const AZ::Data::AssetId& assetId, const Callbacks::OnSave& saveCB);
bool SaveAssetAsImpl(const AZ::Data::AssetId& assetId, const Callbacks::OnSave& saveCB);
bool OnFileSave();
bool OnFileSaveAs();
bool OnFileSaveCaller(){return OnFileSave();};
bool OnFileSaveAsCaller(){return OnFileSaveAs();};
bool SaveAssetImpl_OLD(const ScriptCanvasEditor::SourceHandle& assetId, const Callbacks::OnSave& saveCB);
enum class Save
{
InPlace,
As
};
bool SaveAssetImpl(const ScriptCanvasEditor::SourceHandle& assetId, Save save);
void OnFileOpen();
// Edit menu
@@ -415,30 +420,27 @@ namespace ScriptCanvasEditor
void CloseNextTab();
bool IsTabOpen(const AZ::Data::AssetId& assetId, int& outTabIndex) const;
QVariant GetTabData(const AZ::Data::AssetId& assetId);
bool IsTabOpen(const SourceHandle& assetId, int& outTabIndex) const;
QVariant GetTabData(const SourceHandle& assetId);
//! GeneralRequestBus
AZ::Outcome<int, AZStd::string> OpenScriptCanvasAssetId(const AZ::Data::AssetId& assetId) override;
AZ::Outcome<int, AZStd::string> OpenScriptCanvasAsset(AZ::Data::AssetId scriptCanvasAssetId, int tabIndex = -1) override;
AZ::Outcome<int, AZStd::string> OpenScriptCanvasAsset(const ScriptCanvasMemoryAsset& scriptCanvasAsset, int tabIndex = -1);
int CloseScriptCanvasAsset(const AZ::Data::AssetId& assetId) override;
AZ::Outcome<int, AZStd::string> OpenScriptCanvasAssetId(const SourceHandle& assetId, Tracker::ScriptCanvasFileState fileState) override;
AZ::Outcome<int, AZStd::string> OpenScriptCanvasAsset(SourceHandle scriptCanvasAssetId, Tracker::ScriptCanvasFileState fileState, int tabIndex = -1) override;
AZ::Outcome<int, AZStd::string> OpenScriptCanvasAssetImplementation(const SourceHandle& sourceHandle, Tracker::ScriptCanvasFileState fileState, int tabIndex = -1);
int CloseScriptCanvasAsset(const SourceHandle& assetId) override;
bool CreateScriptCanvasAssetFor(const TypeDefs::EntityComponentId& requestingEntityId) override;
bool IsScriptCanvasAssetOpen(const AZ::Data::AssetId& assetId) const override;
bool IsScriptCanvasAssetOpen(const SourceHandle& assetId) const override;
const CategoryInformation* FindNodePaletteCategoryInformation(AZStd::string_view categoryPath) const override;
const NodePaletteModelInformation* FindNodePaletteModelInformation(const ScriptCanvas::NodeTypeIdentifier& nodeType) const override;
////
AZ::Outcome<int, AZStd::string> CreateScriptCanvasAsset(AZStd::string_view assetPath, AZ::Data::AssetType assetType, int tabIndex = -1);
AZ::Outcome<int, AZStd::string> UpdateScriptCanvasAsset(const AZ::Data::Asset<ScriptCanvas::ScriptCanvasAssetBase>& scriptCanvasAsset);
AZ::Outcome<int, AZStd::string> CreateScriptCanvasAsset(AZStd::string_view assetPath, int tabIndex = -1);
void RefreshScriptCanvasAsset(const AZ::Data::Asset<ScriptCanvas::ScriptCanvasAssetBase>& scriptCanvasAsset);
//! Removes the assetId -> ScriptCanvasAsset mapping and disconnects from the asset tracker
void RemoveScriptCanvasAsset(const AZ::Data::AssetId& assetId);
void OnChangeActiveGraphTab(AZ::Data::AssetId) override;
void RemoveScriptCanvasAsset(const ScriptCanvasEditor::SourceHandle& assetId);
void OnChangeActiveGraphTab(ScriptCanvasEditor::SourceHandle) override;
void CreateNewRuntimeAsset() override { OnFileNew(); }
@@ -448,8 +450,8 @@ namespace ScriptCanvasEditor
GraphCanvas::GraphId GetGraphCanvasGraphId(const ScriptCanvas::ScriptCanvasId& scriptCanvasId) const override;
GraphCanvas::GraphId FindGraphCanvasGraphIdByAssetId(const AZ::Data::AssetId& assetId) const override;
ScriptCanvas::ScriptCanvasId FindScriptCanvasIdByAssetId(const AZ::Data::AssetId& assetId) const override;
GraphCanvas::GraphId FindGraphCanvasGraphIdByAssetId(const ScriptCanvasEditor::SourceHandle& assetId) const override;
ScriptCanvas::ScriptCanvasId FindScriptCanvasIdByAssetId(const ScriptCanvasEditor::SourceHandle& assetId) const override;
bool IsInUndoRedo(const AZ::EntityId& graphCanvasGraphId) const override;
bool IsScriptCanvasInUndoRedo(const ScriptCanvas::ScriptCanvasId& scriptCanvasId) const override;
@@ -517,17 +519,18 @@ namespace ScriptCanvasEditor
QObject* FindElementByName(QString elementName) override;
////
AZ::EntityId FindEditorNodeIdByAssetNodeId(const AZ::Data::AssetId& assetId, AZ::EntityId assetNodeId) const override;
AZ::EntityId FindAssetNodeIdByEditorNodeId(const AZ::Data::AssetId& assetId, AZ::EntityId editorNodeId) const override;
AZ::EntityId FindEditorNodeIdByAssetNodeId(const ScriptCanvasEditor::SourceHandle& assetId, AZ::EntityId assetNodeId) const override;
AZ::EntityId FindAssetNodeIdByEditorNodeId(const ScriptCanvasEditor::SourceHandle& assetId, AZ::EntityId editorNodeId) const override;
private:
void SourceFileChanged(AZStd::string relativePath, AZStd::string scanFolder, AZ::Uuid fileAssetId) override;
void SourceFileRemoved(AZStd::string relativePath, AZStd::string scanFolder, AZ::Uuid fileAssetId) override;
void DeleteNodes(const AZ::EntityId& sceneId, const AZStd::vector<AZ::EntityId>& nodes) override;
void DeleteConnections(const AZ::EntityId& sceneId, const AZStd::vector<AZ::EntityId>& connections) override;
void DisconnectEndpoints(const AZ::EntityId& sceneId, const AZStd::vector<GraphCanvas::Endpoint>& endpoints) override;
/////////////////////////////////////////////////////////////////////////////////////////////
void UpdateWorkspaceStatus(const ScriptCanvasMemoryAsset& scriptCanvasAsset);
GraphCanvas::Endpoint HandleProposedConnection(const GraphCanvas::GraphId& graphId, const GraphCanvas::ConnectionId& connectionId, const GraphCanvas::Endpoint& endpoint, const GraphCanvas::NodeId& proposedNode, const QPoint& screenPoint);
//! UndoNotificationBus
@@ -543,29 +546,20 @@ namespace ScriptCanvasEditor
void OnAutoSave();
//! Helper function which serializes a file to disk
//! \param filename name of file to serialize the Entity
//! \param asset asset to save
void GetSuggestedFullFilenameToSaveAs(const AZ::Data::AssetId& assetId, AZStd::string& filePath, AZStd::string& fileFilter);
void MarkAssetModified(const AZ::Data::AssetId& assetId);
void UpdateFileState(const ScriptCanvasEditor::SourceHandle& assetId, Tracker::ScriptCanvasFileState fileState);
// QMainWindow
void closeEvent(QCloseEvent *event) override;
UnsavedChangesOptions ShowSaveDialog(const QString& filename);
bool ActivateAndSaveAsset(const AZ::Data::AssetId& unsavedAssetId, const Callbacks::OnSave& onSave);
bool ActivateAndSaveAsset(const ScriptCanvasEditor::SourceHandle& unsavedAssetId);
void SaveNewAsset(AZStd::string_view path, AZ::Data::AssetId assetId, const Callbacks::OnSave& onSave);
void SaveAsset(AZ::Data::AssetId assetId, const Callbacks::OnSave& onSave);
void SaveAs(AZStd::string_view path, ScriptCanvasEditor::SourceHandle assetId);
void OpenFile(const char* fullPath);
void CreateMenus();
void SignalActiveSceneChanged(const AZ::Data::AssetId assetId);
void SaveWorkspace(bool updateAssetList = true);
void RestoreWorkspace();
void SignalActiveSceneChanged(const ScriptCanvasEditor::SourceHandle assetId);
void RunUpgradeTool();
@@ -593,29 +587,27 @@ namespace ScriptCanvasEditor
void UpdateMenuState(bool enabledState);
void OnWorkspaceRestoreStart();
void OnWorkspaceRestoreEnd(AZ::Data::AssetId lastFocusAsset);
void OnWorkspaceRestoreEnd(ScriptCanvasEditor::SourceHandle lastFocusAsset);
void UpdateAssignToSelectionState();
void UpdateUndoRedoState();
void UpdateSaveState();
void UpdateSaveState(bool enabled);
void CreateFunctionInput();
void CreateFunctionOutput();
void CreateFunctionDefinitionNode(int positionOffset);
int CreateAssetTab(const AZ::Data::AssetId& assetId, int tabIndex = -1);
int CreateAssetTab(const ScriptCanvasEditor::SourceHandle& assetId, Tracker::ScriptCanvasFileState fileState, int tabIndex = -1);
//! \param asset The AssetId of the ScriptCanvas Asset.
void SetActiveAsset(const AZ::Data::AssetId& assetId);
void SetActiveAsset(const ScriptCanvasEditor::SourceHandle& assetId);
void RefreshActiveAsset();
void ReconnectSceneBuses(AZ::Data::AssetId previousAssetId, AZ::Data::AssetId nextAssetId);
void SignalBatchOperationComplete(BatchOperatorTool* batchTool);
void ReconnectSceneBuses(ScriptCanvasEditor::SourceHandle previousAssetId, ScriptCanvasEditor::SourceHandle nextAssetId);
void PrepareActiveAssetForSave();
void PrepareAssetForSave(const AZ::Data::AssetId& asssetId);
void PrepareAssetForSave(const ScriptCanvasEditor::SourceHandle& asssetId);
void RestartAutoTimerSave(bool forceTimer = false);
@@ -626,24 +618,16 @@ namespace ScriptCanvasEditor
void AssignGraphToEntityImpl(const AZ::EntityId& entityId);
////
Tracker::ScriptCanvasFileState GetAssetFileState(AZ::Data::AssetId assetId) const;
Tracker::ScriptCanvasFileState GetAssetFileState(ScriptCanvasEditor::SourceHandle assetId) const;
AZ::Data::AssetId GetSourceAssetId(const AZ::Data::AssetId& memoryAssetId) const
ScriptCanvasEditor::SourceHandle GetSourceAssetId(const ScriptCanvasEditor::SourceHandle& memoryAssetId) const
{
ScriptCanvasMemoryAsset::pointer memoryAsset;
AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, memoryAssetId);
if (memoryAsset)
{
return memoryAsset->GetFileAssetId();
}
return AZ::Data::AssetId();
return memoryAssetId;
}
int InsertTabForAsset(AZStd::string_view assetPath, AZ::Data::AssetId assetId, int tabIndex = -1);
int InsertTabForAsset(AZStd::string_view assetPath, ScriptCanvasEditor::SourceHandle assetId, int tabIndex = -1);
void UpdateUndoCache(AZ::Data::AssetId assetId);
void UpdateUndoCache(ScriptCanvasEditor::SourceHandle assetId);
bool HasSystemTickAction(SystemTickActionFlag action);
@@ -655,34 +639,9 @@ namespace ScriptCanvasEditor
void OpenNextFile();
template <typename GraphAssetType, typename AssetHandler>
void MakeNewFile()
{
static int scriptCanvasEditorDefaultNewNameCount = 0;
AZStd::string newAssetName = AZStd::string::format(ScriptCanvas::AssetDescription::GetAssetNamePattern<GraphAssetType>(), ++scriptCanvasEditorDefaultNewNameCount);
AZStd::array<char, AZ::IO::MaxPathLength> assetRootArray;
if (!AZ::IO::FileIOBase::GetInstance()->ResolvePath(ScriptCanvas::AssetDescription::GetSuggestedSavePath<GraphAssetType>(), assetRootArray.data(), assetRootArray.size()))
{
AZ_ErrorOnce("Script Canvas", false, "Unable to resolve @projectroot@ path");
}
AZStd::string assetPath;
AzFramework::StringFunc::Path::Join(assetRootArray.data(), (newAssetName + ScriptCanvas::AssetDescription::GetExtension<GraphAssetType>()).data(), assetPath);
auto createOutcome = CreateScriptCanvasAsset(assetPath, azrtti_typeid<GraphAssetType>());
if (createOutcome)
{
}
else
{
AZ_Warning("Script Canvas", createOutcome, "%s", createOutcome.GetError().data());
}
}
void DisableAssetView(ScriptCanvasMemoryAsset::pointer memoryAsset);
void EnableAssetView(ScriptCanvasMemoryAsset::pointer memoryAsset);
void DisableAssetView(const ScriptCanvasEditor::SourceHandle& memoryAssetId);
void EnableAssetView(const ScriptCanvasEditor::SourceHandle& memoryAssetId);
QWidget* m_host = nullptr;
@@ -741,22 +700,22 @@ namespace ScriptCanvasEditor
GraphCanvas::GraphCanvasEditorEmptyDockWidget* m_emptyCanvas; // Displayed when there is no open graph
QVBoxLayout* m_layout;
AZ::Data::AssetId m_activeAssetId;
ScriptCanvasEditor::SourceHandle m_activeGraph;
bool m_loadingNewlySavedFile;
AZStd::string m_newlySavedFile;
AZStd::string m_errorFilePath;
bool m_isClosingTabs;
AZ::Data::AssetId m_skipTabOnClose;
ScriptCanvasEditor::SourceHandle m_skipTabOnClose;
bool m_enterState;
bool m_ignoreSelection;
AZ::s32 m_preventUndoStateUpdateCount;
bool m_isRestoringWorkspace;
AZ::Data::AssetId m_queuedFocusOverride;
ScriptCanvasEditor::SourceHandle m_queuedFocusOverride;
Ui::MainWindow* ui;
AZStd::array<AZStd::pair<QAction*, QMetaObject::Connection>, c_scriptCanvasEditorSettingsRecentFilesCountMax> m_recentActions;
@@ -778,17 +737,17 @@ namespace ScriptCanvasEditor
AZStd::vector<AZ::EntityId> m_selectedVariableIds;
AZ::u32 m_systemTickActions;
AZStd::unordered_set< AZ::Data::AssetId > m_processedClosedAssetIds;
AZStd::unordered_set< ScriptCanvasEditor::SourceHandle > m_processedClosedAssetIds;
AZStd::unordered_set< AZ::Data::AssetId > m_loadingWorkspaceAssets;
AZStd::unordered_set< AZ::Data::AssetId > m_loadingAssets;
AZStd::unordered_set< ScriptCanvasEditor::SourceHandle > m_loadingWorkspaceAssets;
AZStd::unordered_set< ScriptCanvasEditor::SourceHandle > m_loadingAssets;
AZStd::unordered_set< AZ::Uuid > m_variablePaletteTypes;
AZStd::unordered_map< AZ::Crc32, QObject* > m_automationLookUpMap;
bool m_closeCurrentGraphAfterSave;
AZStd::unordered_map< AZ::Data::AssetId, TypeDefs::EntityComponentId > m_assetCreationRequests;
AZStd::unordered_map< ScriptCanvasEditor::SourceHandle, TypeDefs::EntityComponentId > m_assetCreationRequests;
ScriptCanvas::Debugger::ClientTransceiver m_clientTRX;
GraphCanvas::StyleManager m_styleManager;
@@ -797,6 +756,14 @@ namespace ScriptCanvasEditor
//! this object manages the Save/Restore operations
Workspace* m_workspace;
void OnSaveCallback(bool saveSuccess, AZ::Data::AssetPtr, AZ::Data::AssetId previousFileAssetId);
AZStd::unique_ptr<VersionExplorer::FileSaver> m_fileSaver;
VersionExplorer::FileSaveResult m_fileSaveResult;
void OnSaveCallBack(const VersionExplorer::FileSaveResult& result);
void ClearStaleSaves();
bool IsRecentSave(const SourceHandle& handle) const;
void MarkRecentSave(const SourceHandle& handle);
AZStd::recursive_mutex m_mutex;
AZStd::unordered_map <AZStd::string, AZStd::chrono::system_clock::time_point> m_saves;
};
}
Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/Controller.h
+15 -15
View File
@@ -65,36 +65,36 @@ namespace ScriptCanvasEditor
void AddLogEntries();
void EnableAllUpgradeButtons();
QList<QTableWidgetItem*> FindTableItems(const AZ::Data::AssetInfo& assetInfo);
QList<QTableWidgetItem*> FindTableItems(const SourceHandle& assetInfo);
void OnButtonPressClose();
void OnButtonPressScan();
void OnButtonPressUpgrade();
void OnButtonPressUpgradeImplementation(const AZ::Data::AssetInfo& assetInfo);
void OnButtonPressUpgradeSingle(const AZ::Data::AssetInfo& assetInfo);
void OnButtonPressUpgradeImplementation(const SourceHandle& assetInfo);
void OnButtonPressUpgradeSingle(const SourceHandle& assetInfo);
void OnGraphUpgradeComplete(AZ::Data::Asset<AZ::Data::AssetData>&, bool skipped) override;
void OnGraphUpgradeComplete(SourceHandle&, bool skipped) override;
void OnScanBegin(size_t assetCount) override;
void OnScanComplete(const ScanResult& result) override;
void OnScanFilteredGraph(const AZ::Data::AssetInfo& info) override;
void OnScanLoadFailure(const AZ::Data::AssetInfo& info) override;
void OnScanUnFilteredGraph(const AZ::Data::AssetInfo& info) override;
void OnScanFilteredGraph(const SourceHandle& info) override;
void OnScanLoadFailure(const SourceHandle& info) override;
void OnScanUnFilteredGraph(const SourceHandle& info) override;
enum class Filtered { No, Yes };
void OnScannedGraph(const AZ::Data::AssetInfo& info, Filtered filtered);
void OnScannedGraphResult(const AZ::Data::AssetInfo& info);
void OnScannedGraph(const SourceHandle& info, Filtered filtered);
void OnScannedGraphResult(const SourceHandle& info);
// for single operation UI updates, just check the assets size, or note it on the request
void OnUpgradeBegin(const ModifyConfiguration& config, const WorkingAssets& assets) override;
void OnUpgradeBegin(const ModifyConfiguration& config, const AZStd::vector<SourceHandle>& assets) override;
void OnUpgradeComplete(const ModificationResults& results) override;
void OnUpgradeDependenciesGathered(const AZ::Data::AssetInfo& info, Result result) override;
void OnUpgradeDependencySortBegin(const ModifyConfiguration& config, const WorkingAssets& assets) override;
void OnUpgradeDependenciesGathered(const SourceHandle& info, Result result) override;
void OnUpgradeDependencySortBegin(const ModifyConfiguration& config, const AZStd::vector<SourceHandle>& assets) override;
void OnUpgradeDependencySortEnd
( const ModifyConfiguration& config
, const WorkingAssets& assets
, const AZStd::vector<SourceHandle>& assets
, const AZStd::vector<size_t>& sortedOrder) override;
void OnUpgradeModificationBegin(const ModifyConfiguration& config, const AZ::Data::AssetInfo& info) override;
void OnUpgradeModificationEnd(const ModifyConfiguration& config, const AZ::Data::AssetInfo& info, ModificationResult result) override;
void OnUpgradeModificationBegin(const ModifyConfiguration& config, const SourceHandle& info) override;
void OnUpgradeModificationEnd(const ModifyConfiguration& config, const SourceHandle& info, ModificationResult result) override;
void SetLoggingPreferences();
void SetSpinnerIsBusy(bool isBusy);
Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/FileSaver.h
+8 -3
View File
@@ -29,14 +29,19 @@ namespace ScriptCanvasEditor
( AZStd::function<bool()> onReadOnlyFile
, AZStd::function<void(const FileSaveResult& result)> onComplete);
void Save(AZ::Data::Asset<AZ::Data::AssetData> asset);
const SourceHandle& GetSource() const;
void Save(const SourceHandle& source);
private:
AZStd::mutex m_mutex;
bool m_sourceFileReleased = false;
SourceHandle m_source;
AZStd::function<void(const FileSaveResult& result)> m_onComplete;
AZStd::function<bool()> m_onReadOnlyFile;
void OnSourceFileReleased(AZ::Data::Asset<AZ::Data::AssetData> asset);
void OnSourceFileReleased(const SourceHandle& source);
void PerformMove
( AZStd::string source
, AZStd::string target
Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/Model.cpp
+3 -3
View File
@@ -101,7 +101,7 @@ namespace ScriptCanvasEditor
return;
}
if (modification.modifySingleAsset.m_assetId.IsValid())
if (!modification.modifySingleAsset.Path().empty())
{
const auto& results = m_scanner->GetResult();
auto iter = AZStd::find_if
@@ -109,7 +109,7 @@ namespace ScriptCanvasEditor
, results.m_unfiltered.end()
, [&modification](const auto& candidate)
{
return candidate.info.m_assetId == modification.modifySingleAsset.m_assetId;
return candidate.AnyEquals(modification.modifySingleAsset);
});
if (iter == results.m_unfiltered.end())
@@ -120,7 +120,7 @@ namespace ScriptCanvasEditor
m_state = State::ModifySingle;
m_modifier = AZStd::make_unique<Modifier>(modification, WorkingAssets{ *iter }, [this]() { OnModificationComplete(); });
m_modifier = AZStd::make_unique<Modifier>(modification, AZStd::vector<SourceHandle>{ *iter }, [this]() { OnModificationComplete(); });
}
else
{
Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/ModelTraits.h
+25 -27
View File
@@ -9,53 +9,51 @@
#include <AzCore/EBus/EBus.h>
#include <AzCore/Asset/AssetManagerBus.h>
#include <ScriptCanvas/Core/Core.h>
namespace ScriptCanvasEditor
{
namespace VersionExplorer
{
struct WorkingAsset
{
AZ::Data::Asset<AZ::Data::AssetData> asset;
AZ::Data::AssetInfo info;
};
using WorkingAssets = AZStd::vector<WorkingAsset>;
struct ModifyConfiguration
{
AZStd::function<void(AZ::Data::Asset<AZ::Data::AssetData>)> modification;
AZStd::function<void(SourceHandle&)> modification;
AZStd::function<bool()> onReadOnlyFile;
AZ::Data::AssetInfo modifySingleAsset;
SourceHandle modifySingleAsset;
bool backupGraphBeforeModification = false;
bool successfulDependencyUpgradeRequired = true;
};
struct ModificationResult
{
AZ::Data::Asset<AZ::Data::AssetData> asset;
AZ::Data::AssetInfo assetInfo;
SourceHandle asset;
AZStd::string errorMessage;
};
struct ModificationResults
{
AZStd::vector<AZ::Data::AssetInfo> m_successes;
AZStd::vector<SourceHandle> m_successes;
AZStd::vector<ModificationResult> m_failures;
};
struct ScanConfiguration
{
AZStd::function<bool(AZ::Data::Asset<AZ::Data::AssetData>)> filter;
enum class Filter
{
Include,
Exclude
};
AZStd::function<Filter(const SourceHandle&)> filter;
bool reportFilteredGraphs = false;
};
struct ScanResult
{
AZStd::vector<AZ::Data::AssetInfo> m_catalogAssets;
WorkingAssets m_unfiltered;
AZStd::vector<AZ::Data::AssetInfo> m_filteredAssets;
AZStd::vector<AZ::Data::AssetInfo> m_loadErrors;
AZStd::vector<SourceHandle> m_catalogAssets;
AZStd::vector<SourceHandle> m_unfiltered;
AZStd::vector<SourceHandle> m_filteredAssets;
AZStd::vector<SourceHandle> m_loadErrors;
};
enum Result
@@ -88,20 +86,20 @@ namespace ScriptCanvasEditor
public:
virtual void OnScanBegin(size_t assetCount) = 0;
virtual void OnScanComplete(const ScanResult& result) = 0;
virtual void OnScanFilteredGraph(const AZ::Data::AssetInfo& info) = 0;
virtual void OnScanLoadFailure(const AZ::Data::AssetInfo& info) = 0;
virtual void OnScanUnFilteredGraph(const AZ::Data::AssetInfo& info) = 0;
virtual void OnScanFilteredGraph(const SourceHandle& info) = 0;
virtual void OnScanLoadFailure(const SourceHandle& info) = 0;
virtual void OnScanUnFilteredGraph(const SourceHandle& info) = 0;
virtual void OnUpgradeBegin(const ModifyConfiguration& config, const WorkingAssets& assets) = 0;
virtual void OnUpgradeBegin(const ModifyConfiguration& config, const AZStd::vector<SourceHandle>& assets) = 0;
virtual void OnUpgradeComplete(const ModificationResults& results) = 0;
virtual void OnUpgradeDependenciesGathered(const AZ::Data::AssetInfo& info, Result result) = 0;
virtual void OnUpgradeDependencySortBegin(const ModifyConfiguration& config, const WorkingAssets& assets) = 0;
virtual void OnUpgradeDependenciesGathered(const SourceHandle& info, Result result) = 0;
virtual void OnUpgradeDependencySortBegin(const ModifyConfiguration& config, const AZStd::vector<SourceHandle>& assets) = 0;
virtual void OnUpgradeDependencySortEnd
( const ModifyConfiguration& config
, const WorkingAssets& assets
, const AZStd::vector<SourceHandle>& assets
, const AZStd::vector<size_t>& sortedOrder) = 0;
virtual void OnUpgradeModificationBegin(const ModifyConfiguration& config, const AZ::Data::AssetInfo& info) = 0;
virtual void OnUpgradeModificationEnd(const ModifyConfiguration& config, const AZ::Data::AssetInfo& info, ModificationResult result) = 0;
virtual void OnUpgradeModificationBegin(const ModifyConfiguration& config, const SourceHandle& info) = 0;
virtual void OnUpgradeModificationEnd(const ModifyConfiguration& config, const SourceHandle& info, ModificationResult result) = 0;
};
using ModelNotificationsBus = AZ::EBus<ModelNotificationsTraits>;
}
Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/Modifier.cpp
+52 -53
View File
@@ -6,24 +6,21 @@
*
*/
#include <Editor/Include/ScriptCanvas/Components/EditorGraph.h>
#include <Editor/View/Windows/Tools/UpgradeTool/LogTraits.h>
#include <Editor/View/Windows/Tools/UpgradeTool/Modifier.h>
#include <ScriptCanvas/Asset/RuntimeAsset.h>
#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
#include <ScriptCanvas/Assets/ScriptCanvasFileHandling.h>
#include <ScriptCanvas/Core/Graph.h>
namespace ModifierCpp
{
}
namespace ScriptCanvasEditor
{
namespace VersionExplorer
{
Modifier::Modifier
( const ModifyConfiguration& modification
, WorkingAssets&& assets
, AZStd::vector<SourceHandle>&& assets
, AZStd::function<void()> onComplete)
: m_state(State::GatheringDependencies)
, m_config(modification)
@@ -35,11 +32,12 @@ namespace ScriptCanvasEditor
AZ::SystemTickBus::Handler::BusConnect();
}
const AZ::Data::AssetInfo& Modifier::GetCurrentAsset() const
size_t Modifier::GetCurrentIndex() const
{
return m_state == State::GatheringDependencies
? m_assets[m_assetIndex].info
: m_assets[m_dependencyOrderedAssetIndicies[m_assetIndex]].info;
? m_assetIndex
: m_dependencyOrderedAssetIndicies[m_assetIndex];
}
AZStd::unordered_set<size_t>& Modifier::GetOrCreateDependencyIndexSet()
@@ -65,14 +63,10 @@ namespace ScriptCanvasEditor
AZ_Assert(serializeContext, "SerializeContext is required to enumerate dependent assets in the ScriptCanvas file");
bool anyFailures = false;
auto asset = LoadAsset();
if (asset
&& asset.GetAs<ScriptCanvasAsset>()
&& asset.GetAs<ScriptCanvasAsset>()->GetScriptCanvasGraph()
&& asset.GetAs<ScriptCanvasAsset>()->GetScriptCanvasGraph()->GetGraphData())
if (m_result.asset.Get() && m_result.asset.Mod()->GetGraphData())
{
auto graphData = asset.GetAs<ScriptCanvasAsset>()->GetScriptCanvasGraph()->GetGraphData();
auto graphData = m_result.asset.Mod()->GetGraphData();
auto dependencyGrabber = [this]
( void* instancePointer
@@ -107,71 +101,69 @@ namespace ScriptCanvasEditor
, nullptr))
{
anyFailures = true;
VE_LOG("Modifier: ERROR - Failed to gather dependencies from graph data: %s"
, GetCurrentAsset().m_relativePath.c_str())
VE_LOG("Modifier: ERROR - Failed to gather dependencies from graph data: %s"
, m_result.asset.Path().c_str())
}
}
else
{
anyFailures = true;
VE_LOG("Modifier: ERROR - Failed to load asset %s for modification, even though it scanned properly"
, GetCurrentAsset().m_relativePath.c_str());
, m_result.asset.Path().c_str());
}
ModelNotificationsBus::Broadcast
( &ModelNotificationsTraits::OnUpgradeDependenciesGathered
, GetCurrentAsset()
, m_result.asset
, anyFailures ? Result::Failure : Result::Success);
ReleaseCurrentAsset();
// Flush asset database events to ensure no asset references are held by closures queued on Ebuses.
AZ::Data::AssetManager::Instance().DispatchEvents();
}
AZ::Data::Asset<AZ::Data::AssetData> Modifier::LoadAsset()
void Modifier::LoadAsset()
{
AZ::Data::Asset<AZ::Data::AssetData> asset = AZ::Data::AssetManager::Instance().GetAsset
( GetCurrentAsset().m_assetId
, azrtti_typeid<ScriptCanvasAsset>()
, AZ::Data::AssetLoadBehavior::PreLoad);
asset.BlockUntilLoadComplete();
if (asset.IsReady())
auto& handle = m_result.asset;
if (!handle.IsGraphValid())
{
return asset;
}
else
{
return {};
auto outcome = LoadFromFile(handle.Path().c_str());
if (outcome.IsSuccess())
{
handle = outcome.TakeValue();
}
}
}
void Modifier::ModificationComplete(const ModificationResult& result)
{
m_result = result;
if (result.errorMessage.empty())
if (!result.errorMessage.empty())
{
SaveModifiedGraph(result);
ReportModificationError(result.errorMessage);
}
else if (m_result.asset.Describe() != result.asset.Describe())
{
ReportModificationError("Received modifiction complete notification for different result");
}
else
{
ReportModificationError(result.errorMessage);
SaveModifiedGraph(result);
}
}
void Modifier::ModifyCurrentAsset()
{
m_result = {};
m_result.assetInfo = GetCurrentAsset();
m_result.asset = m_assets[GetCurrentIndex()];
ModelNotificationsBus::Broadcast(&ModelNotificationsTraits::OnUpgradeModificationBegin, m_config, m_result.asset);
LoadAsset();
ModelNotificationsBus::Broadcast(&ModelNotificationsTraits::OnUpgradeModificationBegin, m_config, GetCurrentAsset());
if (auto asset = LoadAsset())
if (m_result.asset.IsGraphValid())
{
ModificationNotificationsBus::Handler::BusConnect();
m_modifyState = ModifyState::InProgress;
m_config.modification(asset);
m_config.modification(m_result.asset);
}
else
{
@@ -182,24 +174,30 @@ namespace ScriptCanvasEditor
void Modifier::ModifyNextAsset()
{
ModelNotificationsBus::Broadcast
( &ModelNotificationsTraits::OnUpgradeModificationEnd, m_config, GetCurrentAsset(), m_result);
( &ModelNotificationsTraits::OnUpgradeModificationEnd, m_config, m_result.asset, m_result);
ModificationNotificationsBus::Handler::BusDisconnect();
m_modifyState = ModifyState::Idle;
ReleaseCurrentAsset();
++m_assetIndex;
m_result = {};
}
void Modifier::ReleaseCurrentAsset()
{
m_result.asset = m_result.asset.Describe();
}
void Modifier::ReportModificationError(AZStd::string_view report)
{
m_result.asset = {};
m_result.errorMessage = report;
m_results.m_failures.push_back(m_result);
m_results.m_failures.push_back({ m_result.asset.Describe(), report });
ModifyNextAsset();
}
void Modifier::ReportModificationSuccess()
{
m_results.m_successes.push_back(m_result.assetInfo);
m_result.asset = m_result.asset.Describe();
m_results.m_successes.push_back({ m_result.asset.Describe(), {} });
ModifyNextAsset();
}
@@ -227,7 +225,7 @@ namespace ScriptCanvasEditor
{
VE_LOG
( "Temporary file not removed for %s: %s"
, m_result.assetInfo.m_relativePath.c_str()
, m_result.asset.Path().c_str()
, result.tempFileRemovalError.c_str());
}
@@ -259,7 +257,7 @@ namespace ScriptCanvasEditor
m_modifyState = ModifyState::Saving;
m_fileSaver = AZStd::make_unique<FileSaver>
( m_config.onReadOnlyFile
, [this](const FileSaveResult& result) { OnFileSaveComplete(result); });
, [this](const FileSaveResult& fileSaveResult) { OnFileSaveComplete(fileSaveResult); });
m_fileSaver->Save(result.asset);
}
@@ -287,7 +285,7 @@ namespace ScriptCanvasEditor
for (size_t index = 0; index != m_assets.size(); ++index)
{
m_assetInfoIndexById.insert({ m_assets[index].info.m_assetId.m_guid, index });
m_assetInfoIndexById.insert({ m_assets[index].Id(), index });
}
}
else
@@ -299,7 +297,7 @@ namespace ScriptCanvasEditor
m_dependencyOrderedAssetIndicies.push_back(index);
}
// go straight into ModifyinGraphs
// go straight into ModifyingGraphs
m_assetIndex = m_assets.size();
}
}
@@ -322,6 +320,7 @@ namespace ScriptCanvasEditor
else
{
GatherDependencies();
ReleaseCurrentAsset();
++m_assetIndex;
}
}
@@ -380,10 +379,10 @@ namespace ScriptCanvasEditor
if (markedTemporary.contains(index))
{
AZ_Error
(ScriptCanvas::k_VersionExplorerWindow.data()
(ScriptCanvas::k_VersionExplorerWindow.data()
, false
, "Modifier: Dependency sort has failed during, circular dependency detected for Asset: %s"
, modifier->GetCurrentAsset().m_relativePath.c_str());
, modifier->m_result.asset.Path().c_str());
return;
}
Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/Modifier.h
+6 -4
View File
@@ -26,7 +26,7 @@ namespace ScriptCanvasEditor
Modifier
( const ModifyConfiguration& modification
, WorkingAssets&& assets
, AZStd::vector<SourceHandle>&& assets
, AZStd::function<void()> onComplete);
const ModificationResults& GetResult() const;
@@ -67,9 +67,10 @@ namespace ScriptCanvasEditor
State m_state = State::GatheringDependencies;
ModifyState m_modifyState = ModifyState::Idle;
size_t m_assetIndex = 0;
AZStd::function<void()> m_onComplete;
// asset infos in scanned order
WorkingAssets m_assets;
AZStd::vector<SourceHandle> m_assets;
// dependency sorted order indices into the asset vector
AZStd::vector<size_t> m_dependencyOrderedAssetIndicies;
// dependency indices by asset info index (only exist if graphs have them)
@@ -82,13 +83,14 @@ namespace ScriptCanvasEditor
AZStd::unique_ptr<FileSaver> m_fileSaver;
FileSaveResult m_fileSaveResult;
size_t GetCurrentIndex() const;
void GatherDependencies();
const AZ::Data::AssetInfo& GetCurrentAsset() const;
AZStd::unordered_set<size_t>& GetOrCreateDependencyIndexSet();
AZ::Data::Asset<AZ::Data::AssetData> LoadAsset();
void LoadAsset();
void ModifyCurrentAsset();
void ModifyNextAsset();
void ModificationComplete(const ModificationResult& result) override;
void ReleaseCurrentAsset();
void ReportModificationError(AZStd::string_view report);
void ReportModificationSuccess();
void ReportSaveResult();
Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/Scanner.cpp
+81 -42
View File
@@ -6,9 +6,49 @@
*
*/
#include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
#include <AzToolsFramework/AssetBrowser/AssetBrowserEntry.h>
#include <AzToolsFramework/AssetBrowser/AssetBrowserFilterModel.h>
#include <AzToolsFramework/AssetBrowser/AssetBrowserModel.h>
#include <Editor/View/Windows/Tools/UpgradeTool/LogTraits.h>
#include <Editor/View/Windows/Tools/UpgradeTool/Scanner.h>
#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
#include <Editor/View/Windows/Tools/UpgradeTool/LogTraits.h>
#include <ScriptCanvas/Assets/ScriptCanvasFileHandling.h>
namespace ScannerCpp
{
void TraverseTree
( QModelIndex index
, AzToolsFramework::AssetBrowser::AssetBrowserFilterModel& model
, ScriptCanvasEditor::VersionExplorer::ScanResult& result)
{
QModelIndex sourceIndex = model.mapToSource(index);
AzToolsFramework::AssetBrowser::AssetBrowserEntry* entry =
reinterpret_cast<AzToolsFramework::AssetBrowser::AssetBrowserEntry*>(sourceIndex.internalPointer());
if (entry
&& entry->GetEntryType() == AzToolsFramework::AssetBrowser::AssetBrowserEntry::AssetEntryType::Source
&& azrtti_istypeof<const AzToolsFramework::AssetBrowser::SourceAssetBrowserEntry*>(entry)
&& entry->GetFullPath().ends_with(".scriptcanvas"))
{
auto sourceEntry = azrtti_cast<const AzToolsFramework::AssetBrowser::SourceAssetBrowserEntry*>(entry);
AZStd::string fullPath = sourceEntry->GetFullPath();
AzFramework::StringFunc::Path::Normalize(fullPath);
result.m_catalogAssets.push_back(
ScriptCanvasEditor::SourceHandle(nullptr, sourceEntry->GetSourceUuid(), fullPath));
}
const int rowCount = model.rowCount(index);
for (int i = 0; i < rowCount; ++i)
{
TraverseTree(model.index(i, 0, index), model, result);
}
}
}
namespace ScriptCanvasEditor
{
@@ -18,60 +58,54 @@ namespace ScriptCanvasEditor
: m_config(config)
, m_onComplete(onComplete)
{
AZ::Data::AssetCatalogRequestBus::Broadcast
( &AZ::Data::AssetCatalogRequestBus::Events::EnumerateAssets
, nullptr
, [this](const AZ::Data::AssetId, const AZ::Data::AssetInfo& assetInfo)
{
if (assetInfo.m_assetType == azrtti_typeid<ScriptCanvasAsset>())
{
m_result.m_catalogAssets.push_back(assetInfo);
}
}
, nullptr);
AzToolsFramework::AssetBrowser::AssetBrowserModel* assetBrowserModel = nullptr;
AzToolsFramework::AssetBrowser::AssetBrowserComponentRequestBus::BroadcastResult
( assetBrowserModel, &AzToolsFramework::AssetBrowser::AssetBrowserComponentRequests::GetAssetBrowserModel);
if (assetBrowserModel)
{
auto stringFilter = new AzToolsFramework::AssetBrowser::StringFilter();
stringFilter->SetName("ScriptCanvas");
stringFilter->SetFilterString(".scriptcanvas");
stringFilter->SetFilterPropagation(AzToolsFramework::AssetBrowser::AssetBrowserEntryFilter::PropagateDirection::Down);
AzToolsFramework::AssetBrowser::AssetBrowserFilterModel assetFilterModel;
assetFilterModel.SetFilter(AzToolsFramework::AssetBrowser::FilterConstType(stringFilter));
assetFilterModel.setSourceModel(assetBrowserModel);
ScannerCpp::TraverseTree(QModelIndex(), assetFilterModel, m_result);
}
ModelNotificationsBus::Broadcast(&ModelNotificationsTraits::OnScanBegin, m_result.m_catalogAssets.size());
AZ::SystemTickBus::Handler::BusConnect();
}
void Scanner::FilterAsset(AZ::Data::Asset<AZ::Data::AssetData> asset)
void Scanner::FilterAsset(SourceHandle asset)
{
if (m_config.filter && m_config.filter(asset))
if (m_config.filter && m_config.filter(asset) == ScanConfiguration::Filter::Exclude)
{
VE_LOG("Scanner: Excluded: %s ", GetCurrentAsset().m_relativePath.c_str());
m_result.m_filteredAssets.push_back(GetCurrentAsset());
ModelNotificationsBus::Broadcast(&ModelNotificationsTraits::OnScanFilteredGraph, GetCurrentAsset());
VE_LOG("Scanner: Excluded: %s ", ModCurrentAsset().Path().c_str());
m_result.m_filteredAssets.push_back(ModCurrentAsset().Describe());
ModelNotificationsBus::Broadcast(&ModelNotificationsTraits::OnScanFilteredGraph, ModCurrentAsset());
}
else
{
VE_LOG("Scanner: Included: %s ", GetCurrentAsset().m_relativePath.c_str());
m_result.m_unfiltered.push_back({ asset, GetCurrentAsset() });
ModelNotificationsBus::Broadcast(&ModelNotificationsTraits::OnScanUnFilteredGraph, GetCurrentAsset());
VE_LOG("Scanner: Included: %s ", ModCurrentAsset().Path().c_str());
m_result.m_unfiltered.push_back(ModCurrentAsset().Describe());
ModelNotificationsBus::Broadcast(&ModelNotificationsTraits::OnScanUnFilteredGraph, ModCurrentAsset());
}
}
const AZ::Data::AssetInfo& Scanner::GetCurrentAsset() const
{
return m_result.m_catalogAssets[m_catalogAssetIndex];
}
const ScanResult& Scanner::GetResult() const
{
return m_result;
}
AZ::Data::Asset<AZ::Data::AssetData> Scanner::LoadAsset()
SourceHandle Scanner::LoadAsset()
{
AZ::Data::Asset<AZ::Data::AssetData> asset = AZ::Data::AssetManager::Instance().GetAsset
( GetCurrentAsset().m_assetId
, azrtti_typeid<ScriptCanvasAsset>()
, AZ::Data::AssetLoadBehavior::PreLoad);
asset.BlockUntilLoadComplete();
if (asset.IsReady())
auto fileOutcome = LoadFromFile(ModCurrentAsset().Path().c_str());
if (fileOutcome.IsSuccess())
{
return asset;
return fileOutcome.GetValue();
}
else
{
@@ -79,6 +113,11 @@ namespace ScriptCanvasEditor
}
}
SourceHandle& Scanner::ModCurrentAsset()
{
return m_result.m_catalogAssets[m_catalogAssetIndex];
}
void Scanner::OnSystemTick()
{
if (m_catalogAssetIndex == m_result.m_catalogAssets.size())
@@ -93,19 +132,19 @@ namespace ScriptCanvasEditor
}
else
{
if (auto asset = LoadAsset())
if (auto asset = LoadAsset(); asset.IsGraphValid())
{
VE_LOG("Scanner: Loaded: %s ", GetCurrentAsset().m_relativePath.c_str());
VE_LOG("Scanner: Loaded: %s ", ModCurrentAsset().Path().c_str());
FilterAsset(asset);
}
else
{
VE_LOG("Scanner: Failed to load: %s ", GetCurrentAsset().m_relativePath.c_str());
m_result.m_loadErrors.push_back(GetCurrentAsset());
ModelNotificationsBus::Broadcast(&ModelNotificationsTraits::OnScanLoadFailure, GetCurrentAsset());
VE_LOG("Scanner: Failed to load: %s ", ModCurrentAsset().Path().c_str());
m_result.m_loadErrors.push_back(ModCurrentAsset().Describe());
ModelNotificationsBus::Broadcast(&ModelNotificationsTraits::OnScanLoadFailure, ModCurrentAsset());
}
VE_LOG("Scanner: scan of %s complete", GetCurrentAsset().m_relativePath.c_str());
VE_LOG("Scanner: scan of %s complete", ModCurrentAsset().Path().c_str());
++m_catalogAssetIndex;
}
}
Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/Scanner.h
+3 -3
View File
@@ -33,9 +33,9 @@ namespace ScriptCanvasEditor
ScanConfiguration m_config;
ScanResult m_result;
void FilterAsset(AZ::Data::Asset<AZ::Data::AssetData>);
const AZ::Data::AssetInfo& GetCurrentAsset() const;
AZ::Data::Asset<AZ::Data::AssetData> LoadAsset();
void FilterAsset(SourceHandle);
SourceHandle LoadAsset();
SourceHandle& ModCurrentAsset();
void OnSystemTick() override;
};
}
Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/UpgradeHelper.cpp
+10 -11
View File
@@ -55,26 +55,25 @@ namespace ScriptCanvasEditor
for (auto& failedUpdate : result->m_failures)
{
auto& assetInfo = failedUpdate.assetInfo;
auto assetId = assetInfo.m_assetId;
auto asset = failedUpdate.asset;
m_ui->tableWidget->insertRow(rows);
connect(m_ui->closeButton, &QPushButton::pressed, this, &QDialog::accept);
connect(m_ui->tableWidget, &QTableWidget::itemDoubleClicked, this, [this, rows, assetId](QTableWidgetItem* item)
connect(m_ui->tableWidget, &QTableWidget::itemDoubleClicked, this, [this, rows, asset](QTableWidgetItem* item)
{
if (item && item->data(Qt::UserRole).toInt() == rows)
{
OpenGraph(assetId);
OpenGraph(asset);
}
}
);
auto openGraph = [this, assetId] {
OpenGraph(assetId);
auto openGraph = [this, asset] {
OpenGraph(asset);
};
QTableWidgetItem* rowName = new QTableWidgetItem(tr(assetInfo.m_relativePath.c_str()));
QTableWidgetItem* rowName = new QTableWidgetItem(tr(asset.Path().c_str()));
rowName->setData(Qt::UserRole, rows);
m_ui->tableWidget->setItem(rows, 0, rowName);
@@ -91,15 +90,15 @@ namespace ScriptCanvasEditor
}
}
void UpgradeHelper::OpenGraph(AZ::Data::AssetId assetId)
void UpgradeHelper::OpenGraph(const SourceHandle& asset)
{
// Open the graph in SC editor
AzToolsFramework::OpenViewPane(/*LyViewPane::ScriptCanvas*/"Script Canvas");
AZ::Outcome<int, AZStd::string> openOutcome = AZ::Failure(AZStd::string());
if (assetId.IsValid())
if (!asset.Path().empty())
{
GeneralRequestBus::BroadcastResult(openOutcome, &GeneralRequests::OpenScriptCanvasAsset, assetId, -1);
GeneralRequestBus::BroadcastResult(openOutcome, &GeneralRequests::OpenScriptCanvasAsset, asset, Tracker::ScriptCanvasFileState::UNMODIFIED, -1);
}
if (!openOutcome)
Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/UpgradeHelper.h
+3 -1
View File
@@ -35,6 +35,8 @@ namespace Ui
namespace ScriptCanvasEditor
{
// class SourceHandle;
//! A tool that collects and upgrades all Script Canvas graphs in the asset catalog
class UpgradeHelper
: public AzQtComponents::StyledDialog
@@ -51,6 +53,6 @@ namespace ScriptCanvasEditor
AZStd::unique_ptr<Ui::UpgradeHelper> m_ui;
void OpenGraph(AZ::Data::AssetId assetId);
void OpenGraph(const SourceHandle& assetId);
};
}