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

The Great ScriptCanvas Purge, Part V

Browse Source 
Signed-off-by: chcurran <82187351+carlitosan@users.noreply.github.com>
This commit is contained in:
chcurran
2021-07-06 15:05:37 -07:00
parent 360236b89e
commit 0a910a31aa
66 changed files with 24 additions and 1731 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Gems/ScriptCanvas/Code/Asset/EditorAssetSystemComponent.cpp
+1 -1
View File
@@ -28,7 +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/RuntimeFunctionAssetHandler.h>
#include <ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.h>
namespace ScriptCanvasEditor
{
Gems/ScriptCanvas/Code/Asset/RuntimeAssetSystemComponent.cpp
+2 -2
View File
@@ -2,7 +2,7 @@
* 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
*
*s
*/
#include <AzCore/Asset/AssetManager.h>
@@ -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
-27
View File
@@ -102,30 +102,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();
}
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();
@@ -135,15 +114,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
-1
View File
@@ -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
+1 -3
View File
@@ -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
-33
View File
@@ -175,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
+1 -2
View File
@@ -17,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>
Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetHelpers.cpp
+4 -28
View File
@@ -148,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
-154
View File
@@ -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
-46
View File
@@ -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
-57
View File
@@ -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
-70
View File
@@ -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
-234
View File
@@ -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
-1
View File
@@ -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/Components/EditorGraph.cpp
-11
View File
@@ -60,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>
@@ -3127,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
-1
View File
@@ -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
-11
View File
@@ -42,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/FunctionNodeDescriptorComponent.h
-2
View File
@@ -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
-68
View File
@@ -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
-4
View File
@@ -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
-3
View File
@@ -267,9 +267,6 @@ namespace ScriptCanvasEditor
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;
Gems/ScriptCanvas/Code/Editor/Nodes/EditorLibrary.cpp
-56
View File
@@ -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
-32
View File
@@ -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/ScriptCanvasAssetNode.cpp
-200
View File
@@ -1,200 +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::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
-91
View File
@@ -1,91 +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:
// 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
-7
View File
@@ -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);
Gems/ScriptCanvas/Code/Editor/ScriptCanvasEditorGem.cpp
-2
View File
@@ -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>
@@ -118,7 +117,6 @@ namespace ScriptCanvas
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
+2 -14
View File
@@ -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
-3
View File
@@ -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
-68
View File
@@ -1316,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);
@@ -1552,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
-2
View File
@@ -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/ScriptCanvasNodePaletteDockWidget.cpp
+1 -1
View File
@@ -223,7 +223,7 @@ namespace ScriptCanvasEditor
void ScriptCanvasRootPaletteTreeItem::SetActiveScriptCanvasId(const ScriptCanvas::ScriptCanvasId& scriptCanvasId)
{
ScriptCanvas::RuntimeRequestBus::EventResult(m_previousAssetId, scriptCanvasId, &ScriptCanvas::GraphRequests::GetAssetId);
ScriptCanvas::GraphRequestBus::EventResult(m_previousAssetId, scriptCanvasId, &ScriptCanvas::GraphRequests::GetAssetId);
for (auto functionTreePair : m_globalFunctionTreeItems)
{
Gems/ScriptCanvas/Code/Editor/View/Widgets/StatisticsDialog/ScriptCanvasStatisticsDialog.cpp
+3 -7
View File
@@ -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
-3
View File
@@ -1053,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/VariableDockWidget.cpp
+2 -2
View File
@@ -758,7 +758,7 @@ namespace ScriptCanvasEditor
auto owningGraph = ScriptCanvas::GraphRequestBus::FindFirstHandler(m_scriptCanvasId);
if (runtimeRequests == nullptr)
if (owningGraph == nullptr)
{
return;
}
@@ -769,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
+2 -16
View File
@@ -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/Tools/UpgradeTool/UpgradeHelper.cpp
-2
View File
@@ -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
-10
View File
@@ -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
-21
View File
@@ -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/RuntimeFunctionAssetHandler.cpp → Gems/ScriptCanvas/Code/Include/ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.cpp
+1 -1
View File
@@ -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/Asset/Functions/RuntimeFunctionAssetHandler.h → Gems/ScriptCanvas/Code/Include/ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.h
View File
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Graph.cpp
-2
View File
@@ -13,8 +13,6 @@
#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>
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodes/BaseTimerNode.h
+1 -1
View File
@@ -83,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
-5
View File
@@ -443,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
-5
View File
@@ -37,8 +37,6 @@ namespace ScriptCanvas
AZStd::string GetRawFormat() const;
const AZStd::unordered_map<AZStd::string, SlotId>& GetSlotsByName() const;
protected:
@@ -76,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...
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Core/FunctionCallNode.h
-1
View File
@@ -10,7 +10,6 @@
#include <AzCore/Asset/AssetCommon.h>
#include <AzCore/std/containers/unordered_map.h>
#include <AzCore/std/parallel/mutex.h>
#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
#include <ScriptCanvas/Asset/RuntimeAsset.h>
#include <ScriptCanvas/Core/SubgraphInterface.h>
#include <ScriptCanvas/Core/Graph.h>
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Core/Method.cpp
-5
View File
@@ -86,11 +86,6 @@ namespace ScriptCanvas
AZ::Outcome<void, AZStd::string> IsExposable(const AZ::BehaviorMethod& method)
{
if (method.GetNumArguments() > BehaviorContextMethodHelper::MaxCount)
{
return AZ::Failure(AZStd::string("Too many arguments for a Script Canvas method"));
}
for (size_t argIndex(0), sentinel(method.GetNumArguments()); argIndex != sentinel; ++argIndex)
{
if (const AZ::BehaviorParameter* argument = method.GetArgument(argIndex))
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Core/ReceiveScriptEvent.cpp
-11
View File
@@ -177,11 +177,6 @@ namespace ScriptCanvas
m_userData.m_methodDefinition = methodDefinition;
AZ_Assert(!event.m_parameters.empty(), "No parameters in event!");
if (!events[eventIndex].m_function)
{
m_handler->InstallGenericHook(events[eventIndex].m_name, &OnEventGenericHook, &m_userData);
}
if (m_eventMap.find(eventId) == m_eventMap.end())
{
m_eventMap[eventId] = ConfigureEbusEntry(*methodDefinition, event, populationMapping);
@@ -309,12 +304,6 @@ namespace ScriptCanvas
return eBusEventEntry;
}
void ReceiveScriptEvent::OnEventGenericHook(void* userData, const char* eventName, int eventIndex, AZ::BehaviorValueParameter* result, int numParameters, AZ::BehaviorValueParameter* parameters)
{
ReceiveScriptEvent::EventHookUserData* eventHookUserData(reinterpret_cast<ReceiveScriptEvent::EventHookUserData*>(userData));
eventHookUserData->m_handler->OnEvent(eventName, eventIndex, result, numParameters, parameters);
}
void ReceiveScriptEvent::SetAutoConnectToGraphOwner(bool enabled)
{
ScriptCanvas::Slot* connectSlot = ReceiveScriptEventProperty::GetConnectSlot(this);
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Core/ReceiveScriptEvent.h
-1
View File
@@ -42,7 +42,6 @@ namespace ScriptCanvas
~ReceiveScriptEvent() override;
void OnActivate() override;
void OnPostActivate() override;
void OnDeactivate() override;
const AZ::Data::AssetId GetAssetId() const { return m_scriptEventAssetId; }
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Math/MathExpression.cpp
-11
View File
@@ -12,17 +12,6 @@ namespace ScriptCanvas
{
namespace Math
{
void MathExpression::OnResult(const ExpressionEvaluation::ExpressionResult& result)
{
if (result.is<double>())
{
Datum output;
output.Set(AZStd::any_cast<double>(result));
PushOutput(output, (*MathExpressionProperty::GetResultSlot(this)));
SignalOutput(MathExpressionProperty::GetOutSlotId(this));
}
}
ExpressionEvaluation::ParseOutcome MathExpression::ParseExpression(const AZStd::string& formatString)
{
const AZStd::unordered_set<ExpressionEvaluation::ExpressionParserId> mathInterfaceSet = {
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Math/MathExpression.h
-1
View File
@@ -37,7 +37,6 @@ namespace ScriptCanvas
return AZ::Success(GetSlotsByType(targetSlotType));
}
void OnResult(const ExpressionEvaluation::ExpressionResult& result) override;
ExpressionEvaluation::ParseOutcome ParseExpression(const AZStd::string& formatString) override;
AZStd::string GetExpressionSeparator() const override;
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Operators/Containers/OperatorBack.h
-2
View File
@@ -35,9 +35,7 @@ namespace ScriptCanvas
void ConfigureContracts(SourceType sourceType, AZStd::vector<ContractDescriptor>& contractDescs) override;
void OnSourceTypeChanged() override;
void InvokeOperator();
};
}
}
}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Operators/Containers/OperatorFront.h
-2
View File
@@ -35,9 +35,7 @@ namespace ScriptCanvas
void ConfigureContracts(SourceType sourceType, AZStd::vector<ContractDescriptor>& contractDescs) override;
void OnSourceTypeChanged() override;
void InvokeOperator();
};
}
}
}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Operators/Math/OperatorArithmetic.cpp
-14
View File
@@ -207,20 +207,6 @@ namespace ScriptCanvas
AZ_UNUSED(dataType);
}
void OperatorArithmetic::InvokeOperator()
{
if (!m_result.GetType().IsValid())
{
return;
}
Evaluate(m_applicableInputs, m_result);
PushOutput(m_result, (*m_resultSlot));
SignalOutput(m_outSlot);
}
SlotId OperatorArithmetic::CreateSlot(AZStd::string_view name, AZStd::string_view toolTip, ConnectionType connectionType)
{
DynamicDataSlotConfiguration slotConfiguration;
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Operators/Math/OperatorArithmetic.h
+1 -2
View File
@@ -100,8 +100,7 @@ namespace ScriptCanvas
virtual void Operator(Data::eType type, const ArithmeticOperands& operands, Datum& result);
virtual void InitializeSlot(const SlotId& slotId, const Data::Type& dataType);
virtual void InvokeOperator();
//////////////////////////////////////////////////////////////////////////
// Translation
AZ::Outcome<DependencyReport, void> GetDependencies() const override;
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/Timer.cpp
-5
View File
@@ -20,11 +20,6 @@ namespace ScriptCanvas
, m_seconds(0.f)
, m_milliseconds(0.f)
{}
void Timer::OnDeactivate()
{
AZ::TickBus::Handler::BusDisconnect();
}
}
}
}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/Timer.h
-5
View File
@@ -34,11 +34,6 @@ namespace ScriptCanvas
float m_seconds;
float m_milliseconds;
protected:
AZ::ScriptTimePoint m_start;
void OnDeactivate() override;
};
}
}
Gems/ScriptCanvas/Code/Source/ScriptCanvasCommonGem.cpp
-2
View File
@@ -20,7 +20,6 @@
#include <ScriptCanvas/Libraries/Libraries.h>
#include <ScriptCanvas/Libraries/Math/MathNodeUtilities.h>
#include <ScriptCanvas/Variable/GraphVariableManagerComponent.h>
#include <ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h>
namespace ScriptCanvas
{
@@ -41,7 +40,6 @@ namespace ScriptCanvas
ScriptCanvas::Node::CreateDescriptor(),
ScriptCanvas::Debugger::ServiceComponent::CreateDescriptor(),
ScriptCanvas::Graph::CreateDescriptor(),
ScriptCanvasEditor::ScriptCanvasFunctionDataComponent::CreateDescriptor(),
ScriptCanvas::GraphVariableManagerComponent::CreateDescriptor(),
ScriptCanvas::RuntimeComponent::CreateDescriptor(),
Gems/ScriptCanvas/Code/scriptcanvasgem_common_files.cmake
+2 -3
View File
@@ -25,9 +25,8 @@ set(FILES
Include/ScriptCanvas/Asset/RuntimeAssetHandler.h
Include/ScriptCanvas/Asset/ScriptCanvasAssetBase.h
Include/ScriptCanvas/Asset/ScriptCanvasAssetData.h
Include/ScriptCanvas/Asset/Functions/ScriptCanvasFunctionAsset.h
Include/ScriptCanvas/Asset/Functions/RuntimeFunctionAssetHandler.cpp
Include/ScriptCanvas/Asset/Functions/RuntimeFunctionAssetHandler.h
Include/ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.cpp
Include/ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.h
Include/ScriptCanvas/Core/ScriptCanvasBus.h
Include/ScriptCanvas/Core/ExecutionNotificationsBus.cpp
Include/ScriptCanvas/Core/ExecutionNotificationsBus.h
Gems/ScriptCanvas/Code/scriptcanvasgem_editor_builder_files.cmake
-1
View File
@@ -14,5 +14,4 @@ set(FILES
Builder/ScriptCanvasBuilderWorker.cpp
Builder/ScriptCanvasBuilderWorker.h
Builder/ScriptCanvasBuilderWorkerUtility.cpp
Builder/ScriptCanvasFunctionBuilderWorker.cpp
)
Gems/ScriptCanvas/Code/scriptcanvasgem_editor_files.cmake
-11
View File
@@ -21,8 +21,6 @@ set(FILES
Editor/Assets/ScriptCanvasAssetHelpers.h
Editor/Assets/ScriptCanvasAssetHelpers.cpp
Editor/Assets/ScriptCanvasAssetTrackerDefinitions.h
Editor/Include/ScriptCanvas/Assets/Functions/ScriptCanvasFunctionAssetHandler.h
Editor/Assets/Functions/ScriptCanvasFunctionAssetHandler.cpp
Editor/Include/ScriptCanvas/Assets/ScriptCanvasAsset.h
Editor/Assets/ScriptCanvasAsset.cpp
Editor/Include/ScriptCanvas/Assets/ScriptCanvasAssetBus.h
@@ -31,11 +29,6 @@ set(FILES
Editor/Assets/ScriptCanvasAssetHandler.cpp
Editor/Assets/ScriptCanvasAssetHolder.h
Editor/Assets/ScriptCanvasAssetHolder.cpp
Editor/Assets/ScriptCanvasAssetInstance.h
Editor/Assets/ScriptCanvasAssetInstance.cpp
Editor/Assets/ScriptCanvasAssetReference.h
Editor/Assets/ScriptCanvasAssetReference.cpp
Editor/Assets/ScriptCanvasAssetReferenceContainer.h
Editor/Assets/ScriptCanvasMemoryAsset.h
Editor/Assets/ScriptCanvasMemoryAsset.cpp
Editor/Assets/ScriptCanvasUndoHelper.h
@@ -127,16 +120,12 @@ set(FILES
Editor/Model/LibraryDataModel.cpp
Editor/Model/UnitTestBrowserFilterModel.h
Editor/Model/UnitTestBrowserFilterModel.cpp
Editor/Nodes/EditorLibrary.h
Editor/Nodes/EditorLibrary.cpp
Editor/Nodes/NodeCreateUtils.h
Editor/Nodes/NodeCreateUtils.cpp
Editor/Nodes/NodeDisplayUtils.h
Editor/Nodes/NodeDisplayUtils.cpp
Editor/Nodes/NodeUtils.h
Editor/Nodes/NodeUtils.cpp
Editor/Nodes/ScriptCanvasAssetNode.h
Editor/Nodes/ScriptCanvasAssetNode.cpp
Editor/Translation/TranslationHelper.h
Editor/Undo/ScriptCanvasGraphCommand.cpp
Editor/Undo/ScriptCanvasGraphCommand.h
Gems/ScriptCanvasDeveloper/Code/Editor/Source/EditorAutomation/EditorAutomationActions/ScriptCanvasActions/GraphActions.cpp
-13
View File
@@ -73,19 +73,6 @@ namespace ScriptCanvasDeveloper
{
return AZ::Failure<AZStd::string>("Active graph is not the newly created graph.");
}
else
{
ScriptCanvas::ScriptCanvasId scriptCanvasId;
ScriptCanvasEditor::GeneralRequestBus::BroadcastResult(scriptCanvasId, &ScriptCanvasEditor::GeneralRequests::GetScriptCanvasId, activeGraphCanvasId);
bool isRuntimeGraph = false;
ScriptCanvasEditor::EditorGraphRequestBus::EventResult(isRuntimeGraph, scriptCanvasId, &ScriptCanvasEditor::EditorGraphRequests::IsRuntimeGraph);
if (!isRuntimeGraph)
{
return AZ::Failure<AZStd::string>("Created a new Graph, but graph is not of type Runtime Graph.");
}
}
}
return CompoundAction::GenerateReport();
Gems/ScriptCanvasDeveloper/Code/Editor/Source/EditorAutomationTests/GraphCreationTests.cpp
-13
View File
@@ -75,19 +75,6 @@ namespace ScriptCanvasDeveloper
{
ReportError("Active graph is not the newly created graph using hotkey.");
}
else
{
ScriptCanvas::ScriptCanvasId scriptCanvasId;
ScriptCanvasEditor::GeneralRequestBus::BroadcastResult(scriptCanvasId, &ScriptCanvasEditor::GeneralRequests::GetScriptCanvasId, activeGraphCanvasId);
bool isRuntimeGraph = false;
ScriptCanvasEditor::EditorGraphRequestBus::EventResult(isRuntimeGraph, scriptCanvasId, &ScriptCanvasEditor::EditorGraphRequests::IsRuntimeGraph);
if (!isRuntimeGraph)
{
ReportError("Failed to create Runtime graph using button");
}
}
}
GraphCanvas::AssetEditorNotificationBus::Handler::BusDisconnect();
Gems/ScriptCanvasTesting/Code/Platform/Common/MSVC/scriptcanvastesting_editor_tests_msvc.cmake
-1
View File
@@ -8,7 +8,6 @@
ly_add_source_properties(
SOURCES
Source/Framework/ScriptCanvasTestUtilities.cpp
Tests/ScriptCanvas_Async.cpp
Tests/ScriptCanvas_BehaviorContext.cpp
Tests/ScriptCanvas_ContainerSupport.cpp
Tests/ScriptCanvas_Core.cpp
Gems/ScriptCanvasTesting/Code/Tests/ScriptCanvas_Async.cpp
-316
View File
@@ -1,316 +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 <AzCore/PlatformDef.h>
#include <AzCore/Component/ComponentApplicationBus.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <Source/Framework/ScriptCanvasTestFixture.h>
#include <Source/Framework/ScriptCanvasTestUtilities.h>
#include <ScriptCanvas/Core/SlotConfigurationDefaults.h>
using namespace ScriptCanvasTests;
using namespace ScriptCanvasEditor;
// Asynchronous ScriptCanvas Behaviors
#if AZ_COMPILER_MSVC
#include <future>
class AsyncEvent : public AZ::EBusTraits
{
public:
//////////////////////////////////////////////////////////////////////////
// EBusTraits overrides
static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
using BusIdType = AZ::EntityId;
using MutexType = AZStd::recursive_mutex;
static const bool LocklessDispatch = true;
//////////////////////////////////////////////////////////////////////////
virtual void OnAsyncEvent() = 0;
};
using AsyncEventNotificationBus = AZ::EBus<AsyncEvent>;
class LongRunningProcessSimulator3000
{
public:
static void Run(const AZ::EntityId& listener)
{
int duration = 40;
while (--duration > 0)
{
AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(10));
}
AsyncEventNotificationBus::Event(listener, &AsyncEvent::OnAsyncEvent);
}
};
class AsyncNode
: public ScriptCanvas::Node
, protected AsyncEventNotificationBus::Handler
, protected AZ::TickBus::Handler
{
public:
AZ_COMPONENT(AsyncNode, "{0A7FF6C6-878B-42EC-A8BB-4D29C4039853}", ScriptCanvas::Node);
bool IsEntryPoint() const { return true; }
AsyncNode()
: Node()
{}
static void Reflect(AZ::ReflectContext* reflection)
{
AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(reflection);
if (serializeContext)
{
serializeContext->Class<AsyncNode, Node>()
->Version(1)
;
}
}
void ConfigureSlots() override
{
AddSlot(ScriptCanvas::CommonSlots::GeneralInSlot());
AddSlot(ScriptCanvas::CommonSlots::GeneralOutSlot());
}
void OnActivate() override
{
ScriptCanvasTestFixture::s_asyncOperationActive = true;
AZ::TickBus::Handler::BusConnect();
AsyncEventNotificationBus::Handler::BusConnect(GetEntityId());
std::packaged_task<void()> task([this]() { LongRunningProcessSimulator3000::Run(GetEntityId()); }); // wrap the function
m_eventThread = AZStd::make_shared<AZStd::thread>(AZStd::move(task)); // launch on a thread
}
void OnDeactivate() override
{
if (m_eventThread)
{
m_eventThread->join();
m_eventThread.reset();
}
// We've received the event, no longer need the bus connection
AsyncEventNotificationBus::Handler::BusDisconnect();
// We're done, kick it out.
SignalOutput(GetSlotId("Out"));
// Disconnect from tick bus as well
AZ::TickBus::Handler::BusDisconnect();
}
virtual void HandleAsyncEvent()
{
EXPECT_GT(m_duration, 0.f);
Shutdown();
}
void OnAsyncEvent() override
{
HandleAsyncEvent();
}
void Shutdown()
{
ScriptCanvasTestFixture::s_asyncOperationActive = false;
}
void OnTick(float deltaTime, AZ::ScriptTimePoint) override
{
AZ_TracePrintf("Debug", "Awaiting async operation: %.2f\n", m_duration);
m_duration += deltaTime;
}
protected:
AZStd::shared_ptr<AZStd::thread> m_eventThread;
private:
double m_duration = 0.f;
};
TEST_F(ScriptCanvasTestFixture, Asynchronous_Behaviors)
{
using namespace ScriptCanvas;
RegisterComponentDescriptor<AsyncNode>();
// Make the graph.
ScriptCanvas::Graph* graph =nullptr;
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
ASSERT_TRUE(graph != nullptr);
AZ::Entity* graphEntity = graph->GetEntity();
graphEntity->Init();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
AZ::Entity* startEntity{ aznew AZ::Entity };
startEntity->Init();
AZ::EntityId startNodeId;
CreateTestNode<ScriptCanvas::Nodes::Core::Start>(graphUniqueId, startNodeId);
AZ::EntityId asyncNodeId;
CreateTestNode<AsyncNode>(graphUniqueId, asyncNodeId);
EXPECT_TRUE(Connect(*graph, startNodeId, ScriptCanvas::CommonSlots::GeneralOutSlot::GetName(), asyncNodeId, ScriptCanvas::CommonSlots::GeneralInSlot::GetName()));
{
ScopedOutputSuppression supressOutput;
graphEntity->Activate();
// Tick the TickBus while the graph entity is active
while (ScriptCanvasTestFixture::s_asyncOperationActive)
{
AZ::TickBus::ExecuteQueuedEvents();
AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(100));
AZ::TickBus::Broadcast(&AZ::TickEvents::OnTick, 0.01f, AZ::ScriptTimePoint(AZStd::chrono::system_clock::now()));
}
}
graphEntity->Deactivate();
delete graphEntity;
}
///////////////////////////////////////////////////////////////////////////////
namespace
{
// Fibonacci solver, used to compare against the graph version.
long ComputeFibonacci(int digits)
{
int a = 0;
int b = 1;
long sum = 0;
for (int i = 0; i < digits - 2; ++i)
{
sum = a + b;
a = b;
b = sum;
}
return sum;
}
}
class AsyncFibonacciComputeNode
: public AsyncNode
{
public:
AZ_COMPONENT(AsyncFibonacciComputeNode, "{B198F52D-708C-414B-BB90-DFF0462D7F03}", AsyncNode);
AsyncFibonacciComputeNode()
: AsyncNode()
{}
bool IsEntryPoint() const { return true; }
static const int k_numberOfFibonacciDigits = 64;
static void Reflect(AZ::ReflectContext* reflection)
{
AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(reflection);
if (serializeContext)
{
serializeContext->Class<AsyncFibonacciComputeNode, AsyncNode>()
->Version(1)
;
}
}
void OnActivate() override
{
AZ::TickBus::Handler::BusConnect();
AsyncEventNotificationBus::Handler::BusConnect(GetEntityId());
int digits = k_numberOfFibonacciDigits;
std::promise<long> p;
m_computeFuture = p.get_future();
m_eventThread = AZStd::make_shared<AZStd::thread>([this, digits, p = AZStd::move(p)]() mutable
{
p.set_value(ComputeFibonacci(digits));
AsyncEventNotificationBus::Event(GetEntityId(), &AsyncEvent::OnAsyncEvent);
});
}
void HandleAsyncEvent() override
{
m_result = m_computeFuture.get();
EXPECT_EQ(m_result, ComputeFibonacci(k_numberOfFibonacciDigits));
}
void OnTick(float deltaTime, AZ::ScriptTimePoint) override
{
AZ_TracePrintf("Debug", "Awaiting async fib operation: %.2f\n", m_duration);
m_duration += deltaTime;
if (m_result != 0)
{
Shutdown();
}
}
private:
std::future<long> m_computeFuture;
long m_result = 0;
double m_duration = 0.f;
};
TEST_F(ScriptCanvasTestFixture, ComputeFibonacciAsyncGraphTest)
{
using namespace ScriptCanvas;
RegisterComponentDescriptor<AsyncNode>();
RegisterComponentDescriptor<AsyncFibonacciComputeNode>();
// Make the graph.
ScriptCanvas::Graph* graph =nullptr;
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
ASSERT_NE(graph, nullptr);
AZ::Entity* graphEntity = graph->GetEntity();
graphEntity->Init();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
AZ::EntityId startNodeId;
CreateTestNode<ScriptCanvas::Nodes::Core::Start>(graphUniqueId, startNodeId);
AZ::EntityId asyncNodeId;
CreateTestNode<AsyncFibonacciComputeNode>(graphUniqueId, asyncNodeId);
EXPECT_TRUE(Connect(*graph, startNodeId, "Out", asyncNodeId, "In"));
graphEntity->Activate();
// Tick the TickBus while the graph entity is active
while (ScriptCanvasTestFixture::s_asyncOperationActive)
{
AZ::TickBus::ExecuteQueuedEvents();
AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(100));
AZ::TickBus::Broadcast(&AZ::TickEvents::OnTick, 0.01f, AZ::ScriptTimePoint(AZStd::chrono::system_clock::now()));
}
graphEntity->Deactivate();
delete graphEntity;
}
#endif // AZ_COMPILER_MSVC
Gems/ScriptCanvasTesting/Code/scriptcanvastestingeditor_tests_files.cmake
-1
View File
@@ -15,7 +15,6 @@ set(FILES
Source/Framework/ScriptCanvasTestApplication.h
Source/Framework/EntityRefTests.h
Tests/ScriptCanvasTestingTest.cpp
Tests/ScriptCanvas_Async.cpp
Tests/ScriptCanvas_BehaviorContext.cpp
Tests/ScriptCanvas_ContainerSupport.cpp
Tests/ScriptCanvas_Core.cpp