Code/Sandbox/EditorQt/EditorFileMonitor.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "EditorFileMonitor.h"
   5 #include <CryCore/ToolsHelpers/ResourceCompilerHelper.h>
   6 #include "CrySystem/IProjectManager.h"
   7 #include "GameEngine.h"
   8 #include "Include/IAnimationCompressionManager.h"
   9 #include <CryString/StringUtils.h>
  10 #include <CrySystem/IProjectManager.h>
  11 #include "CryEdit.h"
  12 #include "FilePathUtil.h"
  13
  14 //////////////////////////////////////////////////////////////////////////
  15 CEditorFileMonitor::CEditorFileMonitor()
  16 {
  17         GetIEditorImpl()->RegisterNotifyListener(this);
  18 }
  19
  20 //////////////////////////////////////////////////////////////////////////
  21 CEditorFileMonitor::~CEditorFileMonitor()
  22 {
  23         CFileChangeMonitor::DeleteInstance();
  24 }
  25
  26 //////////////////////////////////////////////////////////////////////////
  27 void CEditorFileMonitor::OnEditorNotifyEvent(EEditorNotifyEvent ev)
  28 {
  29         if (ev == eNotify_OnInit)
  30         {
  31                 // Setup file change monitoring
  32                 gEnv->pSystem->SetIFileChangeMonitor(this);
  33
  34                 // We don't want the file monitor to be enabled while
  35                 // in console mode...
  36                 if (!GetIEditorImpl()->IsInConsolewMode())
  37                         MonitorDirectories();
  38
  39                 CFileChangeMonitor::Instance()->Subscribe(this);
  40         }
  41         else if (ev == eNotify_OnQuit)
  42         {
  43                 gEnv->pSystem->SetIFileChangeMonitor(NULL);
  44                 CFileChangeMonitor::Instance()->StopMonitor();
  45                 GetIEditorImpl()->UnregisterNotifyListener(this);
  46         }
  47 }
  48
  49 //////////////////////////////////////////////////////////////////////////
  50 bool CEditorFileMonitor::RegisterListener(IFileChangeListener* pListener, const char* sMonitorItem)
  51 {
  52         return RegisterListener(pListener, sMonitorItem, "*");
  53 }
  54
  55 //////////////////////////////////////////////////////////////////////////
  56 static string CanonicalizePath(const char* szPath)
  57 {
  58         std::vector<char> canonicalizedPath(strlen(szPath) + 1, '\0');
  59         if (PathCanonicalize(&canonicalizedPath[0], szPath))
  60                 return string(&canonicalizedPath[0]);
  61
  62         return string(szPath);
  63 }
  64
  65 //////////////////////////////////////////////////////////////////////////
  66 static string GetAbsolutePathOfProjectFolder(const char* szPath)
  67 {
  68         const char* szProjectRoot = GetISystem()->GetIProjectManager()->GetCurrentProjectDirectoryAbsolute();
  69         CryPathString path = PathUtil::Make(szProjectRoot, szPath);
  70         path = PathUtil::AddBackslash(path);
  71         path = PathUtil::ToDosPath(path);
  72         return CanonicalizePath(path.c_str());
  73 }
  74
  75 //////////////////////////////////////////////////////////////////////////
  76 // TODO: Change the initialization order to call MonitorDirectories() before any of CEditorFileMonitor::RegisterListener
  77 void CEditorFileMonitor::MonitorDirectories()
  78 {
  79
  80         // NOTE: Instead of monitoring each sub-directory we monitor the whole root
  81         // folder. This is needed since if the sub-directory does not exist when
  82         // we register it it will never get monitored properly.
  83         CFileChangeMonitor::Instance()->MonitorItem(GetAbsolutePathOfProjectFolder(PathUtil::GetGameFolder()));
  84
  85         // Add mod paths too
  86         for (int index = 0;; index++)
  87         {
  88                 const char* sModPath = gEnv->pCryPak->GetMod(index);
  89                 if (!sModPath)
  90                         break;
  91                 CFileChangeMonitor::Instance()->MonitorItem(GetAbsolutePathOfProjectFolder(sModPath));
  92         }
  93
  94         // Add editor directory for scripts
  95         CFileChangeMonitor::Instance()->MonitorItem(GetAbsolutePathOfProjectFolder("Editor"));
  96
  97         // Add shader source folder
  98         CFileChangeMonitor::Instance()->MonitorItem(GetAbsolutePathOfProjectFolder("Engine/Shaders"));
  99 }
 100
 101 //////////////////////////////////////////////////////////////////////////
 102 bool CEditorFileMonitor::RegisterListener(IFileChangeListener* pListener, const char* szFolderRelativeToGame, const char* sExtension)
 103 {
 104         m_vecFileChangeCallbacks.push_back(SFileChangeCallback(pListener, PathUtil::ToUnixPath(szFolderRelativeToGame), sExtension));
 105
 106         // NOTE: Here we do not register any CFileChangeMonitor::Instance()->MonitorItem(path).
 107         // See CEditorFileMonitor::MonitorDirectories().
 108         return true;
 109 }
 110
 111 bool CEditorFileMonitor::UnregisterListener(IFileChangeListener* pListener)
 112 {
 113         bool bRet = false;
 114
 115         // Note that we remove the listener, but we don't currently remove the monitored item
 116         // from the file monitor. This is fine, but inefficient
 117
 118         std::vector<SFileChangeCallback>::iterator iter = m_vecFileChangeCallbacks.begin();
 119         while (iter != m_vecFileChangeCallbacks.end())
 120         {
 121                 if (iter->pListener == pListener)
 122                 {
 123                         iter = m_vecFileChangeCallbacks.erase(iter);
 124                         bRet = true;
 125                 }
 126                 else
 127                 {
 128                         ++iter;
 129                 }
 130         }
 131
 132         return bRet;
 133 }
 134
 135 //////////////////////////////////////////////////////////////////////////
 136 static bool IsFilenameEndsWithDotDaeDotZip(const char* fln)
 137 {
 138         size_t len = strlen(fln);
 139         if (len < 8)
 140                 return false;
 141
 142         if (stricmp(fln + len - 8, ".dae.zip") == 0)
 143                 return true;
 144         else
 145                 return false;
 146 }
 147
 148 //////////////////////////////////////////////////////////////////////////
 149 static bool RecompileColladaFile(const char* path)
 150 {
 151         string pathWithGameFolder = PathUtil::ToUnixPath(PathUtil::AddSlash(PathUtil::GetGameFolder())) + string(path);
 152         if (CResourceCompilerHelper::CallResourceCompiler(
 153               pathWithGameFolder.c_str(), "/refresh", NULL, false, CResourceCompilerHelper::eRcExePath_editor, true, true, L".")
 154             != CResourceCompilerHelper::eRcCallResult_success)
 155                 return true;
 156         else
 157                 return false;
 158 }
 159
 160 //////////////////////////////////////////////////////////////////////////
 161 static const char* AbsoluteToProjectPath(const char* szAbsolutePath)
 162 {
 163         if (!GetISystem()->GetIPak()->IsAbsPath(szAbsolutePath))
 164         {
 165                 return szAbsolutePath;
 166         }
 167
 168         const string projectPath = PathUtil::AddSlash(gEnv->pSystem->GetIProjectManager()->GetCurrentProjectDirectoryAbsolute());
 169         const string fixedPath = PathUtil::ToUnixPath(szAbsolutePath);
 170
 171         if (cry_strnicmp(fixedPath.c_str(), projectPath.c_str(), projectPath.length()) == 0) // path starts with rootPathStr
 172         {
 173                 return szAbsolutePath + projectPath.length();
 174         }
 175         return "";
 176 }
 177
 178 //////////////////////////////////////////////////////////////////////////
 179 const char* GetPathRelativeToModFolder(const char* szAbsolutePath)
 180 {
 181         if (szAbsolutePath[0] == '\0')
 182                 return szAbsolutePath;
 183
 184         if (_strnicmp("engine", szAbsolutePath, 6) == 0 && (szAbsolutePath[6] == '\\' || szAbsolutePath[6] == '/'))
 185                 return szAbsolutePath;
 186
 187         szAbsolutePath = AbsoluteToProjectPath(szAbsolutePath);
 188
 189         string gameFolder = PathUtil::GetGameFolder();
 190         string modLocation;
 191         const char* modFolder = gameFolder.c_str();
 192         int modIndex = 0;
 193         do
 194         {
 195                 if (_strnicmp(modFolder, szAbsolutePath, strlen(modFolder)) == 0)
 196                 {
 197                         const char* result = szAbsolutePath + strlen(modFolder);
 198                         if (*result == '\\' || *result == '/')
 199                                 ++result;
 200                         return result;
 201                 }
 202
 203                 modFolder = gEnv->pCryPak->GetMod(modIndex);
 204                 ++modIndex;
 205         }
 206         while (modFolder != 0);
 207
 208         return "";
 209 }
 210
 211 ///////////////////////////////////////////////////////////////////////////
 212
 213 // Called when file monitor message is received
 214 void CEditorFileMonitor::OnFileMonitorChange(const SFileChangeInfo& rChange)
 215 {
 216         CCryEditApp* app = CCryEditApp::GetInstance();
 217         if (app == NULL || app->IsExiting())
 218                 return;
 219
 220         // skip folders!
 221         if (QDir(QString::fromLocal8Bit(rChange.filename)).exists())
 222         {
 223                 return;
 224         }
 225
 226         // Process updated file.
 227         // Make file relative to MasterCD folder.
 228         string filename = rChange.filename;
 229
 230         // Make sure there is no leading slash
 231         if (!filename.IsEmpty() && filename[0] == '\\' || filename[0] == '/')
 232                 filename = filename.Mid(1);
 233
 234         if (!filename.IsEmpty())
 235         {
 236                 // Make it relative to the game folder
 237                 const string filenameRelGame = GetPathRelativeToModFolder(filename.GetString());
 238
 239                 const string ext = filename.Right(filename.GetLength() - filename.ReverseFind('.') - 1);
 240
 241                 // Check for File Monitor callback
 242                 std::vector<SFileChangeCallback>::iterator iter;
 243                 for (iter = m_vecFileChangeCallbacks.begin(); iter != m_vecFileChangeCallbacks.end(); ++iter)
 244                 {
 245                         SFileChangeCallback& sCallback = *iter;
 246
 247                         // We compare against length of callback string, so we get directory matches as well as full filenames
 248                         if (sCallback.pListener)
 249                         {
 250                                 if (sCallback.extension == "*" || stricmp(ext, sCallback.extension) == 0)
 251                                 {
 252                                         if (!filenameRelGame.empty() && _strnicmp(filenameRelGame, sCallback.item, sCallback.item.GetLength()) == 0)
 253                                         {
 254                                                 sCallback.pListener->OnFileChange(filenameRelGame, IFileChangeListener::EChangeType(rChange.changeType));
 255                                         }
 256                                         else if (_strnicmp(filename, sCallback.item, sCallback.item.GetLength()) == 0)
 257                                         {
 258                                                 sCallback.pListener->OnFileChange(filename, IFileChangeListener::EChangeType(rChange.changeType));
 259                                         }
 260                                 }
 261                         }
 262                 }
 263
 264                 //TODO:  have all these file types encapsulated in some IFileChangeFileTypeHandler to deal with each of them in a more generic way
 265                 bool isCAF = stricmp(ext, "caf") == 0;
 266                 bool isLMG = (stricmp(ext, "lmg") == 0) || (stricmp(ext, "bspace") == 0) || (stricmp(ext, "comb") == 0);
 267
 268                 bool isExportLog = stricmp(ext, "exportlog") == 0;
 269                 bool isRCDone = stricmp(ext, "rcdone") == 0;
 270                 bool isCOLLADA = (stricmp(ext, "dae") == 0 || IsFilenameEndsWithDotDaeDotZip(filename.GetString()));
 271
 272                 if (!isCAF && !isLMG && !isCOLLADA && !isExportLog && !isRCDone)
 273                 {
 274                         // Updating an existing CGF file is often implemented as a DeleteFile + MoveFile pair.
 275                         // If the file listener triggers a refresh of a CStatObj after deletion and before moving,
 276                         // it will not find the CGF file, overwrite its path with a default file, and lose the
 277                         // reference to the original path. This causes objects in the level to disappear.
 278                         // Therefore, we ignore deletions of CGF objects.
 279                         if (rChange.changeType != IFileChangeListener::eChangeType_Deleted)
 280                         {
 281                                 // Apart from reloading resources it also may trigger importing of tif files.
 282                                 if (rChange.changeType != IFileChangeListener::eChangeType_RenamedOldName)
 283                                 {
 284                                         GetIEditorImpl()->GetGameEngine()->ReloadResourceFile(filenameRelGame);
 285                                 }
 286
 287                                 if (stricmp(ext, "cgf") == 0)
 288                                 {
 289                                         CBaseObjectsArray objects;
 290                                         GetIEditorImpl()->GetObjectManager()->GetObjects(objects);
 291                                         for (CBaseObject* pObj : objects)
 292                                         {
 293                                                 pObj->InvalidateGeometryFile(filenameRelGame);
 294                                         }
 295                                 }
 296                         }
 297                 }
 298                 else if (isCOLLADA)
 299                 {
 300                         // Make a corresponding .cgf path.
 301                         string cgfFileName;
 302                         int nameLength = filename.GetLength();
 303
 304                         cgfFileName = filename;
 305                         if (stricmp(ext, "dae") == 0)
 306                         {
 307                                 cgfFileName.SetAt(nameLength - 3, 'c');
 308                                 cgfFileName.SetAt(nameLength - 2, 'g');
 309                                 cgfFileName.SetAt(nameLength - 1, 'f');
 310                         }
 311                         else
 312                         {
 313                                 cgfFileName.SetAt(nameLength - 7, 'c');
 314                                 cgfFileName.SetAt(nameLength - 6, 'g');
 315                                 cgfFileName.SetAt(nameLength - 5, 'f');
 316                                 cgfFileName.SetAt(nameLength - 4, 0);
 317                         }
 318                         IStatObj* pStatObjectToReload = GetIEditorImpl()->Get3DEngine()->FindStatObjectByFilename(cgfFileName.GetBuffer());
 319
 320                         // If the corresponding .cgf file exists, recompile the changed COLLADA file.
 321                         if (pStatObjectToReload)
 322                         {
 323                                 CryLog("Recompile DAE file: %s", (LPCTSTR)filename);
 324                                 RecompileColladaFile(filename.GetString());
 325                         }
 326                 }
 327                 else
 328                 {
 329                         ICharacterManager* pICharacterManager = GetISystem()->GetIAnimationSystem();
 330                         stack_string strPath = filenameRelGame;
 331                         PathUtil::UnifyFilePath(strPath);
 332
 333                         if (isLMG)
 334                         {
 335                                 CryLog("Reload blendspace file: %s", (LPCTSTR)strPath);
 336                                 pICharacterManager->ReloadLMG(strPath.c_str());
 337                         }
 338
 339                 }
 340                 // Set this flag to make sure that the viewport will update at least once,
 341                 // so that the changes will be shown, even if the app does not have focus.
 342                 CCryEditApp::GetInstance()->ForceNextIdleProcessing();
 343         }
 344 }