EffectMetadata.h

/*
 * GDevelop Core
 * Copyright 2008-present Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <functional>
#include <map>
#include <memory>
#include <algorithm>
 
#include "GDCore/Project/PropertyDescriptor.h"
#include "GDCore/String.h"
 
namespace gd {
 
class GD_CORE_API EffectMetadata {
 public:
   EffectMetadata(const gd::String &type_)
       : type(type_), isMarkedAsNotWorkingForObjects(false),
         isMarkedAsOnlyWorkingFor2D(false), isMarkedAsOnlyWorkingFor3D(false),
         isMarkedAsUnique(false) {}
 
   EffectMetadata() {}
 
   virtual ~EffectMetadata(){};
 
   EffectMetadata &SetFullName(const gd::String &fullname_) {
     fullname = fullname_;
     return *this;
  };
 
  EffectMetadata& SetDescription(const gd::String& description_) {
    description = description_;
    return *this;
  };
 
  EffectMetadata& SetHelpPath(const gd::String& path) {
    helpPath = path;
    return *this;
  }
 
  EffectMetadata& SetIncludeFile(const gd::String& includeFile);
 
  EffectMetadata& AddIncludeFile(const gd::String& includeFile);
 
  std::map<gd::String, gd::PropertyDescriptor>& GetProperties() {
    return properties;
  }
 
  const std::map<gd::String, gd::PropertyDescriptor>& GetProperties() const {
    return properties;
  }
 
  const gd::String& GetHelpPath() const { return helpPath; }
 
  const gd::String& GetType() const { return type; }
 
  const gd::String& GetFullName() const { return fullname; }
 
  const gd::String& GetDescription() const { return description; }
 
  const std::vector<gd::String>& GetIncludeFiles() const {
    return includeFiles;
  }
 
  EffectMetadata& MarkAsNotWorkingForObjects() {
    isMarkedAsNotWorkingForObjects = true;
    return *this;
  }
 
  EffectMetadata& MarkAsOnlyWorkingFor2D() {
    isMarkedAsOnlyWorkingFor2D = true;
    return *this;
  }
 
  EffectMetadata& MarkAsOnlyWorkingFor3D() {
    isMarkedAsOnlyWorkingFor3D = true;
    return *this;
  }
 
  EffectMetadata& MarkAsUnique() {
    isMarkedAsUnique = true;
    return *this;
  }
 
  bool IsMarkedAsNotWorkingForObjects() const {
    return isMarkedAsNotWorkingForObjects;
  };
 
  bool IsMarkedAsOnlyWorkingFor2D() const {
    return isMarkedAsOnlyWorkingFor2D;
  };
 
  bool IsMarkedAsOnlyWorkingFor3D() const {
    return isMarkedAsOnlyWorkingFor3D;
  };
 
  bool IsMarkedAsUnique() const {
    return isMarkedAsUnique;
  };
 
 private:
  gd::String extensionNamespace;
  gd::String type;
  gd::String helpPath;
  gd::String fullname;
  gd::String description;
  std::vector<gd::String> includeFiles;
  bool isMarkedAsNotWorkingForObjects;
  bool isMarkedAsOnlyWorkingFor2D;
  bool isMarkedAsOnlyWorkingFor3D;
  bool isMarkedAsUnique;
  std::map<gd::String, gd::PropertyDescriptor> properties;
};
 
}  // namespace gd