Fix LDtk tile map resources export with the fast loading

Core/GDCore/IDE/Project/ArbitraryResourceWorker.cpp

@@ -63,14 +63,10 @@ void ArbitraryResourceWorker::ExposeBitmapFont(gd::String& bitmapFontName){
 };
 
 void ArbitraryResourceWorker::ExposeAudio(gd::String& audioName) {
-  for (auto resources : GetResources()) {
-    if (!resources) continue;
-
-    if (resources->HasResource(audioName) &&
-        resources->GetResource(audioName).GetKind() == "audio") {
-      // Nothing to do, the audio is a reference to a proper resource.
-      return;
-    }
+  if (resourcesManager->HasResource(audioName) &&
+      resourcesManager->GetResource(audioName).GetKind() == "audio") {
+    // Nothing to do, the audio is a reference to a proper resource.
+    return;
   }
 
   // For compatibility with older projects (where events were referring to files
@@ -80,14 +76,10 @@ void ArbitraryResourceWorker::ExposeAudio(gd::String& audioName) {
 };
 
 void ArbitraryResourceWorker::ExposeFont(gd::String& fontName) {
-  for (auto resources : GetResources()) {
-    if (!resources) continue;
-
-    if (resources->HasResource(fontName) &&
-        resources->GetResource(fontName).GetKind() == "font") {
-      // Nothing to do, the font is a reference to a proper resource.
-      return;
-    }
+  if (resourcesManager->HasResource(fontName) &&
+      resourcesManager->GetResource(fontName).GetKind() == "font") {
+    // Nothing to do, the font is a reference to a proper resource.
+    return;
   }
 
   // For compatibility with older projects (where events were referring to files
@@ -96,12 +88,7 @@ void ArbitraryResourceWorker::ExposeFont(gd::String& fontName) {
   ExposeFile(fontName);
 };
 
-void ArbitraryResourceWorker::ExposeResources(
-    gd::ResourcesManager* resourcesManager) {
-  if (!resourcesManager) return;
-
-  resourcesManagers.push_back(resourcesManager);
-
+void ArbitraryResourceWorker::ExposeResources() {
   std::vector<gd::String> resources = resourcesManager->GetAllResourceNames();
   for (std::size_t i = 0; i < resources.size(); i++) {
     if (resourcesManager->GetResource(resources[i]).UseFile())
@@ -110,9 +97,6 @@ void ArbitraryResourceWorker::ExposeResources(
 }
 
 void ArbitraryResourceWorker::ExposeEmbeddeds(gd::String& resourceName) {
-  if (resourcesManagers.empty()) return;
-  gd::ResourcesManager* resourcesManager = resourcesManagers[0];
-
   gd::Resource& resource = resourcesManager->GetResource(resourceName);
 
   if (!resource.GetMetadata().empty()) {
@@ -176,6 +160,7 @@ void ArbitraryResourceWorker::ExposeResourceWithType(
   }
   if (resourceType == "tilemap") {
     ExposeTilemap(resourceName);
+    ExposeEmbeddeds(resourceName);
     return;
   }
   if (resourceType == "tileset") {
@@ -184,6 +169,7 @@ void ArbitraryResourceWorker::ExposeResourceWithType(
   }
   if (resourceType == "json") {
     ExposeJson(resourceName);
+    ExposeEmbeddeds(resourceName);
     return;
   }
   if (resourceType == "video") {
@@ -243,10 +229,12 @@ bool ResourceWorkerInEventsWorker::DoVisitInstruction(gd::Instruction& instructi
         } else if (parameterMetadata.GetType() == "jsonResource") {
           gd::String updatedParameterValue = parameterValue;
           worker.ExposeJson(updatedParameterValue);
+          worker.ExposeEmbeddeds(updatedParameterValue);
           instruction.SetParameter(parameterIndex, updatedParameterValue);
         } else if (parameterMetadata.GetType() == "tilemapResource") {
           gd::String updatedParameterValue = parameterValue;
           worker.ExposeTilemap(updatedParameterValue);
+          worker.ExposeEmbeddeds(updatedParameterValue);
           instruction.SetParameter(parameterIndex, updatedParameterValue);
         } else if (parameterMetadata.GetType() == "tilesetResource") {
           gd::String updatedParameterValue = parameterValue;

Core/GDCore/IDE/Project/ArbitraryResourceWorker.h

@@ -42,8 +42,9 @@ namespace gd {
  * \ingroup IDE
  */
 class GD_CORE_API ArbitraryResourceWorker {
- public:
-  ArbitraryResourceWorker(){};
+public:
+  ArbitraryResourceWorker(gd::ResourcesManager &resourcesManager_)
+      : resourcesManager(&resourcesManager_){};
   virtual ~ArbitraryResourceWorker();
 
   /**
@@ -52,7 +53,7 @@ class GD_CORE_API ArbitraryResourceWorker {
    * first to ensure that resources are known so that images, shaders & audio
    * can make reference to them.
    */
-  void ExposeResources(gd::ResourcesManager *resourcesManager);
+  void ExposeResources();
 
   /**
    * \brief Expose a resource from a given type.
@@ -122,19 +123,14 @@ class GD_CORE_API ArbitraryResourceWorker {
    */
   virtual void ExposeEmbeddeds(gd::String &resourceName);
 
- protected:
-  const std::vector<gd::ResourcesManager *> &GetResources() {
-    return resourcesManagers;
-  };
-
  private:
   /**
    * \brief Expose a resource: resources that have a file are
    * exposed as file (see ExposeFile).
    */
   void ExposeResource(gd::Resource &resource);
 
-  std::vector<gd::ResourcesManager *> resourcesManagers;
+  gd::ResourcesManager * resourcesManager;
 };
 
 /**

Core/GDCore/IDE/Project/ObjectsUsingResourceCollector.cpp

@@ -6,7 +6,7 @@
 namespace gd {
 
 void ObjectsUsingResourceCollector::DoVisitObject(gd::Object& object) {
-  gd::ResourceNameMatcher resourceNameMatcher(resourceName);
+  gd::ResourceNameMatcher resourceNameMatcher(*resourcesManager, resourceName);
 
   object.GetConfiguration().ExposeResources(resourceNameMatcher);
   if (resourceNameMatcher.AnyResourceMatches()) {

Core/GDCore/IDE/Project/ObjectsUsingResourceCollector.h

@@ -4,8 +4,7 @@
  * reserved. This project is released under the MIT License.
  */
 
-#ifndef ProjectObjectsUsingResourceCollector_H
-#define ProjectObjectsUsingResourceCollector_H
+#pragma once
 
 #include <vector>
 
@@ -21,9 +20,10 @@ namespace gd {
 
 class GD_CORE_API ObjectsUsingResourceCollector
     : public ArbitraryObjectsWorker {
- public:
-  ObjectsUsingResourceCollector(const gd::String& resourceName_)
-      : resourceName(resourceName_){};
+public:
+  ObjectsUsingResourceCollector(gd::ResourcesManager &resourcesManager_,
+                                const gd::String &resourceName_)
+      : resourcesManager(&resourcesManager_), resourceName(resourceName_){};
   virtual ~ObjectsUsingResourceCollector();
 
   std::vector<gd::String>& GetObjectNames() { return objectNames; }
@@ -33,12 +33,16 @@ class GD_CORE_API ObjectsUsingResourceCollector
 
   std::vector<gd::String> objectNames;
   gd::String resourceName;
+  gd::ResourcesManager *resourcesManager;
 };
 
 class GD_CORE_API ResourceNameMatcher : public ArbitraryResourceWorker {
- public:
-  ResourceNameMatcher(const gd::String& resourceName_)
-      : resourceName(resourceName_), matchesResourceName(false){};
+public:
+  ResourceNameMatcher(gd::ResourcesManager &resourcesManager,
+                      const gd::String &resourceName_)
+      : resourceName(resourceName_),
+        matchesResourceName(false), gd::ArbitraryResourceWorker(
+                                        resourcesManager){};
   virtual ~ResourceNameMatcher(){};
 
   bool AnyResourceMatches() { return matchesResourceName; }
@@ -85,5 +89,3 @@ class GD_CORE_API ResourceNameMatcher : public ArbitraryResourceWorker {
 };
 
 };  // namespace gd
-
-#endif  // ProjectObjectsUsingResourceCollector_H

Core/GDCore/IDE/Project/ProjectResourcesAdder.cpp

@@ -18,8 +18,9 @@ namespace gd {
 std::vector<gd::String> ProjectResourcesAdder::GetAllUseless(
     gd::Project& project, const gd::String& resourceType) {
   std::vector<gd::String> unusedResources;
+
   // Search for resources used in the project
-  gd::ResourcesInUseHelper resourcesInUse;
+  gd::ResourcesInUseHelper resourcesInUse(project.GetResourcesManager());
   gd::ResourceExposer::ExposeWholeProjectResources(project, resourcesInUse);
   std::set<gd::String>& usedResources = resourcesInUse.GetAll(resourceType);
 

Core/GDCore/IDE/Project/ProjectResourcesCopier.cpp

@@ -25,28 +25,44 @@ bool ProjectResourcesCopier::CopyAllResourcesTo(
     bool updateOriginalProject,
     bool preserveAbsoluteFilenames,
     bool preserveDirectoryStructure) {
+  if (updateOriginalProject) {
+    gd::ProjectResourcesCopier::CopyAllResourcesTo(
+        originalProject, originalProject, fs, destinationDirectory,
+        preserveAbsoluteFilenames, preserveDirectoryStructure);
+  } else {
+    gd::Project clonedProject = originalProject;
+    gd::ProjectResourcesCopier::CopyAllResourcesTo(
+        originalProject, clonedProject, fs, destinationDirectory,
+        preserveAbsoluteFilenames, preserveDirectoryStructure);
+  }
+  return true;
+}
+
+bool ProjectResourcesCopier::CopyAllResourcesTo(
+    gd::Project& originalProject,
+    gd::Project& clonedProject,
+    AbstractFileSystem& fs,
+    gd::String destinationDirectory,
+    bool preserveAbsoluteFilenames,
+    bool preserveDirectoryStructure) {
+
   // Check if there are some resources with absolute filenames
-  gd::ResourcesAbsolutePathChecker absolutePathChecker(fs);
+  gd::ResourcesAbsolutePathChecker absolutePathChecker(originalProject.GetResourcesManager(), fs);
   gd::ResourceExposer::ExposeWholeProjectResources(originalProject, absolutePathChecker);
 
   auto projectDirectory = fs.DirNameFrom(originalProject.GetProjectFile());
   std::cout << "Copying all resources from " << projectDirectory << " to "
             << destinationDirectory << "..." << std::endl;
 
   // Get the resources to be copied
-  gd::ResourcesMergingHelper resourcesMergingHelper(fs);
+  gd::ResourcesMergingHelper resourcesMergingHelper(
+      clonedProject.GetResourcesManager(), fs);
   resourcesMergingHelper.SetBaseDirectory(projectDirectory);
   resourcesMergingHelper.PreserveDirectoriesStructure(
       preserveDirectoryStructure);
-  resourcesMergingHelper.PreserveAbsoluteFilenames(
-      preserveAbsoluteFilenames);
-
-  if (updateOriginalProject) {
-    gd::ResourceExposer::ExposeWholeProjectResources(originalProject, resourcesMergingHelper);
-  } else {
-    std::shared_ptr<gd::Project> project(new gd::Project(originalProject));
-    gd::ResourceExposer::ExposeWholeProjectResources(*project, resourcesMergingHelper);
-  }
+  resourcesMergingHelper.PreserveAbsoluteFilenames(preserveAbsoluteFilenames);
+  gd::ResourceExposer::ExposeWholeProjectResources(clonedProject,
+                                                    resourcesMergingHelper);
 
   // Copy resources
   map<gd::String, gd::String>& resourcesNewFilename =

Core/GDCore/IDE/Project/ProjectResourcesCopier.h

@@ -47,6 +47,13 @@ class GD_CORE_API ProjectResourcesCopier {
                                  bool updateOriginalProject,
                                  bool preserveAbsoluteFilenames = true,
                                  bool preserveDirectoryStructure = true);
+private:
+  static bool CopyAllResourcesTo(gd::Project& originalProject,
+                                 gd::Project& clonedProject,
+                                 gd::AbstractFileSystem& fs,
+                                 gd::String destinationDirectory,
+                                 bool preserveAbsoluteFilenames = true,
+                                 bool preserveDirectoryStructure = true);
 };
 
 }  // namespace gd

Core/GDCore/IDE/Project/ResourcesAbsolutePathChecker.h

@@ -3,8 +3,7 @@
  * Copyright 2008-2016 Florian Rival ([email protected]). All rights
  * reserved. This project is released under the MIT License.
  */
-#ifndef RESOURCESABSOLUTEPATHCHECKER_H
-#define RESOURCESABSOLUTEPATHCHECKER_H
+#pragma once
 
 #include "GDCore/IDE/AbstractFileSystem.h"
 #include "GDCore/IDE/Project/ArbitraryResourceWorker.h"
@@ -22,10 +21,10 @@ namespace gd {
  */
 class GD_CORE_API ResourcesAbsolutePathChecker
     : public ArbitraryResourceWorker {
- public:
-  ResourcesAbsolutePathChecker(AbstractFileSystem& fileSystem)
-      : ArbitraryResourceWorker(),
-        hasAbsoluteFilenames(false),
+public:
+  ResourcesAbsolutePathChecker(gd::ResourcesManager &resourcesManager,
+                               AbstractFileSystem &fileSystem)
+      : ArbitraryResourceWorker(resourcesManager), hasAbsoluteFilenames(false),
         fs(fileSystem){};
   virtual ~ResourcesAbsolutePathChecker(){};
 
@@ -47,5 +46,3 @@ class GD_CORE_API ResourcesAbsolutePathChecker
 };
 
 }  // namespace gd
-
-#endif  // RESOURCESABSOLUTEPATHCHECKER_H

Core/GDCore/IDE/Project/ResourcesInUseHelper.h

@@ -33,8 +33,9 @@ std::set<gd::String> & usedImages = resourcesInUse.GetAllImages();
  * \ingroup IDE
  */
 class ResourcesInUseHelper : public gd::ArbitraryResourceWorker {
- public:
-  ResourcesInUseHelper() : gd::ArbitraryResourceWorker(){};
+public:
+  ResourcesInUseHelper(gd::ResourcesManager &resourcesManager)
+      : gd::ArbitraryResourceWorker(resourcesManager){};
   virtual ~ResourcesInUseHelper(){};
 
   std::set<gd::String>& GetAllImages() { return GetAll("image"); };

Core/GDCore/IDE/Project/ResourcesMergingHelper.h

@@ -28,11 +28,11 @@ namespace gd {
  * \ingroup IDE
  */
 class GD_CORE_API ResourcesMergingHelper : public ArbitraryResourceWorker {
- public:
-  ResourcesMergingHelper(gd::AbstractFileSystem& fileSystem)
-      : ArbitraryResourceWorker(),
-        preserveDirectoriesStructure(false),
-        preserveAbsoluteFilenames(false),
+public:
+  ResourcesMergingHelper(gd::ResourcesManager &resourcesManager,
+                         gd::AbstractFileSystem &fileSystem)
+      : ArbitraryResourceWorker(resourcesManager),
+        preserveDirectoriesStructure(false), preserveAbsoluteFilenames(false),
         fs(fileSystem){};
   virtual ~ResourcesMergingHelper(){};
 

Core/GDCore/IDE/Project/ResourcesRenamer.h

@@ -22,13 +22,16 @@ namespace gd {
  */
 class ResourcesRenamer : public gd::ArbitraryResourceWorker {
  public:
-  /**
-   * @brief Constructor taking the map from old name to new name.
-   * @param oldToNewNames_ A map associating to a resource name the new name to
-   * use.
-   */
-  ResourcesRenamer(const std::map<gd::String, gd::String>& oldToNewNames_)
-      : gd::ArbitraryResourceWorker(), oldToNewNames(oldToNewNames_){};
+   /**
+    * @brief Constructor taking the map from old name to new name.
+    * @param oldToNewNames_ A map associating to a resource name the new name to
+    * use.
+    */
+   ResourcesRenamer(gd::ResourcesManager &resourcesManager,
+                    const std::map<gd::String, gd::String> &oldToNewNames_)
+       : gd::ArbitraryResourceWorker(resourcesManager),
+         oldToNewNames(oldToNewNames_){};
+
   virtual ~ResourcesRenamer(){};
 
   virtual void ExposeFile(gd::String& resourceFileName) override{

Core/GDCore/IDE/Project/SceneResourcesFinder.cpp

@@ -13,14 +13,16 @@
 namespace gd {
 
 std::set<gd::String> SceneResourcesFinder::FindProjectResources(gd::Project &project) {
-  gd::SceneResourcesFinder resourceWorker;
+  gd::SceneResourcesFinder resourceWorker(project.GetResourcesManager());
+
   gd::ResourceExposer::ExposeProjectResources(project, resourceWorker);
   return resourceWorker.resourceNames;
 }
 
 std::set<gd::String> SceneResourcesFinder::FindSceneResources(gd::Project &project,
     gd::Layout &layout) {
-  gd::SceneResourcesFinder resourceWorker;
+  gd::SceneResourcesFinder resourceWorker(project.GetResourcesManager());
+
   gd::ResourceExposer::ExposeLayoutResources(project, layout, resourceWorker);
   return resourceWorker.resourceNames;
 }

Core/GDCore/IDE/Project/SceneResourcesFinder.h

@@ -44,7 +44,8 @@ class SceneResourcesFinder : private gd::ArbitraryResourceWorker {
   virtual ~SceneResourcesFinder(){};
 
 private:
-  SceneResourcesFinder() : gd::ArbitraryResourceWorker(){};
+  SceneResourcesFinder(gd::ResourcesManager &resourcesManager)
+      : gd::ArbitraryResourceWorker(resourcesManager){};
 
   void AddUsedResource(gd::String &resourceName);
 

Core/GDCore/IDE/ResourceExposer.cpp

@@ -33,10 +33,8 @@ void ResourceExposer::ExposeWholeProjectResources(gd::Project& project, gd::Arbi
   // traverse the whole project (this time for events) and ExposeProjectEffects
   // (this time for effects).
 
-  gd::ResourcesManager* resourcesManager = &(project.GetResourcesManager());
-
   // Expose any project resources as files.
-  worker.ExposeResources(resourcesManager);
+  worker.ExposeResources();
 
   project.GetPlatformSpecificAssets().ExposeResources(worker);