LumiverseOrientation.h

Go to the documentation of this file.

#ifndef _LumiverseORIENTATION_H_
#define _LumiverseORIENTATION_H_
#pragma once

#include "../LumiverseType.h"
#include <string>
#include <stdio.h>
#include <unordered_map>
#define _USE_MATH_DEFINES
#include <math.h>

namespace Lumiverse {
  enum ORIENTATION_UNIT {
    DEGREE, RADIAN
  };

#ifdef USE_C11_MAPS

  static unordered_map<int, string> oriToString = {
    { DEGREE, "degree" }, { RADIAN, "radian" }
  };

  static unordered_map<string, int> stringToOri = {
    { "degree", DEGREE }, { "radian", RADIAN }
  };
#else
  static string oriToString(ORIENTATION_UNIT u) {
    switch(u) {
    case DEGREE:
      return "degree";
    case RADIAN:
      return "radian";
    default:
      return "";
    }
  }

  static ORIENTATION_UNIT stringToOri(string u) {
    if (u == "degree") return DEGREE;
    if (u == "radian") return RADIAN;

    return RADIAN;
  }
#endif

  class LumiverseOrientation : public LumiverseType
  {
  public:
    LumiverseOrientation(float val = 0.0f, ORIENTATION_UNIT unit = DEGREE, float def = 0.0f, float max = 360.0f, float min = 0.0f);

    LumiverseOrientation(LumiverseOrientation* other);

    LumiverseOrientation(LumiverseType* other);

    ~LumiverseOrientation();

    virtual string getTypeName() { return "orientation"; }

    // Override for =
    void operator=(float val);
    void operator=(LumiverseOrientation val);

    // Arithmetic overrides
    LumiverseOrientation& operator+=(float val);
    LumiverseOrientation& operator+=(LumiverseOrientation& val);

    LumiverseOrientation& operator-=(float val);
    LumiverseOrientation& operator-=(LumiverseOrientation& val);

    LumiverseOrientation& operator*=(float val);
    LumiverseOrientation& operator*=(LumiverseOrientation& val);

    LumiverseOrientation& operator/=(float val);
    LumiverseOrientation& operator/=(LumiverseOrientation& val);

    float getVal() { return m_val; }

    void setVal(float val, ORIENTATION_UNIT unit = DEGREE) { m_val = asUnit(unit, val, m_unit); clamp(); }

    void setVals(float val, float def, float min, float max);

    void setUnit(ORIENTATION_UNIT unit);

    ORIENTATION_UNIT getUnit() { return m_unit; }

    void setMax(float val, ORIENTATION_UNIT unit = DEGREE) { m_max = asUnit(unit, val, m_unit); }
    
    float getMax() { return m_max; }

    void setMin(float val, ORIENTATION_UNIT unit = DEGREE) { m_min = asUnit(unit, val, m_unit); }
    
    float getMin() { return m_min; }

    void setDefault(float val, ORIENTATION_UNIT unit = DEGREE) { m_default = asUnit(unit, val, m_unit); }
    
    float getDefault() { return m_default; }

    virtual void reset() { m_val = m_default; }

    void setValAsPercent(float val);
    
    float asPercent();

    float valAsUnit(ORIENTATION_UNIT unit) { return asUnit(m_unit, m_val, unit); }

    float maxAsUnit(ORIENTATION_UNIT unit) { return asUnit(m_unit, m_max, unit); }

    float minAsUnit(ORIENTATION_UNIT unit) { return asUnit(m_unit, m_min, unit); }

    float defaultAsUnit(ORIENTATION_UNIT unit) { return asUnit(m_unit, m_default, unit); }

    // Converts a float to a JSON object with specified name.
    virtual JSONNode toJSON(string name);

    virtual string asString();

    virtual bool isDefault();

  private:
    void clamp();

    float asUnit(ORIENTATION_UNIT valUnit, float val, ORIENTATION_UNIT targetUnit);

    float m_val;

    float m_default;

    float m_max;

    float m_min;

    ORIENTATION_UNIT m_unit;
  };

  // Ops ops ops all overloaded woo

  // Compares two LumiverseOrientations. Uses normal float comparison
  inline bool operator==(LumiverseOrientation& a, LumiverseOrientation& b) {
    if (a.getTypeName() != "orientation" || b.getTypeName() != "orientation")
      return false;

    // Equality/inequality shouldn't change based on a unit conversion.
    return a.getVal() == b.valAsUnit(a.getUnit());
  }

  inline bool operator!=(LumiverseOrientation& a, LumiverseOrientation& b) {
    return !(a == b);
  }

  // LumiverseOrientation uses the normal < op for floats.
  inline bool operator<(LumiverseOrientation& a, LumiverseOrientation& b) {
    if (a.getTypeName() != "orientation" || b.getTypeName() != "orientation")
      return false;

    // Equality/inequality shouldn't change based on a unit conversion.
    return a.getVal() < b.valAsUnit(a.getUnit());
  }

  inline bool operator>(LumiverseOrientation& a, LumiverseOrientation& b) {
    return b < a;
  }

  inline bool operator<=(LumiverseOrientation& a, LumiverseOrientation& b) {
    return !(a > b);
  }

  inline bool operator>=(LumiverseOrientation& a, LumiverseOrientation b) {
    return !(a < b);
  }

  // Arithmetic overrides
  inline LumiverseOrientation operator+(LumiverseOrientation& lhs, float rhs) {
    LumiverseOrientation val = LumiverseOrientation(lhs);
    val += rhs;
    return val;
  }

  //inline LumiverseOrientation operator+(LumiverseOrientation& lhs, LumiverseOrientation& rhs) {
  //  LumiverseOrientation val = LumiverseOrientation(lhs);
  //  val += rhs.valAsUnit(val.getUnit());
  //  return val;
  //}

  // Apparently clang needs this form of the overload to make it happy
  inline LumiverseOrientation operator+(LumiverseOrientation lhs, LumiverseOrientation rhs) {
    LumiverseOrientation val = LumiverseOrientation(lhs);
    val += rhs.valAsUnit(val.getUnit());
    return val;
  }

  inline LumiverseOrientation operator-(LumiverseOrientation& lhs, float rhs) {
    LumiverseOrientation val = LumiverseOrientation(lhs);
    val -= rhs;
    return val;
  }

  inline LumiverseOrientation operator-(LumiverseOrientation& lhs, LumiverseOrientation& rhs) {
    LumiverseOrientation val = LumiverseOrientation(lhs);
    val -= rhs.valAsUnit(val.getUnit());
    return val;
  }

  inline LumiverseOrientation operator*(LumiverseOrientation& lhs, float rhs) {
    LumiverseOrientation val = LumiverseOrientation(lhs);
    val *= rhs;
    return val;
  }

  inline LumiverseOrientation operator*(LumiverseOrientation& lhs, LumiverseOrientation& rhs) {
    LumiverseOrientation val = LumiverseOrientation(lhs);
    val *= rhs.valAsUnit(val.getUnit());;
    return val;
  }

  inline LumiverseOrientation operator/(LumiverseOrientation& lhs, float rhs) {
    LumiverseOrientation val = LumiverseOrientation(lhs);
    val /= rhs;
    return val;
  }

  inline LumiverseOrientation operator/(LumiverseOrientation& lhs, LumiverseOrientation& rhs) {
    LumiverseOrientation val = LumiverseOrientation(lhs);
    val /= rhs.valAsUnit(val.getUnit());
    return val;
  }
}

#endif