示例#1
0
        /// <summary>
        /// The UpdateText method allows the tooltip text on a specific controller element to be updated at runtime.
        /// </summary>
        /// <param name="element">The specific controller element to change the tooltip text on.</param>
        /// <param name="newText">A string containing the text to update the tooltip to display.</param>
        public virtual void UpdateText(TooltipButtons element, string newText)
        {
            switch (element)
            {
            case TooltipButtons.ButtonOneTooltip:
                buttonOneText = newText;
                break;

            case TooltipButtons.ButtonTwoTooltip:
                buttonTwoText = newText;
                break;

            case TooltipButtons.StartMenuTooltip:
                startMenuText = newText;
                break;

            case TooltipButtons.GripTooltip:
                gripText = newText;
                break;

            case TooltipButtons.TouchpadTooltip:
                touchpadText = newText;
                break;

            case TooltipButtons.TriggerTooltip:
                triggerText = newText;
                break;
            }
            ResetTooltip();
        }
示例#2
0
 public void HideTooltip(TooltipControllers controller, TooltipButtons button)
 {
     SetTooltip("",
                controller,
                button,
                false);
 }
示例#3
0
        private Transform  GetButtonTransform(TooltipControllers controller, TooltipButtons button)
        {
            ControllerInteraction.ControllerElements findElement;

            TooltipTransformAdapterBase adapter = null;

            Transform returnedTransform = null;

            if (controller == TooltipControllers.Left)
            {
                adapter = _leftTooltipAdapter;
            }
            else if (controller == TooltipControllers.Right)
            {
                adapter = _rightTooltipAdapter;
            }

            if (!adapter)
            {
                return(null);
            }


            switch (button)
            {
            case TooltipButtons.Trigger:
                returnedTransform = adapter.GetButtonTransform(ControllerInteraction.ControllerElements.Trigger);
                break;

            case TooltipButtons.Grip:
                returnedTransform = adapter.GetButtonTransform(ControllerInteraction.ControllerElements.GripLeft);
                break;

            case TooltipButtons.Touchpad:
                returnedTransform = adapter.GetButtonTransform(ControllerInteraction.ControllerElements.Touchpad);
                break;

            case TooltipButtons.ButtonOne:
                returnedTransform = adapter.GetButtonTransform(ControllerInteraction.ControllerElements.ButtonOne);
                break;

            case TooltipButtons.ButtonTwo:
                returnedTransform = adapter.GetButtonTransform(ControllerInteraction.ControllerElements.ButtonTwo);
                break;

            case TooltipButtons.StartMenu:
                returnedTransform = adapter.GetButtonTransform(ControllerInteraction.ControllerElements.StartMenu);
                break;

            default:
                returnedTransform = adapter.GetButtonTransform(ControllerInteraction.ControllerElements.Touchpad);
                break;
            }

            return(returnedTransform);
        }
示例#4
0
 public void SetTooltip(
     string text,
     TooltipControllers controller,
     TooltipButtons button,
     bool buttonGlow,
     bool vibration = true)
 {
     StartCoroutine(TooltipCoroutine(text,
                                     controller,
                                     button,
                                     buttonGlow,
                                     vibration));
 }
 public void ShowTips(bool state, TooltipButtons element = TooltipButtons.None)
 {
     if (element == TooltipButtons.None)
     {
         for(int i = 0; i < buttonTooltips.Length; i++)
         {
             buttonTooltips[i].SetActive(state);
         }
     } else
     {
         buttonTooltips[(int)element].SetActive(state);
     }
 }
示例#6
0
        protected virtual void EmitEvent(bool state, TooltipButtons element)
        {
            ControllerTooltipsEventArgs e;

            e.element = element;
            if (state)
            {
                OnControllerTooltipOn(e);
            }
            else
            {
                OnControllerTooltipOff(e);
            }
        }
示例#7
0
 /// <summary>
 /// The ToggleTips method will display the controller tooltips if the state is `true` and will hide the controller tooltips if the state is `false`. An optional `element` can be passed to target a specific controller tooltip to toggle otherwise all tooltips are toggled.
 /// </summary>
 /// <param name="state">The state of whether to display or hide the controller tooltips, true will display and false will hide.</param>
 /// <param name="element">The specific element to hide the tooltip on, if it is `TooltipButtons.None` then it will hide all tooltips. Optional parameter defaults to `TooltipButtons.None`</param>
 public void ToggleTips(bool state, TooltipButtons element = TooltipButtons.None)
 {
     if (element == TooltipButtons.None)
     {
         for (int i = 0; i < buttonTooltips.Length; i++)
         {
             buttonTooltips[i].SetActive(state);
         }
     }
     else
     {
         buttonTooltips[(int)element].SetActive(state);
     }
 }
示例#8
0
 private IEnumerator TooltipCoroutine(
     string text,
     TooltipControllers controller,
     TooltipButtons button,
     bool buttonGlow,
     bool vibration = true)
 {
     while (!UpdateTooltip(text,
                           controller,
                           button,
                           buttonGlow,
                           vibration))
     {
         yield return(new WaitForEndOfFrame());
     }
 }
示例#9
0
 /// <summary>
 /// The ToggleTips method will display the controller tooltips if the state is `true` and will hide the controller tooltips if the state is `false`. An optional `element` can be passed to target a specific controller tooltip to toggle otherwise all tooltips are toggled.
 /// </summary>
 /// <param name="state">The state of whether to display or hide the controller tooltips, true will display and false will hide.</param>
 /// <param name="element">The specific element to hide the tooltip on, if it is `TooltipButtons.None` then it will hide all tooltips. Optional parameter defaults to `TooltipButtons.None`</param>
 public virtual void ToggleTips(bool state, TooltipButtons element = TooltipButtons.None)
 {
     if (element == TooltipButtons.None)
     {
         for (int i = 1; i < buttonTooltips.Length; i++)
         {
             if (buttonTooltips[i].displayText.Length > 0)
             {
                 buttonTooltips[i].gameObject.SetActive(state);
             }
         }
     }
     else
     {
         if (buttonTooltips[(int)element].displayText.Length > 0)
         {
             buttonTooltips[(int)element].gameObject.SetActive(state);
         }
     }
 }
示例#10
0
        /// <summary>
        /// The UpdateText method allows the tooltip text on a specific controller element to be updated at runtime.
        /// </summary>
        /// <param name="element">The specific controller element to change the tooltip text on.</param>
        /// <param name="newText">A string containing the text to update the tooltip to display.</param>
        public void UpdateText(TooltipButtons element, string newText)
        {
            switch (element)
            {
            case TooltipButtons.AppMenuTooltip:
                appMenuText = newText;
                break;

            case TooltipButtons.GripTooltip:
                gripText = newText;
                break;

            case TooltipButtons.TouchpadTooltip:
                touchpadText = newText;
                break;

            case TooltipButtons.TriggerTooltip:
                triggerText = newText;
                break;
            }
            ResetTooltip();
        }
示例#11
0
 public override void ToggleTips(bool state, TooltipButtons element = TooltipButtons.None)
 {
     base.ToggleTips(state, element);
 }
示例#12
0
        public Transform GetTooltipInstantiationTransform(TooltipControllers controller, TooltipButtons button)
        {
            Transform tooltipTransform;

            if (controller == TooltipControllers.Left)
            {
                tooltipTransform = LeftControllerEvents.transform.Find("TooltipPositions");
            }
            else
            {
                tooltipTransform = RightControllerEvents.transform.Find("TooltipPositions");
            }

            switch (button)
            {
            case TooltipButtons.Trigger:
                tooltipTransform = tooltipTransform.Find("Trigger");

                break;

            case TooltipButtons.Grip:
                tooltipTransform = tooltipTransform.Find("Grip");

                break;

            case TooltipButtons.Touchpad:
                tooltipTransform = tooltipTransform.Find("Touchpad");

                break;

            case TooltipButtons.ButtonOne:
                tooltipTransform = tooltipTransform.Find("ButtonOne");

                break;

            case TooltipButtons.ButtonTwo:
                tooltipTransform = tooltipTransform.Find("ButtonTwo");

                break;

            case TooltipButtons.StartMenu:
                tooltipTransform = tooltipTransform.Find("StartMenu");

                break;
            }

            return(tooltipTransform);
        }
示例#13
0
        private bool UpdateTooltip(
            string text,
            TooltipControllers controller,
            TooltipButtons button,
            bool buttonGlow,
            bool vibration = true)
        {
            if ((controller == TooltipControllers.Left && !_leftControllerReady) ||
                (controller == TooltipControllers.Right && !_rightControllerReady))
            {
                return(false);
            }

            GameObject tooltipObject;
            Tooltip    tooltip;

            Transform       buttonAttachTransform = null;
            HighlightEffect highlight             = null;


            if ((controller == TooltipControllers.Left && !_tooltipObjectsLeft.ContainsKey(button)) ||
                (controller == TooltipControllers.Right && !_tooltipObjectsRight.ContainsKey(button)))
            {
                buttonAttachTransform = GetButtonTransform(controller, button);

                if (buttonAttachTransform == null)
                {
                    return(false);
                }

                tooltipObject = Instantiate(TooltipTemplate, GetTooltipInstantiationTransform(controller, button));

                if (controller == TooltipControllers.Left)
                {
                    _tooltipObjectsLeft.Add(button, tooltipObject);
                }
                else
                {
                    _tooltipObjectsRight.Add(button, tooltipObject);
                }

                tooltip = InputAdapter.Instance.Tooltip.GetFromChildren(tooltipObject, true);

                tooltip.drawLineTo = buttonAttachTransform;

                buttonAttachTransform.parent.gameObject.AddComponent <HighlightEffect>();

                highlight = buttonAttachTransform.GetComponentInParent <HighlightEffect>();

                SetupHighlighter(ref highlight);

                highlight.enabled = false;
            }
            else
            {
                if (controller == TooltipControllers.Left)
                {
                    tooltipObject = _tooltipObjectsLeft[button];
                }
                else
                {
                    tooltipObject = _tooltipObjectsRight[button];
                }

                tooltip = InputAdapter.Instance.Tooltip.GetFromChildren(tooltipObject, true);
            }

            tooltip.displayText = text;

            tooltip.ResetTooltip();

            if (highlight == null)
            {
                buttonAttachTransform = GetButtonTransform(controller, button);
                highlight             = buttonAttachTransform.GetComponentInParent <HighlightEffect>();
                if (highlight != null)
                {
                    highlight.enabled = false;
                }
            }

            if (text.Trim().Length != 0 || buttonGlow)
            {
                tooltipObject.SetActive(true);

                if (highlight != null)
                {
                    highlight.enabled = buttonGlow;
                }

                if (vibration)
                {
                    Vibrate(controller);
                }
            }
            else
            {
                tooltipObject.SetActive(false);
            }


            return(true);
        }
 /// <summary>
 /// The UpdateText method allows the tooltip text on a specific controller element to be updated at runtime.
 /// </summary>
 /// <param name="element">The specific controller element to change the tooltip text on.</param>
 /// <param name="newText">A string containing the text to update the tooltip to display.</param>
 public void UpdateText(TooltipButtons element, string newText)
 {
     switch (element)
     {
         case TooltipButtons.AppMenuTooltip:
             appMenuText = newText;
             break;
         case TooltipButtons.GripTooltip:
             gripText = newText;
             break;
         case TooltipButtons.TouchpadTooltip:
             touchpadText = newText;
             break;
         case TooltipButtons.TriggerTooltip:
             triggerText = newText;
             break;
     }
     ResetTooltip();
 }