ResourcesManager.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#ifndef GDCORE_RESOURCESMANAGER_H
#define GDCORE_RESOURCESMANAGER_H
#include <map>
#include <memory>
#include <vector>
 
#include "GDCore/String.h"
namespace gd {
class Project;
class ResourceFolder;
class SerializerElement;
class PropertyDescriptor;
}  // namespace gd
 
namespace gd {
 
class GD_CORE_API Resource {
 public:
  Resource(){};
  virtual ~Resource(){};
  virtual Resource* Clone() const { return new Resource(*this); }
 
  virtual void SetName(const gd::String& name_) { name = name_; }
 
  virtual const gd::String& GetName() const { return name; }
 
  virtual void SetKind(const gd::String& newKind) { kind = newKind; }
 
  virtual const gd::String& GetKind() const { return kind; }
 
  virtual void SetUserAdded(bool isUserAdded) { userAdded = isUserAdded; }
 
  virtual bool IsUserAdded() const { return userAdded; }
 
  virtual bool UseFile() const { return false; }
 
  virtual const gd::String& GetFile() const { return badStr; };
 
  virtual void SetFile(const gd::String& newFile){};
 
  virtual void SetOrigin(const gd::String& originName_, const gd::String& originIdentifier_) {
    originName = originName_;
    originIdentifier = originIdentifier_;
  }
 
  virtual const gd::String& GetOriginName() const { return originName; }
  virtual const gd::String& GetOriginIdentifier() const { return originIdentifier; }
 
  virtual void SetMetadata(const gd::String& metadata_) {
    metadata = metadata_;
  }
 
  virtual const gd::String& GetMetadata() const { return metadata; }
 
 
  virtual std::map<gd::String, gd::PropertyDescriptor> GetProperties() const;
 
  virtual bool UpdateProperty(const gd::String& name, const gd::String& value) {
    return false;
  };
 
  virtual void SerializeTo(SerializerElement& element) const {};
 
  virtual void UnserializeFrom(const SerializerElement& element){};
 
 private:
  gd::String kind;
  gd::String name;
  gd::String metadata;
  gd::String originName;
  gd::String originIdentifier;
  bool userAdded = false;  
 
  static gd::String badStr;
};
 
class GD_CORE_API ImageResource : public Resource {
 public:
  ImageResource() : Resource(), smooth(true) {
    SetKind("image");
  };
  virtual ~ImageResource(){};
  virtual ImageResource* Clone() const override {
    return new ImageResource(*this);
  }
 
  virtual const gd::String& GetFile() const override { return file; };
 
  virtual void SetFile(const gd::String& newFile) override;
 
  virtual bool UseFile() const override { return true; }
 
  std::map<gd::String, gd::PropertyDescriptor> GetProperties() const override;
  bool UpdateProperty(const gd::String& name, const gd::String& value) override;
 
  void SerializeTo(SerializerElement& element) const override;
 
  void UnserializeFrom(const SerializerElement& element) override;
 
  bool IsSmooth() const { return smooth; }
 
  void SetSmooth(bool enable = true) { smooth = enable; }
 
  bool smooth;        
 private:
  gd::String file;
};
 
class GD_CORE_API AudioResource : public Resource {
 public:
  AudioResource() : Resource(), preloadAsMusic(false), preloadAsSound(false), preloadInCache(false) {
    SetKind("audio");
  };
  virtual ~AudioResource(){};
  virtual AudioResource* Clone() const override {
    return new AudioResource(*this);
  }
 
  virtual const gd::String& GetFile() const override { return file; };
  virtual void SetFile(const gd::String& newFile) override;
 
  virtual bool UseFile() const override { return true; }
 
  std::map<gd::String, gd::PropertyDescriptor> GetProperties() const override;
  bool UpdateProperty(const gd::String& name, const gd::String& value) override;
 
  void SerializeTo(SerializerElement& element) const override;
 
  void UnserializeFrom(const SerializerElement& element) override;
 
  bool PreloadAsMusic() const { return preloadAsMusic; }
 
  void SetPreloadAsMusic(bool enable = true) { preloadAsMusic = enable; }
 
  bool PreloadAsSound() const { return preloadAsSound; }
 
  void SetPreloadAsSound(bool enable = true) { preloadAsSound = enable; }
 
  bool PreloadInCache() const { return preloadInCache; }
 
  void SetPreloadInCache(bool enable = true) { preloadInCache = enable; }
 
 private:
  gd::String file;
  bool preloadAsSound;
  bool preloadAsMusic;
  bool preloadInCache;
};
 
class GD_CORE_API FontResource : public Resource {
 public:
  FontResource() : Resource() { SetKind("font"); };
  virtual ~FontResource(){};
  virtual FontResource* Clone() const override {
    return new FontResource(*this);
  }
 
  virtual const gd::String& GetFile() const override { return file; };
  virtual void SetFile(const gd::String& newFile) override;
 
  virtual bool UseFile() const override { return true; }
  void SerializeTo(SerializerElement& element) const override;
 
  void UnserializeFrom(const SerializerElement& element) override;
 
 private:
  gd::String file;
};
 
class GD_CORE_API VideoResource : public Resource {
 public:
  VideoResource() : Resource() { SetKind("video"); };
  virtual ~VideoResource(){};
  virtual VideoResource* Clone() const override {
    return new VideoResource(*this);
  }
 
  virtual const gd::String& GetFile() const override { return file; };
  virtual void SetFile(const gd::String& newFile) override;
 
  virtual bool UseFile() const override { return true; }
  void SerializeTo(SerializerElement& element) const override;
 
  void UnserializeFrom(const SerializerElement& element) override;
 
 private:
  gd::String file;
};
 
class GD_CORE_API JsonResource : public Resource {
 public:
  JsonResource() : Resource(), disablePreload(false) { SetKind("json"); };
  virtual ~JsonResource(){};
  virtual JsonResource* Clone() const override {
    return new JsonResource(*this);
  }
 
  virtual const gd::String& GetFile() const override { return file; };
  virtual void SetFile(const gd::String& newFile) override;
 
  virtual bool UseFile() const override { return true; }
 
  std::map<gd::String, gd::PropertyDescriptor> GetProperties() const override;
  bool UpdateProperty(const gd::String& name, const gd::String& value) override;
 
  void SerializeTo(SerializerElement& element) const override;
 
  void UnserializeFrom(const SerializerElement& element) override;
 
  bool IsPreloadDisabled() const { return disablePreload; }
 
  void DisablePreload(bool disable = true) { disablePreload = disable; }
 
 private:
  bool disablePreload;  
  gd::String file;
};
 
class GD_CORE_API SpineResource : public JsonResource {
 public:
  SpineResource() : JsonResource() { SetKind("spine"); };
  virtual ~SpineResource(){};
  virtual SpineResource* Clone() const override {
    return new SpineResource(*this);
  }
};
 
class GD_CORE_API TilemapResource : public Resource {
 public:
  TilemapResource() : Resource(), disablePreload(false) { SetKind("tilemap"); };
  virtual ~TilemapResource(){};
  virtual TilemapResource* Clone() const override {
    return new TilemapResource(*this);
  }
 
  virtual const gd::String& GetFile() const override { return file; };
  virtual void SetFile(const gd::String& newFile) override;
 
  virtual bool UseFile() const override { return true; }
 
  std::map<gd::String, gd::PropertyDescriptor> GetProperties() const override;
  bool UpdateProperty(const gd::String& name, const gd::String& value) override;
 
  void SerializeTo(SerializerElement& element) const override;
 
  void UnserializeFrom(const SerializerElement& element) override;
 
  bool IsPreloadDisabled() const { return disablePreload; }
 
  void DisablePreload(bool disable = true) { disablePreload = disable; }
 
 private:
  bool disablePreload;  
  gd::String file;
};
 
class GD_CORE_API TilesetResource : public Resource {
 public:
  TilesetResource() : Resource(), disablePreload(false) { SetKind("tileset"); };
  virtual ~TilesetResource(){};
  virtual TilesetResource* Clone() const override {
    return new TilesetResource(*this);
  }
 
  virtual const gd::String& GetFile() const override { return file; };
  virtual void SetFile(const gd::String& newFile) override;
 
  virtual bool UseFile() const override { return true; }
 
  std::map<gd::String, gd::PropertyDescriptor> GetProperties() const override;
  bool UpdateProperty(const gd::String& name, const gd::String& value) override;
 
  void SerializeTo(SerializerElement& element) const override;
 
  void UnserializeFrom(const SerializerElement& element) override;
 
  bool IsPreloadDisabled() const { return disablePreload; }
 
  void DisablePreload(bool disable = true) { disablePreload = disable; }
 
 private:
  bool disablePreload;  
  gd::String file;
};
 
class GD_CORE_API BitmapFontResource : public Resource {
 public:
  BitmapFontResource() : Resource() { SetKind("bitmapFont"); };
  virtual ~BitmapFontResource(){};
  virtual BitmapFontResource* Clone() const override {
    return new BitmapFontResource(*this);
  }
 
  virtual const gd::String& GetFile() const override { return file; };
  virtual void SetFile(const gd::String& newFile) override;
 
  virtual bool UseFile() const override { return true; }
  void SerializeTo(SerializerElement& element) const override;
 
  void UnserializeFrom(const SerializerElement& element) override;
 
 private:
  gd::String file;
};
 
class GD_CORE_API Model3DResource : public Resource {
 public:
  Model3DResource() : Resource() { SetKind("model3D"); };
  virtual ~Model3DResource(){};
  virtual Model3DResource* Clone() const override {
    return new Model3DResource(*this);
  }
 
  virtual const gd::String& GetFile() const override { return file; };
  virtual void SetFile(const gd::String& newFile) override;
 
  virtual bool UseFile() const override { return true; }
  void SerializeTo(SerializerElement& element) const override;
 
  void UnserializeFrom(const SerializerElement& element) override;
 
 private:
  gd::String file;
};
 
class GD_CORE_API AtlasResource : public Resource {
 public:
  AtlasResource() : Resource() { SetKind("atlas"); };
  virtual ~AtlasResource(){};
  virtual AtlasResource* Clone() const override {
    return new AtlasResource(*this);
  }
 
  virtual const gd::String& GetFile() const override { return file; };
  virtual void SetFile(const gd::String& newFile) override;
 
  virtual bool UseFile() const override { return true; }
  void SerializeTo(SerializerElement& element) const override;
 
  void UnserializeFrom(const SerializerElement& element) override;
 
 private:
  gd::String file;
};
 
class GD_CORE_API ResourcesManager {
 public:
  ResourcesManager();
  virtual ~ResourcesManager();
  ResourcesManager(const ResourcesManager&);
  ResourcesManager& operator=(const ResourcesManager& rhs);
 
  bool HasResource(const gd::String& name) const;
 
  const gd::String& GetResourceNameWithOrigin(const gd::String& originName, const gd::String& originIdentifier) const;
 
  const gd::String& GetResourceNameWithFile(const gd::String& file) const;
 
  Resource& GetResource(const gd::String& name);
 
  const Resource& GetResource(const gd::String& name) const;
 
  std::shared_ptr<Resource> CreateResource(const gd::String& kind);
 
  const std::vector<std::shared_ptr<Resource>>& GetAllResources() const { return resources; };
 
  std::vector<gd::String> GetAllResourceNames() const;
 
  std::vector<gd::String> FindFilesNotInResources(const std::vector<gd::String>& filePathsToCheck) const;
 
  std::shared_ptr<gd::Resource> GetResourceSPtr(const gd::String& name);
 
  bool AddResource(const gd::Resource& resource);
 
  bool AddResource(const gd::String& name,
                   const gd::String& filename,
                   const gd::String& kind);
 
  void RemoveResource(const gd::String& name);
 
  void RenameResource(const gd::String& oldName, const gd::String& newName);
 
  std::size_t GetResourcePosition(const gd::String& name) const;
 
  bool MoveResourceUpInList(const gd::String& name);
 
  bool MoveResourceDownInList(const gd::String& name);
 
  void MoveResource(std::size_t oldIndex, std::size_t newIndex);
 
  bool HasFolder(const gd::String& name) const;
 
  const ResourceFolder& GetFolder(const gd::String& name) const;
 
  ResourceFolder& GetFolder(const gd::String& name);
 
  void RemoveFolder(const gd::String& name);
 
  void CreateFolder(const gd::String& name);
 
  bool MoveFolderUpInList(const gd::String& name);
 
  bool MoveFolderDownInList(const gd::String& name);
 
  std::vector<gd::String> GetAllFolderList();
 
  void SerializeTo(SerializerElement& element) const;
 
  static void SerializeResourceTo(gd::Resource& resource, SerializerElement& resourceElement);
 
  void UnserializeFrom(const SerializerElement& element);
 
 private:
  void Init(const ResourcesManager& other);
 
  std::vector<std::shared_ptr<Resource> > resources;
  std::vector<ResourceFolder> folders;
 
  static ResourceFolder badFolder;
  static Resource badResource;
  static gd::String badResourceName;
};
 
class GD_CORE_API ResourceFolder {
 public:
  ResourceFolder(){};
  virtual ~ResourceFolder(){};
  ResourceFolder(const ResourceFolder&);
  ResourceFolder& operator=(const ResourceFolder& rhs);
 
  virtual void SetName(const gd::String& name_) { name = name_; }
 
  virtual const gd::String& GetName() const { return name; }
 
  virtual void AddResource(const gd::String& name,
                           gd::ResourcesManager& parentManager);
 
  virtual void RemoveResource(const gd::String& name);
 
  virtual bool HasResource(const gd::String& name) const;
 
  virtual Resource& GetResource(const gd::String& name);
 
  virtual const Resource& GetResource(const gd::String& name) const;
 
  virtual std::vector<gd::String> GetAllResourceNames();
 
  virtual bool MoveResourceUpInList(const gd::String& name);
 
  virtual bool MoveResourceDownInList(const gd::String& name);
 
  void SerializeTo(SerializerElement& element) const;
 
  void UnserializeFrom(const SerializerElement& element,
                       gd::ResourcesManager& parentManager);
 
 private:
  gd::String name;
  std::vector<std::shared_ptr<Resource> > resources;
 
  void Init(const ResourceFolder& other);
  static Resource badResource;
};
 
}  // namespace gd
 
#endif  // GDCORE_RESOURCESMANAGER_H