Layer.h

#ifndef _LAYER_H_
#define _LAYER_H_

#pragma once

#include "LumiverseCore.h"
#include "Timeline.h"
#include "Playback.h"
#include "CueList.h"
#include "Cue.h"

#include <memory>
#include <chrono>
#include <unordered_map>

namespace Lumiverse {
namespace ShowControl {
  class Playback;
  class CueList;
  
  struct PlaybackData {
    chrono::time_point<chrono::high_resolution_clock> start;    // Timeline start time. More accurate to take difference between now and start instead of summing.
    map<string, set<string> > activeParams;
    string timelineID;
    bool complete;
    chrono::time_point<chrono::high_resolution_clock> elapsed;
    size_t length;
  };

  class Layer
  {
  public:
    enum BlendMode {
      ALPHA,      
      OVERWRITE,  
      MAX,        
      MIN         
    };

    Layer(Rig* rig, Playback* pb, string name, int priority, BlendMode mode = ALPHA);

    Layer(Rig* rig, Playback* pb, string name, int priority, float opacity);

    Layer(DeviceSet set, Playback* pb, string name, int priority, BlendMode mode = ALPHA);

    Layer(Playback* pb, string name, int priority, BlendMode mode = ALPHA);

    Layer(Playback* pb, JSONNode node);

    ~Layer();

    void play(string id);

    void pause();

    void resume();

    void stop();

    BlendMode getMode() { return m_mode; }

    void setMode(BlendMode mode) { m_mode = mode; }

    float getOpacity() { return m_opacity; }

    void setOpacity(float val);

    bool isActive() { return m_active; }

    void activate() { m_active = true; }
    
    void deactivate() { m_active = false; }

    void setName(string name) { m_name = name; }
    
    string getName() { return m_name; }

    void setPriority(int priority) { m_priority = priority; }

    int getPriority() { return m_priority; }

    bool addDevices(DeviceSet d);

    bool addDevice(Device* d, string param);

    bool addDevicesWithParams(DeviceSet d, set<string> params);

    bool addParamToAllDevices(string param, LumiverseType* type);

    bool deleteParameter(string id, string param);

    bool deleteDevices(DeviceSet d);

    bool deleteParametersFromDevices(DeviceSet d, set<string> params);

    bool deleteParametersFromAllDevices(set<string> params);

    string getRecentTimeline();

    map<string, map<string, LumiverseType*> >& getLayerState() { return m_layerState; }

    void update(chrono::time_point<chrono::high_resolution_clock> updateStart);

    void blend(map<string, Device*> currentState);

    JSONNode toJSON();

    void reset();

    void setCueList(shared_ptr<CueList> list, bool resetCurrentCue = true);

    void removeCueList();

    bool hasCueList();

    const shared_ptr<CueList>& getCueList();

    float getCurrentCue();

    void go();

    void back();

    void goToCue(float num, float up = 3, float down = 3, float delay = 0);

  private:
    map<string, map<string, LumiverseType*> > m_layerState;

    Playback* m_pb;

    string m_name;

    int m_priority;

    bool m_active;

    BlendMode m_mode;

    float m_opacity;

    bool m_pause;

    bool m_stop;

    bool m_playing;

    chrono::time_point<chrono::high_resolution_clock> m_previousLoopStart;

    string m_lastPlayedTimeline;

    shared_ptr<CueList> m_cueList;

    float m_currentCue;

    void init(Rig* rig);

    // unsure if this function should remain in this rework.
    //map<string, set<string> > diff(Cue* a, Cue* b, bool assert = false);

    PlaybackData* m_playbackData;
    
    PlaybackData* m_queuedPlayback;

    mutex m_queue;
  };

#ifdef USE_C11_MAPS

  static unordered_map<Layer::BlendMode, string, std::hash<unsigned int>> BlendModeToString {
      { Layer::ALPHA, "ALPHA" },
      { Layer::OVERWRITE, "OVERWRITE" },
      { Layer::MAX, "MAX" },
      { Layer::MIN, "MIN" }
  };

  static unordered_map<string, Layer::BlendMode> StringToBlendMode {
      { "ALPHA", Layer::ALPHA },
      { "OVERWRITE", Layer::OVERWRITE },
      { "MAX", Layer::MAX },
      { "MIN", Layer::MIN }
  };
#else
  static string BlendModeToString(Layer::BlendMode b) {
    switch (b) {
    case Layer::ALPHA: return "ALPHA";
    case Layer::OVERWRITE: return "OVERWRITE";
    case Layer::MAX: return "MAX";
    case Layer::MIN: return "MIN";
    default: return "";
    }
  }

  static Layer::BlendMode StringToBlendMode(string b) {
    if (b == "ALPHA") return Layer::ALPHA;
    if (b == "OVERWRITE") return Layer::OVERWRITE;
    if (b == "MAX") return Layer::MAX;
    if (b == "MIN") return Layer::MIN;
    return Layer::BLEND_OPAQUE;
  }
#endif


}

// Note that for some reason when generating SWIG bindings, having these outside of the Lumiverse
// Namespace (they were in Lumiverse::ShowControl) causes some problems with SWIG's intermediate code
// generator.
// Comparison op overloads
inline bool operator==(ShowControl::Layer& lhs, ShowControl::Layer& rhs) {
  return (lhs.getPriority() == rhs.getPriority());
}

inline bool operator!=(ShowControl::Layer& lhs, ShowControl::Layer& rhs) {
  return !(lhs == rhs);
}

inline bool operator<(ShowControl::Layer& lhs, ShowControl::Layer& rhs) {
  return (lhs.getPriority() < rhs.getPriority());
}

inline bool operator>(ShowControl::Layer& lhs, ShowControl::Layer& rhs) {
  return rhs < lhs;
}

inline bool operator<=(ShowControl::Layer& lhs, ShowControl::Layer& rhs) {
  return !(lhs > rhs);
}

inline bool operator>=(ShowControl::Layer& lhs, ShowControl::Layer& rhs) {
  return !(lhs < rhs);
}
}

namespace std
{
    template<>
    struct hash<Lumiverse::ShowControl::Layer::BlendMode>
    {
        size_t operator()( const Lumiverse::ShowControl::Layer::BlendMode& arg ) const
        {
            std::hash<unsigned int> hasher;
            return hasher( static_cast<unsigned int>( arg ) );
        }
    };
}

#endif