You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1331 lines
67 KiB
C++
1331 lines
67 KiB
C++
/*
|
|
* Copyright (c) Contributors to the Open 3D Engine Project.
|
|
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
*
|
|
*/
|
|
|
|
#include <AzCore/RTTI/BehaviorContextUtilities.h>
|
|
|
|
#include <Editor/Components/IconComponent.h>
|
|
#include <Editor/GraphCanvas/PropertySlotIds.h>
|
|
#include <Editor/Nodes/NodeDisplayUtils.h>
|
|
|
|
#include <GraphCanvas/Components/DynamicOrderingDynamicSlotComponent.h>
|
|
#include <GraphCanvas/Components/MappingComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/AzEventHandlerNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/ClassMethodNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/EBusHandlerEventNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/EBusHandlerNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/EBusSenderNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/FunctionNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/GetVariableNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/NodelingDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/SetVariableNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/ScriptEventReceiverEventNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/ScriptEventReceiverNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/ScriptEventSenderNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/UserDefinedNodeDescriptorComponent.h>
|
|
#include <GraphCanvas/Components/NodeDescriptors/FunctionDefinitionNodeDescriptorComponent.h>
|
|
|
|
#include <GraphCanvas/Components/Nodes/NodeTitleBus.h>
|
|
#include <GraphCanvas/GraphCanvasBus.h>
|
|
#include <GraphCanvas/Components/Slots/Extender/ExtenderSlotBus.h>
|
|
|
|
#include <ScriptCanvas/Bus/EditorScriptCanvasBus.h>
|
|
#include <ScriptCanvas/Core/Node.h>
|
|
#include <ScriptCanvas/Libraries/Core/AzEventHandler.h>
|
|
#include <ScriptCanvas/Libraries/Core/EBusEventHandler.h>
|
|
#include <ScriptCanvas/Libraries/Core/FunctionDefinitionNode.h>
|
|
#include <ScriptCanvas/Libraries/Core/FunctionCallNode.h>
|
|
#include <ScriptCanvas/Libraries/Core/GetVariable.h>
|
|
#include <ScriptCanvas/Libraries/Core/ReceiveScriptEvent.h>
|
|
#include <ScriptCanvas/Libraries/Core/Method.h>
|
|
#include <ScriptCanvas/Libraries/Core/SendScriptEvent.h>
|
|
#include <ScriptCanvas/Libraries/Core/SetVariable.h>
|
|
|
|
namespace ScriptCanvasEditor::Nodes::SlotDisplayHelper
|
|
{
|
|
AZ::EntityId DisplayPropertySlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::VisualExtensionSlotConfiguration& propertyConfiguration);
|
|
AZ::EntityId DisplayExtendableSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::VisualExtensionSlotConfiguration& extenderConfiguration);
|
|
AZ::EntityId DisplayVisualExtensionSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::VisualExtensionSlotConfiguration& extensionConfiguration);
|
|
}
|
|
|
|
namespace ScriptCanvasEditor::Nodes
|
|
{
|
|
// Handles the creation of a node through the node configurations for most nodes.
|
|
AZ::EntityId DisplayGeneralScriptCanvasNode(AZ::EntityId, const ScriptCanvas::Node* node, const NodeConfiguration& nodeConfiguration)
|
|
{
|
|
AZ_PROFILE_FUNCTION(ScriptCanvas);
|
|
|
|
AZ::Entity* graphCanvasEntity = nullptr;
|
|
|
|
if (nodeConfiguration.m_nodeType == NodeType::GeneralNode)
|
|
{
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(graphCanvasEntity, &GraphCanvas::GraphCanvasRequests::CreateGeneralNode, nodeConfiguration.m_nodeSubStyle.c_str());
|
|
}
|
|
else if (nodeConfiguration.m_nodeType == NodeType::WrapperNode)
|
|
{
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(graphCanvasEntity, &GraphCanvas::GraphCanvasRequests::CreateWrapperNode, nodeConfiguration.m_nodeSubStyle.c_str());
|
|
}
|
|
|
|
AZ_Assert(graphCanvasEntity, "Unable to create GraphCanvas Bus Node");
|
|
|
|
if (graphCanvasEntity == nullptr)
|
|
{
|
|
return AZ::EntityId();
|
|
}
|
|
|
|
for (const AZ::Uuid& componentId : nodeConfiguration.m_customComponents)
|
|
{
|
|
graphCanvasEntity->CreateComponent(componentId);
|
|
}
|
|
|
|
// Apply SceneMember remapping if ScriptCanvasId is valid.
|
|
if (nodeConfiguration.m_scriptCanvasId.IsValid())
|
|
{
|
|
graphCanvasEntity->CreateComponent<SceneMemberMappingComponent>(nodeConfiguration.m_scriptCanvasId);
|
|
graphCanvasEntity->CreateComponent<SlotMappingComponent>(nodeConfiguration.m_scriptCanvasId);
|
|
}
|
|
|
|
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, graphCanvasEntity->GetId(), &GraphCanvas::NodeRequests::GetUserData);
|
|
|
|
if (graphCanvasUserData)
|
|
{
|
|
*graphCanvasUserData = node->GetEntityId();
|
|
}
|
|
|
|
GraphCanvas::TranslationKeyedString nodeKeyedString(nodeConfiguration.m_titleFallback, nodeConfiguration.m_translationContext);
|
|
nodeKeyedString.m_key = TranslationHelper::GetKey(nodeConfiguration.m_translationGroup, nodeConfiguration.m_translationKeyContext, nodeConfiguration.m_translationKeyName, TranslationItemType::Node, TranslationKeyId::Name);
|
|
|
|
AZStd::string nodeName = nodeKeyedString.GetDisplayString();
|
|
|
|
int paramIndex = 0;
|
|
int outputIndex = 0;
|
|
|
|
// Create the GraphCanvas slots
|
|
for (const auto& slot : node->GetSlots())
|
|
{
|
|
if (slot.IsVisible())
|
|
{
|
|
AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasEntity->GetId(), slot);
|
|
|
|
GraphCanvas::TranslationKeyedString slotNameKeyedString(slot.GetName(), nodeKeyedString.m_context);
|
|
GraphCanvas::TranslationKeyedString slotTooltipKeyedString(slot.GetToolTip(), nodeKeyedString.m_context);
|
|
|
|
TranslationItemType itemType = TranslationHelper::GetItemType(slot.GetDescriptor());
|
|
|
|
if (itemType == TranslationItemType::ParamDataSlot || itemType == TranslationItemType::ReturnDataSlot)
|
|
{
|
|
int& index = (itemType == TranslationItemType::ParamDataSlot) ? paramIndex : outputIndex;
|
|
|
|
slotNameKeyedString.m_key = TranslationHelper::GetKey(nodeConfiguration.m_translationGroup, nodeConfiguration.m_translationKeyContext, nodeConfiguration.m_translationKeyName, itemType, TranslationKeyId::Name, index);
|
|
slotTooltipKeyedString.m_key = TranslationHelper::GetKey(nodeConfiguration.m_translationGroup, nodeConfiguration.m_translationKeyContext, nodeConfiguration.m_translationKeyName, itemType, TranslationKeyId::Tooltip, index);
|
|
index++;
|
|
}
|
|
|
|
GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotNameKeyedString);
|
|
GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTooltipKeyedString);
|
|
}
|
|
}
|
|
|
|
const auto& visualExtensions = node->GetVisualExtensions();
|
|
|
|
for (const auto& extensionConfiguration : visualExtensions)
|
|
{
|
|
SlotDisplayHelper::DisplayVisualExtensionSlot(graphCanvasEntity->GetId(), extensionConfiguration);
|
|
}
|
|
|
|
GraphCanvas::TranslationKeyedString subtitleKeyedString(nodeConfiguration.m_subtitleFallback, nodeConfiguration.m_translationContext);
|
|
subtitleKeyedString.m_key = TranslationHelper::GetKey(nodeConfiguration.m_translationGroup, nodeConfiguration.m_translationKeyContext, nodeConfiguration.m_translationKeyName, TranslationItemType::Node, TranslationKeyId::Category);
|
|
|
|
graphCanvasEntity->SetName(AZStd::string::format("GC-Node(%s)", nodeKeyedString.GetDisplayString().c_str()));
|
|
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeKeyedString);
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeTitleRequests::SetTranslationKeyedSubTitle, subtitleKeyedString);
|
|
|
|
if (!nodeConfiguration.m_titlePalette.empty())
|
|
{
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeTitleRequests::SetPaletteOverride, nodeConfiguration.m_titlePalette);
|
|
}
|
|
|
|
// Set the name
|
|
GraphCanvas::TranslationKeyedString tooltipKeyedString(nodeConfiguration.m_tooltipFallback, nodeConfiguration.m_translationContext);
|
|
tooltipKeyedString.m_key = TranslationHelper::GetKey(TranslationContextGroup::ClassMethod, nodeConfiguration.m_translationKeyContext, nodeConfiguration.m_translationKeyName, TranslationItemType::Node, TranslationKeyId::Tooltip);
|
|
|
|
GraphCanvas::NodeRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeRequests::SetTranslationKeyedTooltip, tooltipKeyedString);
|
|
|
|
EditorNodeNotificationBus::Event(node->GetEntityId(), &EditorNodeNotifications::OnGraphCanvasNodeDisplayed, graphCanvasEntity->GetId());
|
|
|
|
return graphCanvasEntity->GetId();
|
|
}
|
|
|
|
AZ::EntityId DisplayNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Node* node, StyleConfiguration styleConfiguration = StyleConfiguration())
|
|
{
|
|
NodeConfiguration nodeConfiguration;
|
|
|
|
nodeConfiguration.PopulateComponentDescriptors<IconComponent, UserDefinedNodeDescriptorComponent>();
|
|
|
|
if (node->RequiresDynamicSlotOrdering())
|
|
{
|
|
nodeConfiguration.PopulateComponentDescriptors<DynamicOrderingDynamicSlotComponent>();
|
|
}
|
|
else
|
|
{
|
|
nodeConfiguration.PopulateComponentDescriptors<DynamicSlotComponent>();
|
|
}
|
|
|
|
nodeConfiguration.m_nodeSubStyle = styleConfiguration.m_nodeSubStyle;
|
|
nodeConfiguration.m_titlePalette = styleConfiguration.m_titlePalette;
|
|
nodeConfiguration.m_scriptCanvasId = node->GetEntityId();
|
|
|
|
AZ::SerializeContext* serializeContext = nullptr;
|
|
AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);
|
|
|
|
AZ_Assert(serializeContext, "Failed to acquire application serialize context.");
|
|
const AZ::SerializeContext::ClassData* classData = serializeContext->FindClassData(azrtti_typeid(node));
|
|
|
|
if (classData)
|
|
{
|
|
AZStd::string nodeContext = GetContextName(*classData);
|
|
nodeConfiguration.m_translationContext = TranslationHelper::GetUserDefinedContext(nodeContext);
|
|
|
|
nodeConfiguration.m_titleFallback = (classData->m_editData && classData->m_editData->m_name) ? classData->m_editData->m_name : classData->m_name;
|
|
nodeConfiguration.m_tooltipFallback = (classData->m_editData && classData->m_editData->m_description) ? classData->m_editData->m_description : "";
|
|
|
|
GraphCanvas::TranslationKeyedString subtitleKeyedString(nodeContext, nodeConfiguration.m_translationContext);
|
|
subtitleKeyedString.m_key = TranslationHelper::GetUserDefinedNodeKey(nodeContext, nodeConfiguration.m_titleFallback, ScriptCanvasEditor::TranslationKeyId::Category);
|
|
|
|
nodeConfiguration.m_subtitleFallback = subtitleKeyedString.GetDisplayString();
|
|
|
|
nodeConfiguration.m_translationKeyName = nodeConfiguration.m_titleFallback;
|
|
nodeConfiguration.m_translationKeyContext = nodeContext;
|
|
|
|
nodeConfiguration.m_translationGroup = TranslationContextGroup::ClassMethod;
|
|
|
|
if (classData->m_editData)
|
|
{
|
|
const AZ::Edit::ElementData* elementData = classData->m_editData->FindElementData(AZ::Edit::ClassElements::EditorData);
|
|
|
|
if (elementData)
|
|
{
|
|
if (auto nodeTypeAttribute = elementData->FindAttribute(ScriptCanvas::Attributes::Node::NodeType))
|
|
{
|
|
if (auto nodeTypeAttributeData = azdynamic_cast<const AZ::Edit::AttributeData<NodeType>*>(nodeTypeAttribute))
|
|
{
|
|
nodeConfiguration.m_nodeType = nodeTypeAttributeData->Get(nullptr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return DisplayGeneralScriptCanvasNode(graphCanvasGraphId, node, nodeConfiguration);
|
|
}
|
|
|
|
static void ConfigureGeneralScriptCanvasEntity(const ScriptCanvas::Node* node, AZ::Entity* graphCanvasEntity, const GraphCanvas::SlotGroup& slotGroup = GraphCanvas::SlotGroups::Invalid)
|
|
{
|
|
if (node->RequiresDynamicSlotOrdering())
|
|
{
|
|
graphCanvasEntity->CreateComponent<DynamicOrderingDynamicSlotComponent>(slotGroup);
|
|
}
|
|
else
|
|
{
|
|
graphCanvasEntity->CreateComponent<DynamicSlotComponent>(slotGroup);
|
|
}
|
|
}
|
|
|
|
AZ::EntityId DisplayMethodNode(AZ::EntityId, const ScriptCanvas::Nodes::Core::Method* methodNode)
|
|
{
|
|
AZ::EntityId graphCanvasNodeId;
|
|
|
|
AZ::Entity* graphCanvasEntity = nullptr;
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(graphCanvasEntity, &GraphCanvas::GraphCanvasRequests::CreateGeneralNode, ".method");
|
|
AZ_Error("GraphCanvas", graphCanvasEntity, "Unable to create GraphCanvas Node");
|
|
|
|
if (graphCanvasEntity)
|
|
{
|
|
graphCanvasNodeId = graphCanvasEntity->GetId();
|
|
}
|
|
|
|
// Add the icon component
|
|
ConfigureGeneralScriptCanvasEntity(methodNode, graphCanvasEntity);
|
|
graphCanvasEntity->CreateComponent<IconComponent>(ScriptCanvas::Nodes::Core::Method::RTTI_Type());
|
|
graphCanvasEntity->CreateComponent<SlotMappingComponent>(methodNode->GetEntityId());
|
|
graphCanvasEntity->CreateComponent<SceneMemberMappingComponent>(methodNode->GetEntityId());
|
|
|
|
TranslationContextGroup contextGroup = TranslationContextGroup::Invalid;
|
|
|
|
switch (methodNode->GetMethodType())
|
|
{
|
|
case ScriptCanvas::MethodType::Event:
|
|
graphCanvasEntity->CreateComponent<EBusSenderNodeDescriptorComponent>();
|
|
contextGroup = TranslationContextGroup::EbusSender;
|
|
break;
|
|
case ScriptCanvas::MethodType::Member:
|
|
case ScriptCanvas::MethodType::Getter:
|
|
case ScriptCanvas::MethodType::Setter:
|
|
case ScriptCanvas::MethodType::Free:
|
|
graphCanvasEntity->CreateComponent<ClassMethodNodeDescriptorComponent>();
|
|
contextGroup = TranslationContextGroup::ClassMethod;
|
|
break;
|
|
default:
|
|
AZ_Error("ScriptCanvas", false, "Invalid method node type, node creation failed. This node needs to be deleted.");
|
|
break;
|
|
}
|
|
|
|
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 = methodNode->GetEntityId();
|
|
}
|
|
|
|
const AZStd::string& className = methodNode->GetMethodClassName();
|
|
const AZStd::string& methodName = methodNode->GetName();
|
|
|
|
AZStd::string translationContext = TranslationHelper::GetContextName(contextGroup, className);
|
|
|
|
GraphCanvas::TranslationKeyedString nodeKeyedString(methodName, translationContext);
|
|
nodeKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, TranslationItemType::Node, TranslationKeyId::Name);
|
|
|
|
GraphCanvas::TranslationKeyedString classKeyedString(className, translationContext);
|
|
classKeyedString.m_key = TranslationHelper::GetClassKey(contextGroup, className, TranslationKeyId::Name);
|
|
|
|
GraphCanvas::TranslationKeyedString tooltipKeyedString(AZStd::string(), translationContext);
|
|
tooltipKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, TranslationItemType::Node, TranslationKeyId::Tooltip);
|
|
|
|
int paramIndex = 0;
|
|
int outputIndex = 0;
|
|
|
|
auto busId = methodNode->GetBusSlotId();
|
|
for (const auto& slot : methodNode->GetSlots())
|
|
{
|
|
if (slot.IsVisible())
|
|
{
|
|
AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot);
|
|
|
|
GraphCanvas::TranslationKeyedString slotNameKeyedString(slot.GetName(), translationContext);
|
|
GraphCanvas::TranslationKeyedString slotTooltipKeyedString(slot.GetToolTip(), translationContext);
|
|
|
|
if (methodNode->HasBusID() && busId == slot.GetId() && slot.GetDescriptor() == ScriptCanvas::SlotDescriptors::DataIn())
|
|
{
|
|
slotNameKeyedString = TranslationHelper::GetEBusSenderBusIdNameKey();
|
|
slotTooltipKeyedString = TranslationHelper::GetEBusSenderBusIdTooltipKey();
|
|
}
|
|
else
|
|
{
|
|
TranslationItemType itemType = TranslationHelper::GetItemType(slot.GetDescriptor());
|
|
|
|
int& index = (itemType == TranslationItemType::ParamDataSlot) ? paramIndex : outputIndex;
|
|
|
|
slotNameKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, itemType, TranslationKeyId::Name, index);
|
|
slotTooltipKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, itemType, TranslationKeyId::Tooltip, index);
|
|
|
|
if ((itemType == TranslationItemType::ParamDataSlot) || (itemType == TranslationItemType::ReturnDataSlot))
|
|
{
|
|
index++;
|
|
}
|
|
}
|
|
|
|
GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotNameKeyedString);
|
|
GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTooltipKeyedString);
|
|
|
|
CopyTranslationKeyedNameToDatumLabel(graphCanvasNodeId, slot.GetId(), graphCanvasSlotId);
|
|
}
|
|
}
|
|
|
|
// Set the name
|
|
AZStd::string displayName = methodNode->GetName();
|
|
graphCanvasEntity->SetName(AZStd::string::format("GC-Node(%s)", displayName.c_str()));
|
|
|
|
GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTranslationKeyedTooltip, tooltipKeyedString);
|
|
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeKeyedString);
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedSubTitle, classKeyedString);
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetPaletteOverride, "MethodNodeTitlePalette");
|
|
|
|
// Override the title if it has the Setter or Getter suffixes
|
|
AZStd::string title;
|
|
GraphCanvas::NodeTitleRequestBus::EventResult(title, graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::GetTitle);
|
|
if (!title.empty())
|
|
{
|
|
AZ::RemovePropertyNameArtifacts(title);
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTitle, title);
|
|
|
|
}
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
AZ::EntityId DisplayEbusWrapperNode(AZ::EntityId, const ScriptCanvas::Nodes::Core::EBusEventHandler* busNode)
|
|
{
|
|
AZ::Entity* graphCanvasEntity = nullptr;
|
|
|
|
AZStd::string busName = busNode->GetEBusName();
|
|
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(graphCanvasEntity, &GraphCanvas::GraphCanvasRequests::CreateWrapperNode, "");
|
|
AZ_Assert(graphCanvasEntity, "Unable to create GraphCanvas Node");
|
|
|
|
AZ::EntityId graphCanvasNodeId = graphCanvasEntity->GetId();
|
|
|
|
// Add the icon component
|
|
graphCanvasEntity->CreateComponent<IconComponent>(ScriptCanvas::Nodes::Core::EBusEventHandler::RTTI_Type());
|
|
graphCanvasEntity->CreateComponent<EBusHandlerNodeDescriptorComponent>(busName);
|
|
graphCanvasEntity->CreateComponent<SlotMappingComponent>(busNode->GetEntityId());
|
|
graphCanvasEntity->CreateComponent<SceneMemberMappingComponent>(busNode->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 = busNode->GetEntityId();
|
|
}
|
|
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, SlotGroups::EBusConnectionSlotGroup, GraphCanvas::SlotGroupConfiguration(0));
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::DataGroup, GraphCanvas::SlotGroupConfiguration(1));
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::ExecutionGroup, GraphCanvas::SlotGroupConfiguration(2));
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::SetDividersEnabled, false);
|
|
|
|
AZStd::vector< ScriptCanvas::SlotId > scriptCanvasSlots = busNode->GetNonEventSlotIds();
|
|
|
|
for (const auto& slotId : scriptCanvasSlots)
|
|
{
|
|
ScriptCanvas::Slot* slot = busNode->GetSlot(slotId);
|
|
|
|
GraphCanvas::SlotGroup group = GraphCanvas::SlotGroups::Invalid;
|
|
|
|
if (slot->GetDescriptor().IsExecution())
|
|
{
|
|
group = SlotGroups::EBusConnectionSlotGroup;
|
|
}
|
|
|
|
if (slot->IsVisible())
|
|
{
|
|
AZ::EntityId gcSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, (*slot), group);
|
|
|
|
if (busNode->IsIDRequired() && slot->GetDescriptor() == ScriptCanvas::SlotDescriptors::DataIn())
|
|
{
|
|
GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusHandlerBusIdNameKey());
|
|
GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusHandlerBusIdTooltipKey());
|
|
}
|
|
}
|
|
}
|
|
|
|
GraphCanvas::TranslationKeyedString nodeKeyedString(busName);
|
|
nodeKeyedString.m_context = TranslationHelper::GetEbusHandlerContext(busName);
|
|
nodeKeyedString.m_key = TranslationHelper::GetEbusHandlerKey(busName, TranslationKeyId::Name);
|
|
|
|
GraphCanvas::TranslationKeyedString tooltipKeyedString(AZStd::string(), nodeKeyedString.m_context);
|
|
tooltipKeyedString.m_key = TranslationHelper::GetEbusHandlerKey(busName, TranslationKeyId::Tooltip);
|
|
|
|
// Set the name
|
|
graphCanvasEntity->SetName(AZStd::string::format("GC-BusNode: %s", busName.data()));
|
|
|
|
GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTranslationKeyedTooltip, tooltipKeyedString);
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeKeyedString);
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetDefaultPalette, "HandlerWrapperNodeTitlePalette");
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
AZ::EntityId DisplayEbusEventNode(AZ::EntityId, const AZStd::string& busName, const AZStd::string& eventName, const ScriptCanvas::EBusEventId& eventId)
|
|
{
|
|
AZ_PROFILE_FUNCTION(ScriptCanvas);
|
|
|
|
AZ::EntityId graphCanvasNodeId;
|
|
|
|
AZ::Entity* graphCanvasEntity = nullptr;
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(graphCanvasEntity, &GraphCanvas::GraphCanvasRequests::CreateGeneralNode, ".handler");
|
|
AZ_Assert(graphCanvasEntity, "Unable to create GraphCanvas Node");
|
|
graphCanvasNodeId = graphCanvasEntity->GetId();
|
|
|
|
graphCanvasEntity->CreateComponent<EBusHandlerEventNodeDescriptorComponent>(busName, eventName, eventId);
|
|
graphCanvasEntity->CreateComponent<SlotMappingComponent>();
|
|
|
|
graphCanvasEntity->Init();
|
|
graphCanvasEntity->Activate();
|
|
|
|
AZStd::string decoratedName = AZStd::string::format("%s::%s", busName.c_str(), eventName.c_str());
|
|
|
|
GraphCanvas::TranslationKeyedString nodeKeyedString(eventName);
|
|
nodeKeyedString.m_context = TranslationHelper::GetEbusHandlerContext(busName);
|
|
nodeKeyedString.m_key = TranslationHelper::GetEbusHandlerEventKey(busName, eventName, TranslationKeyId::Name);
|
|
|
|
GraphCanvas::TranslationKeyedString tooltipKeyedString(AZStd::string(), nodeKeyedString.m_context);
|
|
tooltipKeyedString.m_key = TranslationHelper::GetEbusHandlerEventKey(busName, eventName, TranslationKeyId::Tooltip);
|
|
|
|
// Set the name
|
|
graphCanvasEntity->SetName(AZStd::string::format("GC-Node(%s)", decoratedName.c_str()));
|
|
|
|
GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTranslationKeyedTooltip, tooltipKeyedString);
|
|
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeKeyedString);
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetPaletteOverride, "HandlerNodeTitlePalette");
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
AZ::EntityId DisplayAzEventHandlerNode(AZ::EntityId, const ScriptCanvas::Nodes::Core::AzEventHandler* azEventNode)
|
|
{
|
|
AZ::Entity* graphCanvasEntity{};
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(graphCanvasEntity, &GraphCanvas::GraphCanvasRequests::CreateGeneralNode, ".azeventhandler");
|
|
AZ_Assert(graphCanvasEntity, "Unable to create GraphCanvas Node");
|
|
|
|
AZ::EntityId graphCanvasNodeId = graphCanvasEntity->GetId();
|
|
|
|
const ScriptCanvas::Nodes::Core::AzEventEntry& azEventEntry{ azEventNode->GetEventEntry() };
|
|
// Add the icon component
|
|
graphCanvasEntity->CreateComponent<IconComponent>(azrtti_typeid<ScriptCanvas::Nodes::Core::AzEventHandler>());
|
|
graphCanvasEntity->CreateComponent<AzEventHandlerNodeDescriptorComponent>(azEventEntry.m_eventName);
|
|
graphCanvasEntity->CreateComponent<SlotMappingComponent>(azEventNode->GetEntityId());
|
|
graphCanvasEntity->CreateComponent<SceneMemberMappingComponent>(azEventNode->GetEntityId());
|
|
graphCanvasEntity->Init();
|
|
graphCanvasEntity->Activate();
|
|
|
|
// Set the user data on the GraphCanvas node to be the EntityId of the ScriptCanvas node
|
|
AZStd::any* graphCanvasUserData = {};
|
|
GraphCanvas::NodeRequestBus::EventResult(graphCanvasUserData, graphCanvasNodeId, &GraphCanvas::NodeRequests::GetUserData);
|
|
if (graphCanvasUserData)
|
|
{
|
|
*graphCanvasUserData = azEventNode->GetEntityId();
|
|
}
|
|
|
|
for (const ScriptCanvas::Slot& slot: azEventNode->GetSlots())
|
|
{
|
|
GraphCanvas::SlotGroup group = GraphCanvas::SlotGroups::Invalid;
|
|
|
|
if (slot.IsVisible())
|
|
{
|
|
AZ::EntityId gcSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot, group);
|
|
if (slot.GetId() == azEventEntry.m_azEventInputSlotId)
|
|
{
|
|
GraphCanvas::TranslationKeyedString slotTranslationEntry(azEventEntry.m_eventName);
|
|
slotTranslationEntry.m_context = TranslationHelper::GetAzEventHandlerContextKey();
|
|
// The translation key in this case acts like a json pointer referencing a particular
|
|
// json string within a hypothetical json document
|
|
AZ::StackedString azEventHandlerNodeKey = TranslationHelper::GetAzEventHandlerRootPointer(azEventEntry.m_eventName);
|
|
|
|
azEventHandlerNodeKey.Push("Name");
|
|
slotTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
|
|
GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotTranslationEntry);
|
|
azEventHandlerNodeKey.Pop();
|
|
azEventHandlerNodeKey.Push("Tooltip");
|
|
slotTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
|
|
GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTranslationEntry);
|
|
}
|
|
else
|
|
{
|
|
GraphCanvas::TranslationKeyedString slotTranslationEntry(slot.GetName());
|
|
slotTranslationEntry.m_context = TranslationHelper::GetAzEventHandlerContextKey();
|
|
// The translation key in this case acts like a json pointer referencing a particular
|
|
// json string within a hypothetical json document
|
|
// translation key is rooted at /AzEventHandler/${EventName}/Slots/${SlotName}/{In,Out,Param,Return}
|
|
AZ::StackedString azEventHandlerNodeKey = TranslationHelper::GetAzEventHandlerRootPointer(azEventEntry.m_eventName);
|
|
azEventHandlerNodeKey.Push("Slots");
|
|
azEventHandlerNodeKey.Push(slot.GetName());
|
|
switch(TranslationHelper::GetItemType(slot.GetDescriptor()))
|
|
{
|
|
case TranslationItemType::ExecutionInSlot:
|
|
azEventHandlerNodeKey.Push("In");
|
|
break;
|
|
case TranslationItemType::ExecutionOutSlot:
|
|
azEventHandlerNodeKey.Push("Out");
|
|
break;
|
|
case TranslationItemType::ParamDataSlot:
|
|
azEventHandlerNodeKey.Push("Param");
|
|
break;
|
|
case TranslationItemType::ReturnDataSlot:
|
|
azEventHandlerNodeKey.Push("Return");
|
|
break;
|
|
default:
|
|
// Slot is not an execution or data slot, do nothing
|
|
break;
|
|
}
|
|
|
|
azEventHandlerNodeKey.Push("Name");
|
|
slotTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
|
|
GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotTranslationEntry);
|
|
azEventHandlerNodeKey.Pop();
|
|
azEventHandlerNodeKey.Push("Tooltip");
|
|
slotTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
|
|
GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTranslationEntry);
|
|
}
|
|
}
|
|
}
|
|
|
|
GraphCanvas::TranslationKeyedString nodeTranslationEntry(azEventEntry.m_eventName);
|
|
nodeTranslationEntry.m_context = TranslationHelper::GetAzEventHandlerContextKey();
|
|
// The translation key in this case acts like a json pointer referencing a particular
|
|
// json string within a hypothetical json document
|
|
AZ::StackedString azEventHandlerNodeKey = TranslationHelper::GetAzEventHandlerRootPointer(azEventEntry.m_eventName);
|
|
azEventHandlerNodeKey.Push("Name");
|
|
nodeTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeTranslationEntry);
|
|
azEventHandlerNodeKey.Pop();
|
|
azEventHandlerNodeKey.Push("Tooltip");
|
|
nodeTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
|
|
GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTranslationKeyedTooltip, nodeTranslationEntry);
|
|
|
|
// Set the name
|
|
graphCanvasEntity->SetName(AZStd::string::format("GC-EventNode: %s", azEventEntry.m_eventName.c_str()));
|
|
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetPaletteOverride, "HandlerNodeTitlePalette");
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
AZ::EntityId DisplayScriptEventWrapperNode(AZ::EntityId, const ScriptCanvas::Nodes::Core::ReceiveScriptEvent* busNode)
|
|
{
|
|
AZ::Entity* graphCanvasEntity = nullptr;
|
|
|
|
const AZ::Data::AssetId assetId = busNode->GetAssetId();
|
|
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(graphCanvasEntity, &GraphCanvas::GraphCanvasRequests::CreateWrapperNode, "");
|
|
AZ_Assert(graphCanvasEntity, "Unable to create GraphCanvas Node");
|
|
|
|
AZ::EntityId graphCanvasNodeId = graphCanvasEntity->GetId();
|
|
|
|
// Add the icon component
|
|
ConfigureGeneralScriptCanvasEntity(busNode, graphCanvasEntity);
|
|
graphCanvasEntity->CreateComponent<IconComponent>(ScriptCanvas::Nodes::Core::ReceiveScriptEvent::RTTI_Type());
|
|
graphCanvasEntity->CreateComponent<ScriptEventReceiverNodeDescriptorComponent>(assetId);
|
|
graphCanvasEntity->CreateComponent<SlotMappingComponent>(busNode->GetEntityId());
|
|
graphCanvasEntity->CreateComponent<SceneMemberMappingComponent>(busNode->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 = busNode->GetEntityId();
|
|
}
|
|
|
|
AZ::Data::Asset<ScriptEvents::ScriptEventsAsset> asset = AZ::Data::AssetManager::Instance().GetAsset<ScriptEvents::ScriptEventsAsset>(assetId, AZ::Data::AssetLoadBehavior::PreLoad);
|
|
asset.BlockUntilLoadComplete();
|
|
if (asset.GetStatus() == AZ::Data::AssetData::AssetStatus::Error)
|
|
{
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
const ScriptEvents::ScriptEvent& definition = asset.Get()->m_definition;
|
|
|
|
AZStd::string busName = definition.GetName();
|
|
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, SlotGroups::EBusConnectionSlotGroup, GraphCanvas::SlotGroupConfiguration(0));
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::DataGroup, GraphCanvas::SlotGroupConfiguration(1));
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::ExecutionGroup, GraphCanvas::SlotGroupConfiguration(2));
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::SetDividersEnabled, false);
|
|
|
|
AZStd::vector< ScriptCanvas::SlotId > scriptCanvasSlots = busNode->GetNonEventSlotIds();
|
|
|
|
for (const auto& slotId : scriptCanvasSlots)
|
|
{
|
|
ScriptCanvas::Slot* slot = busNode->GetSlot(slotId);
|
|
|
|
GraphCanvas::SlotGroup group = GraphCanvas::SlotGroups::Invalid;
|
|
|
|
if (slot->GetDescriptor().IsExecution())
|
|
{
|
|
group = SlotGroups::EBusConnectionSlotGroup;
|
|
}
|
|
|
|
if (slot->IsVisible())
|
|
{
|
|
AZ::EntityId gcSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, (*slot), group);
|
|
|
|
if (busNode->IsIDRequired() && slot->GetDescriptor() == ScriptCanvas::SlotDescriptors::DataIn())
|
|
{
|
|
GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusHandlerBusIdNameKey());
|
|
GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusHandlerBusIdTooltipKey());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set the name
|
|
graphCanvasEntity->SetName(AZStd::string::format("GC-BusNode: %s", busName.data()));
|
|
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetDefaultPalette, "HandlerWrapperNodeTitlePalette");
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
AZ::EntityId DisplayScriptEventNode(AZ::EntityId, const AZ::Data::AssetId assetId, const ScriptEvents::Method& methodDefinition)
|
|
{
|
|
AZ_PROFILE_FUNCTION(ScriptCanvas);
|
|
|
|
AZ::EntityId graphCanvasNodeId;
|
|
|
|
AZ::Entity* graphCanvasEntity = nullptr;
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(graphCanvasEntity, &GraphCanvas::GraphCanvasRequests::CreateGeneralNode, ".handler");
|
|
AZ_Assert(graphCanvasEntity, "Unable to create GraphCanvas Node");
|
|
graphCanvasNodeId = graphCanvasEntity->GetId();
|
|
|
|
graphCanvasEntity->CreateComponent<ScriptEventReceiverEventNodeDescriptorComponent>(assetId, methodDefinition);
|
|
graphCanvasEntity->CreateComponent<SlotMappingComponent>();
|
|
graphCanvasEntity->CreateComponent<DynamicSlotComponent>();
|
|
|
|
graphCanvasEntity->Init();
|
|
graphCanvasEntity->Activate();
|
|
|
|
AZStd::string eventName = methodDefinition.GetName();
|
|
|
|
AZ::Data::Asset<ScriptEvents::ScriptEventsAsset> asset = AZ::Data::AssetManager::Instance().GetAsset<ScriptEvents::ScriptEventsAsset>(assetId, AZ::Data::AssetLoadBehavior::PreLoad);
|
|
asset.BlockUntilLoadComplete();
|
|
|
|
const AZStd::string& busName = asset.Get()->m_definition.GetName();
|
|
AZStd::string decoratedName = AZStd::string::format("%s::%s", busName.data(), eventName.c_str());
|
|
|
|
// Set the name
|
|
graphCanvasEntity->SetName(AZStd::string::format("GC-Node(%s)", decoratedName.c_str()));
|
|
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetPaletteOverride, "HandlerNodeTitlePalette");
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
AZ::EntityId DisplayScriptEventSenderNode(AZ::EntityId, const ScriptCanvas::Nodes::Core::SendScriptEvent* senderNode)
|
|
{
|
|
AZ::EntityId graphCanvasNodeId;
|
|
|
|
AZ::Entity* graphCanvasEntity = nullptr;
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(graphCanvasEntity, &GraphCanvas::GraphCanvasRequests::CreateGeneralNode, ".method");
|
|
AZ_Error("GraphCanvas", graphCanvasEntity, "Unable to create GraphCanvas Node");
|
|
|
|
if (graphCanvasEntity)
|
|
{
|
|
graphCanvasNodeId = graphCanvasEntity->GetId();
|
|
}
|
|
|
|
// Add the icon component
|
|
ConfigureGeneralScriptCanvasEntity(senderNode, graphCanvasEntity);
|
|
graphCanvasEntity->CreateComponent<IconComponent>(ScriptCanvas::Nodes::Core::Method::RTTI_Type());
|
|
graphCanvasEntity->CreateComponent<SlotMappingComponent>(senderNode->GetEntityId());
|
|
graphCanvasEntity->CreateComponent<SceneMemberMappingComponent>(senderNode->GetEntityId());
|
|
|
|
TranslationContextGroup contextGroup = TranslationContextGroup::Invalid;
|
|
|
|
graphCanvasEntity->CreateComponent<ScriptEventSenderNodeDescriptorComponent>(senderNode->GetAssetId(), senderNode->GetEventId());
|
|
contextGroup = TranslationContextGroup::EbusSender;
|
|
|
|
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 = senderNode->GetEntityId();
|
|
}
|
|
|
|
AZ::Data::Asset<ScriptEvents::ScriptEventsAsset> asset = AZ::Data::AssetManager::Instance().GetAsset<ScriptEvents::ScriptEventsAsset>(senderNode->GetAssetId(), AZ::Data::AssetLoadBehavior::PreLoad);
|
|
asset.BlockUntilLoadComplete();
|
|
|
|
if (asset.GetStatus() == AZ::Data::AssetData::AssetStatus::Error)
|
|
{
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
for (const auto& slot : senderNode->GetSlots())
|
|
{
|
|
if (slot.IsVisible())
|
|
{
|
|
AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot);
|
|
|
|
GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetName, slot.GetName());
|
|
GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTooltip, slot.GetToolTip());
|
|
|
|
CopyTranslationKeyedNameToDatumLabel(graphCanvasNodeId, slot.GetId(), graphCanvasSlotId);
|
|
}
|
|
}
|
|
|
|
// Set the name
|
|
AZStd::string displayName = senderNode->GetEventName();
|
|
graphCanvasEntity->SetName(AZStd::string::format("GC-Node(%s)", displayName.c_str()));
|
|
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetPaletteOverride, "MethodNodeTitlePalette");
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
// Function Nodes
|
|
AZ::EntityId DisplayFunctionNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::FunctionCallNode* functionNode)
|
|
{
|
|
return DisplayFunctionNode(graphCanvasGraphId, const_cast<ScriptCanvas::Nodes::Core::FunctionCallNode*>(functionNode));
|
|
}
|
|
|
|
AZ::EntityId DisplayFunctionNode(AZ::EntityId, ScriptCanvas::Nodes::Core::FunctionCallNode* functionNode)
|
|
{
|
|
AZ::EntityId graphCanvasNodeId;
|
|
|
|
AZ::Entity* graphCanvasEntity = nullptr;
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(graphCanvasEntity, &GraphCanvas::GraphCanvasRequests::CreateGeneralNode, ".method");
|
|
AZ_Error("GraphCanvas", graphCanvasEntity, "Unable to create GraphCanvas Node");
|
|
|
|
if (graphCanvasEntity)
|
|
{
|
|
graphCanvasNodeId = graphCanvasEntity->GetId();
|
|
}
|
|
|
|
auto asset = functionNode->GetAsset();
|
|
|
|
// Add the icon component
|
|
ConfigureGeneralScriptCanvasEntity(functionNode, graphCanvasEntity);
|
|
|
|
graphCanvasEntity->CreateComponent<IconComponent>(ScriptCanvas::Nodes::Core::Method::RTTI_Type());
|
|
graphCanvasEntity->CreateComponent<SlotMappingComponent>(functionNode->GetEntityId());
|
|
graphCanvasEntity->CreateComponent<SceneMemberMappingComponent>(functionNode->GetEntityId());
|
|
graphCanvasEntity->CreateComponent<FunctionNodeDescriptorComponent>(functionNode->GetAssetId(), functionNode->GetName());
|
|
|
|
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 = functionNode->GetEntityId();
|
|
}
|
|
|
|
if (asset->GetStatus() == AZ::Data::AssetData::AssetStatus::Error)
|
|
{
|
|
AZ_Error("Script Canvas", false, "Script Canvas Function asset (%s) is not loaded, unable to display the node.", functionNode->GetAssetId().ToString<AZStd::string>().c_str());
|
|
|
|
GraphCanvas::TranslationKeyedString errorTitle("ERROR!");
|
|
GraphCanvas::TranslationKeyedString errorSubstring("Missing Script Canvas Function Asset!");
|
|
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, errorTitle);
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedSubTitle, errorSubstring);
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
for (const auto& slot : functionNode->GetSlots())
|
|
{
|
|
AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot);
|
|
|
|
GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetName, slot.GetName());
|
|
GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTooltip, slot.GetToolTip());
|
|
|
|
CopyTranslationKeyedNameToDatumLabel(graphCanvasNodeId, slot.GetId(), graphCanvasSlotId);
|
|
}
|
|
|
|
if (asset)
|
|
{
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTitle, asset->GetData().m_name);
|
|
}
|
|
|
|
GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetPaletteOverride, "MethodNodeTitlePalette");
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
AZ::EntityId DisplayFunctionDefinitionNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::FunctionDefinitionNode* functionDefinitionNode)
|
|
{
|
|
NodeConfiguration nodeConfiguration;
|
|
|
|
nodeConfiguration.PopulateComponentDescriptors<IconComponent, FunctionDefinitionNodeDescriptorComponent>();
|
|
|
|
if (functionDefinitionNode->RequiresDynamicSlotOrdering())
|
|
{
|
|
nodeConfiguration.PopulateComponentDescriptors<DynamicOrderingDynamicSlotComponent>();
|
|
}
|
|
else
|
|
{
|
|
nodeConfiguration.PopulateComponentDescriptors<DynamicSlotComponent>();
|
|
}
|
|
|
|
nodeConfiguration.m_nodeSubStyle = ".nodeling";
|
|
nodeConfiguration.m_titlePalette = "NodelingTitlePalette";
|
|
nodeConfiguration.m_scriptCanvasId = functionDefinitionNode->GetEntityId();
|
|
|
|
AZ::SerializeContext* serializeContext = nullptr;
|
|
AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);
|
|
|
|
AZ_Assert(serializeContext, "Failed to acquire application serialize context.");
|
|
|
|
if (const AZ::SerializeContext::ClassData* classData = serializeContext->FindClassData(azrtti_typeid(functionDefinitionNode)))
|
|
{
|
|
AZStd::string nodeContext = GetContextName(*classData);
|
|
nodeConfiguration.m_translationContext = TranslationHelper::GetUserDefinedContext(nodeContext);
|
|
|
|
nodeConfiguration.m_titleFallback = (classData->m_editData && classData->m_editData->m_name) ? classData->m_editData->m_name : classData->m_name;
|
|
nodeConfiguration.m_tooltipFallback = (classData->m_editData && classData->m_editData->m_description) ? classData->m_editData->m_description : "";
|
|
|
|
GraphCanvas::TranslationKeyedString subtitleKeyedString(nodeContext, nodeConfiguration.m_translationContext);
|
|
subtitleKeyedString.m_key = TranslationHelper::GetUserDefinedNodeKey(nodeContext, nodeConfiguration.m_titleFallback, ScriptCanvasEditor::TranslationKeyId::Category);
|
|
|
|
nodeConfiguration.m_subtitleFallback = subtitleKeyedString.GetDisplayString();
|
|
|
|
nodeConfiguration.m_translationKeyName = nodeConfiguration.m_titleFallback;
|
|
nodeConfiguration.m_translationKeyContext = nodeContext;
|
|
|
|
nodeConfiguration.m_translationGroup = TranslationContextGroup::ClassMethod;
|
|
|
|
|
|
ScriptCanvas::GraphScopedNodeId nodelingId;
|
|
|
|
nodelingId.m_identifier = nodeConfiguration.m_scriptCanvasId;
|
|
nodelingId.m_scriptCanvasId = functionDefinitionNode->GetOwningScriptCanvasId();
|
|
|
|
AZStd::string nodelingName;
|
|
ScriptCanvas::NodelingRequestBus::EventResult(nodelingName, nodelingId, &ScriptCanvas::NodelingRequests::GetDisplayName);
|
|
|
|
if (classData->m_editData)
|
|
{
|
|
const AZ::Edit::ElementData* elementData = classData->m_editData->FindElementData(AZ::Edit::ClassElements::EditorData);
|
|
|
|
if (elementData)
|
|
{
|
|
if (auto nodeTypeAttribute = elementData->FindAttribute(ScriptCanvas::Attributes::Node::NodeType))
|
|
{
|
|
if (auto nodeTypeAttributeData = azdynamic_cast<const AZ::Edit::AttributeData<NodeType>*>(nodeTypeAttribute))
|
|
{
|
|
nodeConfiguration.m_nodeType = nodeTypeAttributeData->Get(nullptr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
nodeConfiguration.m_subtitleFallback = "";
|
|
|
|
// Because of how the extender slots are registered, there isn't an easy way to only create one or the other based on
|
|
// the type of nodeling, so instead they both get created and we need to remove the inapplicable one
|
|
GraphCanvas::ConnectionType typeToRemove = (functionDefinitionNode->IsExecutionEntry()) ? GraphCanvas::CT_Input : GraphCanvas::CT_Output;
|
|
|
|
AZ::EntityId graphCanvasNodeId = DisplayGeneralScriptCanvasNode(graphCanvasGraphId, functionDefinitionNode, nodeConfiguration);
|
|
|
|
|
|
AZStd::vector<GraphCanvas::SlotId> extenderSlotIds, executionSlotIds;
|
|
GraphCanvas::NodeRequestBus::EventResult(extenderSlotIds, graphCanvasNodeId, &GraphCanvas::NodeRequests::FindVisibleSlotIdsByType, typeToRemove, GraphCanvas::SlotTypes::ExtenderSlot);
|
|
if (!extenderSlotIds.empty())
|
|
{
|
|
GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::RemoveSlot, *extenderSlotIds.begin());
|
|
}
|
|
|
|
GraphCanvas::NodeRequestBus::EventResult(executionSlotIds, graphCanvasNodeId, &GraphCanvas::NodeRequests::FindVisibleSlotIdsByType, typeToRemove, GraphCanvas::SlotTypes::ExecutionSlot);
|
|
if (!executionSlotIds.empty())
|
|
{
|
|
GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::RemoveSlot, *executionSlotIds.begin());
|
|
}
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
AZ::EntityId DisplayNodeling(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::Internal::Nodeling* nodeling)
|
|
{
|
|
NodeConfiguration nodeConfiguration;
|
|
|
|
nodeConfiguration.PopulateComponentDescriptors<IconComponent, NodelingDescriptorComponent>();
|
|
|
|
if (nodeling->RequiresDynamicSlotOrdering())
|
|
{
|
|
nodeConfiguration.PopulateComponentDescriptors<DynamicOrderingDynamicSlotComponent>();
|
|
}
|
|
else
|
|
{
|
|
nodeConfiguration.PopulateComponentDescriptors<DynamicSlotComponent>();
|
|
}
|
|
|
|
nodeConfiguration.m_nodeSubStyle = ".nodeling";
|
|
nodeConfiguration.m_titlePalette = "NodelingTitlePalette";
|
|
nodeConfiguration.m_scriptCanvasId = nodeling->GetEntityId();
|
|
|
|
AZ::SerializeContext* serializeContext = nullptr;
|
|
AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);
|
|
|
|
AZ_Assert(serializeContext, "Failed to acquire application serialize context.");
|
|
const AZ::SerializeContext::ClassData* classData = serializeContext->FindClassData(azrtti_typeid(nodeling));
|
|
|
|
if (classData)
|
|
{
|
|
AZStd::string nodeContext = GetContextName(*classData);
|
|
nodeConfiguration.m_translationContext = TranslationHelper::GetUserDefinedContext(nodeContext);
|
|
|
|
nodeConfiguration.m_titleFallback = (classData->m_editData && classData->m_editData->m_name) ? classData->m_editData->m_name : classData->m_name;
|
|
nodeConfiguration.m_tooltipFallback = (classData->m_editData && classData->m_editData->m_description) ? classData->m_editData->m_description : "";
|
|
|
|
GraphCanvas::TranslationKeyedString subtitleKeyedString(nodeContext, nodeConfiguration.m_translationContext);
|
|
subtitleKeyedString.m_key = TranslationHelper::GetUserDefinedNodeKey(nodeContext, nodeConfiguration.m_titleFallback, ScriptCanvasEditor::TranslationKeyId::Category);
|
|
|
|
nodeConfiguration.m_subtitleFallback = subtitleKeyedString.GetDisplayString();
|
|
|
|
nodeConfiguration.m_translationKeyName = nodeConfiguration.m_titleFallback;
|
|
nodeConfiguration.m_translationKeyContext = nodeContext;
|
|
|
|
nodeConfiguration.m_translationGroup = TranslationContextGroup::ClassMethod;
|
|
|
|
if (classData->m_editData)
|
|
{
|
|
const AZ::Edit::ElementData* elementData = classData->m_editData->FindElementData(AZ::Edit::ClassElements::EditorData);
|
|
|
|
if (elementData)
|
|
{
|
|
if (auto nodeTypeAttribute = elementData->FindAttribute(ScriptCanvas::Attributes::Node::NodeType))
|
|
{
|
|
if (auto nodeTypeAttributeData = azdynamic_cast<const AZ::Edit::AttributeData<NodeType>*>(nodeTypeAttribute))
|
|
{
|
|
nodeConfiguration.m_nodeType = nodeTypeAttributeData->Get(nullptr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
nodeConfiguration.m_subtitleFallback = "";
|
|
|
|
return DisplayGeneralScriptCanvasNode(graphCanvasGraphId, nodeling, nodeConfiguration);
|
|
}
|
|
|
|
AZ::EntityId DisplayGetVariableNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::GetVariableNode* variableNode)
|
|
{
|
|
AZ_PROFILE_FUNCTION(ScriptCanvas);
|
|
|
|
NodeConfiguration nodeConfiguration;
|
|
nodeConfiguration.PopulateComponentDescriptors<IconComponent, DynamicSlotComponent, GetVariableNodeDescriptorComponent>();
|
|
nodeConfiguration.m_nodeSubStyle = ".getVariable";
|
|
nodeConfiguration.m_titlePalette = "GetVariableNodeTitlePalette";
|
|
nodeConfiguration.m_scriptCanvasId = variableNode->GetEntityId();
|
|
|
|
// <Translation>
|
|
nodeConfiguration.m_translationContext = TranslationHelper::GetContextName(TranslationContextGroup::ClassMethod, "CORE");
|
|
|
|
nodeConfiguration.m_translationKeyContext = "CORE";
|
|
nodeConfiguration.m_translationKeyName = "GETVARIABLE";
|
|
|
|
nodeConfiguration.m_titleFallback = "Get Variable";
|
|
nodeConfiguration.m_subtitleFallback = "";
|
|
nodeConfiguration.m_tooltipFallback = "Gets the specified Variable or one of it's properties.";
|
|
|
|
nodeConfiguration.m_translationGroup = TranslationContextGroup::ClassMethod;
|
|
// </Translation>
|
|
|
|
AZ::EntityId graphCanvasNodeId = DisplayGeneralScriptCanvasNode(graphCanvasGraphId, variableNode, nodeConfiguration);
|
|
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::ExecutionGroup, GraphCanvas::SlotGroupConfiguration(0));
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::PropertyGroup, GraphCanvas::SlotGroupConfiguration(1));
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::DataGroup, GraphCanvas::SlotGroupConfiguration(2));
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
AZ::EntityId DisplaySetVariableNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::SetVariableNode* variableNode)
|
|
{
|
|
AZ_PROFILE_FUNCTION(ScriptCanvas);
|
|
|
|
NodeConfiguration nodeConfiguration;
|
|
nodeConfiguration.PopulateComponentDescriptors<IconComponent, DynamicSlotComponent, SetVariableNodeDescriptorComponent>();
|
|
nodeConfiguration.m_nodeSubStyle = ".setVariable";
|
|
nodeConfiguration.m_titlePalette = "SetVariableNodeTitlePalette";
|
|
nodeConfiguration.m_scriptCanvasId = variableNode->GetEntityId();
|
|
|
|
// <Translation>
|
|
|
|
nodeConfiguration.m_translationContext = TranslationHelper::GetContextName(TranslationContextGroup::ClassMethod, "CORE");
|
|
|
|
nodeConfiguration.m_translationKeyContext = "CORE";
|
|
nodeConfiguration.m_translationKeyName = "SETVARIABLE";
|
|
|
|
nodeConfiguration.m_titleFallback = "Set Variable";
|
|
nodeConfiguration.m_subtitleFallback = "";
|
|
nodeConfiguration.m_tooltipFallback = "Sets the specified Variable.";
|
|
|
|
nodeConfiguration.m_translationGroup = TranslationContextGroup::ClassMethod;
|
|
// </Translation>
|
|
|
|
AZ::EntityId graphCanvasId = DisplayGeneralScriptCanvasNode(graphCanvasGraphId, variableNode, nodeConfiguration);
|
|
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::ExecutionGroup, GraphCanvas::SlotGroupConfiguration(0));
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::PropertyGroup, GraphCanvas::SlotGroupConfiguration(1));
|
|
GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::DataGroup, GraphCanvas::SlotGroupConfiguration(2));
|
|
|
|
return graphCanvasId;
|
|
}
|
|
|
|
///////////////////
|
|
// Header Methods
|
|
///////////////////
|
|
AZ::EntityId DisplayScriptCanvasNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Node* node)
|
|
{
|
|
AZ_PROFILE_FUNCTION(ScriptCanvas);
|
|
AZ::EntityId graphCanvasNodeId;
|
|
|
|
if (azrtti_istypeof<ScriptCanvas::Nodes::Core::SetVariableNode>(node))
|
|
{
|
|
graphCanvasNodeId = DisplaySetVariableNode(graphCanvasGraphId, static_cast<const ScriptCanvas::Nodes::Core::SetVariableNode*>(node));
|
|
}
|
|
else if (azrtti_istypeof<ScriptCanvas::Nodes::Core::GetVariableNode>(node))
|
|
{
|
|
graphCanvasNodeId = DisplayGetVariableNode(graphCanvasGraphId, static_cast<const ScriptCanvas::Nodes::Core::GetVariableNode*>(node));
|
|
}
|
|
else if (azrtti_istypeof<ScriptCanvas::Nodes::Core::Method>(node))
|
|
{
|
|
graphCanvasNodeId = DisplayMethodNode(graphCanvasGraphId, static_cast<const ScriptCanvas::Nodes::Core::Method*>(node));
|
|
}
|
|
else if (azrtti_istypeof<ScriptCanvas::Nodes::Core::EBusEventHandler>(node))
|
|
{
|
|
graphCanvasNodeId = DisplayEbusWrapperNode(graphCanvasGraphId, static_cast<const ScriptCanvas::Nodes::Core::EBusEventHandler*>(node));
|
|
}
|
|
else if (auto azEventHandlerNode{ azrtti_cast<const ScriptCanvas::Nodes::Core::AzEventHandler*>(node) }; azEventHandlerNode != nullptr)
|
|
{
|
|
graphCanvasNodeId = DisplayAzEventHandlerNode(graphCanvasGraphId, azEventHandlerNode);
|
|
}
|
|
else if (azrtti_istypeof<ScriptCanvas::Nodes::Core::ReceiveScriptEvent>(node))
|
|
{
|
|
graphCanvasNodeId = DisplayScriptEventWrapperNode(graphCanvasGraphId, static_cast<const ScriptCanvas::Nodes::Core::ReceiveScriptEvent*>(node));
|
|
}
|
|
else if (azrtti_istypeof<ScriptCanvas::Nodes::Core::SendScriptEvent>(node))
|
|
{
|
|
graphCanvasNodeId = DisplayScriptEventSenderNode(graphCanvasGraphId, static_cast<const ScriptCanvas::Nodes::Core::SendScriptEvent*>(node));
|
|
}
|
|
else if (azrtti_istypeof<ScriptCanvas::Nodes::Core::FunctionCallNode>(node))
|
|
{
|
|
graphCanvasNodeId = DisplayFunctionNode(graphCanvasGraphId, static_cast<const ScriptCanvas::Nodes::Core::FunctionCallNode*>(node));
|
|
}
|
|
else if (azrtti_istypeof<ScriptCanvas::Nodes::Core::FunctionDefinitionNode>(node))
|
|
{
|
|
graphCanvasNodeId = DisplayFunctionDefinitionNode(graphCanvasGraphId, static_cast<const ScriptCanvas::Nodes::Core::FunctionDefinitionNode*>(node));
|
|
}
|
|
else if (azrtti_istypeof<ScriptCanvas::Nodes::Core::Internal::Nodeling>(node))
|
|
{
|
|
graphCanvasNodeId = DisplayNodeling(graphCanvasGraphId, static_cast<const ScriptCanvas::Nodes::Core::Internal::Nodeling*>(node));
|
|
}
|
|
else if (node)
|
|
{
|
|
graphCanvasNodeId = DisplayNode(graphCanvasGraphId, node);
|
|
}
|
|
|
|
return graphCanvasNodeId;
|
|
}
|
|
|
|
static void RegisterAndActivateGraphCanvasSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::SlotId& slotId, AZ::Entity* slotEntity)
|
|
{
|
|
AZ_PROFILE_FUNCTION(ScriptCanvas);
|
|
if (slotEntity)
|
|
{
|
|
slotEntity->Init();
|
|
slotEntity->Activate();
|
|
|
|
// Set the user data on the GraphCanvas slot to be the SlotId of the ScriptCanvas
|
|
AZStd::any* slotUserData = nullptr;
|
|
GraphCanvas::SlotRequestBus::EventResult(slotUserData, slotEntity->GetId(), &GraphCanvas::SlotRequests::GetUserData);
|
|
|
|
if (slotUserData)
|
|
{
|
|
*slotUserData = slotId;
|
|
}
|
|
|
|
GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::AddSlot, slotEntity->GetId());
|
|
}
|
|
}
|
|
|
|
static GraphCanvas::ConnectionType ToGraphCanvasConnectionType(ScriptCanvas::ConnectionType connectionType)
|
|
{
|
|
GraphCanvas::ConnectionType graphCanvasConnectionType = GraphCanvas::CT_Invalid;
|
|
switch (connectionType)
|
|
{
|
|
case ScriptCanvas::ConnectionType::Input:
|
|
graphCanvasConnectionType = GraphCanvas::CT_Input;
|
|
break;
|
|
case ScriptCanvas::ConnectionType::Output:
|
|
graphCanvasConnectionType = GraphCanvas::CT_Output;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return graphCanvasConnectionType;
|
|
}
|
|
|
|
AZ::EntityId DisplayScriptCanvasSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::Slot& slot, GraphCanvas::SlotGroup slotGroup)
|
|
{
|
|
if (!slot.IsVisible())
|
|
{
|
|
return AZ::EntityId();
|
|
}
|
|
|
|
AZ_PROFILE_FUNCTION(ScriptCanvas);
|
|
AZ::Entity* slotEntity = nullptr;
|
|
|
|
AZ::Uuid typeId = ScriptCanvas::Data::ToAZType(slot.GetDataType());
|
|
|
|
if (slot.IsExecution())
|
|
{
|
|
GraphCanvas::ExecutionSlotConfiguration executionConfiguration;
|
|
executionConfiguration.m_name = slot.GetName();
|
|
executionConfiguration.m_tooltip = slot.GetToolTip();
|
|
executionConfiguration.m_slotGroup = slotGroup;
|
|
|
|
if (slot.IsLatent())
|
|
{
|
|
executionConfiguration.m_textDecoration = u8"\U0001f552";
|
|
executionConfiguration.m_textDecorationToolTip = "This slot will not be executed immediately.";
|
|
}
|
|
|
|
if (slotGroup == GraphCanvas::SlotGroups::Invalid && slot.GetDisplayGroup() != AZ::Crc32())
|
|
{
|
|
executionConfiguration.m_slotGroup = slot.GetDisplayGroup();
|
|
}
|
|
|
|
executionConfiguration.m_connectionType = ToGraphCanvasConnectionType(slot.GetConnectionType());
|
|
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(slotEntity, &GraphCanvas::GraphCanvasRequests::CreateSlot, graphCanvasNodeId, executionConfiguration);
|
|
}
|
|
else if (slot.IsData())
|
|
{
|
|
GraphCanvas::DataSlotConfiguration dataSlotConfiguration;
|
|
dataSlotConfiguration.m_typeId = typeId;
|
|
dataSlotConfiguration.m_dataSlotType = GraphCanvas::DataSlotType::Value;
|
|
|
|
dataSlotConfiguration.m_name = slot.GetName();
|
|
dataSlotConfiguration.m_tooltip = slot.GetToolTip();
|
|
dataSlotConfiguration.m_slotGroup = slotGroup;
|
|
|
|
if (slot.IsLatent())
|
|
{
|
|
dataSlotConfiguration.m_textDecoration = u8"\U0001f552";
|
|
dataSlotConfiguration.m_textDecorationToolTip = "This slot will not be executed immediately.";
|
|
}
|
|
|
|
if (slotGroup == GraphCanvas::SlotGroups::Invalid && slot.GetDisplayGroup() != AZ::Crc32())
|
|
{
|
|
dataSlotConfiguration.m_slotGroup = slot.GetDisplayGroup();
|
|
}
|
|
|
|
dataSlotConfiguration.m_connectionType = ToGraphCanvasConnectionType(slot.GetConnectionType());
|
|
|
|
if (ScriptCanvas::Data::IsContainerType(typeId))
|
|
{
|
|
dataSlotConfiguration.m_dataValueType = GraphCanvas::DataValueType::Container;
|
|
dataSlotConfiguration.m_containerTypeIds = ScriptCanvas::Data::GetContainedTypes(typeId);
|
|
}
|
|
|
|
switch (slot.GetDynamicDataType())
|
|
{
|
|
case ScriptCanvas::DynamicDataType::Container:
|
|
dataSlotConfiguration.m_dataValueType = GraphCanvas::DataValueType::Container;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (slot.IsVariableReference())
|
|
{
|
|
dataSlotConfiguration.m_dataSlotType = GraphCanvas::DataSlotType::Reference;
|
|
}
|
|
|
|
dataSlotConfiguration.m_canConvertTypes = slot.CanConvertTypes();
|
|
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(slotEntity, &GraphCanvas::GraphCanvasRequests::CreateSlot, graphCanvasNodeId, dataSlotConfiguration);
|
|
}
|
|
|
|
if (slotEntity)
|
|
{
|
|
RegisterAndActivateGraphCanvasSlot(graphCanvasNodeId, slot.GetId(), slotEntity);
|
|
CopyTranslationKeyedNameToDatumLabel(graphCanvasNodeId, slot.GetId(), slotEntity->GetId());
|
|
return slotEntity->GetId();
|
|
}
|
|
else
|
|
{
|
|
return AZ::EntityId();
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace ScriptCanvasEditor::Nodes::SlotDisplayHelper
|
|
{
|
|
AZ::EntityId DisplayPropertySlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::VisualExtensionSlotConfiguration& propertyConfiguration)
|
|
{
|
|
AZ_PROFILE_FUNCTION(ScriptCanvas);
|
|
|
|
GraphCanvas::SlotConfiguration graphCanvasConfiguration;
|
|
|
|
graphCanvasConfiguration.m_name = propertyConfiguration.m_name;
|
|
graphCanvasConfiguration.m_tooltip = propertyConfiguration.m_tooltip;
|
|
graphCanvasConfiguration.m_slotGroup = GraphCanvas::SlotGroup(propertyConfiguration.m_displayGroup);
|
|
|
|
graphCanvasConfiguration.m_connectionType = ToGraphCanvasConnectionType(propertyConfiguration.m_connectionType);
|
|
|
|
AZ::Entity* slotEntity = nullptr;
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(slotEntity, &GraphCanvas::GraphCanvasRequests::CreatePropertySlot, graphCanvasNodeId, propertyConfiguration.m_identifier, graphCanvasConfiguration);
|
|
|
|
if (slotEntity)
|
|
{
|
|
slotEntity->Init();
|
|
slotEntity->Activate();
|
|
|
|
GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::AddSlot, slotEntity->GetId());
|
|
}
|
|
|
|
return slotEntity ? slotEntity->GetId() : AZ::EntityId();
|
|
}
|
|
|
|
AZ::EntityId DisplayExtendableSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::VisualExtensionSlotConfiguration& extenderConfiguration)
|
|
{
|
|
AZ_PROFILE_FUNCTION(ScriptCanvas);
|
|
|
|
GraphCanvas::ExtenderSlotConfiguration graphCanvasConfiguration;
|
|
|
|
graphCanvasConfiguration.m_name = extenderConfiguration.m_name;
|
|
graphCanvasConfiguration.m_tooltip = extenderConfiguration.m_tooltip;
|
|
graphCanvasConfiguration.m_slotGroup = GraphCanvas::SlotGroup(extenderConfiguration.m_displayGroup);
|
|
|
|
graphCanvasConfiguration.m_connectionType = ToGraphCanvasConnectionType(extenderConfiguration.m_connectionType);
|
|
|
|
graphCanvasConfiguration.m_extenderId = extenderConfiguration.m_identifier;
|
|
|
|
AZ::Entity* slotEntity = nullptr;
|
|
|
|
GraphCanvas::GraphCanvasRequestBus::BroadcastResult(slotEntity, &GraphCanvas::GraphCanvasRequests::CreateSlot, graphCanvasNodeId, graphCanvasConfiguration);
|
|
|
|
if (slotEntity)
|
|
{
|
|
slotEntity->Init();
|
|
slotEntity->Activate();
|
|
|
|
GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::AddSlot, slotEntity->GetId());
|
|
}
|
|
|
|
return slotEntity ? slotEntity->GetId() : AZ::EntityId();
|
|
}
|
|
|
|
AZ::EntityId DisplayVisualExtensionSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::VisualExtensionSlotConfiguration& extensionConfiguration)
|
|
{
|
|
AZ::EntityId slotId;
|
|
switch (extensionConfiguration.m_extensionType)
|
|
{
|
|
case ScriptCanvas::VisualExtensionSlotConfiguration::VisualExtensionType::ExtenderSlot:
|
|
slotId = SlotDisplayHelper::DisplayExtendableSlot(graphCanvasNodeId, extensionConfiguration);
|
|
break;
|
|
case ScriptCanvas::VisualExtensionSlotConfiguration::VisualExtensionType::PropertySlot:
|
|
slotId = SlotDisplayHelper::DisplayPropertySlot(graphCanvasNodeId, extensionConfiguration);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return slotId;
|
|
}
|
|
}
|