DMXDevicePatch.h

Go to the documentation of this file.

#ifndef _DMXDEVICEPATCH_H_
#define _DMXDEVICEPATCH_H_

#pragma once
#include "../Device.h"
#include <sstream>
#include <unordered_map>

namespace Lumiverse {
  enum conversionType {
    FLOAT_TO_SINGLE,  
    FLOAT_TO_FINE,    
    ENUM,             
    RGB_REPEAT2,      
    RGB_REPEAT3,      
    RGB_REPEAT4,      
    COLOR_RGB,        
    COLOR_RGBW,       
    COLOR_LUSTRPLUS,  
    ORI_TO_FINE       
  };
#ifdef USE_C11_MAPS
  static unordered_map<int, string> convTypeToString = {
    { FLOAT_TO_SINGLE, "FLOAT_TO_SINGLE" }, { FLOAT_TO_FINE, "FLOAT_TO_FINE" },
    { ENUM, "ENUM" }, { RGB_REPEAT2, "RGB_REPEAT2" }, { RGB_REPEAT3, "RGB_REPEAT3" },
    { RGB_REPEAT4, "RGB_REPEAT4" }, { COLOR_RGB, "COLOR_RGB" }, { COLOR_RGBW, "COLOR_RGBW" },
    { ORI_TO_FINE, "ORI_TO_FINE" }, { COLOR_LUSTRPLUS, "COLOR_LUSTRPLUS" }
  };

  static unordered_map<string, int> stringToConvType = {
    { "FLOAT_TO_SINGLE", FLOAT_TO_SINGLE }, { "FLOAT_TO_FINE", FLOAT_TO_FINE },
    { "ENUM", ENUM }, { "RGB_REPEAT2", RGB_REPEAT2 }, { "RGB_REPEAT3", RGB_REPEAT3 },
    { "RGB_REPEAT4", RGB_REPEAT4 }, { "COLOR_RGB", COLOR_RGB }, { "COLOR_RGBW", COLOR_RGBW },
    { "ORI_TO_FINE", ORI_TO_FINE }, { "COLOR_LUSTRPLUS", COLOR_LUSTRPLUS }
  };
#else
  static string convTypeToString(conversionType t) {
    if (t == FLOAT_TO_SINGLE) { return "FLOAT_TO_SINGLE"; }
    else if (t == FLOAT_TO_FINE) { return "FLOAT_TO_FINE"; }
    else if (t == ENUM) { return "ENUM"; }
    else if (t == RGB_REPEAT2) { return "RGB_REPEAT2"; }
    else if (t == RGB_REPEAT3) { return "RGB_REPEAT3"; }
    else if (t == RGB_REPEAT4) { return "RGB_REPEAT4"; }
    else if (t == COLOR_RGB) { return "COLOR_RGB"; }
    else if (t == COLOR_RGBW) { return "COLOR_RGBW"; }
    else if (t == ORI_TO_FINE) { return "ORI_TO_FINE"; }
    else if (t == COLOR_LUSTRPLUS) { return "COLOR_LUSTRPLUS"; }
    else {
      Logger::log(WARN, "Unknown conversion type. Defaulting to float to single.");
      return "FLOAT_TO_SINGLE";
    }
  }

  static conversionType stringToConvType(string t) {
    if (t == "FLOAT_TO_SINGLE") { return FLOAT_TO_SINGLE; }
    else if (t == "FLOAT_TO_FINE") { return FLOAT_TO_FINE; }
    else if (t == "ENUM") { return ENUM; }
    else if (t == "RGB_REPEAT2") { return RGB_REPEAT2; }
    else if (t == "RGB_REPEAT3") { return RGB_REPEAT3; }
    else if (t == "RGB_REPEAT4") { return RGB_REPEAT4; }
    else if (t == "COLOR_RGB") { return COLOR_RGB; }
    else if (t == "COLOR_RGBW") { return COLOR_RGBW; }
    else if (t == "ORI_TO_FINE") { return ORI_TO_FINE; }
    else if (t == "COLOR_LUSTRPLUS") { return COLOR_LUSTRPLUS; }
    else {
      Logger::log(WARN, "Unknown conversion type. Defaulting to float to single.");
      return FLOAT_TO_SINGLE;
    }
  }
#endif

  struct patchData {
    unsigned int startAddress; 

    conversionType type;

    patchData() : startAddress(0), type(FLOAT_TO_SINGLE) { }

    patchData(unsigned int addr, conversionType t) : startAddress(addr), type(t) { }

    patchData(unsigned int addr, string t) : startAddress(addr) {
#ifdef USE_C11_MAPS
      type = (conversionType) stringToConvType[t];
#else
      type = (conversionType) stringToConvType(t);
#endif
    }
  };

  class DMXDevicePatch
  {
  public:
    DMXDevicePatch(string mapKey, unsigned int baseAddress, unsigned int universe);

    ~DMXDevicePatch();

    void updateDMX(unsigned char* data, Device* device, map<string, patchData>& dmxMap);

    unsigned int getUniverse() { return m_universe; }

    void setUniverse(unsigned char newUniverse) { m_universe = newUniverse; }

    unsigned int getBaseAddress() { return m_baseAddress; }

    void setBaseAddress(unsigned int newAddress) { m_baseAddress = newAddress; }

    string getDMXMapKey() { return m_dmxMapKey; }

  private:
    unsigned int m_baseAddress;

    unsigned int m_universe;

    unsigned int m_numAddresses;

    //map<string, patchData> m_dmxMap;
    string m_dmxMapKey;

    // Conversion Functions
    // These functions all take in a universe of DMX and stick their converted
    // value in the right place.
    // --------------------------------------------------------------------------

    void floatToSingle(unsigned char* data, unsigned int address, LumiverseFloat* val);

    void floatToFine(unsigned char* data, unsigned int address, float val);

    void toEnum(unsigned char* data, unsigned int address, LumiverseEnum* val);
    
    void RGBRepeat(unsigned char* data, unsigned int address, LumiverseFloat* val, int repeats);

    void ColorToRGB(unsigned char* data, unsigned int address, LumiverseColor* val);

    void ColorToRGBW(unsigned char* data, unsigned int address, LumiverseColor* val);

    void ColorToLustrPlus(unsigned char* data, unsigned int address, LumiverseColor* val);

    inline void setDMXVal(unsigned char* data, unsigned int address, unsigned char val);
  };
}

#endif