Use shared pointers for assets

include/openspace/engine/openspaceengine.h

@@ -43,6 +43,7 @@ namespace ghoul::fontrendering { class FontManager; }
 namespace openspace {
 
 class AssetLoader;
+class AssetSynchronizer;
 class ConfigurationManager;
 class DownloadManager;
 class GUI;
@@ -123,6 +124,7 @@ public:
     WindowWrapper& windowWrapper();
     AssetLoader& assetLoader();
     ResourceSynchronizer& resourceSynchronizer();
+    AssetSynchronizer& assetSynchronizer();
     ghoul::fontrendering::FontManager& fontManager();
     interaction::NavigationHandler& navigationHandler();
     interaction::KeyBindingManager& keyBindingManager();
@@ -202,6 +204,7 @@ private:
     std::unique_ptr<interaction::NavigationHandler> _navigationHandler;
     std::unique_ptr<interaction::KeyBindingManager> _keyBindingManager;
     std::unique_ptr<ResourceSynchronizer> _resourceSynchronizer;
+    std::unique_ptr<AssetSynchronizer> _assetSynchronizer;
     std::unique_ptr<scripting::ScriptEngine> _scriptEngine;
     std::unique_ptr<scripting::ScriptScheduler> _scriptScheduler;
     std::unique_ptr<VirtualPropertyManager> _virtualPropertyManager;

include/openspace/scene/asset.h

@@ -33,13 +33,17 @@
 #include <vector>
 #include <optional>
 
+#include <memory>
+#include <set>
+#include <iterator>
+
 namespace openspace {
 
 class AssetLoader;
 
-class Asset {
+class Asset : public std::enable_shared_from_this<Asset> {
 public:
-    using Optional = std::pair<Asset*, bool>;
+    using Optional = std::pair<std::shared_ptr<Asset>, bool>;
 
     enum class ReadyState : unsigned int {
         Loaded,
@@ -67,30 +71,29 @@ public:
 
     void addSynchronization(std::shared_ptr<ResourceSynchronization> synchronization);
     std::vector<std::shared_ptr<ResourceSynchronization>> synchronizations();
-    std::vector<std::shared_ptr<ResourceSynchronization>> getSynchronizationsRecursive();
+
+    std::vector<std::shared_ptr<Asset>> allActiveAssets();
+    std::vector<std::shared_ptr<Asset>> allAssets();
 
     bool isInitReady() const;
     void initialize();
     void deinitialize();
 
     bool hasRequiredDependency(const Asset* asset) const;
-    void addRequiredDependency(Asset* asset);
+    void addRequiredDependency(std::shared_ptr<Asset> asset);
     void removeRequiredDependency(Asset* asset);
     void removeRequiredDependency(const std::string& assetId);
 
     bool hasDependants() const;
     bool hasInitializedDependants() const;
 
-    std::vector<Asset*> optionalAssets() const;
+    std::vector<std::shared_ptr<Asset>> optionalAssets() const;
     bool hasOptionalDependency(const Asset* asset) const;
     bool hasEnabledOptionalDependency(const Asset* asset) const;
     void setOptionalDependencyEnabled(Asset* asset, bool enabled);
-    void addOptionalDependency(Asset* asset, bool enabled);
+    void addOptionalDependency(std::shared_ptr<Asset> asset, bool enabled);
     void removeOptionalDependency(Asset* asset);
 
-    void dependantDidInitialize(Asset* dependant);
-    void dependantWillDeinitialize(Asset* dependant);
-
     std::string resolveLocalResource(std::string resourceName);
     std::string resolveSyncedResource(std::string resourceName);
 private:
@@ -105,16 +108,16 @@ private:
     std::optional<std::string> _assetPath;
 
     // Required dependencies
-    std::vector<Asset*> _requiredDependencies;
+    std::vector<std::shared_ptr<Asset>> _requiredDependencies;
 
     // Assets that refers to this asset as an required dependency
-    std::vector<Asset*> _requiredDependants;
+    std::vector<std::weak_ptr<Asset>> _requiredDependants;
 
     // Optional dependencies
     std::vector<Optional> _optionalDependencies;
 
     // Assets that refers to this asset as an optional dependency
-    std::vector<Asset*> _optionalDependants;
+    std::vector<std::weak_ptr<Asset>> _optionalDependants;
 };
 
 } // namespace openspace

include/openspace/scene/assetloader.h

@@ -78,14 +78,14 @@ public:
      *  - Import one asset
      *  - Unimport all other assets
      */
-    Asset* loadSingleAsset(const std::string& identifier);
+    std::shared_ptr<Asset> loadSingleAsset(const std::string& identifier);
 
     /**
      * Import an asset:
      * Add the asset as an optional on the root asset
      * The asset is imported synchronously
      */
-    Asset* importAsset(const std::string& identifier);
+    std::shared_ptr<Asset> importAsset(const std::string& identifier);
 
     /**
      * Unimport an asset:
@@ -107,13 +107,18 @@ public:
     /**
      * Return the root asset
      */
-    Asset* rootAsset() const;
+    std::shared_ptr<Asset> rootAsset() const;
 
     /**
      * Return the sync root directory
      */
     const std::string& syncRootDirectory();
 
+    /**
+    * Return the asset root directory
+    */
+    const std::string& assetRootDirectory();
+
     void callOnInitialize(Asset* asset);
 
     void callOnDeinitialize(Asset* asset);
@@ -125,13 +130,13 @@ public:
     std::string generateAssetPath(const std::string& baseDirectory, const std::string& path) const;
 
 private:
-    Asset* importRequiredDependency(const std::string& identifier);
-    Asset* importOptionalDependency(const std::string& identifier, bool enabled = true);
-    Asset* loadAsset(std::string name);
-    Asset* getAsset(std::string name);
+    std::shared_ptr<Asset> importRequiredDependency(const std::string& identifier);
+    std::shared_ptr<Asset> importOptionalDependency(const std::string& identifier, bool enabled = true);
+    std::shared_ptr<Asset> loadAsset(std::string name);
+    std::shared_ptr<Asset> getAsset(std::string name);
     ghoul::filesystem::Directory currentDirectory();
 
-    void pushAsset(Asset* asset);
+    void pushAsset(std::shared_ptr<Asset> asset);
     void popAsset();
     void updateLuaGlobals();
     void addLuaDependencyTable(Asset* dependant, Asset* dependency);
@@ -160,9 +165,9 @@ private:
     friend int assetloader::resolveSyncedResource(lua_State* state);
     friend int assetloader::exportAsset(lua_State* state);
 
-    std::unique_ptr<Asset> _rootAsset;
-    std::map<std::string, std::unique_ptr<Asset>> _importedAssets;
-    std::vector<Asset*> _assetStack;
+    std::shared_ptr<Asset> _rootAsset;
+    std::map<std::string, std::shared_ptr<Asset>> _importedAssets;
+    std::vector<std::shared_ptr<Asset>> _assetStack;
 
     AssetSynchronizer* _assetSynchronizer;
     std::string _assetRootDirectory;