Refactor resource reloading based on filename into a function, which can be called externally.

Source/Engine/LuaScript/pkgs/Resource/ResourceCache.pkg

@@ -4,6 +4,7 @@ class ResourceCache
 {    
     void ReleaseAllResources(bool force = false);
     bool ReloadResource(Resource* resource);
+    void ReloadResourceWithDependencies(const String &fileName);
 
     void SetMemoryBudget(StringHash type, unsigned budget);
     void SetMemoryBudget(const String type, unsigned budget);

Source/Engine/Resource/ResourceCache.cpp

@@ -378,6 +378,44 @@ bool ResourceCache::ReloadResource(Resource* resource)
     return false;
 }
 
+void ResourceCache::ReloadResourceWithDependencies(const String& fileName)
+{
+    StringHash fileNameHash(fileName);
+    // If the filename is a resource we keep track of, reload it
+    const SharedPtr<Resource>& resource = FindResource(fileNameHash);
+    if (resource)
+    {
+        LOGDEBUG("Reloading changed resource " + fileName);
+        ReloadResource(resource);
+    }
+    // Always perform dependency resource check for resource loaded from XML file as it could be used in inheritance
+    if (!resource || GetExtension(resource->GetName()) == ".xml")
+    {
+        // Check if this is a dependency resource, reload dependents
+        HashMap<StringHash, HashSet<StringHash> >::ConstIterator j = dependentResources_.Find(fileNameHash);
+        if (j != dependentResources_.End())
+        {
+            // Reloading a resource may modify the dependency tracking structure. Therefore collect the
+            // resources we need to reload first
+            Vector<SharedPtr<Resource> > dependents;
+            dependents.Reserve(j->second_.Size());
+            
+            for (HashSet<StringHash>::ConstIterator k = j->second_.Begin(); k != j->second_.End(); ++k)
+            {
+                const SharedPtr<Resource>& dependent = FindResource(*k);
+                if (dependent)
+                    dependents.Push(dependent);
+            }
+            
+            for (unsigned k = 0; k < dependents.Size(); ++k)
+            {
+                LOGDEBUG("Reloading resource " + dependents[k]->GetName() + " depending on " + fileName);
+                ReloadResource(dependents[k]);
+            }
+        }
+    }
+}
+
 void ResourceCache::SetMemoryBudget(StringHash type, unsigned budget)
 {
     resourceGroups_[type].memoryBudget_ = budget;
@@ -906,40 +944,7 @@ void ResourceCache::HandleBeginFrame(StringHash eventType, VariantMap& eventData
         String fileName;
         while (fileWatchers_[i]->GetNextChange(fileName))
         {
-            StringHash fileNameHash(fileName);
-            // If the filename is a resource we keep track of, reload it
-            const SharedPtr<Resource>& resource = FindResource(fileNameHash);
-            if (resource)
-            {
-                LOGDEBUG("Reloading changed resource " + fileName);
-                ReloadResource(resource);
-            }
-            // Always perform dependency resource check for resource loaded from XML file as it could be used in inheritance
-            if (!resource || GetExtension(resource->GetName()) == ".xml")
-            {
-                // Check if this is a dependency resource, reload dependents
-                HashMap<StringHash, HashSet<StringHash> >::ConstIterator j = dependentResources_.Find(fileNameHash);
-                if (j != dependentResources_.End())
-                {
-                    // Reloading a resource may modify the dependency tracking structure. Therefore collect the
-                    // resources we need to reload first
-                    Vector<SharedPtr<Resource> > dependents;
-                    dependents.Reserve(j->second_.Size());
-                    
-                    for (HashSet<StringHash>::ConstIterator k = j->second_.Begin(); k != j->second_.End(); ++k)
-                    {
-                        const SharedPtr<Resource>& dependent = FindResource(*k);
-                        if (dependent)
-                            dependents.Push(dependent);
-                    }
-                    
-                    for (unsigned k = 0; k < dependents.Size(); ++k)
-                    {
-                        LOGDEBUG("Reloading resource " + dependents[k]->GetName() + " depending on " + fileName);
-                        ReloadResource(dependents[k]);
-                    }
-                }
-            }
+            ReloadResourceWithDependencies(fileName);
 
             // Finally send a general file changed event even if the file was not a tracked resource
             using namespace FileChanged;

Source/Engine/Resource/ResourceCache.h

@@ -112,6 +112,8 @@ public:
     void ReleaseAllResources(bool force = false);
     /// Reload a resource. Return true on success. The resource will not be removed from the cache in case of failure.
     bool ReloadResource(Resource* resource);
+    /// Reload a resource based on filename. Causes also reload of dependent resources if necessary.
+    void ReloadResourceWithDependencies(const String &fileName);
     /// Set memory budget for a specific resource type, default 0 is unlimited.
     void SetMemoryBudget(StringHash type, unsigned budget);
     /// Enable or disable automatic reloading of resources as files are modified. Default false.

Source/Engine/Script/ResourceAPI.cpp

@@ -113,6 +113,7 @@ static void RegisterResourceCache(asIScriptEngine* engine)
     engine->RegisterObjectMethod("ResourceCache", "void ReleaseResources(const String&in, bool force = false)", asMETHODPR(ResourceCache, ReleaseResources, (const String&, bool), void), asCALL_THISCALL);
     engine->RegisterObjectMethod("ResourceCache", "void ReleaseAllResources(bool force = false)", asMETHOD(ResourceCache, ReleaseAllResources), asCALL_THISCALL);
     engine->RegisterObjectMethod("ResourceCache", "bool ReloadResource(Resource@+)", asMETHOD(ResourceCache, ReloadResource), asCALL_THISCALL);
+    engine->RegisterObjectMethod("ResourceCache", "void ReloadResourceWithDependencies(const String&in)", asMETHOD(ResourceCache, ReloadResourceWithDependencies), asCALL_THISCALL);
     engine->RegisterObjectMethod("ResourceCache", "bool Exists(const String&in) const", asMETHODPR(ResourceCache, Exists, (const String&) const, bool), asCALL_THISCALL);
     engine->RegisterObjectMethod("ResourceCache", "File@ GetFile(const String&in)", asFUNCTION(ResourceCacheGetFile), asCALL_CDECL_OBJLAST);
     engine->RegisterObjectMethod("ResourceCache", "String GetPreferredResourceDir(const String&in) const", asMETHOD(ResourceCache, GetPreferredResourceDir), asCALL_THISCALL);