Code/CryEngine/CrySchematyc2/Script/GraphNodes/ScriptGraphSwitchNode.cpp

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "Script/GraphNodes/ScriptGraphSwitchNode.h"
   5
   6 #include <CryString/CryStringUtils.h>
   7 #include <CrySchematyc2/GUIDRemapper.h>
   8 #include <CrySchematyc2/IDomainContext.h>
   9 #include <CrySchematyc2/IObject.h>
  10 #include <CrySchematyc2/LibUtils.h>
  11 #include <CrySchematyc2/Script/IScriptGraphNodeCompiler.h>
  12 #include <CrySchematyc2/Script/IScriptGraphNodeCreationMenu.h>
  13 #include <CrySchematyc2/Serialization/ISerializationContext.h>
  14
  15 #include "AggregateTypeIdSerialize.h"
  16 #include "DomainContext.h"
  17 #include "Script/ScriptVariableDeclaration.h"
  18 #include "Script/GraphNodes/ScriptGraphNodeFactory.h"
  19
  20 namespace Schematyc2
  21 {
  22         const SGUID CScriptGraphSwitchNode::s_typeGUID = "1d081133-e900-4244-add5-f0831d27b16f";
  23
  24         CScriptGraphSwitchNode::SCase::SCase() {}
  25
  26         CScriptGraphSwitchNode::SCase::SCase(const IAnyPtr& _pValue)
  27                 : pValue(_pValue)
  28         {}
  29
  30         void CScriptGraphSwitchNode::SCase::Serialize(Serialization::IArchive& archive)
  31         {
  32                 const IAny* pDefaultValue = archive.context<IAny>();
  33                 SCHEMATYC2_SYSTEM_ASSERT(pDefaultValue);
  34                 if(!pValue && pDefaultValue)
  35                 {
  36                         pValue = pDefaultValue->Clone();
  37                 }
  38                 if(pValue)
  39                 {
  40                         archive(*pValue, "value", "^Value");
  41                         if(archive.isValidation())
  42                         {
  43                                 char stringBuffer[512] = "";
  44                                 ToString(*pValue, stringBuffer);
  45                                 if(!stringBuffer[0])
  46                                 {
  47                                         archive.error(*this, "Empty case value!");
  48                                 }
  49                         }
  50                 }
  51                 else if(archive.isValidation())
  52                 {
  53                         archive.error(*this, "Unable to instantiate case value!");
  54                 }
  55         }
  56
  57         CScriptGraphSwitchNode::CScriptGraphSwitchNode(const SGUID& guid)
  58                 : CScriptGraphNodeBase(guid)
  59         {}
  60
  61         CScriptGraphSwitchNode::CScriptGraphSwitchNode(const SGUID& guid, const Vec2& pos)
  62                 : CScriptGraphNodeBase(guid, pos)
  63         {}
  64
  65         SGUID CScriptGraphSwitchNode::GetTypeGUID() const
  66         {
  67                 return s_typeGUID;
  68         }
  69
  70         EScriptGraphColor CScriptGraphSwitchNode::GetColor() const
  71         {
  72                 return EScriptGraphColor::Orange;
  73         }
  74
  75         void CScriptGraphSwitchNode::Refresh(const SScriptRefreshParams& params)
  76         {
  77                 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
  78
  79                 CScriptGraphNodeBase::Refresh(params);
  80
  81                 CScriptGraphNodeBase::SetName("Switch");
  82                 CScriptGraphNodeBase::AddInput(EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Execute, "In");
  83                 CScriptGraphNodeBase::AddOutput(EScriptGraphPortFlags::Execute | EScriptGraphPortFlags::SpacerBelow, "Default");
  84
  85                 if(m_typeId)
  86                 {
  87                         CScriptGraphNodeBase::AddInput(EScriptGraphPortFlags::Data, "Value", m_typeId);
  88
  89                         uint32 invalidCaseCount = 0;
  90                         for(SCase& _case : m_cases)
  91                         {
  92                                 char outputName[128] = "";
  93                                 if(_case.pValue)
  94                                 {
  95                                         ToString(*_case.pValue, outputName);
  96                                 }
  97                                 if(!outputName[0])
  98                                 {
  99                                         cry_sprintf(outputName, "INVALID_CASE[%d]", ++ invalidCaseCount);
 100                                 }
 101                                 CScriptGraphNodeBase::AddOutput(EScriptGraphPortFlags::Removable | EScriptGraphPortFlags::Execute, outputName);
 102                         }
 103                 }
 104         }
 105
 106         void CScriptGraphSwitchNode::Serialize(Serialization::IArchive& archive)
 107         {
 108                 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
 109
 110                 CScriptGraphNodeBase::Serialize(archive);
 111
 112                 switch(SerializationContext::GetPass(archive))
 113                 {
 114                 case ESerializationPass::PreLoad:
 115                         {
 116                                 SerializeBasicInfo(archive);
 117                                 break;
 118                         }
 119                 case ESerializationPass::PostLoad:
 120                         {
 121                                 CreateDefaultValue();
 122                                 SerializeCases(archive);
 123                                 break;
 124                         }
 125                 case ESerializationPass::Save:
 126                         {
 127                                 SerializeBasicInfo(archive);
 128                                 SerializeCases(archive);
 129                                 break;
 130                         }
 131                 case ESerializationPass::Edit:
 132                         {
 133                                 Edit(archive);
 134                                 SerializeCases(archive);
 135                                 Validate(archive);
 136                                 break;
 137                         }
 138                 case ESerializationPass::Validate:
 139                         {
 140                                 SerializeCases(archive);
 141                                 Validate(archive);
 142                                 break;
 143                         }
 144                 }
 145         }
 146
 147         void CScriptGraphSwitchNode::RemapGUIDs(IGUIDRemapper& guidRemapper)
 148         {
 149                 CScriptGraphNodeBase::RemapGUIDs(guidRemapper);
 150
 151                 if(m_typeId.GetDomain() == EDomain::Script) // #SchematycTODO : Create CAggregateTypeId::RemapGUIDs() function?
 152                 {
 153                         m_typeId = CAggregateTypeId::FromScriptTypeGUID(guidRemapper.Remap(m_typeId.AsScriptTypeGUID()));
 154                 }
 155         }
 156
 157         void CScriptGraphSwitchNode::Compile_New(IScriptGraphNodeCompiler& compiler) const
 158         {
 159                 if(m_pDefaultValue)
 160                 {
 161                         compiler.BindCallback(&Execute);
 162
 163                         const uint32 caseCount = m_cases.size();
 164                         compiler.BindAttribute(EAttributeId::CaseCount, caseCount);
 165                         for(uint32 caseIdx = 0; caseIdx < caseCount; ++ caseIdx)
 166                         {
 167                                 if(m_cases[caseIdx].pValue)
 168                                 {
 169                                         compiler.BindAnyAttribute(EAttributeId::FirstCase + caseIdx, *m_cases[caseIdx].pValue);
 170                                 }
 171                         }
 172
 173                         compiler.BindAnyInput(EInputIdx::Value, *m_pDefaultValue);
 174                 }
 175         }
 176
 177         void CScriptGraphSwitchNode::RegisterCreator(CScriptGraphNodeFactory& factory)
 178         {
 179                 class CCreator : public IScriptGraphNodeCreator
 180                 {
 181                 private:
 182
 183                         class CNodeCreationMenuCommand : public IScriptGraphNodeCreationMenuCommand
 184                         {
 185                         public:
 186
 187                                 // IMenuCommand
 188
 189                                 IScriptGraphNodePtr Execute(const Vec2& pos)
 190                                 {
 191                                         return std::make_shared<CScriptGraphSwitchNode>(gEnv->pSchematyc2->CreateGUID(), pos);
 192                                 }
 193
 194                                 // ~IMenuCommand
 195                         };
 196
 197                 public:
 198
 199                         // IScriptGraphNodeCreator
 200
 201                         virtual SGUID GetTypeGUID() const override
 202                         {
 203                                 return CScriptGraphSwitchNode::s_typeGUID;
 204                         }
 205
 206                         virtual IScriptGraphNodePtr CreateNode() override
 207                         {
 208                                 return std::make_shared<CScriptGraphSwitchNode>(gEnv->pSchematyc2->CreateGUID());
 209                         }
 210
 211                         virtual void PopulateNodeCreationMenu(IScriptGraphNodeCreationMenu& nodeCreationMenu, const IDomainContext& domainContext, const IScriptGraphExtension& graph) override
 212                         {
 213                                 nodeCreationMenu.AddOption("Switch", "Switch on input value", "", std::make_shared<CNodeCreationMenuCommand>());
 214                         }
 215
 216                         // ~IScriptGraphNodeCreator
 217                 };
 218
 219                 factory.RegisterCreator(std::make_shared<CCreator>());
 220         }
 221
 222         void CScriptGraphSwitchNode::CreateDefaultValue()
 223         {
 224                 if(!m_pDefaultValue || (m_pDefaultValue->GetTypeInfo().GetTypeId() != m_typeId))
 225                 {
 226                         m_pDefaultValue = MakeScriptVariableValueShared(CScriptGraphNodeBase::GetGraph()->GetElement_New().GetFile(), m_typeId);
 227
 228                         m_cases.clear();
 229                 }
 230         }
 231
 232         void CScriptGraphSwitchNode::SerializeBasicInfo(Serialization::IArchive& archive)
 233         {
 234                 archive(m_typeId, "typeId");
 235         }
 236
 237         void CScriptGraphSwitchNode::SerializeCases(Serialization::IArchive& archive)
 238         {
 239                 Serialization::SContext context(archive, static_cast<IAny*>(m_pDefaultValue.get()));
 240                 archive(m_cases, "cases", "Cases");
 241         }
 242
 243         void CScriptGraphSwitchNode::Edit(Serialization::IArchive& archive)
 244         {
 245                 TypeIds                   typeIds;
 246                 Serialization::StringList typeNames;
 247                 typeIds.reserve(50);
 248                 typeNames.reserve(50);
 249
 250                 auto visitEnvType = [&typeIds, &typeNames] (const IEnvTypeDesc& envTypeDesc) -> EVisitStatus
 251                 {
 252                         if((envTypeDesc.GetCategory() == EEnvTypeCategory::Enumeration) || ((envTypeDesc.GetFlags() & EEnvTypeFlags::Switchable) != 0))
 253                         {
 254                                 typeIds.push_back(envTypeDesc.GetTypeInfo().GetTypeId());
 255                                 typeNames.push_back(envTypeDesc.GetName());
 256                         }
 257                         return EVisitStatus::Continue;
 258                 };
 259                 gEnv->pSchematyc2->GetEnvRegistry().VisitTypeDescs(EnvTypeDescVisitor::FromLambdaFunction(visitEnvType)); // #SchematycTODO : Use domain context?
 260
 261                 const IScriptElement& scriptElement = CScriptGraphNodeBase::GetGraph()->GetElement_New();
 262                 CDomainContext        domainContext(SDomainContextScope(&scriptElement.GetFile(), scriptElement.GetScopeGUID()));
 263                 auto visitScriptEnumeration = [&typeIds, &typeNames, &domainContext] (const IScriptEnumeration& scriptEnumeration) -> EVisitStatus
 264                 {
 265                         typeIds.push_back(scriptEnumeration.GetTypeId());
 266
 267                         stack_string typeName;
 268                         domainContext.QualifyName(scriptEnumeration, EDomainQualifier::Local, typeName);
 269                         typeNames.push_back(typeName.c_str());
 270
 271                         return EVisitStatus::Continue;
 272                 };
 273                 domainContext.VisitScriptEnumerations(ScriptEnumerationConstVisitor::FromLambdaFunction(visitScriptEnumeration), EDomainScope::Derived);
 274
 275                 if(archive.isInput())
 276                 {
 277                         Serialization::StringListValue typeName(typeNames, 0);
 278                         archive(typeName, "typeName", "Type");
 279
 280                         const CAggregateTypeId oldTypeId = m_typeId;
 281                         const CAggregateTypeId newTypeId = typeIds[typeName.index()];
 282                         m_typeId = newTypeId;
 283                         if (oldTypeId != newTypeId)
 284                         {
 285                                 m_cases.clear();
 286                                 CScriptGraphNodeBase::GetGraph()->RemoveLinks(CScriptGraphNodeBase::GetGUID());
 287                         }
 288                         CreateDefaultValue();
 289                 }
 290                 else if(archive.isOutput())
 291                 {
 292                         int               typeIdx;
 293                         TypeIds::iterator itTypeId = std::find(typeIds.begin(), typeIds.end(), m_typeId);
 294                         if(itTypeId != typeIds.end())
 295                         {
 296                                 typeIdx = static_cast<int>(itTypeId - typeIds.begin());
 297                         }
 298                         else
 299                         {
 300                                 typeIds.push_back(m_typeId);
 301                                 typeNames.push_back("None");
 302                                 typeIdx = static_cast<int>(typeIds.size() - 1);
 303                         }
 304
 305                         Serialization::StringListValue typeName(typeNames, typeIdx);
 306                         archive(typeName, "typeName", "Type");
 307                 }
 308         }
 309
 310         void CScriptGraphSwitchNode::Validate(Serialization::IArchive& archive)
 311         {
 312                 std::vector<stack_string> caseStrings;
 313                 uint32                    duplicateCaseValueCount = 0;
 314                 for(const SCase& _case : m_cases)
 315                 {
 316                         if(_case.pValue)
 317                         {
 318                                 char stringBuffer[128] = "";
 319                                 ToString(*_case.pValue, stringBuffer);
 320                                 if(stringBuffer[0])
 321                                 {
 322                                         stack_string caseString = stringBuffer;
 323                                         if(std::find(caseStrings.begin(), caseStrings.end(), caseString) != caseStrings.end())
 324                                         {
 325                                                 ++ duplicateCaseValueCount;
 326                                         }
 327                                         else
 328                                         {
 329                                                 caseStrings.push_back(caseString);
 330                                         }
 331                                 }
 332                         }
 333                 }
 334                 if(duplicateCaseValueCount)
 335                 {
 336                         archive.error(*this, "Duplicate case values detected!");
 337                 }
 338         }
 339
 340         SRuntimeResult CScriptGraphSwitchNode::Execute(IObject* pObject, const SRuntimeActivationParams& activationParams, CRuntimeNodeData& data)
 341         {
 342                 const IAny* pValue = data.GetInput(EInputIdx::Value);
 343                 // Note: we can't make this into a fatal assert because this will then crash the editor when the user
 344                 // changes the type of the switch node.
 345                 //SCHEMATYC2_SYSTEM_ASSERT_FATAL(pValue != nullptr);
 346                 if (pValue != nullptr)
 347                 {
 348                         const uint32 caseCount = *data.GetAttribute<uint32>(EAttributeId::CaseCount);
 349                         for (uint32 caseIdx = 0; caseIdx < caseCount; ++caseIdx)
 350                         {
 351                                 const IAny* pCaseValue = data.GetAttribute(EAttributeId::FirstCase + caseIdx);
 352                                 if (pCaseValue != nullptr)
 353                                 {
 354                                         if (*pValue == *pCaseValue)
 355                                         {
 356                                                 return SRuntimeResult(ERuntimeStatus::Continue, EOutputIdx::FirstCase + caseIdx);
 357                                         }
 358                                 }
 359                         }
 360                 }
 361                 return SRuntimeResult(ERuntimeStatus::Continue, EOutputIdx::Default);
 362         }
 363 }