al_PresetHandler.hpp

#ifndef AL_PRESETHANDLER_H
#define AL_PRESETHANDLER_H
 
/*  Allolib --
   Multimedia / virtual environment application class library
 
   Copyright (C) 2009. AlloSphere Research Group, Media Arts & Technology,
   UCSB. Copyright (C) 2012-2018. The Regents of the University of California.
   All rights reserved.
 
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions are met:
 
   Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
 
   Redistributions in binary form must reproduce the above
   copyright notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.
 
   Neither the name of the University of California nor the names of its
   contributors may be used to endorse or promote products derived from this
   software without specific prior written permission.
 
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
   OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
   File description:
   Preset classes that encapsulates storing values for groups of parameters
   File author(s):
   Andrés Cabrera mantaraya36@gmail.com
*/
 
#include <algorithm>
#include <atomic>
#include <condition_variable>
#include <functional>
#include <map>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
#include "al/protocol/al_OSC.hpp"
#include "al/system/al_Time.hpp"
#include "al/ui/al_Parameter.hpp"
#include "al/ui/al_ParameterServer.hpp"
 
namespace al {
 
class PresetHandler {
public:
  typedef std::map<std::string, std::vector<ParameterField>> ParameterStates;
  PresetHandler(std::string rootDirectory, bool verbose = false);
 
  PresetHandler(TimeMasterMode timeMasterMode = TimeMasterMode::TIME_MASTER_CPU,
                std::string rootDirectory = "presets", bool verbose = false);
 
  ~PresetHandler();
 
  void storePreset(std::string name);
 
  void storePreset(int index, std::string name = "", bool overwrite = true);
  void recallPreset(std::string name);
 
  std::string recallPreset(int index);
 
  void recallPresetSynchronous(std::string name);
 
  std::string recallPresetSynchronous(int index);
 
  void setInterpolatedPreset(int index1, int index2, double factor);
 
  void setInterpolatedPreset(std::string presetName1, std::string presetName2,
                             double factor);
 
  //  static void setParameterValues(ParameterMeta *param,
  //                                 std::vector<ParameterField> &values);
  void setInterpolatedValues(ParameterStates &startValues,
                             ParameterStates &endValues, double factor = 1.0);
 
  std::map<int, std::string> availablePresets();
  std::string getPresetName(int index);
  std::string getCurrentPresetName() { return mCurrentPresetName; }
 
  void skipParameter(std::string parameterAddr, bool skip = true);
 
  int getCurrentPresetIndex();
 
  float getMorphTime();
  void setMorphTime(float time);
  void setMaxMorphTime(float time);
  void stopMorphing() { mTotalSteps.store(0); }
  void morphTo(ParameterStates &parameterStates, float morphTime);
  void morphTo(std::string presetName, float morphTime);
 
  void setMorphStepTime(float stepTime) { mMorphInterval = stepTime; }
 
  void stepMorphing(double stepTime);
 
  void stepMorphing();
 
  void setSubDirectory(std::string directory);
  std::string getSubDirectory() { return mSubDir; }
 
  std::string getCurrentPath();
 
  void setRootPath(std::string path);
 
  std::string getRootPath();
 
  void print();
 
  void registerPresetCallback(
      std::function<void(int index, void *sender, void *userData)> cb,
      void *userData = nullptr);
 
  void registerStoreCallback(
      std::function<void(int index, std::string name, void *userData)> cb,
      void *userData = nullptr);
 
  void registerMorphTimeCallback(Parameter::ParameterChangeCallback cb);
 
  typedef const std::function<void(std::string)> PresetMapCallback;
  void registerPresetMapCallback(PresetMapCallback cb);
 
  PresetHandler &registerParameter(ParameterMeta &parameter);
 
  PresetHandler &operator<<(ParameterMeta &param) {
    return this->registerParameter(param);
  }
 
  PresetHandler &registerParameterBundle(ParameterBundle &bundle);
 
  PresetHandler &operator<<(ParameterBundle &bundle) {
    return this->registerParameterBundle(bundle);
  }
 
  std::vector<ParameterMeta *> parameters() { return mParameters; }
 
  std::string buildMapPath(std::string mapName, bool useSubDirectory = false);
 
  std::vector<std::string> availablePresetMaps();
 
  std::map<int, std::string> readPresetMap(std::string mapName = "default");
 
  void setCurrentPresetMap(std::string mapName = "default",
                           bool autoCreate = false);
 
  void setPresetMap(std::map<int, std::string> presetsMap) {
    mPresetsMap = presetsMap;
  }
 
  void storeCurrentPresetMap(std::string mapName = "",
                             bool useSubDirectory = false);
 
  void useCallbacks(bool use) { mUseCallbacks = use; }
 
  void changeParameterValue(std::string presetName, std::string parameterPath,
                            float newValue);
 
  static int asciiToPresetIndex(int ascii, int offset = 0);
 
  [[deprecated]] void verbose(bool isVerbose) { mVerbose = isVerbose; }
  void setVerbose(bool isVerbose = true) { mVerbose = isVerbose; }
  bool verbose() { return mVerbose; }
 
  ParameterStates loadPresetValues(std::string name);
 
  bool savePresetValues(const ParameterStates &values, std::string presetName,
                        bool overwrite = true);
 
  void setTimeMaster(TimeMasterMode masterMode);
 
  void startCpuThread();
  void stopCpuThread();
 
private:
  //  std::vector<float> getParameterValue(ParameterMeta *p);
  //  void setParametersInBundle(ParameterBundle *bundle, std::string
  //  bundlePrefix,
  //                             PresetHandler *handler, double factor = 1.0);
  static void morphingFunction(PresetHandler *handler);
 
  ParameterStates getBundleStates(ParameterBundle *bundle, std::string id);
 
  bool mVerbose{false};
  bool mUseCallbacks{true};
  std::string mRootDir;
  std::string mSubDir; // Optional sub directory, e.g. for preset map archives
 
  std::string mCurrentMapName;
  std::string mCurrentPresetName;
  std::vector<ParameterMeta *> mParameters;
 
  std::vector<std::string> mSkipParameters;
  std::mutex mSkipParametersLock;
 
  std::map<std::string, std::vector<ParameterBundle *>> mBundles;
 
  // Protects file writing from this class. Only one file may be written at
  // a time.
  std::mutex mFileLock;
 
  std::mutex mTargetLock;
  ParameterStates mTargetValues;
  ParameterStates mStartValues;
 
  TimeMasterMode mTimeMasterMode{TimeMasterMode::TIME_MASTER_CPU};
 
  Parameter mMorphTime{"morphTime", "", 0.0, 0.0, 20.0};
 
  std::atomic<uint64_t> mMorphStepCount{0};
  std::atomic<uint64_t> mTotalSteps{0};
  //  std::atomic<float> mCurrentMorphIndex;
  bool mCpuThreadRunning{false}; // To keep the morphing thread alive
  std::unique_ptr<std::thread> mMorphingThread;
  //  std::condition_variable mMorphConditionVar;
  double mMorphInterval{0.02};
  //  std::atomic<bool> mMorphing;
 
  std::vector<std::function<void(int index, void *sender, void *userData)>>
      mCallbacks;
  std::vector<void *> mCallbackUdata;
  std::vector<std::function<void(int index, std::string name, void *userData)>>
      mStoreCallbacks;
  std::vector<void *> mStoreCallbackUdata;
  std::vector<std::function<void(std::string)>> mPresetsMapCbs;
 
  std::map<int, std::string> mPresetsMap;
};
 
} // namespace al
 
#endif // AL_PRESETHANDLER_H