Initial commit

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Assets/Functions/ScriptCanvasFunctionAssetHandler.h

@@ -0,0 +1,76 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Asset/AssetManager.h>
+#include <AzCore/Asset/AssetTypeInfoBus.h>
+#include <AzCore/Serialization/ObjectStream.h>
+#include <ScriptCanvas/Asset/AssetDescription.h>
+#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
+#include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
+
+namespace ScriptCanvas 
+{ 
+    class ScriptCanvasFunctionAsset; 
+}
+
+namespace AZ
+{
+    class SerializeContext;
+}
+
+namespace ScriptCanvasEditor
+{
+    /**
+    * Manages editor Script Canvas graph assets.
+    */
+    class ScriptCanvasFunctionAssetHandler
+        : public ScriptCanvasAssetHandler
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(ScriptCanvasFunctionAssetHandler, AZ::SystemAllocator, 0);
+        AZ_RTTI(ScriptCanvasFunctionAssetHandler, "{CE1EB0B7-D8DA-4B9B-858B-A34DF5092BC2}", ScriptCanvasAssetHandler);
+
+        ScriptCanvasFunctionAssetHandler(AZ::SerializeContext* context = nullptr);
+        ~ScriptCanvasFunctionAssetHandler();
+
+        AZ::Data::AssetPtr CreateAsset(const AZ::Data::AssetId& id, const AZ::Data::AssetType& type) override;
+        AZ::Data::AssetHandler::LoadResult LoadAssetData(
+            const AZ::Data::Asset<AZ::Data::AssetData>& asset,
+            AZStd::shared_ptr<AZ::Data::AssetDataStream> stream,
+            const AZ::Data::AssetFilterCB& assetLoadFilterCB) override;
+        bool SaveAssetData(const AZ::Data::Asset<AZ::Data::AssetData>& asset, AZ::IO::GenericStream* stream) override;
+
+        bool SaveAssetData(const ScriptCanvas::ScriptCanvasFunctionAsset* assetData, AZ::IO::GenericStream* stream);
+
+        bool SaveAssetData(const ScriptCanvas::ScriptCanvasFunctionAsset* assetData, AZ::IO::GenericStream* stream, AZ::DataStream::StreamType streamType);
+
+        // Called by asset database on registration.
+        void GetAssetTypeExtensions(AZStd::vector<AZStd::string>& extensions) override;
+        void GetHandledAssetTypes(AZStd::vector<AZ::Data::AssetType>& assetTypes) override;
+
+        // Provides editor with information about script canvas graph assets.
+        AZ::Data::AssetType GetAssetType() const override;
+        const char* GetAssetTypeDisplayName() const override;
+
+        bool CanCreateComponent(const AZ::Data::AssetId& assetId) const override;
+
+        const char* GetGroup() const override;
+        const char* GetBrowserIcon() const override;
+
+        static AZ::Data::AssetType GetAssetTypeStatic();
+
+        ScriptCanvas::ScriptCanvasFunctionAsset* m_scriptCanvasAsset;
+
+    };
+} // namespace ScriptCanvasEditor

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Assets/ScriptCanvasAsset.h

@@ -0,0 +1,92 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Asset/AssetCommon.h>
+#include <ScriptCanvas/Asset/AssetDescription.h>
+#include <ScriptCanvas/Assets/ScriptCanvasAssetBus.h>
+#include <ScriptCanvas/Assets/ScriptCanvasBaseAssetData.h>
+
+#include <ScriptCanvas/Asset/ScriptCanvasAssetBase.h>
+
+namespace AZ
+{
+    class Entity;
+}
+
+namespace ScriptCanvas
+{
+    class Graph;
+}
+
+namespace ScriptCanvasEditor
+{
+    class Graph;
+    class ScriptCanvasAsset;
+
+    class ScriptCanvasAssetDescription : public ScriptCanvas::AssetDescription
+    {
+    public:
+
+        AZ_TYPE_INFO(ScriptCanvasAssetDescription, "{3678E33E-521B-4CAC-9DC1-42566AC71249}");
+
+        ScriptCanvasAssetDescription()
+            : ScriptCanvas::AssetDescription(
+                azrtti_typeid<ScriptCanvasAsset>(),
+                "Script Canvas",
+                "Script Canvas Graph Asset",
+                "@devassets@/scriptcanvas",
+                ".scriptcanvas",
+                "Script Canvas",
+                "Untitled-%i",
+                "Script Canvas Files (*.scriptcanvas)",
+                "Script Canvas",
+                "Script Canvas",
+                "Editor/Icons/ScriptCanvas/Viewport/ScriptCanvas.png",
+                AZ::Color(0.321f, 0.302f, 0.164f, 1.0f),
+                true
+            )
+        {}
+    };
+
+    class ScriptCanvasAsset
+        : public ScriptCanvas::ScriptCanvasAssetBase
+    {
+
+    public:
+        AZ_RTTI(ScriptCanvasAsset, "{FA10C3DA-0717-4B72-8944-CD67D13DFA2B}", ScriptCanvas::ScriptCanvasAssetBase);
+        AZ_CLASS_ALLOCATOR(ScriptCanvasAsset, AZ::SystemAllocator, 0);
+
+        ScriptCanvasAsset(const AZ::Data::AssetId& assetId = AZ::Data::AssetId(AZ::Uuid::CreateRandom()),
+            AZ::Data::AssetData::AssetStatus status = AZ::Data::AssetData::AssetStatus::NotLoaded)
+            : ScriptCanvas::ScriptCanvasAssetBase(assetId, status)
+        {
+            m_data = aznew ScriptCanvas::ScriptCanvasData();
+        }
+        ~ScriptCanvasAsset() override
+        {
+        }
+
+        ScriptCanvas::AssetDescription GetAssetDescription() const override
+        {
+            return ScriptCanvasAssetDescription();
+        }
+       
+        ScriptCanvas::Graph* GetScriptCanvasGraph() const;
+        using Description = ScriptCanvasAssetDescription;
+
+        ScriptCanvas::ScriptCanvasData& GetScriptCanvasData();
+        const ScriptCanvas::ScriptCanvasData& GetScriptCanvasData() const;
+
+    };
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Assets/ScriptCanvasAssetBus.h

@@ -0,0 +1,35 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+namespace ScriptCanvas
+{
+
+    class ScriptCanvasAssetBusRequests : public AZ::EBusTraits
+    {
+    public:
+
+        using BusIdType = AZ::Data::AssetId;
+        using MutexType = AZStd::recursive_mutex;
+
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+
+        virtual void SetAsNewAsset() = 0;
+
+    };
+
+    using ScriptCanvasAssetBusRequestBus = AZ::EBus<ScriptCanvasAssetBusRequests>;
+
+
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Assets/ScriptCanvasAssetHandler.h

@@ -0,0 +1,80 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Asset/AssetManager.h>
+#include <AzCore/Asset/AssetTypeInfoBus.h>
+#include <AzCore/Serialization/ObjectStream.h>
+#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
+
+namespace AZ
+{
+    class SerializeContext;
+}
+
+namespace ScriptCanvasEditor
+{
+    /**
+    * Manages editor Script Canvas graph assets.
+    */
+    class ScriptCanvasAssetHandler
+        : public AZ::Data::AssetHandler
+        , protected AZ::AssetTypeInfoBus::MultiHandler
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(ScriptCanvasAssetHandler, AZ::SystemAllocator, 0);
+        AZ_RTTI(ScriptCanvasAssetHandler, "{098B86B2-2527-4155-84C9-A698A0D20068}", AZ::Data::AssetHandler);
+
+        ScriptCanvasAssetHandler(AZ::SerializeContext* context = nullptr);
+        ~ScriptCanvasAssetHandler();
+
+        // Called by the asset database to create a new asset.
+        AZ::Data::AssetPtr CreateAsset(const AZ::Data::AssetId& id, const AZ::Data::AssetType& type) override;
+
+        // Override the stream info to force source assets to load into the Editor instead of cached, processed assets.
+        void GetCustomAssetStreamInfoForLoad(AZ::Data::AssetStreamInfo& streamInfo) override;
+
+        // Called by the asset database to perform actual asset load.
+        AZ::Data::AssetHandler::LoadResult LoadAssetData(
+            const AZ::Data::Asset<AZ::Data::AssetData>& asset,
+            AZStd::shared_ptr<AZ::Data::AssetDataStream> stream,
+            const AZ::Data::AssetFilterCB& assetLoadFilterCB) override;
+
+        // Called by the asset database to perform actual asset save. Returns true if successful otherwise false (default - as we don't require support save).
+        bool SaveAssetData(const AZ::Data::Asset<AZ::Data::AssetData>& asset, AZ::IO::GenericStream* stream) override;
+        bool SaveAssetData(const ScriptCanvasAsset* assetData, AZ::IO::GenericStream* stream);
+        bool SaveAssetData(const ScriptCanvasAsset* assetData, AZ::IO::GenericStream* stream  , AZ::DataStream::StreamType streamType);
+
+        // Called by the asset database when an asset should be deleted.
+        void DestroyAsset(AZ::Data::AssetPtr ptr) override;
+
+        // Called by asset database on registration.
+        void GetHandledAssetTypes(AZStd::vector<AZ::Data::AssetType>& assetTypes) override;
+
+        // Provides editor with information about script canvas graph assets.
+        AZ::Data::AssetType GetAssetType() const override;
+        const char* GetAssetTypeDisplayName() const override;
+        void GetAssetTypeExtensions(AZStd::vector<AZStd::string>& extensions) override;
+
+        AZ::Uuid GetComponentTypeId() const override;
+
+        AZ::SerializeContext* GetSerializeContext() const;
+
+        void SetSerializeContext(AZ::SerializeContext* context);
+
+        static AZ::Data::AssetType GetAssetTypeStatic();
+
+    protected:
+        AZ::SerializeContext* m_serializeContext;
+    };
+} // namespace ScriptCanvasEditor

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Assets/ScriptCanvasAssetTypes.h

@@ -0,0 +1,18 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+namespace ScriptCanvasEditor
+{
+
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Assets/ScriptCanvasBaseAssetData.h

@@ -0,0 +1,39 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <ScriptCanvas/Variable/VariableData.h>
+#include <ScriptCanvas/Core/GraphData.h>
+
+namespace ScriptCanvas
+{
+    class ScriptCanvasData
+    {
+    public:
+
+        AZ_RTTI(ScriptCanvasData, "{1072E894-0C67-4091-8B64-F7DB324AD13C}");
+        AZ_CLASS_ALLOCATOR(ScriptCanvasData, AZ::SystemAllocator, 0);
+        ScriptCanvasData() {}
+        virtual ~ScriptCanvasData() {}
+        ScriptCanvasData(ScriptCanvasData&& other);
+        ScriptCanvasData& operator=(ScriptCanvasData&& other);
+
+        static void Reflect(AZ::ReflectContext* reflectContext);
+
+        AZ::Entity* GetScriptCanvasEntity() const { return m_scriptCanvasEntity.get(); }
+
+        AZStd::unique_ptr<AZ::Entity> m_scriptCanvasEntity;
+    private:
+        ScriptCanvasData(const ScriptCanvasData&) = delete;
+    };
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/DocumentContextBus.h

@@ -0,0 +1,112 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+#include <AzCore/EBus/EBus.h>
+#include <AzCore/Asset/AssetCommon.h>
+#include <AzCore/Outcome/Outcome.h>
+#include <AzCore/std/string/string_view.h>
+
+#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
+
+namespace AZ
+{
+    namespace Data
+    {
+        class AssetInfo;
+    }
+}
+
+namespace ScriptCanvasEditor
+{
+    enum class ScriptCanvasFileState : AZ::s32
+    {
+        NEW,
+        MODIFIED,
+        UNMODIFIED,
+        INVALID = -1
+    };
+
+    struct ScriptCanvasAssetFileInfo
+    {
+        AZ_TYPE_INFO(ScriptCanvasAssetFileInfo, "{81F6B390-7CF3-4A97-B5A6-EC09330F184E}");
+        AZ_CLASS_ALLOCATOR(ScriptCanvasAssetFileInfo, AZ::SystemAllocator, 0);
+        ScriptCanvasFileState m_fileModificationState = ScriptCanvasFileState::INVALID;
+        bool m_reloadable = false;
+        AZStd::string m_absolutePath;
+    };
+
+    //! Bus for handling transactions involving ScriptCanvas Assets, such as graph Saving, graph modification state, etc
+    class DocumentContextRequests
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+
+        //! Creates a new ScriptCanvas asset and registers it with the document context
+        virtual AZ::Data::Asset<ScriptCanvasAsset> CreateScriptCanvasAsset(AZStd::string_view relativeAssetPath) = 0;
+
+        using SaveCB = AZStd::function<void(bool saveSuccess)>;
+        // !Callback will fire when a new in-memory Script Canvas asset is saved to disk for the first time and a new AssetId is generated for it
+        using SourceFileChangedCB = AZStd::function<void(AZStd::string relPath, AZStd::string scanFolder, const AZ::Data::AssetId& newAssetId)>;
+        //! Saves a ScriptCanvas asset using the supplied AssetPath structure
+        //! \param assetAbsolutePath path where ScriptCanvas asset will be saved on disk
+        virtual void SaveScriptCanvasAsset(AZStd::string_view/*assetAbsolutePath*/, AZ::Data::Asset<ScriptCanvasAsset>, const SaveCB&, const SourceFileChangedCB&) = 0;
+
+        //! Loads a ScriptCanvas asset by looking up the assetPath in the AssetCatalog
+        //! \param assetPath filepath to asset that will be looked up in the AssetCatalog for the AssetId
+        //! \param loadBlocking should the loading of the ScriptCanvas asset be blocking
+        virtual AZ::Data::Asset<ScriptCanvasAsset> LoadScriptCanvasAsset(const char* assetPath, bool loadBlocking) = 0;
+        virtual AZ::Data::Asset<ScriptCanvasAsset> LoadScriptCanvasAssetById(const AZ::Data::AssetId& assetId, bool loadBlocking) = 0;
+
+        //! Registers a ScriptCanvas assetId with the DocumentContext for lookup. ScriptCanvasAssetFileInfo will be associated with the ScriptCanvasAsset
+        //! \return true if the assetId is newly registered, false if the assetId is already registered
+        virtual bool RegisterScriptCanvasAsset(const AZ::Data::AssetId& assetId, const ScriptCanvasAssetFileInfo& assetFileInfo) = 0;
+
+        //! Unregisters a ScriptCanvas assetId with the DocumentContext for lookup
+        //! \return true if assetId was registered with the DocumentContext, false otherwise
+        virtual bool UnregisterScriptCanvasAsset(const AZ::Data::AssetId& assetId) = 0;
+
+        virtual ScriptCanvasFileState GetScriptCanvasAssetModificationState(const AZ::Data::AssetId& assetId) = 0;
+        virtual void SetScriptCanvasAssetModificationState(const AZ::Data::AssetId& assetId, ScriptCanvasFileState) = 0;
+
+        //! Retrieves the file information for the registered ScriptCanvas asset
+        virtual AZ::Outcome<ScriptCanvasAssetFileInfo, AZStd::string> GetFileInfo(const AZ::Data::AssetId& assetId) const = 0;
+        virtual AZ::Outcome<void, AZStd::string> SetFileInfo(const AZ::Data::AssetId& assetId, const ScriptCanvasAssetFileInfo& fileInfo) = 0;
+    };
+
+    using DocumentContextRequestBus = AZ::EBus<DocumentContextRequests>;
+
+    class DocumentContextNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::Data::AssetId;
+
+        virtual void OnAssetModificationStateChanged(ScriptCanvasFileState) {}
+
+        //! Notification which fires after an ScriptCanvasDocumentContext has received it's on AssetReady callback
+        //! \param scriptCanvasAsset Script Canvas asset which is now ready for use in the Editor
+        virtual void OnScriptCanvasAssetReady(const AZ::Data::Asset<ScriptCanvasAsset>& /*scriptCanvasAsset*/) {}
+
+        //! Notification which fires after an ScriptCanvasDocumentContext has received it's on AssetReloaded callback
+        //! \param scriptCanvasAsset Script Canvas asset which is now ready for use in the Editor
+        virtual void OnScriptCanvasAssetReloaded(const AZ::Data::Asset<ScriptCanvasAsset>& /*scriptCanvaAsset */) {}
+
+        //! Notification which fires after an ScriptCanvasDocumentContext has received it's on AssetReady callback
+        //! \param AssetId AssetId of unloaded ScriptCanvas
+        virtual void OnScriptCanvasAssetUnloaded(const AZ::Data::AssetId& /*assetId*/) {}
+    };
+
+    using DocumentContextNotificationBus = AZ::EBus<DocumentContextNotifications>;
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/EditorSceneVariableManagerBus.h

@@ -0,0 +1,37 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <QAbstractItemModel>
+
+#include <AzCore/EBus/EBus.h>
+#include <AzCore/std/string/string.h>
+#include <AzCore/Outcome/Outcome.h>
+
+namespace ScriptCanvasEditor
+{
+    class EditorSceneVariableManagerRequests
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = ScriptCanvas::ScriptCanvasId;
+        
+        // The QCompleter needs this to be non-const for some reason. Shouldn't
+        // matter since we should only have have a single instance operating on it at once.
+        virtual QAbstractItemModel* GetVariableItemModel() = 0;
+    };
+
+    using EditorSceneVariableManagerRequestBus = AZ::EBus<EditorSceneVariableManagerRequests>;
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/EditorScriptCanvasBus.h

@@ -0,0 +1,221 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+#include <AzCore/Component/Entity.h>
+#include <AzCore/std/string/string.h>
+#include <AzCore/Asset/AssetCommon.h>
+#include <AzCore/Asset/AssetSerializer.h>
+#include <AzCore/Component/Entity.h>
+#include <AzCore/Math/Uuid.h>
+#include <AzCore/Math/Vector2.h>
+
+#include <GraphCanvas/Editor/EditorTypes.h>
+#include <GraphCanvas/Types/EntitySaveData.h>
+
+#include <Editor/Include/ScriptCanvas/Assets/ScriptCanvasAsset.h>
+#include <Editor/Include/ScriptCanvas/Bus/NodeIdPair.h>
+#include <ScriptCanvas/Core/ExecutionNotificationsBus.h>
+#include <ScriptCanvas/Variable/VariableCore.h>
+
+namespace GraphCanvas
+{
+    class GraphCanvasTreeItem;
+}
+
+namespace ScriptCanvasEditor
+{
+    //=========================================================================
+    // EditorGraphBus
+    //=========================================================================
+    class EditorScriptCanvasRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = ScriptCanvas::ScriptCanvasId;
+
+
+        //! Sets the name of the ScriptCanvas Graph.
+        //! \param name value to set
+        virtual void SetName(const AZStd::string& name) = 0;
+
+        //! Gets the name of the ScriptCanvas Graph.
+        //! \return reference to Graph name
+        virtual const AZStd::string& GetName() const = 0;
+
+        //! Will open the graph in the editor.
+        virtual void OpenEditor() = 0;
+
+        //! Used to close a graph that is currently opened in the editor.
+        virtual void CloseGraph() = 0;
+
+        //! Returns the Entity ID of the Editor Entity that owns this graph.
+        virtual AZ::EntityId GetEditorEntityId() const = 0;
+        virtual AZ::NamedEntityId GetNamedEditorEntityId() const = 0;
+    };
+
+    using EditorScriptCanvasRequestBus = AZ::EBus<EditorScriptCanvasRequests>;
+
+    class EditorScriptCanvasComponentRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+
+        virtual void SetAssetId(const AZ::Data::AssetId& assetId) = 0;
+        virtual bool HasAssetId() const = 0;
+    };
+
+    using EditorScriptCanvasComponentRequestBus = AZ::EBus<EditorScriptCanvasComponentRequests>;
+
+    // Above bus is keyed off of the graph Id. Which I don't really have access to.
+    // This bus is here just so I can tell it to open the Editor.
+    class EditorContextMenuRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+
+        //! Gets the GraphId for the EditorScriptCanvasComponent on the given entity.
+        virtual AZ::Data::AssetId GetAssetId() const = 0;
+    };
+
+    using EditorContextMenuRequestBus = AZ::EBus<EditorContextMenuRequests>;
+
+    class EditorScriptCanvasAssetNotifications : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::Data::AssetId;
+
+        //! Notification which fires after an EditorGraph has received it's on AssetReady callback
+        //! \param scriptCanvasAsset Script Canvas asset which is now ready for use in the Editor
+        virtual void OnScriptCanvasAssetReady(const AZ::Data::Asset<ScriptCanvas::ScriptCanvasAssetBase>& /*scriptCanvasAsset*/) {};
+
+        //! Notification which fires after an EditorGraph has received it's on AssetReloaded callback
+        //! \param scriptCanvasAsset Script Canvas asset which is now ready for use in the Editor
+        virtual void OnScriptCanvasAssetReloaded(const AZ::Data::Asset<ScriptCanvas::ScriptCanvasAssetBase>& /*scriptCanvaAsset */) {};
+
+        //! Notification which fires after an EditorGraph has received it's on AssetReady callback
+        //! \param AssetId AssetId of unloaded ScriptCanvas
+        virtual void OnScriptCanvasAssetUnloaded(const AZ::Data::AssetId& /*assetId*/) {};
+
+        //! Notification which fires after an EditorGraph has received an onAssetSaved callback
+        //! \param scriptCanvasAsset Script Canvas asset which was attempted to be saved
+        //! \param isSuccessful specified where the Script Canvas asset was successfully saved
+        virtual void OnScriptCanvasAssetSaved(const AZ::Data::AssetId) {};
+    };
+    using EditorScriptCanvasAssetNotificationBus = AZ::EBus<EditorScriptCanvasAssetNotifications>;
+    
+    class EditorGraphRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = ScriptCanvas::ScriptCanvasId;
+
+        virtual void SetAssetId(const AZ::Data::AssetId& assetId) = 0;
+
+        virtual void CreateGraphCanvasScene() = 0;
+        virtual void ClearGraphCanvasScene() = 0;
+        virtual GraphCanvas::GraphId GetGraphCanvasGraphId() const = 0;
+
+        virtual void DisplayGraphCanvasScene() = 0;
+
+        virtual void OnGraphCanvasSceneVisible() = 0;
+
+        virtual void UpdateGraphCanvasSaveData(const AZStd::unordered_map< AZ::EntityId, GraphCanvas::EntitySaveDataContainer* >& saveData) = 0;
+        virtual AZStd::unordered_map< AZ::EntityId, GraphCanvas::EntitySaveDataContainer* > GetGraphCanvasSaveData() = 0;
+
+        virtual NodeIdPair CreateCustomNode(const AZ::Uuid& typeId, const AZ::Vector2& position) = 0;
+
+        virtual void AddCrcCache(const AZ::Crc32& crcValue, const AZStd::string& cacheString) = 0;
+        virtual void RemoveCrcCache(const AZ::Crc32& crcValue) = 0;
+        virtual AZStd::string DecodeCrc(const AZ::Crc32& crcValue) = 0;
+
+        virtual void ClearHighlights() = 0;
+        virtual void HighlightMembersFromTreeItem(const GraphCanvas::GraphCanvasTreeItem* treeItem) = 0;
+        virtual void HighlightVariables(const AZStd::unordered_set< ScriptCanvas::VariableId>& variableIds) = 0;
+        virtual void HighlightNodes(const AZStd::vector<NodeIdPair>& nodes) = 0;
+
+        virtual AZStd::vector<NodeIdPair> GetNodesOfType(const ScriptCanvas::NodeTypeIdentifier&) = 0;
+        virtual AZStd::vector<NodeIdPair> GetVariableNodes(const ScriptCanvas::VariableId&) = 0;        
+
+        virtual void RemoveUnusedVariables() = 0;
+
+        virtual bool ConvertVariableNodeToReference(const GraphCanvas::NodeId& nodeId) = 0;
+        virtual bool ConvertReferenceToVariableNode(const GraphCanvas::Endpoint& endpoint) = 0;
+
+        virtual void QueueVersionUpdate(const AZ::EntityId& graphCanvasNodeId) = 0;
+
+        virtual bool IsRuntimeGraph() const = 0;
+        virtual bool IsFunctionGraph() const = 0;
+
+        virtual ScriptCanvas::Endpoint ConvertToScriptCanvasEndpoint(const GraphCanvas::Endpoint& endpoinnt) const = 0;
+        virtual GraphCanvas::Endpoint ConvertToGraphCanvasEndpoint(const ScriptCanvas::Endpoint& endpoint) const = 0;
+    };
+    
+    using EditorGraphRequestBus = AZ::EBus<EditorGraphRequests>;
+
+    class EditorGraphNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = ScriptCanvas::ScriptCanvasId;
+
+        virtual void OnGraphCanvasSceneDisplayed() {};
+    };
+
+    using EditorGraphNotificationBus = AZ::EBus<EditorGraphNotifications>;
+
+    class EditorNodeNotifications : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+
+        virtual void OnGraphCanvasNodeDisplayed(AZ::EntityId /*graphCanvasNodeId*/) {}
+
+        virtual void OnVersionConversionBegin() {};
+        virtual void OnVersionConversionEnd() {};
+    };
+
+    using EditorNodeNotificationBus = AZ::EBus<EditorNodeNotifications>;
+
+    // Mainly expected to be used from an aggregator.
+    class EditorScriptCanvasComponentLogging 
+        : public AZ::ComponentBus
+    {
+    public:
+        
+        virtual AZ::NamedEntityId FindNamedEntityId() const = 0;
+        virtual ScriptCanvas::GraphIdentifier GetGraphIdentifier() const = 0;
+    };
+
+    using EditorScriptCanvasComponentLoggingBus = AZ::EBus<EditorScriptCanvasComponentLogging>;
+
+    class EditorLoggingComponentNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
+
+        virtual void OnEditorScriptCanvasComponentActivated(const AZ::NamedEntityId& namedEntityId, const ScriptCanvas::GraphIdentifier& graphIdentifier) = 0;
+        virtual void OnEditorScriptCanvasComponentDeactivated(const AZ::NamedEntityId& namedEntityId, const ScriptCanvas::GraphIdentifier& graphIdentifier) = 0;
+        virtual void OnAssetSwitched(const AZ::NamedEntityId& namedEntityId, const ScriptCanvas::GraphIdentifier& newGraphIdentifier, const ScriptCanvas::GraphIdentifier& oldGraphIdentifier) = 0;
+    };
+
+    using EditorLoggingComponentNotificationBus = AZ::EBus<EditorLoggingComponentNotifications>;
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/GraphBus.h

@@ -0,0 +1,31 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+
+#include <ScriptCanvas/Core/Core.h>
+
+
+namespace ScriptCanvasEditor
+{   
+    class GeneralGraphEvents : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+
+        virtual void OnBuildGameEntity([[maybe_unused]] const AZStd::string& name, [[maybe_unused]] const AZ::EntityId& editGraphId, [[maybe_unused]] const ScriptCanvas::ScriptCanvasId& scriptCanvasId) {}
+    };
+
+    using GeneralGraphEventBus = AZ::EBus<GeneralGraphEvents>;
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/IconBus.h

@@ -0,0 +1,33 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+
+#include <AzCore/Component/EntityId.h>
+#include <AzCore/std/string/string.h>
+
+namespace ScriptCanvasEditor
+{
+    class IconRequests
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+        
+        virtual AZStd::string GetIconPath() const = 0;
+    };
+    
+    using IconBus = AZ::EBus<IconRequests>;
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/NodeIdPair.h

@@ -0,0 +1,29 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Component/EntityId.h>
+
+namespace ScriptCanvasEditor
+{
+    struct NodeIdPair
+    {
+        AZ::EntityId m_graphCanvasId;
+        AZ::EntityId m_scriptCanvasId;
+
+        NodeIdPair()
+            : m_graphCanvasId(AZ::EntityId::InvalidEntityId)
+            , m_scriptCanvasId(AZ::EntityId::InvalidEntityId)
+        {}
+    };
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/RequestBus.h

@@ -0,0 +1,238 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+#include <AzCore/Component/EntityId.h>
+#include <AzCore/Component/Entity.h>
+#include <AzCore/Asset/AssetCommon.h>
+#include <AzCore/Outcome/Outcome.h>
+#include <AzCore/Math/Vector2.h>
+
+#include <GraphCanvas/Types/Types.h>
+
+#include <ScriptCanvas/Bus/ScriptCanvasBus.h>
+#include <ScriptCanvas/Bus/NodeIdPair.h>
+
+#include <ScriptCanvas/Data/Data.h>
+
+namespace GraphCanvas
+{
+    struct Endpoint;
+
+    class GraphCanvasMimeEvent;
+    class GraphCanvasTreeItem;
+}
+
+namespace ScriptCanvas
+{
+    class ScriptCanvasAssetBase;
+}
+
+namespace ScriptCanvasEditor
+{
+    struct CategoryInformation;
+    struct NodePaletteModelInformation;
+
+
+    namespace Widget
+    {
+        struct GraphTabMetadata;
+    }
+
+    namespace TypeDefs
+    {
+        typedef AZStd::pair<AZ::EntityId, AZ::ComponentId> EntityComponentId;
+    }
+
+    class GeneralRequests
+        : public AZ::EBusTraits
+    {
+    public:
+
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+
+        //! Opens an existing graph and returns the tab index in which it was open in.
+        //! \param File AssetId
+        //! \return index of open tab if the asset was able to be open successfully or error message of why the open failed
+        virtual AZ::Outcome<int, AZStd::string> OpenScriptCanvasAsset(AZ::Data::AssetId scriptCanvasAssetId, int tabIndex = -1) = 0;
+        virtual AZ::Outcome<int, AZStd::string> OpenScriptCanvasAssetId(const AZ::Data::AssetId& scriptCanvasAsset) = 0;        
+        
+        virtual int CloseScriptCanvasAsset(const AZ::Data::AssetId&) = 0;
+
+        virtual bool CreateScriptCanvasAssetFor(const TypeDefs::EntityComponentId& requestingComponent) = 0;
+
+        virtual bool IsScriptCanvasAssetOpen(const AZ::Data::AssetId& assetId) const = 0;
+
+        virtual void OnChangeActiveGraphTab(AZ::Data::AssetId) {}
+
+        virtual void CreateNewFunctionAsset() = 0;
+        virtual void CreateNewRuntimeAsset() = 0;
+
+        virtual ScriptCanvas::ScriptCanvasId GetActiveScriptCanvasId() const
+        {
+            return ScriptCanvas::ScriptCanvasId();
+        }
+
+        virtual GraphCanvas::GraphId GetActiveGraphCanvasGraphId() const
+        {
+            return GraphCanvas::GraphId();
+        }
+
+        virtual GraphCanvas::GraphId GetGraphCanvasGraphId([[maybe_unused]] const ScriptCanvas::ScriptCanvasId& scriptCanvasEntityId) const
+        {
+            return GraphCanvas::GraphId();
+        }
+
+        virtual ScriptCanvas::ScriptCanvasId GetScriptCanvasId([[maybe_unused]] const GraphCanvas::GraphId& graphCanvasSceneId) const
+        {
+            return ScriptCanvas::ScriptCanvasId();
+        }
+
+        virtual GraphCanvas::GraphId FindGraphCanvasGraphIdByAssetId([[maybe_unused]] const AZ::Data::AssetId& assetId) const
+        {
+            return GraphCanvas::GraphId();
+        }
+
+        virtual ScriptCanvas::ScriptCanvasId FindScriptCanvasIdByAssetId([[maybe_unused]] const AZ::Data::AssetId& assetId) const
+        {
+            return ScriptCanvas::ScriptCanvasId();
+        }
+        
+        virtual bool IsInUndoRedo(const AZ::EntityId& graphCanvasGraphId) const = 0;
+        virtual bool IsScriptCanvasInUndoRedo(const ScriptCanvas::ScriptCanvasId& scriptCanvasId) const = 0;
+
+        virtual bool IsActiveGraphInUndoRedo() const = 0;
+
+        virtual void UpdateName(const AZ::EntityId& /*graphId*/, const AZStd::string& /*name*/) {}
+
+        virtual void DeleteNodes(const AZ::EntityId& /*sceneId*/, const AZStd::vector<AZ::EntityId>& /*nodes*/){}
+        virtual void DeleteConnections(const AZ::EntityId& /*sceneId*/, const AZStd::vector<AZ::EntityId>& /*connections*/){}
+
+        virtual void DisconnectEndpoints(const AZ::EntityId& /*sceneId*/, const AZStd::vector<GraphCanvas::Endpoint>& /*endpoints*/) {}
+
+        virtual void PostUndoPoint(ScriptCanvas::ScriptCanvasId) = 0;
+        virtual void SignalSceneDirty(AZ::Data::AssetId) = 0;
+
+        // Increment the value of the ignore undo point tracker
+        virtual void PushPreventUndoStateUpdate() = 0;
+        // Decrement the value of the ignore undo point tracker
+        virtual void PopPreventUndoStateUpdate() = 0;
+        // Sets the value of the ignore undo point tracker to 0.
+        // Therefore allowing undo points to be posted
+        virtual void ClearPreventUndoStateUpdate() = 0;
+
+        virtual void TriggerUndo() = 0;
+        virtual void TriggerRedo() = 0;
+
+        virtual const CategoryInformation* FindNodePaletteCategoryInformation(AZStd::string_view categoryPath) const = 0;
+        virtual const NodePaletteModelInformation* FindNodePaletteModelInformation(const ScriptCanvas::NodeTypeIdentifier& nodeType) const = 0;
+    };
+
+    using GeneralRequestBus = AZ::EBus<GeneralRequests>;
+
+    class GeneralEditorNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = ScriptCanvas::ScriptCanvasId;
+
+        virtual void OnUndoRedoBegin() {}
+        virtual void OnUndoRedoEnd() {}
+    };
+
+    using GeneralEditorNotificationBus = AZ::EBus<GeneralEditorNotifications>;
+
+    class GeneralAssetNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::Data::AssetId;
+
+        virtual void OnAssetVisualized() {};
+        virtual void OnAssetUnloaded() {};
+    };
+
+    using GeneralAssetNotificationBus = AZ::EBus<GeneralAssetNotifications>;
+
+    class NodeCreationNotifications : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = ScriptCanvas::ScriptCanvasId;
+
+        virtual void OnGraphCanvasNodeCreated(const AZ::EntityId& nodeId) = 0;
+    };
+
+    using NodeCreationNotificationBus = AZ::EBus<NodeCreationNotifications>;
+
+    class VariablePaletteRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+
+        virtual void RegisterVariableType(const ScriptCanvas::Data::Type& variabletype) = 0;
+    };
+
+    using VariablePaletteRequestBus = AZ::EBus<VariablePaletteRequests>;
+
+    class VariableAutomationRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+
+        virtual AZStd::vector< ScriptCanvas::Data::Type > GetPrimitiveTypes() const = 0;
+        virtual AZStd::vector< ScriptCanvas::Data::Type > GetBehaviorContextObjectTypes() const = 0;
+        virtual AZStd::vector< ScriptCanvas::Data::Type > GetMapTypes() const = 0;
+        virtual AZStd::vector< ScriptCanvas::Data::Type > GetArrayTypes() const = 0;
+
+        AZStd::vector< ScriptCanvas::Data::Type > GetVariableTypes() const
+        {
+            AZStd::vector< ScriptCanvas::Data::Type > dataTypes = GetPrimitiveTypes();
+
+            auto workingTypes = GetBehaviorContextObjectTypes();
+            dataTypes.insert(dataTypes.begin(), workingTypes.begin(), workingTypes.end());
+            workingTypes.clear();
+
+            workingTypes = GetMapTypes();
+            dataTypes.insert(dataTypes.begin(), workingTypes.begin(), workingTypes.end());
+            workingTypes.clear();
+
+            workingTypes = GetArrayTypes();
+            dataTypes.insert(dataTypes.begin(), workingTypes.begin(), workingTypes.end());
+            workingTypes.clear();
+
+            return dataTypes;
+        }
+    };
+
+    using VariableAutomationRequestBus = AZ::EBus<VariableAutomationRequests>;
+
+    class AutomationRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+
+        virtual NodeIdPair ProcessCreateNodeMimeEvent(GraphCanvas::GraphCanvasMimeEvent* mimeEvent, const AZ::EntityId& graphCanvasGraphId, AZ::Vector2 nodeCreationPos) = 0;
+        virtual const GraphCanvas::GraphCanvasTreeItem* GetNodePaletteRoot() const = 0;
+
+        virtual void SignalAutomationBegin() = 0;
+        virtual void SignalAutomationEnd() = 0;
+    };
+
+    using AutomationRequestBus = AZ::EBus<AutomationRequests>;
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/ScriptCanvasAssetNodeBus.h

@@ -0,0 +1,48 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+#include <AzCore/std/containers/vector.h>
+#include <GraphCanvas/Components/SceneBus.h>
+
+namespace AZ
+{
+    class Vector2;
+}
+
+namespace GraphCanvas
+{
+    class SceneSliceInstance;
+    class SceneSliceReference;
+    struct ExposedEndpointInfo;
+
+    //! SubSceneRequests
+    //! EBus for forwarding scene request for a node to the a contained sub scene
+    class SubSceneRequests
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+
+        //! Retrieves the SceneSlice reference of the sub scene
+        virtual SceneSliceReference* GetReference() = 0;
+        virtual const SceneSliceReference* GetReferenceConst() const = 0;
+
+        //! Retrieves the SceneSlice instance from the sub scene scene slice reference
+        virtual SceneSliceInstance* GetInstance() = 0;
+    };
+
+    using SubSceneRequestBus = AZ::EBus<SubSceneRequests>;
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/ScriptCanvasBus.h

@@ -0,0 +1,61 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+#include <AzCore/std/string/string.h>
+#include <AzCore/Serialization/SerializeContext.h>
+
+#include <ScriptCanvas/Data/Data.h>
+
+class QWidget;
+
+namespace ScriptCanvasEditor
+{
+    class SystemRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+
+        virtual void AddAsyncJob(AZStd::function<void()>&& jobFunc) = 0;
+
+        // Inserts into the supplied set types that are creatable within the editor
+        virtual void GetEditorCreatableTypes(AZStd::unordered_set<ScriptCanvas::Data::Type>& outCreatableTypes) = 0;
+
+        // Creates all editor components needed to associate the script canvas engine with an entity
+        virtual void CreateEditorComponentsOnEntity(AZ::Entity* entity, const AZ::Data::AssetType& assetType) = 0;
+    };
+
+    using SystemRequestBus = AZ::EBus<SystemRequests>;
+
+    class UIRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+
+        virtual QWidget* GetMainWindow() = 0;
+
+        virtual void OpenValidationPanel() = 0;
+    };
+
+    using UIRequestBus = AZ::EBus<UIRequests>;
+
+    class UINotifications : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+
+        virtual void MainWindowCreationEvent(QWidget* /*mainWindow*/) {};
+    };
+
+    using UINotificationBus = AZ::EBus<UINotifications>;
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/ScriptCanvasExecutionBus.h

@@ -0,0 +1,33 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+#include <AzCore/EBus/EBus.h>
+#include <Editor/Framework/ScriptCanvasReporter.h>
+#include <AzCore/std/string/string_view.h>
+
+namespace ScriptCanvasEditor
+{
+
+    /* ScriptCanvasExecutionRequests - Execute a ScriptCanvas script in the Editor */
+
+    class ScriptCanvasExecutionRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
+
+        virtual Reporter RunGraph(AZStd::string_view path) = 0;
+    };
+    using ScriptCanvasExecutionBus = AZ::EBus<ScriptCanvasExecutionRequests>;
+
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/UndoBus.h

@@ -0,0 +1,115 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+#include <AzCore/std/any.h>
+#include <AzCore/std/string/string_view.h>
+#include <AzToolsFramework/Undo/UndoSystem.h>
+
+#include <GraphCanvas/Types/EntitySaveData.h>
+#include <ScriptCanvas/Core/GraphData.h>
+#include <ScriptCanvas/Variable/VariableData.h>
+
+namespace ScriptCanvasEditor
+{
+    enum class UndoGraphCommand
+    {
+        ChangeItem,
+        AddItem,
+        RemoveItem
+    };
+
+    struct UndoData
+    {
+        AZ_TYPE_INFO(UndoData, "{12561F1F-2806-4BCB-BDC5-B2F2B568A139}");
+        AZ_CLASS_ALLOCATOR(UndoData, AZ::SystemAllocator, 0);
+        UndoData() = default;
+
+        static void Reflect(AZ::ReflectContext* reflectContext)
+        {
+            if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(reflectContext))
+            {
+                serializeContext->Class<UndoData>()
+                    ->Version(2)
+                    ->Field("m_graphData", &UndoData::m_graphData)
+                    ->Field("m_variableData", &UndoData::m_variableData)
+                    ->Field("m_visualSaveData",&UndoData::m_visualSaveData)
+                    ;
+            }
+        }
+
+        ScriptCanvas::GraphData             m_graphData;
+        ScriptCanvas::VariableData          m_variableData;
+        AZStd::unordered_map< AZ::EntityId, GraphCanvas::EntitySaveDataContainer* > m_visualSaveData;
+    };
+
+    class UndoCache;
+    class UndoRequests
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = ScriptCanvas::ScriptCanvasId;
+
+        virtual UndoCache* GetSceneUndoCache() = 0;
+        virtual UndoData CreateUndoData() = 0;
+
+        /*!
+        * Start batch undo so we can add multiple undo to one undo step.
+        */
+        virtual void BeginUndoBatch(AZStd::string_view label) = 0;
+
+        /*!
+        * End current undo batch and save it to undo stack.
+        */
+        virtual void EndUndoBatch() = 0;
+
+        /*!
+        * Add a undo to stack. it could be added directly to stack or added to the current batch.
+        */
+        virtual void AddUndo(AzToolsFramework::UndoSystem::URSequencePoint* seqPoint) = 0;
+
+        virtual void AddGraphItemChangeUndo(AZStd::string_view undoLabel) = 0;
+        virtual void AddGraphItemAdditionUndo(AZStd::string_view undoLabel) = 0;
+        virtual void AddGraphItemRemovalUndo(AZStd::string_view undoLabel)  = 0;
+
+        virtual void Undo() = 0;
+        virtual void Redo() = 0;
+        virtual void Reset() = 0;
+
+        virtual bool IsIdle() = 0;
+        virtual bool IsActive() = 0;
+
+        virtual bool CanUndo() const = 0;
+        virtual bool CanRedo() const = 0;
+    };
+    using UndoRequestBus = AZ::EBus<UndoRequests>;
+
+    class UndoNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+        //////////////////////////////////////////////////////////////////////////
+        // EBusTraits overrides
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+        //////////////////////////////////////////////////////////////////////////
+
+        virtual void OnCanUndoChanged([[maybe_unused]] bool canUndo) {}
+        virtual void OnCanRedoChanged([[maybe_unused]] bool canRedo) {}
+
+    };
+    using UndoNotificationBus = AZ::EBus<UndoNotifications>;
+
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/UnitTestVerificationBus.h

@@ -0,0 +1,65 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+#include <AzCore/EBus/EBus.h>
+#include <Editor/Framework/ScriptCanvasReporter.h>
+
+namespace ScriptCanvasEditor
+{
+
+    struct UnitTestResult
+    {   
+        bool m_success;
+        bool m_running;
+        AZStd::string m_consoleOutput;
+        bool m_latestTestingRound;
+
+        UnitTestResult()
+            : m_success(true)
+            , m_running(false)
+            , m_latestTestingRound(true)
+        {
+        }
+        
+        UnitTestResult(bool newRunning, bool newSuccess, AZStd::string_view newConsoleOutput)
+            : m_success(newSuccess)
+            , m_running(newRunning)
+            , m_consoleOutput(newConsoleOutput)
+            , m_latestTestingRound(true)
+        {
+        }
+    };
+
+    class UnitTestVerificationRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
+
+        virtual UnitTestResult Verify(ScriptCanvasEditor::Reporter reporter) = 0;
+    };
+    using UnitTestVerificationBus = AZ::EBus<UnitTestVerificationRequests>;
+
+    class UnitTestWidgetNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+
+        virtual void OnTestStart([[maybe_unused]] const AZ::Uuid& sourceID) {}
+        virtual void OnTestResult([[maybe_unused]] const AZ::Uuid& sourceID, UnitTestResult result) {}
+        virtual void OnCheckStateCountChange([[maybe_unused]] const int count) {}
+    };
+    using UnitTestWidgetNotificationBus = AZ::EBus<UnitTestWidgetNotifications>;
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Components/EditorGraph.h

@@ -0,0 +1,354 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <AzCore/std/containers/unordered_map.h>
+
+#include <ScriptCanvas/Core/Graph.h>
+#include <ScriptCanvas/Bus/GraphBus.h>
+#include <ScriptCanvas/Bus/NodeIdPair.h>
+#include <ScriptCanvas/Bus/RequestBus.h>
+#include <ScriptCanvas/GraphCanvas/NodeDescriptorBus.h>
+
+#include <Editor/GraphCanvas/DataInterfaces/ScriptCanvasVariableDataInterface.h>
+
+#include <Editor/Include/ScriptCanvas/Bus/EditorScriptCanvasBus.h>
+#include <Editor/Include/ScriptCanvas/Components/EditorUtils.h>
+#include <Editor/Undo/ScriptCanvasGraphCommand.h>
+
+#include <GraphCanvas/Components/Connections/ConnectionBus.h>
+#include <GraphCanvas/Components/EntitySaveDataBus.h>
+#include <GraphCanvas/Components/Nodes/Wrapper/WrapperNodeBus.h>
+#include <GraphCanvas/Components/SceneBus.h>
+#include <GraphCanvas/Components/Slots/Data/DataSlotBus.h>
+#include <GraphCanvas/Components/ToastBus.h>
+#include <GraphCanvas/Types/GraphCanvasGraphSerialization.h>
+#include <GraphCanvas/Editor/GraphModelBus.h>
+
+#include <GraphCanvas/Widgets/NodePropertyBus.h>
+
+
+namespace ScriptCanvasEditor
+{
+    //! EditorGraph is the editor version of the ScriptCanvas::Graph component that is activated when executing the script canvas engine
+    class Graph
+        : public ScriptCanvas::Graph
+        , private NodeCreationNotificationBus::Handler
+        , private SceneCounterRequestBus::Handler
+        , private EditorGraphRequestBus::Handler
+        , private GraphCanvas::GraphModelRequestBus::Handler
+        , private GraphCanvas::SceneNotificationBus::Handler
+        , private GraphItemCommandNotificationBus::Handler
+        , private GraphCanvas::ToastNotificationBus::MultiHandler
+        , private GeneralEditorNotificationBus::Handler
+    {
+    private:
+        typedef AZStd::unordered_map< AZ::EntityId, AZ::EntityId > WrappedNodeGroupingMap;
+
+        static void ConvertToGetVariableNode(Graph* graph, ScriptCanvas::VariableId variableId, const AZ::EntityId& nodeId, AZStd::unordered_map<AZ::EntityId, AZ::EntityId>& setVariableRemapping);
+
+        struct CRCCache
+        {
+            AZ_TYPE_INFO(CRCCache, "{59798D92-94AD-4A08-8F38-D5975B0DC33B}");
+
+            CRCCache()
+                : m_cacheCount(0)
+            {
+            }
+
+            CRCCache(const AZStd::string& cacheString)
+                : m_cacheValue(cacheString)
+                , m_cacheCount(1)
+            {
+
+            }
+
+            AZStd::string m_cacheValue;
+            int m_cacheCount;
+        };
+
+    public:
+        AZ_COMPONENT(Graph, "{4D755CA9-AB92-462C-B24F-0B3376F19967}", ScriptCanvas::Graph);
+
+        static void Reflect(AZ::ReflectContext* context);
+
+        Graph(const ScriptCanvas::ScriptCanvasId& scriptCanvasId = AZ::Entity::MakeId())
+            : ScriptCanvas::Graph(scriptCanvasId)
+            , m_variableCounter(0)
+            , m_graphCanvasSceneEntity(nullptr)
+            , m_ignoreSaveRequests(false)
+            , m_graphCanvasSaveVersion(GraphCanvas::EntitySaveDataContainer::CurrentVersion)
+        {}
+        
+        ~Graph() override;
+
+        void Activate() override;
+        void Deactivate() override;
+
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+        {
+            ScriptCanvas::Graph::GetProvidedServices(provided);
+            provided.push_back(AZ_CRC("EditorScriptCanvasService", 0x975114ff));
+        }
+
+        static void GetRequiredServices([[maybe_unused]] AZ::ComponentDescriptor::DependencyArrayType& required)
+        {
+        }
+
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+        {
+            ScriptCanvas::Graph::GetIncompatibleServices(incompatible);
+            incompatible.push_back(AZ_CRC("EditorScriptCanvasService", 0x975114ff));
+        }
+
+        // SceneCounterRequestBus
+        AZ::u32 GetNewVariableCounter() override;
+        void ReleaseVariableCounter(AZ::u32 variableCounter) override;
+        ////
+
+        // RuntimeBus
+        AZ::Data::AssetId GetAssetId() const override { return m_assetId; }
+        ////
+
+        // GraphCanvas::GraphModelRequestBus
+        void RequestUndoPoint() override;
+
+        void RequestPushPreventUndoStateUpdate() override;
+        void RequestPopPreventUndoStateUpdate() override;
+
+        void TriggerUndo() override;
+        void TriggerRedo() override;
+
+        bool EnableNodes(const AZStd::unordered_set< GraphCanvas::NodeId >& nodeIds) override;
+        bool DisableNodes(const AZStd::unordered_set< GraphCanvas::NodeId >& nodeIds) override;
+
+        GraphCanvas::NodePropertyDisplay* CreateDataSlotPropertyDisplay(const AZ::Uuid& dataType, const AZ::EntityId& nodeId, const AZ::EntityId& slotId) const override;
+        GraphCanvas::NodePropertyDisplay* CreatePropertySlotPropertyDisplay(const AZ::Crc32& propertyId, const AZ::EntityId& nodeId, const AZ::EntityId& slotId) const override;
+
+        void DisconnectConnection(const GraphCanvas::ConnectionId& connectionId) override;
+        bool CreateConnection(const GraphCanvas::ConnectionId& connectionId, const GraphCanvas::Endpoint& sourcePoint, const GraphCanvas::Endpoint& targetPoint) override;
+
+        bool IsValidConnection(const GraphCanvas::Endpoint& sourcePoint, const GraphCanvas::Endpoint& targetPoint) const override;
+        GraphCanvas::ConnectionValidationTooltip GetConnectionValidityTooltip(const GraphCanvas::Endpoint& sourcePoint, const GraphCanvas::Endpoint& targetPoint) const override;
+
+        bool IsValidVariableAssignment(const AZ::EntityId& variableId, const GraphCanvas::Endpoint& targetPoint) const override;
+        GraphCanvas::ConnectionValidationTooltip GetVariableAssignmentValidityTooltip(const AZ::EntityId& variableId, const GraphCanvas::Endpoint& targetPoint) const override;
+
+        AZStd::string GetDataTypeString(const AZ::Uuid& typeId) override;
+
+        void OnRemoveUnusedNodes() override;
+        void OnRemoveUnusedElements() override;
+
+        bool AllowReset(const GraphCanvas::Endpoint& endpoint) const override;
+
+        void ResetSlotToDefaultValue(const GraphCanvas::Endpoint& endpoint) override;
+        void ResetReference(const GraphCanvas::Endpoint& endpoint) override;
+        void ResetProperty(const GraphCanvas::NodeId& nodeId, const AZ::Crc32& propertyId) override;
+
+        void RemoveSlot(const GraphCanvas::Endpoint& endpoint) override;
+        bool IsSlotRemovable(const GraphCanvas::Endpoint& endpoint) const override;
+
+        bool ConvertSlotToReference(const GraphCanvas::Endpoint& endpoint) override;
+        bool CanConvertSlotToReference(const GraphCanvas::Endpoint& endpoint) override;
+        bool CanHandleReferenceMimeEvent(const GraphCanvas::Endpoint& endpoint, const QMimeData* mimeData) override;
+        bool HandleReferenceMimeEvent(const GraphCanvas::Endpoint& endpoint, const QMimeData* mimeData) override;
+        bool CanPromoteToVariable(const GraphCanvas::Endpoint& endpoint) const override;
+        bool PromoteToVariableAction(const GraphCanvas::Endpoint& endpoint) override;
+        bool SynchronizeReferences(const GraphCanvas::Endpoint& sourceEndpoint, const GraphCanvas::Endpoint& targetEndpoint) override;
+
+        bool ConvertSlotToValue(const GraphCanvas::Endpoint& endpoint) override;
+        bool CanConvertSlotToValue(const GraphCanvas::Endpoint& endpoint) override;
+        bool CanHandleValueMimeEvent(const GraphCanvas::Endpoint& endpoint, const QMimeData* mimeData) override;
+        bool HandleValueMimeEvent(const GraphCanvas::Endpoint& endpoint, const QMimeData* mimeData) override;
+
+        GraphCanvas::SlotId RequestExtension(const GraphCanvas::NodeId& nodeId, const GraphCanvas::ExtenderId& extenderId) override;
+        void ExtensionCancelled(const GraphCanvas::NodeId& nodeId, const GraphCanvas::ExtenderId& extenderId) override;
+        void FinalizeExtension(const GraphCanvas::NodeId& nodeId, const GraphCanvas::ExtenderId& extenderId) override;
+
+        bool ShouldWrapperAcceptDrop(const GraphCanvas::NodeId& wrapperNode, const QMimeData* mimeData) const override;
+
+        void AddWrapperDropTarget(const GraphCanvas::NodeId& wrapperNode) override;
+        void RemoveWrapperDropTarget(const GraphCanvas::NodeId& wrapperNode) override;
+        ////
+
+        // SceneNotificationBus
+        void OnEntitiesSerialized(GraphCanvas::GraphSerialization& serializationTarget) override;
+        void OnEntitiesDeserialized(const GraphCanvas::GraphSerialization& serializationSource) override;
+        void OnPreNodeDeleted(const AZ::EntityId& nodeId) override;
+        void OnPreConnectionDeleted(const AZ::EntityId& nodeId) override;
+
+        void OnUnknownPaste(const QPointF& scenePos) override;
+
+        void OnSelectionChanged() override;
+
+        void PostDeletionEvent() override;
+        void PostCreationEvent() override;
+        void OnPasteBegin() override;
+        void OnPasteEnd() override;
+        
+        void OnViewRegistered() override;
+        /////////////////////////////////////////////////////////////////////////////////////////////
+
+        //! NodeCreationNotifications
+        void OnGraphCanvasNodeCreated(const AZ::EntityId& nodeId) override;
+        ///////////////////////////
+
+        // EditorGraphRequestBus
+        void SetAssetId(const AZ::Data::AssetId& assetId) override { m_assetId = assetId; }
+
+        void CreateGraphCanvasScene() override;
+        void ClearGraphCanvasScene() override;
+        void DisplayGraphCanvasScene() override;
+
+        void OnGraphCanvasSceneVisible() override;
+
+        GraphCanvas::GraphId GetGraphCanvasGraphId() const override;
+
+        AZStd::unordered_map< AZ::EntityId, GraphCanvas::EntitySaveDataContainer* > GetGraphCanvasSaveData();
+        void UpdateGraphCanvasSaveData(const AZStd::unordered_map< AZ::EntityId, GraphCanvas::EntitySaveDataContainer* >& saveData);
+
+        NodeIdPair CreateCustomNode(const AZ::Uuid& typeId, const AZ::Vector2& position) override;
+
+        void AddCrcCache(const AZ::Crc32& crcValue, const AZStd::string& cacheString) override;
+        void RemoveCrcCache(const AZ::Crc32& crcValue) override;
+        AZStd::string DecodeCrc(const AZ::Crc32& crcValue) override;
+
+        void ClearHighlights() override;
+        void HighlightMembersFromTreeItem(const GraphCanvas::GraphCanvasTreeItem* treeItem) override;
+        void HighlightVariables(const AZStd::unordered_set< ScriptCanvas::VariableId>& variableIds) override;
+        void HighlightNodes(const AZStd::vector<NodeIdPair>& nodes) override;
+
+        AZStd::vector<NodeIdPair> GetNodesOfType(const ScriptCanvas::NodeTypeIdentifier&) override;
+        AZStd::vector<NodeIdPair> GetVariableNodes(const ScriptCanvas::VariableId&) override;
+        
+        void RemoveUnusedVariables() override;
+
+        bool ConvertVariableNodeToReference(const GraphCanvas::NodeId& nodeId) override;
+        bool ConvertReferenceToVariableNode(const GraphCanvas::Endpoint& endpoint) override;
+
+        void QueueVersionUpdate(const AZ::EntityId& graphCanvasNodeId) override;
+
+        bool IsRuntimeGraph() const override;
+        bool IsFunctionGraph() const override;
+
+        ScriptCanvas::Endpoint ConvertToScriptCanvasEndpoint(const GraphCanvas::Endpoint& endpoint) const override;
+        GraphCanvas::Endpoint ConvertToGraphCanvasEndpoint(const ScriptCanvas::Endpoint& endpoint) const override;
+        ////
+
+        bool OnVersionConversionBegin(ScriptCanvas::Node& node);
+        void OnVersionConversionEnd(ScriptCanvas::Node& node);
+
+        // EntitySaveDataGraphActionBus
+        void OnSaveDataDirtied(const AZ::EntityId& savedElement) override;
+        ////
+
+        // Save Information Conversion
+        bool NeedsSaveConversion() const;
+        void ConvertSaveFormat();
+
+        void ConstructSaveData();
+        ////
+
+        // ToastNotifications
+        void OnToastInteraction() override;
+        void OnToastDismissed() override;
+        ////
+
+        // GeneralEditorNotificationBus
+        void OnUndoRedoEnd() override;
+        ////
+
+        void SetAssetType(AZ::Data::AssetType);
+
+        void ReportError(const ScriptCanvas::Node& node, const AZStd::string& errorSource, const AZStd::string& errorMessage) override;
+
+        const GraphStatisticsHelper& GetNodeUsageStatistics() const;
+
+        // Finds and returns all nodes within the graph that are of the specified type
+        template <typename NodeType>
+        AZStd::vector<const NodeType*> GetNodesOfType() const
+        {
+            AZStd::vector<const NodeType*> nodes;
+            for (auto& nodeRef : m_graphData.m_nodes)
+            {
+                const NodeType* node = nodeRef->FindComponent<NodeType>();
+                if (node)
+                {
+                    nodes.push_back(node);
+                }
+            }
+            return nodes;
+        }
+
+    protected:
+        void PostRestore(const UndoData& restoredData);
+
+        void UnregisterToast(const GraphCanvas::ToastId& toastId);
+
+    private:
+        Graph(const Graph&) = delete;
+
+        void DisplayUpdateToast();
+        
+        AZ::EntityId          ConvertToScriptCanvasNodeId(const GraphCanvas::NodeId& nodeId) const;        
+
+        GraphCanvas::NodePropertyDisplay* CreateDisplayPropertyForSlot(const AZ::EntityId& scriptCanvasNodeId, const ScriptCanvas::SlotId& scriptCanvasSlotId) const;
+
+        void SignalDirty();
+
+        void HighlightNodesByType(const ScriptCanvas::NodeTypeIdentifier& nodeTypeIdentifier);
+        void HighlightEBusNodes(const ScriptCanvas::EBusBusId& busId, const ScriptCanvas::EBusEventId& eventId);
+        void HighlightScriptEventNodes(const ScriptCanvas::EBusBusId& busId, const ScriptCanvas::EBusEventId& eventId);
+        void HighlightScriptCanvasEntity(const AZ::EntityId& scriptCanvasId);
+
+        AZ::EntityId FindGraphCanvasSlotId(const AZ::EntityId& graphCanvasNodeId, const ScriptCanvas::SlotId& slotId);
+        bool ConfigureConnectionUserData(const ScriptCanvas::Endpoint& sourceEndpoint, const ScriptCanvas::Endpoint& targetEndpoint, GraphCanvas::ConnectionId connectionId);
+
+        void HandleQueuedUpdates();
+        bool IsNodeVersionConverting(const AZ::EntityId& graphCanvasNodeId) const;
+
+        AZStd::unordered_map< GraphCanvas::ToastId, AZ::EntityId > m_toastNodeIds;
+
+        //// Version Update code
+        AZStd::unordered_set< AZ::EntityId > m_queuedConvertingNodes;
+        AZStd::unordered_set< AZ::EntityId > m_convertingNodes;
+        AZStd::unordered_multimap< AZ::EntityId, ScriptCanvas::SlotId > m_versionedSlots;
+        AZStd::unordered_set< AZStd::string > m_updateStrings;
+
+        AZ::u32 m_variableCounter;
+        AZ::EntityId m_wrapperNodeDropTarget;
+
+        VariableComboBoxDataModel m_variableDataModel;
+        
+        WrappedNodeGroupingMap m_wrappedNodeGroupings;
+        AZStd::vector< AZ::EntityId > m_lastGraphCanvasCreationGroup;
+        
+        AZ::Entity* m_graphCanvasSceneEntity;
+
+        GraphCanvas::EntitySaveDataContainer::VersionInformation m_graphCanvasSaveVersion;
+        AZStd::unordered_map< AZ::EntityId, GraphCanvas::EntitySaveDataContainer* > m_graphCanvasSaveData;
+
+        AZStd::unordered_map< AZ::Crc32, CRCCache > m_crcCacheMap;
+
+        AZStd::unordered_set< GraphCanvas::GraphicsEffectId > m_highlights;
+
+        GraphCanvas::NodeFocusCyclingHelper m_focusHelper;
+        GraphStatisticsHelper m_statisticsHelper;
+
+        bool m_ignoreSaveRequests;
+
+        //! Defaults to true to signal that this graph does not have the GraphCanvas stuff intermingled
+        bool m_saveFormatConverted = true;
+
+        AZ::Data::AssetId m_assetId;
+    };
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Components/EditorGraphVariableManagerComponent.h

@@ -0,0 +1,102 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <qabstractitemmodel.h>
+
+#include <ScriptCanvas/Variable/GraphVariableManagerComponent.h>
+
+#include <Editor/Include/ScriptCanvas/Bus/EditorSceneVariableManagerBus.h>
+
+namespace ScriptCanvasEditor
+{
+    class EditorGraphVariableItemModel
+        : public QAbstractItemModel
+        , public ScriptCanvas::GraphVariableManagerNotificationBus::Handler
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(EditorGraphVariableItemModel, AZ::SystemAllocator, 0);
+        EditorGraphVariableItemModel() = default;
+
+        void Activate(const ScriptCanvas::ScriptCanvasId& executionId);
+
+        ScriptCanvas::VariableId FindVariableIdForIndex(const QModelIndex& modelIndex) const;
+
+        // QAbstractItemModel
+        QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
+        QModelIndex parent(const QModelIndex& index) const override;
+
+        int columnCount(const QModelIndex& parent = QModelIndex()) const override;
+        int rowCount(const QModelIndex& parent = QModelIndex()) const override;
+
+        QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
+        ////
+
+        // SceneVariableManagerNotificationBus
+        void OnVariableAddedToGraph(const ScriptCanvas::VariableId& variableId, AZStd::string_view variableName) override;
+        void OnVariableRemovedFromGraph(const ScriptCanvas::VariableId& variableId, AZStd::string_view variableName) override;
+        ////
+
+    private:
+
+        EditorGraphVariableItemModel(const EditorGraphVariableItemModel&) = delete;
+        EditorGraphVariableItemModel& operator=(const EditorGraphVariableItemModel&) = delete;
+
+        AZStd::vector< ScriptCanvas::VariableId > m_variableIds;
+        ScriptCanvas::ScriptCanvasId m_busId;
+    };
+
+    // Editor version of Variable Component which prevents multiple of them being on the same Entity
+    class EditorGraphVariableManagerComponent
+        : public ScriptCanvas::GraphVariableManagerComponent
+        , public ScriptCanvas::GraphVariableManagerNotificationBus::Handler
+        , public EditorSceneVariableManagerRequestBus::Handler        
+    {
+    public:
+        AZ_COMPONENT(EditorGraphVariableManagerComponent, "{86B7CC96-9830-4BD1-85C3-0C0BD0BFBEE7}", ScriptCanvas::GraphVariableManagerComponent);
+
+        static void Reflect(AZ::ReflectContext* context);
+
+        EditorGraphVariableManagerComponent() = default;
+        EditorGraphVariableManagerComponent(ScriptCanvas::ScriptCanvasId scriptCanvasId);
+        ~EditorGraphVariableManagerComponent() override = default;
+
+        // GraphConfigurationNotificationBus
+        void ConfigureScriptCanvasId(const ScriptCanvas::ScriptCanvasId& scriptCanvasId) override;
+        ////
+
+        // EditorSceneVariableManagerRequestBus
+        QAbstractItemModel* GetVariableItemModel() override;
+        ////
+
+    protected:
+        // prevents a second VariableComponent from being attached to the Entity in the Editor
+
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+        {
+            ScriptCanvas::GraphVariableManagerComponent::GetProvidedServices(provided);
+            provided.push_back(AZ_CRC("EditorScriptCanvasVariableService", 0x3df3d54e));
+        }
+
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+        {
+            incompatible.push_back(AZ_CRC("EditorScriptCanvasVariableService", 0x3df3d54e));
+        }
+
+    private:
+
+        EditorGraphVariableManagerComponent(const EditorGraphVariableManagerComponent&) = delete;
+        EditorGraphVariableManagerComponent& operator=(const EditorGraphVariableManagerComponent&) = delete;
+
+        EditorGraphVariableItemModel m_variableModel;
+    };
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Components/EditorScriptCanvasComponent.h

@@ -0,0 +1,154 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzFramework/Asset/AssetCatalogBus.h>
+#include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
+
+#include <Editor/Assets/ScriptCanvasAssetHolder.h>
+#include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
+#include <ScriptCanvas/Bus/EditorScriptCanvasBus.h>
+#include <ScriptCanvas/Variable/VariableBus.h>
+#include <ScriptCanvas/Variable/VariableData.h>
+
+namespace ScriptCanvasEditor
+{
+    /*! EditorScriptCanvasComponent
+    The user facing Editor Component for interfacing with ScriptCanvas
+    It connects to the AssetCatalogEventBus in order to remove the ScriptCanvasAssetHolder asset reference
+    when the asset is removed from the file system. The reason the ScriptCanvasAssetHolder holder does not
+    remove the asset reference itself is because the ScriptCanvasEditor MainWindow has a ScriptCanvasAssetHolder
+    which it uses to maintain the asset data in memory. Therefore removing an open ScriptCanvasAsset from the file system
+    will remove the reference from the EditorScriptCanvasComponent, but not the reference from the MainWindow allowing the
+    ScriptCanvas graph to still be modified while open
+
+    Finally per graph instance variables values are stored on the EditorScriptCanvasComponent and injected into the runtime ScriptCanvas component in BuildGameEntity
+    */
+    class EditorScriptCanvasComponent
+        : public AzToolsFramework::Components::EditorComponentBase        
+        , private EditorContextMenuRequestBus::Handler
+        , private AzFramework::AssetCatalogEventBus::Handler
+        , private EditorScriptCanvasComponentLoggingBus::Handler
+        , private EditorScriptCanvasComponentRequestBus::Handler
+        , private AssetTrackerNotificationBus::Handler
+    {
+    public:
+        AZ_COMPONENT(EditorScriptCanvasComponent, "{C28E2D29-0746-451D-A639-7F113ECF5D72}", AzToolsFramework::Components::EditorComponentBase);
+
+        EditorScriptCanvasComponent();
+        EditorScriptCanvasComponent(AZ::Data::Asset<ScriptCanvasAsset> asset);
+        ~EditorScriptCanvasComponent() override;
+
+        //=====================================================================
+        // AZ::Component
+        void Init() override;
+        void Activate() override;
+        void Deactivate() override;
+        //=====================================================================
+
+
+        //=====================================================================
+        // EditorComponentBase
+        void BuildGameEntity(AZ::Entity* gameEntity) override;
+        void SetPrimaryAsset(const AZ::Data::AssetId&) override;
+        //=====================================================================
+
+        //=====================================================================
+        // EditorScriptCanvasComponentLoggingBus
+        AZ::NamedEntityId FindNamedEntityId() const override { return GetNamedEntityId(); }
+        ScriptCanvas::GraphIdentifier GetGraphIdentifier() const override;
+        //=====================================================================
+
+        void OpenEditor();
+        void CloseGraph();
+
+        void SetName(const AZStd::string& name) { m_name = name; }
+        const AZStd::string& GetName() const { return m_name; };
+        AZ::EntityId GetEditorEntityId() const { return GetEntity() ? GetEntityId() : AZ::EntityId(); }
+        AZ::NamedEntityId GetNamedEditorEntityId() const { return GetEntity() ? GetNamedEntityId() : AZ::NamedEntityId(); }
+        
+        //=====================================================================
+        // EditorScriptCanvasComponentRequestBus
+        void SetAssetId(const AZ::Data::AssetId& assetId) override;
+        bool HasAssetId() const override;
+        //=====================================================================
+
+        //=====================================================================
+        // EditorContextMenuRequestBus
+        AZ::Data::AssetId GetAssetId() const override;
+        //=====================================================================
+        AZ::EntityId GetGraphEntityId() const;
+
+        //=====================================================================
+        // AssetTrackerNotificationBus
+        void OnAssetReady(const ScriptCanvasMemoryAsset::pointer asset) override;
+        void OnAssetSaved(const ScriptCanvasMemoryAsset::pointer asset, bool isSuccessful) override;
+        void OnAssetReloaded(const ScriptCanvasMemoryAsset::pointer asset) override;
+        //=====================================================================
+
+    protected:
+        static void Reflect(AZ::ReflectContext* context);
+
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+        {
+            provided.push_back(AZ_CRC("ScriptCanvasService", 0x41fd58f3));
+        }
+
+        static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required)
+        {
+            (void)required;
+        }
+
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+        {
+            (void)incompatible;
+        }
+
+        //=====================================================================
+        // AssetCatalogEventBus
+        void OnCatalogAssetAdded(const AZ::Data::AssetId& assetId) override;
+        void OnCatalogAssetRemoved(const AZ::Data::AssetId& assetId, const AZ::Data::AssetInfo& assetInfo) override;
+        //=====================================================================
+
+        void OnScriptCanvasAssetChanged(AZ::Data::AssetId assetId);
+
+        void UpdateName();
+
+        //=====================================================================
+        void OnScriptCanvasAssetReady(const ScriptCanvasMemoryAsset::pointer asset);
+        //=====================================================================
+
+        void AddVariable(AZStd::string_view varName, const ScriptCanvas::GraphVariable& varDatum);
+        void AddNewVariables(const ScriptCanvas::VariableData& graphVarData);
+        void RemoveVariable(const ScriptCanvas::VariableId& varId);
+        void RemoveOldVariables(const ScriptCanvas::VariableData& graphVarData);
+        bool UpdateVariable(const ScriptCanvas::GraphVariable& graphDatum, ScriptCanvas::GraphVariable& updateDatum, ScriptCanvas::GraphVariable& originalDatum);
+        void LoadVariables(const ScriptCanvasMemoryAsset::pointer memoryAsset);
+        void ClearVariables();
+
+        void GetScriptCanvasId();
+
+    private:
+        AZ::Data::AssetId m_removedCatalogId;
+        AZ::Data::AssetId m_previousAssetId;
+
+        AZStd::string m_name;
+        ScriptCanvasAssetHolder m_scriptCanvasAssetHolder;
+        
+        ScriptCanvas::EditableVariableData m_editableData;
+
+        //< Contains a mapping of the EntityId value from the ScriptCanvasAsset stored as an AZ::u64 so that it does not get remapped
+        //< to itself stored as an EntityId
+        AZStd::unordered_map<AZ::u64, AZ::EntityId> m_variableEntityIdMap; 
+    };
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Components/EditorUtils.h

@@ -0,0 +1,56 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <AzCore/RTTI/ReflectContext.h>
+#include <AzCore/std/containers/unordered_map.h>
+
+#include <GraphCanvas/Widgets/GraphCanvasTreeItem.h>
+
+#include <ScriptCanvas/Core/Core.h>
+
+namespace GraphCanvas
+{
+    class NodePaletteTreeItem;
+}
+
+namespace ScriptCanvasEditor
+{
+    class Graph;
+    class NodePaletteModel;
+
+    class NodeIdentifierFactory
+    {
+    public:
+        static ScriptCanvas::NodeTypeIdentifier ConstructNodeIdentifier(const GraphCanvas::GraphCanvasTreeItem* treeItem);
+        static AZStd::vector< ScriptCanvas::NodeTypeIdentifier > ConstructNodeIdentifiers(const GraphCanvas::GraphCanvasTreeItem* treeItem);
+    };
+    
+    class GraphStatisticsHelper
+    {
+    public:
+        static void Reflect(AZ::ReflectContext* reflectContext);     
+
+        AZ_CLASS_ALLOCATOR(GraphStatisticsHelper, AZ::SystemAllocator, 0);
+        AZ_RTTI(GraphStatisticsHelper, "{7D5B7A65-F749-493E-BA5C-6B8724791F03}");
+
+        virtual ~GraphStatisticsHelper() = default;
+
+        void PopulateStatisticData(const Graph* editorGraph);
+        
+        AZStd::unordered_map< ScriptCanvas::NodeTypeIdentifier, int > m_nodeIdentifierCount;
+
+    private:
+
+        void RegisterNodeType(const ScriptCanvas::NodeTypeIdentifier& nodeTypeIdentifier);
+    };        
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/GraphCanvas/DynamicSlotBus.h

@@ -0,0 +1,34 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+
+#include <ScriptCanvas/Core/Core.h>
+
+namespace ScriptCanvasEditor
+{    
+    class DynamicSlotRequests : public AZ::EBusTraits
+    {
+    public:
+        //! The id here is the id of the node.
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+        
+        virtual void OnUserDataChanged() = 0;
+
+        virtual void StartQueueSlotUpdates() = 0;
+        virtual void StopQueueSlotUpdates() = 0;
+    };
+
+    using DynamicSlotRequestBus = AZ::EBus<DynamicSlotRequests>;
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/GraphCanvas/MappingBus.h

@@ -0,0 +1,54 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+
+#include <ScriptCanvas/Core/Core.h>
+
+namespace ScriptCanvasEditor
+{    
+    class SlotMappingRequests : public AZ::EBusTraits
+    {
+    public:
+        //! The id here is the id of the node.
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+        
+        virtual AZ::EntityId MapToGraphCanvasId(const ScriptCanvas::SlotId& slotId) = 0;
+    };
+
+    using SlotMappingRequestBus = AZ::EBus<SlotMappingRequests>;
+
+    class SceneMemberMappingConfigurationRequests : public AZ::EBusTraits
+    {
+    public:
+        // This bus will be keyed off of the GraphCanvas::MemberId.
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+
+        virtual void ConfigureMapping(const AZ::EntityId& scriptCanvasMemberId) = 0;
+    };
+
+    using SceneMemberMappingConfigurationRequestBus = AZ::EBus<SceneMemberMappingConfigurationRequests>;
+
+    class SceneMemberMappingRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+
+        virtual AZ::EntityId GetGraphCanvasEntityId() const = 0;
+    };
+
+    using SceneMemberMappingRequestBus = AZ::EBus<SceneMemberMappingRequests>;
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/GraphCanvas/NodeDescriptorBus.h

@@ -0,0 +1,245 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <QPoint>
+#include <QRect>
+
+#include <AzCore/EBus/EBus.h>
+
+#include <GraphCanvas/Components/Nodes/Wrapper/WrapperNodeBus.h>
+#include <GraphCanvas/Types/Endpoint.h>
+#include <GraphCanvas/Editor/EditorTypes.h>
+
+#include <Editor/Include/ScriptCanvas/Bus/NodeIdPair.h>
+#include <ScriptCanvas/Core/Core.h>
+#include <ScriptCanvas/Core/Endpoint.h>
+#include <ScriptCanvas/Core/Datum.h>
+
+#include <ScriptCanvas/Variable/VariableCore.h>
+#include <ScriptEvents/ScriptEventsAsset.h>
+
+namespace GraphCanvas
+{
+    class StringDataInterface;
+    class VariableReferenceDataInterface;
+}
+
+namespace ScriptCanvasEditor
+{
+    enum class NodeDescriptorType
+    {
+        Unknown,
+        EBusHandler,
+        EBusHandlerEvent,
+        EBusSender,
+        EntityRef,
+        VariableNode,
+        SetVariable,
+        GetVariable,
+        UserDefined,
+        ClassMethod,
+        FunctionNode,
+        ExecutionNodeling,
+        
+        Invalid
+    };
+    
+    class NodeDescriptorRequests : public AZ::EBusTraits
+    {
+    public:
+        //! The id here is the id of the node.
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+
+        virtual NodeDescriptorType GetType() const = 0;
+        virtual bool IsType(const NodeDescriptorType& descriptorType)
+        { 
+            NodeDescriptorType localType = GetType();
+            
+            if (localType == NodeDescriptorType::Invalid
+                || descriptorType == NodeDescriptorType::Invalid)
+            {
+                return false;
+            }
+            
+            return GetType() == descriptorType;
+        }
+    };
+
+    using NodeDescriptorRequestBus = AZ::EBus<NodeDescriptorRequests>;
+
+    struct HandlerEventConfiguration
+    {
+        ScriptCanvas::EBusEventId m_eventId;
+        AZStd::string             m_eventName;
+    };
+
+    class EBusHandlerNodeDescriptorRequests : public AZ::EBusTraits
+    {
+    public:
+        //! The id here is the id of the node.
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+
+        virtual AZStd::string_view GetBusName() const = 0;
+
+        virtual GraphCanvas::WrappedNodeConfiguration GetEventConfiguration(const ScriptCanvas::EBusEventId& eventId) const = 0;
+        virtual bool ContainsEvent(const ScriptCanvas::EBusEventId& eventId) const = 0;
+
+        virtual AZStd::vector< HandlerEventConfiguration > GetEventConfigurations() const = 0;
+
+        virtual AZ::EntityId FindEventNodeId(const ScriptCanvas::EBusEventId& eventName) const = 0;
+        virtual AZ::EntityId FindGraphCanvasNodeIdForSlot(const ScriptCanvas::SlotId& slotId) const = 0;
+
+        virtual GraphCanvas::Endpoint MapSlotToGraphCanvasEndpoint(const ScriptCanvas::SlotId& slotId) const = 0;
+    };
+
+    using EBusHandlerNodeDescriptorRequestBus = AZ::EBus<EBusHandlerNodeDescriptorRequests>;
+
+    class EBusHandlerEventNodeDescriptorRequests : public AZ::EBusTraits
+    {
+    public:
+        //! The id here is the id of the node.
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+
+        virtual AZStd::string_view GetBusName() const = 0;
+        virtual AZStd::string_view GetEventName() const = 0;
+
+        virtual ScriptCanvas::EBusEventId GetEventId() const = 0;
+
+        virtual void SetHandlerAddress(const ScriptCanvas::Datum& idDatum) = 0;
+    };
+
+    using EBusHandlerEventNodeDescriptorRequestBus = AZ::EBus<EBusHandlerEventNodeDescriptorRequests>;
+
+    class VariableNodeDescriptorRequests : public AZ::EBusTraits
+    {
+    public:
+        //! The id here is the id of the node.
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+
+        virtual ScriptCanvas::VariableId GetVariableId() const = 0;
+    };
+
+    using VariableNodeDescriptorRequestBus = AZ::EBus<VariableNodeDescriptorRequests>;
+
+    class SceneCounterRequests : public AZ::EBusTraits
+    {
+    public:
+        //! The id here is the id of the scene.
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = ScriptCanvas::ScriptCanvasId;
+
+        virtual AZ::u32 GetNewVariableCounter() = 0;
+        virtual void ReleaseVariableCounter(AZ::u32 variableCounter) = 0;
+    };
+
+    using SceneCounterRequestBus = AZ::EBus<SceneCounterRequests>;
+
+    class ScriptCanvasWrapperNodeDescriptorRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = GraphCanvas::NodeId;
+
+        virtual void OnWrapperAction(const QRect& actionWidgetBoundingRect, const QPointF& scenePoint, const QPoint& screenPoint) = 0;
+    };
+
+    using ScriptCanvasWrapperNodeDescriptorRequestBus = AZ::EBus<ScriptCanvasWrapperNodeDescriptorRequests>;
+
+    class ScriptEventReceiverNodeDescriptorRequests : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = GraphCanvas::NodeId;
+
+        virtual AZ::Data::AssetId GetAssetId() const = 0;
+    };
+
+    using ScriptEventReceiverNodeDescriptorRequestBus = AZ::EBus<ScriptEventReceiverNodeDescriptorRequests>;
+
+    class ScriptEventReceiveNodeDescriptorNotifications : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = GraphCanvas::NodeId;
+        
+        virtual void OnScriptEventReloaded([[maybe_unused]] const AZ::Data::Asset<ScriptEvents::ScriptEventsAsset>& asset) {};
+    };
+
+    using ScriptEventReceiveNodeDescriptorNotificationBus = AZ::EBus<ScriptEventReceiveNodeDescriptorNotifications>;
+
+    class ScriptEventReceiverEventNodeDescriptorRequests : public AZ::EBusTraits
+    {
+    public:
+        //! The id here is the id of the node.
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = AZ::EntityId;
+
+        virtual const ScriptEvents::Method& GetMethodDefinition() = 0;
+        virtual AZStd::string GetEventName() = 0;
+    };
+
+    using ScriptEventReceiverEventNodeDescriptorBus = AZ::EBus<ScriptEventReceiverEventNodeDescriptorRequests>;
+
+    namespace Deprecated
+    {
+        class VariableNodeDescriptorRequests : public AZ::EBusTraits
+        {
+        public:
+            //! The id here is the id of the node.
+            static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+            using BusIdType = AZ::EntityId;
+
+            virtual ScriptCanvas::Endpoint GetReadEndpoint() const = 0;
+            virtual ScriptCanvas::Endpoint GetWriteEndpoint() const = 0;
+        };
+
+        using VariableNodeDescriptorRequestBus = AZ::EBus<VariableNodeDescriptorRequests>;
+
+        class VariableNodeDescriptorNotifications : public AZ::EBusTraits
+        {
+        public:
+            static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+            using BusIdType = AZ::EntityId;
+
+            virtual void OnNameChanged() {}
+        };
+
+        using VariableNodeDescriptorNotificationBus = AZ::EBus<VariableNodeDescriptorNotifications>;
+
+        class GetVariableNodeDescriptorRequests : public AZ::EBusTraits
+        {
+        public:
+            static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+            using BusIdType = AZ::EntityId;
+
+            virtual AZ::EntityId GetVariableId() const = 0;
+        };
+
+        using GetVariableNodeDescriptorRequestBus = AZ::EBus<GetVariableNodeDescriptorRequests>;
+
+        class SetVariableNodeDescriptorRequests : public AZ::EBusTraits
+        {
+        public:
+            static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+            using BusIdType = AZ::EntityId;
+
+            virtual AZ::EntityId GetVariableId() const = 0;
+        };
+
+        using SetVariableNodeDescriptorRequestBus = AZ::EBus<SetVariableNodeDescriptorRequests>;
+    }
+}