Rig.h

Go to the documentation of this file.

#ifndef _RIG_H_
#define _RIG_H_

#pragma once

#include <thread>
#include <chrono>
#include <iostream>
#include <algorithm>
#include <fstream>
#include <sstream>
#include <set>
#include <functional>

#include "LumiverseCoreConfig.h"
#include "Patch.h"
#include "DMX/DMXPatch.h"
#include "Device.h"
#include "Logger.h"
#include "DeviceSet.h"
#include "lib/libjson/libjson.h"

#ifdef USE_ARNOLD
#include "lib/arnold/include/ai.h"

#include "Simulation/PhotoPatch.h"
#include "Simulation/PhotoAnimationPatch.h"
#endif

#if defined(USE_ARNOLD) || defined(USE_ARNOLD_CACHING)
#include "Simulation/ArnoldPatch.h"
#include "Simulation/ArnoldAnimationPatch.h"
#endif

#ifdef USE_OSC
#include "OscPatch.h" 
#endif

namespace Lumiverse {
  typedef function<Patch*(JSONNode&)> patchParseFunc;

  class DeviceSet;

  // TODO: Right now if you change a device channel or id the rig doesn't
  // know about it. Need to add functions in the Rig that allow
  // this sort of change.
  class Rig
  {
    friend class DeviceSet;
  
  public:
    static map<string, patchParseFunc> patchParsers;

  public:
    Rig();

    Rig(string filename);

    ~Rig();

    void init();

    void run();

    void stop();

    bool load(string filename);

    void addDevice(Device * device);

    Device* getDevice(string id);

    void deleteDevice(string id);

    void addPatch(string id, Patch* patch);

    Patch* getPatch(string id);

    const map<string, Patch*>& getPatches() { return m_patches; }

    DMXPatch* getPatchAsDMXPatch(string id) { return (DMXPatch*)getPatch(id); }

    void deletePatch(string id);

    void setRefreshRate(unsigned int rate);

    unsigned int getRefreshRate() { return m_refreshRate; }

    Device* operator[](string id);

    DeviceSet select(string q);

    DeviceSet operator[](unsigned int channel);

    // Queries. Most everything starts with the creation of a DeviceSet.
    // Detailed filtering happens there, the Rig provides a few convenience functions
    // to get things started.

    DeviceSet getAllDevices();

    DeviceSet getChannel(unsigned int channel);

    DeviceSet getChannel(unsigned int lower, unsigned int upper);

    DeviceSet getDevices(string key, string val, bool isEqual);

    set<string> getAllUsedParams();

    const set<Device *>& getDeviceRaw() { return m_devices; }

    bool save(string filename, bool overwrite = true);

    JSONNode toJSON();

    bool addFunction(int pid, function<void()> func);

    bool removeFunction(int pid);

    void update();

    void updateOnce();

    Patch *getSimulationPatch(string type);

    void setAllDevices(map<string, Device*> devices);

    size_t getNumDevices() { return m_devices.size(); }

    void resetDevices();

    bool isSlow() { return m_slow; }

    set<string> getMetadataValues(string key);

  private:
    void loadJSON(JSONNode root);

    void loadDevices(JSONNode root);

    void loadPatches(JSONNode root);

    void reset();

    thread* m_updateLoop;

    bool m_running;

    unsigned int m_refreshRate;

    float m_loopTime;

    set<Device *> m_devices;

    map<string, Patch *> m_patches;

    map<string, Device *> m_devicesById;

    multimap<unsigned int, Device *> m_devicesByChannel;

    map<int, function<void()> > m_updateFunctions;

    bool m_slow;

    // May have more indicies in the future, like mapping by channel number.
  };
}
#endif