Merged stabilization/2106 -> development (resolved merge conflicts).
Signed-off-by: Chris Galvan <chgalvan@amazon.com>
This commit is contained in:
Chris Galvan
@@ -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>();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
};
|
||||
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
};
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
};
|
||||
}
|
||||
@@ -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;
|
||||
};
|
||||
}
|
||||
@@ -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>
|
||||
|
||||
@@ -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>();
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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;
|
||||
|
||||
-126
@@ -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");
|
||||
}
|
||||
}
|
||||
-48
@@ -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;
|
||||
};
|
||||
}
|
||||
-2
@@ -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>
|
||||
|
||||
|
||||
-68
@@ -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;
|
||||
|
||||
};
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -37,7 +37,7 @@ namespace ScriptCanvasEditor
|
||||
EBusHandler,
|
||||
EBusHandlerEvent,
|
||||
EBusSender,
|
||||
EntityRef,
|
||||
_deprecated_,
|
||||
VariableNode,
|
||||
SetVariable,
|
||||
GetVariable,
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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__);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
};
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
-3
@@ -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>
|
||||
|
||||
@@ -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.");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
-42
@@ -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
|
||||
///////////////////////////////
|
||||
|
||||
-33
@@ -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
|
||||
|
||||
-2
@@ -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>
|
||||
|
||||
@@ -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)
|
||||
{
|
||||
|
||||
+3
-7
@@ -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();
|
||||
|
||||
|
||||
+1
-5
@@ -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)
|
||||
|
||||
@@ -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>
|
||||
|
||||
|
||||
@@ -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());
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
//////////////////////////
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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)
|
||||
{
|
||||
|
||||
@@ -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");
|
||||
|
||||
Reference in New Issue
Block a user