Code/CryEngine/CrySchematyc2/Deprecated/DocLogicGraph.cpp

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "DocLogicGraph.h"
   5
   6 #include <CrySerialization/BlackBox.h>
   7 #include <CrySerialization/IArchiveHost.h>
   8 #include <CrySerialization/STL.h>
   9 #include <CrySchematyc2/AbstractInterfaceUtils.h>
  10 #include <CrySchematyc2/IAbstractInterface.h>
  11 #include <CrySchematyc2/IComponentFactory.h>
  12 #include <CrySchematyc2/IDomainContext.h>
  13 #include <CrySchematyc2/IFramework.h>
  14 #include <CrySchematyc2/Deprecated/DocUtils.h>
  15 #include <CrySchematyc2/Deprecated/IGlobalFunction.h>
  16 #include <CrySchematyc2/Env/IEnvRegistry.h>
  17 #include <CrySchematyc2/Serialization/ISerializationContext.h>
  18
  19 #include "DomainContext.h"
  20 #include "Deprecated/DocGraphNodes/DocGraphAbstractInterfaceFunctionNode.h"
  21 #include "Deprecated/DocGraphNodes/DocGraphBranchNode.h"
  22 #include "Deprecated/DocGraphNodes/DocGraphContainerAddNode.h"
  23 #include "Deprecated/DocGraphNodes/DocGraphContainerFindByValueNode.h"
  24 #include "Deprecated/DocGraphNodes/DocGraphContainerRemoveByIndexNode.h"
  25 #include "Deprecated/DocGraphNodes/DocGraphContainerRemoveByValueNode.h"
  26 #include "Deprecated/DocGraphNodes/DocGraphContainerSetNode.h"
  27 #include "Deprecated/DocGraphNodes/DocGraphFunctionNode.h"
  28 #include "Deprecated/DocGraphNodes/DocGraphConditionNode.h"
  29 #include "Deprecated/DocGraphNodes/DocGraphGetNode.h"
  30 #include "Deprecated/DocGraphNodes/DocGraphNodes.h"
  31 #include "Deprecated/DocGraphNodes/DocGraphReturnNode.h"
  32 #include "Deprecated/DocGraphNodes/DocGraphStateNode.h"
  33 #include "Deprecated/DocGraphNodes/DocGraphSendSignalNode.h"
  34 #include "Deprecated/DocGraphNodes/DocGraphSequenceNode.h"
  35 #include "Deprecated/DocGraphNodes/DocGraphSetNode.h"
  36 #include "Deprecated/DocGraphNodes/DocGraphSwitchNode.h"
  37
  38 SERIALIZATION_ENUM_BEGIN_NESTED(Schematyc2, EGraphExecutionFilter, "Graph Execution Filter")
  39         SERIALIZATION_ENUM(Schematyc2::EGraphExecutionFilter::Always, "Always", "Always")
  40         SERIALIZATION_ENUM(Schematyc2::EGraphExecutionFilter::DevModeOrLoggingEnabled, "DevModeOrLoggingEnabled", "Dev Mode Or Logging Enabled")
  41         SERIALIZATION_ENUM(Schematyc2::EGraphExecutionFilter::DevModeOnly, "DevModeOnly", "Dev Mode Only")
  42 SERIALIZATION_ENUM_END()
  43
  44 namespace Schematyc2
  45 {
  46         namespace DocLogicGraphUtils
  47         {
  48                 struct SDocVisitor
  49                 {
  50                         inline SDocVisitor(const IScriptFile& _file, CDocGraphBase& _docGraph)
  51                                 : file(_file)
  52                                 , docGraph(_docGraph)
  53                         {}
  54
  55                         inline void VisitSignal(const IScriptFile& signalFile, const IScriptSignal& signal) const
  56                         {
  57                                 stack_string nodeName;
  58                                 DocUtils::GetFullElementName(file, signal, nodeName);
  59                                 nodeName.insert(0, "Send Signal::");
  60                                 docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::SendSignal, SGUID(), signal.GetGUID());
  61                         }
  62
  63                         inline void VisitAbstractInterfaceFunction(const IScriptFile& abstractInterfaceFunctionFile, const IScriptAbstractInterfaceFunction& abstractInterfaceFunction) const
  64                         {
  65                                 stack_string nodeName;
  66                                 DocUtils::GetFullElementName(abstractInterfaceFunctionFile, abstractInterfaceFunction.GetGUID(), nodeName);
  67                                 nodeName.insert(0, "Abstract Interface Function::");
  68                                 docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::AbstractInterfaceFunction, abstractInterfaceFunction.GetScopeGUID(), abstractInterfaceFunction.GetGUID());
  69                         }
  70
  71                         const IScriptFile& file;
  72                         CDocGraphBase&     docGraph;
  73                 };
  74
  75                 struct SClassElementVisitor
  76                 {
  77                         inline SClassElementVisitor(const IScriptFile& _file, CDocGraphBase& _docGraph)
  78                                 : file(_file)
  79                                 , docGraph(_docGraph)
  80                         {}
  81
  82                         inline EVisitStatus VisitElement(const IScriptElement& element) const
  83                         {
  84                                 const char* szElementName = element.GetName();
  85                                 switch(element.GetElementType())
  86                                 {
  87                                 case EScriptElementType::Group:
  88                                 case EScriptElementType::Class:
  89                                         {
  90                                                 file.VisitElements(ScriptElementConstVisitor::FromConstMemberFunction<SClassElementVisitor, &SClassElementVisitor::VisitElement>(*this), element.GetGUID(), false);
  91                                                 break;
  92                                         }
  93                                 case EScriptElementType::Container: // #SchematycTODO : Use domain context to visit containers!!!
  94                                         {
  95                                                 {
  96                                                         stack_string nodeName = "Container Add::";
  97                                                         nodeName.append(szElementName);
  98                                                         docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::ContainerAdd, SGUID(), element.GetGUID());
  99                                                 }
 100                                                 {
 101                                                         stack_string nodeName = "Container Remove By Index::";
 102                                                         nodeName.append(szElementName);
 103                                                         docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::ContainerRemoveByIndex, SGUID(), element.GetGUID());
 104                                                 }
 105                                                 {
 106                                                         stack_string nodeName = "Container Remove By Value::";
 107                                                         nodeName.append(szElementName);
 108                                                         docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::ContainerRemoveByValue, SGUID(), element.GetGUID());
 109                                                 }
 110                                                 {
 111                                                         stack_string nodeName = "Container Clear::";
 112                                                         nodeName.append(szElementName);
 113                                                         docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::ContainerClear, SGUID(), element.GetGUID());
 114                                                 }
 115                                                 {
 116                                                         stack_string nodeName = "Container Size::";
 117                                                         nodeName.append(szElementName);
 118                                                         docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::ContainerSize, SGUID(), element.GetGUID());
 119                                                 }
 120                                                 {
 121                                                         stack_string nodeName = "Container Get::";
 122                                                         nodeName.append(szElementName);
 123                                                         docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::ContainerGet, SGUID(), element.GetGUID());
 124                                                 }
 125                                                 {
 126                                                         stack_string nodeName = "Container Set::";
 127                                                         nodeName.append(szElementName);
 128                                                         docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::ContainerSet, SGUID(), element.GetGUID());
 129                                                 }
 130                                                 {
 131                                                         stack_string nodeName = "Container Find By Value::";
 132                                                         nodeName.append(szElementName);
 133                                                         docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::ContainerFindByValue, SGUID(), element.GetGUID());
 134                                                 }
 135                                                 break;
 136                                         }
 137                                 case EScriptElementType::Timer: // #SchematycTODO : Use domain context to visit timers!!!
 138                                         {
 139                                                 {
 140                                                         stack_string nodeName = "Start Timer::";
 141                                                         nodeName.append(szElementName);
 142                                                         docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::StartTimer, SGUID(), element.GetGUID());
 143                                                 }
 144                                                 {
 145                                                         stack_string nodeName = "Stop Timer::";
 146                                                         nodeName.append(szElementName);
 147                                                         docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::StopTimer, SGUID(), element.GetGUID());
 148                                                 }
 149                                                 {
 150                                                         stack_string nodeName = "Reset Timer::";
 151                                                         nodeName.append(szElementName);
 152                                                         docGraph.AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::ResetTimer, SGUID(), element.GetGUID());
 153                                                 }
 154                                                 break;
 155                                         }
 156                                 }
 157                                 return EVisitStatus::Continue;
 158                         }
 159
 160                         const IScriptFile& file;
 161                         CDocGraphBase&     docGraph;
 162                 };
 163
 164                 inline bool FunctionIsCondition(const IGlobalFunction& function)
 165                 {
 166                         return (function.GetOutputCount() == 1) && (function.GetOutputValue(0)->GetTypeInfo().GetTypeId() == GetAggregateTypeId<bool>());
 167                 }
 168
 169                 inline bool FunctionIsCondition(const IComponentMemberFunction& function)
 170                 {
 171                         return (function.GetOutputCount() == 1) && (function.GetOutputValue(0)->GetTypeInfo().GetTypeId() == GetAggregateTypeId<bool>());
 172                 }
 173
 174                 inline bool FunctionIsCondition(const IActionMemberFunction& function)
 175                 {
 176                         return (function.GetOutputCount() == 1) && (function.GetOutputValue(0)->GetTypeInfo().GetTypeId() == GetAggregateTypeId<bool>());
 177                 }
 178         }
 179
 180         //////////////////////////////////////////////////////////////////////////
 181         CDocLogicGraph::CDocLogicGraph(IScriptFile& file, const SGUID& guid, const SGUID& scopeGUID, const char* szName, EScriptGraphType type, const SGUID& contextGUID)
 182                 : CDocGraphBase(file, guid, scopeGUID, szName, type, contextGUID)
 183                 , m_accessor(EAccessor::Private)
 184                 , m_executionFilter(EGraphExecutionFilter::Always)
 185         {}
 186
 187         //////////////////////////////////////////////////////////////////////////
 188         EAccessor CDocLogicGraph::GetAccessor() const
 189         {
 190                 return m_accessor;
 191         }
 192
 193         //////////////////////////////////////////////////////////////////////////
 194         void CDocLogicGraph::EnumerateDependencies(const ScriptDependancyEnumerator& enumerator) const
 195         {
 196                 SCHEMATYC2_SYSTEM_ASSERT(enumerator);
 197                 if (enumerator)
 198                 {
 199                         CDocGraphBase::EnumerateDependencies(enumerator);
 200
 201                         if (CDocGraphBase::GetType() == EScriptGraphType::AbstractInterfaceFunction)
 202                         {
 203                                 if (const SGUID scopeGUID = CDocGraphBase::GetScopeGUID())
 204                                 {
 205                                         // scopeGUID is AbstractInterfaceImplementation
 206                                         enumerator(scopeGUID);
 207                                 }
 208                         }
 209                 }
 210         }
 211
 212         //////////////////////////////////////////////////////////////////////////
 213         void CDocLogicGraph::Refresh(const SScriptRefreshParams& params)
 214         {
 215                 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
 216
 217                 RefreshInputsAndOutputs();
 218                 CDocGraphBase::Refresh(params);
 219         }
 220
 221         //////////////////////////////////////////////////////////////////////////
 222         void CDocLogicGraph::Serialize(Serialization::IArchive& archive)
 223         {
 224                 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
 225
 226                 switch(SerializationContext::GetPass(archive))
 227                 {
 228                 case ESerializationPass::PreLoad:
 229                         {
 230                                 CDocGraphBase::Serialize(archive);
 231                                 const EScriptGraphType type = CDocGraphBase::GetType();
 232                                 if((type == EScriptGraphType::Function) || (type == EScriptGraphType::Condition))
 233                                 {
 234                                         archive(m_accessor, "accessor", "Accessor");
 235                                         archive(m_executionFilter, "executionFilter", "Execution Filter");
 236                                 }
 237                                 break;
 238                         }
 239                 case ESerializationPass::Load:
 240                         {
 241                                 RefreshInputsAndOutputs();
 242                                 CDocGraphBase::Serialize(archive);
 243                                 break;
 244                         }
 245                 case ESerializationPass::PostLoad:
 246                         {
 247                                 CDocGraphBase::Serialize(archive);
 248                                 break;
 249                         }
 250                 case ESerializationPass::Save:
 251                         {
 252                                 CDocGraphBase::Serialize(archive);
 253                                 SInfoSerializer(*this).Serialize(archive);
 254                                 break;
 255                         }
 256                 case ESerializationPass::Edit:
 257                         {
 258                                 CDocGraphBase::Serialize(archive);
 259                                 SInfoSerializer(*this).Serialize(archive);
 260
 261                                 Serialization::SContext fileContext(archive, static_cast<IScriptFile*>(&CDocGraphBase::GetFile())); // #SchematycTODO : Do we still need this?
 262
 263                                 switch(CDocGraphBase::GetType())
 264                                 {
 265                                 case EScriptGraphType::Function:
 266                                         {
 267                                                 archive(CDocGraphBase::GetInputs(), "inputs", "Inputs");
 268                                                 archive(CDocGraphBase::GetOutputs(), "outputs", "Outputs");
 269                                                 break;
 270                                         }
 271                                 case EScriptGraphType::Condition:
 272                                         {
 273                                                 archive(CDocGraphBase::GetInputs(), "inputs", "Inputs");
 274                                                 for(CScriptVariableDeclaration& output : GetOutputs())
 275                                                 {
 276                                                         const IAnyConstPtr& pOutputValue = output.GetValue();
 277                                                         if(pOutputValue)
 278                                                         {
 279                                                                 const char* szOutputName = output.GetName();
 280                                                                 archive(*pOutputValue, szOutputName, szOutputName);
 281                                                         }
 282                                                 }
 283                                                 break;
 284                                         }
 285                                 case EScriptGraphType::AbstractInterfaceFunction:
 286                                         {
 287                                                 // #SchematycTODO : Can we display inputs and outputs in editor?
 288                                                 break;
 289                                         }
 290                                 }
 291                                 break;
 292                         }
 293                 case ESerializationPass::Validate:
 294                         {
 295                                 Validate(archive);
 296                                 break;
 297                         }
 298                 }
 299         }
 300
 301         //////////////////////////////////////////////////////////////////////////
 302         void CDocLogicGraph::RefreshAvailableNodes(const CAggregateTypeId& inputTypeId)
 303         {
 304                 CDocGraphBase::ClearAvailablNodes();
 305                 CDocGraphBase::AddAvailableNode("Sequence", EScriptGraphNodeType::Sequence, SGUID(), SGUID());
 306                 CDocGraphBase::AddAvailableNode("Branch", EScriptGraphNodeType::Branch, SGUID(), SGUID());
 307                 CDocGraphBase::AddAvailableNode("Switch", EScriptGraphNodeType::Switch, SGUID(), SGUID());
 308                 CDocGraphBase::AddAvailableNode("Make Enumeration", EScriptGraphNodeType::MakeEnumeration, SGUID(), SGUID());
 309                 CDocGraphBase::AddAvailableNode("For Loop", EScriptGraphNodeType::ForLoop, SGUID(), SGUID());
 310                 CDocGraphBase::AddAvailableNode("Return", EScriptGraphNodeType::Return, SGUID(), SGUID());
 311                 CDocGraphBase::AddAvailableNode("Comment", EScriptGraphNodeType::Comment, SGUID(), SGUID());
 312
 313                 const IScriptFile&  file = CDocGraphBase::GetFile();
 314                 const SGUID         scopeGUID = CDocGraphBase::GetScopeGUID();
 315                 const IScriptClass* pOwnerClass = DocUtils::FindOwnerClass(file, scopeGUID);
 316                 if(pOwnerClass)
 317                 {
 318                         CDocGraphBase::AddAvailableNode("Get Object", EScriptGraphNodeType::GetObject, SGUID(), pOwnerClass->GetGUID());
 319                 }
 320
 321                 CDomainContext domainContext(SDomainContextScope(&file, scopeGUID));
 322                 VisitEnvGlobalFunctions(domainContext);
 323                 VisitEnvAbstractInterfaces(domainContext);
 324                 VisitEnvComponentMemberFunctions(domainContext);
 325                 VisitEnvActionMemberFunctions(domainContext);
 326                 VisitVariables(domainContext);
 327                 VisitProperties(domainContext);
 328                 VisitGraphs(domainContext);
 329
 330                 // #SchematycTODO : Use domain context to visit everything!
 331
 332                 DocLogicGraphUtils::SDocVisitor docVisitor(file, *this);
 333                 ScriptIncludeRecursionUtils::VisitSignals(file, ScriptIncludeRecursionUtils::SignalVisitor::FromConstMemberFunction<DocLogicGraphUtils::SDocVisitor, &DocLogicGraphUtils::SDocVisitor::VisitSignal>(docVisitor), SGUID(), true);
 334                 ScriptIncludeRecursionUtils::VisitAbstractInterfaceFunctions(file, ScriptIncludeRecursionUtils::AbstractInterfaceFunctionVisitor::FromConstMemberFunction<DocLogicGraphUtils::SDocVisitor, &DocLogicGraphUtils::SDocVisitor::VisitAbstractInterfaceFunction>(docVisitor), SGUID(), true);
 335
 336                 DocLogicGraphUtils::SClassElementVisitor classElementVisitor(file, *this);
 337                 const IScriptElement*                    pScopeElement = file.GetElement(scopeGUID);
 338                 CRY_ASSERT(pScopeElement);
 339                 while(pScopeElement)
 340                 {
 341                         file.VisitElements(ScriptElementConstVisitor::FromConstMemberFunction<DocLogicGraphUtils::SClassElementVisitor, &DocLogicGraphUtils::SClassElementVisitor::VisitElement>(classElementVisitor), pScopeElement->GetGUID(), false);
 342                         if(pScopeElement->GetElementType() != EScriptElementType::Class)
 343                         {
 344                                 pScopeElement = file.GetElement(pScopeElement->GetScopeGUID());
 345                         }
 346                         else
 347                         {
 348                                 break;
 349                         }
 350                 }
 351         }
 352
 353         //////////////////////////////////////////////////////////////////////////
 354         IScriptGraphNodePtr CDocLogicGraph::CreateNode(const SGUID& guid, EScriptGraphNodeType type, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
 355         {
 356                 MEMSTAT_CONTEXT(EMemStatContextType::Other, "Schematyc: Create Node(Doc Logic Graph)");
 357                 switch(type)
 358                 {
 359                 case EScriptGraphNodeType::Begin:
 360                         {
 361                                 return IScriptGraphNodePtr(new CDocGraphBeginNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 362                         }
 363                 case EScriptGraphNodeType::BeginConstructor:
 364                         {
 365                                 return IScriptGraphNodePtr(new CDocGraphBeginConstructorNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 366                         }
 367                 case EScriptGraphNodeType::BeginDestructor:
 368                         {
 369                                 return IScriptGraphNodePtr(new CDocGraphBeginDestructorNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 370                         }
 371                 case EScriptGraphNodeType::BeginSignalReceiver:
 372                         {
 373                                 return IScriptGraphNodePtr(new CDocGraphBeginSignalReceiverNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 374                         }
 375                 case EScriptGraphNodeType::Return:
 376                         {
 377                                 return IScriptGraphNodePtr(new CDocGraphReturnNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 378                         }
 379                 case EScriptGraphNodeType::Sequence:
 380                         {
 381                                 return IScriptGraphNodePtr(new CDocGraphSequenceNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 382                         }
 383                 case EScriptGraphNodeType::Branch:
 384                         {
 385                                 return IScriptGraphNodePtr(new CDocGraphBranchNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 386                         }
 387                 case EScriptGraphNodeType::Switch:
 388                         {
 389                                 return IScriptGraphNodePtr(new CDocGraphSwitchNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 390                         }
 391                 case EScriptGraphNodeType::MakeEnumeration:
 392                         {
 393                                 return IScriptGraphNodePtr(new CDocGraphMakeEnumerationNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 394                         }
 395                 case EScriptGraphNodeType::ForLoop:
 396                         {
 397                                 return IScriptGraphNodePtr(new CDocGraphForLoopNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 398                         }
 399                 case EScriptGraphNodeType::ProcessSignal:
 400                         {
 401                                 return IScriptGraphNodePtr(new CDocGraphProcessSignalNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 402                         }
 403                 case EScriptGraphNodeType::SendSignal:
 404                         {
 405                                 return IScriptGraphNodePtr(new CDocGraphSendSignalNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 406                         }
 407                 case EScriptGraphNodeType::BroadcastSignal:
 408                         {
 409                                 return IScriptGraphNodePtr(new CDocGraphBroadcastSignalNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 410                         }
 411                 case EScriptGraphNodeType::Function:
 412                         {
 413                                 return IScriptGraphNodePtr(new CDocGraphFunctionNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 414                         }
 415                 case EScriptGraphNodeType::Condition:
 416                         {
 417                                 return IScriptGraphNodePtr(new CDocGraphConditionNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 418                         }
 419                 case EScriptGraphNodeType::AbstractInterfaceFunction:
 420                         {
 421                                 return IScriptGraphNodePtr(new CDocGraphAbstractInterfaceFunctionNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 422                         }
 423                 case EScriptGraphNodeType::GetObject:
 424                         {
 425                                 return IScriptGraphNodePtr(new CDocGraphGetObjectNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 426                         }
 427                 case EScriptGraphNodeType::Set:
 428                         {
 429                                 return IScriptGraphNodePtr(new CDocGraphSetNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 430                         }
 431                 case EScriptGraphNodeType::Get:
 432                         {
 433                                 return IScriptGraphNodePtr(new CDocGraphGetNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 434                         }
 435                 case EScriptGraphNodeType::ContainerAdd:
 436                         {
 437                                 return IScriptGraphNodePtr(new CDocGraphContainerAddNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 438                         }
 439                 case EScriptGraphNodeType::ContainerRemoveByIndex:
 440                         {
 441                                 return IScriptGraphNodePtr(new CDocGraphContainerRemoveByIndexNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 442                         }
 443                 case EScriptGraphNodeType::ContainerRemoveByValue:
 444                         {
 445                                 return IScriptGraphNodePtr(new CDocGraphContainerRemoveByValueNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 446                         }
 447                 case EScriptGraphNodeType::ContainerClear:
 448                         {
 449                                 return IScriptGraphNodePtr(new CDocGraphContainerClearNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 450                         }
 451                 case EScriptGraphNodeType::ContainerSize:
 452                         {
 453                                 return IScriptGraphNodePtr(new CDocGraphContainerSizeNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 454                         }
 455                 case EScriptGraphNodeType::ContainerGet:
 456                         {
 457                                 return IScriptGraphNodePtr(new CDocGraphContainerGetNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 458                         }
 459                 case EScriptGraphNodeType::ContainerSet:
 460                         {
 461                                 return IScriptGraphNodePtr(new CDocGraphContainerSetNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 462                         }
 463                 case EScriptGraphNodeType::ContainerFindByValue:
 464                         {
 465                                 return IScriptGraphNodePtr(new CDocGraphContainerFindByValueNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 466                         }
 467                 case EScriptGraphNodeType::StartTimer:
 468                         {
 469                                 return IScriptGraphNodePtr(new CDocGraphStartTimerNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 470                         }
 471                 case EScriptGraphNodeType::StopTimer:
 472                         {
 473                                 return IScriptGraphNodePtr(new CDocGraphStopTimerNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 474                         }
 475                 case EScriptGraphNodeType::ResetTimer:
 476                         {
 477                                 return IScriptGraphNodePtr(new CDocGraphResetTimerNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 478                         }
 479                 case EScriptGraphNodeType::Comment:
 480                         {
 481                                 return IScriptGraphNodePtr(new CDocGraphCommentNode(CDocGraphBase::GetFile(), *this, guid, contextGUID, refGUID, pos));
 482                         }
 483                 default:
 484                         {
 485                                 return IScriptGraphNodePtr();
 486                         }
 487                 }
 488         }
 489
 490         //////////////////////////////////////////////////////////////////////////
 491         CDocLogicGraph::SInfoSerializer::SInfoSerializer(CDocLogicGraph& _graph)
 492                 : graph(_graph)
 493         {}
 494
 495         //////////////////////////////////////////////////////////////////////////
 496         void CDocLogicGraph::SInfoSerializer::Serialize(Serialization::IArchive& archive)
 497         {
 498                 const EScriptGraphType type = graph.GetType();
 499                 if((type == EScriptGraphType::Function) || (type == EScriptGraphType::Condition))
 500                 {
 501                         archive(graph.m_accessor, "accessor", "Accessor");
 502                         archive(graph.m_executionFilter, "executionFilter", "Execution Filter");
 503                 }
 504         }
 505
 506         //////////////////////////////////////////////////////////////////////////
 507         bool CDocLogicGraph::RefreshInputsAndOutputs()
 508         {
 509                 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
 510                 // #SchematycTODO : Clean up this function, there's a lot of duplicated code here.
 511                 switch(CDocGraphBase::GetType())
 512                 {
 513                 case EScriptGraphType::Condition:
 514                         {
 515                                 ScriptVariableDeclarationVector& outputs = GetOutputs();
 516                                 if(outputs.empty())
 517                                 {
 518                                         outputs.push_back(CScriptVariableDeclaration("Result", GetAggregateTypeId<bool>(), MakeAnyShared(bool(false))));
 519                                 }
 520                                 return true;
 521                         }
 522                 case EScriptGraphType::AbstractInterfaceFunction:
 523                         {
 524                                 // Retrieve interface function.
 525                                 // #SchematycTODO : Check that inputs and output actually need to be refreshed?
 526                                 const IScriptFile&                            file = CDocGraphBase::GetFile();
 527                                 const IScriptAbstractInterfaceImplementation* pAbstractInterfaceImplementation = file.GetAbstractInterfaceImplementation(CDocGraphBase::GetScopeGUID());
 528                                 if(pAbstractInterfaceImplementation)
 529                                 {
 530                                         const SGUID abstractInterfaceGUID = pAbstractInterfaceImplementation->GetRefGUID();
 531                                         const SGUID abstractInterfaceFunctionGUID = CDocGraphBase::GetContextGUID();
 532                                         switch(pAbstractInterfaceImplementation->GetDomain())
 533                                         {
 534                                         case EDomain::Env:
 535                                                 {
 536                                                         IAbstractInterfaceConstPtr pAbstractInterface = gEnv->pSchematyc2->GetEnvRegistry().GetAbstractInterface(abstractInterfaceGUID);
 537                                                         if(pAbstractInterface)
 538                                                         {
 539                                                                 IAbstractInterfaceFunctionConstPtr      pAbstractInterfaceFunction = pAbstractInterface->GetFunction(AbstractInterfaceUtils::FindFunction(*pAbstractInterface, abstractInterfaceFunctionGUID));
 540                                                                 CRY_ASSERT(pAbstractInterfaceFunction);
 541                                                                 if(pAbstractInterfaceFunction)
 542                                                                 {
 543                                                                         CDocGraphBase::SetName(pAbstractInterfaceFunction->GetName());
 544                                                                         // Refresh inputs.
 545                                                                         const size_t                     inputCount = pAbstractInterfaceFunction->GetInputCount();
 546                                                                         ScriptVariableDeclarationVector& inputs = GetInputs();
 547                                                                         inputs.resize(inputCount);
 548                                                                         for(size_t inputIdx = 0; inputIdx < inputCount; ++ inputIdx)
 549                                                                         {
 550                                                                                 const IAnyConstPtr pNewInputValue = pAbstractInterfaceFunction->GetInputValue(inputIdx);
 551                                                                                 inputs[inputIdx] = CScriptVariableDeclaration(pAbstractInterfaceFunction->GetInputName(inputIdx), pNewInputValue ? pNewInputValue->Clone() : IAnyPtr());
 552                                                                         }
 553                                                                         // Refresh outputs.
 554                                                                         const size_t                     outputCount = pAbstractInterfaceFunction->GetOutputCount();
 555                                                                         ScriptVariableDeclarationVector& outputs = GetOutputs();
 556                                                                         outputs.resize(outputCount);
 557                                                                         for(size_t outputIdx = 0; outputIdx < outputCount; ++ outputIdx)
 558                                                                         {
 559                                                                                 const IAnyConstPtr pNewOutputValue = pAbstractInterfaceFunction->GetOutputValue(outputIdx);
 560                                                                                 outputs[outputIdx] = CScriptVariableDeclaration(pAbstractInterfaceFunction->GetOutputName(outputIdx), pNewOutputValue ? pNewOutputValue->Clone() : IAnyPtr());
 561                                                                         }
 562                                                                         return true;
 563                                                                 }
 564                                                         }
 565                                                         break;
 566                                                 }
 567                                         case EDomain::Script:
 568                                                 {
 569                                                         ScriptIncludeRecursionUtils::TGetAbstractInterfaceResult abstractInterface = ScriptIncludeRecursionUtils::GetAbstractInterface(file, abstractInterfaceGUID);
 570                                                         if(abstractInterface.second)
 571                                                         {
 572                                                                 const IScriptAbstractInterfaceFunction* pAbstractInterfaceFunction = abstractInterface.first->GetAbstractInterfaceFunction(abstractInterfaceFunctionGUID);
 573                                                                 if(pAbstractInterfaceFunction)
 574                                                                 {
 575                                                                         CDocGraphBase::SetName(pAbstractInterfaceFunction->GetName());
 576                                                                         // Refresh inputs.
 577                                                                         const size_t                     inputCount = pAbstractInterfaceFunction->GetInputCount();
 578                                                                         ScriptVariableDeclarationVector& inputs = GetInputs();
 579                                                                         inputs.resize(inputCount);
 580                                                                         for(size_t inputIdx = 0; inputIdx < inputCount; ++ inputIdx)
 581                                                                         {
 582                                                                                 const IAnyConstPtr pNewInputValue = pAbstractInterfaceFunction->GetInputValue(inputIdx);
 583                                                                                 inputs[inputIdx] = CScriptVariableDeclaration(pAbstractInterfaceFunction->GetInputName(inputIdx), pNewInputValue ? pNewInputValue->Clone() : IAnyPtr());
 584                                                                         }
 585                                                                         // Refresh outputs.
 586                                                                         const size_t                     outputCount = pAbstractInterfaceFunction->GetOutputCount();
 587                                                                         ScriptVariableDeclarationVector& outputs = GetOutputs();
 588                                                                         outputs.resize(outputCount);
 589                                                                         for(size_t outputIdx = 0; outputIdx < outputCount; ++ outputIdx)
 590                                                                         {
 591                                                                                 const IAnyConstPtr pNewOutputValue = pAbstractInterfaceFunction->GetOutputValue(outputIdx);
 592                                                                                 outputs[outputIdx] = CScriptVariableDeclaration(pAbstractInterfaceFunction->GetOutputName(outputIdx), pNewOutputValue ? pNewOutputValue->Clone() : IAnyPtr());
 593                                                                         }
 594                                                                         return true;
 595                                                                 }
 596                                                         }
 597                                                         break;
 598                                                 }
 599                                         }
 600                                 }
 601                                 break;
 602                         }
 603                 default:
 604                         {
 605                                 return true;
 606                         }
 607                 }
 608                 return false;
 609         }
 610
 611         //////////////////////////////////////////////////////////////////////////
 612         void CDocLogicGraph::Validate(Serialization::IArchive& archive)
 613         {
 614                 for(CScriptVariableDeclaration& input : GetInputs())
 615                 {
 616                         if(!input.GetValue())
 617                         {
 618                                 archive.error(*this, "Failed to instantiate input value: input = %s", input.GetName());
 619                         }
 620                 }
 621
 622                 for(CScriptVariableDeclaration& output : GetOutputs())
 623                 {
 624                         if(!output.GetValue())
 625                         {
 626                                 archive.error(*this, "Failed to instantiate output value: output = %s", output.GetName());
 627                         }
 628                 }
 629         }
 630
 631         //////////////////////////////////////////////////////////////////////////
 632         void CDocLogicGraph::VisitEnvGlobalFunctions(const IDomainContext& domainContext)
 633         {
 634                 auto visitEnvGlobalFunction = [this, &domainContext] (const IGlobalFunctionConstPtr& pFunction) -> EVisitStatus
 635                 {
 636                         stack_string qualifiedFunctionName;
 637                         domainContext.QualifyName(*pFunction, qualifiedFunctionName);
 638                         const SGUID contextGUID = SGUID();
 639                         const SGUID refGUID = pFunction->GetGUID();
 640                         if(DocLogicGraphUtils::FunctionIsCondition(*pFunction))
 641                         {
 642                                 stack_string nodeName = "Condition::";
 643                                 nodeName.append(qualifiedFunctionName);
 644                                 AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::Condition, contextGUID, refGUID);
 645                         }
 646                         {
 647                                 stack_string nodeName = "Function::";
 648                                 nodeName.append(qualifiedFunctionName);
 649                                 AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::Function, contextGUID, refGUID);
 650                         }
 651                         return EVisitStatus::Continue;
 652                 };
 653                 domainContext.VisitEnvGlobalFunctions(EnvGlobalFunctionVisitor::FromLambdaFunction(visitEnvGlobalFunction));
 654         }
 655
 656         //////////////////////////////////////////////////////////////////////////
 657         void CDocLogicGraph::VisitEnvAbstractInterfaces(const IDomainContext& domainContext)
 658         {
 659                 auto visitEnvAbstractInterface = [this, &domainContext] (const IAbstractInterfaceConstPtr& pAbstractInterface) -> EVisitStatus
 660                 {
 661                         for(size_t functionIdx = 0, functionCount = pAbstractInterface->GetFunctionCount(); functionIdx < functionCount; ++ functionIdx)
 662                         {
 663                                 IAbstractInterfaceFunctionConstPtr pFunction = pAbstractInterface->GetFunction(functionIdx);
 664                                 if(pFunction)
 665                                 {
 666                                         stack_string nodeName;
 667                                         domainContext.QualifyName(*pFunction, nodeName);
 668                                         nodeName.insert(0, "Abstract Interface Function::");
 669                                         AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::AbstractInterfaceFunction, pAbstractInterface->GetGUID(), pFunction->GetGUID());
 670                                 }
 671                         }
 672                         return EVisitStatus::Continue;
 673                 };
 674                 domainContext.VisitEnvAbstractInterfaces(EnvAbstractInterfaceVisitor::FromLambdaFunction(visitEnvAbstractInterface));
 675         }
 676
 677         //////////////////////////////////////////////////////////////////////////
 678         void CDocLogicGraph::VisitEnvComponentMemberFunctions(const IDomainContext& domainContext)
 679         {
 680                 typedef std::vector<const IScriptComponentInstance*> ComponentInstances;
 681
 682                 ComponentInstances componentInstances;
 683                 componentInstances.reserve(32);
 684                 auto visitComponentInstance = [&componentInstances] (const IScriptComponentInstance& componentInstance) -> EVisitStatus
 685                 {
 686                         componentInstances.push_back(&componentInstance);
 687                         return EVisitStatus::Continue;
 688                 };
 689                 domainContext.VisitScriptComponentInstances(ScriptComponentInstanceConstVisitor::FromLambdaFunction(visitComponentInstance), EDomainScope::Local);
 690
 691                 auto visitEnvComponentMemberFunction = [this, &domainContext, &componentInstances] (const IComponentMemberFunctionConstPtr& pFunction) -> EVisitStatus
 692                 {
 693                         const SGUID componentGUID = pFunction->GetComponentGUID();
 694                         const bool  bFunctionIsCondition = DocLogicGraphUtils::FunctionIsCondition(*pFunction);
 695                         for(const IScriptComponentInstance* pComponentInstance : componentInstances)
 696                         {
 697                                 if(pComponentInstance->GetComponentGUID() == componentGUID)
 698                                 {
 699                                         stack_string qualifiedFunctionName;
 700                                         domainContext.QualifyName(*pComponentInstance, *pFunction, EDomainQualifier::Global, qualifiedFunctionName);
 701                                         const SGUID contextGUID = pComponentInstance->GetGUID();
 702                                         const SGUID refGUID = pFunction->GetGUID();
 703                                         if(bFunctionIsCondition)
 704                                         {
 705                                                 stack_string nodeName = "Condition::";
 706                                                 nodeName.append(qualifiedFunctionName);
 707                                                 AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::Condition, contextGUID, refGUID);
 708                                         }
 709                                         {
 710                                                 stack_string nodeName = "Function::";
 711                                                 nodeName.append(qualifiedFunctionName);
 712                                                 AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::Function, contextGUID, refGUID);
 713                                         }
 714                                 }
 715                         }
 716                         return EVisitStatus::Continue;
 717                 };
 718                 domainContext.VisitEnvComponentMemberFunctions(EnvComponentMemberFunctionVisitor::FromLambdaFunction(visitEnvComponentMemberFunction));
 719         }
 720
 721         //////////////////////////////////////////////////////////////////////////
 722         void CDocLogicGraph::VisitEnvActionMemberFunctions(const IDomainContext& domainContext)
 723         {
 724                 typedef std::vector<const IScriptActionInstance*> ActionInstances;
 725
 726                 ActionInstances actionInstances;
 727                 actionInstances.reserve(32);
 728                 auto visitActionInstance = [&actionInstances] (const IScriptActionInstance& actionInstance) -> EVisitStatus
 729                 {
 730                         actionInstances.push_back(&actionInstance);
 731                         return EVisitStatus::Continue;
 732                 };
 733                 domainContext.VisitScriptActionInstances(ScriptActionInstanceConstVisitor::FromLambdaFunction(visitActionInstance), EDomainScope::Local);
 734
 735                 auto visitEnvActionMemberFunction = [this, &domainContext, &actionInstances] (const IActionMemberFunctionConstPtr& pFunction) -> EVisitStatus
 736                 {
 737                         const SGUID actionGUID = pFunction->GetActionGUID();
 738                         const bool  bFunctionIsCondition = DocLogicGraphUtils::FunctionIsCondition(*pFunction);
 739                         for(const IScriptActionInstance* pActionInstance : actionInstances)
 740                         {
 741                                 if(pActionInstance->GetActionGUID() == actionGUID)
 742                                 {
 743                                         stack_string qualifiedFunctionName;
 744                                         domainContext.QualifyName(*pActionInstance, *pFunction, EDomainQualifier::Global, qualifiedFunctionName);
 745                                         const SGUID contextGUID = pActionInstance->GetGUID();
 746                                         const SGUID refGUID = pFunction->GetGUID();
 747                                         if(bFunctionIsCondition)
 748                                         {
 749                                                 stack_string nodeName = "Condition::";
 750                                                 nodeName.append(qualifiedFunctionName);
 751                                                 AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::Condition, contextGUID, refGUID);
 752                                         }
 753                                         {
 754                                                 stack_string nodeName = "Function::";
 755                                                 nodeName.append(qualifiedFunctionName);
 756                                                 AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::Function, contextGUID, refGUID);
 757                                         }
 758                                 }
 759                         }
 760                         return EVisitStatus::Continue;
 761                 };
 762                 domainContext.VisitEnvActionMemberFunctions(EnvActionMemberFunctionVisitor::FromLambdaFunction(visitEnvActionMemberFunction));
 763         }
 764
 765         //////////////////////////////////////////////////////////////////////////
 766         void CDocLogicGraph::VisitVariables(const IDomainContext& domainContext)
 767         {
 768                 auto visitVariable = [this, &domainContext] (const IScriptVariable& variable) -> EVisitStatus
 769                 {
 770                         stack_string qualifiedVariableName;
 771                         domainContext.QualifyName(variable, EDomainQualifier::Global, qualifiedVariableName);
 772                         const SGUID contextGUID = SGUID();
 773                         const SGUID refGUID = variable.GetGUID();
 774                         {
 775                                 stack_string nodeName = "Set::";
 776                                 nodeName.append(qualifiedVariableName);
 777                                 AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::Set, contextGUID, refGUID);
 778                         }
 779                         {
 780                                 stack_string nodeName = "Get::";
 781                                 nodeName.append(qualifiedVariableName);
 782                                 AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::Get, contextGUID, refGUID);
 783                         }
 784                         return EVisitStatus::Continue;
 785                 };
 786                 domainContext.VisitScriptVariables(ScriptVariableConstVisitor::FromLambdaFunction(visitVariable), EDomainScope::Derived);
 787         }
 788
 789         //////////////////////////////////////////////////////////////////////////
 790         void CDocLogicGraph::VisitProperties(const IDomainContext& domainContext)
 791         {
 792                 auto visitProperty = [this, &domainContext] (const IScriptProperty& property) -> EVisitStatus
 793                 {
 794                         stack_string nodeName;
 795                         domainContext.QualifyName(property, EDomainQualifier::Global, nodeName);
 796                         nodeName.insert(0, "Get::");
 797                         AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::Get, SGUID(), property.GetGUID());
 798                         return EVisitStatus::Continue;
 799                 };
 800                 domainContext.VisitScriptProperties(ScriptPropertyConstVisitor::FromLambdaFunction(visitProperty), EDomainScope::Derived);
 801         }
 802
 803         //////////////////////////////////////////////////////////////////////////
 804         void CDocLogicGraph::VisitGraphs(const IDomainContext& domainContext)
 805         {
 806                 auto visitGraph = [this, &domainContext] (const IDocGraph& graph) -> EVisitStatus
 807                 {
 808                         switch(graph.GetType())
 809                         {
 810                         case EScriptGraphType::Function:
 811                                 {
 812                                         stack_string nodeName;
 813                                         domainContext.QualifyName(graph, EDomainQualifier::Global, nodeName);
 814                                         nodeName.insert(0, "Function::");
 815                                         AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::Function, SGUID(), graph.GetGUID());
 816                                         break;
 817                                 }
 818                         case EScriptGraphType::Condition:
 819                                 {
 820                                         stack_string nodeName;
 821                                         domainContext.QualifyName(graph, EDomainQualifier::Global, nodeName);
 822                                         nodeName.insert(0, "Condition::");
 823                                         AddAvailableNode(nodeName.c_str(), EScriptGraphNodeType::Condition, SGUID(), graph.GetGUID());
 824                                 }
 825                         }
 826                         return EVisitStatus::Continue;
 827                 };
 828                 domainContext.VisitDocGraphs(DocGraphConstVisitor::FromLambdaFunction(visitGraph), EDomainScope::Derived);
 829         }
 830 }
 831