Code/CryEngine/CrySchematyc2/Deprecated/DocGraphBase.cpp

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "DocGraphBase.h"
   5
   6 #include <CrySerialization/BlackBox.h>
   7 #include <CrySerialization/IArchiveHost.h>
   8 #include <CrySerialization/STL.h>
   9 #include <CrySchematyc2/GUIDRemapper.h>
  10 #include <CrySchematyc2/Deprecated/DocUtils.h>
  11 #include <CrySchematyc2/Serialization/ISerializationContext.h>
  12 #include <CrySchematyc2/Services/ILog.h>
  13
  14 namespace Schematyc2
  15 {
  16         namespace DocGraphBaseUtils
  17         {
  18                 struct SNodeHeader
  19                 {
  20                         inline SNodeHeader()
  21                                 : type(EScriptGraphNodeType::Unknown)
  22                                 , pos(ZERO)
  23                         {}
  24
  25                         inline SNodeHeader(const SGUID& _guid, EScriptGraphNodeType _type, const SGUID& _contextGUID, const SGUID& _refGUID, const Vec2& _pos)
  26                                 : guid(_guid)
  27                                 , type(_type)
  28                                 , contextGUID(_contextGUID)
  29                                 , refGUID(_refGUID)
  30                                 , pos(_pos)
  31                         {}
  32
  33                         void Serialize(Serialization::IArchive& archive)
  34                         {
  35                                 archive(guid, "guid");
  36                                 archive(type, "type");
  37                                 archive(contextGUID, "context_guid");
  38                                 archive(refGUID, "ref_guid");
  39                                 archive(pos, "pos");
  40                         }
  41
  42                         SGUID                guid;
  43                         EScriptGraphNodeType type;
  44                         SGUID                contextGUID;
  45                         SGUID                refGUID;
  46                         Vec2                 pos;
  47                 };
  48
  49                 struct SNodeMapValueSerializer
  50                 {
  51                         inline SNodeMapValueSerializer(std::pair<SGUID, SDocGraphNode>& _value)
  52                                 : value(_value)
  53                         {}
  54
  55                         void Serialize(Serialization::IArchive& archive)
  56                         {
  57                                 CDocGraphBase* pDocGraph = archive.context<CDocGraphBase>();
  58                                 CRY_ASSERT(pDocGraph);
  59                                 if(pDocGraph)
  60                                 {
  61                                         pDocGraph->SerializeNodeMapValue(archive, value);
  62                                 }
  63                         }
  64
  65                         std::pair<SGUID, SDocGraphNode>& value;
  66                 };
  67         }
  68 }
  69
  70 namespace std   // In order to resolve ADL, std type serialization overrides must be placed in std namespace.
  71 {
  72         inline bool Serialize(Serialization::IArchive& archive, pair<Schematyc2::SGUID, Schematyc2::SDocGraphNode>& value, const char* szName, const char* szLabel)
  73         {
  74                 archive(Schematyc2::DocGraphBaseUtils::SNodeMapValueSerializer(value), szName, szLabel);
  75                 return true;
  76         }
  77
  78         /*inline bool Serialize(Serialization::IArchive& archive, shared_ptr<Schematyc2::CScriptGraphLink>& value, const char* szName, const char* szLabel)
  79         {
  80                 if(!value)
  81                 {
  82                         value = std::make_shared<Schematyc2::CScriptGraphLink>();
  83                 }
  84                 archive(*value, szName, szLabel);
  85                 return true;
  86         }*/
  87 }
  88
  89 namespace Schematyc2
  90 {
  91         //////////////////////////////////////////////////////////////////////////
  92         SDocGraphNode::SDocGraphNode() {}
  93
  94         //////////////////////////////////////////////////////////////////////////
  95         SDocGraphNode::SDocGraphNode(const IScriptGraphNodePtr& _pNode)
  96                 : pNode(_pNode)
  97         {}
  98
  99         //////////////////////////////////////////////////////////////////////////
 100         CScriptGraphLink::CScriptGraphLink(const SGUID& srcNodeGUID, const char* szSrcOutputName, const SGUID& dstNodeGUID, const char* szDstInputName)
 101                 : m_srcNodeGUID(srcNodeGUID)
 102                 , m_srcOutputName(szSrcOutputName)
 103                 , m_dstNodeGUID(dstNodeGUID)
 104                 , m_dstInputName(szDstInputName)
 105         {}
 106
 107         //////////////////////////////////////////////////////////////////////////
 108         void CScriptGraphLink::SetSrcNodeGUID(const SGUID& guid)
 109         {
 110                 m_srcNodeGUID = guid;
 111         }
 112
 113         //////////////////////////////////////////////////////////////////////////
 114         SGUID CScriptGraphLink::GetSrcNodeGUID() const
 115         {
 116                 return m_srcNodeGUID;
 117         }
 118
 119         //////////////////////////////////////////////////////////////////////////
 120         const char* CScriptGraphLink::GetSrcOutputName() const
 121         {
 122                 return m_srcOutputName.c_str();
 123         }
 124
 125         //////////////////////////////////////////////////////////////////////////
 126         void CScriptGraphLink::SetDstNodeGUID(const SGUID& guid)
 127         {
 128                 m_dstNodeGUID = guid;
 129         }
 130
 131         //////////////////////////////////////////////////////////////////////////
 132         SGUID CScriptGraphLink::GetDstNodeGUID() const
 133         {
 134                 return m_dstNodeGUID;
 135         }
 136
 137         //////////////////////////////////////////////////////////////////////////
 138         const char* CScriptGraphLink::GetDstInputName() const
 139         {
 140                 return m_dstInputName.c_str();
 141         }
 142
 143         //////////////////////////////////////////////////////////////////////////
 144         void CScriptGraphLink::Serialize(Serialization::IArchive& archive)
 145         {
 146                 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
 147                 if(!archive.isEdit())
 148                 {
 149                         archive(m_srcNodeGUID, "src_node_guid");
 150                         archive(m_srcOutputName, "src_output_name");
 151                         archive(m_dstNodeGUID, "dst_node_guid");
 152                         archive(m_dstInputName, "dst_input_name");
 153                 }
 154         }
 155
 156         //////////////////////////////////////////////////////////////////////////
 157         CDocGraphBase::CDocGraphBase(IScriptFile& file, const SGUID& guid, const SGUID& scopeGUID, const char* szName, EScriptGraphType type, const SGUID& contextGUID)
 158                 : CScriptElementBase(EScriptElementType::Graph, file)
 159                 , m_guid(guid)
 160                 , m_scopeGUID(scopeGUID)
 161                 , m_name(szName)
 162                 , m_type(type)
 163                 , m_contextGUID(contextGUID)
 164                 , m_pos(ZERO)
 165         {}
 166
 167         //////////////////////////////////////////////////////////////////////////
 168         SGUID CDocGraphBase::GetGUID() const
 169         {
 170                 return m_guid;
 171         }
 172
 173         //////////////////////////////////////////////////////////////////////////
 174         SGUID CDocGraphBase::GetScopeGUID() const
 175         {
 176                 return m_scopeGUID;
 177         }
 178
 179         //////////////////////////////////////////////////////////////////////////
 180         bool CDocGraphBase::SetName(const char* szName)
 181         {
 182                 m_name = szName;
 183                 return true;
 184         }
 185
 186         //////////////////////////////////////////////////////////////////////////
 187         const char* CDocGraphBase::GetName() const
 188         {
 189                 return m_name.c_str();
 190         }
 191
 192         //////////////////////////////////////////////////////////////////////////
 193         void CDocGraphBase::EnumerateDependencies(const ScriptDependancyEnumerator& enumerator) const
 194         {
 195                 SCHEMATYC2_SYSTEM_ASSERT(enumerator);
 196                 if(enumerator)
 197                 {
 198                         if(m_contextGUID)
 199                         {
 200                                 enumerator(m_contextGUID);
 201                         }
 202                         for(const CScriptVariableDeclaration& input : m_inputs)
 203                         {
 204                                 input.EnumerateDependencies(enumerator);
 205                         }
 206                         for(const CScriptVariableDeclaration& output : m_outputs)
 207                         {
 208                                 output.EnumerateDependencies(enumerator);
 209                         }
 210                 }
 211         }
 212
 213         //////////////////////////////////////////////////////////////////////////
 214         void CDocGraphBase::Refresh(const SScriptRefreshParams& params)
 215         {
 216                 for(DocGraphNodeMap::value_type& node : m_nodes)
 217                 {
 218                         node.second.pNode->Refresh(params);
 219                 }
 220                 RemoveBrokenLinks();
 221         }
 222
 223         //////////////////////////////////////////////////////////////////////////
 224         void CDocGraphBase::Serialize(Serialization::IArchive& archive)
 225         {
 226                 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
 227
 228                 SerializationContext::SetValidatorLink(archive, SValidatorLink(m_guid)); // #SchematycTODO : This should be handled by derived classes!
 229
 230                 switch(SerializationContext::GetPass(archive))
 231                 {
 232                 case ESerializationPass::PreLoad:
 233                         {
 234                                 archive(m_pos, "pos");
 235                                 switch(m_type) // #SchematycTODO : Ideally it should be the implementation that decides whether or not to serialize inputs and outputs.
 236                                 {
 237                                 case EScriptGraphType::Function:
 238                                 case EScriptGraphType::Condition:
 239                                         {
 240                                                 archive(m_inputs, "inputs", "Inputs");
 241                                                 archive(m_outputs, "outputs", "Outputs");
 242                                                 break;
 243                                         }
 244                                 }
 245                                 Serialization::SContext fileContext(archive, static_cast<IScriptFile*>(&CScriptElementBase::GetFile())); // #SchematycTODO : Do we really need this?
 246                                 Serialization::SContext docGraphContext(archive, static_cast<CDocGraphBase*>(this)); // #SchematycTODO : Do we really need this?
 247                                 yasli::SerializeMapAsVector<DocGraphNodeMap, SGUID, SDocGraphNode>(archive, m_nodes, "nodes", "nodes");
 248                                 break;
 249                         }
 250                 case ESerializationPass::Load:
 251                         {
 252                                 switch(m_type) // #SchematycTODO : Ideally it should be the implementation that decides whether or not to serialize inputs and outputs.
 253                                 {
 254                                 case EScriptGraphType::Function:
 255                                 case EScriptGraphType::Condition:
 256                                         {
 257                                                 archive(m_inputs, "inputs", "Inputs");
 258                                                 archive(m_outputs, "outputs", "Outputs");
 259                                                 break;
 260                                         }
 261                                 }
 262                                 break;
 263                         }
 264                 case ESerializationPass::PostLoad:
 265                         {
 266                                 Serialization::SContext fileContext(archive, static_cast<IScriptFile*>(&CScriptElementBase::GetFile())); // #SchematycTODO : Do we really need this?
 267                                 Serialization::SContext docGraphContext(archive, static_cast<CDocGraphBase*>(this)); // #SchematycTODO : Do we really need this?
 268                                 yasli::SerializeMapAsVector<DocGraphNodeMap, SGUID, SDocGraphNode>(archive, m_nodes, "nodes", "nodes");
 269                                 archive(m_links, "links");
 270                                 break;
 271                         }
 272                 case ESerializationPass::Save:
 273                         {
 274                                 SInfoSerializer(*this).Serialize(archive);
 275                                 SDataSerializer(*this).Serialize(archive);
 276                                 SNodeAndLinkSerializer(*this).Serialize(archive);
 277                                 break;
 278                         }
 279                 case ESerializationPass::Edit:
 280                         {
 281                                 archive(m_name, "name", "!Name");
 282                                 break;
 283                         }
 284                 }
 285         }
 286
 287         //////////////////////////////////////////////////////////////////////////
 288         void CDocGraphBase::RemapGUIDs(IGUIDRemapper& guidRemapper)
 289         {
 290                 m_guid        = guidRemapper.Remap(m_guid);
 291                 m_scopeGUID   = guidRemapper.Remap(m_scopeGUID);
 292                 m_contextGUID = guidRemapper.Remap(m_contextGUID);
 293                 for(CScriptVariableDeclaration& input : m_inputs)
 294                 {
 295                         input.RemapGUIDs(guidRemapper);
 296                 }
 297                 for(CScriptVariableDeclaration& output : m_outputs)
 298                 {
 299                         output.RemapGUIDs(guidRemapper);
 300                 }
 301                 for(DocGraphNodeMap::value_type& node : m_nodes)
 302                 {
 303                         node.second.pNode->RemapGUIDs(guidRemapper);
 304                 }
 305         }
 306
 307         //////////////////////////////////////////////////////////////////////////
 308         EScriptGraphType CDocGraphBase::GetType() const
 309         {
 310                 return m_type;
 311         }
 312
 313         //////////////////////////////////////////////////////////////////////////
 314         SGUID CDocGraphBase::GetContextGUID() const
 315         {
 316                 return m_contextGUID;
 317         }
 318
 319         //////////////////////////////////////////////////////////////////////////
 320         void CDocGraphBase::SetPos(Vec2 pos)
 321         {
 322                 m_pos = pos;
 323         }
 324
 325         //////////////////////////////////////////////////////////////////////////
 326         Vec2 CDocGraphBase::GetPos() const
 327         {
 328                 return m_pos;
 329         }
 330
 331         //////////////////////////////////////////////////////////////////////////
 332         size_t CDocGraphBase::GetInputCount() const
 333         {
 334                 return m_inputs.size();
 335         }
 336
 337         //////////////////////////////////////////////////////////////////////////
 338         const char* CDocGraphBase::GetInputName(size_t inputIdx) const
 339         {
 340                 return inputIdx < m_inputs.size() ? m_inputs[inputIdx].GetName() : "";
 341         }
 342
 343         //////////////////////////////////////////////////////////////////////////
 344         IAnyConstPtr CDocGraphBase::GetInputValue(size_t inputIdx) const
 345         {
 346                 return inputIdx < m_inputs.size() ? m_inputs[inputIdx].GetValue() : IAnyConstPtr();
 347         }
 348
 349         //////////////////////////////////////////////////////////////////////////
 350         size_t CDocGraphBase::GetOutputCount() const
 351         {
 352                 return m_outputs.size();
 353         }
 354
 355         //////////////////////////////////////////////////////////////////////////
 356         const char* CDocGraphBase::GetOutputName(size_t outputIdx) const
 357         {
 358                 return outputIdx < m_outputs.size() ? m_outputs[outputIdx].GetName() : "";
 359         }
 360
 361         //////////////////////////////////////////////////////////////////////////
 362         IAnyConstPtr CDocGraphBase::GetOutputValue(size_t outputIdx) const
 363         {
 364                 return outputIdx < m_outputs.size() ? m_outputs[outputIdx].GetValue() : IAnyConstPtr();
 365         }
 366
 367         //////////////////////////////////////////////////////////////////////////
 368         size_t CDocGraphBase::GetAvailableNodeCount()
 369         {
 370                 return m_availableNodes.size();
 371         }
 372
 373         //////////////////////////////////////////////////////////////////////////
 374         const char* CDocGraphBase::GetAvailableNodeName(size_t availableNodeIdx) const
 375         {
 376                 return availableNodeIdx < m_availableNodes.size() ? m_availableNodes[availableNodeIdx].name.c_str() : "";
 377         }
 378
 379         //////////////////////////////////////////////////////////////////////////
 380         EScriptGraphNodeType CDocGraphBase::GetAvailableNodeType(size_t availableNodeIdx) const
 381         {
 382                 return availableNodeIdx < m_availableNodes.size() ? m_availableNodes[availableNodeIdx].type : EScriptGraphNodeType::Unknown;
 383         }
 384
 385         //////////////////////////////////////////////////////////////////////////
 386         SGUID CDocGraphBase::GetAvailableNodeContextGUID(size_t availableNodeIdx) const
 387         {
 388                 return availableNodeIdx < m_availableNodes.size() ? m_availableNodes[availableNodeIdx].contextGUID : SGUID();
 389         }
 390
 391         //////////////////////////////////////////////////////////////////////////
 392         SGUID CDocGraphBase::GetAvailableNodeRefGUID(size_t availableNodeIdx) const
 393         {
 394                 return availableNodeIdx < m_availableNodes.size() ? m_availableNodes[availableNodeIdx].refGUID : SGUID();
 395         }
 396
 397         //////////////////////////////////////////////////////////////////////////
 398         IScriptGraphNode* CDocGraphBase::AddNode(EScriptGraphNodeType type, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
 399         {
 400                 SCHEMATYC2_SYSTEM_ASSERT(gEnv->IsEditor());
 401                 if(gEnv->IsEditor())
 402                 {
 403                         const SGUID guid = gEnv->pSchematyc2->CreateGUID();
 404                         if(!GetNode(guid))
 405                         {
 406                                 IScriptGraphNodePtr pNode = CreateNode(guid, type, contextGUID, refGUID, pos);
 407                                 CRY_ASSERT(pNode);
 408                                 if(pNode)
 409                                 {
 410                                         m_nodes.insert(DocGraphNodeMap::value_type(guid, pNode));
 411                                         return pNode.get();
 412                                 }
 413                         }
 414                 }
 415                 return nullptr;
 416         }
 417
 418         //////////////////////////////////////////////////////////////////////////
 419         void CDocGraphBase::RemoveNode(const SGUID& guid)
 420         {
 421                 IScriptGraphNode* pNode = GetNode(guid);
 422                 SCHEMATYC2_SYSTEM_ASSERT(pNode);
 423                 if(pNode)
 424                 {
 425                         m_nodes.erase(guid);
 426                 }
 427         }
 428
 429         //////////////////////////////////////////////////////////////////////////
 430         IScriptGraphNode* CDocGraphBase::GetNode(const SGUID& guid)
 431         {
 432                 DocGraphNodeMap::iterator itNode = m_nodes.find(guid);
 433                 return itNode != m_nodes.end() ? itNode->second.pNode.get() : nullptr;
 434         }
 435
 436         //////////////////////////////////////////////////////////////////////////
 437         const IScriptGraphNode* CDocGraphBase::GetNode(const SGUID& guid) const
 438         {
 439                 DocGraphNodeMap::const_iterator itNode = m_nodes.find(guid);
 440                 return itNode != m_nodes.end() ? itNode->second.pNode.get() : nullptr;
 441         }
 442
 443         //////////////////////////////////////////////////////////////////////////
 444         void CDocGraphBase::VisitNodes(const ScriptGraphNodeVisitor& visitor)
 445         {
 446                 SCHEMATYC2_SYSTEM_ASSERT(visitor);
 447                 if(visitor)
 448                 {
 449                         for(DocGraphNodeMap::value_type& node : m_nodes)
 450                         {
 451                                 if(visitor(*node.second.pNode) != EVisitStatus::Continue)
 452                                 {
 453                                         return;
 454                                 }
 455                         }
 456                 }
 457         }
 458
 459         //////////////////////////////////////////////////////////////////////////
 460         void CDocGraphBase::VisitNodes(const ScriptGraphNodeConstVisitor& visitor) const
 461         {
 462                 SCHEMATYC2_SYSTEM_ASSERT(visitor);
 463                 if(visitor)
 464                 {
 465                         for(const DocGraphNodeMap::value_type& node : m_nodes)
 466                         {
 467                                 if(visitor(*node.second.pNode) != EVisitStatus::Continue)
 468                                 {
 469                                         return;
 470                                 }
 471                         }
 472                 }
 473         }
 474
 475         //////////////////////////////////////////////////////////////////////////
 476         bool CDocGraphBase::CanAddLink(const SGUID& srcNodeGUID, const char* szScOutputName, const SGUID& dstNodeGUID, const char* szDstInputName) const
 477         {
 478                 const IScriptGraphNode* pSrcNode = CDocGraphBase::GetNode(srcNodeGUID);
 479                 const IScriptGraphNode* pDstNode = CDocGraphBase::GetNode(dstNodeGUID);
 480                 SCHEMATYC2_SYSTEM_ASSERT(pSrcNode && pDstNode);
 481                 if(pSrcNode && pDstNode)
 482                 {
 483                         const size_t srcOutputIdx = DocUtils::FindGraphNodeOutput(*pSrcNode, szScOutputName);
 484                         const size_t dstInputIdx = DocUtils::FindGraphNodeInput(*pDstNode, szDstInputName);
 485                         SCHEMATYC2_SYSTEM_ASSERT((srcOutputIdx != INVALID_INDEX) && (dstInputIdx != INVALID_INDEX));
 486                         if((srcOutputIdx != INVALID_INDEX) && (dstInputIdx != INVALID_INDEX))
 487                         {
 488                                 const EScriptGraphPortFlags srcOutputFlags = pSrcNode->GetOutputFlags(srcOutputIdx);
 489                                 const EScriptGraphPortFlags dstInputFlags = pDstNode->GetInputFlags(dstInputIdx);
 490                                 const CAggregateTypeId      srcOutputTypeId = pSrcNode->GetOutputTypeId(srcOutputIdx);
 491                                 const CAggregateTypeId      dstInputTypeId = pDstNode->GetInputTypeId(dstInputIdx);
 492                                 if((((srcOutputFlags & EScriptGraphPortFlags::Execute) != 0) && ((dstInputFlags & EScriptGraphPortFlags::Execute) != 0)) || (srcOutputTypeId == dstInputTypeId))
 493                                 {
 494                                         if((pSrcNode->GetOutputFlags(srcOutputIdx) & EScriptGraphPortFlags::MultiLink) == 0)
 495                                         {
 496                                                 TScriptGraphLinkConstVector srcOutputLinks;
 497                                                 DocUtils::CollectGraphNodeOutputLinks(*this, srcNodeGUID, pSrcNode->GetOutputName(srcOutputIdx), srcOutputLinks);
 498                                                 if(!srcOutputLinks.empty())
 499                                                 {
 500                                                         return false;
 501                                                 }
 502                                         }
 503                                         if((pDstNode->GetInputFlags(dstInputIdx) & EScriptGraphPortFlags::MultiLink) == 0)
 504                                         {
 505                                                 TScriptGraphLinkConstVector dstInputLinks;
 506                                                 DocUtils::CollectGraphNodeInputLinks(*this, dstNodeGUID, pDstNode->GetInputName(dstInputIdx), dstInputLinks);
 507                                                 if(!dstInputLinks.empty())
 508                                                 {
 509                                                         return false;
 510                                                 }
 511                                         }
 512                                         if(CDocGraphBase::FindLink(srcNodeGUID, pSrcNode->GetOutputName(srcOutputIdx), dstNodeGUID, pDstNode->GetInputName(dstInputIdx)) != INVALID_INDEX)
 513                                         {
 514                                                 return false;
 515                                         }
 516                                         // Trace back along sequence to make sure we're not creating a loop.
 517                                         if(DocUtils::IsPrecedingNodeInGraphSequence(*this, *pSrcNode, dstNodeGUID))
 518                                         {
 519                                                 return false;
 520                                         }
 521                                         return true;
 522                                 }
 523                         }
 524                 }
 525                 return false;
 526         }
 527
 528         //////////////////////////////////////////////////////////////////////////
 529         IScriptGraphLink* CDocGraphBase::AddLink(const SGUID& srcNodeGUID, const char* szSrcOutputName, const SGUID& dstNodeGUID, const char* szDstInputName)
 530         {
 531                 if(FindLink(srcNodeGUID, szSrcOutputName, dstNodeGUID, szDstInputName))
 532                 {
 533                         CScriptGraphLinkPtr pLink(new CScriptGraphLink(srcNodeGUID, szSrcOutputName, dstNodeGUID, szDstInputName));
 534                         m_links.push_back(pLink);
 535                         return pLink.get();
 536                 }
 537                 return nullptr;
 538         }
 539
 540         //////////////////////////////////////////////////////////////////////////
 541         void CDocGraphBase::RemoveLink(size_t linkIdx)
 542         {
 543                 const size_t linkCount = m_links.size();
 544                 SCHEMATYC2_SYSTEM_ASSERT(linkIdx < linkCount);
 545                 if(linkIdx < linkCount)
 546                 {
 547                         m_signals.linkRemoved.Send(*m_links[linkIdx]);
 548                         m_links.erase(m_links.begin() + linkIdx);
 549                 }
 550         }
 551
 552         //////////////////////////////////////////////////////////////////////////
 553         void CDocGraphBase::RemoveLinks(const SGUID& nodeGUID)
 554         {
 555                 // #SchematycTODO : We can probably optimize this a bit.
 556                 for(size_t linkIdx = 0, linkCount = m_links.size(); linkIdx < linkCount; )
 557                 {
 558                         if((m_links[linkIdx]->GetSrcNodeGUID() == nodeGUID) || (m_links[linkIdx]->GetDstNodeGUID() == nodeGUID))
 559                         {
 560                                 m_signals.linkRemoved.Send(*m_links[linkIdx]);
 561                                 m_links.erase(m_links.begin() + linkIdx);
 562                                 -- linkCount;
 563                         }
 564                         else
 565                         {
 566                                 ++ linkIdx;
 567                         }
 568                 }
 569         }
 570
 571         //////////////////////////////////////////////////////////////////////////
 572         size_t CDocGraphBase::GetLinkCount() const
 573         {
 574                 return m_links.size();
 575         }
 576
 577         //////////////////////////////////////////////////////////////////////////
 578         size_t CDocGraphBase::FindLink(const SGUID& srcGUID, const char* szSrcOutputName, const SGUID& dstNodeGUID, const char* szDstInputName) const
 579         {
 580                 SCHEMATYC2_SYSTEM_ASSERT(szSrcOutputName && szDstInputName);
 581                 if(szSrcOutputName && szDstInputName)
 582                 {
 583                         for(LinkVector::const_iterator iBeginLink = m_links.begin(), iEndLink = m_links.end(), iLink = iBeginLink; iLink != iEndLink; ++ iLink)
 584                         {
 585                                 const CScriptGraphLink& link = *(*iLink);
 586                                 if((link.GetSrcNodeGUID() == srcGUID) && (link.GetDstNodeGUID() == dstNodeGUID) && (strcmp(link.GetSrcOutputName(), szSrcOutputName) == 0) && (strcmp(link.GetDstInputName(), szDstInputName) == 0))
 587                                 {
 588                                         return iLink - iBeginLink;
 589                                 }
 590                         }
 591                 }
 592                 return INVALID_INDEX;
 593         }
 594
 595         //////////////////////////////////////////////////////////////////////////
 596         IScriptGraphLink* CDocGraphBase::GetLink(size_t linkIdx)
 597         {
 598                 return linkIdx < m_links.size() ? m_links[linkIdx].get() : nullptr;
 599         }
 600
 601         //////////////////////////////////////////////////////////////////////////
 602         const IScriptGraphLink* CDocGraphBase::GetLink(size_t linkIdx) const
 603         {
 604                 return linkIdx < m_links.size() ? m_links[linkIdx].get() : nullptr;
 605         }
 606
 607         //////////////////////////////////////////////////////////////////////////
 608         void CDocGraphBase::VisitLinks(const ScriptGraphLinkVisitor& visitor)
 609         {
 610                 SCHEMATYC2_SYSTEM_ASSERT(visitor);
 611                 if(visitor)
 612                 {
 613                         for(CScriptGraphLinkPtr& pLink : m_links)
 614                         {
 615                                 if(visitor(*pLink) != EVisitStatus::Continue)
 616                                 {
 617                                         return;
 618                                 }
 619                         }
 620                 }
 621         }
 622
 623         //////////////////////////////////////////////////////////////////////////
 624         void CDocGraphBase::VisitLinks(const ScriptGraphLinkConstVisitor& visitor) const
 625         {
 626                 SCHEMATYC2_SYSTEM_ASSERT(visitor);
 627                 if(visitor)
 628                 {
 629                         for(const CScriptGraphLinkPtr& pLink : m_links)
 630                         {
 631                                 if(visitor(*pLink) != EVisitStatus::Continue)
 632                                 {
 633                                         return;
 634                                 }
 635                         }
 636                 }
 637         }
 638
 639         //////////////////////////////////////////////////////////////////////////
 640         void CDocGraphBase::RemoveBrokenLinks()
 641         {
 642                 size_t linkCount = m_links.size();
 643                 for(size_t linkIdx = 0; linkIdx < linkCount; )
 644                 {
 645                         CScriptGraphLink& link = *m_links[linkIdx];
 646                         if(IsBrokenLink(link))
 647                         {
 648                                 m_signals.linkRemoved.Send(link);
 649                                 -- linkCount;
 650                                 if(linkIdx < linkCount)
 651                                 {
 652                                         m_links[linkIdx] = m_links[linkCount];
 653                                 }
 654                         }
 655                         else
 656                         {
 657                                 ++ linkIdx;
 658                         }
 659                 }
 660                 m_links.resize(linkCount);
 661         }
 662
 663         //////////////////////////////////////////////////////////////////////////
 664         SScriptGraphSignals& CDocGraphBase::Signals()
 665         {
 666                 return m_signals;
 667         }
 668
 669         //////////////////////////////////////////////////////////////////////////
 670         void CDocGraphBase::SerializeNodeMapValue(Serialization::IArchive& archive, std::pair<SGUID, SDocGraphNode>& value)
 671         {
 672                 SerializationContext::SetValidatorLink(archive, SValidatorLink(m_guid));
 673
 674                 switch(SerializationContext::GetPass(archive))
 675                 {
 676                 case ESerializationPass::PreLoad:
 677                         {
 678                                 DocGraphBaseUtils::SNodeHeader nodeHeader;
 679                                 archive(nodeHeader, "header");
 680                                 IScriptGraphNodePtr pNode = CreateNode(nodeHeader.guid, nodeHeader.type, nodeHeader.contextGUID, nodeHeader.refGUID, nodeHeader.pos);
 681                                 SCHEMATYC2_SYSTEM_ASSERT(pNode);
 682                                 if(pNode)
 683                                 {
 684                                         value.first  = nodeHeader.guid;
 685                                         value.second = pNode;
 686                                         // Hack to fix cloning of state nodes.
 687                                         if(nodeHeader.type == EScriptGraphNodeType::State)
 688                                         {
 689                                                 archive(*value.second.pNode, "detail");
 690                                         }
 691                                 }
 692                                 break;
 693                         }
 694                 case ESerializationPass::PostLoad:
 695                         {
 696                                 archive(*value.second.pNode, "detail");
 697                                 break;
 698                         }
 699                 case ESerializationPass::Save:
 700                         {
 701                                 IScriptGraphNode&              node = *value.second.pNode;
 702                                 DocGraphBaseUtils::SNodeHeader nodeHeader(node.GetGUID(), node.GetType(), node.GetContextGUID(), node.GetRefGUID(), node.GetPos());
 703                                 archive(nodeHeader, "header");
 704                                 archive(node, "detail");
 705                                 break;
 706                         }
 707                 }
 708         }
 709
 710         //////////////////////////////////////////////////////////////////////////
 711         void CDocGraphBase::AddAvailableNode(const char* szName, EScriptGraphNodeType type, const SGUID& contextGUID, const SGUID& refGUID)
 712         {
 713                 m_availableNodes.push_back(SAvailableNode(szName, type, contextGUID, refGUID));
 714         }
 715
 716         //////////////////////////////////////////////////////////////////////////
 717         void CDocGraphBase::ClearAvailablNodes()
 718         {
 719                 m_availableNodes.clear();
 720         }
 721
 722         //////////////////////////////////////////////////////////////////////////
 723         ScriptVariableDeclarationVector& CDocGraphBase::GetInputs()
 724         {
 725                 return m_inputs;
 726         }
 727
 728         //////////////////////////////////////////////////////////////////////////
 729         ScriptVariableDeclarationVector& CDocGraphBase::GetOutputs()
 730         {
 731                 return m_outputs;
 732         }
 733
 734         //////////////////////////////////////////////////////////////////////////
 735         CDocGraphBase::SInfoSerializer::SInfoSerializer(CDocGraphBase& _graph)
 736                 : graph(_graph)
 737         {}
 738
 739         //////////////////////////////////////////////////////////////////////////
 740         void CDocGraphBase::SInfoSerializer::Serialize(Serialization::IArchive& archive)
 741         {
 742                 archive(graph.m_pos, "pos");
 743         }
 744
 745         //////////////////////////////////////////////////////////////////////////
 746         CDocGraphBase::SDataSerializer::SDataSerializer(CDocGraphBase& _graph)
 747                 : graph(_graph)
 748         {}
 749
 750         //////////////////////////////////////////////////////////////////////////
 751         void CDocGraphBase::SDataSerializer::Serialize(Serialization::IArchive& archive)
 752         {
 753                 // #SchematycTODO : Ideally it should be the implementation that decides whether or not to serialize inputs and outputs.
 754                 switch(graph.m_type)
 755                 {
 756                 case EScriptGraphType::Function:
 757                 case EScriptGraphType::Condition:
 758                         {
 759                                 Serialization::SContext fileContext(archive, static_cast<IScriptFile*>(&graph.GetFile())); // #SchematycTODO : Do we still need this?
 760                                 Serialization::SContext docGraphContext(archive, static_cast<CDocGraphBase*>(&graph)); // #SchematycTODO : Do we still need this?
 761                                 archive(graph.m_inputs, "inputs", "Inputs");
 762                                 archive(graph.m_outputs, "outputs", "Outputs");
 763                                 break;
 764                         }
 765                 }
 766         }
 767
 768         //////////////////////////////////////////////////////////////////////////
 769         CDocGraphBase::SNodeAndLinkSerializer::SNodeAndLinkSerializer(CDocGraphBase& _graph)
 770                 : graph(_graph)
 771         {}
 772
 773         //////////////////////////////////////////////////////////////////////////
 774         void CDocGraphBase::SNodeAndLinkSerializer::Serialize(Serialization::IArchive& archive)
 775         {
 776                 Serialization::SContext fileContext(archive, static_cast<IScriptFile*>(&graph.GetFile())); // #SchematycTODO : Do we still need this?
 777                 Serialization::SContext docGraphContext(archive, static_cast<CDocGraphBase*>(&graph)); // #SchematycTODO : Do we still need this?
 778                 yasli::SerializeMapAsVector<DocGraphNodeMap, SGUID, SDocGraphNode>(archive, graph.m_nodes, "nodes", "nodes");
 779
 780                 std::sort(graph.m_links.begin(), graph.m_links.end(), [](const CScriptGraphLinkPtr a, const CScriptGraphLinkPtr b)
 781                 {
 782                         return a->GetSrcNodeGUID() > b->GetSrcNodeGUID();
 783                 });
 784
 785                 archive(graph.m_links, "links");
 786         }
 787
 788         //////////////////////////////////////////////////////////////////////////
 789         CDocGraphBase::SAvailableNode::SAvailableNode(const char* _szName, EScriptGraphNodeType _type, const SGUID& _contextGUID, const SGUID& _refGUID)
 790                 : name(_szName)
 791                 , type(_type)
 792                 , contextGUID(_contextGUID)
 793                 , refGUID(_refGUID)
 794         {}
 795
 796         //////////////////////////////////////////////////////////////////////////
 797         bool CDocGraphBase::IsBrokenLink(const CScriptGraphLink& link) const
 798         {
 799                 const IScriptGraphNode* pSrcNode = GetNode(link.GetSrcNodeGUID());
 800                 if(!pSrcNode || (DocUtils::FindGraphNodeOutput(*pSrcNode, link.GetSrcOutputName()) == INVALID_INDEX))
 801                 {
 802                         return true;
 803                 }
 804                 const IScriptGraphNode* pDstNode = GetNode(link.GetDstNodeGUID());
 805                 if(!pDstNode || (DocUtils::FindGraphNodeInput(*pDstNode, link.GetDstInputName()) == INVALID_INDEX))
 806                 {
 807                         return true;
 808                 }
 809                 return false;
 810         }
 811 }