factory.hpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef BLITTER_FACTORY_HPP
#define BLITTER_FACTORY_HPP
 
#include "base.hpp"
#include "../debug.h"
#include "../string_func.h"
 

class BlitterFactory {
private:
  const std::string name;        
  const std::string description; 
 
  typedef std::map<std::string, BlitterFactory *> Blitters; 

  static Blitters &GetBlitters()
  {
    static Blitters &s_blitters = *new Blitters();
    return s_blitters;
  }

  static std::unique_ptr<Blitter> &GetActiveBlitter()
  {
    static std::unique_ptr<Blitter> s_blitter = nullptr;
    return s_blitter;
  }
 
protected:
  BlitterFactory(std::string_view name, std::string_view description, bool usable = true) :
      name(name), description(description)
  {
    if (usable) {
      Blitters &blitters = GetBlitters();
      assert(blitters.find(this->name) == blitters.end());
      /*
       * Only add when the blitter is usable. Do not bail out or
       * do more special things since the blitters are always
       * instantiated upon start anyhow and freed upon shutdown.
       */
      blitters.insert(Blitters::value_type(this->name, this));
    } else {
      Debug(driver, 1, "Not registering blitter {} as it is not usable", name);
    }
  }

  virtual bool IsUsable() const
  {
    return true;
  }
 
public:
  virtual ~BlitterFactory()
  {
    GetBlitters().erase(this->name);
    if (GetBlitters().empty()) delete &GetBlitters();
  }

  static Blitter *SelectBlitter(std::string_view name)
  {
    BlitterFactory *b = GetBlitterFactory(name);
    if (b == nullptr) return nullptr;
 
    GetActiveBlitter() = b->CreateInstance();
 
    Debug(driver, 1, "Successfully {} blitter '{}'", name.empty() ? "probed" : "loaded", GetCurrentBlitter()->GetName());
    return GetCurrentBlitter();
  }

  static BlitterFactory *GetBlitterFactory(std::string_view name)
  {
#if defined(DEDICATED)
    static const std::string_view default_blitter = "null";
#elif defined(WITH_COCOA)
    static const std::string_view default_blitter = "32bpp-anim";
#else
    static const std::string_view default_blitter = "8bpp-optimized";
#endif
    if (GetBlitters().empty()) return nullptr;
    std::string_view bname = name.empty() ? default_blitter : name;
 
    for (auto &it : GetBlitters()) {
      BlitterFactory *b = it.second;
      if (StrEqualsIgnoreCase(bname, b->name)) {
        return b->IsUsable() ? b : nullptr;
      }
    }
    return nullptr;
  }

  static Blitter *GetCurrentBlitter()
  {
    return GetActiveBlitter().get();
  }

  static void GetBlittersInfo(std::back_insert_iterator<std::string> &output_iterator)
  {
    fmt::format_to(output_iterator, "List of blitters:\n");
    for (auto &it : GetBlitters()) {
      BlitterFactory *b = it.second;
      fmt::format_to(output_iterator, "{:>18}: {}\n", b->name, b->GetDescription());
    }
    fmt::format_to(output_iterator, "\n");
  }

  std::string_view GetName() const
  {
    return this->name;
  }

  std::string_view GetDescription() const
  {
    return this->description;
  }

  virtual std::unique_ptr<Blitter> CreateInstance() = 0;
};
 
extern std::string _ini_blitter;
extern bool _blitter_autodetected;
 
#endif /* BLITTER_FACTORY_HPP */