driver.h

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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef DRIVER_H
#define DRIVER_H
 
#include "core/enum_type.hpp"
#include "string_type.h"
 
const char *GetDriverParam(const StringList &parm, const char *name);
bool GetDriverParamBool(const StringList &parm, const char *name);
int GetDriverParamInt(const StringList &parm, const char *name, int def);
 
class Driver {
public:
  virtual std::optional<std::string_view> Start(const StringList &parm) = 0;
 
  virtual void Stop() = 0;
 
  virtual ~Driver() = default;
 
  enum Type {
    DT_BEGIN = 0, 
    DT_MUSIC = 0, 
    DT_SOUND,     
    DT_VIDEO,     
    DT_END,       
  };
 
  virtual std::string_view GetName() const = 0;
};
 
DECLARE_POSTFIX_INCREMENT(Driver::Type)
 
 
 
class DriverFactoryBase {
private:
  friend class MusicDriver;
  friend class SoundDriver;
  friend class VideoDriver;
 
  Driver::Type type;       
  int priority;            
  std::string_view name;        
  std::string_view description; 
 
  typedef std::map<std::string, DriverFactoryBase *> Drivers; 
 
  static Drivers &GetDrivers()
  {
    static Drivers &s_drivers = *new Drivers();
    return s_drivers;
  }
 
  static Driver **GetActiveDriver(Driver::Type type)
  {
    static Driver *s_driver[3] = { nullptr, nullptr, nullptr };
    return &s_driver[type];
  }
 
  static std::string_view GetDriverTypeName(Driver::Type type)
  {
    static const std::string_view driver_type_name[] = { "music", "sound", "video" };
    return driver_type_name[type];
  }
 
  static bool SelectDriverImpl(const std::string &name, Driver::Type type);
 
  static void MarkVideoDriverOperational();
 
protected:
  DriverFactoryBase(Driver::Type type, int priority, const char *name, const char *description);
 
  virtual ~DriverFactoryBase();
 
  virtual bool UsesHardwareAcceleration() const
  {
    return false;
  }
 
public:
  static void ShutdownDrivers()
  {
    for (Driver::Type dt = Driver::DT_BEGIN; dt < Driver::DT_END; dt++) {
      Driver *driver = *GetActiveDriver(dt);
      if (driver != nullptr) driver->Stop();
    }
  }
 
  static void SelectDriver(const std::string &name, Driver::Type type);
  static void GetDriversInfo(std::back_insert_iterator<std::string> &output_iterator);
 
  std::string_view GetDescription() const
  {
    return this->description;
  }
 
  virtual Driver *CreateInstance() const = 0;
};
 
#endif /* DRIVER_H */