Code/CryEngine/CrySchematyc2/Script/Elements/ScriptAbstractInterfaceImplementation.cpp

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "Script/Elements/ScriptAbstractInterfaceImplementation.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/IAbstractInterface.h>
  11 #include <CrySchematyc2/ICompiler.h>
  12 #include <CrySchematyc2/Deprecated/DocUtils.h>
  13 #include <CrySchematyc2/Env/IEnvRegistry.h>
  14 #include <CrySchematyc2/Script/IScriptGraph.h>
  15 #include <CrySchematyc2/Serialization/ISerializationContext.h>
  16 #include <CrySchematyc2/Serialization/SerializationUtils.h>
  17
  18 namespace Schematyc2
  19 {
  20         //////////////////////////////////////////////////////////////////////////
  21         CScriptAbstractInterfaceImplementation::CScriptAbstractInterfaceImplementation(IScriptFile& file, const SGUID& guid, const SGUID& scopeGUID, EDomain domain, const SGUID& refGUID)
  22                 : CScriptElementBase(EScriptElementType::AbstractInterfaceImplementation, file)
  23                 , m_guid(guid)
  24                 , m_scopeGUID(scopeGUID)
  25                 , m_domain(domain)
  26                 , m_refGUID(refGUID)
  27         {}
  28
  29         //////////////////////////////////////////////////////////////////////////
  30         EAccessor CScriptAbstractInterfaceImplementation::GetAccessor() const
  31         {
  32                 return EAccessor::Private;
  33         }
  34
  35         //////////////////////////////////////////////////////////////////////////
  36         SGUID CScriptAbstractInterfaceImplementation::GetGUID() const
  37         {
  38                 return m_guid;
  39         }
  40
  41         //////////////////////////////////////////////////////////////////////////
  42         SGUID CScriptAbstractInterfaceImplementation::GetScopeGUID() const
  43         {
  44                 return m_scopeGUID;
  45         }
  46
  47         //////////////////////////////////////////////////////////////////////////
  48         bool CScriptAbstractInterfaceImplementation::SetName(const char* szName)
  49         {
  50                 return false;
  51         }
  52
  53         //////////////////////////////////////////////////////////////////////////
  54         const char* CScriptAbstractInterfaceImplementation::GetName() const
  55         {
  56                 return m_name.c_str();
  57         }
  58
  59         //////////////////////////////////////////////////////////////////////////
  60         void CScriptAbstractInterfaceImplementation::EnumerateDependencies(const ScriptDependancyEnumerator& enumerator) const
  61         {
  62                 SCHEMATYC2_SYSTEM_ASSERT(enumerator);
  63                 if(enumerator)
  64                 {
  65                         if(m_domain == EDomain::Script)
  66                         {
  67                                 enumerator(m_refGUID);
  68                         }
  69                 }
  70         }
  71
  72         //////////////////////////////////////////////////////////////////////////
  73         void CScriptAbstractInterfaceImplementation::Refresh(const SScriptRefreshParams& params)
  74         {
  75                 if((params.reason == EScriptRefreshReason::EditorAdd) || (params.reason == EScriptRefreshReason::EditorFixUp) || (params.reason == EScriptRefreshReason::EditorPaste) || (params.reason == EScriptRefreshReason::EditorDependencyModified))
  76                 {
  77                         switch(m_domain)
  78                         {
  79                         case EDomain::Env:
  80                                 {
  81                                         IAbstractInterfaceConstPtr pAbstractInterface = gEnv->pSchematyc2->GetEnvRegistry().GetAbstractInterface(m_refGUID);
  82                                         if(pAbstractInterface)
  83                                         {
  84                                                 m_name = pAbstractInterface->GetName();
  85                                                 RefreshEnvAbstractrInterfaceFunctions(*pAbstractInterface);
  86                                         }
  87                                         break;
  88                                 }
  89                         case EDomain::Script:
  90                                 {
  91                                         ScriptIncludeRecursionUtils::TGetAbstractInterfaceResult abstractInterface = ScriptIncludeRecursionUtils::GetAbstractInterface(CScriptElementBase::GetFile(), m_refGUID);
  92                                         if(abstractInterface.second)
  93                                         {
  94                                                 m_name = abstractInterface.second->GetName();
  95                                                 RefreshScriptAbstractrInterfaceFunctions(*abstractInterface.first);
  96                                                 RefreshScriptAbstractrInterfaceTasks(*abstractInterface.first);
  97                                         }
  98                                         break;
  99                                 }
 100                         }
 101                 }
 102         }
 103
 104         //////////////////////////////////////////////////////////////////////////
 105         void CScriptAbstractInterfaceImplementation::Serialize(Serialization::IArchive& archive)
 106         {
 107                 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
 108
 109                 CScriptElementBase::Serialize(archive);
 110
 111                 SerializationContext::SetValidatorLink(archive, SValidatorLink(m_guid)); // #SchematycTODO : Can we set this from CScriptElementBase?
 112                 switch(SerializationContext::GetPass(archive))
 113                 {
 114                 case ESerializationPass::PreLoad:
 115                 case ESerializationPass::Save:
 116                         {
 117                                 archive(m_guid, "guid");
 118                                 archive(m_scopeGUID, "scope_guid");
 119                                 archive(m_name, "name");
 120                                 archive(m_domain, "origin"); // #SchematycTODO : Update name and patch files!
 121                                 archive(m_refGUID, "abstract_interface_guid");
 122                                 break;
 123                         }
 124                 case ESerializationPass::Validate:
 125                         {
 126                                 Validate(archive);
 127                                 break;
 128                         }
 129                 }
 130         }
 131
 132         //////////////////////////////////////////////////////////////////////////
 133         void CScriptAbstractInterfaceImplementation::RemapGUIDs(IGUIDRemapper& guidRemapper)
 134         {
 135                 m_guid      = guidRemapper.Remap(m_guid);
 136                 m_scopeGUID = guidRemapper.Remap(m_scopeGUID);
 137                 m_refGUID   = guidRemapper.Remap(m_refGUID);
 138         }
 139
 140         //////////////////////////////////////////////////////////////////////////
 141         EDomain CScriptAbstractInterfaceImplementation::GetDomain() const
 142         {
 143                 return m_domain;
 144         }
 145
 146         //////////////////////////////////////////////////////////////////////////
 147         SGUID CScriptAbstractInterfaceImplementation::GetRefGUID() const
 148         {
 149                 return m_refGUID;
 150         }
 151
 152         //////////////////////////////////////////////////////////////////////////
 153         void CScriptAbstractInterfaceImplementation::RefreshEnvAbstractrInterfaceFunctions(const IAbstractInterface& abstractInterface)
 154         {
 155                 // Collect graphs.
 156                 IScriptFile&    file = CScriptElementBase::GetFile();
 157                 TDocGraphVector graphs;
 158                 DocUtils::CollectGraphs(file, m_guid, false, graphs);
 159                 // Iterate through all functions in abstract interface and create corresponding graphs (if they don't already exist).
 160                 for(size_t functionIdx = 0, functionCount = abstractInterface.GetFunctionCount(); functionIdx < functionCount; ++ functionIdx)
 161                 {
 162                         IAbstractInterfaceFunctionConstPtr pFunction = abstractInterface.GetFunction(functionIdx);
 163                         const SGUID                        functionGUID = pFunction->GetGUID();
 164                         bool                               bGraphExists = false;
 165                         for(const IDocGraph* pGraph : graphs)
 166                         {
 167                                 if(pGraph->GetContextGUID() == functionGUID)
 168                                 {
 169                                         bGraphExists = true;
 170                                         break;
 171                                 }
 172                         }
 173                         if(!bGraphExists)
 174                         {
 175                                 IDocGraph* pGraph = file.AddGraph(SScriptGraphParams(m_guid, pFunction->GetName(), EScriptGraphType::AbstractInterfaceFunction, functionGUID));
 176                                 CRY_ASSERT(pGraph);
 177                                 if(pGraph)
 178                                 {
 179                                         pGraph->AddNode(EScriptGraphNodeType::Begin, SGUID(), SGUID(), Vec2(0.0f, 0.0f));       // #SchematycTODO : This should be handled by the graph itself!!!
 180                                         graphs.push_back(pGraph);
 181                                 }
 182                         }
 183                 }
 184         }
 185
 186         //////////////////////////////////////////////////////////////////////////
 187         void CScriptAbstractInterfaceImplementation::RefreshScriptAbstractrInterfaceFunctions(const IScriptFile& abstractrInterfaceFile)
 188         {
 189                 typedef std::map<SGUID, IDocGraph*> FunctionGraphs;
 190
 191                 IScriptFile&   file = CScriptElementBase::GetFile();
 192                 FunctionGraphs functionGraphs;
 193
 194                 auto visitGraph = [&functionGraphs] (IDocGraph& graph) -> EVisitStatus
 195                 {
 196                         if(graph.GetType() == EScriptGraphType::AbstractInterfaceFunction)
 197                         {
 198                                 functionGraphs.insert(FunctionGraphs::value_type(graph.GetContextGUID(), &graph));
 199                         }
 200                         return EVisitStatus::Continue;
 201                 };
 202                 file.VisitGraphs(DocGraphVisitor::FromLambdaFunction(visitGraph), m_guid, false);
 203
 204                 auto visitAbstractInterfaceFunction = [this, &file, &functionGraphs] (const IScriptAbstractInterfaceFunction& function) -> EVisitStatus
 205                 {
 206                         const SGUID              functionGUID = function.GetGUID();
 207                         FunctionGraphs::iterator itFunctionGraph = functionGraphs.find(functionGUID);
 208                         if(itFunctionGraph == functionGraphs.end())
 209                         {
 210                                 IDocGraph* pGraph = file.AddGraph(SScriptGraphParams(m_guid, function.GetName(), EScriptGraphType::AbstractInterfaceFunction, functionGUID));
 211                                 CRY_ASSERT(pGraph);
 212                                 if(pGraph)
 213                                 {
 214                                         pGraph->AddNode(EScriptGraphNodeType::Begin, SGUID(), SGUID(), Vec2(0.0f, 0.0f)); // #SchematycTODO : This should be handled by the graph itself!!!
 215                                 }
 216                         }
 217                         else
 218                         {
 219                                 functionGraphs.erase(itFunctionGraph);
 220                         }
 221                         return EVisitStatus::Continue;
 222                 };
 223                 abstractrInterfaceFile.VisitAbstractInterfaceFunctions(ScriptAbstractInterfaceFunctionConstVisitor::FromLambdaFunction(visitAbstractInterfaceFunction), m_refGUID, false);
 224
 225                 for(FunctionGraphs::value_type& functionGraph : functionGraphs)
 226                 {
 227                         functionGraph.second->SetElementFlags(EScriptElementFlags::Discard);
 228                 }
 229         }
 230
 231         //////////////////////////////////////////////////////////////////////////
 232         void CScriptAbstractInterfaceImplementation::RefreshScriptAbstractrInterfaceTasks(const IScriptFile& abstractrInterfaceFile)
 233         {
 234                 typedef std::unordered_map<SGUID, IScriptStateMachine*> TaskStateMachines;
 235
 236                 IScriptFile&      file = CScriptElementBase::GetFile();
 237                 TaskStateMachines taskStateMachines;
 238
 239                 auto visitStateMachine = [&taskStateMachines] (IScriptStateMachine& stateMachine) -> EVisitStatus
 240                 {
 241                         if(stateMachine.GetLifetime() == EStateMachineLifetime::Task)
 242                         {
 243                                 taskStateMachines.insert(TaskStateMachines::value_type(stateMachine.GetContextGUID(), &stateMachine));
 244                         }
 245                         return EVisitStatus::Continue;
 246                 };
 247                 file.VisitStateMachines(ScriptStateMachineVisitor::FromLambdaFunction(visitStateMachine), m_guid, false);
 248
 249                 auto visitAbstractInterfaceTask = [this, &abstractrInterfaceFile, &file, &taskStateMachines] (const IScriptAbstractInterfaceTask& task) -> EVisitStatus
 250                 {
 251                         const SGUID                 taskGUID = task.GetGUID();
 252                         TaskStateMachines::iterator itTaskStateMachine = taskStateMachines.find(taskGUID);
 253                         if(itTaskStateMachine == taskStateMachines.end())
 254                         {
 255                                 file.AddStateMachine(m_guid, task.GetName(), EStateMachineLifetime::Task, taskGUID, SGUID());
 256                         }
 257                         else
 258                         {
 259                                 taskStateMachines.erase(itTaskStateMachine);
 260                         }
 261                         RefreshScriptAbstractrInterfaceTaskPropertiess(abstractrInterfaceFile, taskGUID);
 262                         return EVisitStatus::Continue;
 263                 };
 264                 abstractrInterfaceFile.VisitAbstractInterfaceTasks(ScriptAbstractInterfaceTaskConstVisitor::FromLambdaFunction(visitAbstractInterfaceTask), m_refGUID, false);
 265
 266                 for(TaskStateMachines::value_type& taskStateMachine : taskStateMachines)
 267                 {
 268                         taskStateMachine.second->SetElementFlags(EScriptElementFlags::Discard);
 269                 }
 270         }
 271
 272         //////////////////////////////////////////////////////////////////////////
 273         void CScriptAbstractInterfaceImplementation::RefreshScriptAbstractrInterfaceTaskPropertiess(const IScriptFile& abstractrInterfaceFile, const SGUID& taskGUID) {}
 274
 275         //////////////////////////////////////////////////////////////////////////
 276         void CScriptAbstractInterfaceImplementation::Validate(Serialization::IArchive& archive)
 277         {
 278                 if(m_refGUID)
 279                 {
 280                         switch(m_domain)
 281                         {
 282                         case EDomain::Env:
 283                                 {
 284                                         IAbstractInterfaceConstPtr pAbstractInterface = gEnv->pSchematyc2->GetEnvRegistry().GetAbstractInterface(m_refGUID);
 285                                         if(!pAbstractInterface)
 286                                         {
 287                                                 archive.error(*this, "Unable to retrieve abstract interface!");
 288                                         }
 289                                         break;
 290                                 }
 291                         case EDomain::Script:
 292                                 {
 293                                         ScriptIncludeRecursionUtils::TGetAbstractInterfaceResult abstractInterface = ScriptIncludeRecursionUtils::GetAbstractInterface(CScriptElementBase::GetFile(), m_refGUID);
 294                                         if(!abstractInterface.second)
 295                                         {
 296                                                 archive.error(*this, "Unable to retrieve abstract interface!");
 297                                         }
 298                                         break;
 299                                 }
 300                         }
 301                 }
 302         }
 303 }