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

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "Script/Elements/ScriptClassBase.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/Serialization/SerializationUtils.h>
  13
  14 namespace Schematyc2
  15 {
  16         typedef std::unordered_map<SGUID, IScriptProperty*>       PropertyMap;
  17         typedef std::unordered_map<SGUID, const IScriptProperty*> BasePropertyMap;
  18         typedef std::vector<const IScriptGroup*>                  Groups;
  19
  20         namespace ScriptClassBaseUtils
  21         {
  22                 struct SPropertyCollector
  23                 {
  24                         SPropertyCollector(PropertyMap& _properties, IScriptFile& _file, const SGUID& _scopeGUID)
  25                                 : properties(_properties)
  26                                 , file(_file)
  27                                 , scopeGUID(_scopeGUID)
  28                         {
  29                                 file.VisitElements(ScriptElementVisitor::FromMemberFunction<SPropertyCollector, &SPropertyCollector::VisitElement>(*this), scopeGUID, false);
  30                         }
  31
  32                         EVisitStatus VisitElement(IScriptElement& element)
  33                         {
  34                                 switch(element.GetElementType())
  35                                 {
  36                                 case EScriptElementType::Group:
  37                                         {
  38                                                 file.VisitElements(ScriptElementVisitor::FromMemberFunction<SPropertyCollector, &SPropertyCollector::VisitElement>(*this), element.GetGUID(), false);
  39                                                 break;
  40                                         }
  41                                 case EScriptElementType::Property:
  42                                         {
  43                                                 IScriptProperty& property = static_cast<IScriptProperty&>(element);
  44                                                 properties.insert(PropertyMap::value_type(property.GetRefGUID(), &property));
  45                                                 break;
  46                                         }
  47                                 }
  48                                 return EVisitStatus::Continue;
  49                         }
  50
  51                         PropertyMap& properties;
  52                         IScriptFile& file;
  53                         SGUID        scopeGUID;
  54                 };
  55
  56                 struct SBasePropertyCollector
  57                 {
  58                         SBasePropertyCollector(BasePropertyMap& _properties, const IScriptFile& _file, const SGUID& _scopeGUID)
  59                                 : properties(_properties)
  60                                 , file(_file)
  61                                 , scopeGUID(_scopeGUID)
  62                         {
  63                                 file.VisitElements(ScriptElementConstVisitor::FromMemberFunction<SBasePropertyCollector, &SBasePropertyCollector::VisitElement>(*this), scopeGUID, false);
  64                         }
  65
  66                         EVisitStatus VisitElement(const IScriptElement& element)
  67                         {
  68                                 switch(element.GetElementType())
  69                                 {
  70                                 case EScriptElementType::Group:
  71                                         {
  72                                                 file.VisitElements(ScriptElementConstVisitor::FromMemberFunction<SBasePropertyCollector, &SBasePropertyCollector::VisitElement>(*this), element.GetGUID(), false);
  73                                                 break;
  74                                         }
  75                                 case EScriptElementType::Property:
  76                                         {
  77                                                 const IScriptProperty& property = static_cast<const IScriptProperty&>(element);
  78                                                 properties.insert(BasePropertyMap::value_type(property.GetGUID(), &property));
  79                                                 break;
  80                                         }
  81                                 }
  82                                 return EVisitStatus::Continue;
  83                         }
  84
  85                         BasePropertyMap&   properties;
  86                         const IScriptFile& file;
  87                         SGUID              scopeGUID;
  88                 };
  89
  90                 inline const IScriptGroup* FindGroup(IScriptFile& file, const SGUID& scopeGUID, const char* szName)
  91                 {
  92                         SCHEMATYC2_SYSTEM_ASSERT(szName);
  93                         const IScriptGroup* pResult = nullptr;
  94                         auto visitGroup = [szName, &pResult] (const IScriptGroup& group) -> EVisitStatus
  95                         {
  96                                 if(strcmp(szName, group.GetName()) == 0)
  97                                 {
  98                                         pResult = &group;
  99                                         return EVisitStatus::End;
 100                                 }
 101                                 return EVisitStatus::Continue;
 102                         };
 103                         file.VisitGroups(ScriptGroupConstVisitor::FromLambdaFunction(visitGroup), scopeGUID, false);
 104                         return pResult;
 105                 }
 106         }
 107
 108         CScriptClassBase::CScriptClassBase(IScriptFile& file, const SGUID& guid, const SGUID& scopeGUID, const SGUID& refGUID)
 109                 : CScriptElementBase(EScriptElementType::ClassBase, file)
 110                 , m_guid(guid)
 111                 , m_scopeGUID(scopeGUID)
 112                 , m_refGUID(refGUID)
 113         {}
 114
 115         EAccessor CScriptClassBase::GetAccessor() const
 116         {
 117                 return EAccessor::Private;
 118         }
 119
 120         SGUID CScriptClassBase::GetGUID() const
 121         {
 122                 return m_guid;
 123         }
 124
 125         SGUID CScriptClassBase::GetScopeGUID() const
 126         {
 127                 return m_scopeGUID;
 128         }
 129
 130         bool CScriptClassBase::SetName(const char* szName)
 131         {
 132                 return false;
 133         }
 134
 135         const char* CScriptClassBase::GetName() const
 136         {
 137                 return m_name.c_str();
 138         }
 139
 140         void CScriptClassBase::EnumerateDependencies(const ScriptDependancyEnumerator& enumerator) const
 141         {
 142                 SCHEMATYC2_SYSTEM_ASSERT(enumerator);
 143                 if(enumerator)
 144                 {
 145                         enumerator(m_refGUID);
 146                 }
 147         }
 148
 149         void CScriptClassBase::Refresh(const SScriptRefreshParams& params)
 150         {
 151                 ScriptIncludeRecursionUtils::GetClassResult baseClass = ScriptIncludeRecursionUtils::GetClass(CScriptElementBase::GetFile(), m_refGUID);
 152                 if(baseClass.second)
 153                 {
 154                         m_name = baseClass.second->GetName();
 155                         if((params.reason == EScriptRefreshReason::EditorAdd) || (params.reason == EScriptRefreshReason::EditorFixUp) || (params.reason == EScriptRefreshReason::EditorPaste) || (params.reason == EScriptRefreshReason::EditorDependencyModified))
 156                         {
 157                                 RefreshProperties(*baseClass.first, *baseClass.second);
 158                         }
 159                 }
 160         }
 161
 162         void CScriptClassBase::Serialize(Serialization::IArchive& archive)
 163         {
 164                 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
 165
 166                 CScriptElementBase::Serialize(archive);
 167
 168                 SerializationContext::SetValidatorLink(archive, SValidatorLink(m_guid)); // #SchematycTODO : Can we set this from CScriptElementBase?
 169                 switch(SerializationContext::GetPass(archive))
 170                 {
 171                 case ESerializationPass::PreLoad:
 172                 case ESerializationPass::Save:
 173                         {
 174                                 Serialization::SContext fileContext(archive, static_cast<IScriptFile*>(&CScriptElementBase::GetFile())); // #SchematycTODO : Do we still need this?
 175                                 Serialization::SContext context(archive, static_cast<IScriptClassBase*>(this)); // #SchematycTODO : Do we still need this?
 176
 177                                 archive(m_guid, "guid");
 178                                 archive(m_scopeGUID, "scopeGUID");
 179                                 archive(m_refGUID, "refGUID");
 180                                 archive(m_userDocumentation, "userDocumentation", "Documentation");
 181                                 break;
 182                         }
 183                 case ESerializationPass::Validate:
 184                         {
 185                                 Validate(archive);
 186                                 break;
 187                         }
 188                 }
 189         }
 190
 191         void CScriptClassBase::RemapGUIDs(IGUIDRemapper& guidRemapper)
 192         {
 193                 m_guid      = guidRemapper.Remap(m_guid);
 194                 m_scopeGUID = guidRemapper.Remap(m_scopeGUID);
 195                 m_refGUID   = guidRemapper.Remap(m_refGUID);
 196         }
 197
 198         SGUID CScriptClassBase::GetRefGUID() const
 199         {
 200                 return m_refGUID;
 201         }
 202
 203         void CScriptClassBase::RefreshProperties(const IScriptFile& baseClassFile, const IScriptClass& baseClass)
 204         {
 205                 // Retrieve derived properties and properties from base class.
 206                 IScriptFile& file = CScriptElementBase::GetFile();
 207                 PropertyMap  properties;
 208                 ScriptClassBaseUtils::SPropertyCollector(properties, file, m_guid);
 209                 BasePropertyMap baseProperties;
 210                 ScriptClassBaseUtils::SBasePropertyCollector(baseProperties, baseClassFile, m_refGUID);
 211                 // Remove all derived properties that are either finalized of no longer part of base class.
 212                 for(PropertyMap::value_type& property : properties)
 213                 {
 214                         BasePropertyMap::iterator itBaseProperty = baseProperties.find(property.first);
 215                         if((itBaseProperty == baseProperties.end()) || (itBaseProperty->second->GetOverridePolicy() == EOverridePolicy::Finalize))
 216                         {
 217                                 file.RemoveElement(property.second->GetGUID(), true);
 218                         }
 219                 }
 220                 // Create/update derived properties.
 221                 for(const BasePropertyMap::value_type& baseProperty : baseProperties)
 222                 {
 223                         if(baseProperty.second->GetOverridePolicy() != EOverridePolicy::Finalize)
 224                         {
 225                                 PropertyMap::iterator itProperty = properties.find(baseProperty.first);
 226                                 if(itProperty != properties.end())
 227                                 {
 228                                         // Update derived property name.
 229                                         itProperty->second->SetName(baseProperty.second->GetName());
 230                                 }
 231                                 else
 232                                 {
 233                                         // Retrieve group hierarchy from base class.
 234                                         Groups baseGroups;
 235                                         SGUID  baseScopeGUID = baseProperty.second->GetScopeGUID();
 236                                         while(baseScopeGUID != m_refGUID)
 237                                         {
 238                                                 const IScriptGroup* pBaseGroup = baseClassFile.GetGroup(baseScopeGUID);
 239                                                 SCHEMATYC2_SYSTEM_ASSERT(pBaseGroup);
 240                                                 if(pBaseGroup)
 241                                                 {
 242                                                         baseGroups.push_back(pBaseGroup);
 243                                                         baseScopeGUID = pBaseGroup->GetScopeGUID();
 244                                                 }
 245                                                 else
 246                                                 {
 247                                                         break;
 248                                                 }
 249                                         }
 250                                         std::reverse(baseGroups.begin(), baseGroups.end());
 251                                         // Clone group hierarchy.
 252                                         SGUID   scopeGUID = m_guid;
 253                                         for(const IScriptGroup* pBaseGroup : baseGroups)
 254                                         {
 255                                                 const char*         szGroupName = pBaseGroup->GetName();
 256                                                 const IScriptGroup* pGroup = ScriptClassBaseUtils::FindGroup(file, scopeGUID, szGroupName);
 257                                                 if(!pGroup)
 258                                                 {
 259                                                         pGroup = file.AddGroup(scopeGUID, szGroupName);
 260                                                 }
 261                                                 SCHEMATYC2_SYSTEM_ASSERT(pGroup);
 262                                                 if(pGroup)
 263                                                 {
 264                                                         scopeGUID = pGroup->GetGUID();
 265                                                 }
 266                                         }
 267                                         // Create new derived property.
 268                                         file.AddProperty(scopeGUID, baseProperty.second->GetName(), baseProperty.first, baseProperty.second->GetTypeId());
 269                                 }
 270                         }
 271                 }
 272         }
 273
 274         void CScriptClassBase::Validate(Serialization::IArchive& archive)
 275         {
 276                 if(m_refGUID)
 277                 {
 278                         const IScriptClass* pBaseClass = ScriptIncludeRecursionUtils::GetClass(CScriptElementBase::GetFile(), m_refGUID).second;
 279                         if(!pBaseClass)
 280                         {
 281                                 archive.error(*this, "Unable to retrieve base class!");
 282                         }
 283                 }
 284         }
 285 }