RadialMenu.c

Go to the documentation of this file.

enum RadialMenuControlType
{
  MOUSE,
  CONTROLLER
}
 
class RadialMenu : ScriptedWidgetEventHandler
{
  protected Widget m_Parent;
  protected Widget m_ItemCardsContainer;
  protected Widget m_RadialSelector;
  protected ImageWidget m_RadialSelectorImage;
  protected ImageWidget m_RadialSelectorPointerImage;
  protected int m_RadialSelectorOriginalColor;
  protected int m_RadialSelectorDisabledColor;
  protected Widget m_SelectedObject;
  protected ref map<Widget, float> m_RadialItemCards;
 
  protected float m_AngleRadOffset;
  protected ref Timer m_UpdateTimer;
 
  //widget
  static const string RADIAL_SELECTOR = "RadialSelector";
  static const string RADIAL_SELECTOR_IMAGE = "SelectorImage";
  static const string RADIAL_SELECTOR_POINTER = "SelectorPointer";
  static const string RADIAL_DELIMITER_CONTAINER = "RadialDelimiterContainer";
  static const string RADIAL_ITEM_CARD_CONTAINER = "RadialItemCardContainer";
 
  //controls
  protected RadialMenuControlType m_ControlType;
  private UAIDWrapper m_SelectInputWrapper;
  private UAIDWrapper m_BackInputWrapper;
  protected float m_ControllerAngle;
  protected float m_ControllerTilt;
 
  //controller
  protected int m_ControllerTimout;
  protected bool m_IsControllerTimoutEnabled = true; //enables/disables controller deselect timeout reset
  protected const float CONTROLLER_DESELECT_TIMEOUT = 1000; //timeout [ms] after which selection is automatically deselect when controller is not active
  protected const float CONTROLLER_TILT_TRESHOLD_SELECT = 0.8; //tilt value (0.0-1.0) for controller sticks after which the selection will be selected
  protected const float CONTROLLER_TILT_TRESHOLD_EXECUTE = 1.0; //tilt value (0.0-1.0) for controller sticks after which the selection will be executed
 
  //mouse
  protected bool m_WidgetInitialized;
  protected const float MOUSE_SAFE_ZONE_RADIUS = 120; //Radius [px] of safe zone where every previous selection is deselected
 
  //References
  protected float m_RadiusOffset; //Radius [% of the main container size]
  protected float m_ExecuteDistanceOffset; //Distance offset [% of the main container size] after which the selection will be automatically executed
  protected float m_OffsetFromTop; //first item in the menu won't be directly on top but offset by a rad angle value (clock-wise)
  protected float m_ItemCardRadiusOffset; //Radius [% of the main container size] for item cards
  protected string m_DelimiterLayout; //layout file name with path
 
  ref UIScriptedMenu m_RegisteredClass;
  ref static RadialMenu m_Instance;
 
  /*
 
      RADIAL MENU EVENTS
 
    Mouse:
    OnMouseSelect
    OnMouseDeselect
    OnMouseExecute - unused, press events used instead
    OnMousePressLeft
    OnMousePressRight
 
    Controller:
    OnControllerSelect
    OnControllerDeselect
    OnControllerExecute - unused, press events used instead
    OnControllerPressSelect
    OnControllerPressBack
 
    Common:
    OnControlsChanged   - controls has been changed (mouse<->controller)
 
  */
 
 
  //============================================
  // RadialMenu
  //============================================
  void RadialMenu()
  {
    m_Instance = this;
 
    //set default control type
#ifdef PLATFORM_CONSOLE
    Input inp = GetGame().GetInput();
    if (inp && inp.IsEnabledMouseAndKeyboardEvenOnServer())
      m_ControlType = RadialMenuControlType.MOUSE;
    else
      m_ControlType = RadialMenuControlType.CONTROLLER;
#endif
#ifdef PLATFORM_WINDOWS
    m_ControlType = RadialMenuControlType.MOUSE;
#endif
 
    m_SelectInputWrapper = GetUApi().GetInputByID(UAUISelect).GetPersistentWrapper();
    m_BackInputWrapper = GetUApi().GetInputByID(UAUIBack).GetPersistentWrapper();
 
    //radial cards
    m_RadialItemCards = new map<Widget, float>;
    m_UpdateTimer = new Timer();
    m_UpdateTimer.Run(0.01, this, "Update", NULL, true);
  }
 
  void ~RadialMenu()
  {
  }
 
  static RadialMenu GetInstance()
  {
    return m_Instance;
  }
 
  //Set handler
  void OnWidgetScriptInit(Widget w)
  {
    m_ItemCardsContainer = w.FindAnyWidget(RADIAL_ITEM_CARD_CONTAINER);
    m_RadialSelector = w.FindAnyWidget(RADIAL_SELECTOR);
    m_RadialSelectorImage = ImageWidget.Cast(m_RadialSelector.FindAnyWidget(RADIAL_SELECTOR_IMAGE));
    m_RadialSelectorPointerImage = ImageWidget.Cast(m_RadialSelector.FindAnyWidget(RADIAL_SELECTOR_POINTER));
 
    m_RadialSelectorOriginalColor = m_RadialSelectorImage.GetColor();
    m_RadialSelectorDisabledColor = ARGB(255, 150, 150, 150);
 
    //parent
    m_Parent = w;
    m_Parent.SetHandler(this);
  }
 
  //controls
  void SetControlType(RadialMenuControlType type)
  {
    if (m_ControlType != type)
    {
      m_ControlType = type;
      GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControlsChanged", NULL, type);
    }
  }
 
  bool IsUsingMouse()
  {
    if (m_ControlType == RadialMenuControlType.MOUSE)
      return true;
 
    return false;
  }
 
  bool IsUsingController()
  {
    if (m_ControlType == RadialMenuControlType.CONTROLLER)
      return true;
 
    return false;
  }
 
  void SetWidgetInitialized(bool state)
  {
    m_WidgetInitialized = state;
  }
 
  bool IsWidgetInitialized()
  {
    return m_WidgetInitialized;
  }
 
  //============================================
  // Setup
  //============================================
  void RegisterClass(UIScriptedMenu class_name)
  {
    m_RegisteredClass = class_name;
    if (m_UpdateTimer && !m_UpdateTimer.IsRunning())
      m_UpdateTimer.Run(0.01, this, "Update", NULL, true);
  }
 
  //Set radial menu parameters
  //Radius offset [% of the main container size]
  void SetRadiusOffset(float radius_offset)
  {
    m_RadiusOffset = radius_offset;
  }
 
  //Distance offset [% of the main container size] after which the selection will be automatically executed
  void SetExecuteDistOffset(float execute_dist_offset)
  {
    m_ExecuteDistanceOffset = execute_dist_offset;
  }
 
  //First item in the menu won't be directly on top but offset by a rad angle value (clock-wise)
  void SetOffsetFromTop(float offset_from_top)
  {
    m_OffsetFromTop = offset_from_top;
  }
 
  //Radius [% of the main container size] for item cards
  void SetItemCardRadiusOffset(float item_card_radius_offset)
  {
    m_ItemCardRadiusOffset = item_card_radius_offset;
  }
 
  //Enable/Disable controller timeout
  void ActivateControllerTimeout(bool state)
  {
    m_IsControllerTimoutEnabled = state;
  }
 
  void SetWidgetProperties(string delimiter_layout)
  {
    m_DelimiterLayout = delimiter_layout;
  }
 
  //============================================
  // Visual
  //============================================
  //hide_selector => shows/hides radial selector when refreshing radial menu
  void Refresh(bool hide_selector = true)
  {
    int item_cards_count = GetItemCardsCount();
    if (item_cards_count > 0)
      m_AngleRadOffset = 2 * Math.PI / item_cards_count;
    float angle_rad = -Math.PI / 2;
 
    //--PARAM top offset--
    if (m_OffsetFromTop != 0)
      angle_rad = angle_rad + m_OffsetFromTop;
    //--------------------
 
    //delete all delimiters
    Widget delimiters_panel = m_Parent.FindAnyWidget(RADIAL_DELIMITER_CONTAINER);
    if (delimiters_panel)
    {
      Widget del_child = delimiters_panel.GetChildren();
      while (del_child)
      {
        Widget child_to_destroy1 = del_child;
        del_child = del_child.GetSibling();
 
        delete child_to_destroy1;
      }
    }
 
    //Position item cards, crate radial delimiters
    Widget item_cards_panel = m_Parent.FindAnyWidget(RADIAL_ITEM_CARD_CONTAINER);
    Widget item_card = item_cards_panel.GetChildren();
 
    //get radius
    float original_r = GetRadius();
    float item_cards_r = original_r;
 
    //--PARAM top offset--....
    if (m_ItemCardRadiusOffset != 0)
    {
      item_cards_r = item_cards_r * m_ItemCardRadiusOffset;
      if (item_cards_r < 0) item_cards_r = 0; //min radius is 0
    }
 
    m_RadialItemCards.Clear();
    for (int i = 0; i < item_cards_count; ++i)
    {
      //position item cards
      if (item_card)
      {
        //creates circle from simple widget items
        float pos_x = item_cards_r * Math.Cos(angle_rad);
        float pos_y = item_cards_r * Math.Sin(angle_rad);
 
        pos_x = pos_x / original_r;
        pos_y = pos_y / original_r;
 
        item_card.SetPos(pos_x, pos_y);
 
        //store item card
        m_RadialItemCards.Insert(item_card, angle_rad);
 
        //get next child
        item_card = item_card.GetSibling();
      }
      //-------------------------
 
      //create delimiter
      if (item_cards_count > 1 && delimiters_panel && m_DelimiterLayout)
      {
        Widget delimiter_widget = GetGame().GetWorkspace().CreateWidgets(m_DelimiterLayout, delimiters_panel);
        float delim_angle_rad = angle_rad + (m_AngleRadOffset / 2);
        delimiter_widget.SetPos(0, 0);
        delimiter_widget.SetRotation(0, 0, GetAngleInDegrees(delim_angle_rad) + 90);
      }
 
      //calculate next angle
      angle_rad += m_AngleRadOffset;
    }
 
    //hide selector on refresh
    if (hide_selector)
      HideRadialSelector();
  }
 
  //Radial selector
  protected void ShowRadialSelector(Widget selected_item)
  {
    if (m_RadialSelector && selected_item)
    {
      int item_count = m_RadialItemCards.Count();
      if (item_count > 1)
      {
        int angle_deg = GetAngleInDegrees(m_RadialItemCards.Get(selected_item));
        m_RadialSelector.SetRotation(0, 0, angle_deg + 90); //rotate widget according to its desired rotation
 
        //set radial selector size
        float progress = (1 / item_count) * 2;
        m_RadialSelectorImage.SetMaskProgress(progress);
 
        m_RadialSelector.Show(true);
 
        bool grey_selector = selected_item.GetFlags() & WidgetFlags.DISABLED;
        if (!grey_selector)
        {
          m_RadialSelectorImage.SetColor(m_RadialSelectorDisabledColor);
          m_RadialSelectorPointerImage.SetColor(m_RadialSelectorDisabledColor);
        }
        else
        {
          m_RadialSelectorImage.SetColor(m_RadialSelectorOriginalColor);
          m_RadialSelectorPointerImage.SetColor(m_RadialSelectorOriginalColor);
        }
      }
    }
  }
 
  protected void HideRadialSelector()
  {
    if (m_RadialSelector)
      m_RadialSelector.Show(false);
  }
 
  //============================================
  // Widget size calculations
  //============================================
  protected int GetItemCardsCount()
  {
    Widget child = m_ItemCardsContainer.GetChildren();
    int count = 0;
 
    while (child)
    {
      ++count;
 
      child = child.GetSibling();
    }
 
    return count;
  }
 
  protected float GetRadius()
  {
    float radius = Math.AbsFloat(GetParentMinSize() * 0.5);
 
    //PARAM --radius--
    if (m_RadiusOffset > 0)
      return radius * m_RadiusOffset;
    //----------------
 
    return radius;
  }
 
  protected void GetParentCenter(out float center_x, out float center_y)
  {
    if (m_Parent)
    {
      float wx;
      float wy;
      m_Parent.GetScreenPos(wx, wy);
 
      float ww;
      float wh;
      m_Parent.GetScreenSize(ww, wh);
 
      center_x = wx + ww / 2; //center
      center_y = wy + wh / 2;
    }
  }
 
  protected float GetParentMinSize()
  {
    if (m_Parent)
    {
      float size_x;
      float size_y;
      m_Parent.GetScreenSize(size_x, size_y);
 
      return Math.Min(size_x, size_y);
    }
 
    return 0;
  }
 
  //============================================
  // Angle calculations
  //============================================
  //get object by angle (degrees)
  protected Widget GetObjectByDegAngle(float deg_angle)
  {
    for (int i = 0; i < m_RadialItemCards.Count(); ++i)
    {
      Widget w = m_RadialItemCards.GetKey(i);
      float w_angle = GetAngleInDegrees(m_RadialItemCards.Get(w));
      float offset = GetAngleInDegrees(m_AngleRadOffset) / 2;
      float min_angle = w_angle - offset;
      float max_angle = w_angle + offset;
 
      if (min_angle < 0) min_angle += 360; //clamp 0-360
      if (max_angle > 360) max_angle -= 360;
 
      if (min_angle > max_angle) //angle radius is in the cycling point 360->
      {
        if (min_angle <= deg_angle) //is cursor position also before this point
        {
          if (deg_angle > max_angle)
            return w;
        }
        else //is cursor position after this point
        {
          if (deg_angle < max_angle)
            return w;
        }
      }
      else
      {
        if (deg_angle >= min_angle && deg_angle < max_angle) //min, max angles are within 0-360 radius
          return w;
      }
    }
 
    return NULL;
  }
 
  //returns GUI compatible mouse-to-parent angle
  protected float GetMousePointerAngle()
  {
    int mouse_x;
    int mouse_y;
    GetMousePos(mouse_x, mouse_y);
 
    float center_x;
    float center_y;
    GetParentCenter(center_x, center_y);
 
    float tan_x = mouse_x - center_x;
    float tan_y = mouse_y - center_y;
    float angle = Math.Atan2(tan_y, tan_x);
 
    return angle;
  }
 
  //returns distance from parent center
  protected float GetMouseDistance()
  {
    int mouse_x;
    int mouse_y;
    GetMousePos(mouse_x, mouse_y);
 
    float center_x;
    float center_y;
    GetParentCenter(center_x, center_y);
 
    float distance = vector.Distance(Vector(mouse_x, mouse_y, 0), Vector(center_x, center_y, 0));
 
    return distance;
  }
 
  //return angle 0-360 deg
  protected float GetAngleInDegrees(float rad_angle)
  {
    float rad_deg = rad_angle * Math.RAD2DEG;
 
    int angle_mp = rad_deg / 360;
 
    if (rad_deg < 0)
    {
      rad_deg = rad_deg - (360 * angle_mp);
      rad_deg += 360;
    }
 
    return rad_deg;
  }
 
  //============================================
  // Update
  //============================================
  //mouse
  int last_time = -1;
  protected void Update()
  {
    if (this && !m_RegisteredClass)
    {
      m_UpdateTimer.Stop();
      return;
    }
 
    //get delta time
    if (last_time < 0)
      last_time = GetGame().GetTime();
    int delta_time = GetGame().GetTime() - last_time;
    last_time = GetGame().GetTime();
 
    //controls
    if (this && m_RegisteredClass && m_RegisteredClass.IsVisible())
    {
      //mouse controls
      if (IsUsingMouse() && m_WidgetInitialized)
      {
        float mouse_angle = GetMousePointerAngle();
        float mouse_distance = GetMouseDistance();
 
        //--PARAM --safe zone radius--
        if (mouse_distance <= MOUSE_SAFE_ZONE_RADIUS)
        {
          //Deselect
          GetGame().GameScript.CallFunction(m_RegisteredClass, "OnMouseDeselect", NULL, m_SelectedObject);
          m_SelectedObject = NULL;
          //hide selector
          HideRadialSelector();
        }
        else
        {
          //Deselect
          GetGame().GameScript.CallFunction(m_RegisteredClass, "OnMouseDeselect", NULL, m_SelectedObject);
 
          //Select
          m_SelectedObject = GetObjectByDegAngle(GetAngleInDegrees(mouse_angle));
          GetGame().GameScript.CallFunction(m_RegisteredClass, "OnMouseSelect", NULL, m_SelectedObject);
          //show selector
          ShowRadialSelector(m_SelectedObject);
        }
      }
      //controller controls
      else if (IsUsingController())
      {
        UpdataControllerInput();
 
        //Controller tilt
        if (m_ControllerAngle > -1 && m_ControllerTilt > -1)
        {
          //Right analogue stick
          Widget w_selected = GetObjectByDegAngle(m_ControllerAngle);
          //Select
          if (w_selected)
          {
            if (w_selected != m_SelectedObject)
            {
              if (m_ControllerTilt >= CONTROLLER_TILT_TRESHOLD_SELECT)
              {
                //Deselect
                GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerDeselect", NULL, m_SelectedObject);
 
                //Select new object
                m_SelectedObject = w_selected;
                GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerSelect", NULL, m_SelectedObject);
                //show selector
                ShowRadialSelector(m_SelectedObject);
              }
            }
          }
          else
          {
            GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerDeselect", NULL, m_SelectedObject);
            m_SelectedObject = NULL;
            //hide selector
            HideRadialSelector();
          }
        }
        //if controller is giving no feedback
        else
        {
          if (m_IsControllerTimoutEnabled)
          {
            m_ControllerTimout += delta_time;
 
            if (m_ControllerTimout >= CONTROLLER_DESELECT_TIMEOUT)
            {
              GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerDeselect", NULL, m_SelectedObject);
              m_SelectedObject = NULL;
              //hide selector
              HideRadialSelector();
 
              m_ControllerTimout = 0; //reset controller timeout
            }
          }
        }
 
        m_ControllerAngle = -1; //reset angle and tilt
        m_ControllerTilt = -1;
      }
 
      m_WidgetInitialized = true;
    }
  }
 
  float NormalizeInvertAngle(float angle)
  {
    float new_angle = 360 - angle;
    int angle_mp = new_angle / 360;
 
    new_angle = new_angle - (360 * angle_mp);
 
    return new_angle;
  }
 
  //============================================
  // Controls
  //============================================
  void UpdataControllerInput()
  {
    Input input = GetGame().GetInput();
 
    //Controller radial
    float angle;
    float tilt;
    input.GetGamepadThumbDirection(GamepadButton.THUMB_RIGHT, angle, tilt);
    angle = NormalizeInvertAngle(angle * Math.RAD2DEG);
 
    m_ControllerAngle = angle;
    m_ControllerTilt = tilt;
    m_ControllerTimout = 0; //reset controller timeout
 
    //Controller buttons
    //Select (A,cross)
    if (m_SelectInputWrapper.InputP().LocalPress())
      GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerPressSelect", NULL, m_SelectedObject);
 
    //Back (B,circle)
    if (m_BackInputWrapper.InputP().LocalPress())
      GetGame().GameScript.CallFunction(m_RegisteredClass, "OnControllerPressBack", NULL, m_SelectedObject);
  }
 
  override bool OnMouseButtonUp(Widget w, int x, int y, int button)
  {
    if (button == MouseState.LEFT && m_SelectedObject/* && w == m_SelectedObject*/)
    {
      //Execute
      GetGame().GameScript.CallFunction(m_RegisteredClass, "OnMousePressLeft", NULL, m_SelectedObject);
 
      return true;
    }
 
    if (button == MouseState.RIGHT)
    {
      //Back one level
      GetGame().GameScript.CallFunction(m_RegisteredClass, "OnMousePressRight", NULL, NULL);
 
      return true;
    }
 
    return false;
  }
}