ResourcesContainer.h

/*
 * GDevelop Core
 * Copyright 2008-2025 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <map>
#include <memory>
#include <vector>
 
#include "GDCore/String.h"
 
namespace gd {
class Project;
class SerializerElement;
class PropertyDescriptor;
} // namespace gd
 
namespace gd {
 
class GD_CORE_API Resource {
public:
  static const gd::String imageType;
  static const gd::String audioType;
  static const gd::String fontType;
  static const gd::String videoType;
  static const gd::String jsonType;
  static const gd::String tileMapType;
  static const gd::String tileSetType;
  static const gd::String bitmapType;
  static const gd::String model3DType;
  static const gd::String atlasType;
  static const gd::String spineType;
  static const gd::String javaScriptType;
  static const gd::String internalInGameEditorOnlySvgType;
 
  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 JavaScriptResource : public Resource {
public:
  JavaScriptResource() : Resource() { SetKind("javascript"); };
  virtual ~JavaScriptResource(){};
  virtual JavaScriptResource *Clone() const override {
    return new JavaScriptResource(*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 InternalInGameEditorOnlySvgResource : public Resource {
 public:
  InternalInGameEditorOnlySvgResource() : Resource() { SetKind("internal-in-game-editor-only-svg"); };
  virtual ~InternalInGameEditorOnlySvgResource(){};
  virtual InternalInGameEditorOnlySvgResource* Clone() const override {
    return new InternalInGameEditorOnlySvgResource(*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 ResourcesContainer {
public:
  enum SourceType {
    Unknown,
    Global,
    Parameters,
    Properties
  };
 
  ResourcesContainer(const SourceType sourceType);
  virtual ~ResourcesContainer();
  ResourcesContainer(const ResourcesContainer &);
  ResourcesContainer &operator=(const ResourcesContainer &rhs);
 
  SourceType GetSourceType() const { return sourceType; }
 
  bool HasResource(const gd::String &name) const;
 
  Resource &GetResource(const gd::String &name);
 
  const Resource &GetResource(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;
 
  std::vector<gd::String> FindFilesNotInResources(
      const std::vector<gd::String> &filePathsToCheck) 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::shared_ptr<gd::Resource> GetResourceSPtr(const gd::String &name);
 
  std::size_t Count() const { return resources.size(); };
 
  inline void Clear() { resources.clear(); }
 
  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);
 
  void SerializeTo(SerializerElement &element) const;
 
  static void SerializeResourceTo(gd::Resource &resource,
                                  SerializerElement &resourceElement);
 
  void UnserializeFrom(const SerializerElement &element);
 
private:
  void Init(const ResourcesContainer &other);
 
  SourceType sourceType = Unknown;
 
  std::vector<std::shared_ptr<Resource>> resources;
 
  static Resource badResource;
  static gd::String badResourceName;
};
 
} // namespace gd