Merge pull request #1744 from aws-lumberyard-dev/carlitosan/thecleansing

Removal of dead runtime code from ScriptCanvas editor

Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Editor/GraphModelBus.h

@@ -90,19 +90,6 @@ namespace GraphCanvas
             return result;
         }
 
-        //! This is sent to confirm whether or not a variable assignment can take place.
-        virtual bool IsValidVariableAssignment(const AZ::EntityId& variableId, const Endpoint& targetPoint) const = 0;
-
-        //! This will return the structure needed to display why a variable could not be assigned to a specific reference inside of GraphCanvas.
-        virtual ConnectionValidationTooltip GetVariableAssignmentValidityTooltip(const AZ::EntityId& variableId, const Endpoint& targetPoint) const
-        {
-            ConnectionValidationTooltip result;
-
-            result.m_isValid = IsValidVariableAssignment(variableId, targetPoint);
-
-            return result;
-        }
-
         //! Get the Display Type name for the given AZ type
         virtual AZStd::string GetDataTypeString(const AZ::Uuid& typeId) = 0;
 

Gems/GraphModel/Code/Include/GraphModel/Integration/GraphController.h

@@ -147,8 +147,6 @@ namespace GraphModelIntegration
         bool CreateConnection(const AZ::EntityId& connectionUiId, const GraphCanvas::Endpoint& sourcePoint, const GraphCanvas::Endpoint& targetPoint) override;
 
         bool IsValidConnection(const GraphCanvas::Endpoint& sourcePoint, const GraphCanvas::Endpoint& targetPoint) const override;
-        bool IsValidVariableAssignment(const AZ::EntityId& variableId, const GraphCanvas::Endpoint& targetPoint) const override;
-
 
         ////////////////////////////////////////////////////////////////////////////////////
         // GraphCanvas::GraphModelRequestBus, undo

Gems/GraphModel/Code/Source/Integration/GraphController.cpp

@@ -1187,14 +1187,6 @@ namespace GraphModelIntegration
         return dataTypesMatch && !CheckForLoopback(sourceSlot->GetParentNode(), targetSlot->GetParentNode());
     }
 
-
-    bool GraphController::IsValidVariableAssignment([[maybe_unused]] const AZ::EntityId& variableId, [[maybe_unused]] const GraphCanvas::Endpoint& targetPoint) const
-    {
-        AZ_Assert(false, "This Graph Canvas does not support graph variables");
-        return false;
-    }
-    
-
     //! Helper function to create a GraphCanvas::NodePropertyDisplay and a data interface for editing input pin values
     //! \typename  DataInterfaceType  One of the data interface types. Ex: BooleanDataInterface
     //! \typename  CreateDisplayFunctionType  Function pointer type should be filled automatically

Gems/ScriptCanvas/Code/Asset/EditorAssetConversionBus.h

@@ -19,7 +19,6 @@ namespace AZ
 
 namespace ScriptCanvas
 {
-    class ScriptCanvasFunctionAsset;
     class RuntimeAsset;
     class SubgraphInterfaceAsset;
 }
@@ -27,7 +26,6 @@ namespace ScriptCanvas
 namespace ScriptCanvasEditor
 {
     class ScriptCanvasAsset;
-    class ScriptCanvasFunctionAsset;
 
     class EditorAssetConversionBusTraits
         : public AZ::EBusTraits
@@ -36,10 +34,8 @@ namespace ScriptCanvasEditor
         static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
       
         virtual AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset> LoadAsset(AZStd::string_view graphPath) = 0;
-        virtual AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset> LoadFunctionAsset(AZStd::string_view graphPath) = 0;
         virtual AZ::Outcome<ScriptCanvas::Translation::LuaAssetResult, AZStd::string> CreateLuaAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset>& editAsset, AZStd::string_view graphPathForRawLuaFile) = 0;
         virtual AZ::Outcome<AZ::Data::Asset<ScriptCanvas::RuntimeAsset>, AZStd::string> CreateRuntimeAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset>& editAsset) = 0;
-        virtual AZ::Outcome<AZ::Data::Asset<ScriptCanvas::SubgraphInterfaceAsset>, AZStd::string> CreateFunctionRuntimeAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset>& editAsset) = 0;
     };
 
     using EditorAssetConversionBus = AZ::EBus<EditorAssetConversionBusTraits>;

Gems/ScriptCanvas/Code/Asset/EditorAssetSystemComponent.cpp

@@ -28,9 +28,7 @@ AZ_PUSH_DISABLE_WARNING(4251 4800 4244, "-Wunknown-warning-option")
 #include <ScriptCanvas/Components/EditorGraphVariableManagerComponent.h>
 AZ_POP_DISABLE_WARNING
 
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
-#include <ScriptCanvas/Assets/Functions/ScriptCanvasFunctionAssetHandler.h>
-#include <ScriptCanvas/Asset/Functions/RuntimeFunctionAssetHandler.h>
+#include <ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.h>
 
 namespace ScriptCanvasEditor
 {
@@ -77,7 +75,6 @@ namespace ScriptCanvasEditor
     void EditorAssetSystemComponent::Activate()
     {
         m_editorAssetRegistry.Register<ScriptCanvasAsset, ScriptCanvasAssetHandler, ScriptCanvasAssetDescription>();
-        m_editorAssetRegistry.Register<ScriptCanvasEditor::ScriptCanvasFunctionAsset, ScriptCanvasFunctionAssetHandler, ScriptCanvasEditor::ScriptCanvasFunctionDescription>();
         m_editorAssetRegistry.Register<ScriptCanvas::SubgraphInterfaceAsset, ScriptCanvas::SubgraphInterfaceAssetHandler, ScriptCanvas::SubgraphInterfaceAssetDescription>();
 
         AzToolsFramework::AssetBrowser::AssetBrowserInteractionNotificationBus::Handler::BusConnect();
@@ -131,30 +128,11 @@ namespace ScriptCanvasEditor
         }
     }
 
-    AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset> EditorAssetSystemComponent::LoadFunctionAsset(AZStd::string_view graphPath)
-    {
-        auto outcome = ScriptCanvasBuilder::LoadEditorFunctionAsset(graphPath);
-
-        if (outcome.IsSuccess())
-        {
-            return outcome.GetValue();
-        }
-        else
-        {
-            return {};
-        }
-    }
-
     AZ::Outcome<AZ::Data::Asset<ScriptCanvas::RuntimeAsset>, AZStd::string> EditorAssetSystemComponent::CreateRuntimeAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset>& editAsset)
     {
         return ScriptCanvasBuilder::CreateRuntimeAsset(editAsset);
     }
 
-    AZ::Outcome<AZ::Data::Asset<ScriptCanvas::SubgraphInterfaceAsset>, AZStd::string> EditorAssetSystemComponent::CreateFunctionRuntimeAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset>& editAsset)
-    {
-        return ScriptCanvasBuilder::CreateRuntimeFunctionAsset(editAsset);
-    }
-
     AZ::Outcome<ScriptCanvas::Translation::LuaAssetResult, AZStd::string> EditorAssetSystemComponent::CreateLuaAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset>& editAsset, AZStd::string_view graphPathForRawLuaFile)
     {
         return ScriptCanvasBuilder::CreateLuaAsset(editAsset->GetScriptCanvasEntity(), editAsset->GetId(), graphPathForRawLuaFile);

Gems/ScriptCanvas/Code/Asset/EditorAssetSystemComponent.h

@@ -22,7 +22,6 @@
 namespace ScriptCanvasEditor
 {
     class ScriptCanvasAsset;
-    class ScriptCanvasFunctionAsset;
 
     class EditorAssetSystemComponent
         : public AZ::Component
@@ -57,9 +56,7 @@ namespace ScriptCanvasEditor
         //////////////////////////////////////////////////////////////////////////
         // EditorAssetConversionBus::Handler...
         AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset> LoadAsset(AZStd::string_view graphPath) override;
-        AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset> LoadFunctionAsset(AZStd::string_view graphPath) override;
         AZ::Outcome<AZ::Data::Asset<ScriptCanvas::RuntimeAsset>, AZStd::string> CreateRuntimeAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset>& editAsset) override;
-        AZ::Outcome<AZ::Data::Asset<ScriptCanvas::SubgraphInterfaceAsset>, AZStd::string> CreateFunctionRuntimeAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset>& editAsset) override;
         AZ::Outcome<ScriptCanvas::Translation::LuaAssetResult, AZStd::string> CreateLuaAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset>& editAsset, AZStd::string_view graphPathForRawLuaFile) override;
         //////////////////////////////////////////////////////////////////////////
         

Gems/ScriptCanvas/Code/Asset/RuntimeAssetSystemComponent.cpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
+ *
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
@@ -11,7 +11,7 @@
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
 #include <ScriptCanvas/Asset/RuntimeAssetHandler.h>
 #include <Asset/RuntimeAssetSystemComponent.h>
-#include <Asset/Functions/RuntimeFunctionAssetHandler.h>
+#include <Asset/SubgraphInterfaceAssetHandler.h>
 
 namespace ScriptCanvas
 {

Gems/ScriptCanvas/Code/Builder/ScriptCanvasBuilderComponent.cpp

@@ -5,19 +5,16 @@
  *
  */
 
-#include <precompiled.h>
-
 #include <AssetBuilderSDK/AssetBuilderBusses.h>
 #include <AzCore/std/containers/map.h>
 #include <AzToolsFramework/ToolsComponents/ToolsAssetCatalogBus.h>
 #include <Builder/ScriptCanvasBuilder.h>
 #include <Builder/ScriptCanvasBuilderComponent.h>
 #include <Builder/ScriptCanvasBuilderWorker.h>
-#include <ScriptCanvas/Asset/Functions/RuntimeFunctionAssetHandler.h>
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
 #include <ScriptCanvas/Asset/RuntimeAssetHandler.h>
-#include <ScriptCanvas/Assets/Functions/ScriptCanvasFunctionAssetHandler.h>
+#include <ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.h>
 #include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
+#include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
 #include <ScriptCanvas/Utils/BehaviorContextUtils.h>
 
 namespace ScriptCanvasBuilder
@@ -50,7 +47,6 @@ namespace ScriptCanvasBuilder
     SharedHandlers HandleAssetTypes()
     {
         SharedHandlers handlers;
-        handlers.m_editorFunctionAssetHandler = RegisterHandler<ScriptCanvasEditor::ScriptCanvasFunctionAsset, ScriptCanvasEditor::ScriptCanvasFunctionAssetHandler>("scriptcanvas_fn", false);
         handlers.m_editorAssetHandler = RegisterHandler<ScriptCanvasEditor::ScriptCanvasAsset, ScriptCanvasEditor::ScriptCanvasAssetHandler>("scriptcanvas", false);
         handlers.m_subgraphInterfaceHandler = RegisterHandler<ScriptCanvas::SubgraphInterfaceAsset, ScriptCanvas::SubgraphInterfaceAssetHandler>("scriptcanvas_fn_compiled", true);
         handlers.m_runtimeAssetHandler = RegisterHandler<ScriptCanvas::RuntimeAsset, JobDependencyVerificationHandler>("scriptcanvas_compiled", true);
@@ -105,31 +101,9 @@ namespace ScriptCanvasBuilder
             AzToolsFramework::ToolsAssetSystemBus::Broadcast(&AzToolsFramework::ToolsAssetSystemRequests::RegisterSourceAssetType, azrtti_typeid<ScriptCanvasEditor::ScriptCanvasAsset>(), ScriptCanvasEditor::ScriptCanvasAsset::Description::GetFileFilter<ScriptCanvasEditor::ScriptCanvasAsset>());
         }
 
-        {
-            AssetBuilderSDK::AssetBuilderDesc builderDescriptor;
-            builderDescriptor.m_name = "Script Canvas Function Builder";
-            builderDescriptor.m_patterns.push_back(AssetBuilderSDK::AssetBuilderPattern("*.scriptcanvas_fn", AssetBuilderSDK::AssetBuilderPattern::PatternType::Wildcard));
-            builderDescriptor.m_busId = ScriptCanvasBuilder::FunctionWorker::GetUUID();
-            builderDescriptor.m_createJobFunction = AZStd::bind(&FunctionWorker::CreateJobs, &m_scriptCanvasFunctionBuilder, AZStd::placeholders::_1, AZStd::placeholders::_2);
-            builderDescriptor.m_processJobFunction = AZStd::bind(&FunctionWorker::ProcessJob, &m_scriptCanvasFunctionBuilder, AZStd::placeholders::_1, AZStd::placeholders::_2);
-            // changing the version number invalidates all assets and will rebuild everything.
-            builderDescriptor.m_version = m_scriptCanvasFunctionBuilder.GetVersionNumber();
-            // changing the analysis fingerprint just invalidates analysis (ie, not the assets themselves)
-            // which will cause the "CreateJobs" function to be called, for each asset, even if the
-            // source file has not changed, but won't actually do the jobs unless the source file has changed
-            // or the fingerprint of the individual job is different.
-            builderDescriptor.m_analysisFingerprint = m_scriptCanvasFunctionBuilder.GetFingerprintString();
-            builderDescriptor.AddFlags(AssetBuilderSDK::AssetBuilderDesc::BF_DeleteLastKnownGoodProductOnFailure, s_scriptCanvasProcessJobKey);
-            builderDescriptor.m_productsToKeepOnFailure[s_scriptCanvasProcessJobKey] = { AZ_CRC("SubgraphInterface", 0xdfe6dc72) };
-            AssetBuilderSDK::AssetBuilderBus::Broadcast(&AssetBuilderSDK::AssetBuilderBus::Handler::RegisterBuilderInformation, builderDescriptor);
-            ScriptCanvas::Grammar::RequestBus::Handler::BusConnect();
-            AzToolsFramework::ToolsAssetSystemBus::Broadcast(&AzToolsFramework::ToolsAssetSystemRequests::RegisterSourceAssetType, azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>(), ScriptCanvasEditor::ScriptCanvasFunctionAsset::Description::GetFileFilter<ScriptCanvasEditor::ScriptCanvasFunctionAsset>());
-        }
-
         m_sharedHandlers = HandleAssetTypes();
         AssetHandlers workerHandlers(m_sharedHandlers);
         m_scriptCanvasBuilder.Activate(workerHandlers);
-        m_scriptCanvasFunctionBuilder.Activate(workerHandlers);
 
         ScriptCanvas::Translation::RequestBus::Handler::BusConnect();
         ScriptCanvas::Grammar::RequestBus::Handler::BusConnect();
@@ -139,15 +113,9 @@ namespace ScriptCanvasBuilder
     {
         // Finish all queued work
         AZ::Data::AssetBus::ExecuteQueuedEvents();
-        
         AzToolsFramework::ToolsAssetSystemBus::Broadcast(&AzToolsFramework::ToolsAssetSystemRequests::UnregisterSourceAssetType, azrtti_typeid<ScriptCanvasEditor::ScriptCanvasAsset>());
-        AzToolsFramework::ToolsAssetSystemBus::Broadcast(&AzToolsFramework::ToolsAssetSystemRequests::UnregisterSourceAssetType, azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>());
-
         m_scriptCanvasBuilder.BusDisconnect();
-        m_scriptCanvasFunctionBuilder.BusDisconnect();
-
         m_sharedHandlers.DeleteOwnedHandlers();
-
         ScriptCanvas::Translation::RequestBus::Handler::BusDisconnect();
         ScriptCanvas::Grammar::RequestBus::Handler::BusDisconnect();
     }

Gems/ScriptCanvas/Code/Builder/ScriptCanvasBuilderComponent.h

@@ -54,7 +54,6 @@ namespace ScriptCanvasBuilder
         SharedHandlers m_sharedHandlers;
 
         Worker m_scriptCanvasBuilder;
-        FunctionWorker m_scriptCanvasFunctionBuilder;
         ScriptCanvas::Translation::Context m_translationContext;
         ScriptCanvas::Grammar::Context m_grammarContext;
     };

Gems/ScriptCanvas/Code/Builder/ScriptCanvasBuilderWorker.cpp

@@ -8,7 +8,6 @@
 #include "precompiled.h"
 
 #include <Asset/AssetDescription.h>
-#include <Asset/Functions/ScriptCanvasFunctionAsset.h>
 #include <AssetBuilderSDK/SerializationDependencies.h>
 #include <AzCore/Asset/AssetManager.h>
 #include <AzCore/IO/FileIO.h>
@@ -18,9 +17,8 @@
 #include <AzFramework/Script/ScriptComponent.h>
 #include <AzFramework/StringFunc/StringFunc.h>
 
-#include <ScriptCanvas/Asset/Functions/RuntimeFunctionAssetHandler.h>
+#include <ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.h>
 #include <ScriptCanvas/Asset/RuntimeAssetHandler.h>
-#include <ScriptCanvas/Assets/Functions/ScriptCanvasFunctionAssetHandler.h>
 #include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
 #include <ScriptCanvas/Components/EditorGraph.h>
 #include <ScriptCanvas/Components/EditorGraphVariableManagerComponent.h>

Gems/ScriptCanvas/Code/Builder/ScriptCanvasBuilderWorker.h

@@ -36,8 +36,8 @@ namespace ScriptCanvasEditor
 {
     class Graph;
     class ScriptCanvasAsset;
-    class ScriptCanvasFunctionAsset;
 }
+
 namespace ScriptCanvasBuilder
 {
     constexpr const char* s_scriptCanvasBuilder = "ScriptCanvasBuilder";
@@ -122,8 +122,6 @@ namespace ScriptCanvasBuilder
 
     AZ::Outcome<AZ::Data::Asset<ScriptCanvas::RuntimeAsset>, AZStd::string> CreateRuntimeAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset>& asset);
 
-    AZ::Outcome<AZ::Data::Asset<ScriptCanvas::SubgraphInterfaceAsset>, AZStd::string> CreateRuntimeFunctionAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset>& asset);
-
     AZ::Outcome<ScriptCanvas::GraphData, AZStd::string> CompileGraphData(AZ::Entity* scriptCanvasEntity);
 
     AZ::Outcome<ScriptCanvas::VariableData, AZStd::string> CompileVariableData(AZ::Entity* scriptCanvasEntity);
@@ -134,8 +132,6 @@ namespace ScriptCanvasBuilder
 
     AZ::Outcome<AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset>, AZStd::string> LoadEditorAsset(AZStd::string_view graphPath, AZ::Data::AssetId assetId, AZ::Data::AssetFilterCB assetFilterCB = {});
 
-    AZ::Outcome<AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset>, AZStd::string> LoadEditorFunctionAsset(AZStd::string_view graphPath);
-
     AZ::Outcome<ScriptCanvas::Grammar::AbstractCodeModelConstPtr, AZStd::string> ParseGraph(AZ::Entity& buildEntity, AZStd::string_view graphPath);
 
     AZ::Outcome<void, AZStd::string> ProcessTranslationJob(ProcessTranslationJobInput& input);
@@ -179,37 +175,4 @@ namespace ScriptCanvasBuilder
         // cached on first time query
         mutable AZStd::string m_fingerprintString;
     };
-
-    class FunctionWorker
-        : public AssetBuilderSDK::AssetBuilderCommandBus::Handler
-    {
-    public:
-        static AZ::Uuid GetUUID();
-
-        FunctionWorker() = default;
-        FunctionWorker(const FunctionWorker&) = delete;
-
-        void Activate(const AssetHandlers& handlers);
-
-        //! Asset Builder Callback Functions
-        void CreateJobs(const AssetBuilderSDK::CreateJobsRequest& request, AssetBuilderSDK::CreateJobsResponse& response) const;
-
-        const char* GetFingerprintString() const;
-
-        int GetVersionNumber() const;
-
-        void ProcessJob(const AssetBuilderSDK::ProcessJobRequest& request, AssetBuilderSDK::ProcessJobResponse& response) const;
-
-        void ShutDown() override {};
-
-    private:
-        AZ::Data::AssetHandler* m_editorAssetHandler = nullptr;
-        AZ::Data::AssetHandler* m_runtimeAssetHandler = nullptr;
-        AZ::Data::AssetHandler* m_subgraphInterfaceHandler = nullptr;
-
-        mutable AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>> m_sourceDependencies;
-
-        // cached on first time query
-        mutable AZStd::string m_fingerprintString;
-    };
 }

Gems/ScriptCanvas/Code/Builder/ScriptCanvasBuilderWorkerUtility.cpp

@@ -8,7 +8,6 @@
 #include "precompiled.h"
 
 #include <Asset/AssetDescription.h>
-#include <Asset/Functions/ScriptCanvasFunctionAsset.h>
 #include <AssetBuilderSDK/SerializationDependencies.h>
 #include <AzCore/Asset/AssetManager.h>
 #include <AzCore/IO/FileIO.h>
@@ -18,10 +17,9 @@
 #include <AzFramework/Script/ScriptComponent.h>
 #include <AzFramework/StringFunc/StringFunc.h>
 #include <Builder/ScriptCanvasBuilderWorker.h>
-#include <ScriptCanvas/Asset/Functions/RuntimeFunctionAssetHandler.h>
+#include <ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.h>
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
 #include <ScriptCanvas/Asset/RuntimeAssetHandler.h>
-#include <ScriptCanvas/Assets/Functions/ScriptCanvasFunctionAssetHandler.h>
 #include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
 #include <ScriptCanvas/Components/EditorGraph.h>
 #include <ScriptCanvas/Components/EditorGraphVariableManagerComponent.h>
@@ -160,18 +158,6 @@ namespace ScriptCanvasBuilder
         return AZ::Success(runtimeAsset);
     }
 
-    AZ::Outcome<AZ::Data::Asset<ScriptCanvas::SubgraphInterfaceAsset>, AZStd::string> CreateRuntimeFunctionAsset(const AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset>& editAsset)
-    {
-        // Flush asset manager events to ensure no asset references are held by closures queued on Ebuses.
-        AZ::Data::AssetManager::Instance().DispatchEvents();
-
-        auto runtimeAssetId = editAsset.GetId();
-        runtimeAssetId.m_subId = AZ_CRC("SubgraphInterface", 0xdfe6dc72);
-        AZ::Data::Asset<ScriptCanvas::SubgraphInterfaceAsset> runtimeAsset;
-        runtimeAsset.Create(runtimeAssetId);
-        return AZ::Success(runtimeAsset);
-    }
-
     AZ::Outcome<ScriptCanvas::GraphData, AZStd::string> CompileGraphData(AZ::Entity* scriptCanvasEntity)
     {
         typedef AZStd::pair< ScriptCanvas::Node*, AZ::Entity* > NodeEntityPair;
@@ -452,48 +438,6 @@ namespace ScriptCanvasBuilder
         return AZ::Success(asset);
     }
 
-    AZ::Outcome<AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset>, AZStd::string> LoadEditorFunctionAsset(AZStd::string_view filePath)
-    {
-        AZStd::shared_ptr<AZ::Data::AssetDataStream> assetDataStream = AZStd::make_shared<AZ::Data::AssetDataStream>();
-
-        // Read the asset into a memory buffer, then hand ownership of the buffer to assetDataStream
-        {
-            AZ::IO::FileIOStream stream(filePath.data(), AZ::IO::OpenMode::ModeRead);
-            if (!AZ::IO::RetryOpenStream(stream))
-            {
-                return AZ::Failure(AZStd::string::format("File failed to open: %s", filePath.data()));
-            }
-            AZStd::vector<AZ::u8> fileBuffer(stream.GetLength());
-            size_t bytesRead = stream.Read(fileBuffer.size(), fileBuffer.data());
-            if (bytesRead != stream.GetLength())
-            {
-                return AZ::Failure(AZStd::string::format("File failed to open: %s", filePath.data()));
-            }
-
-            assetDataStream->Open(AZStd::move(fileBuffer));
-        }
-
-        AZ::IO::FileIOStream ioStream;
-        if (!ioStream.Open(filePath.data(), AZ::IO::OpenMode::ModeRead))
-        {
-            return AZ::Failure(AZStd::string::format("File failed to open: %s", filePath.data()));
-        }
-
-        ScriptCanvasEditor::ScriptCanvasFunctionAssetHandler editorAssetHandler;
-
-        AZ::SerializeContext* context{};
-        AZ::ComponentApplicationBus::BroadcastResult(context, &AZ::ComponentApplicationBus::Events::GetSerializeContext);
-        AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset> asset;
-        asset.Create(AZ::Data::AssetId(AZ::Uuid::CreateRandom()));
-
-        if (editorAssetHandler.LoadAssetData(asset, assetDataStream, AZ::Data::AssetFilterCB{}) != AZ::Data::AssetHandler::LoadResult::LoadComplete)
-        {
-            return AZ::Failure(AZStd::string::format("Failed to load ScriptCavas Function asset: %s", filePath.data()));
-        }
-
-        return AZ::Success(asset);
-    }
-
     ScriptCanvasEditor::Graph* PrepareSourceGraph(AZ::Entity* const buildEntity)
     {
         auto sourceGraph = AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvasEditor::Graph>(buildEntity);

Gems/ScriptCanvas/Code/Builder/ScriptCanvasFunctionBuilderWorker.cpp

@@ -1,338 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "precompiled.h"
-
-#include "platform.h"
-#include <Asset/AssetDescription.h>
-#include <Asset/Functions/ScriptCanvasFunctionAsset.h>
-#include <AssetBuilderSDK/SerializationDependencies.h>
-#include <AzCore/Asset/AssetManager.h>
-#include <AzCore/IO/FileIO.h>
-#include <AzCore/IO/IOUtils.h>
-#include <AzCore/Math/Uuid.h>
-#include <AzCore/Serialization/SerializeContext.h>
-#include <AzCore/std/string/conversions.h>
-#include <AzFramework/Script/ScriptComponent.h>
-#include <AzFramework/StringFunc/StringFunc.h>
-#include <Builder/ScriptCanvasBuilderWorker.h>
-#include <ScriptCanvas/Asset/Functions/RuntimeFunctionAssetHandler.h>
-#include <ScriptCanvas/Asset/RuntimeAssetHandler.h>
-#include <ScriptCanvas/Assets/Functions/ScriptCanvasFunctionAssetHandler.h>
-#include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
-#include <ScriptCanvas/Components/EditorGraph.h>
-#include <ScriptCanvas/Components/EditorGraphVariableManagerComponent.h>
-#include <ScriptCanvas/Core/Connection.h>
-#include <ScriptCanvas/Core/Node.h>
-#include <ScriptCanvas/Grammar/AbstractCodeModel.h>
-#include <ScriptCanvas/Results/ErrorText.h>
-#include <ScriptCanvas/Utils/BehaviorContextUtils.h>
-
-namespace ScriptCanvasBuilder
-{
-    void FunctionWorker::Activate(const AssetHandlers& handlers)
-    {
-        m_editorAssetHandler = handlers.m_editorFunctionAssetHandler;
-        m_runtimeAssetHandler = handlers.m_runtimeAssetHandler;
-        m_subgraphInterfaceHandler = handlers.m_subgraphInterfaceHandler;
-    }
-
-    void FunctionWorker::CreateJobs(const AssetBuilderSDK::CreateJobsRequest& request, AssetBuilderSDK::CreateJobsResponse& response) const
-    {
-        AZ_TracePrintf(s_scriptCanvasBuilder, "Start Creating Job");
-        AZStd::string fullPath;
-        AzFramework::StringFunc::Path::ConstructFull(request.m_watchFolder.data(), request.m_sourceFile.data(), fullPath, false);
-        AzFramework::StringFunc::Path::Normalize(fullPath);
-
-        if (!m_editorAssetHandler)
-        {
-            AZ_Error(s_scriptCanvasBuilder, false, R"(CreateJobs for %s failed because the ScriptCanvas Editor Asset handler is missing.)", fullPath.data());
-        }
-
-        AZStd::shared_ptr<AZ::Data::AssetDataStream> assetDataStream = AZStd::make_shared<AZ::Data::AssetDataStream>();
-
-        // Read the asset into a memory buffer, then hand ownership of the buffer to assetDataStream
-        {
-            AZ::IO::FileIOStream stream(fullPath.c_str(), AZ::IO::OpenMode::ModeRead);
-            if (!AZ::IO::RetryOpenStream(stream))
-            {
-                AZ_Warning(s_scriptCanvasBuilder, false, "CreateJobs for \"%s\" failed because the source file could not be opened.", fullPath.data());
-                return;
-            }
-            AZStd::vector<AZ::u8> fileBuffer(stream.GetLength());
-            size_t bytesRead = stream.Read(fileBuffer.size(), fileBuffer.data());
-            if (bytesRead != stream.GetLength())
-            {
-                AZ_Warning(s_scriptCanvasBuilder, false, "CreateJobs for \"%s\" failed because the source file could not be read.", fullPath.data());
-                return;
-            }
-
-            assetDataStream->Open(AZStd::move(fileBuffer));
-        }
-
-        m_sourceDependencies.clear();
-
-        auto assetFilter = [&response, this](const AZ::Data::AssetFilterInfo& filterInfo)
-        {
-            if (filterInfo.m_assetType == azrtti_typeid<ScriptCanvasEditor::ScriptCanvasAsset>() ||
-                filterInfo.m_assetType == azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>() ||
-                filterInfo.m_assetType == azrtti_typeid<ScriptEvents::ScriptEventsAsset>() ||
-                filterInfo.m_assetType == azrtti_typeid<ScriptCanvas::SubgraphInterfaceAsset>()) // this required, since nodes reference this, rather than the editor asset
-            {
-                AssetBuilderSDK::SourceFileDependency dependency;
-                dependency.m_sourceFileDependencyUUID = filterInfo.m_assetId.m_guid;
-
-                response.m_sourceFileDependencyList.push_back(dependency);
-            }
-
-            // Asset filter always returns false to prevent parsing dependencies, but makes note of the script canvas dependencies
-            return false;
-        };
-
-        AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset> asset;
-        asset.Create(AZ::Data::AssetId(AZ::Uuid::CreateRandom()));
-        ScriptCanvasEditor::ScriptCanvasFunctionAssetHandler* functionAssetHandler = azrtti_cast<ScriptCanvasEditor::ScriptCanvasFunctionAssetHandler*>(m_editorAssetHandler);
-        if (functionAssetHandler->LoadAssetData(asset, assetDataStream, assetFilter) != AZ::Data::AssetHandler::LoadResult::LoadComplete)
-        {
-            AZ_Warning(s_scriptCanvasBuilder, false, "CreateJobs for \"%s\" failed because the asset data could not be loaded from the file", fullPath.data());
-            return;
-        }
-
-        // Flush asset database events to ensure no asset references are held by closures queued on Ebuses.
-        AZ::Data::AssetManager::Instance().DispatchEvents();
-
-        auto* scriptCanvasEntity = asset.Get()->GetScriptCanvasEntity();
-        auto* sourceGraph = AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvasEditor::Graph>(scriptCanvasEntity);
-        AZ_Assert(sourceGraph, "Graph component is missing from entity.");
-        size_t fingerprint = 0;
-        const AZStd::set<AZ::Entity*> sortedEntities(sourceGraph->GetGraphData()->m_nodes.begin(), sourceGraph->GetGraphData()->m_nodes.end());
-        for (auto& nodeEntity : sortedEntities)
-        {
-            if (auto nodeComponent = AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvas::Node>(nodeEntity))
-            {
-                AZStd::hash_combine(fingerprint, nodeComponent->GenerateFingerprint());
-            }
-        }
-
-#if defined(FUNCTION_LEGACY_SUPPORT_ENABLED)
-        for (const AssetBuilderSDK::PlatformInfo& info : request.m_enabledPlatforms)
-        {
-            if (info.HasTag("tools"))
-            {
-                AssetBuilderSDK::JobDescriptor copyDescriptor;
-                copyDescriptor.m_priority = 2;
-                copyDescriptor.m_critical = true;
-                copyDescriptor.m_jobKey = s_scriptCanvasCopyJobKey;
-                copyDescriptor.SetPlatformIdentifier(info.m_identifier.c_str());
-                copyDescriptor.m_additionalFingerprintInfo = AZStd::string(GetFingerprintString()).append("|").append(AZStd::to_string(static_cast<AZ::u64>(fingerprint)));
-                response.m_createJobOutputs.push_back(copyDescriptor);
-        }
-
-            AssetBuilderSDK::JobDescriptor jobDescriptor;
-            jobDescriptor.m_priority = 2;
-            jobDescriptor.m_critical = true;
-            jobDescriptor.m_jobKey = s_scriptCanvasProcessJobKey;
-            jobDescriptor.SetPlatformIdentifier(info.m_identifier.c_str());
-            jobDescriptor.m_additionalFingerprintInfo = AZStd::string(GetFingerprintString()).append("|").append(AZStd::to_string(static_cast<AZ::u64>(fingerprint)));
-            // Function process job needs to wait until its dependency asset job finished
-            for (const auto& sourceDependency : response.m_sourceFileDependencyList)
-            {
-                AssetBuilderSDK::JobDependency jobDep(s_scriptCanvasBuilder, info.m_identifier.c_str(), AssetBuilderSDK::JobDependencyType::OrderOnce, sourceDependency);
-                jobDescriptor.m_jobDependencyList.emplace_back(jobDep);
-            }
-            response.m_createJobOutputs.push_back(jobDescriptor);
-        }
-#endif
-
-        response.m_result = AssetBuilderSDK::CreateJobsResultCode::Success;
-        AZ_TracePrintf(s_scriptCanvasBuilder, "Finish Creating Job");
-    }
-
-    
-
-    const char* FunctionWorker::GetFingerprintString() const
-    {
-        if (m_fingerprintString.empty())
-        {
-            // compute it the first time
-            const AZStd::string runtimeAssetTypeId = azrtti_typeid<ScriptCanvas::SubgraphInterfaceAsset>().ToString<AZStd::string>();
-            m_fingerprintString = AZStd::string::format("%i%s", GetVersionNumber(), runtimeAssetTypeId.c_str());
-        }
-        return m_fingerprintString.c_str();
-    }
-
-    int FunctionWorker::GetVersionNumber() const
-    {
-        return GetBuilderVersion();
-    }
-
-    AZ::Uuid FunctionWorker::GetUUID()
-    {
-        return AZ::Uuid::CreateString("{7227E0E1-4113-456A-877B-B2276ACB292B}");
-    }
-
-
-    void FunctionWorker::ProcessJob(const AssetBuilderSDK::ProcessJobRequest& request, AssetBuilderSDK::ProcessJobResponse& response) const
-    {
-        AZ_TracePrintf(s_scriptCanvasBuilder, "Start Processing Job");
-        // A runtime script canvas component is generated, which creates a .scriptcanvas_compiled file
-        AZStd::string fullPath;
-        AZStd::string fileNameOnly;
-        AzFramework::StringFunc::Path::GetFullFileName(request.m_sourceFile.c_str(), fileNameOnly);
-        fullPath = request.m_fullPath.c_str();
-        AzFramework::StringFunc::Path::Normalize(fullPath);
-
-        bool pathFound = false;
-        AZStd::string relativePath;
-        AzToolsFramework::AssetSystemRequestBus::BroadcastResult
-            ( pathFound
-            , &AzToolsFramework::AssetSystem::AssetSystemRequest::GetRelativeProductPathFromFullSourceOrProductPath
-            , request.m_fullPath.c_str(), relativePath);
-
-        if (!pathFound)
-        {
-            AZ_Error(s_scriptCanvasBuilder, false, "Failed to get engine relative path from %s", request.m_fullPath.c_str());
-            return;
-        }
-
-        if (!m_editorAssetHandler)
-        {
-            AZ_Error(s_scriptCanvasBuilder, false, R"(Exporting of .scriptcanvas for "%s" file failed as no editor asset handler was registered for script canvas. The ScriptCanvas Gem might not be enabled.)", fullPath.data());
-            return;
-        }
-
-        if (!m_runtimeAssetHandler)
-        {
-            AZ_Error(s_scriptCanvasBuilder, false, R"(Exporting of .scriptcanvas for "%s" file failed as no runtime asset handler was registered for script canvas.)", fullPath.data());
-            return;
-        }
-
-        AZStd::shared_ptr<AZ::Data::AssetDataStream> assetDataStream = AZStd::make_shared<AZ::Data::AssetDataStream>();
-
-        // Read the asset into a memory buffer, then hand ownership of the buffer to assetDataStream
-        {
-            AZ::IO::FileIOStream stream(fullPath.data(), AZ::IO::OpenMode::ModeRead);
-            if (!AZ::IO::RetryOpenStream(stream))
-            {
-                AZ_Warning(s_scriptCanvasBuilder, false, "Exporting of .scriptcanvas for \"%s\" failed because the source file could not be opened.", fullPath.c_str());
-                return;
-            }
-            AZStd::vector<AZ::u8> fileBuffer(stream.GetLength());
-            size_t bytesRead = stream.Read(fileBuffer.size(), fileBuffer.data());
-            if (bytesRead != stream.GetLength())
-            {
-                AZ_Warning(s_scriptCanvasBuilder, false, "Exporting of .scriptcanvas for \"%s\" failed because the source file could not be opened.", fullPath.c_str());
-                return;
-            }
-
-            assetDataStream->Open(AZStd::move(fileBuffer));
-        }
-
-        AZ::SerializeContext* context{};
-        AZ::ComponentApplicationBus::BroadcastResult(context, &AZ::ComponentApplicationBus::Events::GetSerializeContext);
-
-        AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset> asset;
-        asset.Create(request.m_sourceFileUUID);
-        ScriptCanvasEditor::ScriptCanvasFunctionAssetHandler* functionAssetHandler = azrtti_cast<ScriptCanvasEditor::ScriptCanvasFunctionAssetHandler*>(m_editorAssetHandler);
-        if (functionAssetHandler->LoadAssetData(asset, assetDataStream, nullptr) != AZ::Data::AssetHandler::LoadResult::LoadComplete)
-        {
-            AZ_Error(s_scriptCanvasBuilder, false, R"(Loading of ScriptCanvas asset for source file "%s" has failed)", fullPath.data());
-            return;
-        }
-
-        // Flush asset manager events to ensure no asset references are held by closures queued on Ebuses.
-        AZ::Data::AssetManager::Instance().DispatchEvents();
-
-        AZStd::string runtimeScriptCanvasOutputPath;
-        AzFramework::StringFunc::Path::Join(request.m_tempDirPath.c_str(), fileNameOnly.c_str(), runtimeScriptCanvasOutputPath, true, true);
-        AzFramework::StringFunc::Path::ReplaceExtension(runtimeScriptCanvasOutputPath, ScriptCanvas::SubgraphInterfaceAsset::GetFileExtension());
-
-        if (request.m_jobDescription.m_jobKey == s_scriptCanvasCopyJobKey)
-        {
-            // ScriptCanvas Editor Asset Copy job
-            // The SubID is zero as this represents the main asset
-            AssetBuilderSDK::JobProduct jobProduct;
-            jobProduct.m_productFileName = fullPath;
-            jobProduct.m_productAssetType = azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>();
-            jobProduct.m_productSubID = 0;
-            jobProduct.m_dependenciesHandled = true;
-            response.m_outputProducts.push_back(AZStd::move(jobProduct));
-            response.m_resultCode = AssetBuilderSDK::ProcessJobResult_Success;
-        }
-        else
-        {
-            // force load all dependencies into memory
-            for (auto& dependency : m_sourceDependencies)
-            {
-                AZ::Data::AssetManager::Instance().GetAsset(dependency.GetId(), dependency.GetType(), AZ::Data::AssetLoadBehavior::PreLoad);
-            }
-
-            AZ::Entity* buildEntity = asset.Get()->GetScriptCanvasEntity();
-
-            ProcessTranslationJobInput input;
-            input.assetID = AZ::Data::AssetId(request.m_sourceFileUUID, AZ_CRC("RuntimeData", 0x163310ae));
-            input.request = &request;
-            input.response = &response;
-            input.runtimeScriptCanvasOutputPath = runtimeScriptCanvasOutputPath;
-            input.assetHandler = m_runtimeAssetHandler;
-            input.buildEntity = buildEntity;
-            input.fullPath = fullPath;
-            input.fileNameOnly = fileNameOnly;
-            input.namespacePath = relativePath;
-            input.saveRawLua = true;
-
-            auto translationOutcome = ProcessTranslationJob(input);
-            if (translationOutcome.IsSuccess())
-            {
-                AzFramework::StringFunc::Path::ReplaceExtension(input.runtimeScriptCanvasOutputPath, ScriptCanvas::RuntimeAsset::GetFileExtension());
-                auto saveRuntimAssetOutcome = SaveRuntimeAsset(input, input.runtimeDataOut);
-                if (saveRuntimAssetOutcome.IsSuccess())
-                {
-                    // \todo this file is only required on PC editor builds, cull it in packaging, here or wherever appropriate
-                    AzFramework::StringFunc::Path::StripExtension(fileNameOnly);
-
-                    ScriptCanvas::SubgraphInterfaceData functionInterface;
-                    functionInterface.m_name = fileNameOnly;
-                    functionInterface.m_interface = AZStd::move(input.interfaceOut);
-
-                    // save function interface
-                    input.assetHandler = m_subgraphInterfaceHandler;
-
-                    AzFramework::StringFunc::Path::ReplaceExtension(input.runtimeScriptCanvasOutputPath, ScriptCanvas::SubgraphInterfaceAsset::GetFileExtension());
-                    auto saveInterfaceOutcome = SaveSubgraphInterface(input, functionInterface);
-                    if (saveInterfaceOutcome.IsSuccess())
-                    {
-                        response.m_resultCode = AssetBuilderSDK::ProcessJobResult_Success;
-                    }
-                    else
-                    {
-                        AZ_Error(s_scriptCanvasBuilder, false, saveInterfaceOutcome.GetError().data());
-                    }
-                }
-                else
-                {
-                    AZ_Error(s_scriptCanvasBuilder, false, saveRuntimAssetOutcome.GetError().data());
-                }
-            }
-            else if (AzFramework::StringFunc::Find(translationOutcome.GetError().data(), ScriptCanvas::ParseErrors::SourceUpdateRequired) != AZStd::string::npos)
-            {
-                AZ_Warning(s_scriptCanvasBuilder, false, ScriptCanvas::ParseErrors::SourceUpdateRequired);
-                response.m_resultCode = AssetBuilderSDK::ProcessJobResult_Success;
-            }
-            else if (AzFramework::StringFunc::Find(fileNameOnly, s_unitTestParseErrorPrefix) != AZStd::string::npos)
-            {
-                response.m_resultCode = AssetBuilderSDK::ProcessJobResult_Success;
-            }
-            else
-            {
-                AZ_Warning(s_scriptCanvasBuilder, false, translationOutcome.GetError().data());
-            }
-        }
-
-        AZ_TracePrintf(s_scriptCanvasBuilder, "Finish Processing Job");
-    }
-}

Gems/ScriptCanvas/Code/Editor/Assets/Functions/ScriptCanvasFunctionAssetHandler.cpp

@@ -1,157 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "precompiled.h"
-
-#include <ScriptCanvas/Assets/Functions/ScriptCanvasFunctionAssetHandler.h>
-
-#include <ScriptCanvas/Asset/RuntimeAsset.h>
-#include <ScriptCanvas/Bus/ScriptCanvasBus.h>
-#include <Core/ScriptCanvasBus.h>
-#include <ScriptCanvas/Components/EditorGraph.h>
-#include <ScriptCanvas/Components/EditorScriptCanvasComponent.h>
-#include <ScriptCanvas/Components/EditorGraphVariableManagerComponent.h>
-
-#include <GraphCanvas/GraphCanvasBus.h>
-
-#include <AzCore/IO/GenericStreams.h>
-#include <AzCore/IO/FileIO.h>
-#include <AzCore/Serialization/Utils.h>
-#include <AzCore/Serialization/SerializeContext.h>
-#include <AzCore/Component/ComponentApplicationBus.h>
-#include <AzCore/Component/Entity.h>
-#include <AzCore/std/string/string_view.h>
-
-#include <AzFramework/StringFunc/StringFunc.h>
-#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
-
-namespace ScriptCanvasEditor
-{
-    ScriptCanvasFunctionAssetHandler::ScriptCanvasFunctionAssetHandler(AZ::SerializeContext* context)
-        : ScriptCanvasAssetHandler(context)
-    {
-        AZ::AssetTypeInfoBus::MultiHandler::BusConnect(azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>());
-    }
-
-    ScriptCanvasFunctionAssetHandler::~ScriptCanvasFunctionAssetHandler()
-    {
-        AZ::AssetTypeInfoBus::MultiHandler::BusDisconnect();
-    }
-
-    AZ::Data::AssetPtr ScriptCanvasFunctionAssetHandler::CreateAsset(const AZ::Data::AssetId& id, const AZ::Data::AssetType& type)
-    {
-        AZ_UNUSED(type);
-
-        ScriptCanvasEditor::ScriptCanvasFunctionAsset* assetData = aznew ScriptCanvasEditor::ScriptCanvasFunctionAsset(id);
-
-        AZ::Entity* scriptCanvasEntity = aznew AZ::Entity(ScriptCanvas::AssetDescription::GetEntityName<ScriptCanvasEditor::ScriptCanvasFunctionAsset>());
-        SystemRequestBus::Broadcast(&SystemRequests::CreateEditorComponentsOnEntity, scriptCanvasEntity, azrtti_typeid<ScriptCanvas::SubgraphInterfaceAsset>());
-        assetData->m_cachedComponent = scriptCanvasEntity->CreateComponent<ScriptCanvasEditor::ScriptCanvasFunctionDataComponent>();
-
-        assetData->SetScriptCanvasEntity(scriptCanvasEntity);
-
-        return assetData;
-    }
-
-    AZ::Data::AssetHandler::LoadResult ScriptCanvasFunctionAssetHandler::LoadAssetData(
-        const AZ::Data::Asset<AZ::Data::AssetData>& asset,
-        AZStd::shared_ptr<AZ::Data::AssetDataStream> stream,
-        const AZ::Data::AssetFilterCB& assetLoadFilterCB)
-    {
-        ScriptCanvasEditor::ScriptCanvasFunctionAsset* scriptCanvasAsset = asset.GetAs<ScriptCanvasEditor::ScriptCanvasFunctionAsset>();
-        AZ_Assert(m_serializeContext, "ScriptCanvasFunctionAssetHandler needs to be initialized with a SerializeContext");
-
-        if (scriptCanvasAsset)
-        {
-            stream->Seek(0U, AZ::IO::GenericStream::ST_SEEK_BEGIN);
-
-            bool loadSuccess = AZ::Utils::LoadObjectFromStreamInPlace(*stream, scriptCanvasAsset->GetScriptCanvasData(), m_serializeContext, AZ::ObjectStream::FilterDescriptor(assetLoadFilterCB, AZ::ObjectStream::FILTERFLAG_IGNORE_UNKNOWN_CLASSES));
-            if (loadSuccess)
-            {
-                scriptCanvasAsset->m_cachedComponent = scriptCanvasAsset->GetScriptCanvasData().GetScriptCanvasEntity()->FindComponent<ScriptCanvasEditor::ScriptCanvasFunctionDataComponent>();
-            }
-
-            return loadSuccess ? AZ::Data::AssetHandler::LoadResult::LoadComplete : AZ::Data::AssetHandler::LoadResult::Error;
-        }
-        return AZ::Data::AssetHandler::LoadResult::Error;
-    }
-
-    bool ScriptCanvasFunctionAssetHandler::SaveAssetData(const AZ::Data::Asset<AZ::Data::AssetData>& asset, AZ::IO::GenericStream* stream)
-    {
-        return SaveAssetData(asset.GetAs<ScriptCanvasEditor::ScriptCanvasFunctionAsset>(), stream);
-    }
-
-    bool ScriptCanvasFunctionAssetHandler::SaveAssetData(const ScriptCanvasEditor::ScriptCanvasFunctionAsset* assetData, AZ::IO::GenericStream* stream)
-    {
-        return SaveAssetData(assetData, stream, AZ::DataStream::ST_XML);
-    }
-
-    bool ScriptCanvasFunctionAssetHandler::SaveAssetData(const ScriptCanvasEditor::ScriptCanvasFunctionAsset* assetData, AZ::IO::GenericStream* stream, AZ::DataStream::StreamType streamType)
-    {
-        if (assetData && m_serializeContext)
-        {
-            AZStd::vector<char> byteBuffer;
-            AZ::IO::ByteContainerStream<decltype(byteBuffer)> byteStream(&byteBuffer);
-            AZ::ObjectStream* objStream = AZ::ObjectStream::Create(&byteStream, *m_serializeContext, streamType);
-
-            const ScriptCanvas::ScriptCanvasData& functionData = assetData->GetScriptCanvasData();
-            bool assetSaved = objStream->WriteClass(&functionData);
-            objStream->Finalize();
-            assetSaved = stream->Write(byteBuffer.size(), byteBuffer.data()) == byteBuffer.size() && assetSaved;
-            return assetSaved;
-        }
-
-        return false;
-    }
-
-    AZ::Data::AssetType ScriptCanvasFunctionAssetHandler::GetAssetType() const
-    {
-        return ScriptCanvasFunctionAssetHandler::GetAssetTypeStatic();
-    }
-
-    const char* ScriptCanvasFunctionAssetHandler::GetAssetTypeDisplayName() const
-    {
-        return ScriptCanvas::AssetDescription::GetAssetTypeDisplayName<ScriptCanvasEditor::ScriptCanvasFunctionAsset>();
-    }
-
-    bool ScriptCanvasFunctionAssetHandler::CanCreateComponent([[maybe_unused]] const AZ::Data::AssetId& assetId) const
-    {
-        return false;
-    }
-
-    void ScriptCanvasFunctionAssetHandler::GetAssetTypeExtensions(AZStd::vector<AZStd::string>& extensions)
-    {
-        const AZ::Uuid& assetType = *AZ::AssetTypeInfoBus::GetCurrentBusId();
-        if (assetType == AZ::AzTypeInfo<ScriptCanvasEditor::ScriptCanvasFunctionAsset>::Uuid())
-        {
-            extensions.push_back(ScriptCanvas::AssetDescription::GetExtension<ScriptCanvasEditor::ScriptCanvasFunctionAsset>());
-        }
-    }
-
-    void ScriptCanvasFunctionAssetHandler::GetHandledAssetTypes(AZStd::vector<AZ::Data::AssetType>& assetTypes)
-    {
-        assetTypes.push_back(AZ::AzTypeInfo<ScriptCanvasEditor::ScriptCanvasFunctionAsset>::Uuid());
-    }
-
-
-    AZ::Data::AssetType ScriptCanvasFunctionAssetHandler::GetAssetTypeStatic()
-    {
-        return azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>();
-    }
-
-    const char* ScriptCanvasFunctionAssetHandler::GetGroup() const
-    {
-        return ScriptCanvas::AssetDescription::GetGroup<ScriptCanvasEditor::ScriptCanvasFunctionAsset>();
-    }
-
-    const char* ScriptCanvasFunctionAssetHandler::GetBrowserIcon() const
-    {
-        return ScriptCanvas::AssetDescription::GetIconPath<ScriptCanvasEditor::ScriptCanvasFunctionAsset>();
-    }
-
-}

Gems/ScriptCanvas/Code/Editor/Assets/Functions/ScriptCanvasFunctionAssetHolder.cpp

@@ -1,201 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#include "precompiled.h"
-
-#include <LyViewPaneNames.h>
-
-#include <Editor/Assets/Functions/ScriptCanvasFunctionAssetHolder.h>
-
-#include <ScriptCanvas/Asset/AssetRegistry.h>
-#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
-#include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
-#include <ScriptCanvas/Bus/EditorScriptCanvasBus.h>
-#include <ScriptCanvas/Bus/RequestBus.h>
-#include <ScriptCanvas/Bus/ScriptCanvasBus.h>
-#include <ScriptCanvas/Core/ScriptCanvasBus.h>
-
-#include <AzCore/Serialization/EditContext.h>
-#include <AzCore/Component/ComponentApplicationBus.h>
-#include <AzCore/Serialization/IdUtils.h>
-#include <AzCore/Asset/AssetManager.h>
-
-#include <AzToolsFramework/API/ToolsApplicationAPI.h>
-
-namespace ScriptCanvasEditor
-{
-    //=========================================================================
-    void ScriptCanvasFunctionAssetHolder::Reflect(AZ::ReflectContext* context)
-    {
-        if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
-        {
-            serializeContext->Class<ScriptCanvasFunctionAssetHolder>()
-                ->Version(1)
-                ->Field("m_asset", &ScriptCanvasFunctionAssetHolder::m_scriptCanvasAssetId)
-                ;
-
-            if (AZ::EditContext* editContext = serializeContext->GetEditContext())
-            {
-                editContext->Class<ScriptCanvasFunctionAssetHolder>("Script Canvas", "Script Canvas Function Asset Holder")
-                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
-                    ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasFunctionAssetHolder::m_scriptCanvasAssetId, "Script Canvas Function Asset", "Script Canvas asset associated with this component")
-                    ->Attribute(AZ::Edit::Attributes::ChangeNotify, &ScriptCanvasFunctionAssetHolder::OnScriptChanged)
-                    ->Attribute("EditButton", "Editor/Icons/PropertyEditor/open_in.png")
-                    ->Attribute("EditDescription", "Open in Script Canvas Editor")
-                    ->Attribute("EditCallback", &ScriptCanvasFunctionAssetHolder::LaunchScriptCanvasEditor)
-                    ;
-            }
-        }
-    }
-
-    ScriptCanvasFunctionAssetHolder::ScriptCanvasFunctionAssetHolder(AZ::Data::AssetId assetId, const ScriptChangedCB& scriptChangedCB)
-        : m_scriptCanvasAssetId(assetId)
-        , m_scriptNotifyCallback(scriptChangedCB)
-    {
-    }
-
-    ScriptCanvasFunctionAssetHolder::~ScriptCanvasFunctionAssetHolder()
-    {
-        AZ::Data::AssetBus::Handler::BusDisconnect();
-    }
-
-    void ScriptCanvasFunctionAssetHolder::Init(AZ::EntityId ownerId)
-    {
-        m_ownerId = ownerId;
-
-        if (m_scriptCanvasAssetId.IsValid())
-        {
-            AZ::Data::AssetBus::Handler::BusDisconnect();
-            AZ::Data::AssetBus::Handler::BusConnect(m_scriptCanvasAssetId);
-        }
-    }
-
-    void ScriptCanvasFunctionAssetHolder::LaunchScriptCanvasEditor(const AZ::Data::AssetId&, const AZ::Data::AssetType&) const
-    {
-        OpenEditor();
-    }
-
-    void ScriptCanvasFunctionAssetHolder::OpenEditor() const
-    {
-        AzToolsFramework::OpenViewPane(LyViewPane::ScriptCanvas);
-
-        AZ::Outcome<int, AZStd::string> openOutcome = AZ::Failure(AZStd::string());
-
-        if (m_scriptCanvasAssetId.IsValid())
-        {
-            GeneralRequestBus::BroadcastResult(openOutcome, &GeneralRequests::OpenScriptCanvasAsset, m_scriptCanvasAssetId, -1);
-
-            if (!openOutcome)
-            {
-                AZ_Warning("Script Canvas", openOutcome, "%s", openOutcome.GetError().data());
-            }
-        }
-        else if (m_ownerId.IsValid())
-        {
-            AzToolsFramework::EntityIdList selectedEntityIds;
-            AzToolsFramework::ToolsApplicationRequestBus::BroadcastResult(selectedEntityIds, &AzToolsFramework::ToolsApplicationRequests::GetSelectedEntities);
-
-            // Going to bypass the multiple selected entities flow for right now.
-            if (selectedEntityIds.size() == 1)
-            {
-                GeneralRequestBus::Broadcast(&GeneralRequests::CreateScriptCanvasAssetFor, m_ownerId);
-            }
-        }        
-    }
-
-    AZ::EntityId ScriptCanvasFunctionAssetHolder::GetGraphId() const
-    {
-        AZ::EntityId graphId;
-        if (m_scriptCanvasAsset.IsReady())
-        {
-            ScriptCanvas::SystemRequestBus::BroadcastResult(graphId, &ScriptCanvas::SystemRequests::FindGraphId, m_scriptCanvasAsset.Get()->GetScriptCanvasEntity());
-        }
-        return graphId;
-    }
-
-    void ScriptCanvasFunctionAssetHolder::SetScriptChangedCB(const ScriptChangedCB& scriptChangedCB)
-    {
-        m_scriptNotifyCallback = scriptChangedCB;
-    }
-
-    void ScriptCanvasFunctionAssetHolder::Load(bool loadBlocking)
-    {
-        if (!m_scriptCanvasAsset.IsReady())
-        {
-            AZ::Data::AssetInfo assetInfo;
-            AZ::Data::AssetCatalogRequestBus::BroadcastResult(assetInfo, &AZ::Data::AssetCatalogRequests::GetAssetInfoById, m_scriptCanvasAsset.GetId());
-            if (assetInfo.m_assetId.IsValid())
-            {
-                const AZ::Data::AssetType assetTypeId = azrtti_typeid<ScriptCanvasAsset>();
-                auto& assetManager = AZ::Data::AssetManager::Instance();
-                m_scriptCanvasAsset = assetManager.GetAsset(m_scriptCanvasAsset.GetId(), azrtti_typeid<ScriptCanvasAsset>(), true, nullptr, loadBlocking);
-            }
-        }
-    }
-
-    AZ::u32 ScriptCanvasFunctionAssetHolder::OnScriptChanged()
-    {
-        SetAsset(m_scriptCanvasAsset.GetId());
-        Load(false);
-
-        if (m_scriptNotifyCallback)
-        {
-            m_scriptNotifyCallback(m_scriptCanvasAsset);
-        }
-        return AZ::Edit::PropertyRefreshLevels::EntireTree;
-    }
-
-    void ScriptCanvasFunctionAssetHolder::OnAssetReady(AZ::Data::Asset<AZ::Data::AssetData> asset)
-    {
-        SetAsset(asset.GetId());
-        EditorScriptCanvasAssetNotificationBus::Event(m_scriptCanvasAsset.GetId(), &EditorScriptCanvasAssetNotifications::OnScriptCanvasAssetReady, m_scriptCanvasAsset);
-    }
-
-    void ScriptCanvasFunctionAssetHolder::OnAssetReloaded(AZ::Data::Asset<AZ::Data::AssetData> asset)
-    {
-        SetAsset(asset.GetId());
-        EditorScriptCanvasAssetNotificationBus::Event(m_scriptCanvasAsset.GetId(), &EditorScriptCanvasAssetNotifications::OnScriptCanvasAssetReloaded, m_scriptCanvasAsset);
-    }
-
-    void ScriptCanvasFunctionAssetHolder::OnAssetUnloaded(const AZ::Data::AssetId assetId, const AZ::Data::AssetType)
-    {
-        EditorScriptCanvasAssetNotificationBus::Event(assetId, &EditorScriptCanvasAssetNotifications::OnScriptCanvasAssetUnloaded, assetId);
-    }
-
-    void ScriptCanvasFunctionAssetHolder::OnAssetSaved(AZ::Data::Asset<AZ::Data::AssetData> asset, bool isSuccessful)
-    {
-        SetAsset(asset.GetId());
-        auto currentBusId = AZ::Data::AssetBus::GetCurrentBusId();
-        if (currentBusId)
-        {
-            EditorScriptCanvasAssetNotificationBus::Event(*currentBusId, &EditorScriptCanvasAssetNotifications::OnScriptCanvasAssetSaved, asset.GetId());
-        }
-    }
-
-    void ScriptCanvasFunctionAssetHolder::SetAsset(AZ::Data::AssetId assetId)
-    {
-        m_scriptCanvasAssetId = assetId;
-
-        if (!AZ::Data::AssetBus::Handler::BusIsConnectedId(m_scriptCanvasAssetId))
-        {
-            AZ::Data::AssetBus::Handler::BusDisconnect();
-            if (m_scriptCanvasAssetId.IsValid())
-            {
-                AZ::Data::AssetBus::Handler::BusConnect(m_scriptCanvasAssetId);
-            }
-        }
-    }
-
-    //AZ::Data::Asset<ScriptCanvasAsset> ScriptCanvasFunctionAssetHolder::GetAsset() const
-    //{
-    //    return m_scriptCanvasAsset;
-    //}
-
-    AZ::Data::AssetId ScriptCanvasFunctionAssetHolder::GetAssetId() const
-    {
-        return m_scriptCanvasAssetId;
-    }
-}

Gems/ScriptCanvas/Code/Editor/Assets/Functions/ScriptCanvasFunctionAssetHolder.h

@@ -1,75 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <AzCore/Component/EntityId.h>
-#include <AzCore/Asset/AssetCommon.h>
-
-namespace ScriptCanvas
-{
-    class ScriptCanvasFunctionAsset;
-}
-
-namespace ScriptCanvasEditor
-{
-    class ScriptCanvasFunctionAsset;
-
-    /*! ScriptCanvasAssetHolder
-    Wraps a ScriptCanvasAsset reference and registers for the individual AssetBus events
-    for saving, loading and unloading the asset.
-    The ScriptCanvasAsset Holder contains functionality for activating the ScriptCanvasEntity stored on the reference asset
-    as well as attempting to open the ScriptCanvasAsset within the ScriptCanvas Editor.
-    It also provides the EditContext reflection for opening the asset in the ScriptCanvas Editor via a button
-    */
-    class ScriptCanvasFunctionAssetHolder
-        : private AZ::Data::AssetBus::Handler
-    {
-    public:
-        AZ_RTTI(ScriptCanvasFunctionAssetHolder, "{21693AFA-5664-4AAE-9213-8B944A398BA1}");
-        AZ_CLASS_ALLOCATOR(ScriptCanvasFunctionAssetHolder, AZ::SystemAllocator, 0);
-
-        using ScriptChangedCB = AZStd::function<void(const AZ::Data::Asset<ScriptCanvasAsset>&)>;
-
-        ScriptCanvasFunctionAssetHolder() = default;
-        ScriptCanvasFunctionAssetHolder(AZ::Data::AssetId assetId, const ScriptChangedCB& = {});
-        ~ScriptCanvasFunctionAssetHolder() override;
-        
-        static void Reflect(AZ::ReflectContext* context);
-        void Init(AZ::EntityId ownerId = AZ::EntityId());
-
-        void SetAsset(AZ::Data::AssetId assetId);
-        AZ::Data::AssetId GetAssetId() const;
-
-        AZ::EntityId GetGraphId() const;
-
-        void LaunchScriptCanvasEditor(const AZ::Data::AssetId&, const AZ::Data::AssetType&) const;
-        void OpenEditor() const;
-
-        void SetScriptChangedCB(const ScriptChangedCB&);
-        void Load(bool loadBlocking = false);
-
-    protected:
-
-        //=====================================================================
-        // AZ::Data::AssetBus
-        void OnAssetReady(AZ::Data::Asset<AZ::Data::AssetData> asset) override;
-        void OnAssetReloaded(AZ::Data::Asset<AZ::Data::AssetData> asset) override;
-        void OnAssetUnloaded(const AZ::Data::AssetId assetId, const AZ::Data::AssetType assetType) override;
-        void OnAssetSaved(AZ::Data::Asset<AZ::Data::AssetData> asset, bool isSuccessful) override;
-        //=====================================================================
-
-        //! Reloads the Script From the AssetData if it has changed
-        AZ::u32 OnScriptChanged();
-        AZ::Data::AssetId m_scriptCanvasAssetId;
-        AZ::Data::Asset<ScriptCanvas::ScriptCanvasFunctionAsset> m_scriptCanvasAsset;
-
-        AZ::EntityId m_ownerId; // Id of Entity which stores this AssetHolder object
-        ScriptChangedCB m_scriptNotifyCallback;
-    };
-
-}

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetHelpers.cpp

@@ -8,7 +8,6 @@
 #include <Editor/Assets/ScriptCanvasAssetHelpers.h>
 
 #include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
 #include <ScriptCanvas/Bus/EditorScriptCanvasBus.h>
 
 namespace ScriptCanvasEditor
@@ -149,37 +148,13 @@ namespace ScriptCanvasEditor
 
         }
 
-        bool IsValidSourceFile(const AZStd::string& filePath, ScriptCanvas::ScriptCanvasId scriptCanvasId)
+        bool IsValidSourceFile(const AZStd::string& filePath, [[maybe_unused]] ScriptCanvas::ScriptCanvasId scriptCanvasId)
         {
-            bool isValidSourceFile = true;
-
-            if (scriptCanvasId.IsValid())
+            ScriptCanvasAssetDescription assetDescription;
+            return AZ::StringFunc::EndsWith(filePath, assetDescription.GetExtensionImpl(), false);
             {
-                bool isRuntimeGraph = false;
-                EditorGraphRequestBus::EventResult(isRuntimeGraph, scriptCanvasId, &EditorGraphRequests::IsRuntimeGraph);
-
-                if (isRuntimeGraph)
-                {
-                    ScriptCanvasAssetDescription assetDescription;
-
-                    if (!AZ::StringFunc::EndsWith(filePath, assetDescription.GetExtensionImpl(), false))
-                    {
-                        isValidSourceFile = false;
-                    }
-                }
-                // Assume it's a function for now
-                else
-                {
-                    ScriptCanvasEditor::ScriptCanvasFunctionDescription assetDescription;
-
-                    if (!AZ::StringFunc::EndsWith(filePath, assetDescription.GetExtensionImpl(), false))
-                    {
-                        isValidSourceFile = false;
-                    }
-                }
+                return true;
             }
-
-            return isValidSourceFile;
         }
     }
 }

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetInstance.cpp

@@ -1,154 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "precompiled.h"
-
-#include <AzCore/Component/Entity.h>
-#include <AzCore/Serialization/IdUtils.h>
-#include <Editor/Assets/ScriptCanvasAssetInstance.h>
-
-namespace ScriptCanvasEditor
-{
-    ScriptCanvasAssetInstance::~ScriptCanvasAssetInstance()
-    {
-    }
-
-    void ScriptCanvasAssetInstance::Reflect(AZ::ReflectContext* context)
-    {
-        if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
-        {
-            serializeContext->Class<ScriptCanvasAssetInstance>()
-                // TODO: This results in more data being saved per instance, but is needed to make Id remapping transparent.
-                // Allow a way to enumerate the elements for Id Remapping, while disallowing serialization
-                ->Field("m_data", &ScriptCanvasAssetInstance::m_scriptCanvasData) 
-                ->Field("m_assetRef", &ScriptCanvasAssetInstance::m_assetRef)
-                ->Field("m_entityInstanceMap", &ScriptCanvasAssetInstance::m_baseToInstanceMap)
-                ->Field("m_dataFlags", &ScriptCanvasAssetInstance::m_entityToDataFlags)
-                ->Field("m_dataPatch", &ScriptCanvasAssetInstance::m_dataPatch)
-                ;
-        }
-    }
-
-    ScriptCanvasAssetReference& ScriptCanvasAssetInstance::GetReference()
-    {
-        return m_assetRef;
-    }
-
-    const ScriptCanvasAssetReference& ScriptCanvasAssetInstance::GetReference() const
-    {
-        return m_assetRef;
-    }
-
-    ScriptCanvas::ScriptCanvasData& ScriptCanvasAssetInstance::GetScriptCanvasData()
-    {
-        return m_scriptCanvasData;
-    }
-
-    const ScriptCanvas::ScriptCanvasData& ScriptCanvasAssetInstance::GetScriptCanvasData() const
-    {
-        return m_scriptCanvasData;
-    }
-
-    void ScriptCanvasAssetInstance::ComputeDataPatch()
-    {
-        if (!m_assetRef.GetAsset().IsReady())
-        {
-            return;
-        }
-
-        ScriptCanvas::ScriptCanvasData& baseData = m_assetRef.GetAsset().Get()->GetScriptCanvasData();
-
-        AZ::SerializeContext* serializeContext{};
-        AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);
-
-        decltype(m_baseToInstanceMap) entityIdReverseLookUp;
-        for (const auto& baseToInstancePair : m_baseToInstanceMap)
-        {
-            entityIdReverseLookUp.emplace(baseToInstancePair.second, baseToInstancePair.first);
-        }
-
-        // remap entity ids to the "original"
-        AZ::IdUtils::Remapper<AZ::EntityId>::ReplaceIdsAndIdRefs(&m_scriptCanvasData, [&entityIdReverseLookUp](AZ::EntityId sourceId, [[maybe_unused]] bool isEntityId, const AZ::IdUtils::Remapper<AZ::EntityId>::IdGenerator&) -> AZ::EntityId
-        {
-            auto findIt = entityIdReverseLookUp.find(sourceId);
-            return findIt != entityIdReverseLookUp.end() ? findIt->second : sourceId;
-        }, serializeContext);
-
-        // compute the delta (what we changed from the base slice)
-        m_dataPatch.Create(&baseData, &m_scriptCanvasData, AZ::DataPatch::FlagsMap(), GetDataFlagsForPatching(), serializeContext);
-
-        // remap entity ids back to the "instance onces"
-        AZ::IdUtils::Remapper<AZ::EntityId>::ReplaceIdsAndIdRefs(&m_scriptCanvasData, [this](AZ::EntityId sourceId, [[maybe_unused]] bool isEntityId, const AZ::IdUtils::Remapper<AZ::EntityId>::IdGenerator&) -> AZ::EntityId {
-            auto findIt = m_baseToInstanceMap.find(sourceId);
-            return findIt != m_baseToInstanceMap.end() ? findIt->second : sourceId;
-        }, serializeContext);
-
-    }
-
-    void ScriptCanvasAssetInstance::ApplyDataPatch()
-    {
-        if (!m_assetRef.GetAsset().IsReady())
-        {
-            return;
-        }
-
-        ScriptCanvas::ScriptCanvasData& baseData = m_assetRef.GetAsset().Get()->GetScriptCanvasData();
-
-        AZ::SerializeContext* serializeContext{};
-        AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);
-        // An empty map indicates its a fresh instance (i.e. has never be instantiated and then serialized).
-        if (m_baseToInstanceMap.empty())
-        {
-            // Generate new Ids and populate the map.
-            AZ_Assert(!m_dataPatch.IsValid(), "Data patch is valid for scene slice instance, but base scene to instantiated scene Id map is not!");
-            serializeContext->CloneObjectInplace(m_scriptCanvasData, &baseData);
-            AZ::IdUtils::Remapper<AZ::EntityId>::GenerateNewIdsAndFixRefs(&m_scriptCanvasData, m_baseToInstanceMap);
-        }
-        else
-        {
-            // Clone entities while applying any data patches.
-            AZ_Assert(m_dataPatch.IsValid(), "Data patch is not valid for existing scene slice instance!");
-            ScriptCanvas::ScriptCanvasData* patchedSceneData = m_dataPatch.Apply(&baseData, serializeContext);
-
-            // Remap Ids & references.
-            AZ::IdUtils::Remapper<AZ::EntityId>::GenerateNewIdsAndFixRefs(patchedSceneData, m_baseToInstanceMap);
-            serializeContext->CloneObjectInplace(m_scriptCanvasData, patchedSceneData);
-        }
-    }
-
-    AZ::DataPatch::FlagsMap ScriptCanvasAssetInstance::GetDataFlagsForPatching() const
-    {
-        // Collect all entities' data flags
-        AZ::DataPatch::FlagsMap dataFlags;
-
-        for (auto& baseIdInstanceIdPair : m_baseToInstanceMap)
-        {
-            // Make the addressing relative to InstantiatedContainer (m_dataFlags stores flags relative to the individual entity)
-            AZ::DataPatch::AddressType addressPrefix;
-            addressPrefix.push_back(AZ_CRC("Entities", 0x50ec64e5));
-            addressPrefix.push_back(static_cast<AZ::u64>(baseIdInstanceIdPair.first));
-
-            auto findIt = m_entityToDataFlags.find(baseIdInstanceIdPair.second);
-            if (findIt != m_entityToDataFlags.end())
-            {
-                for (auto& addressDataFlagsPair : findIt->second)
-                {
-                    const AZ::DataPatch::AddressType& originalAddress = addressDataFlagsPair.first;
-
-                    AZ::DataPatch::AddressType prefixedAddress;
-                    prefixedAddress.reserve(addressPrefix.size() + originalAddress.size());
-                    prefixedAddress.insert(prefixedAddress.end(), addressPrefix.begin(), addressPrefix.end());
-                    prefixedAddress.insert(prefixedAddress.end(), originalAddress.begin(), originalAddress.end());
-
-                    dataFlags.emplace(AZStd::move(prefixedAddress), addressDataFlagsPair.second);
-                }
-            }
-        }
-
-        return dataFlags;
-    }
-}

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetInstance.h

@@ -1,46 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
-#include <Editor/Assets/ScriptCanvasAssetReference.h>
-
-namespace ScriptCanvasEditor
-{
-    class ScriptCanvasAssetInstance
-    {
-    public:
-        AZ_TYPE_INFO(ScriptCanvasAssetInstance, "{96B16AAB-DB63-4D32-9FC9-7A5DE440B0B7}");
-        AZ_CLASS_ALLOCATOR(ScriptCanvasAssetInstance, AZ::SystemAllocator, 0);
-
-        ScriptCanvasAssetInstance() = default;
-        ~ScriptCanvasAssetInstance();
-        static void Reflect(AZ::ReflectContext* context);
-
-        const AZStd::unordered_map<AZ::EntityId, AZ::EntityId>& GetBaseToInstanceMap() const { return m_baseToInstanceMap; }
-        ScriptCanvasAssetReference& GetReference();
-        const ScriptCanvasAssetReference& GetReference() const;
-
-        ScriptCanvas::ScriptCanvasData& GetScriptCanvasData();
-        const ScriptCanvas::ScriptCanvasData& GetScriptCanvasData() const;
-
-        void ComputeDataPatch();
-        void ApplyDataPatch();
-
-    private:
-        ScriptCanvasAssetInstance(const ScriptCanvasAssetInstance&) = delete;
-        AZ::DataPatch::FlagsMap GetDataFlagsForPatching() const;
-
-        ScriptCanvas::ScriptCanvasData m_scriptCanvasData;
-        ScriptCanvasAssetReference m_assetRef;
-        AZStd::unordered_map<AZ::EntityId, AZ::EntityId> m_baseToInstanceMap;
-        AZStd::unordered_map<AZ::EntityId, AZ::DataPatch::FlagsMap> m_entityToDataFlags;
-
-        AZ::DataPatch m_dataPatch;
-        bool m_canApplyPatch;
-    };
-}

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetReference.cpp

@@ -1,57 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "precompiled.h"
-
-#include <AzCore/Serialization/IdUtils.h>
-#include <Editor/Assets/ScriptCanvasAssetReference.h>
-#include <Editor/Assets/ScriptCanvasAssetReferenceContainer.h>
-
-namespace ScriptCanvasEditor
-{
-    void ScriptCanvasAssetReference::Reflect(AZ::ReflectContext* context)
-    {
-        if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
-        {
-            serializeContext->Class<ScriptCanvasAssetReference>()
-                ->DataContainer<ScriptCanvasAssetReferenceContainer>()
-                ;
-        }
-    }
-
-    ScriptCanvasAssetReference::ScriptCanvasAssetReference(AZ::Data::Asset<ScriptCanvasAsset> sliceAsset, bool storeInObjectStream)
-    {
-        SetAsset(sliceAsset);
-        SetAssetDataStoredInternally(storeInObjectStream);
-    }
-
-    void ScriptCanvasAssetReference::SetAsset(AZ::Data::Asset<ScriptCanvasAsset> sliceAsset)
-    {
-        m_asset = sliceAsset;
-    }
-
-    const AZ::Data::Asset<ScriptCanvasAsset>& ScriptCanvasAssetReference::GetAsset() const
-    {
-        return m_asset;
-    }
-
-    AZ::Data::Asset<ScriptCanvasAsset>& ScriptCanvasAssetReference::GetAsset()
-    {
-        return m_asset;
-    }
-
-    void ScriptCanvasAssetReference::SetAssetDataStoredInternally(bool storeInObjectStream)
-    {
-        m_storeInObjectStream = storeInObjectStream;
-    }
-
-    bool ScriptCanvasAssetReference::GetAssetDataStoredInternally() const
-    {
-        return m_storeInObjectStream;
-    }
-
-}

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetReference.h

@@ -1,70 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-#include <AzCore/Serialization/DataPatch.h>
-#include <AzCore/Asset/AssetCommon.h>
-
-namespace ScriptCanvas
-{
-    class ScriptCanvasData;
-}
-
-namespace ScriptCanvasEditor
-{
-    class ScriptCanvasAsset;
-
-    class ScriptCanvasAssetReference
-    {
-    public:
-        AZ_TYPE_INFO(ScriptCanvasAssetReference, "{C1B24507-887C-4E20-A259-BFEEDD7EDF9D}");
-        AZ_CLASS_ALLOCATOR(ScriptCanvasAssetReference, AZ::SystemAllocator, 0);
-
-        ScriptCanvasAssetReference() = default;
-        ScriptCanvasAssetReference(AZ::Data::Asset<ScriptCanvasAsset> scriptCanvasAsset, bool storeInObjectStream = false);
-        static void Reflect(AZ::ReflectContext* context);
-
-        /*!
-        \param scriptCanvasAsset asset reference to store
-        \param storeInObjectStream bool which determines if the asset data will serialized out as part of the ObjectStream when serializing
-        */
-        void SetAsset(AZ::Data::Asset<ScriptCanvasAsset> scriptCanvasAsset);
-        const AZ::Data::Asset<ScriptCanvasAsset>& GetAsset() const;
-        AZ::Data::Asset<ScriptCanvasAsset>& GetAsset();
-
-        /*!
-        \param storeInObjectStream bool which determines if the asset data will serialized out as part of the ObjectStream when serializing
-        */
-        void SetAssetDataStoredInternally(bool storeInObjectStream);
-
-        /*!
-        Indicates if this scriptCanvas reference contains an asset whose data is stored internally in this class.
-        \return true if the asset is asset data is serialize as part of this class object stream
-        */
-        bool GetAssetDataStoredInternally() const;
-
-    private:
-        bool m_storeInObjectStream = false; ///< If true the asset data is stored in the object stream with this class
-        AZ::Data::Asset<ScriptCanvasAsset> m_asset;
-        friend class ScriptCanvasAssetReferenceContainer;
-    };
-}
-
-namespace AZStd
-{
-    template<>
-    struct hash<ScriptCanvasEditor::ScriptCanvasAssetReference>
-    {
-        using argument_type = ScriptCanvasEditor::ScriptCanvasAssetReference;
-        using result_type = AZStd::size_t;
-        AZ_FORCE_INLINE size_t operator()(const argument_type& key) const
-        {
-            AZStd::hash<AZ::Data::AssetId> hasher;
-            return hasher(key.GetAsset().GetId());
-        }
-    };
-}

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetReferenceContainer.h

@@ -1,234 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <AzCore/Asset/AssetManager.h>
-#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
-#include <Editor/Assets/ScriptCanvasAssetReference.h>
-
-namespace ScriptCanvasEditor
-{
-    class ScriptCanvasAssetReferenceContainer
-        : public AZ::SerializeContext::IDataContainer
-    {
-    public:
-        ScriptCanvasAssetReferenceContainer()
-        {
-            m_storeInObjectStreamElement.m_name = "m_storeInObjectStream";
-            m_storeInObjectStreamElement.m_nameCrc = AZ_CRC("m_storeInObjectStream", 0xf5a45371);
-            m_storeInObjectStreamElement.m_typeId = azrtti_typeid<bool>();
-            m_storeInObjectStreamElement.m_offset = 0;
-            m_storeInObjectStreamElement.m_dataSize = sizeof(bool);
-            m_storeInObjectStreamElement.m_azRtti = nullptr;
-            m_storeInObjectStreamElement.m_genericClassInfo = AZ::SerializeGenericTypeInfo<bool>::GetGenericInfo();
-            m_storeInObjectStreamElement.m_editData = nullptr;
-            m_storeInObjectStreamElement.m_flags = 0;
-
-            m_assetElement.m_name = "m_asset";
-            m_assetElement.m_nameCrc = AZ_CRC("m_asset", 0x4e58e538);
-            m_assetElement.m_typeId = AZ::SerializeGenericTypeInfo<AZ::Data::Asset<ScriptCanvasAsset>>::GetClassTypeId();
-            m_assetElement.m_offset = m_storeInObjectStreamElement.m_dataSize;
-            m_assetElement.m_dataSize = sizeof(AZ::Data::Asset<ScriptCanvasAsset>);
-            m_assetElement.m_azRtti = AZ::GetRttiHelper<AZ::Data::Asset<ScriptCanvasAsset>>();
-            m_assetElement.m_genericClassInfo = AZ::SerializeGenericTypeInfo<AZ::Data::Asset<ScriptCanvasAsset>>::GetGenericInfo();
-            m_assetElement.m_editData = nullptr;
-            m_assetElement.m_flags = 0;
-            
-            m_baseDataElement.m_name = "m_scriptCanvasData";
-            m_baseDataElement.m_nameCrc = AZ_CRC("m_scriptCanvasData", 0x78a93f93);
-            m_baseDataElement.m_typeId = AZ::SerializeGenericTypeInfo<ScriptCanvas::ScriptCanvasData>::GetClassTypeId();
-            m_baseDataElement.m_offset = m_assetElement.m_offset + m_assetElement.m_dataSize;
-            m_baseDataElement.m_dataSize = sizeof(ScriptCanvas::ScriptCanvasData);
-            m_baseDataElement.m_azRtti = AZ::GetRttiHelper<ScriptCanvas::ScriptCanvasData>();
-            m_baseDataElement.m_genericClassInfo = AZ::SerializeGenericTypeInfo<ScriptCanvas::ScriptCanvasData>::GetGenericInfo();
-            m_baseDataElement.m_editData = nullptr;
-            m_baseDataElement.m_flags = 0;
-        }
-        /// Null if element with this name can't be found.
-        const AZ::SerializeContext::ClassElement* GetElement(AZ::u32 elementNameCrc) const override
-        {
-            if (m_storeInObjectStreamElement.m_nameCrc == elementNameCrc)
-            {
-                return &m_storeInObjectStreamElement;
-            }
-            if (m_assetElement.m_nameCrc == elementNameCrc)
-            {
-                return &m_assetElement;
-            }
-            if (m_baseDataElement.m_nameCrc == elementNameCrc)
-            {
-                return &m_baseDataElement;
-            }
-
-            return nullptr;
-        }
-
-        bool GetElement(AZ::SerializeContext::ClassElement& classElement, const AZ::SerializeContext::DataElement& dataElement) const override
-        {
-            if (m_storeInObjectStreamElement.m_nameCrc == dataElement.m_nameCrc)
-            {
-                classElement = m_storeInObjectStreamElement;
-                return true;
-            }
-            if (m_assetElement.m_nameCrc == dataElement.m_nameCrc)
-            {
-                classElement = m_assetElement;
-                return true;
-            }
-            if (m_baseDataElement.m_nameCrc == dataElement.m_nameCrc)
-            {
-                classElement = m_baseDataElement;
-                return true;
-            }
-            return false;
-        }
-
-        /// Enumerate elements in the array.
-        void EnumElements(void* instance, const ElementCB& cb) override
-        {
-            auto assetRef = reinterpret_cast<ScriptCanvasAssetReference*>(instance);
-
-            if (!cb(&assetRef->m_storeInObjectStream, m_storeInObjectStreamElement.m_typeId, m_storeInObjectStreamElement.m_genericClassInfo ? m_storeInObjectStreamElement.m_genericClassInfo->GetClassData() : nullptr, &m_storeInObjectStreamElement))
-            {
-                return;
-            }
-
-            if (!cb(&assetRef->m_asset, m_assetElement.m_typeId, m_assetElement.m_genericClassInfo ? m_assetElement.m_genericClassInfo->GetClassData() : nullptr, &m_assetElement))
-            {
-                return;
-            }
-
-            if (assetRef->m_storeInObjectStream && assetRef->m_asset.Get())
-            {
-                cb(&assetRef->m_asset.Get()->GetScriptCanvasData(), m_baseDataElement.m_typeId, m_baseDataElement.m_genericClassInfo ? m_baseDataElement.m_genericClassInfo->GetClassData() : nullptr, &m_baseDataElement);
-            }
-        }
-
-        void EnumTypes(const ElementTypeCB& cb) override
-        {
-            cb(m_storeInObjectStreamElement.m_typeId, &m_storeInObjectStreamElement);
-            cb(m_assetElement.m_typeId, &m_assetElement);
-            cb(m_baseDataElement.m_typeId, &m_baseDataElement);
-        }
-
-        /// Return number of elements in the container.
-        size_t  Size(void* instance) const override
-        {
-            auto assetRef = reinterpret_cast<ScriptCanvasAssetReference*>(instance);
-            return assetRef->m_storeInObjectStream && assetRef->m_asset.Get() ? m_numClassElements : m_numClassElements - 1;
-        }
-
-        /// Returns the capacity of the container. Returns 0 for objects without fixed capacity.
-        size_t Capacity(void*) const override
-        {
-            return m_numClassElements;
-        }
-
-        /// Returns true if elements pointers don't change on add/remove. If false you MUST enumerate all elements.
-        bool    IsStableElements() const override { return true; }
-
-        /// Returns true if the container is fixed size, otherwise false.
-        bool    IsFixedSize() const override { return false; }
-
-        /// Returns if the container is fixed capacity, otherwise false
-        bool    IsFixedCapacity() const override { return true; }
-
-        /// Returns true if the container is a smart pointer.
-        bool    IsSmartPointer() const override { return false; }
-
-        /// Returns true if elements can be retrieved by index.
-        bool    CanAccessElementsByIndex() const override { return false; }
-
-        /// Reserve element
-        void* ReserveElement(void* instance, const AZ::SerializeContext::ClassElement* classElement) override
-        {
-            auto assetRef = reinterpret_cast<ScriptCanvasAssetReference*>(instance);
-            if (classElement->m_nameCrc == m_storeInObjectStreamElement.m_nameCrc)
-            {
-                return &assetRef->m_storeInObjectStream;
-            }
-            if (classElement->m_nameCrc == m_assetElement.m_nameCrc)
-            {
-                if (assetRef->m_storeInObjectStream)
-                {
-                    assetRef->m_asset.SetFlags(static_cast<AZ::u8>(AZ::Data::AssetLoadBehavior::NoLoad));
-                }
-                return &assetRef->m_asset;
-            }
-            if (assetRef->m_storeInObjectStream && classElement->m_nameCrc == m_baseDataElement.m_nameCrc)
-            {
-                auto* scriptCanvasAsset = aznew ScriptCanvasAsset(assetRef->m_asset.GetId(), AZ::Data::AssetData::AssetStatus::Ready);
-                assetRef->m_asset = { scriptCanvasAsset, AZ::Data::AssetLoadBehavior::Default };
-                return &assetRef->m_asset.Get()->GetScriptCanvasData();
-            }
-
-            return instance;
-        }
-
-        /// Get an element's address by its index (called before the element is loaded).
-        void* GetElementByIndex(void*, const AZ::SerializeContext::ClassElement*, size_t) override
-        {
-            return nullptr;
-        }
-
-        /// Store element
-        void StoreElement(void* instance, void* element) override
-        {
-            auto assetRef = reinterpret_cast<ScriptCanvasAssetReference*>(instance);
-            if (assetRef->m_storeInObjectStream && assetRef->m_asset.Get() && element == &assetRef->m_asset.Get()->GetScriptCanvasData())
-            {
-                auto existingAsset = AZ::Data::AssetManager::Instance().FindAsset<ScriptCanvasAsset>(assetRef->m_asset.GetId(), assetRef->m_asset.GetAutoLoadBehavior());
-                if (existingAsset.IsReady())
-                {
-                    assetRef->m_asset = existingAsset;
-                }
-            }
-        }
-
-        /// Remove element in the container.
-        bool RemoveElement(void* instance, const void* element, AZ::SerializeContext* deletePointerDataContext) override
-        {
-            if (deletePointerDataContext)
-            {
-                auto assetRef = reinterpret_cast<ScriptCanvasAssetReference*>(instance);
-                if (&assetRef->m_storeInObjectStream == element)
-                {
-                    DeletePointerData(deletePointerDataContext, &m_storeInObjectStreamElement, &assetRef->m_storeInObjectStream);
-                }
-                else if (&assetRef->m_asset == element)
-                {
-                    DeletePointerData(deletePointerDataContext, &m_assetElement, &assetRef->m_asset);
-                }
-            }
-            return false;
-        }
-
-        /// Remove elements (removed array of elements) regardless if the container is Stable or not (IsStableElements)
-        size_t RemoveElements(void* instance, const void** elements, size_t numElements, AZ::SerializeContext* deletePointerDataContext) override
-        {
-            if (deletePointerDataContext)
-            {
-                for (size_t i = 0; i < numElements; ++i)
-                {
-                    RemoveElement(instance, elements[i], deletePointerDataContext);
-                }
-            }
-            return 0;
-        }
-
-        /// Clear elements in the instance.
-        void ClearElements(void*, AZ::SerializeContext*) override
-        {
-        }
-
-        AZ::SerializeContext::ClassElement m_storeInObjectStreamElement;
-        AZ::SerializeContext::ClassElement m_assetElement;
-        AZ::SerializeContext::ClassElement m_baseDataElement;
-        const size_t m_numClassElements = 3;
-    };
-}

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetTracker.cpp

@@ -22,7 +22,6 @@
 #include <Editor/Assets/ScriptCanvasMemoryAsset.h>
 
 #include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
 
 #include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
 #include <ScriptCanvas/Core/ScriptCanvasBus.h>

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasMemoryAsset.cpp

@@ -80,11 +80,6 @@ namespace ScriptCanvasEditor
             AZ::Data::Asset<ScriptCanvasAsset> newAsset = Clone<ScriptCanvasAsset>();
             memoryAsset.m_inMemoryAsset = newAsset;
         }
-        else if (m_assetType == azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>())
-        {
-            AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset> newAsset = Clone<ScriptCanvasEditor::ScriptCanvasFunctionAsset>();
-            memoryAsset.m_inMemoryAsset = newAsset;
-        }
         else
         {
             AZ_Assert(false, "Unsupported Script Canvas Asset Type");
@@ -107,10 +102,6 @@ namespace ScriptCanvasEditor
         {
             asset = assetHandler->CreateAsset(assetId, azrtti_typeid<ScriptCanvasAsset>());
         }
-        else if (assetType == azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>())
-        {
-            asset = assetHandler->CreateAsset(assetId, azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>());
-        }
 
         m_inMemoryAsset = AZ::Data::Asset<AssetType>(asset, AZ::Data::AssetLoadBehavior::PreLoad);
 
@@ -155,8 +146,6 @@ namespace ScriptCanvasEditor
         streamInfo.m_streamFlags = AZ::IO::OpenMode::ModeWrite;
         streamInfo.m_streamName = m_saveAsPath;
 
-        ScriptCanvasEditor::ScriptCanvasDataRequestBus::Event(GetScriptCanvasId(), &ScriptCanvasEditor::ScriptCanvasDataRequests::SetPrettyName, GetTabName().c_str());
-
         if (!streamInfo.IsValid())
         {
             return;
@@ -223,10 +212,6 @@ namespace ScriptCanvasEditor
         {
             m_inMemoryAsset = AZ::Data::AssetManager::Instance().GetAsset<ScriptCanvasAsset>(assetId, AZ::Data::AssetLoadBehavior::Default);
         }
-        else if (assetInfo.m_assetType == azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>())
-        {
-            m_inMemoryAsset = AZ::Data::AssetManager::Instance().GetAsset<ScriptCanvasEditor::ScriptCanvasFunctionAsset>(assetId, AZ::Data::AssetLoadBehavior::Default);
-        }
 
         if (m_inMemoryAsset)
         {
@@ -290,15 +275,8 @@ namespace ScriptCanvasEditor
             return;
         }
 
-        if (m_assetType == azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>())
-        {
-            editorGraph->MarkFunctionGraph();
-        }
-
         m_scriptCanvasId = editorGraph->GetScriptCanvasId();
 
-        ScriptCanvasEditor::ScriptCanvasDataRequestBus::Event(m_scriptCanvasId, &ScriptCanvasEditor::ScriptCanvasDataRequests::SetPrettyName, GetTabName().c_str());
-
         EditorGraphNotificationBus::Handler::BusDisconnect();
         EditorGraphNotificationBus::Handler::BusConnect(m_scriptCanvasId);
 
@@ -538,10 +516,6 @@ namespace ScriptCanvasEditor
         {
             return CloneAssetData<ScriptCanvasAsset>(newAssetId);
         }
-        else if (m_assetType == azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>())
-        {
-            return CloneAssetData<ScriptCanvasEditor::ScriptCanvasFunctionAsset>(newAssetId);
-        }
 
         AZ_Assert(false, "The provides asset type is not supported as a valid Script Canvas memory asset");
         return AZ::Data::Asset<AZ::Data::AssetData>();

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasMemoryAsset.h

@@ -21,7 +21,6 @@
 #include <Editor/Assets/ScriptCanvasAssetTrackerDefinitions.h>
 
 #include <ScriptCanvas/Asset/ScriptCanvasAssetBase.h>
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
 #include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
 
 #include <ScriptCanvas/Bus/ScriptCanvasBus.h>

Gems/ScriptCanvas/Code/Editor/Components/EditorGraph.cpp

@@ -38,9 +38,6 @@ AZ_POP_DISABLE_WARNING
 #include <ScriptCanvas/Libraries/Core/EBusEventHandler.h>
 #include <ScriptCanvas/Libraries/Core/FunctionDefinitionNode.h>
 #include <Editor/Include/ScriptCanvas/GraphCanvas/MappingBus.h>
-
-#include <Core/PureData.h>
-
 #include <Editor/Include/ScriptCanvas/GraphCanvas/NodeDescriptorBus.h>
 #include <Editor/Nodes/NodeCreateUtils.h>
 #include <Editor/Nodes/NodeDisplayUtils.h>
@@ -63,7 +60,6 @@ AZ_POP_DISABLE_WARNING
 #include <Editor/GraphCanvas/PropertyInterfaces/ScriptCanvasEnumComboBoxPropertyDataInterface.h>
 #include <Editor/GraphCanvas/PropertyInterfaces/ScriptCanvasStringPropertyDataInterface.h>
 
-#include <Editor/Nodes/ScriptCanvasAssetNode.h>
 #include <Editor/Translation/TranslationHelper.h>
 #include <Editor/View/Dialogs/SettingsDialog.h>
 #include <Editor/View/Widgets/ScriptCanvasNodePaletteDockWidget.h>
@@ -1087,66 +1083,6 @@ namespace ScriptCanvasEditor
         return CanCreateConnectionBetween(scSourceEndpoint, scTargetEndpoint).IsSuccess();
     }
 
-    GraphCanvas::ConnectionValidationTooltip Graph::GetConnectionValidityTooltip(const GraphCanvas::Endpoint& sourcePoint, const GraphCanvas::Endpoint& targetPoint) const
-    {
-        ScriptCanvas::Endpoint scSourceEndpoint = ConvertToScriptCanvasEndpoint(sourcePoint);
-        ScriptCanvas::Endpoint scTargetEndpoint = ConvertToScriptCanvasEndpoint(targetPoint);
-
-        AZ::Outcome<void, AZStd::string> connectionResult = CanCreateConnectionBetween(scSourceEndpoint, scTargetEndpoint);
-
-        GraphCanvas::ConnectionValidationTooltip validationTooltip;
-
-        validationTooltip.m_isValid = connectionResult.IsSuccess();
-
-        if (!connectionResult)
-        {
-            validationTooltip.m_failureReason = connectionResult.GetError();
-        }
-
-        return validationTooltip;
-    }
-
-    bool Graph::IsValidVariableAssignment(const AZ::EntityId& variableId, const GraphCanvas::Endpoint& targetPoint) const
-    {
-        AZStd::any* userData = nullptr;
-        GraphCanvas::NodeRequestBus::EventResult(userData, variableId, &GraphCanvas::NodeRequests::GetUserData);
-        AZ::EntityId variableNodeId = (userData && userData->is<AZ::EntityId>()) ? *AZStd::any_cast<AZ::EntityId>(userData) : AZ::EntityId();
-
-        ScriptCanvas::SlotId variableSlotId;
-        ScriptCanvas::NodeRequestBus::EventResult(variableSlotId, variableNodeId, &ScriptCanvas::NodeRequests::GetSlotId, ScriptCanvas::PureData::k_getThis);
-
-        ScriptCanvas::Endpoint variableSourceEndpoint(variableNodeId, variableSlotId);
-        ScriptCanvas::Endpoint targetEndpoint = ConvertToScriptCanvasEndpoint(targetPoint);
-
-        return CanCreateConnectionBetween(variableSourceEndpoint, targetEndpoint).IsSuccess();
-    }
-
-    GraphCanvas::ConnectionValidationTooltip Graph::GetVariableAssignmentValidityTooltip(const AZ::EntityId& variableId, const GraphCanvas::Endpoint& targetPoint) const
-    {
-        AZStd::any* userData = nullptr;
-        GraphCanvas::NodeRequestBus::EventResult(userData, variableId, &GraphCanvas::NodeRequests::GetUserData);
-        AZ::EntityId variableNodeId = (userData && userData->is<AZ::EntityId>()) ? *AZStd::any_cast<AZ::EntityId>(userData) : AZ::EntityId();
-
-        ScriptCanvas::SlotId variableSlotId;
-        ScriptCanvas::NodeRequestBus::EventResult(variableSlotId, variableNodeId, &ScriptCanvas::NodeRequests::GetSlotId, ScriptCanvas::PureData::k_getThis);
-
-        ScriptCanvas::Endpoint variableSourceEndpoint(variableNodeId, variableSlotId);
-        ScriptCanvas::Endpoint targetEndpoint = ConvertToScriptCanvasEndpoint(targetPoint);
-
-        AZ::Outcome<void, AZStd::string> connectionResult = CanCreateConnectionBetween(variableSourceEndpoint, targetEndpoint);
-
-        GraphCanvas::ConnectionValidationTooltip validationTooltip;
-
-        validationTooltip.m_isValid = connectionResult.IsSuccess();
-
-        if (!connectionResult)
-        {
-            validationTooltip.m_failureReason = connectionResult.GetError();
-        }
-
-        return  validationTooltip;
-    }
-
     AZStd::string Graph::GetDataTypeString(const AZ::Uuid& typeId)
     {
         return TranslationHelper::GetSafeTypeName(ScriptCanvas::Data::FromAZType(typeId));
@@ -3190,16 +3126,6 @@ namespace ScriptCanvasEditor
         }
     }
 
-    bool Graph::IsRuntimeGraph() const
-    {
-        return GetAssetType() == azrtti_typeid<ScriptCanvas::RuntimeAsset>();
-    }
-
-    bool Graph::IsFunctionGraph() const
-    {
-        return GetAssetType() == azrtti_typeid<ScriptCanvas::SubgraphInterfaceAsset>();
-    }
-
     bool Graph::CanExposeEndpoint(const GraphCanvas::Endpoint& endpoint)
     {
         bool isEnabled = false;

Gems/ScriptCanvas/Code/Editor/Framework/ScriptCanvasGraphUtilities.inl

@@ -14,7 +14,6 @@
 #include <AzCore/Script/ScriptContext.h>
 #include <AzFramework/API/ApplicationAPI.h>
 #include <Editor/Framework/ScriptCanvasReporter.h>
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
 #include <ScriptCanvas/Asset/RuntimeAssetHandler.h>
 #include <ScriptCanvas/Assets/ScriptCanvasAsset.h>

Gems/ScriptCanvas/Code/Editor/Framework/ScriptCanvasTraceUtilities.h

@@ -20,10 +20,8 @@
 #include <ScriptCanvas/Core/ScriptCanvasBus.h>
 #include <ScriptCanvas/Data/Data.h>
 #include <ScriptCanvas/Libraries/Comparison/Comparison.h>
-#include <ScriptCanvas/Libraries/Core/BehaviorContextObjectNode.h>
 #include <ScriptCanvas/Libraries/Core/BinaryOperator.h>
 #include <ScriptCanvas/Libraries/Core/CoreNodes.h>
-#include <ScriptCanvas/Libraries/Entity/EntityRef.h>
 #include <ScriptCanvas/Libraries/Libraries.h>
 #include <ScriptCanvas/Libraries/Logic/Logic.h>
 #include <ScriptCanvas/Libraries/Math/Math.h>
@@ -44,17 +42,6 @@ namespace ScriptCanvasEditor
 {
     class ScriptCanvasAsset;
 
-    struct LoadTestFunctionResult
-    {
-        AZStd::string_view m_graphPath;
-        AZStd::unique_ptr<AZ::Entity> m_entity;
-        ScriptCanvas::RuntimeComponent* m_runtimeComponent = nullptr;
-        bool m_nativeFunctionFound = false;
-        AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasFunctionAsset> m_editorAsset;
-        AZ::Data::Asset<ScriptCanvas::SubgraphInterfaceAsset> m_runtimeAsset;
-        AZ::Data::Asset<AZ::ScriptAsset> m_scriptAsset;
-    };
-
     struct LoadTestGraphResult
     {
         AZStd::string_view m_graphPath;

Gems/ScriptCanvas/Code/Editor/GraphCanvas/Components/NodeDescriptors/EntityRefNodeDescriptorComponent.cpp

@@ -1,126 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#include "precompiled.h"
-
-#include <GraphCanvas/Components/Nodes/NodeTitleBus.h>
-
-#include "EntityRefNodeDescriptorComponent.h"
-
-#include "ScriptCanvas/Core/Datum.h"
-#include "ScriptCanvas/Core/PureData.h"
-#include "ScriptCanvas/Core/Slot.h"
-
-namespace ScriptCanvasEditor
-{
-    /////////////////////////////////////
-    // EntityRefNodeDescriptorComponent
-    /////////////////////////////////////
-
-    void EntityRefNodeDescriptorComponent::Reflect(AZ::ReflectContext* reflectContext)
-    {
-        AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(reflectContext);
-        if (serializeContext)
-        {
-            serializeContext->Class<EntityRefNodeDescriptorComponent, NodeDescriptorComponent>()
-                ->Version(1)
-            ;
-        }
-    }
-
-    EntityRefNodeDescriptorComponent::EntityRefNodeDescriptorComponent()
-        : NodeDescriptorComponent(NodeDescriptorType::EntityRef)
-    {
-    }
-
-    void EntityRefNodeDescriptorComponent::OnEntityNameChanged([[maybe_unused]] const AZStd::string& name)
-    {
-        UpdateNodeTitle();
-    }   
-
-    void EntityRefNodeDescriptorComponent::OnSlotInputChanged(const ScriptCanvas::SlotId& slotId)
-    {
-        if (slotId == m_endpoint.GetSlotId())
-        {
-            AZ::EntityBus::Handler::BusDisconnect();
-
-            AZ::EntityId referencedId = GetReferencedEntityId();
-
-            if (referencedId.IsValid())
-            {
-                AZ::EntityBus::Handler::BusConnect(referencedId);
-            }
-
-            UpdateNodeTitle();
-        }
-    }
-
-    void EntityRefNodeDescriptorComponent::OnAddedToGraphCanvasGraph([[maybe_unused]] const GraphCanvas::GraphId& sceneId, const AZ::EntityId& scriptCanvasNodeId)
-    {
-        ScriptCanvas::SlotId scriptCanvasSlotId;
-        ScriptCanvas::NodeRequestBus::EventResult(scriptCanvasSlotId, scriptCanvasNodeId, &ScriptCanvas::NodeRequests::GetSlotId, ScriptCanvas::PureData::k_setThis);
-
-        m_endpoint = ScriptCanvas::Endpoint(scriptCanvasNodeId, scriptCanvasSlotId);
-
-        if (m_endpoint.IsValid())
-        {
-            AZ::EntityId referencedId = GetReferencedEntityId();
-
-            if (referencedId.IsValid())
-            {
-                AZ::EntityBus::Handler::BusConnect(referencedId);
-            }
-        }
-
-        UpdateNodeTitle();
-    }
-
-    AZ::EntityId EntityRefNodeDescriptorComponent::GetReferencedEntityId() const
-    {
-        AZ::EntityId retVal;
-
-        const ScriptCanvas::Datum* object = nullptr;
-        ScriptCanvas::NodeRequestBus::EventResult(object, m_endpoint.GetNodeId(), &ScriptCanvas::NodeRequests::FindDatum, m_endpoint.GetSlotId());
-
-        if (object && object->IS_A<AZ::EntityId>())
-        {
-            retVal = (*object->GetAs<AZ::EntityId>());
-        }
-
-        return retVal;
-    }    
-    
-    void EntityRefNodeDescriptorComponent::UpdateNodeTitle()
-    {
-        bool needsTitle = true;
-        
-        if (m_endpoint.IsValid())
-        {
-            AZ::EntityId referencedId = GetReferencedEntityId();
-
-            AZStd::string entityName;
-            AZ::ComponentApplicationBus::BroadcastResult(entityName, &AZ::ComponentApplicationRequests::GetEntityName, referencedId);
-                    
-            if (!entityName.empty())
-            {
-                needsTitle = false;
-                GraphCanvas::NodeTitleRequestBus::Event(GetEntityId(), &GraphCanvas::NodeTitleRequests::SetTitle, entityName.c_str());
-            }
-            else if (referencedId.IsValid())
-            {
-                needsTitle = false;
-                GraphCanvas::NodeTitleRequestBus::Event(GetEntityId(), &GraphCanvas::NodeTitleRequests::SetTitle, referencedId.ToString().c_str());
-            }
-        }
-        
-        if (needsTitle)
-        {
-            GraphCanvas::NodeTitleRequestBus::Event(GetEntityId(), &GraphCanvas::NodeTitleRequests::SetTitle, "<None>");
-        }
-
-        GraphCanvas::NodeTitleRequestBus::Event(GetEntityId(), &GraphCanvas::NodeTitleRequests::SetSubTitle, "EntityRef");
-    }
-}

Gems/ScriptCanvas/Code/Editor/GraphCanvas/Components/NodeDescriptors/EntityRefNodeDescriptorComponent.h

@@ -1,48 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <GraphCanvas/Components/Nodes/NodeBus.h>
-
-#include <AzCore/Component/EntityBus.h>
-
-#include "Editor/GraphCanvas/Components/NodeDescriptors/NodeDescriptorComponent.h"
-
-#include "ScriptCanvas/Core/NodeBus.h"
-#include "ScriptCanvas/Core/Endpoint.h"
-
-namespace ScriptCanvasEditor
-{
-    class EntityRefNodeDescriptorComponent
-        : public NodeDescriptorComponent
-        , public AZ::EntityBus::Handler        
-    {
-    public:
-        AZ_COMPONENT(EntityRefNodeDescriptorComponent, "{887AE9AC-C793-4FE5-BAE2-AF6A7F70A374}", NodeDescriptorComponent);
-        static void Reflect(AZ::ReflectContext* reflectContext);
-        
-        EntityRefNodeDescriptorComponent();
-        ~EntityRefNodeDescriptorComponent() = default;
-
-        // AZ::EntityBus
-        void OnEntityNameChanged(const AZStd::string& name) override;
-        ////
-        
-        // ScriptCanvas::NodeNotificationsBus
-        void OnSlotInputChanged(const ScriptCanvas::SlotId& slotId) override;
-        ////
-
-    private:
-
-        void OnAddedToGraphCanvasGraph(const GraphCanvas::GraphId& graphId, const AZ::EntityId& scriptCanvasNodeId) override;
-
-        AZ::EntityId GetReferencedEntityId() const;
-        void UpdateNodeTitle();
-        
-        ScriptCanvas::Endpoint m_endpoint;
-    };
-}

Gems/ScriptCanvas/Code/Editor/GraphCanvas/Components/NodeDescriptors/FunctionNodeDescriptorComponent.h

@@ -10,8 +10,6 @@
 #include <GraphCanvas/Components/VisualBus.h>
 
 #include <Editor/GraphCanvas/Components/NodeDescriptors/NodeDescriptorComponent.h>
-
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
 #include <ScriptCanvas/Bus/RequestBus.h>
 #include <ScriptCanvas/Bus/EditorScriptCanvasBus.h>
 

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

@@ -1,68 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#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 AZ
-{
-    class SerializeContext;
-}
-
-namespace ScriptCanvasEditor
-{
-    class ScriptCanvasFunctionAsset;
-
-    /**
-    * 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 ScriptCanvasEditor::ScriptCanvasFunctionAsset* assetData, AZ::IO::GenericStream* stream);
-
-        bool SaveAssetData(const ScriptCanvasEditor::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();
-
-        ScriptCanvasEditor::ScriptCanvasFunctionAsset* m_scriptCanvasAsset;
-
-    };
-}

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

@@ -154,10 +154,6 @@ namespace ScriptCanvasEditor
         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 bool CanExposeEndpoint(const GraphCanvas::Endpoint& endpoint) = 0;
 
         virtual ScriptCanvas::Endpoint ConvertToScriptCanvasEndpoint(const GraphCanvas::Endpoint& endpoinnt) const = 0;

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

@@ -110,12 +110,12 @@ namespace ScriptCanvasEditor
             , m_graphCanvasSaveVersion(GraphCanvas::EntitySaveDataContainer::CurrentVersion)
             , m_upgradeSM(this)
         {}
-        
+
         ~Graph() override;
 
         void Activate() override;
         void Deactivate() override;
-        
+
         static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
         {
             ScriptCanvas::Graph::GetProvidedServices(provided);
@@ -160,10 +160,6 @@ namespace ScriptCanvasEditor
         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;
 
@@ -192,7 +188,7 @@ namespace ScriptCanvasEditor
         GraphCanvas::CanHandleMimeEventOutcome 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, GraphModelRequests::ExtensionRequestReason ) override;
+        GraphCanvas::SlotId RequestExtension(const GraphCanvas::NodeId& nodeId, const GraphCanvas::ExtenderId& extenderId, GraphModelRequests::ExtensionRequestReason) override;
         void ExtensionCancelled(const GraphCanvas::NodeId& nodeId, const GraphCanvas::ExtenderId& extenderId) override;
         void FinalizeExtension(const GraphCanvas::NodeId& nodeId, const GraphCanvas::ExtenderId& extenderId) override;
 
@@ -216,7 +212,7 @@ namespace ScriptCanvasEditor
         void PostCreationEvent() override;
         void OnPasteBegin() override;
         void OnPasteEnd() override;
-        
+
         void OnViewRegistered() override;
         /////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -262,7 +258,7 @@ namespace ScriptCanvasEditor
 
         AZStd::vector<NodeIdPair> GetNodesOfType(const ScriptCanvas::NodeTypeIdentifier&) override;
         AZStd::vector<NodeIdPair> GetVariableNodes(const ScriptCanvas::VariableId&) override;
-        
+
         void RemoveUnusedVariables() override;
 
         bool CanConvertVariableNodeToReference(const GraphCanvas::NodeId& nodeId) override;
@@ -270,12 +266,9 @@ namespace ScriptCanvasEditor
         bool ConvertReferenceToVariableNode(const GraphCanvas::Endpoint& endpoint) override;
 
         void QueueVersionUpdate(const AZ::EntityId& graphCanvasNodeId) override;
-        
-        bool IsRuntimeGraph() const override;
-        bool IsFunctionGraph() const override;
 
         bool CanExposeEndpoint(const GraphCanvas::Endpoint& endpoint) override;
-        
+
         ScriptCanvas::Endpoint ConvertToScriptCanvasEndpoint(const GraphCanvas::Endpoint& endpoint) const override;
         GraphCanvas::Endpoint ConvertToGraphCanvasEndpoint(const ScriptCanvas::Endpoint& endpoint) const override;
         ////
@@ -333,8 +326,8 @@ namespace ScriptCanvasEditor
         Graph(const Graph&) = delete;
 
         void DisplayUpdateToast();
-        
-        AZ::EntityId          ConvertToScriptCanvasNodeId(const GraphCanvas::NodeId& nodeId) const;        
+
+        AZ::EntityId          ConvertToScriptCanvasNodeId(const GraphCanvas::NodeId& nodeId) const;
 
         GraphCanvas::NodePropertyDisplay* CreateDisplayPropertyForSlot(const AZ::EntityId& scriptCanvasNodeId, const ScriptCanvas::SlotId& scriptCanvasSlotId) const;
 
@@ -370,10 +363,10 @@ namespace ScriptCanvasEditor
         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;

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

@@ -37,7 +37,7 @@ namespace ScriptCanvasEditor
         EBusHandler,
         EBusHandlerEvent,
         EBusSender,
-        EntityRef,
+        _deprecated_,
         VariableNode,
         SetVariable,
         GetVariable,

Gems/ScriptCanvas/Code/Editor/Nodes/EditorLibrary.cpp

@@ -1,56 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#include "precompiled.h"
-
-#include <AzCore/Serialization/EditContext.h>
-
-#include <Editor/Nodes/EditorLibrary.h>
-#include <Editor/Nodes/ScriptCanvasAssetNode.h>
-
-
-namespace ScriptCanvasEditor
-{
-    namespace Library
-    {
-        void Editor::Reflect(AZ::ReflectContext* reflection)
-        {
-            AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(reflection);
-            if (serializeContext)
-            {
-                serializeContext->Class<Editor, LibraryDefinition>()
-                    ->Version(1)
-                    ;
-
-                AZ::EditContext* editContext = serializeContext->GetEditContext();
-                if (editContext)
-                {
-                    editContext->Class<Editor>("Editor", "")
-                        ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
-                        ->Attribute(AZ::Edit::Attributes::Icon, "Icons/Components/All.png")
-                        ;
-                }
-            }
-        }
-
-        void Editor::InitNodeRegistry(ScriptCanvas::NodeRegistry& nodeRegistry)
-        {
-            ScriptCanvas::Library::AddNodeToRegistry<Editor, ScriptCanvasAssetNode>(nodeRegistry);
-        }
-
-        AZStd::vector<AZ::ComponentDescriptor*> Editor::GetComponentDescriptors()
-        {
-            return AZStd::vector<AZ::ComponentDescriptor*>({
-                ScriptCanvasAssetNode::CreateDescriptor(),
-            });
-        }
-    }
-
-    AZStd::vector<AZ::ComponentDescriptor*> GetLibraryDescriptors()
-    {
-        return Library::Editor::GetComponentDescriptors();
-    }
-}

Gems/ScriptCanvas/Code/Editor/Nodes/EditorLibrary.h

@@ -1,32 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <ScriptCanvas/Libraries/Libraries.h>
-
-namespace AZ
-{
-    class ReflectContext;
-    class ComponentDescriptor;
-}
-
-namespace ScriptCanvasEditor
-{
-    namespace Library
-    {
-        struct Editor : public ScriptCanvas::Library::LibraryDefinition
-        {
-            AZ_RTTI(Editor, "{59697735-4B64-4DC5-8380-02B2999FFCFE}", ScriptCanvas::Library::LibraryDefinition);
-
-            static void Reflect(AZ::ReflectContext*);
-            static void InitNodeRegistry(ScriptCanvas::NodeRegistry& nodeRegistry);
-            static AZStd::vector<AZ::ComponentDescriptor*> GetComponentDescriptors();
-        };
-    }
-
-    AZStd::vector<AZ::ComponentDescriptor*> GetLibraryDescriptors();
-}

Gems/ScriptCanvas/Code/Editor/Nodes/NodeCreateUtils.cpp

@@ -26,7 +26,6 @@
 #include <ScriptCanvas/Libraries/Core/ReceiveScriptEvent.h>
 #include <ScriptCanvas/Libraries/Core/SendScriptEvent.h>
 #include <ScriptCanvas/Libraries/Core/SetVariable.h>
-#include <ScriptCanvas/Libraries/Entity/EntityRef.h>
 
 namespace ScriptCanvasEditor::Nodes
 {
@@ -132,36 +131,6 @@ namespace ScriptCanvasEditor::Nodes
         return AZStd::make_pair(node, nodeIdPair);
     }
 
-    NodeIdPair CreateEntityNode(const AZ::EntityId& sourceId, const ScriptCanvas::ScriptCanvasId& scriptCanvasId)
-    {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
-        NodeIdPair nodeIdPair;
-
-        ScriptCanvas::Node* node = nullptr;
-        AZ::Entity* scriptCanvasEntity{ aznew AZ::Entity };
-        scriptCanvasEntity->Init();
-        nodeIdPair.m_scriptCanvasId = scriptCanvasEntity->GetId();
-        ScriptCanvas::SystemRequestBus::BroadcastResult(node, &ScriptCanvas::SystemRequests::CreateNodeOnEntity, scriptCanvasEntity->GetId(), scriptCanvasId, ScriptCanvas::Nodes::Entity::EntityRef::RTTI_Type());
-
-        auto* entityNode = azrtti_cast<ScriptCanvas::Nodes::Entity::EntityRef*>(node);
-        entityNode->SetEntityRef(sourceId);
-
-        // Set the name
-        AZ::Entity* sourceEntity = nullptr;
-        AZ::ComponentApplicationBus::BroadcastResult(sourceEntity, &AZ::ComponentApplicationRequests::FindEntity, sourceId);
-        if (sourceEntity)
-        {
-            scriptCanvasEntity->SetName(AZStd::string::format("SC-EntityRef(%s)", sourceEntity->GetName().data()));
-        }
-
-        AZ::EntityId graphCanvasGraphId;
-        EditorGraphRequestBus::EventResult(graphCanvasGraphId, scriptCanvasId, &EditorGraphRequests::GetGraphCanvasGraphId);
-
-        nodeIdPair.m_graphCanvasId = DisplayEntityNode(graphCanvasGraphId, entityNode);
-
-        return nodeIdPair;
-    }
-
     NodeIdPair CreateObjectMethodNode(AZStd::string_view className, AZStd::string_view methodName, const ScriptCanvas::ScriptCanvasId& scriptCanvasId, ScriptCanvas::PropertyStatus propertyStatus)
     {
         AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);

Gems/ScriptCanvas/Code/Editor/Nodes/NodeCreateUtils.h

@@ -28,7 +28,6 @@ namespace ScriptCanvasEditor::Nodes
     // Specific create methods which will also handle displaying the node.
     AZStd::pair<ScriptCanvas::Node*, NodeIdPair> CreateAndGetNode(const AZ::Uuid& classData, const ScriptCanvas::ScriptCanvasId& scriptCanvasId, const StyleConfiguration& styleConfiguration, AZStd::function<void(ScriptCanvas::Node*)> = nullptr);
     NodeIdPair CreateNode(const AZ::Uuid& classData, const ScriptCanvas::ScriptCanvasId& scriptCanvasId, const StyleConfiguration& styleConfiguration);
-    NodeIdPair CreateEntityNode(const AZ::EntityId& sourceId, const ScriptCanvas::ScriptCanvasId& scriptCanvasId);
     NodeIdPair CreateObjectMethodNode(AZStd::string_view className, AZStd::string_view methodName, const ScriptCanvas::ScriptCanvasId& scriptCanvasId, ScriptCanvas::PropertyStatus propertyStatus);
     NodeIdPair CreateObjectMethodOverloadNode(AZStd::string_view className, AZStd::string_view methodName, const ScriptCanvas::ScriptCanvasId& scriptCanvasGraphId);
     NodeIdPair CreateGlobalMethodNode(AZStd::string_view methodName, const ScriptCanvas::ScriptCanvasId& scriptCanvasId);

Gems/ScriptCanvas/Code/Editor/Nodes/NodeDisplayUtils.cpp

@@ -18,7 +18,6 @@
 #include <GraphCanvas/Components/NodeDescriptors/EBusHandlerEventNodeDescriptorComponent.h>
 #include <GraphCanvas/Components/NodeDescriptors/EBusHandlerNodeDescriptorComponent.h>
 #include <GraphCanvas/Components/NodeDescriptors/EBusSenderNodeDescriptorComponent.h>
-#include <GraphCanvas/Components/NodeDescriptors/EntityRefNodeDescriptorComponent.h>
 #include <GraphCanvas/Components/NodeDescriptors/FunctionNodeDescriptorComponent.h>
 #include <GraphCanvas/Components/NodeDescriptors/GetVariableNodeDescriptorComponent.h>
 #include <GraphCanvas/Components/NodeDescriptors/NodelingDescriptorComponent.h>
@@ -44,8 +43,6 @@
 #include <ScriptCanvas/Libraries/Core/Method.h>
 #include <ScriptCanvas/Libraries/Core/SendScriptEvent.h>
 #include <ScriptCanvas/Libraries/Core/SetVariable.h>
-#include <ScriptCanvas/Libraries/Entity/EntityRef.h>
-
 
 namespace ScriptCanvasEditor::Nodes::SlotDisplayHelper
 {
@@ -231,57 +228,6 @@ namespace ScriptCanvasEditor::Nodes
         return DisplayGeneralScriptCanvasNode(graphCanvasGraphId, node, nodeConfiguration);
     }
 
-    AZ::EntityId DisplayEntityNode(AZ::EntityId, const ScriptCanvas::Nodes::Entity::EntityRef* entityNode)
-    {
-        AZ::EntityId graphCanvasNodeId;
-
-        AZ::Entity* graphCanvasEntity = nullptr;
-        GraphCanvas::GraphCanvasRequestBus::BroadcastResult(graphCanvasEntity, &GraphCanvas::GraphCanvasRequests::CreateGeneralNode, ".entity");
-        AZ_Assert(graphCanvasEntity, "Unable to create GraphCanvas Bus Node");
-
-        graphCanvasNodeId = graphCanvasEntity->GetId();
-
-        // Add the icon component
-        graphCanvasEntity->CreateComponent<IconComponent>(ScriptCanvas::Nodes::Entity::EntityRef::RTTI_Type());
-        graphCanvasEntity->CreateComponent<EntityRefNodeDescriptorComponent>();
-        graphCanvasEntity->CreateComponent<SlotMappingComponent>(entityNode->GetEntityId());
-        graphCanvasEntity->CreateComponent<SceneMemberMappingComponent>(entityNode->GetEntityId());
-
-        graphCanvasEntity->Init();
-        graphCanvasEntity->Activate();
-
-        // Set the user data on the GraphCanvas node to be the EntityId of the ScriptCanvas node
-        AZStd::any* graphCanvasUserData = nullptr;
-        GraphCanvas::NodeRequestBus::EventResult(graphCanvasUserData, graphCanvasNodeId, &GraphCanvas::NodeRequests::GetUserData);
-        if (graphCanvasUserData)
-        {
-            *graphCanvasUserData = entityNode->GetEntityId();
-        }
-
-        // Create the GraphCanvas slots
-        for (const auto& slot : entityNode->GetSlots())
-        {
-            if (slot.GetDescriptor() == ScriptCanvas::SlotDescriptors::DataOut() && slot.IsVisible())
-            {
-                DisplayScriptCanvasSlot(graphCanvasNodeId, slot);
-            }
-        }
-
-        AZ::Entity* sourceEntity = nullptr;
-        AZ::ComponentApplicationBus::BroadcastResult(sourceEntity, &AZ::ComponentApplicationRequests::FindEntity, entityNode->GetEntityRef());
-
-        if (sourceEntity)
-        {
-            graphCanvasEntity->SetName(AZStd::string::format("GC-EntityRef(%s)", sourceEntity->GetName().data()));
-        }
-        else
-        {
-            graphCanvasEntity->SetName(AZStd::string::format("GC-EntityRef(%s)", entityNode->GetEntityRef().ToString().c_str()));
-        }
-
-        return graphCanvasNodeId;
-    }
-
     static void ConfigureGeneralScriptCanvasEntity(const ScriptCanvas::Node* node, AZ::Entity* graphCanvasEntity, const GraphCanvas::SlotGroup& slotGroup = GraphCanvas::SlotGroups::Invalid)
     {
         if (node->RequiresDynamicSlotOrdering())
@@ -1145,10 +1091,6 @@ namespace ScriptCanvasEditor::Nodes
         {
             graphCanvasNodeId = DisplayAzEventHandlerNode(graphCanvasGraphId, azEventHandlerNode);
         }
-        else if (azrtti_istypeof<ScriptCanvas::Nodes::Entity::EntityRef>(node))
-        {
-            graphCanvasNodeId = DisplayEntityNode(graphCanvasGraphId, static_cast<const ScriptCanvas::Nodes::Entity::EntityRef*>(node));
-        }
         else if (azrtti_istypeof<ScriptCanvas::Nodes::Core::ReceiveScriptEvent>(node))
         {
             graphCanvasNodeId = DisplayScriptEventWrapperNode(graphCanvasGraphId, static_cast<const ScriptCanvas::Nodes::Core::ReceiveScriptEvent*>(node));

Gems/ScriptCanvas/Code/Editor/Nodes/NodeDisplayUtils.h

@@ -30,10 +30,6 @@ namespace ScriptCanvas::Nodes::Core
     class SetVariableNode;
     class SendScriptEvent;
 }
-namespace ScriptCanvas::Nodes::Entity
-{
-    class EntityRef;
-}
 namespace ScriptEvents
 {
     class Method;
@@ -45,7 +41,6 @@ namespace ScriptCanvasEditor::Nodes
     AZ::EntityId DisplayScriptCanvasNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Node* node);
 
     // Core Node
-    AZ::EntityId DisplayEntityNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Entity::EntityRef* entityNode);
     AZ::EntityId DisplayEbusEventNode(AZ::EntityId graphCanvasGraphId, const AZStd::string& busName, const AZStd::string& eventName, const ScriptCanvas::EBusEventId& eventId);
     AZ::EntityId DisplayEbusWrapperNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::EBusEventHandler* busNode);
     AZ::EntityId DisplayGetVariableNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::GetVariableNode* variableNode);

Gems/ScriptCanvas/Code/Editor/Nodes/NodeUtils.cpp

@@ -11,26 +11,10 @@
 #include <GraphCanvas/Components/Slots/SlotBus.h>
 #include <GraphCanvas/Components/DynamicOrderingDynamicSlotComponent.h>
 
-#include <ScriptCanvas/Core/PureData.h>
 #include <ScriptCanvas/Core/NodeBus.h>
 
 namespace
 {
-    void CopyTranslationKeyedNameToDatumLabel(ScriptCanvas::PureData* node,
-                                                const GraphCanvas::TranslationKeyedString& name)
-    {
-        ScriptCanvas::SlotId slotId = node->GetSlotId(ScriptCanvas::PureData::k_setThis);
-        if (!slotId.IsValid())
-        {
-            return;
-        }
-
-        ScriptCanvas::ModifiableDatumView datumView;
-        node->FindModifiableDatumView(slotId, datumView);
-
-        datumView.RelabelDatum(name.GetDisplayString());
-    }
-
     ScriptCanvas::ConnectionType ToScriptCanvasConnectionType(GraphCanvas::ConnectionType connectionType)
     {
         ScriptCanvas::ConnectionType scriptCanvasConnectionType = ScriptCanvas::ConnectionType::Unknown;

Gems/ScriptCanvas/Code/Editor/Nodes/ScriptCanvasAssetNode.cpp

@@ -1,205 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "precompiled.h"
-#include <Editor/Nodes/ScriptCanvasAssetNode.h>
-
-#include <ScriptCanvas/Core/Graph.h>
-#include <Editor/Assets/ScriptCanvasAssetTrackerBus.h>
-
-namespace ScriptCanvasEditor
-{
-    /**
-    * \note when we reflecting we can check if the class is inheriting from IEventHandler
-    * and use the this->events.
-    */
-    class ScriptCanvasAssetNodeEventHandler
-        : public AZ::SerializeContext::IEventHandler
-    {
-        void OnReadBegin(void* classPtr)
-        {
-            auto* scriptCanvasAssetNode = reinterpret_cast<ScriptCanvasAssetNode*>(classPtr);
-            scriptCanvasAssetNode->ComputeDataPatch();
-        }
-    };
-
-    void ScriptCanvasAssetNode::Reflect(AZ::ReflectContext* context)
-    {
-        AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
-        if (!serializeContext)
-        {
-            return;
-        }
-
-        serializeContext->Class<ScriptCanvasAssetNode, ScriptCanvas::Node>()
-            ->Version(0)
-            ->EventHandler<ScriptCanvasAssetNodeEventHandler>()
-            ->Field("m_assetInstance", &ScriptCanvasAssetNode::m_scriptCanvasAssetInstance)
-            ;
-
-        if (AZ::EditContext* editContext = serializeContext->GetEditContext())
-        {
-            editContext->Class<ScriptCanvasAssetNode>("ScriptCanvas Asset", "Script Canvas Asset Node which contains a reference to another ScriptCanvas graph")
-                ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
-                ->Attribute(AZ::Edit::Attributes::Icon, "Icons/ScriptCanvas/Placeholder.png")
-                ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::List)
-                ;
-        }
-    }
-
-    ScriptCanvasAssetNode::ScriptCanvasAssetNode(const AZ::Data::Asset<ScriptCanvasAsset>& scriptCanvasAsset, bool storeAssetDataInternally)
-    {
-        SetAssetDataStoredInternally(storeAssetDataInternally);
-        SetAsset(scriptCanvasAsset);
-    }
-
-    ScriptCanvasAssetNode::~ScriptCanvasAssetNode()
-    {
-    }
-
-    void ScriptCanvasAssetNode::OnInputSignal(const ScriptCanvas::SlotId&)
-    {
-
-    }
-
-    void ScriptCanvasAssetNode::OnInit()
-    {
-        if (GetAsset().GetId().IsValid())
-        {
-            AZ::Data::AssetBus::Handler::BusConnect(GetAsset().GetId());
-            AZ::Entity* scriptCanvasEntity = GetScriptCanvasEntity();
-            if (scriptCanvasEntity)
-            {
-                if (scriptCanvasEntity->GetState() == AZ::Entity::State::Constructed)
-                {
-                    scriptCanvasEntity->Init();
-                }
-                if (scriptCanvasEntity->GetState() == AZ::Entity::State::Init)
-                {
-                    scriptCanvasEntity->Activate();
-                }
-            }
-        }
-    }
-
-    bool ScriptCanvasAssetNode::GetAssetDataStoredInternally() const
-    {
-        return m_scriptCanvasAssetInstance.GetReference().GetAssetDataStoredInternally();
-    }
-
-    void ScriptCanvasAssetNode::SetAssetDataStoredInternally(bool storeInObjectStream)
-    {
-        m_scriptCanvasAssetInstance.GetReference().SetAssetDataStoredInternally(storeInObjectStream);
-    }
-
-    ScriptCanvas::ScriptCanvasData& ScriptCanvasAssetNode::GetScriptCanvasData()
-    {
-        return m_scriptCanvasAssetInstance.GetScriptCanvasData();
-    }
-
-    const ScriptCanvas::ScriptCanvasData& ScriptCanvasAssetNode::GetScriptCanvasData() const
-    {
-        return m_scriptCanvasAssetInstance.GetScriptCanvasData();
-    }
-
-    AZ::Entity* ScriptCanvasAssetNode::GetScriptCanvasEntity() const
-    {
-        return GetScriptCanvasData().GetScriptCanvasEntity();
-    }
-
-    AZ::Data::Asset<ScriptCanvasAsset>& ScriptCanvasAssetNode::GetAsset()
-    {
-        return m_scriptCanvasAssetInstance.GetReference().GetAsset();
-    }
-
-    const AZ::Data::Asset<ScriptCanvasAsset>& ScriptCanvasAssetNode::GetAsset() const
-    {
-        return m_scriptCanvasAssetInstance.GetReference().GetAsset();
-    }
-
-    void ScriptCanvasAssetNode::SetAsset(const AZ::Data::Asset<ScriptCanvasAsset>& scriptCanvasAsset)
-    {
-        m_scriptCanvasAssetInstance.GetReference().SetAsset(scriptCanvasAsset);
-        if (scriptCanvasAsset.GetId().IsValid())
-        {
-            auto onAssetReady = [](ScriptCanvasMemoryAsset&) {};
-            AssetTrackerRequestBus::Broadcast(&AssetTrackerRequests::Load, scriptCanvasAsset.GetId(), azrtti_typeid<ScriptCanvasAsset>(), onAssetReady);
-
-            AZ::Data::AssetBus::Handler::BusConnect(scriptCanvasAsset.GetId());
-            ApplyDataPatch();
-        }
-    }
-
-    void ScriptCanvasAssetNode::OnAssetReloaded(AZ::Data::Asset<AZ::Data::AssetData> asset)
-    {
-        SetAsset(asset);
-        if (!GetAsset().IsReady())
-        {
-            AZ_Error("Script Canvas", false, "Reloaded graph with id %s is not valid", asset.GetId().ToString<AZStd::string>().data());
-            return;
-        }
-
-        // Update data patches against the old version of the asset.
-        ApplyDataPatch();
-    }
-
-    void ScriptCanvasAssetNode::OnAssetUnloaded(const AZ::Data::AssetId assetId, const AZ::Data::AssetType)
-    {
-        AZ::Data::AssetBus::Handler::BusDisconnect(assetId);
-    }
-
-    void ScriptCanvasAssetNode::ComputeDataPatch()
-    {
-        m_scriptCanvasAssetInstance.ComputeDataPatch();
-    }
-
-    void ScriptCanvasAssetNode::ApplyDataPatch()
-    {
-        m_scriptCanvasAssetInstance.ApplyDataPatch();
-    }
-
-    bool ScriptCanvasAssetNode::Visit(const VisitCB& preVisitCB, const VisitCB & postVisitCB)
-    {
-        AZStd::unordered_set<AZ::Data::AssetId> visitedGraphs;
-        return Visit(preVisitCB, postVisitCB, visitedGraphs);
-    }
-
-    bool ScriptCanvasAssetNode::Visit(const VisitCB& preVisitCB, const VisitCB & postVisitCB, AZStd::unordered_set<AZ::Data::AssetId>& visitedGraphs)
-    {
-        const AZ::Data::AssetId& visitedAssetId = GetAsset().GetId();
-        if (visitedGraphs.count(visitedAssetId) > 0)
-        {
-            AZ_Error("Script Canvas", false, "The Script Canvas Asset %s has already been visited, processing will stop", visitedAssetId.ToString<AZStd::string>().data());
-            return false;
-        }
-
-        if (!preVisitCB || preVisitCB(*this))
-        {
-            auto graph = GetScriptCanvasEntity() ? AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvas::Graph>(GetScriptCanvasEntity()) : nullptr;
-            if (graph)
-            {
-                for (AZ::Entity* nodeEntity : graph->GetNodeEntities())
-                {
-                    if (auto childAssetNode = AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvasAssetNode>(nodeEntity))
-                    {
-                        // Visit ScriptCanvasAssetNodes that are in the asset referenced by @assetNode
-                        if (!childAssetNode->Visit(preVisitCB, postVisitCB, visitedGraphs))
-                        {
-                            break;
-                        }
-
-                    }
-                }
-            }
-        }
-
-        // Visit siblings ScriptCanvasAssetNodes
-        bool visitSiblings = !postVisitCB || postVisitCB(*this);
-        visitedGraphs.insert(visitedAssetId);
-        return visitSiblings;
-    }
-}

Gems/ScriptCanvas/Code/Editor/Nodes/ScriptCanvasAssetNode.h

@@ -1,92 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <AzCore/Component/Component.h>
-
-#include <ScriptCanvas/Core/Node.h>
-#include <ScriptCanvas/Bus/GraphBus.h>
-#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
-#include <Editor/Assets/ScriptCanvasAssetInstance.h>
-
-namespace ScriptCanvasEditor
-{
-    //! A group of entities in a scene
-    class ScriptCanvasAssetNode
-        : public ScriptCanvas::Node
-        , protected AZ::Data::AssetBus::Handler
-    {
-    public:
-        AZ_COMPONENT(ScriptCanvasAssetNode, "{65A34956-B6ED-4EB2-966C-5BC844F7B05E}", ScriptCanvas::Node);
-
-        static void Reflect(AZ::ReflectContext* context);
-
-        ScriptCanvasAssetNode() = default;
-        ScriptCanvasAssetNode(const AZ::Data::Asset<ScriptCanvasAsset>& scriptCanvasAsset, bool storeAssetDataInternally);
-        ~ScriptCanvasAssetNode() override;
-
-        // AZ::Component
-        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
-        {
-            provided.push_back(AZ_CRC("ScriptCanvas_AssetService", 0x17a357ae));
-        }
-
-        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
-        {
-            incompatible.push_back(AZ_CRC("ScriptCanvas_AssetService", 0x17a357ae));
-        }
-
-        static void GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& dependent)
-        {
-            (void)dependent;
-        }
-
-        static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required)
-        {
-            (void)required;
-        }
-        ////
-
-        void OnInit() override;
-
-        // Retrieves the asset associated with this node
-        AZ::Data::Asset<ScriptCanvasAsset>& GetAsset();
-        const AZ::Data::Asset<ScriptCanvasAsset>& GetAsset() const;
-        // Sets the asset associated with this node
-        void SetAsset(const AZ::Data::Asset<ScriptCanvasAsset>& scriptCanvasAsset);
-
-        bool GetAssetDataStoredInternally() const;
-        void SetAssetDataStoredInternally(bool storeInObjectStream);
-
-        ScriptCanvas::ScriptCanvasData& GetScriptCanvasData();
-        const ScriptCanvas::ScriptCanvasData& GetScriptCanvasData() const;
-
-        AZ::Entity* GetScriptCanvasEntity() const;
-
-        using VisitCB = AZStd::function<bool(ScriptCanvasAssetNode& scriptCanvasAssetNode)>;
-        bool Visit(const VisitCB& preVisitCB, const VisitCB & postVisitCB);
-        bool Visit(const VisitCB& preVisitCB, const VisitCB & postVisitCB, AZStd::unordered_set<AZ::Data::AssetId>& visitedGraphs);
-        ////
-
-    protected:
-        void OnInputSignal(const ScriptCanvas::SlotId&) override;
-        // AssetBus::Handler
-        void OnAssetReloaded(AZ::Data::Asset<AZ::Data::AssetData> asset) override;
-        void OnAssetUnloaded(const AZ::Data::AssetId assetId, const AZ::Data::AssetType) override;
-        ////
-
-        friend class ScriptCanvasAssetNodeEventHandler;
-        void ComputeDataPatch();
-        void ApplyDataPatch();
-
-    private:
-        ScriptCanvasAssetNode(const ScriptCanvasAssetNode&) = delete;
-        //! References to the Script Canvas asset used by this component
-        ScriptCanvasAssetInstance m_scriptCanvasAssetInstance;
-    };
-}

Gems/ScriptCanvas/Code/Editor/ReflectComponent.cpp

@@ -13,10 +13,6 @@
 #include <AzCore/Serialization/EditContext.h>
 
 #include <Editor/Assets/ScriptCanvasAssetHolder.h>
-#include <Editor/Assets/ScriptCanvasAssetReference.h>
-#include <Editor/Assets/ScriptCanvasAssetInstance.h>
-
-#include <Editor/Nodes/EditorLibrary.h>
 
 #include <Editor/View/Dialogs/SettingsDialog.h>
 #include <Editor/View/Widgets/LoggingPanel/LiveWindowSession/LiveLoggingWindowSession.h>
@@ -36,12 +32,9 @@ namespace ScriptCanvasEditor
     void ReflectComponent::Reflect(AZ::ReflectContext* context)
     {
         ScriptCanvas::ScriptCanvasData::Reflect(context);
-        ScriptCanvasAssetReference::Reflect(context);
-        ScriptCanvasAssetInstance::Reflect(context);
         ScriptCanvasAssetHolder::Reflect(context);
         EditorSettings::EditorWorkspace::Reflect(context);        
         EditorSettings::ScriptCanvasEditorSettings::Reflect(context);        
-        Library::Editor::Reflect(context);
         LiveLoggingUserSettings::Reflect(context);
         UndoData::Reflect(context);
 
@@ -59,7 +52,6 @@ namespace ScriptCanvasEditor
         CreateEBusHandlerMimeEvent::Reflect(context);
         CreateEBusHandlerEventMimeEvent::Reflect(context);
         CreateEBusSenderMimeEvent::Reflect(context);
-        CreateEntityRefNodeMimeEvent::Reflect(context);
         CreateGetVariableNodeMimeEvent::Reflect(context);
         CreateSetVariableNodeMimeEvent::Reflect(context);
         CreateVariableChangedNodeMimeEvent::Reflect(context);

Gems/ScriptCanvas/Code/Editor/ScriptCanvasEditorGem.cpp

@@ -35,7 +35,6 @@
 #include <Editor/Model/EntityMimeDataHandler.h>
 
 #include <Libraries/Libraries.h>
-#include <Editor/Nodes/EditorLibrary.h>
 
 #include <ScriptCanvas/Components/EditorGraph.h>
 #include <ScriptCanvas/Components/EditorGraphVariableManagerComponent.h>
@@ -53,7 +52,6 @@
 #include <Editor/GraphCanvas/Components/NodeDescriptors/ScriptEventReceiverNodeDescriptorComponent.h>
 #include <Editor/GraphCanvas/Components/NodeDescriptors/ScriptEventSenderNodeDescriptorComponent.h>
 #include <Editor/GraphCanvas/Components/NodeDescriptors/EBusSenderNodeDescriptorComponent.h>
-#include <Editor/GraphCanvas/Components/NodeDescriptors/EntityRefNodeDescriptorComponent.h>
 #include <Editor/GraphCanvas/Components/NodeDescriptors/GetVariableNodeDescriptorComponent.h>
 #include <Editor/GraphCanvas/Components/NodeDescriptors/NodeDescriptorComponent.h>
 #include <Editor/GraphCanvas/Components/NodeDescriptors/NodelingDescriptorComponent.h>
@@ -108,7 +106,6 @@ namespace ScriptCanvas
             ScriptCanvasEditor::ScriptEventReceiverNodeDescriptorComponent::CreateDescriptor(),
             ScriptCanvasEditor::ScriptEventSenderNodeDescriptorComponent::CreateDescriptor(),
             ScriptCanvasEditor::EBusSenderNodeDescriptorComponent::CreateDescriptor(),
-            ScriptCanvasEditor::EntityRefNodeDescriptorComponent::CreateDescriptor(),
             ScriptCanvasEditor::VariableNodeDescriptorComponent::CreateDescriptor(),
             ScriptCanvasEditor::GetVariableNodeDescriptorComponent::CreateDescriptor(),
             ScriptCanvasEditor::SetVariableNodeDescriptorComponent::CreateDescriptor(),
@@ -117,10 +114,6 @@ namespace ScriptCanvas
             ScriptCanvasEditor::FunctionDefinitionNodeDescriptorComponent::CreateDescriptor(),
             ScriptCanvasEditor::NodelingDescriptorComponent::CreateDescriptor()
             });
-
-        auto libraryDescriptors = ScriptCanvasEditor::GetLibraryDescriptors();
-        m_descriptors.insert(m_descriptors.end(), libraryDescriptors.begin(), libraryDescriptors.end());
-        ScriptCanvasEditor::Library::Editor::InitNodeRegistry(GetNodeRegistry().Get());
     }
 
     AZ::ComponentTypeList ScriptCanvasModule::GetRequiredSystemComponents() const

Gems/ScriptCanvas/Code/Editor/SystemComponent.cpp

@@ -47,8 +47,6 @@
 #include <AzFramework/IO/FileOperations.h>
 #include <AzCore/Serialization/Utils.h>
 
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
-
 namespace ScriptCanvasEditor
 {
     static const size_t cs_jobThreads = 1;
@@ -332,12 +330,6 @@ namespace ScriptCanvasEditor
             isScriptCanvasAsset = true;
         }
 
-        ScriptCanvasFunctionDescription scriptCanvasFunctionAssetDescription;
-        if (!isScriptCanvasAsset && AZStd::wildcard_match(AZStd::string::format("*%s", scriptCanvasFunctionAssetDescription.GetExtensionImpl()).c_str(), fullSourceFileName))
-        {
-            isScriptCanvasAsset = true;
-        }
-
         if (isScriptCanvasAsset)
         {
             auto scriptCanvasEditorCallback = [this]([[maybe_unused]] const char* fullSourceFileNameInCall, const AZ::Uuid& sourceUUIDInCall)
@@ -412,7 +404,7 @@ namespace ScriptCanvasEditor
             nullptr,
             [this](const AZ::Data::AssetId, const AZ::Data::AssetInfo& assetInfo) {
 
-                if (assetInfo.m_assetType == azrtti_typeid<ScriptCanvasAsset>() || assetInfo.m_assetType == azrtti_typeid<ScriptCanvasFunctionAsset>())
+                if (assetInfo.m_assetType == azrtti_typeid<ScriptCanvasAsset>())
                 {
                     AddAssetToUpgrade(assetInfo);
                 }
@@ -456,11 +448,7 @@ namespace ScriptCanvasEditor
 
         if (query == m_assetsToConvert.end())
         {
-            if (assetInfo.m_assetType == azrtti_typeid<ScriptCanvasFunctionAsset>())
-            {
-                m_assetsToConvert.push_front(assetInfo);
-            }
-            else if (assetInfo.m_assetType == azrtti_typeid<ScriptCanvasAsset>())
+            if (assetInfo.m_assetType == azrtti_typeid<ScriptCanvasAsset>())
             {
                 m_assetsToConvert.push_back(assetInfo);
             }

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/FunctionNodePaletteTreeItemTypes.h

@@ -15,9 +15,6 @@
 
 #include <ScriptCanvas/Bus/NodeIdPair.h>
 #include <ScriptCanvas/Bus/RequestBus.h>
-
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
-
 #include <Editor/View/Widgets/NodePalette/CreateNodeMimeEvent.h>
 
 #include <ScriptCanvas/GraphCanvas/NodeDescriptorBus.h>

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/NodePaletteModel.cpp

@@ -23,7 +23,6 @@
 #include <Editor/Settings.h>
 #include <Editor/Translation/TranslationHelper.h>
 
-#include <ScriptCanvas/Core/PureData.h>
 #include <ScriptCanvas/Data/DataRegistry.h>
 #include <ScriptCanvas/Libraries/Libraries.h>
 #include <ScriptCanvas/Libraries/Core/GetVariable.h>
@@ -342,12 +341,6 @@ namespace
                     continue;
                 }
 
-                // Detect primitive types os we avoid making nodes out of them.
-                // Or anything that is 'pure data' and should be populated through a different mechanism.
-                if (nodeClassData->m_azRtti && nodeClassData->m_azRtti->IsTypeOf<ScriptCanvas::PureData>())
-                {
-                    continue;
-                }
                 // Skip over some of our more dynamic nodes that we want to populate using different means
                 else if (nodeClassData->m_azRtti && nodeClassData->m_azRtti->IsTypeOf<ScriptCanvas::Nodes::Core::GetVariableNode>())
                 {
@@ -1323,56 +1316,6 @@ namespace ScriptCanvasEditor
         return identifiers;
     }
 
-    AZStd::vector<ScriptCanvas::NodeTypeIdentifier> NodePaletteModel::RegisterFunctionInformation(ScriptCanvasFunctionAsset* functionAsset)
-    {
-        const AZ::Data::AssetId& assetId = functionAsset->GetId();
-
-        FunctionNodeModelInformation* modelInformation = aznew FunctionNodeModelInformation();
-
-        modelInformation->m_functionAssetId = assetId;
-        modelInformation->m_titlePaletteOverride = "FunctionNodeTitlePalette";
-        modelInformation->m_nodeIdentifier = ScriptCanvas::NodeUtils::ConstructFunctionNodeIdentifier(assetId);
-
-        // Temporary until I drive data from the function asset itself
-        AZStd::string rootPath;
-        AZ::Data::AssetInfo assetInfo = AssetHelpers::GetAssetInfo(assetId, rootPath);
-        AZStd::string absolutePath;
-
-        AzFramework::StringFunc::Path::Join(rootPath.c_str(), assetInfo.m_relativePath.c_str(), absolutePath);
-
-        AZStd::string category = "User Functions";
-        AZStd::string relativePath;
-
-        if (AzFramework::StringFunc::Path::GetFolderPath(assetInfo.m_relativePath.c_str(), relativePath))
-        {
-            AZStd::to_lower(relativePath.begin(), relativePath.end());
-
-            const AZStd::string root = "scriptcanvas/functions/";
-            if (relativePath.starts_with(root))
-            {
-                relativePath = relativePath.substr(root.size(), relativePath.size() - root.size());
-            }
-
-            category.append("/");
-            category.append(relativePath);
-        }
-
-        modelInformation->m_categoryPath = category;
-
-        AzFramework::StringFunc::Path::Normalize(absolutePath);
-        
-        AzFramework::StringFunc::Path::GetFileName(absolutePath.c_str(), modelInformation->m_displayName);
-        ////
-
-        m_registeredNodes.emplace(AZStd::make_pair(modelInformation->m_nodeIdentifier, modelInformation));
-        m_assetMapping.insert(AZStd::make_pair(assetId, modelInformation->m_nodeIdentifier));
-
-        AZStd::vector<ScriptCanvas::NodeTypeIdentifier> nodeTypeIdentifiers;
-        nodeTypeIdentifiers.push_back(modelInformation->m_nodeIdentifier);
-
-        return nodeTypeIdentifiers;
-    }
-
     void NodePaletteModel::RegisterCategoryInformation(const AZStd::string& category, const CategoryInformation& categoryInformation)
     {
         auto categoryIter = m_categoryInformation.find(category);
@@ -1559,24 +1502,6 @@ namespace ScriptCanvasEditor
                         AZ_TracePrintf("NodePaletteModel", "Could not refresh node palette properly, the asset failed to load correctly.");
                     }
                 }
-                else if (productEntry->GetAssetType() == azrtti_typeid<ScriptCanvasFunctionAsset>())
-                {
-                    const AZ::Data::AssetId& assetId = productEntry->GetAssetId();
-
-                    auto functionAsset = AZ::Data::AssetManager::Instance().GetAsset(assetId, azrtti_typeid<ScriptCanvasFunctionAsset>(), AZ::Data::AssetLoadBehavior::PreLoad);
-                    functionAsset.BlockUntilLoadComplete();
-
-                    if (functionAsset.IsReady())
-                    {
-                        ScriptCanvasFunctionAsset* data = functionAsset.GetAs<ScriptCanvasFunctionAsset>();
-
-                        return RegisterFunctionInformation(data);
-                    }
-                    else
-                    {
-                        AZ_TracePrintf("NodePaletteModel", "Could not refresh node palette properly, the asset failed to load correctly.");
-                    }
-                }
             }
         }
 

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/NodePaletteModel.h

@@ -22,7 +22,6 @@
 
 #include <Editor/View/Widgets/NodePalette/NodePaletteModelBus.h>
 
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
 #include <ScriptCanvas/Core/Core.h>
 
@@ -87,7 +86,6 @@ namespace ScriptCanvasEditor
 
         // Asset Based Registrations
         AZStd::vector<ScriptCanvas::NodeTypeIdentifier> RegisterScriptEvent(ScriptEvents::ScriptEventsAsset* scriptEventAsset);
-        AZStd::vector<ScriptCanvas::NodeTypeIdentifier> RegisterFunctionInformation(ScriptCanvasFunctionAsset* functionAsset);
 
         void RegisterCategoryInformation(const AZStd::string& category, const CategoryInformation& categoryInformation);
         const CategoryInformation* FindCategoryInformation(const AZStd::string& categoryStyle) const;

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/SpecializedNodePaletteTreeItemTypes.cpp

@@ -24,51 +24,9 @@
 #include "Editor/GraphCanvas/GraphCanvasEditorNotificationBusId.h"
 
 #include <Core/Attributes.h>
-#include <Libraries/Entity/EntityRef.h>
 
 namespace ScriptCanvasEditor
 {
-    /////////////////////////////////
-    // CreateEntityRefNodeMimeEvent
-    /////////////////////////////////
-
-    void CreateEntityRefNodeMimeEvent::Reflect(AZ::ReflectContext* reflectContext)
-    {
-        AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(reflectContext);
-
-        if (serializeContext)
-        {
-            serializeContext->Class<CreateEntityRefNodeMimeEvent, GraphCanvas::GraphCanvasMimeEvent>()
-                ->Version(0)
-                ->Field("EntityId", &CreateEntityRefNodeMimeEvent::m_entityId)
-                ;
-        }
-    }
-
-    CreateEntityRefNodeMimeEvent::CreateEntityRefNodeMimeEvent(const AZ::EntityId& entityId)
-        : m_entityId(entityId)
-    {
-    }
-
-    ScriptCanvasEditor::NodeIdPair CreateEntityRefNodeMimeEvent::CreateNode(const ScriptCanvas::ScriptCanvasId& scriptCanvasId) const
-    {
-        return Nodes::CreateEntityNode(m_entityId, scriptCanvasId);
-    }
-
-    /////////////////////////////////
-    // EntityRefNodePaletteTreeItem
-    /////////////////////////////////
-
-    EntityRefNodePaletteTreeItem::EntityRefNodePaletteTreeItem(AZStd::string_view nodeName, [[maybe_unused]] const QString& iconPath)
-        : DraggableNodePaletteTreeItem(nodeName, ScriptCanvasEditor::AssetEditorId)
-    {
-    }
-
-    GraphCanvas::GraphCanvasMimeEvent* EntityRefNodePaletteTreeItem::CreateMimeEvent() const
-    {
-        return aznew CreateEntityRefNodeMimeEvent();
-    }
-
     ///////////////////////////////
     // CreateCommentNodeMimeEvent
     ///////////////////////////////

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/SpecializedNodePaletteTreeItemTypes.h

@@ -11,39 +11,6 @@
 
 namespace ScriptCanvasEditor
 {
-    // <EntityRefNode>
-    class CreateEntityRefNodeMimeEvent
-        : public CreateNodeMimeEvent
-    {
-    public:
-        AZ_RTTI(CreateEntityRefNodeMimeEvent, "{20CD5AF5-216E-4A41-9630-191C2803899B}", CreateNodeMimeEvent);
-        AZ_CLASS_ALLOCATOR(CreateEntityRefNodeMimeEvent, AZ::SystemAllocator, 0);
-
-        static void Reflect(AZ::ReflectContext* reflectContext);
-
-        CreateEntityRefNodeMimeEvent() = default;
-        CreateEntityRefNodeMimeEvent(const AZ::EntityId& entityId);
-        ~CreateEntityRefNodeMimeEvent() = default;
-
-    protected:
-        ScriptCanvasEditor::NodeIdPair CreateNode(const ScriptCanvas::ScriptCanvasId& scriptCanvasId) const override;
-
-    private:
-        AZ::EntityId m_entityId;
-    };
-
-    class EntityRefNodePaletteTreeItem
-        : public GraphCanvas::DraggableNodePaletteTreeItem
-    {
-    public:
-        AZ_CLASS_ALLOCATOR(EntityRefNodePaletteTreeItem, AZ::SystemAllocator, 0);
-        EntityRefNodePaletteTreeItem(AZStd::string_view nodeName, const QString& iconPath);
-        ~EntityRefNodePaletteTreeItem() = default;
-
-        GraphCanvas::GraphCanvasMimeEvent* CreateMimeEvent() const override;
-    };
-    // </EntityRefNode>    
-    
     // <CommentNode>
     class CreateCommentNodeMimeEvent
         : public SpecializedCreateNodeMimeEvent

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/VariableNodePaletteTreeItemTypes.cpp

@@ -30,8 +30,6 @@
 #include "Editor/Include/ScriptCanvas/GraphCanvas/NodeDescriptorBus.h"
 
 #include <Core/Attributes.h>
-#include <Libraries/Core/Assign.h>
-#include <Libraries/Core/BehaviorContextObjectNode.h>
 #include <Libraries/Core/Method.h>
 
 #include <Editor/GraphCanvas/GraphCanvasEditorNotificationBusId.h>

Gems/ScriptCanvas/Code/Editor/View/Widgets/ScriptCanvasNodePaletteDockWidget.cpp

@@ -60,7 +60,6 @@
 #include <ScriptCanvas/Libraries/Core/GetVariable.h>
 #include <ScriptCanvas/Libraries/Core/Method.h>
 #include <ScriptCanvas/Libraries/Core/SetVariable.h>
-#include <ScriptCanvas/Libraries/Entity/EntityRef.h>
 #include <ScriptCanvas/Libraries/Libraries.h>
 #include <ScriptCanvas/Utils/NodeUtils.h>
 #include <ScriptEvents/ScriptEventsAsset.h>
@@ -224,7 +223,7 @@ namespace ScriptCanvasEditor
 
         void ScriptCanvasRootPaletteTreeItem::SetActiveScriptCanvasId(const ScriptCanvas::ScriptCanvasId& scriptCanvasId)
         {
-            ScriptCanvas::RuntimeRequestBus::EventResult(m_previousAssetId, scriptCanvasId, &ScriptCanvas::RuntimeRequests::GetAssetId);
+            ScriptCanvas::GraphRequestBus::EventResult(m_previousAssetId, scriptCanvasId, &ScriptCanvas::GraphRequests::GetAssetId);
 
             for (auto functionTreePair : m_globalFunctionTreeItems)
             {

Gems/ScriptCanvas/Code/Editor/View/Widgets/StatisticsDialog/ScriptCanvasStatisticsDialog.cpp

@@ -16,7 +16,6 @@
 #include <Editor/GraphCanvas/GraphCanvasEditorNotificationBusId.h>
 
 #include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
 #include <ScriptCanvas/Bus/RequestBus.h>
 
 namespace
@@ -181,8 +180,7 @@ namespace ScriptCanvasEditor
     {
         AZ::Data::AssetInfo assetInfo;
         AZ::Data::AssetCatalogRequestBus::BroadcastResult(assetInfo, &AZ::Data::AssetCatalogRequestBus::Events::GetAssetInfoById, assetId);
-        if (assetInfo.m_assetType == azrtti_typeid<ScriptCanvasAsset>()
-            || assetInfo.m_assetType == azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>())
+        if (assetInfo.m_assetType == azrtti_typeid<ScriptCanvasAsset>())
         {
             m_scriptCanvasAssetTreeRoot->RegisterAsset(assetId, assetInfo.m_assetType);
         }
@@ -197,8 +195,7 @@ namespace ScriptCanvasEditor
     {
         AZ::Data::AssetInfo assetInfo;
         AZ::Data::AssetCatalogRequestBus::BroadcastResult(assetInfo, &AZ::Data::AssetCatalogRequestBus::Events::GetAssetInfoById, assetId);
-        if (assetInfo.m_assetType == azrtti_typeid<ScriptCanvasAsset>()
-            || assetInfo.m_assetType == azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>())
+        if (assetInfo.m_assetType == azrtti_typeid<ScriptCanvasAsset>())
         {
             m_scriptCanvasAssetTreeRoot->RemoveAsset(assetId);
         }
@@ -440,8 +437,7 @@ namespace ScriptCanvasEditor
             {
                 const AzToolsFramework::AssetBrowser::ProductAssetBrowserEntry* productEntry = static_cast<const AzToolsFramework::AssetBrowser::ProductAssetBrowserEntry*>(entry);
 
-                if (productEntry->GetAssetType() == azrtti_typeid<ScriptCanvasAsset>()
-                    || productEntry->GetAssetType() == azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>())
+                if (productEntry->GetAssetType() == azrtti_typeid<ScriptCanvasAsset>())
                 {
                     const AZ::Data::AssetId& assetId = productEntry->GetAssetId();
 

Gems/ScriptCanvas/Code/Editor/View/Widgets/VariablePanel/GraphVariablesTableView.cpp

@@ -31,7 +31,6 @@
 #include <Editor/View/Widgets/ScriptCanvasNodePaletteDockWidget.h>
 #include <Editor/View/Widgets/NodePalette/VariableNodePaletteTreeItemTypes.h>
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
-#include <ScriptCanvas/Execution/RuntimeBus.h>
 #include <ScriptCanvas/Bus/RequestBus.h>
 #include <ScriptCanvas/Bus/EditorScriptCanvasBus.h>
 
@@ -722,7 +721,7 @@ namespace ScriptCanvasEditor
         ScriptCanvas::GraphVariableManagerNotificationBus::Handler::BusDisconnect();
 
         m_assetType = AZ::Data::AssetType::CreateNull();
-        ScriptCanvas::RuntimeRequestBus::EventResult(m_assetType, scriptCanvasId, &ScriptCanvas::RuntimeRequests::GetAssetType);
+        ScriptCanvas::GraphRequestBus::EventResult(m_assetType, scriptCanvasId, &ScriptCanvas::GraphRequests::GetAssetType);
 
         m_scriptCanvasId = scriptCanvasId;
 
@@ -1054,9 +1053,6 @@ namespace ScriptCanvasEditor
         AZ::SerializeContext* serializeContext = AZ::EntityUtils::GetApplicationSerializeContext();
         AZ::Utils::LoadObjectFromBufferInPlace(byteArray.constData(), static_cast<AZStd::size_t>(byteArray.size()), copiedVariableData, serializeContext);
 
-        bool isRuntimeGraph = false;
-        EditorGraphRequestBus::EventResult(isRuntimeGraph, scriptCanvasId, &EditorGraphRequests::IsRuntimeGraph);
-
         ScriptCanvas::GraphVariableManagerRequests* requests = ScriptCanvas::GraphVariableManagerRequestBus::FindFirstHandler(scriptCanvasId);
 
         if (requests == nullptr)

Gems/ScriptCanvas/Code/Editor/View/Widgets/VariablePanel/SlotTypeSelectorWidget.cpp

@@ -50,7 +50,6 @@
 
 #include <ScriptCanvas/Core/NodeBus.h>
 #include <ScriptCanvas/Data/DataRegistry.h>
-#include <ScriptCanvas/Execution/RuntimeBus.h>
 #include <ScriptCanvas/GraphCanvas/NodeDescriptorBus.h>
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
 

Gems/ScriptCanvas/Code/Editor/View/Widgets/VariablePanel/VariableDockWidget.cpp

@@ -50,7 +50,6 @@
 
 #include <ScriptCanvas/Core/NodeBus.h>
 #include <ScriptCanvas/Data/DataRegistry.h>
-#include <ScriptCanvas/Execution/RuntimeBus.h>
 #include <ScriptCanvas/GraphCanvas/NodeDescriptorBus.h>
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
 
@@ -757,9 +756,9 @@ namespace ScriptCanvasEditor
 
         AZStd::vector<AZ::EntityId> selection;
 
-        ScriptCanvas::RuntimeRequests* runtimeRequests = ScriptCanvas::RuntimeRequestBus::FindFirstHandler(m_scriptCanvasId);
+        auto owningGraph = ScriptCanvas::GraphRequestBus::FindFirstHandler(m_scriptCanvasId);
 
-        if (runtimeRequests == nullptr)
+        if (owningGraph == nullptr)
         {
             return;
         }
@@ -770,7 +769,7 @@ namespace ScriptCanvasEditor
 
             if (propertiesComponent)
             {
-                ScriptCanvas::GraphVariable* graphVariable = runtimeRequests->FindVariableById(varId);;
+                ScriptCanvas::GraphVariable* graphVariable = owningGraph->FindVariableById(varId);;
                 propertiesComponent->SetVariable(graphVariable);
 
                 selection.push_back(propertiesComponent->GetEntityId());

Gems/ScriptCanvas/Code/Editor/View/Windows/MainWindow.cpp

@@ -150,8 +150,6 @@
 
 #include <ScriptCanvas/Asset/AssetDescription.h>
 #include <ScriptCanvas/Components/EditorScriptCanvasComponent.h>
-#include <ScriptCanvas/Assets/Functions/ScriptCanvasFunctionAssetHandler.h>
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
 #include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
 
 #include <Editor/QtMetaTypes.h>
@@ -264,14 +262,7 @@ namespace ScriptCanvasEditor
 
                             if (editorRequests)
                             {
-                                if (editorRequests->IsFunctionGraph())
-                                {
-                                    assetSaveData.m_assetType = azrtti_typeid<ScriptCanvasFunctionAsset>();
-                                }
-                                else
-                                {
-                                    assetSaveData.m_assetType = azrtti_typeid<ScriptCanvasAsset>();
-                                }
+                                assetSaveData.m_assetType = azrtti_typeid<ScriptCanvasAsset>();
                             }
 
                             activeAssets.push_back(assetSaveData);
@@ -1303,8 +1294,7 @@ namespace ScriptCanvasEditor
             return AZ::Failure(AZStd::string("Unknown AssetId"));
         }
 
-        if (assetInfo.m_assetType != azrtti_typeid<ScriptCanvasAsset>() && 
-            assetInfo.m_assetType != azrtti_typeid<ScriptCanvasFunctionAsset>())
+        if (assetInfo.m_assetType != azrtti_typeid<ScriptCanvasAsset>())
         {
             return AZ::Failure(AZStd::string("Invalid AssetId provided, it's not a Script Canvas supported type"));
         }
@@ -3680,10 +3670,6 @@ namespace ScriptCanvasEditor
             {
                 buttonEnabled = false;
             }
-            else
-            {
-                EditorGraphRequestBus::EventResult(buttonEnabled, GetActiveScriptCanvasId(), &EditorGraphRequests::IsRuntimeGraph);
-            }
 
             m_assignToSelectedEntity->setEnabled(buttonEnabled);
         }

Gems/ScriptCanvas/Code/Editor/View/Windows/ScriptCanvasContextMenus.cpp

@@ -55,59 +55,6 @@
 
 namespace ScriptCanvasEditor
 {
-    //////////////////////////////
-    // AddSelectedEntitiesAction
-    //////////////////////////////
-
-    AddSelectedEntitiesAction::AddSelectedEntitiesAction(QObject* parent)
-        : GraphCanvas::ContextMenuAction("", parent)
-    {
-    }
-
-    GraphCanvas::ActionGroupId AddSelectedEntitiesAction::GetActionGroupId() const
-    {
-        return AZ_CRC("EntityActionGroup", 0x17e16dfe);
-    }
-
-    void AddSelectedEntitiesAction::RefreshAction(const GraphCanvas::GraphId&, const AZ::EntityId&)
-    {
-        AzToolsFramework::EntityIdList selectedEntities;
-        AzToolsFramework::ToolsApplicationRequests::Bus::BroadcastResult(selectedEntities, &AzToolsFramework::ToolsApplicationRequests::GetSelectedEntities);
-
-        setEnabled(!selectedEntities.empty());
-
-        if (selectedEntities.size() <= 1)
-        {
-            setText("Reference selected entity");
-        }
-        else
-        {
-            setText("Reference selected entities");
-        }
-    }
-
-    GraphCanvas::ContextMenuAction::SceneReaction AddSelectedEntitiesAction::TriggerAction(const AZ::EntityId& graphCanvasGraphId, const AZ::Vector2& scenePos)
-    {
-        AzToolsFramework::EntityIdList selectedEntities;
-        AzToolsFramework::ToolsApplicationRequests::Bus::BroadcastResult(selectedEntities, &AzToolsFramework::ToolsApplicationRequests::GetSelectedEntities);
-
-        ScriptCanvas::ScriptCanvasId scriptCanvasId;
-        GeneralRequestBus::BroadcastResult(scriptCanvasId, &GeneralRequests::GetScriptCanvasId, graphCanvasGraphId);
-
-        GraphCanvas::SceneRequestBus::Event(graphCanvasGraphId, &GraphCanvas::SceneRequests::ClearSelection);
-
-        AZ::Vector2 addPosition = scenePos;
-
-        for (const AZ::EntityId& id : selectedEntities)
-        {
-            NodeIdPair nodePair = Nodes::CreateEntityNode(id, scriptCanvasId);
-            GraphCanvas::SceneRequestBus::Event(graphCanvasGraphId, &GraphCanvas::SceneRequests::AddNode, nodePair.m_graphCanvasId, addPosition, false);
-            addPosition += AZ::Vector2(20, 20);
-        }
-
-        return GraphCanvas::ContextMenuAction::SceneReaction::PostUndo;
-    }
-
     ////////////////////////////
     // EndpointSelectionAction
     ////////////////////////////
@@ -860,12 +807,6 @@ namespace ScriptCanvasEditor
     {
         const bool inContextMenu = true;
         Widget::ScriptCanvasNodePaletteConfig paletteConfig(paletteModel, assetModel, inContextMenu);
-
-        m_addSelectedEntitiesAction = aznew AddSelectedEntitiesAction(this);
-        
-        AddActionGroup(m_addSelectedEntitiesAction->GetActionGroupId());
-        AddMenuAction(m_addSelectedEntitiesAction);
-
         AddNodePaletteMenuAction(paletteConfig);
     }
 
@@ -905,8 +846,6 @@ namespace ScriptCanvasEditor
         m_graphCanvasConstructGroups.SetCommentsEnabled(false);
         m_nodeGroupPresets.SetEnabled(false);
         m_alignmentActionsGroups.SetEnabled(false);
-
-        m_addSelectedEntitiesAction->setEnabled(false);
     }
 
     //////////////////////////

Gems/ScriptCanvas/Code/Editor/View/Windows/ScriptCanvasContextMenus.h

@@ -32,22 +32,6 @@ namespace ScriptCanvasEditor
     // CustomActions
     //////////////////
 
-    class AddSelectedEntitiesAction
-        : public GraphCanvas::ContextMenuAction
-    {
-        Q_OBJECT
-    public:
-        AZ_CLASS_ALLOCATOR(AddSelectedEntitiesAction, AZ::SystemAllocator, 0);
-
-        AddSelectedEntitiesAction(QObject* parent);
-        virtual ~AddSelectedEntitiesAction() = default;
-
-        GraphCanvas::ActionGroupId GetActionGroupId() const override;
-
-        void RefreshAction(const GraphCanvas::GraphId& graphCanvasGraphId, const AZ::EntityId& targetId) override;
-        SceneReaction TriggerAction(const GraphCanvas::GraphId& graphCanvasGraphId, const AZ::Vector2& scenePos) override;
-    };
-
     class EndpointSelectionAction
         : public QAction
     {
@@ -217,8 +201,6 @@ namespace ScriptCanvasEditor
     protected:
 
         AZ::EntityId                      m_sourceSlotId;
-
-        AddSelectedEntitiesAction* m_addSelectedEntitiesAction;
     };
 
     class ConnectionContextMenu

Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/UpgradeHelper.cpp

@@ -16,8 +16,6 @@
 
 #include "UpgradeHelper.h"
 
-#include <Asset/Functions/ScriptCanvasFunctionAsset.h>
-
 #include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/Component/TickBus.h>
 #include <AzCore/IO/SystemFile.h>

Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/UpgradeTool.cpp

@@ -12,8 +12,6 @@
 
 #include "UpgradeTool.h"
 
-#include <Asset/Functions/ScriptCanvasFunctionAsset.h>
-
 #include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/Component/TickBus.h>
 #include <AzCore/IO/SystemFile.h>
@@ -284,10 +282,6 @@ namespace ScriptCanvasEditor
                     {
                         tmpFilesaved = AZ::Utils::SaveObjectToStream<ScriptCanvas::ScriptCanvasData>(fileStream, AZ::DataStream::ST_XML, &asset.GetAs<ScriptCanvasAsset>()->GetScriptCanvasData());
                     }
-                    else if (asset.GetType() == azrtti_typeid<ScriptCanvasFunctionAsset>())
-                    {
-                        tmpFilesaved = AZ::Utils::SaveObjectToStream<ScriptCanvas::ScriptCanvasData>(fileStream, AZ::DataStream::ST_XML, &asset.GetAs<ScriptCanvasFunctionAsset>()->GetScriptCanvasData());
-                    }
 
                     fileStream.Close();
                 }
@@ -708,10 +702,6 @@ namespace ScriptCanvasEditor
         {
             scriptCanvasEntity = UpgradeGraph<ScriptCanvasAsset>(asset, this);
         }
-        else if (asset.GetType() == azrtti_typeid<ScriptCanvasFunctionAsset>())
-        {
-            scriptCanvasEntity = UpgradeGraph<ScriptCanvasFunctionAsset>(asset, this);
-        }
 
         if (!scriptCanvasEntity)
         {

Gems/ScriptCanvas/Code/Editor/View/Windows/Tools/UpgradeTool/VersionExplorer.cpp

@@ -16,8 +16,6 @@
 
 #include "VersionExplorer.h"
 
-#include <Asset/Functions/ScriptCanvasFunctionAsset.h>
-
 #include <AzCore/Asset/AssetManagerBus.h>
 #include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/Component/TickBus.h>
@@ -323,10 +321,6 @@ namespace ScriptCanvasEditor
         {
             m_scriptCanvasEntity = UpgradeGraphProcess<ScriptCanvasAsset>(asset, this);
         }
-        else if (asset.GetType() == azrtti_typeid<ScriptCanvasFunctionAsset>())
-        {
-            m_scriptCanvasEntity = UpgradeGraphProcess<ScriptCanvasFunctionAsset>(asset, this);
-        }
 
         if (!m_scriptCanvasEntity)
         {
@@ -358,10 +352,6 @@ namespace ScriptCanvasEditor
                 {
                     tmpFilesaved = AZ::Utils::SaveObjectToStream<ScriptCanvas::ScriptCanvasData>(fileStream, AZ::DataStream::ST_XML, &asset.GetAs<ScriptCanvasAsset>()->GetScriptCanvasData());
                 }
-                else if (asset.GetType() == azrtti_typeid<ScriptCanvasFunctionAsset>())
-                {
-                    tmpFilesaved = AZ::Utils::SaveObjectToStream<ScriptCanvas::ScriptCanvasData>(fileStream, AZ::DataStream::ST_XML, &asset.GetAs<ScriptCanvasFunctionAsset>()->GetScriptCanvasData());
-                }
 
                 fileStream.Close();
             }
@@ -647,17 +637,6 @@ namespace ScriptCanvasEditor
             scriptCanvasEntity = scriptCanvasAsset->GetScriptCanvasEntity();
             AZ_Assert(scriptCanvasEntity, "The Script Canvas asset must have a valid entity");
         }
-        else if (asset.GetType() == azrtti_typeid<ScriptCanvasFunctionAsset>())
-        {
-            ScriptCanvasFunctionAsset* scriptCanvasAsset = asset.GetAs<ScriptCanvasFunctionAsset>();
-            if (!scriptCanvasAsset)
-            {
-                return;
-            }
-
-            scriptCanvasEntity = scriptCanvasAsset->GetScriptCanvasEntity();
-            AZ_Assert(scriptCanvasEntity, "The Script Canvas asset must have a valid entity");
-        }
 
         auto graphComponent = scriptCanvasEntity->FindComponent<ScriptCanvasEditor::Graph>();
         AZ_Assert(graphComponent, "The Script Canvas entity must have a Graph component");

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h

@@ -1,145 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <AzCore/Asset/AssetCommon.h>
-#include <ScriptCanvas/Asset/AssetDescription.h>
-#include <ScriptCanvas/Asset/ScriptCanvasAssetBase.h>
-
-#include <AzCore/std/containers/vector.h>
-
-namespace AZ
-{
-    class Entity;
-}
-
-namespace ScriptCanvasEditor
-{
-    class ScriptCanvasFunctionAsset;
-    class Graph;
-
-    class ScriptCanvasFunctionDescription : public ScriptCanvas::AssetDescription
-    {
-    public:
-
-        AZ_TYPE_INFO(ScriptCanvasFunctionDescription, "{B53569F6-8408-40FC-9A72-ED873BEF162E}");
-
-        ScriptCanvasFunctionDescription()
-            : AssetDescription(
-                azrtti_typeid<ScriptCanvasEditor::ScriptCanvasFunctionAsset>(),
-                "Script Canvas Function",
-                "Script Canvas Function Graph Asset",
-                "@devassets@/scriptcanvas/functions",
-                ".scriptcanvas_fn",
-                "Script Canvas Function",
-                "Untitled-Function-%i",
-                "Script Canvas Function Files (*.scriptcanvas_fn)",
-                "Script Canvas Function",
-                "Script Canvas Function",
-                "Icons/ScriptCanvas/Viewport/ScriptCanvas_Function.png",
-                AZ::Color(0.192f, 0.149f, 0.392f, 1.0f),
-                true
-                )
-        {}
-    };
-
-    // TODO-LS: move these to their own file
-    class ScriptCanvasDataRequests : public AZ::ComponentBus
-    {
-    public:
-
-        virtual void SetPrettyName(const char* name) = 0;
-        virtual AZStd::string GetPrettyName() = 0;
-    };
-
-    using ScriptCanvasDataRequestBus = AZ::EBus<ScriptCanvasDataRequests>;
-
-
-    class ScriptCanvasFunctionDataComponent
-        : public AZ::Component
-        , ScriptCanvasDataRequestBus::MultiHandler
-    {
-    public:
-        AZ_COMPONENT(ScriptCanvasFunctionDataComponent, "{440BB6DC-4E70-4304-A926-252925F77433}");
-
-        void Activate() override
-        {
-            AZ::EntityId entityId = GetEntityId();
-            ScriptCanvasDataRequestBus::MultiHandler::BusConnect(entityId);
-        }
-
-        void Deactivate() override
-        {
-            ScriptCanvasDataRequestBus::MultiHandler::BusDisconnect();
-
-            AZ::EntityId entityId = GetEntityId();
-        }
-
-        void SetPrettyName(const char* name) override
-        {
-            m_assetPrettyName = name;
-        }
-
-        AZStd::string GetPrettyName() override
-        {
-            return m_assetPrettyName;
-        }
-
-        static void Reflect(AZ::ReflectContext* reflectContext)
-        {
-            if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(reflectContext))
-            {
-                serializeContext->Class<ScriptCanvasFunctionDataComponent, AZ::Component>()
-                    ->Version(2)
-                    ->Field("m_assetPrettyName", &ScriptCanvasFunctionDataComponent::m_assetPrettyName)
-                    ->Field("m_version", &ScriptCanvasFunctionDataComponent::m_functionDataComponentVersion)
-                    ;
-            }
-        }
-
-        size_t m_functionDataComponentVersion = 0;
-        AZStd::string m_assetPrettyName;
-    };
-
-    class ScriptCanvasFunctionAsset
-        : public ScriptCanvas::ScriptCanvasAssetBase
-    {
-    public:
-        AZ_RTTI(ScriptCanvasFunctionAsset, "{ED078D3C-938D-41F8-A5F6-CC04311ECF4F}", ScriptCanvasAssetBase);
-        AZ_CLASS_ALLOCATOR(ScriptCanvasFunctionAsset, AZ::SystemAllocator, 0);
-
-        ScriptCanvasFunctionAsset(const AZ::Data::AssetId& assetId = AZ::Data::AssetId(AZ::Uuid::CreateRandom()), AZ::Data::AssetData::AssetStatus status = AZ::Data::AssetData::AssetStatus::NotLoaded)
-            : ScriptCanvasAssetBase(assetId, status)
-        {
-            m_data = aznew ScriptCanvas::ScriptCanvasData();
-        }
-
-        ~ScriptCanvasFunctionAsset() override
-        {}
-
-        ScriptCanvas::AssetDescription GetAssetDescription() const override
-        {
-            return ScriptCanvasFunctionDescription();
-        }
-
-        using Description = ScriptCanvasFunctionDescription;
-
-        ScriptCanvasFunctionDataComponent* m_cachedComponent = nullptr;
-
-        ScriptCanvasFunctionDataComponent* GetFunctionData()
-        {
-            if (m_cachedComponent == nullptr)
-            {
-                m_cachedComponent = GetScriptCanvasEntity()->FindComponent<ScriptCanvasFunctionDataComponent>();
-            }
-
-            return m_cachedComponent;
-        }
-    };
-
-}

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.cpp

@@ -7,7 +7,6 @@
 
 #include <ScriptCanvas/Core/Graph.h>
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
-#include <ScriptCanvas/Asset/Functions/RuntimeFunctionAssetHandler.h>
 #include <ScriptCanvas/Execution/RuntimeComponent.h>
 
 #include <ScriptCanvas/Core/ScriptCanvasBus.h>
@@ -19,6 +18,7 @@
 #include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/Component/Entity.h>
 
+#include <ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.h>
 
 namespace ScriptCanvas
 {

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Connection.cpp

@@ -168,7 +168,12 @@ namespace ScriptCanvas
     {
         if (nodeId == m_sourceEndpoint.GetNodeId() || nodeId == m_targetEndpoint.GetNodeId())
         {
-            GraphRequestBus::Event(*GraphNotificationBus::GetCurrentBusId(), &GraphRequests::DisconnectById, GetEntityId());
+            Slot* sourceSlot{};
+            NodeRequestBus::EventResult(sourceSlot, m_sourceEndpoint.GetNodeId(), &NodeRequests::GetSlot, m_sourceEndpoint.GetSlotId());
+            if (sourceSlot)
+            {
+                GraphRequestBus::Event(sourceSlot->GetNode()->GetOwningScriptCanvasId(), &GraphRequests::DisconnectById, GetEntityId());
+            }
         }
     }
 }

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Connection.h

@@ -60,8 +60,6 @@ namespace ScriptCanvas
         // GraphNotificationBus
         void OnNodeRemoved(const ID& nodeId) override;
 
-        void UpdateConnectionStatus(NodeUpdateSlotReport& report);
-
     protected:
         //-------------------------------------------------------------------------
         static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Contracts.h

@@ -11,7 +11,6 @@
 #include "Contracts/DisallowReentrantExecutionContract.h"
 #include "Contracts/DisplayGroupConnectedSlotLimitContract.h"
 #include "Contracts/DynamicTypeContract.h"
-#include "Contracts/ExclusivePureDataContract.h"
 #include "Contracts/IsReferenceTypeContract.h"
 #include "Contracts/MathOperatorContract.h"
 #include "Contracts/MethodOverloadContract.h"

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Contracts/ExclusivePureDataContract.cpp

@@ -1,56 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "ExclusivePureDataContract.h"
-#include <ScriptCanvas/Core/ContractBus.h>
-#include <ScriptCanvas/Core/GraphBus.h>
-#include <ScriptCanvas/Core/NodeBus.h>
-#include <ScriptCanvas/Core/Endpoint.h>
-#include <ScriptCanvas/Core/Slot.h>
-
-namespace ScriptCanvas
-{
-    AZ::Outcome<void, AZStd::string> ExclusivePureDataContract::HasNoPureDataConnection(const Slot& dataInputSlot) const
-    {
-        bool isOnPureDataThread(true);
-        NodeRequestBus::EventResult(isOnPureDataThread, dataInputSlot.GetNodeId(), &NodeRequests::IsOnPureDataThread, dataInputSlot.GetId());
-
-        if (!isOnPureDataThread)
-        {
-            return AZ::Success();
-        }
-        
-        return AZ::Failure(AZStd::string("There is already a pure data input into this slot"));
-    }
-
-    AZ::Outcome<void, AZStd::string> ExclusivePureDataContract::OnEvaluate(const Slot& sourceSlot, const Slot& targetSlot) const
-    {
-        if (sourceSlot.GetDescriptor().CanConnectTo(targetSlot.GetDescriptor()))
-        {
-            if (sourceSlot.GetDescriptor().IsInput())
-            {
-                return HasNoPureDataConnection(sourceSlot);
-            }
-            else if (targetSlot.GetDescriptor().IsInput())
-            {
-                return HasNoPureDataConnection(targetSlot);
-            }
-        }
-
-        return AZ::Failure(AZStd::string("invalid data connection attempted"));
-    }
-
-    void ExclusivePureDataContract::Reflect(AZ::ReflectContext* reflection)
-    {
-        if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(reflection))
-        {
-            serializeContext->Class<ExclusivePureDataContract, Contract>()
-                ->Version(0)
-                ;
-        }
-    }
-}

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Contracts/ExclusivePureDataContract.h

@@ -1,30 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <ScriptCanvas/Core/Contract.h>
-
-namespace ScriptCanvas
-{
-    class ExclusivePureDataContract
-        : public Contract
-    {
-    public:
-        AZ_CLASS_ALLOCATOR(ExclusivePureDataContract, AZ::SystemAllocator, 0);
-        AZ_RTTI(ExclusivePureDataContract, "{E48A0B26-B6B7-4AF3-9341-9E5C5C1F0DE8}", Contract);
-
-        // no multiple literals, variables, defaults, gets, or any other new form of data that can be routed without getting pushed by execution
-        ~ExclusivePureDataContract() override = default;
-
-        static void Reflect(AZ::ReflectContext* reflection);
-
-    protected:
-        AZ::Outcome<void, AZStd::string> OnEvaluate(const Slot& sourceSlot, const Slot& targetSlot) const override;
-
-        AZ::Outcome<void, AZStd::string> HasNoPureDataConnection(const Slot& dataInputSlot) const;
-    };
-}

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Graph.cpp

@@ -12,40 +12,32 @@
 #include <AzCore/Serialization/IdUtils.h>
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/Serialization/Utils.h>
-
 #include <AzFramework/Entity/EntityContextBus.h>
-
-#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
-
 #include <ScriptCanvas/Core/Connection.h>
 #include <ScriptCanvas/Core/Core.h>
 #include <ScriptCanvas/Core/Datum.h>
 #include <ScriptCanvas/Core/Graph.h>
 #include <ScriptCanvas/Core/Node.h>
-#include <ScriptCanvas/Core/PureData.h>
 #include <ScriptCanvas/Data/BehaviorContextObject.h>
-#include <ScriptCanvas/Grammar/AbstractCodeModel.h>
-
-#include <ScriptCanvas/Debugger/ValidationEvents/DataValidation/DataValidationIds.h>
+#include <ScriptCanvas/Data/PropertyTraits.h>
+#include <ScriptCanvas/Debugger/StatusBus.h>
 #include <ScriptCanvas/Debugger/ValidationEvents/DataValidation/DataValidationEvents.h>
-#include <ScriptCanvas/Debugger/ValidationEvents/ExecutionValidation/ExecutionValidationIds.h>
+#include <ScriptCanvas/Debugger/ValidationEvents/DataValidation/DataValidationIds.h>
 #include <ScriptCanvas/Debugger/ValidationEvents/ExecutionValidation/ExecutionValidationEvents.h>
-
-#include <ScriptCanvas/Libraries/Core/UnaryOperator.h>
+#include <ScriptCanvas/Debugger/ValidationEvents/ExecutionValidation/ExecutionValidationIds.h>
+#include <ScriptCanvas/Grammar/AbstractCodeModel.h>
 #include <ScriptCanvas/Libraries/Core/BinaryOperator.h>
 #include <ScriptCanvas/Libraries/Core/EBusEventHandler.h>
-#include <ScriptCanvas/Libraries/Core/ErrorHandler.h>
 #include <ScriptCanvas/Libraries/Core/FunctionDefinitionNode.h>
 #include <ScriptCanvas/Libraries/Core/Method.h>
-#include <ScriptCanvas/Libraries/Core/Start.h>
-#include <ScriptCanvas/Libraries/Core/SendScriptEvent.h>
 #include <ScriptCanvas/Libraries/Core/ReceiveScriptEvent.h>
 #include <ScriptCanvas/Libraries/Core/ScriptEventBase.h>
-
+#include <ScriptCanvas/Libraries/Core/SendScriptEvent.h>
+#include <ScriptCanvas/Libraries/Core/Start.h>
+#include <ScriptCanvas/Libraries/Core/UnaryOperator.h>
 #include <ScriptCanvas/Profiler/Driller.h>
 #include <ScriptCanvas/Translation/Translation.h>
-#include <ScriptCanvas/Debugger/StatusBus.h>
 #include <ScriptCanvas/Variable/VariableBus.h>
 #include <ScriptCanvas/Variable/VariableData.h>
 
@@ -58,6 +50,7 @@ namespace GraphCpp
         MergeScriptAssetDescriptions,
         VariablePanelSymantics,
         AddVersionData,
+        RemoveFunctionGraphMarker,
         // label your version above
         Current
     };
@@ -77,6 +70,11 @@ namespace ScriptCanvas
             componentElementNode.AddElementWithData(context, "m_assetType", azrtti_typeid<RuntimeAsset>());
         }
 
+        if (componentElementNode.GetVersion() < GraphCpp::GraphVersion::RemoveFunctionGraphMarker)
+        {
+            componentElementNode.RemoveElementByName(AZ_CRC_CE("isFunctionGraph"));
+        }
+
         return true;
     }
 
@@ -107,18 +105,15 @@ namespace ScriptCanvas
         Nodes::ComparisonExpression::Reflect(context);
         Datum::Reflect(context);
         BehaviorContextObjectPtrReflect(context);
-
         GraphData::Reflect(context);
 
-        AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
-        if (serializeContext)
+        if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
         {
             serializeContext->Class<Graph, AZ::Component>()
                 ->Version(GraphCpp::GraphVersion::Current, &GraphComponentVersionConverter)
                 ->Field("m_graphData", &Graph::m_graphData)
                 ->Field("executionMode", &Graph::m_executionMode)
                 ->Field("m_assetType", &Graph::m_assetType)
-                ->Field("isFunctionGraph", &Graph::m_isFunctionGraph)
                 ->Field("versionData", &Graph::m_versionData)
                 ;
         }
@@ -128,8 +123,6 @@ namespace ScriptCanvas
     {
         const auto& scriptCanvasId = GetScriptCanvasId();
         GraphRequestBus::Handler::BusConnect(scriptCanvasId);
-        RuntimeRequestBus::Handler::BusConnect(scriptCanvasId);
-
         ValidationRequestBus::Handler::BusConnect(scriptCanvasId);
 
         for (auto& nodeEntity : m_graphData.m_nodes)
@@ -148,6 +141,7 @@ namespace ScriptCanvas
         }
 
         m_graphData.BuildEndpointMap();
+
         for (auto& connectionEntity : m_graphData.m_connections)
         {
             if (connectionEntity)
@@ -159,21 +153,6 @@ namespace ScriptCanvas
         StatusRequestBus::Handler::BusConnect(scriptCanvasId);
     }
 
-    bool Graph::IsFunctionGraph() const
-    {
-        if (m_isFunctionGraph)
-        {
-            return true;
-        }
-
-        return false;
-    }
-
-    void Graph::MarkFunctionGraph()
-    {
-        m_isFunctionGraph = true;
-    }
-
     void Graph::MarkVersion()
     {
         m_versionData.MarkLatest();

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Graph.h

@@ -19,7 +19,6 @@
 #include <ScriptCanvas/Debugger/Bus.h>
 #include <ScriptCanvas/Execution/ErrorBus.h>
 #include <ScriptCanvas/Execution/ExecutionContext.h>
-#include <ScriptCanvas/Execution/RuntimeBus.h>
 #include <ScriptCanvas/Debugger/StatusBus.h>
 
 #include <ScriptCanvas/Debugger/ValidationEvents/ValidationEvent.h>
@@ -35,7 +34,6 @@ namespace ScriptCanvas
     class Graph
         : public AZ::Component
         , protected GraphRequestBus::Handler
-        , protected RuntimeRequestBus::Handler
         , protected StatusRequestBus::Handler
         , private AZ::EntityBus::Handler
         , private ValidationRequestBus::Handler
@@ -112,9 +110,6 @@ namespace ScriptCanvas
 
         Graph* GetGraph() { return this; }
 
-        bool IsFunctionGraph() const;
-        void MarkFunctionGraph();
-
         GraphData* GetGraphData() override { return &m_graphData; }
         const GraphData* GetGraphDataConst() const override { return &m_graphData; }
         const VariableData* GetVariableDataConst() const { return const_cast<Graph*>(this)->GetVariableData(); }
@@ -174,14 +169,12 @@ namespace ScriptCanvas
 
         void RefreshConnectionValidity(bool warnOnRemoval = false);
 
-        //// RuntimeRequestBus::Handler
         AZ::Data::AssetId GetAssetId() const override { return AZ::Data::AssetId(); }
         GraphIdentifier GetGraphIdentifier() const override { return GraphIdentifier(GetAssetId(), 0); }
         AZStd::string GetAssetName() const override { return "";  }
         AZ::EntityId GetRuntimeEntityId() const override { return GetEntity() ? GetEntityId() : AZ::EntityId(); }
 
         VariableId FindAssetVariableIdByRuntimeVariableId(VariableId runtimeId) const override { return runtimeId; }
-        VariableId FindRuntimeVariableIdByAssetVariableId(VariableId assetId) const override { return assetId; }
         AZ::EntityId FindAssetNodeIdByRuntimeNodeId(AZ::EntityId editorNode) const override { return editorNode; }
         AZ::EntityId FindRuntimeNodeIdByAssetNodeId(AZ::EntityId runtimeNode) const override { return runtimeNode; }
         
@@ -190,8 +183,8 @@ namespace ScriptCanvas
         const GraphVariableMapping* GetVariables() const override;
         GraphVariable* FindVariable(AZStd::string_view propName) override;
         GraphVariable* FindVariableById(const VariableId& variableId) override;
-        Data::Type GetVariableType(const VariableId& variableId) const override;
-        AZStd::string_view GetVariableName(const VariableId& variableId) const override;
+        Data::Type GetVariableType(const VariableId& variableId) const;
+        AZStd::string_view GetVariableName(const VariableId& variableId) const;
 
         bool IsGraphObserved() const override;
         void SetIsGraphObserved(bool isObserved) override;
@@ -208,7 +201,6 @@ namespace ScriptCanvas
         AZ::Data::AssetType m_assetType;
 
     private:
-        bool m_isFunctionGraph = false;
         ScriptCanvasId m_scriptCanvasId;
         ExecutionMode m_executionMode = ExecutionMode::Interpreted;
         VersionData m_versionData;

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/GraphBus.h

@@ -11,6 +11,7 @@
 #include "Endpoint.h"
 
 #include <ScriptCanvas/Variable/VariableCore.h>
+#include <ScriptCanvas/Variable/GraphVariable.h>
 
 #include <AzCore/EBus/EBus.h>
 #include <AzCore/std/containers/vector.h>
@@ -23,6 +24,8 @@ namespace ScriptCanvas
     class Graph;
     class Slot;
 
+    using EndpointMapConstIterator = AZStd::unordered_multimap<Endpoint, Endpoint>::const_iterator;
+
     //! These are public graph requests
     class GraphRequests : public AZ::EBusTraits
     {
@@ -51,7 +54,7 @@ namespace ScriptCanvas
         virtual bool FindConnection(AZ::Entity*& connectionEntity, const Endpoint& firstEndpoint, const Endpoint& otherEndpoint) const = 0;
 
         virtual Slot* FindSlot(const Endpoint& endpoint) const = 0;
-        
+
         //! Retrieves the Entity this Graph component is located on
         //! NOTE: There can be multiple Graph components on the same entity so calling FindComponent may not not return this GraphComponent
         virtual AZ::Entity* GetGraphEntity() const = 0;
@@ -59,7 +62,7 @@ namespace ScriptCanvas
         //! Retrieves the Graph Component directly using the BusId
         virtual Graph* GetGraph() = 0;
 
-        virtual bool Connect(const AZ::EntityId& sourceNodeId, const SlotId& sourceSlot, const AZ::EntityId& targetNodeId,const SlotId& targetSlot) = 0;
+        virtual bool Connect(const AZ::EntityId& sourceNodeId, const SlotId& sourceSlot, const AZ::EntityId& targetNodeId, const SlotId& targetSlot) = 0;
         virtual bool Disconnect(const AZ::EntityId& sourceNodeId, const SlotId& sourceSlot, const AZ::EntityId& targetNodeId, const SlotId& targetSlot) = 0;
 
         virtual bool ConnectByEndpoint(const Endpoint& sourceEndpoint, const Endpoint& targetEndpoint) = 0;
@@ -88,7 +91,7 @@ namespace ScriptCanvas
         virtual bool AddItem(AZ::Entity* itemEntity) = 0;
         //! Remove item if it is on the graph
         virtual bool RemoveItem(AZ::Entity* itemEntity) = 0;
-        
+
         //! Retrieves a pointer the GraphData structure stored on the graph
         virtual GraphData* GetGraphData() = 0;
         virtual const GraphData* GetGraphDataConst() const = 0;
@@ -104,8 +107,49 @@ namespace ScriptCanvas
 
         virtual void SetIsGraphObserved(bool observed) = 0;
         virtual bool IsGraphObserved() const = 0;
-    };
 
+        virtual VariableId FindAssetVariableIdByRuntimeVariableId(VariableId runtimeId) const = 0;
+
+        virtual AZ::EntityId FindAssetNodeIdByRuntimeNodeId(AZ::EntityId editorNode) const = 0;
+
+        virtual AZ::Data::AssetId GetAssetId() const = 0;
+
+        virtual GraphIdentifier GetGraphIdentifier() const = 0;
+
+        virtual AZStd::string GetAssetName() const = 0;
+
+        //! Looks up the nodeId within the bus handler
+        virtual Node* FindNode(AZ::EntityId nodeId) const = 0;
+
+        virtual AZ::EntityId FindRuntimeNodeIdByAssetNodeId(AZ::EntityId runtimeNode) const = 0;
+
+        //! Returns the entity id of the execution component
+        virtual AZ::EntityId GetRuntimeEntityId() const = 0;
+
+        virtual AZStd::pair< EndpointMapConstIterator, EndpointMapConstIterator > GetConnectedEndpointIterators(const Endpoint& endpoint) const = 0;
+
+        //! Returns whether the given endpoint has any connections
+        virtual bool IsEndpointConnected(const Endpoint& endpoint) const = 0;
+
+        //! Retrieves VariableData structure which manages variable data for the execution component
+        virtual VariableData* GetVariableData() = 0;
+        virtual const VariableData* GetVariableDataConst() const = 0;
+
+        //! Retrieves a map of variable id to variable name and variable datums pair
+        virtual const GraphVariableMapping* GetVariables() const = 0;
+
+        //! Searches for a variable with the specified name
+        //! returns pointer to the first variable with the specified name or nullptr
+        virtual GraphVariable* FindVariable(AZStd::string_view varName) = 0;
+
+        //! Searches for a variable by VariableId
+        //! returns a pair of <variable datum pointer, variable name> with the supplied id
+        //! The variable datum pointer is non-null if the variable has been found
+        virtual GraphVariable* FindVariableById(const VariableId& variableId) = 0;
+
+        virtual AZ::Data::AssetType GetAssetType() const = 0;
+
+    };
     using GraphRequestBus = AZ::EBus<GraphRequests>;
 
     class GraphNotifications : public AZ::EBusTraits

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/ModifiableDatumView.h

@@ -29,8 +29,7 @@ namespace ScriptCanvas
 
         friend class Node;
         friend class GraphVariable;
-        friend class PureData;
-
+        
     public:
         AZ_CLASS_ALLOCATOR(ModifiableDatumView, AZ::SystemAllocator, 0);
 

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/NativeDatumNode.h

@@ -1,133 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <Data/Data.h>
-#include <ScriptCanvas/Core/Node.h>
-#include <ScriptCanvas/Core/PureData.h>
-#include <AzCore/std/typetraits/function_traits.h>
-
-namespace ScriptCanvas
-{
-    namespace Nodes
-    {
-        template<typename t_Node, typename t_Datum>
-        class NativeDatumNode
-            : public PureData
-        {
-        public:
-            using t_ThisType = NativeDatumNode<t_Node, t_Datum>;
-
-            AZ_RTTI(((NativeDatumNode<t_Node, t_Datum>), "{B7D8D8D6-B2F1-481A-A712-B07D1C19555F}", t_Node, t_Datum), PureData, AZ::Component);
-            AZ_COMPONENT_INTRUSIVE_DESCRIPTOR_TYPE(NativeDatumNode);
-            AZ_COMPONENT_BASE(NativeDatumNode, PureData);
-
-            static void Reflect(AZ::ReflectContext* reflection) 
-            {
-                if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(reflection))
-                {
-                    serializeContext->Class<t_ThisType, PureData>()
-                        ->Version(0)
-                        ;
-
-                    if (AZ::EditContext* editContext = serializeContext->GetEditContext())
-                    {
-                        editContext->Class<t_ThisType>("NativeDatumNode", "")
-                            ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
-                            ;
-                    }
-                }
-            }
-
-            ~NativeDatumNode() override = default;
-
-        protected:
-            virtual void ConfigureSetters()
-            {
-                Data::SetterContainer setterWrappers = Data::ExplodeToSetters(Data::FromAZType(Data::Traits<t_Datum>::GetAZType()));
-                for (const auto& setterWrapperPair : setterWrappers)
-                {
-                    SlotId setterSlotId;
-                    const Data::SetterWrapper& setterWrapper = setterWrapperPair.second;
-                    const AZStd::string argName = AZStd::string::format("%s: %s", Data::GetName(setterWrapper.m_propertyType).data(), setterWrapper.m_propertyName.data());
-                    AZStd::string_view argumentTooltip;
-                    // Add the slot if it doesn't exist
-                    setterSlotId = FindSlotIdForDescriptor(argName, SlotDescriptors::DataIn());
-
-                    if (!setterSlotId.IsValid())
-                    {
-                        DataSlotConfiguration slotConfiguration;
-
-                        slotConfiguration.m_name = argName;
-                        slotConfiguration.m_toolTip = argumentTooltip;
-                        slotConfiguration.SetType(setterWrapper.m_propertyType);
-                        slotConfiguration.SetConnectionType(ConnectionType::Input);
-
-                        setterSlotId = AddSlot(slotConfiguration);
-                    }
-
-                    if (setterSlotId.IsValid())
-                    {
-                        m_propertyAccount.m_getterSetterIdPairs[setterWrapperPair.first].second = setterSlotId;
-                        m_propertyAccount.m_settersByInputSlot.emplace(setterSlotId, setterWrapperPair.second);
-                    }
-                }
-            }
-
-            virtual void ConfigureGetters()
-            {
-                Data::GetterContainer getterWrappers = Data::ExplodeToGetters(Data::FromAZType(Data::Traits<t_Datum>::GetAZType()));
-                for (const auto& getterWrapperPair : getterWrappers)
-                {
-                    SlotId getterSlotId;
-
-                    const Data::GetterWrapper& getterWrapper = getterWrapperPair.second;
-                    const AZStd::string resultSlotName(AZStd::string::format("%s: %s", getterWrapper.m_propertyName.data(), Data::GetName(getterWrapper.m_propertyType).data()));
-                    // Add the slot if it doesn't exist
-
-                    getterSlotId = FindSlotIdForDescriptor(resultSlotName, SlotDescriptors::DataOut());
-
-                    if (!getterSlotId.IsValid())
-                    {
-                        DataSlotConfiguration slotConfiguration;
-
-                        slotConfiguration.m_name = resultSlotName;
-                        slotConfiguration.SetType(getterWrapper.m_propertyType);
-                        slotConfiguration.SetConnectionType(ConnectionType::Output);                        
-
-                        getterSlotId = AddSlot(slotConfiguration);
-                    }
-
-                    if (getterSlotId.IsValid())
-                    {
-                        m_propertyAccount.m_getterSetterIdPairs[getterWrapperPair.first].first = getterSlotId;
-                        m_propertyAccount.m_gettersByInputSlot.emplace(getterSlotId, getterWrapperPair.second);
-                    }
-                }
-            }
-
-            virtual void ConfigureProperties()
-            {
-                if (IsConfigured())
-                {
-                    return;
-                }
-
-                ConfigureGetters();
-                ConfigureSetters();
-                m_configured = true;
-            }
-
-            void OnInit() override
-            {
-                AddInputAndOutputTypeSlot(Data::FromAZType<t_Datum>());
-                ConfigureProperties();
-            }
-        };
-    }
-}

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Node.cpp

@@ -19,11 +19,9 @@
 #include <ScriptCanvas/Core/Attributes.h>
 #include <ScriptCanvas/Core/Contract.h>
 #include <ScriptCanvas/Core/Contracts/ConnectionLimitContract.h>
-#include <ScriptCanvas/Core/Contracts/ExclusivePureDataContract.h>
 #include <ScriptCanvas/Core/Contracts/DynamicTypeContract.h>
 #include <ScriptCanvas/Core/GraphBus.h>
 #include <ScriptCanvas/Core/NodeableNode.h>
-#include <ScriptCanvas/Core/PureData.h>
 #include <ScriptCanvas/Data/DataRegistry.h>
 #include <ScriptCanvas/Libraries/Core/EBusEventHandler.h>
 #include <ScriptCanvas/Variable/VariableBus.h>
@@ -48,9 +46,7 @@ namespace NodeCpp
 
         // add your named version above
         Current,
-    };
-    
-
+    }; 
 }
 
 namespace ScriptCanvas
@@ -397,7 +393,6 @@ namespace ScriptCanvas
     void Node::Reflect(AZ::ReflectContext* context)
     {
         Slot::Reflect(context);
-        ExclusivePureDataContract::Reflect(context);
         Nodes::NodeableNode::Reflect(context);
 
         // Version Conversion Reflection
@@ -492,23 +487,16 @@ namespace ScriptCanvas
 
     void Node::Activate()
     {
-        SignalBus::Handler::BusConnect(GetEntityId());
-
-        SetRuntimeBus(RuntimeRequestBus::FindFirstHandler(m_scriptCanvasId));
-        AZ_Assert(m_runtimeBus, "Invalid m_executionUniqueId given for RuntimeRequestBus");
-
+        m_graphRequestBus = GraphRequestBus::FindFirstHandler(m_scriptCanvasId);
+        AZ_Assert(m_graphRequestBus, "Invalid m_executionUniqueId given for RuntimeRequestBus");
         OnActivate();
-
         MarkDefaultableInput();
     }
 
     void Node::Deactivate()
     {
         OnDeactivate();
-
-        SignalBus::Handler::BusDisconnect();
-
-        SetRuntimeBus(RuntimeRequestBus::FindFirstHandler(m_scriptCanvasId));
+        m_graphRequestBus = GraphRequestBus::FindFirstHandler(m_scriptCanvasId);
     }
 
     void Node::PostActivate()
@@ -730,26 +718,11 @@ namespace ScriptCanvas
                 // for each output slot...
                 // for each connected node...
                 // remove the ability to default it...
-                // ...and until a more viable solution is available, variable get input in another node must be exclusive   
-
+                
                 EndpointsResolved connections = GetConnectedNodes(inputSlot);
                 if (!connections.empty())
                 {
-                    bool isConnectedToPureData = false;
-
-                    for (auto& nodePtrSlotId : connections)
-                    {
-                        if (azrtti_cast<const PureData*>(nodePtrSlotId.first))
-                        {
-                            isConnectedToPureData = true;
-                            break;
-                        }
-                    }
-
-                    if (!isConnectedToPureData)
-                    {
-                        m_possiblyStaleInput.insert(slotId);
-                    }
+                    m_possiblyStaleInput.insert(slotId);
                 }
             }
         }
@@ -757,7 +730,7 @@ namespace ScriptCanvas
 
     bool Node::IsInEventHandlingScope(const ID& possibleEventHandler) const
     {
-        Node* node = m_runtimeBus->FindNode(possibleEventHandler);
+        Node* node = m_graphRequestBus->FindNode(possibleEventHandler);
 
         if (auto eventHandler = azrtti_cast<ScriptCanvas::Nodes::Core::EBusEventHandler*>(node))
         {
@@ -804,9 +777,7 @@ namespace ScriptCanvas
     bool Node::IsTargetInDataFlowPath(const Node* targetNode) const
     {
         AZStd::unordered_set<ID> path;
-        return azrtti_cast<const PureData*>(this)
-            || azrtti_cast<const PureData*>(targetNode)
-            || (targetNode && IsTargetInDataFlowPath(targetNode->GetEntityId(), path));
+        return (targetNode && IsTargetInDataFlowPath(targetNode->GetEntityId(), path));
     }
 
     bool Node::IsTargetInDataFlowPath(const ID& targetNodeId, AZStd::unordered_set<ID>& path) const
@@ -866,7 +837,7 @@ namespace ScriptCanvas
 
     GraphVariable* Node::FindGraphVariable(const VariableId& variableId) const
     {
-        return m_runtimeBus->FindVariableById(variableId);      
+        return m_graphRequestBus->FindVariableById(variableId);      
     }
 
     void Node::OnSlotConvertedToValue(const SlotId& slotId)
@@ -1620,24 +1591,6 @@ namespace ScriptCanvas
         NodeNotificationsBus::Event(GetEntityId(), &NodeNotifications::OnSlotDisplayTypeChanged, slotId, dataType);
     }
 
-    void Node::SignalInput(const SlotId& slotId)
-    {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::ScriptCanvas);
-        SC_EXECUTION_TRACE_SIGNAL_INPUT((*this), (InputSignal(CreateNodeInputSignal(slotId))));
-
-        {
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::%s::SignalInput", GetNodeName().c_str());
-            OnInputSignal(slotId);
-        }
-
-    }
-
-    void Node::SignalOutput(const SlotId& slotId, ExecuteMode mode)
-    {
-        AZ_UNUSED(slotId);
-        AZ_UNUSED(mode);
-    }
-
     AZ::Outcome<void, AZStd::string> Node::SlotAcceptsType(const SlotId& slotID, const Data::Type& type) const
     {
         if (auto slot = GetSlot(slotID))
@@ -1936,7 +1889,7 @@ namespace ScriptCanvas
             if (slot.GetDescriptor() == slotDescriptor
                 && (allowLatentSlots || !slot.IsLatent()))
             {
-                AZStd::vector<Endpoint> connectedEndpoints = m_runtimeBus->GetConnectedEndpoints(Endpoint{ GetEntityId(), slot.GetId() });
+                AZStd::vector<Endpoint> connectedEndpoints = m_graphRequestBus->GetConnectedEndpoints(Endpoint{ GetEntityId(), slot.GetId() });
                 endpoints.insert(endpoints.end(), connectedEndpoints.begin(), connectedEndpoints.end());
             }
         }
@@ -2361,9 +2314,7 @@ namespace ScriptCanvas
     void Node::SetOwningScriptCanvasId(ScriptCanvasId scriptCanvasId)
     {
         m_scriptCanvasId = scriptCanvasId;
-
-        SetRuntimeBus(RuntimeRequestBus::FindFirstHandler(m_scriptCanvasId));
-
+        m_graphRequestBus = GraphRequestBus::FindFirstHandler(m_scriptCanvasId);
         OnGraphSet();
     }
 
@@ -2448,7 +2399,7 @@ namespace ScriptCanvas
 
     AZ::EntityId Node::GetGraphEntityId() const
     {
-        return m_runtimeBus->GetRuntimeEntityId();
+        return m_graphRequestBus->GetRuntimeEntityId();
     }
 
     NodePtrConstList Node::FindConnectedNodesByDescriptor(const SlotDescriptor& slotDescriptor, bool followLatentConnections) const
@@ -2459,7 +2410,7 @@ namespace ScriptCanvas
 
         for (const auto& endpoint : GetAllEndpointsByDescriptor(slotDescriptor, followLatentConnections))
         {
-            Node* connectedNode = m_runtimeBus->FindNode(endpoint.GetNodeId());
+            Node* connectedNode = m_graphRequestBus->FindNode(endpoint.GetNodeId());
             
             if (connectedNode)
             {
@@ -2478,7 +2429,7 @@ namespace ScriptCanvas
 
         for (const auto& endpoint : GetAllEndpointsByDescriptor(slotDescriptor, followLatentConnections))
         {
-            Node* connectedNode = m_runtimeBus->FindNode(endpoint.GetNodeId());
+            Node* connectedNode = m_graphRequestBus->FindNode(endpoint.GetNodeId());
             
             if (connectedNode)
             {
@@ -2491,7 +2442,7 @@ namespace ScriptCanvas
 
     AZ::Data::AssetId Node::GetGraphAssetId() const
     {
-        return m_runtimeBus->GetAssetId();
+        return m_graphRequestBus->GetAssetId();
     }
 
     AZStd::string Node::GetGraphAssetName() const
@@ -2504,7 +2455,7 @@ namespace ScriptCanvas
 
     GraphIdentifier Node::GetGraphIdentifier() const
     {
-        return m_runtimeBus->GetGraphIdentifier();
+        return m_graphRequestBus->GetGraphIdentifier();
     }
 
     bool Node::IsSanityCheckRequired() const
@@ -2674,7 +2625,7 @@ namespace ScriptCanvas
                 return;
             }
 
-            auto node = m_runtimeBus->FindNode(endpoint.GetNodeId());
+            auto node = m_graphRequestBus->FindNode(endpoint.GetNodeId());
 
             if (node)
             {
@@ -2862,7 +2813,7 @@ namespace ScriptCanvas
     bool Node::IsConnected(const Slot& slot) const
     {
         AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::IsConnected");
-        return slot.IsVariableReference() || m_runtimeBus->IsEndpointConnected(slot.GetEndpoint());
+        return slot.IsVariableReference() || m_graphRequestBus->IsEndpointConnected(slot.GetEndpoint());
     }
 
     bool Node::IsConnected(const SlotId& slotId) const
@@ -2902,7 +2853,7 @@ namespace ScriptCanvas
 
     bool Node::IsActivated() const
     {
-        return m_runtimeBus;
+        return m_graphRequestBus;
     }
     
     EndpointsResolved Node::GetConnectedNodes(const Slot& slot) const
@@ -2911,17 +2862,17 @@ namespace ScriptCanvas
 
         EndpointsResolved connectedNodes;
 
-        auto endpointIters = m_runtimeBus->GetConnectedEndpointIterators(Endpoint{ GetEntityId(), slot.GetId() });
+        auto endpointIters = m_graphRequestBus->GetConnectedEndpointIterators(Endpoint{ GetEntityId(), slot.GetId() });
 
         for (auto endpointIter = endpointIters.first; endpointIter != endpointIters.second; ++endpointIter)
         {
             const Endpoint& endpoint = endpointIter->second;
-            auto node = m_runtimeBus->FindNode(endpoint.GetNodeId());
+            auto node = m_graphRequestBus->FindNode(endpoint.GetNodeId());
 
             if (node == nullptr)
             {                
-                AZStd::string assetName = m_runtimeBus->GetAssetName();
-                AZ::EntityId assetNodeId = m_runtimeBus->FindAssetNodeIdByRuntimeNodeId(endpoint.GetNodeId());
+                AZStd::string assetName = m_graphRequestBus->GetAssetName();
+                AZ::EntityId assetNodeId = m_graphRequestBus->FindAssetNodeIdByRuntimeNodeId(endpoint.GetNodeId());
                 AZ_Warning("Script Canvas", false, "Unable to find node with id (id: %s) in the graph '%s'. Most likely the node was serialized with a type that is no longer reflected",
                     assetNodeId.ToString().data(), assetName.data());
 
@@ -2935,8 +2886,8 @@ namespace ScriptCanvas
             auto endpointSlot = node->GetSlot(endpoint.GetSlotId());
             if (!endpointSlot)
             {
-                AZStd::string assetName = m_runtimeBus->GetAssetName();
-                AZ::EntityId assetNodeId = m_runtimeBus->FindAssetNodeIdByRuntimeNodeId(endpoint.GetNodeId());
+                AZStd::string assetName = m_graphRequestBus->GetAssetName();
+                AZ::EntityId assetNodeId = m_graphRequestBus->FindAssetNodeIdByRuntimeNodeId(endpoint.GetNodeId());
                 AZ_Warning("Script Canvas", false, "Endpoint was missing slot. id (id: %s) in the graph '%s'.",
                     assetNodeId.ToString().data(), assetName.data());
 
@@ -2959,18 +2910,18 @@ namespace ScriptCanvas
 
     void Node::ModConnectedNodes(const Slot& slot, AZStd::vector<AZStd::pair<Node*, const SlotId>>& connectedNodes) const
     {
-        auto endpointIters = m_runtimeBus->GetConnectedEndpointIterators(Endpoint{ GetEntityId(), slot.GetId() });
+        auto endpointIters = m_graphRequestBus->GetConnectedEndpointIterators(Endpoint{ GetEntityId(), slot.GetId() });
 
         for (auto endpointIter = endpointIters.first; endpointIter != endpointIters.second; ++endpointIter)
         {
             const Endpoint& endpoint = endpointIter->second;
 
-            auto node = m_runtimeBus->FindNode(endpoint.GetNodeId());
+            auto node = m_graphRequestBus->FindNode(endpoint.GetNodeId());
 
             if (node == nullptr)
             {
-                AZStd::string assetName = m_runtimeBus->GetAssetName();
-                AZ::EntityId assetNodeId = m_runtimeBus->FindAssetNodeIdByRuntimeNodeId(endpoint.GetNodeId());
+                AZStd::string assetName = m_graphRequestBus->GetAssetName();
+                AZ::EntityId assetNodeId = m_graphRequestBus->FindAssetNodeIdByRuntimeNodeId(endpoint.GetNodeId());
 
                 AZ_Error("Script Canvas", false, "Unable to find node with id (id: %s) in the graph '%s'. Most likely the node was serialized with a type that is no longer reflected",
                     assetNodeId.ToString().data(), assetName.data());
@@ -2983,41 +2934,7 @@ namespace ScriptCanvas
 
     bool Node::HasConnectedNodes(const Slot& slot) const
     {
-        return m_runtimeBus->IsEndpointConnected(Endpoint{ GetEntityId(), slot.GetId() });
-    }
-
-    void Node::OnInputChanged(Node& node, const Datum& input, const SlotId& slotID)
-    {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::ScriptCanvas);
-        node.OnInputChanged(input, slotID);
-    }
-
-    void Node::PushOutput(const Datum& output, const Slot& slot) const
-    {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::ScriptCanvas);
-
-        if (slot.IsVariableReference())
-        {
-            GraphVariable* variable = slot.GetVariable();
-
-            if (variable)
-            {
-                ModifiableDatumView datumView;
-                variable->ConfigureDatumView(datumView);
-
-                datumView.AssignToDatum(output);
-            }
-        }
-        else
-            {
-            auto endpointIters = m_runtimeBus->GetConnectedEndpointIterators(Endpoint{ GetEntityId(), slot.GetId() });
-
-            for (auto endpointIter = endpointIters.first; endpointIter != endpointIters.second; ++endpointIter)
-            {
-                Node* node = m_runtimeBus->FindNode(endpointIter->second.GetNodeId());
-                node->SetInput(output, endpointIter->second.GetSlotId());
-            }
-        }
+        return m_graphRequestBus->IsEndpointConnected(Endpoint{ GetEntityId(), slot.GetId() });
     }
 
     void Node::ForEachConnectedNode(const Slot& slot, AZStd::function<void(Node&, const SlotId&)> callable) const
@@ -3040,9 +2957,8 @@ namespace ScriptCanvas
         FindModifiableDatumView(slotId, datumView);
 
         if (datumView.IsValid())
-            {
+        {
             datumView.AssignToDatum(newInput);
-            OnInputChanged((*datumView.GetDatum()), slotId);
         }
     }
 
@@ -3056,7 +2972,6 @@ namespace ScriptCanvas
         if (datumView.IsValid())
         {
             datumView.AssignToDatum(newInput);
-            OnInputChanged((*datumView.GetDatum()), slotId);
         }
     }
 

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Node.h

@@ -22,12 +22,10 @@
 #include <ScriptCanvas/Core/ExecutionNotificationsBus.h>
 #include <ScriptCanvas/Core/GraphBus.h>
 #include <ScriptCanvas/Core/NodeBus.h>
-#include <ScriptCanvas/Core/SignalBus.h>
 #include <ScriptCanvas/Core/Slot.h>
 #include <ScriptCanvas/Debugger/StatusBus.h>
 #include <ScriptCanvas/Execution/ErrorBus.h>
 #include <ScriptCanvas/Execution/ExecutionBus.h>
-#include <ScriptCanvas/Execution/RuntimeBus.h>
 #include <ScriptCanvas/Variable/GraphVariable.h>
 #include <ScriptCanvas/Grammar/Primitives.h>
 #include <ScriptCanvas/Debugger/ValidationEvents/ValidationEvent.h>
@@ -400,7 +398,6 @@ namespace ScriptCanvas
     class Node
         : public AZ::Component
         , public DatumNotificationBus::Handler
-        , private SignalBus::Handler
         , public NodeRequestBus::Handler
         , public EndpointNotificationBus::MultiHandler
     {
@@ -542,7 +539,6 @@ namespace ScriptCanvas
         AZStd::vector<AZStd::pair<const Node*, SlotId>> FindConnectedNodesAndSlotsByDescriptor(const SlotDescriptor& slotType, bool followLatentConnections = false) const;
         
         AZStd::vector<const Slot*> GetSlotsByType(CombinedSlotType slotType) const;
-        AZStd::vector<Endpoint> GetConnectedEndpoints(SlotId outSlot) const;
 
         bool IsConnected(const Slot& slot) const;
         bool IsConnected(const SlotId& slotId) const;
@@ -845,7 +841,6 @@ namespace ScriptCanvas
 
         void SignalSlotsReordered();
 
-        static void OnInputChanged(Node& node, const Datum& input, const SlotId& slotID);
         static void SetInput(Node& node, const SlotId& id, const Datum& input);
         static void SetInput(Node& node, const SlotId& id, Datum&& input);
 
@@ -892,7 +887,6 @@ protected:
         void Configure();
 
     protected:
-
         TransientSlotIdentifier ConstructTransientIdentifier(const Slot& slot) const;
 
         DatumVector GatherDatumsForDescriptor(SlotDescriptor descriptor) const;
@@ -900,7 +894,6 @@ protected:
         SlotDataMap CreateInputMap() const;
         SlotDataMap CreateOutputMap() const;
 
-
         Signal CreateNodeInputSignal(const SlotId& slotId) const;
         Signal CreateNodeOutputSignal(const SlotId& slotId) const;
 
@@ -954,6 +947,7 @@ protected:
 
         //! This is a used by CodeGen to configure slots just prior to OnInit.
         virtual void ConfigureSlots() {}
+
         //! Entity level initialization, perform any resource allocation here that should be available throughout the node's existence.
         virtual void OnInit() {}
 
@@ -968,13 +962,11 @@ protected:
 
         //! Entity level activation, perform entity lifetime setup here, i.e. connect to EBuses
         virtual void OnActivate() {}
+
         //! Entity level deactivation, perform any entity lifetime release here, i.e disconnect from EBuses
         virtual void OnDeactivate() {}
         
         virtual void OnPostActivate() {}
-        //! Any node that is not pure data will perform its operation assuming that all input has been pushed and is reasonably valid
-        // perform your derived nodes work in OnInputSignal(const SlotId&)
-        virtual void OnInputSignal(const SlotId& /*slot*/) {}
 
         //! Signal sent once the OwningScriptCanvasId is set.
         virtual void OnGraphSet() {}
@@ -1000,25 +992,12 @@ protected:
         void ModConnectedNodes(const Slot& slot, AZStd::vector<AZStd::pair<Node*, const SlotId>>&) const;
         bool HasConnectedNodes(const Slot& slot) const;
 
-        virtual void OnInputChanged(const Datum& /*input*/, const SlotId& /*slotID*/) {}
-
-        //////////////////////////////////////////////////////////////////////////
-        //! The body of the node's execution, implement the node's work here.
-        void PushOutput(const Datum& output, const Slot& slot) const;
         void SetOwningScriptCanvasId(ScriptCanvasId scriptCanvasId);
         void SetGraphEntityId(AZ::EntityId graphEntityId);
 
-        // on activate, simple expressions need to push this data
         virtual void SetInput(const Datum& input, const SlotId& id);
         virtual void SetInput(Datum&& input, const SlotId& id);
 
-        //! Any node that is not pure data will perform its operation assuming that all input has been pushed and is reasonably valid
-        // perform your derived nodes work in OnInputSignal(const SlotId&)
-        void SignalInput(const SlotId& slot) override final;
-
-        //! This must be called manually to send execution out of a specific slot
-        void SignalOutput(const SlotId& slot, ExecuteMode mode = ExecuteMode::Normal) override final;
-
         bool SlotExists(AZStd::string_view name, const SlotDescriptor& slotDescriptor) const;
 
         bool IsTargetInDataFlowPath(const ID& targetNodeId, AZStd::unordered_set<ID>& path) const;
@@ -1027,10 +1006,6 @@ protected:
 
         void PopulateNodeType();
 
-        void SetRuntimeBus(RuntimeRequests* runtimeBus) { m_runtimeBus = runtimeBus; }
-        RuntimeRequests* GetRuntimeBus() const { return m_runtimeBus; }
-
-
         GraphScopedNodeId GetScopedNodeId() const { return GraphScopedNodeId(GetOwningScriptCanvasId(), GetEntityId()); }
         
     private:
@@ -1070,102 +1045,17 @@ protected:
         AZStd::vector< VisualExtensionSlotConfiguration > m_visualExtensions;
 
         // Cache pointer to the owning Graph
-        RuntimeRequests* m_runtimeBus = nullptr;
+        GraphRequests* m_graphRequestBus = nullptr;
         
         ScriptCanvas::SlotId m_removingSlot;
 
     public:
-        template<typename t_Value>
-        const t_Value* GetInput_UNIT_TEST(AZStd::string_view slotName)
-        {
-            return GetInput_UNIT_TEST<t_Value>(GetSlotId(slotName));
-        }
-
-        template<typename t_Value>
-        t_Value* ModInput_UNIT_TEST(AZStd::string_view slotName)
-        {
-            return ModInput_UNIT_TEST<t_Value>(GetSlotId(slotName));
-        }
-
-        template<typename t_Value>
-        const t_Value* GetInput_UNIT_TEST(const SlotId& slotId)
-        {
-            const Datum* input = FindDatum(slotId);
-            return input ? input->GetAs<t_Value>() : nullptr;
-        }
-
-        template<typename t_Value>
-        t_Value* ModInput_UNIT_TEST(const SlotId& slotId)
-        {
-            auto slotIter = m_slotIdIteratorCache.find(slotId);
-
-            if (slotIter != m_slotIdIteratorCache.end())
-            {
-                Slot* slot = &(*slotIter->second.m_slotIterator);
-
-                if (slot->IsVariableReference())
-                {
-                    AZ_Assert(false, "Variable references are not supported in Unit Test methods.");
-                }
-                else
-                {
-                    return slotIter->second.GetDatumIter()->ModAs<t_Value>();
-                }
-            }
-
-            return nullptr;
-        }
-
-        const Datum* GetInput_UNIT_TEST(AZStd::string_view slotName)
-        {
-            return GetInput_UNIT_TEST(GetSlotId(slotName));
-        }
-
-        const Datum* GetInput_UNIT_TEST(const SlotId& slotId)
-        {
-            return FindDatum(slotId);
-        }
-
-        // initializes the node input to the value passed in, not a pointer to it
-        template<typename t_Value>
-        void SetInput_UNIT_TEST(AZStd::string_view slotName, const t_Value& value)
-        {
-            SetInput_UNIT_TEST<t_Value>(GetSlotId(slotName), value);
-        }
-
-        template<typename t_Value>
-        void SetInput_UNIT_TEST(const SlotId& slotId, const t_Value& value)
-        {
-            SetInput(Datum(value), slotId);
-        }
-
-        void SetInput_UNIT_TEST(AZStd::string_view slotName, const Datum& value)
-        {
-            SetInput_UNIT_TEST(GetSlotId(slotName), value);
-        }
-
-        void SetInput_UNIT_TEST(AZStd::string_view slotName, Datum&& value)
-        {
-            SetInput_UNIT_TEST(GetSlotId(slotName), AZStd::move(value));
-        }
-
-        void SetInput_UNIT_TEST(const SlotId& slotId, Datum&& value)
-        {
-            SetInput(AZStd::move(value), slotId);
-        }
-
         template<typename t_Func, t_Func, typename, size_t>
         friend struct Internal::MultipleOutputHelper;
 
         template<typename ResultType, typename t_Traits, typename>
         friend struct Internal::OutputSlotHelper;
 
-        template<typename ResultType, typename t_Traits, typename>
-        friend struct Internal::PushOutputHelper;
-
-        template<typename ResultType, typename ResultIndexSequence, typename t_Func, t_Func function, typename t_Traits>
-        friend struct Internal::CallHelper;
-
         template<size_t... inputDatumIndices>
         friend struct SetDefaultValuesByIndex;
     };
@@ -1238,104 +1128,6 @@ protected:
             }
         };
 
-        template<typename ResultType, typename t_Traits, typename = AZStd::void_t<>>
-        struct PushOutputHelper
-        {
-            template<size_t... Is>
-            static void PushOutput(Node& node, ResultType&& result, AZStd::index_sequence<Is...>)
-            {
-                // protect against changes to the function that generated the node
-                if (auto slot = node.GetSlotByIndex(t_Traits::s_resultsSlotIndicesStart))
-                {
-                    node.PushOutput(Datum(AZStd::forward<ResultType>(result)), *slot);
-                }
-            }
-        };
-
-        template<typename t_Traits>
-        struct PushOutputHelper<void, t_Traits, void>
-        {
-            template<size_t... Is> static void PushOutput(Node& node, AZStd::ignore_t result, AZStd::index_sequence<Is...>) {}
-        };
-
-        template<typename ResultType, typename t_Traits>
-        struct PushOutputHelper<ResultType, t_Traits, AZStd::enable_if_t<IsTupleLike<ResultType>::value>>
-        {
-            template<size_t t_Index>
-            static void PushOutputFold(Node& node, ResultType&& tupleResult)
-            {
-                // protect against changes to the function that generated the node
-                if (auto slot = node.GetSlotByIndex(t_Traits::s_resultsSlotIndicesStart + t_Index))
-                {
-                    node.PushOutput(Datum(AZStd::get<t_Index>(AZStd::forward<ResultType>(tupleResult))), *slot);
-                }
-            }
-
-            template<size_t... Is>
-            static void PushOutput(Node& node, ResultType&& tupleResult, AZStd::index_sequence<Is...>)
-            {
-                (PushOutputFold<Is>(node, AZStd::forward<ResultType>(tupleResult)), ...);
-            }
-        };
-
-        template<typename ResultType, typename ResultIndexSequence, typename t_Func, t_Func function, typename t_Traits>
-        struct CallHelper
-        {
-            // protect against changes to the function that generated the node
-            template<typename... t_Args, size_t... Indices>
-            static bool IsIndexSafe(Node& node, const AZStd::index_sequence<Indices...>&)
-            {
-                return (true && ... && (node.FindDatumByIndex(Indices) != nullptr && node.FindDatumByIndex(Indices)->GetAs<AZStd::decay_t<t_Args>>() != nullptr));
-            }
-
-            template<typename... t_Args, size_t... ArgIndices>
-            static void Call(Node& node, AZStd::Internal::pack_traits_arg_sequence<t_Args...>, [[maybe_unused]] AZStd::index_sequence<ArgIndices...> sequence)
-            {
-#if !defined(_RELEASE)
-                if (IsIndexSafe<t_Args...>(node, sequence))
-                {
-                    PushOutputHelper<ResultType, t_Traits>::PushOutput(node, AZStd::invoke(function, *node.FindDatumByIndex(ArgIndices)->GetAs<AZStd::decay_t<t_Args>>()...), ResultIndexSequence());
-                }
-                else
-                {
-                    SCRIPTCANVAS_REPORT_ERROR((node), "Generic function Node (%s) could not be executed, due to missing slot for source definition."
-                        "this is likely due to changing the function signature. See serialization log for potential errors & warnings.", node.GetNodeName().c_str());    
-                }
-#else
-                PushOutputHelper<ResultType, t_Traits>::PushOutput(node, AZStd::invoke(function, *node.FindDatumByIndex(ArgIndices)->GetAs<AZStd::decay_t<t_Args>>()...), ResultIndexSequence());
-#endif//!defined(_RELEASE)
-            }
-        };
-
-        template<typename ResultIndexSequence, typename t_Func, t_Func function, typename t_Traits>
-        struct CallHelper<void, ResultIndexSequence, t_Func, function, t_Traits>
-        {
-            // protect against changes to the function that generated the node
-            template<typename... t_Args, size_t... Indices>
-            static bool IsIndexSafe(Node& node, const AZStd::index_sequence<Indices...>&)
-            {
-                return true && (... && (node.FindDatumByIndex(Indices) != nullptr && node.FindDatumByIndex(Indices)->GetAs<AZStd::decay_t<t_Args>>() != nullptr));
-            }
-
-            template<typename... t_Args, size_t... ArgIndices>
-            static void Call(Node& node, AZStd::Internal::pack_traits_arg_sequence<t_Args...>, [[maybe_unused]] AZStd::index_sequence<ArgIndices...> sequence)
-            {
-#if !defined(_RELEASE)
-                if (IsIndexSafe<t_Args...>(node, sequence))
-                {
-                    AZStd::invoke(function, *node.FindDatumByIndex(ArgIndices)->GetAs<AZStd::decay_t<t_Args>>()...);
-                }
-                else
-                {
-                    SCRIPTCANVAS_REPORT_ERROR((node), "Generic function Node (%s) could not be executed, due to missing slot for source definition."
-                        "this is likely due to changing the function signature. See serialization log for potential errors & warnings.", node.GetNodeName().c_str());
-                }
-#else
-                AZStd::invoke(function, *node.FindDatumByIndex(ArgIndices)->GetAs<AZStd::decay_t<t_Args>>()...);
-#endif//!defined(_RELEASE)
-            }
-        };
-
         template<typename t_Func, t_Func function, typename t_Traits, size_t NumOutputs>
         struct MultipleOutputHelper
         {
@@ -1346,11 +1138,6 @@ protected:
             {
                 OutputSlotHelper<ResultType, t_Traits>::AddOutputSlot(node, ResultIndexSequence());
             }
-
-            static void Call(Node& node)
-            {
-                CallHelper<ResultType, ResultIndexSequence, t_Func, function, t_Traits>::Call(node, typename AZStd::function_traits<t_Func>::arg_sequence{}, AZStd::make_index_sequence<AZStd::function_traits<t_Func>::arity>{});
-            }
         };
 
         template<typename t_Func, t_Func function, typename t_Traits, typename t_Result, typename = AZStd::void_t<>>

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/NodeFunctionGeneric.h

@@ -248,8 +248,6 @@ namespace ScriptCanvas
             return AZ::Success(scope);
         }
 
-        
-
     protected:
 
         template<typename ArgType, size_t Index>
@@ -298,13 +296,6 @@ namespace ScriptCanvas
             MultipleOutputInvoker<t_Func, function, t_Traits>::Add(*this);
         }
 
-        void OnInputSignal(const SlotId&) override
-        {
-            MultipleOutputInvoker<t_Func, function, t_Traits>::Call(*this);
-            SignalOutput(GetSlotId("Out"));
-        }
-
-
         static bool VersionConverter(AZ::SerializeContext& serializeContext, AZ::SerializeContext::DataElementNode& rootElement);
         static bool ConvertOldNodeGeneric(AZ::SerializeContext& serializeContext, AZ::SerializeContext::DataElementNode& rootElement);
 

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/PureData.cpp

@@ -1,230 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "PureData.h"
-
-namespace ScriptCanvas
-{
-    const char* PureData::k_getThis("Get");
-    const char* PureData::k_setThis("Set");
-
-    PureData::~PureData()
-    {
-
-    }
-    
-    const AZStd::unordered_map<AZStd::string, AZStd::pair<SlotId, SlotId>>& PureData::GetPropertyNameSlotMap() const
-    {
-        return m_propertyAccount.m_getterSetterIdPairs;
-    }
-
-    void PureData::AddInputAndOutputTypeSlot(const Data::Type& type, const void* source)
-    {
-        {
-            DataSlotConfiguration slotConfiguration;
-
-            slotConfiguration.m_name = k_setThis;
-            slotConfiguration.SetConnectionType(ConnectionType::Input);
-            slotConfiguration.ConfigureDatum(AZStd::move(Datum(type, Datum::eOriginality::Original, source, AZ::Uuid::CreateNull())));
-
-            AddSlot(slotConfiguration);
-        }
-
-        {
-            DataSlotConfiguration slotConfiguration;
-
-            slotConfiguration.m_name = k_getThis;
-            slotConfiguration.SetConnectionType(ConnectionType::Output);            
-            slotConfiguration.SetType(type);
-
-            AddSlot(slotConfiguration);
-        }
-    }
-
-    void PureData::AddInputTypeAndOutputTypeSlot(const Data::Type& type)
-    {
-        {
-            DataSlotConfiguration slotConfiguration;
-
-            slotConfiguration.m_name = k_setThis;
-            slotConfiguration.SetConnectionType(ConnectionType::Input);
-            slotConfiguration.SetType(type);
-
-            AddSlot(slotConfiguration);
-        }
-
-        {
-            DataSlotConfiguration slotConfiguration;
-
-            slotConfiguration.m_name = k_getThis;
-            slotConfiguration.SetConnectionType(ConnectionType::Output);
-            slotConfiguration.SetType(type);
-
-            AddSlot(slotConfiguration);
-        }
-    }
-
-    void PureData::OnActivate()
-    {
-        PushThis();
-
-        for (const auto& propertySlotIdsPair : m_propertyAccount.m_getterSetterIdPairs)
-        {
-            const SlotId& getterSlotId = propertySlotIdsPair.second.first;
-            CallGetter(getterSlotId);
-        }
-    }
-
-    void PureData::OnInputChanged(const Datum& input, [[maybe_unused]] const SlotId& id) 
-    {
-        if (IsActivated())
-        {
-            OnOutputChanged(input);
-        }
-    }
-
-    AZStd::string_view PureData::GetInputDataName() const
-    {
-        return k_setThis;
-    }
-
-    AZStd::string_view PureData::GetOutputDataName() const
-    {
-        return k_getThis;
-    }
-
-    void PureData::CallGetter(const SlotId& getterSlotId)
-    {
-        auto getterFuncIt = m_propertyAccount.m_gettersByInputSlot.find(getterSlotId);
-        Slot* getterSlot = GetSlot(getterSlotId);
-        if (getterSlot && getterFuncIt != m_propertyAccount.m_gettersByInputSlot.end())
-        {
-            AZStd::vector<AZStd::pair<Node*, const SlotId>> outputNodes(ModConnectedNodes(*getterSlot));
-
-            if (!outputNodes.empty())
-            {
-                auto getterOutcome = getterFuncIt->second.m_getterFunction((*FindDatum(GetSlotId(k_setThis))));
-                if (!getterOutcome)
-                {
-                    SCRIPTCANVAS_REPORT_ERROR((*this), getterOutcome.GetError().data());
-                    return;
-                }
-
-
-                for (auto& nodePtrSlot : outputNodes)
-                {
-                    if (nodePtrSlot.first)
-                    {
-                        Node::SetInput(*nodePtrSlot.first, nodePtrSlot.second, getterOutcome.GetValue());
-                    }
-                }
-            }
-        }
-    }
-
-    void PureData::SetInput(const Datum& input, const SlotId& id)
-    {
-        if (id == FindSlotIdForDescriptor(GetInputDataName(), SlotDescriptors::DataIn()))
-        {
-            // push this value, as usual
-            Node::SetInput(input, id);
-
-            // now, call every getter, as every property has (presumably) been changed
-            for (const auto& propertyNameSlotIdsPair : m_propertyAccount.m_getterSetterIdPairs)
-            {
-                const SlotId& getterSlotId = propertyNameSlotIdsPair.second.first;
-                CallGetter(getterSlotId);
-            }
-        }
-        else
-        {
-            SetProperty(input, id);
-        }
-    }
-
-    void PureData::SetInput(Datum&& input, const SlotId& id)
-    {
-        if (id == FindSlotIdForDescriptor(GetInputDataName(), SlotDescriptors::DataIn()))
-        {
-            // push this value, as usual
-            Node::SetInput(AZStd::move(input), id);
-
-            if (IsActivated())
-            {
-                // now, call every getter, as every property has (presumably) been changed
-                for (const auto& propertyNameSlotIdsPair : m_propertyAccount.m_getterSetterIdPairs)
-                {
-                    const SlotId& getterSlotId = propertyNameSlotIdsPair.second.first;
-                    CallGetter(getterSlotId);
-                }
-            }
-        }
-        else
-        {
-            SetProperty(AZStd::move(input), id);
-        }
-    }
-
-    void PureData::SetProperty(const Datum& input, const SlotId& setterId)
-    {
-        auto methodBySlotIter = m_propertyAccount.m_settersByInputSlot.find(setterId);
-        if (methodBySlotIter == m_propertyAccount.m_settersByInputSlot.end())
-        {
-            AZ_Error("Script Canvas", false, "BehaviorContextObject SlotId %s did not route to a setter", setterId.m_id.ToString<AZStd::string>().data());
-            return;
-        }
-        if (!methodBySlotIter->second.m_setterFunction)
-        {
-            AZ_Error("Script Canvas", false, "BehaviorContextObject setter is not invocable for SlotId %s is nullptr", setterId.m_id.ToString<AZStd::string>().data());
-            return;
-        }
-
-        ModifiableDatumView datumView;
-        FindModifiableDatumView(GetSlotId(k_setThis), datumView);
-
-        Datum* datum = datumView.ModifyDatum();
-
-        auto setterOutcome = methodBySlotIter->second.m_setterFunction((*datum), input);
-
-        if (!setterOutcome)
-        {
-            SCRIPTCANVAS_REPORT_ERROR((*this), setterOutcome.TakeError().data());
-            return;
-        }
-
-        datumView.SignalModification();
-
-        PushThis();
-
-        auto getterSetterIt = m_propertyAccount.m_getterSetterIdPairs.find(methodBySlotIter->second.m_propertyName);
-
-        if (getterSetterIt != m_propertyAccount.m_getterSetterIdPairs.end())
-        {
-            CallGetter(getterSetterIt->second.first);
-        }
-    }
-
-
-    void PureData::Reflect(AZ::ReflectContext* reflectContext)
-    {
-        AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(reflectContext);
-        if (serializeContext)
-        {
-            serializeContext->Class<PureData, Node>()
-                ->Version(0)
-                ;
-
-            AZ::EditContext* editContext = serializeContext->GetEditContext();
-            if (editContext)
-            {
-                editContext->Class<PureData>("PureData", "")
-                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
-                    ;
-            }
-        }
-    }
-}

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/PureData.h

@@ -1,111 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <ScriptCanvas/Core/Node.h>
-#include <ScriptCanvas/Core/Graph.h>
-#include <ScriptCanvas/Core/Datum.h>
-#include <ScriptCanvas/Data/PropertyTraits.h>
-
-namespace AZ
-{
-    class BehaviorClass;
-    struct BehaviorValueParameter;
-    class ReflectContext;
-}
-
-namespace ScriptCanvas
-{
-    struct PropertyAccount
-    {
-        AZStd::unordered_map<SlotId, Data::GetterWrapper> m_gettersByInputSlot;
-        AZStd::unordered_map<SlotId, Data::SetterWrapper> m_settersByInputSlot;
-        // The first slot id of the pair is the Getter SlotId, the second slot id of the pair is the Setter SlotID
-        AZStd::unordered_map<AZStd::string, AZStd::pair<SlotId, SlotId>> m_getterSetterIdPairs;
-    };
-
-    class PureData
-        : public Node
-    {
-    public:
-        AZ_COMPONENT(PureData, "{8B80FF54-0786-4FEE-B4A3-12907EBF8B75}", Node);
-
-        static void Reflect(AZ::ReflectContext* reflectContext);
-        static const char* k_getThis;
-        static const char* k_setThis;
-
-        const AZStd::unordered_map<AZStd::string, AZStd::pair<SlotId, SlotId>>& GetPropertyNameSlotMap() const;
-
-        AZ_INLINE AZ::Outcome<DependencyReport, void> GetDependencies() const override { return AZ::Success(DependencyReport{}); }
-
-        ~PureData() override;
-
-    protected:
-        void AddInputAndOutputTypeSlot(const Data::Type& type, const void* defaultValue = nullptr);
-        template<typename DatumType>
-        void AddDefaultInputAndOutputTypeSlot(DatumType&& defaultValue);
-        void AddInputTypeAndOutputTypeSlot(const Data::Type& type);
-
-        bool IsDeprecated() const override { return true; }
-
-        void OnActivate() override;
-        void OnInputChanged(const Datum& input, const SlotId& id) override;
-        void MarkDefaultableInput() override {}
-
-        AZ_INLINE void OnOutputChanged(const Datum& output) const
-        { 
-            Slot* slot = GetSlotByName(GetOutputDataName());
-            if (slot)
-            {
-                OnOutputChanged(output, (*slot));
-            }
-        }
-        
-        AZ_INLINE void OnOutputChanged(const Datum& output, const Slot& outputSlot) const
-        {
-            PushOutput(output, outputSlot);
-        }
-
-        // push data out
-        AZ_INLINE void PushThis()
-        {
-            auto slotId = GetSlotId(GetInputDataName());
-
-            if (auto setDatum = FindDatum(slotId))
-            {
-                OnInputChanged(*setDatum, slotId);
-            }
-            else
-            {
-                SCRIPTCANVAS_REPORT_ERROR((*this), "No input datum in a PureData class %s. You must push your data manually in OnActivate() if no input is connected!");
-            }
-        }
-
-        AZStd::string_view GetInputDataName() const;
-        AZStd::string_view GetOutputDataName() const;
-
-        void SetInput(const Datum& input, const SlotId& id) override;
-        void SetInput(Datum&& input, const SlotId& id) override;
-        void SetProperty(const Datum& input, const SlotId& id);
-        void CallGetter(const SlotId& getterSlotId);
-        bool IsConfigured() { return m_configured; }
-
-        PropertyAccount m_propertyAccount;
-        bool m_configured = false;
-    };
-
-    template<typename DatumType>
-    void PureData::AddDefaultInputAndOutputTypeSlot(DatumType&& defaultValue)
-    {
-        AddInputDatumSlot(GetInputDataName(), "", Datum::eOriginality::Original, AZStd::forward<DatumType>(defaultValue));
-        AddOutputTypeSlot(GetOutputDataName(), "", Data::FromAZType(azrtti_typeid<AZStd::decay_t<DatumType>>()), OutputStorage::Optional);
-    }
-
-    template<>
-    void PureData::AddDefaultInputAndOutputTypeSlot<Data::Type>(Data::Type&&) = delete;
-}

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/SignalBus.h

@@ -1,36 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include "Core.h"
-
-#include <AzCore/EBus/EBus.h>
-
-namespace ScriptCanvas
-{
-    enum class ExecuteMode
-    {
-        Normal,
-        UntilNodeIsFoundInStack
-    };
-
-    class SignalInterface : public AZ::EBusTraits
-    {
-    public:
-        //////////////////////////////////////////////////////////////////////////
-        // EBusTraits overrides
-        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
-        typedef ID BusIdType;
-        //////////////////////////////////////////////////////////////////////////
-                
-        virtual void SignalInput(const SlotId& slot) = 0;
-        virtual void SignalOutput(const SlotId& slot, ExecuteMode mode = ExecuteMode::Normal) = 0;
-    };
-
-    using SignalBus = AZ::EBus<SignalInterface>;
-}

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Slot.cpp

@@ -231,12 +231,6 @@ namespace ScriptCanvas
         // Add the slot type contract by default, It is used for filtering input/output slots and flow/data slots
         m_contracts.emplace_back(AZStd::make_unique<SlotTypeContract>());
 
-        // Every DataIn slot has a contract validating that only 1 connection from any PureData node is allowed
-        if (IsData() && IsInput())
-        {
-            AddContract({ []() { return aznew ExclusivePureDataContract(); } });
-        }
-
         for (const auto& contractDesc : slotConfiguration.m_contractDescs)
         {
             AddContract(contractDesc);
@@ -390,15 +384,10 @@ namespace ScriptCanvas
             if (m_variable)
             {
                 VariableNotificationBus::Handler::BusConnect(m_variable->GetGraphScopedId());
-
-                if (IsInput())
-                {
-                    m_node->OnInputChanged((*m_variable->GetDatum()), GetId());
-                }
             }
-            else
+            else if (m_node)
             {
-                SCRIPTCANVAS_REPORT_ERROR((*m_node), "Node (%s) is attempting to execute using an invalid Variable Reference", m_node->GetNodeName().c_str());
+                AZ_Warning("ScriptCanvas", false, "Node (%s) is attempting to initialize an invalid Variable Reference", m_node->GetNodeName().c_str());
             }
         }
     }
@@ -590,11 +579,6 @@ namespace ScriptCanvas
         return m_isLatentSlot;
     }
 
-    void Slot::OnVariableValueChanged()
-    {
-        m_node->OnInputChanged((*m_variable->GetDatum()), GetId());
-    }
-
     void Slot::SetDynamicDataType(DynamicDataType dynamicDataType)
     {
         AZ_Assert(m_dynamicDataType == DynamicDataType::None, "Set Dynamic Data Type is meant to be used for a node wise version conversion step. Not as a run time reconfiguration of a dynamic type.");

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Slot.h

@@ -167,10 +167,6 @@ namespace ScriptCanvas
 
         bool IsLatent() const;
 
-        // VariableNotificationBus
-        void OnVariableValueChanged() override;
-        ////
-
         // Here to allow conversion of the previously untyped any slots into the dynamic type any.
         void SetDynamicDataType(DynamicDataType dynamicDataType);
 

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/SubgraphInterface.h

@@ -266,16 +266,6 @@ namespace ScriptCanvas
             const In* FindIn(const AZStd::string& inSlotId) const;
             const Out* FindLatentOut(const AZStd::string& latent) const;
             LexicalScope GetLexicalScope(bool isSourcePure) const;
-
-#if defined(FUNCTION_LEGACY_SUPPORT_ENABLED)
-        public:
-            bool IsAllInputOutputShared() const;
-
-            // all input/output are used in every in/out/latent slot?
-            bool m_isAllInputOutputShared = false;
-
-            void MarkAllInputOutputShared();
-#endif
         };
 
         AZStd::string ToString(const In& in, size_t tabs = 0);

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Execution/RuntimeBus.h

@@ -1,103 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <ScriptCanvas/Core/Endpoint.h>
-
-#include <AzCore/EBus/EBus.h>
-#include <AzCore/std/containers/unordered_map.h>
-#include <AzCore/std/containers/vector.h>
-#include <AzCore/std/string/string_view.h>
-
-#include <ScriptCanvas/Core/ExecutionNotificationsBus.h>
-#include <ScriptCanvas/Data/Data.h>
-#include <ScriptCanvas/Variable/VariableCore.h>
-
-namespace ScriptCanvas
-{
-    struct GraphData;
-    class GraphVariable;
-    class VariableData;
-    
-    using EndpointMapConstIterator = AZStd::unordered_multimap<Endpoint, Endpoint>::const_iterator;
-
-    //! Runtime Request Bus for interfacing with the runtime execution component
-    class RuntimeRequests : public AZ::EBusTraits
-    {
-    public:
-        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
-        //! BusIdType represents a unique id for the execution component
-        //! Because multiple Script Canvas graphs can execute on the same entity
-        //! this is not an "EntityId" in the sense that it uniquely identifies an entity.
-        using BusIdType = ScriptCanvasId;
-
-        virtual VariableId FindAssetVariableIdByRuntimeVariableId(VariableId runtimeId) const = 0;
-        
-        virtual VariableId FindRuntimeVariableIdByAssetVariableId(VariableId assetId) const = 0;
-
-        virtual AZ::EntityId FindAssetNodeIdByRuntimeNodeId(AZ::EntityId editorNode) const = 0;
-
-        virtual AZ::Data::AssetId GetAssetId() const = 0;
-        virtual GraphIdentifier GetGraphIdentifier() const = 0;
-        virtual AZStd::string GetAssetName() const = 0;
-        
-        //! Looks up the nodeId within the bus handler
-        virtual Node* FindNode(AZ::EntityId nodeId) const = 0;
-        
-        virtual AZ::EntityId FindRuntimeNodeIdByAssetNodeId(AZ::EntityId runtimeNode) const = 0;        
-        
-        //! Returns the entity id of the execution component
-        virtual AZ::EntityId GetRuntimeEntityId() const = 0;
-                
-        //! Returns a container of nodes
-        virtual AZStd::vector<AZ::EntityId> GetNodes() const = 0;
-        //! Returns a container of connections
-        virtual AZStd::vector<AZ::EntityId> GetConnections() const = 0;
-
-        //! Returns a container of all endpoints to which the supplied endpoint is connected point
-        virtual AZStd::vector<Endpoint> GetConnectedEndpoints(const Endpoint& endpoint) const = 0;
-
-        virtual AZStd::pair< EndpointMapConstIterator, EndpointMapConstIterator > GetConnectedEndpointIterators(const Endpoint& endpoint) const = 0;
-
-        //! Returns whether the given endpoint has any connections
-        virtual bool IsEndpointConnected(const Endpoint& endpoint) const = 0;
-
-        //! Retrieves GraphData structure which manages the nodes and connections of an executing graph
-        virtual GraphData* GetGraphData() = 0;
-        virtual const GraphData* GetGraphDataConst() const = 0;
-
-        //! Retrieves VariableData structure which manages variable data for the execution component
-        virtual VariableData* GetVariableData() = 0;
-        virtual const VariableData* GetVariableDataConst() const = 0;
-
-        //! Retrieves a map of variable id to variable name and variable datums pair
-        virtual const GraphVariableMapping* GetVariables() const = 0;
-
-        //! Searches for a variable with the specified name
-        //! returns pointer to the first variable with the specified name or nullptr
-        virtual GraphVariable* FindVariable(AZStd::string_view varName) = 0;
-
-        //! Searches for a variable by VariableId
-        //! returns a pair of <variable datum pointer, variable name> with the supplied id
-        //! The variable datum pointer is non-null if the variable has been found
-        virtual GraphVariable* FindVariableById(const VariableId& variableId) = 0;
-
-        //! Returns the type associated with the specified variable.
-        virtual Data::Type GetVariableType(const VariableId& variableId) const = 0;
-
-        //! Looks up the variable name that the variable data is associated with in the handler of the bus
-        virtual AZStd::string_view GetVariableName(const VariableId& variableId) const = 0;
-
-        virtual bool IsGraphObserved() const = 0;
-        virtual void SetIsGraphObserved(bool isObserved) = 0;
-
-        virtual AZ::Data::AssetType GetAssetType() const = 0;
-    };
-
-    using RuntimeRequestBus = AZ::EBus<RuntimeRequests>;
-}

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Grammar/AbstractCodeModel.cpp

@@ -2248,17 +2248,6 @@ namespace ScriptCanvas
 
             m_subgraphInterface.SetNamespacePath(m_source.m_namespacePath);
 
-#if defined(FUNCTION_LEGACY_SUPPORT_ENABLED)
-            if (m_source.m_graph->IsFunctionGraph())
-            {
-                m_variableScopeMeaning = VariableScopeMeaning_LegacyFunctions::FunctionPrototype;
-                m_subgraphInterface.MarkAllInputOutputShared();
-            }
-            else
-            {
-                m_variableScopeMeaning = VariableScopeMeaning_LegacyFunctions::ValueInitialization;
-            }
-#endif
             // The Order Matters: begin
 
             // add all data to the ACM for easy look up in input/output processing for ACM nodes

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Grammar/AbstractCodeModel.h

@@ -594,24 +594,6 @@ namespace ScriptCanvas
             void ParseExecutionIfStatementBooleanExpression(ExecutionTreePtr booleanExpressionExecution, AZStd::string executionName, LexicalScope lexicalScope);
 
             void ParseExecutionIfStatementInternalFunction(ExecutionTreePtr internalFunctionExecution);
-
-#if defined(FUNCTION_LEGACY_SUPPORT_ENABLED)
-        public:
-            AZStd::vector<VariablePtr> FindAllVariablesInVariableFlagScope(VariableFlags::Scope scope) const;
-
-            // scrape variables for scope, every Scope::In and InOut 
-            AZStd::vector<VariablePtr> FindSubGraphInputValues() const;
-
-            // scrape variables for scope, every Scope::Out and InOut
-            AZStd::vector<VariablePtr> FindSubGraphOutputValues() const;
-
-            AZStd::vector<VariableConstPtr> GetLocalVariablesUser() const;
-
-            VariableScopeMeaning_LegacyFunctions GetVariableScopeMeaning() const;
-
-        private:
-            VariableScopeMeaning_LegacyFunctions m_variableScopeMeaning = VariableScopeMeaning_LegacyFunctions::ValueInitialization;
-#endif 
         }; // class AbstractCodeModel
 
         template<typename T>

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Grammar/FunctionsLegacySupport.cpp

@@ -1,283 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "PrimitivesDeclarations.h"
-
-#if defined(FUNCTION_LEGACY_SUPPORT_ENABLED)
-
-#include <AzCore/Asset/AssetManager.h>
-#include <AzCore/std/containers/unordered_map.h>
-#include <AzFramework/StringFunc/StringFunc.h>
-#include <ScriptCanvas/Asset/RuntimeAsset.h>
-#include <ScriptCanvas/Core/Datum.h>
-#include <ScriptCanvas/Core/EBusHandler.h>
-#include <ScriptCanvas/Core/Graph.h>
-#include <ScriptCanvas/Core/GraphData.h>
-#include <ScriptCanvas/Core/ModifiableDatumView.h>
-#include <ScriptCanvas/Core/Nodeable.h>
-#include <ScriptCanvas/Core/NodeableNode.h>
-#include <ScriptCanvas/Core/NodeableNodeOverloaded.h>
-#include <ScriptCanvas/Core/ScriptCanvasBus.h>
-#include <ScriptCanvas/Core/SlotNames.h>
-#include <ScriptCanvas/Core/SubgraphInterfaceUtility.h>
-#include <ScriptCanvas/Debugger/ValidationEvents/DataValidation/ScopedDataConnectionEvent.h>
-#include <ScriptCanvas/Debugger/ValidationEvents/ParsingValidation/ParsingValidations.h>
-#include <ScriptCanvas/Execution/RuntimeComponent.h>
-#include <ScriptCanvas/Grammar/ParsingMetaData.h>
-#include <ScriptCanvas/Libraries/Core/AzEventHandler.h>
-#include <ScriptCanvas/Libraries/Core/EBusEventHandler.h>
-#include <ScriptCanvas/Libraries/Core/FunctionDefinitionNode.h>
-#include <ScriptCanvas/Libraries/Core/ExtractProperty.h>
-#include <ScriptCanvas/Libraries/Core/ForEach.h>
-#include <ScriptCanvas/Libraries/Core/FunctionCallNode.h>
-#include <ScriptCanvas/Libraries/Core/Method.h>
-#include <ScriptCanvas/Libraries/Core/MethodUtility.h>
-#include <ScriptCanvas/Libraries/Core/Start.h>
-#include <ScriptCanvas/Translation/TranslationUtilities.h>
-#include <ScriptCanvas/Utils/VersionConverters.h>
-#include <ScriptCanvas/Variable/GraphVariableManagerComponent.h>
-#include <ScriptCanvas/Variable/VariableBus.h>
-#include <ScriptCanvas/Variable/VariableData.h>
-#include <ScriptEvents/ScriptEventsAsset.h>
-#include <ScriptEvents/ScriptEventsBus.h>
-
-#include "AbstractCodeModel.h"
-#include "FunctionsLegacySupport.h"
-#include "GrammarContextBus.h"
-#include "ParsingUtilities.h"
-#include "Primitives.h"
-
-namespace ScriptCanvas
-{
-    namespace Grammar
-    {
-
-        void AbstractCodeModel::AddAllVariablesPreParse_LegacyFunctions()
-        {
-            // all variables assumed to be NOT persistent - in the live code they are reset when activated
-            // variables with no scope In/Out is assumed to be persistent, this is a mess with tick handlers
-            // warn on any variable attempted to be read before written 
-            AZ_Assert(m_variableScopeMeaning == VariableScopeMeaning_LegacyFunctions::FunctionPrototype, "new graph type added without full support");
-            auto& sourceVariables = m_source.m_variableData->GetVariables();
-
-            AZStd::set<const GraphVariable*, GraphVariable::Comparator> sortedVariables;
-            for (const auto& variablePair : sourceVariables)
-            {
-                sortedVariables.insert(&variablePair.second);
-            }
-
-            for (auto& sourceVariable : sortedVariables)
-            {
-                auto datum = sourceVariable->GetDatum();
-                AZ_Assert(datum != nullptr, "the datum must be valid");
-                AddVariable(*datum, sourceVariable->GetVariableName(), sourceVariable->GetVariableId());
-            }
-        }
-
-        AZStd::vector<VariablePtr> AbstractCodeModel::FindSubGraphInputValues() const
-        {
-            return FindAllVariablesInVariableFlagScope(VariableFlags::Scope::Input);
-        }
-
-        AZStd::vector<VariablePtr> AbstractCodeModel::FindSubGraphOutputValues() const
-        {
-            return FindAllVariablesInVariableFlagScope(VariableFlags::Scope::Output);
-        }
-
-        AZStd::vector<VariablePtr> AbstractCodeModel::FindAllVariablesInVariableFlagScope(VariableFlags::Scope scope) const
-        {
-            AZStd::vector<VariablePtr> variables;
-            auto& sourceVariables = m_source.m_variableData->GetVariables();
-
-            for (auto& variable : m_variables)
-            {
-                if (IsSourceInScope(variable, scope))
-                {
-                    variables.push_back(variable);
-                }
-            }
-
-            // sort by variable id
-            AZStd::sort(variables.begin(), variables.end(), [](const auto& lhs, const auto& rhs) { return lhs->m_sourceVariableId < rhs->m_sourceVariableId; });
-            return variables;
-        }
-
-        AZStd::vector<VariableConstPtr> AbstractCodeModel::GetLocalVariablesUser() const
-        {
-            AZStd::vector<VariableConstPtr> userLocalVariables;
-
-            if (m_variableScopeMeaning == VariableScopeMeaning_LegacyFunctions::FunctionPrototype)
-            {
-                for (auto variable : m_variables)
-                {
-                    if (!variable->m_isMember
-                        && variable->m_sourceVariableId.IsValid()
-                        && !IsSourceInScope(variable, VariableFlags::Scope::Input)
-                        && !IsSourceInScope(variable, VariableFlags::Scope::Output))
-                    {
-                        userLocalVariables.push_back(variable);
-                    }
-                }
-            }
-
-            return userLocalVariables;
-        }
-
-        VariableScopeMeaning_LegacyFunctions AbstractCodeModel::GetVariableScopeMeaning() const
-        {
-            return m_variableScopeMeaning;
-        }
-
-        bool SubgraphInterface::IsAllInputOutputShared() const
-        {
-            return m_isAllInputOutputShared;
-        }
-
-        void SubgraphInterface::MarkAllInputOutputShared()
-        {
-            m_isAllInputOutputShared = true;
-        }
-    } // namespace Grammar
-
-    namespace Nodes
-    {
-        namespace Core
-        {
-            void FunctionCallNode::BuildNodeFromSubgraphInterface
-            (const AZ::Data::Asset<ScriptCanvas::SubgraphInterfaceAsset>& runtimeAsset
-                , const SlotExecution::Map& previousMap)
-            {
-                // build the node here, from the asset topology, take the node/variable ordering from the function runtime data as a suggestion
-                // deal with updates and conversions after
-                const Grammar::SubgraphInterface& subgraphInterface = runtimeAsset.Get()->m_runtimeData.m_interface;
-                m_prettyName = runtimeAsset.Get()->m_runtimeData.m_name;
-
-                if (!subgraphInterface.IsAllInputOutputShared())
-                {
-                    AZ_Error("ScriptCanvas", false, "the current assumption is that there is no way to distinguish between the input/output of different nodelings");
-                    return;
-                }
-
-                // for now, all outputs are shared
-                Grammar::Outputs outputs;
-                bool sharedOutputInitialized = false;
-
-                SlotExecution::Ins slotMapIns;
-                SlotExecution::Outs slotMapLatents;
-
-                int slotOffset = 0;
-
-                // add all ins->outs, in their display groups
-                for (size_t indexIn = 0; indexIn < subgraphInterface.GetInCount(); ++indexIn)
-                {
-                    const Grammar::In& interfaceIn = subgraphInterface.GetIn(indexIn);
-
-                    SlotExecution::In slotMapIn = AddExecutionInSlotFromInterface(interfaceIn, slotOffset++, previousMap.FindInSlotIdBySource(interfaceIn.sourceID));
-                    if (!slotMapIn.slotId.IsValid())
-                    {
-                        AZ_Error("ScriptCanvas", false, "Failed to add Execution In slot from sub graph interface");
-                        return;
-                    }
-                    slotMapIn.inputs = AddDataInputSlotFromInterface(interfaceIn.inputs, interfaceIn.sourceID, interfaceIn.displayName, previousMap, slotOffset);
-                    for (auto& input : slotMapIn.inputs)
-                    {
-                        if (!input.slotId.IsValid())
-                        {
-                            AZ_Error("ScriptCanvas", false, "Failed to add Input slot from sub graph interface");
-                            return;
-                        }
-                    }
-
-                    for (auto& interfaceOut : interfaceIn.outs)
-                    {
-                        SlotExecution::Out slotMapOut = AddExecutionOutSlotFromInterface(interfaceIn, interfaceOut, slotOffset++, previousMap.FindOutSlotIdBySource(interfaceIn.sourceID, interfaceOut.sourceID));
-                        if (!slotMapOut.slotId.IsValid())
-                        {
-                            AZ_Error("ScriptCanvas", false, "Failed to add Execution Out slot from sub graph interface");
-                            return;
-                        }
-                        if (!sharedOutputInitialized)
-                        {
-                            outputs = interfaceOut.outputs;
-                            sharedOutputInitialized = true;
-                        }
-
-                        slotMapIn.outs.push_back(slotMapOut);
-                    }
-
-                    slotMapIns.push_back(slotMapIn);
-                }
-
-                // add all latents in their display groups
-                for (size_t indexLatent = 0; indexLatent < subgraphInterface.GetLatentOutCount(); ++indexLatent)
-                {
-                    const Grammar::Out& interfaceLatent = subgraphInterface.GetLatentOut(indexLatent);
-
-                    SlotExecution::Out slotMapLatentOut = AddExecutionLatentOutSlotFromInterface(interfaceLatent, slotOffset++, previousMap.FindLatentSlotIdBySource(interfaceLatent.sourceID));
-                    if (!slotMapLatentOut.slotId.IsValid())
-                    {
-                        AZ_Error("ScriptCanvas", false, "Failed to add Latent Out slot from sub graph interface");
-                        return;
-                    }
-                    slotMapLatentOut.returnValues.values = AddDataInputSlotFromInterface(interfaceLatent.returnValues, interfaceLatent.sourceID, interfaceLatent.displayName, previousMap, slotOffset);
-                    for (auto& input : slotMapLatentOut.returnValues.values)
-                    {
-                        if (!input.slotId.IsValid())
-                        {
-                            AZ_Error("ScriptCanvas", false, "Failed to add Input slot from sub graph interface");
-                            return;
-                        }
-                    }
-
-                    if (!sharedOutputInitialized)
-                    {
-                        outputs = interfaceLatent.outputs;
-                        sharedOutputInitialized = true;
-                    }
-
-                    slotMapLatents.push_back(slotMapLatentOut);
-                }
-
-                // add all outputs one time, since they are currently all required to be part of all the signatures [\todo must fix] , in a variable display group
-                SlotExecution::Outputs slotMapOutputs = AddDataOutputSlotFromInterface(outputs, "", previousMap, slotOffset);
-                for (auto& output : slotMapOutputs)
-                {
-                    if (!output.slotId.IsValid())
-                    {
-                        AZ_Error("ScriptCanvas", false, "Failed to add Output slot from sub graph interface");
-                        return;
-                    }
-                }
-                if (!subgraphInterface.IsLatent())
-                {
-                    for (auto& slotMapIn : slotMapIns)
-                    {
-                        for (auto& slotMapOut : slotMapIn.outs)
-                        {
-                            slotMapOut.outputs = slotMapOutputs;
-                        }
-                    }
-                }
-                else
-                {
-                    for (auto& slotMapLatent : slotMapLatents)
-                    {
-                        slotMapLatent.outputs = slotMapOutputs;
-                    }
-                }
-
-                // when returning variables: sort variables by source slot id, they are sorted in the slot map, so just take them from the slot map
-                m_slotExecutionMap = AZStd::move(SlotExecution::Map(AZStd::move(slotMapIns), AZStd::move(slotMapLatents)));
-                m_slotExecutionMapSourceInterface = subgraphInterface;
-                m_asset = runtimeAsset;
-                SignalSlotsReordered();
-            }
-        } // namespace Core
-    } // namespace Nodes
-}
-
-#endif

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Grammar/FunctionsLegacySupport.h

@@ -1,20 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
- * 
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-namespace ScriptCanvas
-{
-    namespace Grammar
-    {
-        enum class VariableScopeMeaning_LegacyFunctions : AZ::u32
-        {
-            ValueInitialization,
-            FunctionPrototype,
-        };
-    }
-}

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Grammar/PrimitivesDeclarations.h

@@ -19,10 +19,6 @@
 #include <AzCore/std/smart_ptr/shared_ptr.h>
 #include <AzCore/std/string/string.h>
 
-#if defined (FUNCTION_LEGACY_SUPPORT_ENABLED)
-#include "FunctionsLegacySupport.h"
-#endif
-
 namespace AZ
 {
     class ReflectContext;

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodes/BaseTimerNode.cpp

@@ -23,15 +23,6 @@ namespace ScriptCanvas
                 }
             }
             
-            //////////////////
-            // BaseTimerNode
-            //////////////////
-            
-            BaseTimerNode::~BaseTimerNode()
-            {
-                StopTimer();
-            }
-
             void BaseTimerNode::OnInit()
             {
                 AZStd::string slotName = GetTimeSlotName();
@@ -74,11 +65,6 @@ namespace ScriptCanvas
                 AddTimeDataSlot();
             }
             
-            void BaseTimerNode::OnDeactivate()
-            {
-                StopTimer();
-            }
-
             void BaseTimerNode::ConfigureVisualExtensions()
             {
                 {
@@ -103,54 +89,7 @@ namespace ScriptCanvas
 
                 return nullptr;
             }
-            
-            void BaseTimerNode::OnSystemTick()
-            {
-                AZ::SystemTickBus::Handler::BusDisconnect();
-                
-                if (!AZ::TickBus::Handler::BusIsConnected())
-                {
-                    AZ::TickBus::Handler::BusConnect();
-                }
-            }
-               
-            void BaseTimerNode::OnTick(float delta, AZ::ScriptTimePoint)
-            {
-                if (m_timeUnits == TimeUnits::Ticks)
-                {
-                    m_timerCounter += 1;
-                }
-                switch (m_timeUnits)
-                {
-                case TimeUnits::Ticks:
-                    m_timerCounter += 1;
-                    break;
-                case TimeUnits::Milliseconds:
-                case TimeUnits::Seconds:
-                    m_timerCounter += delta;
-                    break;
-                default:
-                    break;
-                }
-
-                while (m_timerCounter > m_timerDuration)
-                {
-                    if (!m_isActive)
-                    {
-                        break;
-                    }
-                    
-                    m_timerCounter -= m_timerDuration;
-                    
-                    OnTimeElapsed();
-                }
-            }
-
-            int BaseTimerNode::GetTickOrder()
-            {
-                return m_tickOrder;
-            }
-            
+                        
             void BaseTimerNode::AddTimeDataSlot()
             {
                 if (!m_timeSlotId.IsValid())
@@ -174,70 +113,6 @@ namespace ScriptCanvas
                 }
             }
                 
-            void BaseTimerNode::StartTimer()
-            {
-                StopTimer();
-                
-                m_isActive = true;
-                
-                const Datum* datum = FindDatum(m_timeSlotId);
-                
-                if (datum)
-                {
-                    const Data::NumberType* timeAmount = datum->GetAs<Data::NumberType>();
-
-                    if (timeAmount)
-                    {
-                        m_timerDuration = (*timeAmount);
-                        m_timerCounter = 0;
-
-                        // Manage the different unit types
-                        if (m_timeUnits == TimeUnits::Ticks)
-                        {
-                            // Remove all of the floating points
-                            m_timerDuration = aznumeric_cast<float>(aznumeric_cast<int>(m_timerDuration));
-                        }
-                        else if (m_timeUnits == TimeUnits::Milliseconds)
-                        {
-                            m_timerDuration /= 1000.0;
-                        }
-                    }
-                }
-
-                if (AZ::TickBus::Handler::BusIsConnected())
-                {
-                    AZ::TickBus::Handler::BusDisconnect();
-                }
-
-                if (AZ::SystemTickBus::Handler::BusIsConnected())
-                {
-                    AZ::SystemTickBus::Handler::BusDisconnect();
-                }
-                
-                if (!AZ::IsClose(m_timerDuration, 0.0, DBL_EPSILON))
-                {
-                    AZ::SystemTickBus::Handler::BusConnect();
-                }
-                else if (AllowInstantResponse())
-                {
-                    while (m_isActive)
-                    {
-                        OnTimeElapsed();
-                    }
-                }
-            }
-            
-            void BaseTimerNode::StopTimer()
-            {
-                m_isActive = false;
-
-                m_timerCounter = 0.0;
-                m_timerDuration = 0.0;
-                
-                AZ::SystemTickBus::Handler::BusDisconnect();
-                AZ::TickBus::Handler::BusDisconnect();
-            }
-
             AZStd::string BaseTimerNode::GetTimeSlotName() const
             {
                 return GetBaseTimeSlotName();
@@ -283,11 +158,7 @@ namespace ScriptCanvas
             {
                 return false;
             }
-            
-            void BaseTimerNode::OnTimeElapsed()
-            {
-            }
-            
+                        
             void BaseTimerNode::ConfigureTimeSlot(DataSlotConfiguration& configuration)
             {
                 AZ_UNUSED(configuration);

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodes/BaseTimerNode.h

@@ -7,10 +7,7 @@
 
 #pragma once
 
-#include <AzCore/Component/TickBus.h>
-
 #include <ScriptCanvas/Core/Node.h>
-
 #include <Include/ScriptCanvas/Internal/Nodes/BaseTimerNode.generated.h>
 
 namespace ScriptCanvas
@@ -23,8 +20,6 @@ namespace ScriptCanvas
             class BaseTimerNode
                 : public Node
                 , public NodePropertyInterfaceListener
-                , public AZ::TickBus::Handler
-                , public AZ::SystemTickBus::Handler
             {
             public:
 
@@ -44,32 +39,16 @@ namespace ScriptCanvas
                     "Seconds"
                 };
                 
-                virtual ~BaseTimerNode();
-
                 // Node...
                 void OnInit() override;
                 void OnConfigured() override;
-                void OnDeactivate() override;
 
                 void ConfigureVisualExtensions() override;
                 NodePropertyInterface* GetPropertyInterface(AZ::Crc32 propertyId) override;
-                ////
-                
-                // SystemTickBus...
-                void OnSystemTick() override;
-                ////
-                
-                // TickBus...
-                void OnTick(float delta, AZ::ScriptTimePoint timePoint) override;
-                int GetTickOrder() override;
-                ////
-                
+                                                
                 // Method that will handle displaying and viewing of the time slot
                 void AddTimeDataSlot();
                 
-                void StartTimer();
-                void StopTimer();
-
                 AZStd::string GetTimeSlotName() const;
 
             protected:
@@ -83,7 +62,6 @@ namespace ScriptCanvas
                 bool IsActive() const;
                 
                 virtual bool AllowInstantResponse() const;
-                virtual void OnTimeElapsed();
 
                 // Store until versioning is complete
                 virtual const char* GetTimeSlotFormat() const { return "Time (%s)";  }
@@ -105,7 +83,7 @@ namespace ScriptCanvas
                 ////
 
                 int m_timeUnits = 0;
-                int m_tickOrder = static_cast<int>(AZ::TICK_DEFAULT);
+                int m_tickOrder = 1000; // from TICK_DEFAULT
                     
                 bool m_isActive = false;
                     

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodes/ExpressionNodeBase.cpp

@@ -112,37 +112,6 @@ namespace ScriptCanvas
                 }
             }
 
-            void ExpressionNodeBase::OnInputSignal(const SlotId& slotId)
-            {
-                if (slotId == ExpressionNodeBaseProperty::GetInSlotId(this))
-                {
-                    for (const SlotId& dirtySlotId : m_dirtyInputs)
-                    {
-                        auto variableIter = m_slotToVariableMap.find(dirtySlotId);
-
-                        if (variableIter != m_slotToVariableMap.end())
-                        {
-                            PushVariable(variableIter->second, (*FindDatum(dirtySlotId)));
-                        }
-                    }
-
-                    m_dirtyInputs.clear();
-
-                    if (m_parseError.IsValidExpression() && m_expressionTree.GetTreeSize() != 0)
-                    {
-                        ExpressionEvaluation::ExpressionResult expressionResult;
-                        ExpressionEvaluation::ExpressionEvaluationRequestBus::BroadcastResult(expressionResult, &ExpressionEvaluation::ExpressionEvaluationRequests::Evaluate, m_expressionTree);
-
-                        OnResult(expressionResult);
-                    }
-                }
-            }
-
-            void ExpressionNodeBase::OnInputChanged([[maybe_unused]] const Datum& input, const SlotId& slotId)
-            {
-                m_dirtyInputs.insert(slotId);
-            }
-
             bool ExpressionNodeBase::CanDeleteSlot([[maybe_unused]] const SlotId& slotId) const
             {
                 return m_handlingExtension;
@@ -474,11 +443,6 @@ namespace ScriptCanvas
                 });
             }
 
-            void ExpressionNodeBase::OnResult([[maybe_unused]] const ExpressionEvaluation::ExpressionResult& result)
-            {
-                AZ_Assert(false, "Implementing node must override OnResult.");
-            }
-
             ExpressionEvaluation::ParseOutcome ExpressionNodeBase::ParseExpression([[maybe_unused]] const AZStd::string& formatString)
             {
                 AZ_Assert(false , "Implementing node must override OnResult.");

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodes/ExpressionNodeBase.h

@@ -37,8 +37,6 @@ namespace ScriptCanvas
                 AZStd::string GetRawFormat() const;
 
                 const AZStd::unordered_map<AZStd::string, SlotId>& GetSlotsByName() const;
-
-                
                                 
             protected:
 
@@ -53,10 +51,6 @@ namespace ScriptCanvas
                 void OnInit() override;  
                 void OnPostActivate() override;
                 void ConfigureVisualExtensions() override;
-
-                void OnInputSignal(const SlotId& slotId) override;
-                void OnInputChanged(const Datum& input, const SlotId& slotId) override;
-
                 bool CanDeleteSlot(const SlotId& slotId) const override;
 
                 SlotId HandleExtension(AZ::Crc32 extensionId) override;
@@ -80,14 +74,11 @@ namespace ScriptCanvas
                 AZ::Crc32 GetPropertyId() const { return AZ_CRC("FormatStringProperty", 0x2c587efa); }
                 
             protected:
-            
-                virtual void OnResult(const ExpressionEvaluation::ExpressionResult& result);
                 virtual ExpressionEvaluation::ParseOutcome ParseExpression(const AZStd::string& formatString);
 
                 virtual AZStd::string GetExpressionSeparator() const;
 
             private:
-
                 void PushVariable(const AZStd::string& variableName, const Datum& datum);
 
                 // NodePropertyInterface...
@@ -110,7 +101,6 @@ namespace ScriptCanvas
                 bool m_isInError = false;
 
                 AZStd::unordered_map<SlotId, AZStd::string> m_slotToVariableMap;
-                AZStd::unordered_set<SlotId> m_dirtyInputs;
                 AZStd::unordered_map<AZStd::string, SlotId> m_slotsByVariables;
 
                 ExpressionEvaluation::ParsingError m_parseError;

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Comparison/EqualTo.h

@@ -41,22 +41,6 @@ namespace ScriptCanvas
                         }
                     }
                 }
-
-            protected:
-                Datum Evaluate(const Datum& lhs, const Datum& rhs) override
-                {
-                    ComparisonOutcome result(lhs == rhs);
-                    
-                    if (result.IsSuccess())
-                    {
-                        return Datum(result.GetValue());
-                    }
-                    else
-                    {
-                        SCRIPTCANVAS_REPORT_ERROR((*this), result.GetError().c_str());
-                        return Datum(false);
-                    }
-                }
             };
 
         }

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Comparison/Greater.h

@@ -40,21 +40,6 @@ namespace ScriptCanvas
                         }
                     }
                 }
-
-            protected:
-                Datum Evaluate(const Datum& lhs, const Datum& rhs) override
-                {
-                    ComparisonOutcome result(lhs >  rhs);
-                    if (result.IsSuccess())
-                    {
-                        return Datum(result.GetValue());
-                    }
-                    else
-                    {
-                        SCRIPTCANVAS_REPORT_ERROR((*this), result.GetError().c_str());
-                        return Datum(false);
-                    }
-                }
             };
 
         }

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Comparison/GreaterEqual.h

@@ -41,21 +41,6 @@ namespace ScriptCanvas
                         }
                     }
                 }
-
-            protected:
-                Datum Evaluate(const Datum& lhs, const Datum& rhs) override
-                {
-                    ComparisonOutcome result(lhs >= rhs);
-                    if (result.IsSuccess())
-                    {
-                        return Datum(result.GetValue());
-                    }
-                    else
-                    {
-                        SCRIPTCANVAS_REPORT_ERROR((*this), result.GetError().c_str());
-                        return Datum(false);
-                    }
-                }
             };
 
         }

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Comparison/Less.h

@@ -40,22 +40,6 @@ namespace ScriptCanvas
                         }
                     }
                 }
-
-            protected:
-                Datum Evaluate(const Datum& lhs, const Datum& rhs) override
-                {
-                    ComparisonOutcome result(lhs < rhs);
-                    
-                    if (result.IsSuccess())
-                    {
-                        return Datum(result.GetValue());
-                    }
-                    else
-                    {
-                        SCRIPTCANVAS_REPORT_ERROR((*this), result.GetError().c_str());
-                        return Datum(false);
-                    }
-                }
             };
 
         }