Added new components for 1.0.0.5 release

--HG--
branch : develop_4.6

Scripts/HSVPicker/HexRGB.cs

@@ -7,7 +7,8 @@ namespace UnityEngine.UI.Extensions
 {
     public class HexRGB : MonoBehaviour
     {
-        public Text textColor;
+        // Unity 5.1/2 needs an InputFiled vs grabbing the text component
+	public InputField hexInput;
 
         public HSVPicker hsvpicker;
 
@@ -15,7 +16,7 @@ namespace UnityEngine.UI.Extensions
         {
             Color color = hsvpicker.currentColor;
             string hex = ColorToHex(color);
-            textColor.text = hex;
+	     hexInput.text = hex;
         }
 
         public static string ColorToHex(Color color)
@@ -28,8 +29,7 @@ namespace UnityEngine.UI.Extensions
 
         public void ManipulateViaHex2RGB()
         {
-            string hex = textColor.text;
+	     string hex = hexInput.text;
-
             Vector3 rgb = Hex2RGB(hex);
             Color color = NormalizeVector4(rgb, 255f, 1f); print(rgb);
 

Scripts/InputModules.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: a0789c2f62bad6b4c800a3dc502fa18e
+folderAsset: yes
+DefaultImporter:
+  userData: 

Scripts/InputModules/AimerInputModule.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: f7d3d69aa5226dc4493464d3b5e4ddc3
+guid: 08b9f423b73fdfb47b59e7de89863600
 MonoImporter:
   serializedVersion: 2
   defaultReferences: []

Scripts/InputModules/GamePadInputModule.cs

@@ -0,0 +1,227 @@
+using System;
+using UnityEngine.Serialization;
+
+namespace UnityEngine.EventSystems
+{
+    [AddComponentMenu("Event/GamePad Input Module")]
+    public class GamePadInputModule : BaseInputModule
+    {
+        private float m_PrevActionTime;
+        Vector2 m_LastMoveVector;
+        int m_ConsecutiveMoveCount = 0;
+
+        protected GamePadInputModule()
+        {}
+
+        [SerializeField]
+        private string m_HorizontalAxis = "Horizontal";
+
+        /// <summary>
+        /// Name of the vertical axis for movement (if axis events are used).
+        /// </summary>
+        [SerializeField]
+        private string m_VerticalAxis = "Vertical";
+
+        /// <summary>
+        /// Name of the submit button.
+        /// </summary>
+        [SerializeField]
+        private string m_SubmitButton = "Submit";
+
+        /// <summary>
+        /// Name of the submit button.
+        /// </summary>
+        [SerializeField]
+        private string m_CancelButton = "Cancel";
+
+        [SerializeField]
+        private float m_InputActionsPerSecond = 10;
+
+        [SerializeField]
+        private float m_RepeatDelay = 0.5f;
+
+        public float inputActionsPerSecond
+        {
+            get { return m_InputActionsPerSecond; }
+            set { m_InputActionsPerSecond = value; }
+        }
+
+        public float repeatDelay
+        {
+            get { return m_RepeatDelay; }
+            set { m_RepeatDelay = value; }
+        }
+
+        /// <summary>
+        /// Name of the horizontal axis for movement (if axis events are used).
+        /// </summary>
+        public string horizontalAxis
+        {
+            get { return m_HorizontalAxis; }
+            set { m_HorizontalAxis = value; }
+        }
+
+        /// <summary>
+        /// Name of the vertical axis for movement (if axis events are used).
+        /// </summary>
+        public string verticalAxis
+        {
+            get { return m_VerticalAxis; }
+            set { m_VerticalAxis = value; }
+        }
+
+        public string submitButton
+        {
+            get { return m_SubmitButton; }
+            set { m_SubmitButton = value; }
+        }
+
+        public string cancelButton
+        {
+            get { return m_CancelButton; }
+            set { m_CancelButton = value; }
+        }
+
+        public override bool ShouldActivateModule()
+        {
+            if (!base.ShouldActivateModule())
+                return false;
+
+            var shouldActivate = true;
+            shouldActivate |= Input.GetButtonDown(m_SubmitButton);
+            shouldActivate |= Input.GetButtonDown(m_CancelButton);
+            shouldActivate |= !Mathf.Approximately(Input.GetAxisRaw(m_HorizontalAxis), 0.0f);
+            shouldActivate |= !Mathf.Approximately(Input.GetAxisRaw(m_VerticalAxis), 0.0f);
+            return shouldActivate;
+        }
+
+        public override void ActivateModule()
+        {
+            StandaloneInputModule StandAloneSystem = GetComponent<StandaloneInputModule>();
+
+            if (StandAloneSystem && StandAloneSystem.enabled)
+            {
+                Debug.LogError("StandAloneInputSystem should not be used with the GamePadInputModule, " +
+                    "please remove it from the Event System in this scene or disable it when this module is in use");
+            }
+
+            base.ActivateModule();
+
+            var toSelect = eventSystem.currentSelectedGameObject;
+            if (toSelect == null)
+                toSelect = eventSystem.firstSelectedGameObject;
+
+            eventSystem.SetSelectedGameObject(toSelect, GetBaseEventData());
+        }
+
+        public override void DeactivateModule()
+        {
+            base.DeactivateModule();
+        }
+
+        public override void Process()
+        {
+            bool usedEvent = SendUpdateEventToSelectedObject();
+
+            if (eventSystem.sendNavigationEvents)
+            {
+                if (!usedEvent)
+                    usedEvent |= SendMoveEventToSelectedObject();
+
+                if (!usedEvent)
+                    SendSubmitEventToSelectedObject();
+            }
+        }
+
+        /// <summary>
+        /// Process submit keys.
+        /// </summary>
+        protected bool SendSubmitEventToSelectedObject()
+        {
+            if (eventSystem.currentSelectedGameObject == null)
+                return false;
+
+            var data = GetBaseEventData();
+            if (Input.GetButtonDown(m_SubmitButton))
+                ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, data, ExecuteEvents.submitHandler);
+
+            if (Input.GetButtonDown(m_CancelButton))
+                ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, data, ExecuteEvents.cancelHandler);
+            return data.used;
+        }
+
+        private Vector2 GetRawMoveVector()
+        {
+            Vector2 move = Vector2.zero;
+            move.x = Input.GetAxisRaw(m_HorizontalAxis);
+            move.y = Input.GetAxisRaw(m_VerticalAxis);
+
+            if (Input.GetButtonDown(m_HorizontalAxis))
+            {
+                if (move.x < 0)
+                    move.x = -1f;
+                if (move.x > 0)
+                    move.x = 1f;
+            }
+            if (Input.GetButtonDown(m_VerticalAxis))
+            {
+                if (move.y < 0)
+                    move.y = -1f;
+                if (move.y > 0)
+                    move.y = 1f;
+            }
+            return move;
+        }
+
+        /// <summary>
+        /// Process events.
+        /// </summary>
+        protected bool SendMoveEventToSelectedObject()
+        {
+            float time = Time.unscaledTime;
+
+            Vector2 movement = GetRawMoveVector();
+            if (Mathf.Approximately(movement.x, 0f) && Mathf.Approximately(movement.y, 0f))
+            {
+                m_ConsecutiveMoveCount = 0;
+                return false;
+            }
+
+            // If user pressed key again, always allow event
+            bool allow = Input.GetButtonDown(m_HorizontalAxis) || Input.GetButtonDown(m_VerticalAxis);
+            bool similarDir = (Vector2.Dot(movement, m_LastMoveVector) > 0);
+            if (!allow)
+            {
+                // Otherwise, user held down key or axis.
+                // If direction didn't change at least 90 degrees, wait for delay before allowing consequtive event.
+                if (similarDir && m_ConsecutiveMoveCount == 1)
+                    allow = (time > m_PrevActionTime + m_RepeatDelay);
+                // If direction changed at least 90 degree, or we already had the delay, repeat at repeat rate.
+                else
+                    allow = (time > m_PrevActionTime + 1f / m_InputActionsPerSecond);
+            }
+            if (!allow)
+                return false;
+
+            // Debug.Log(m_ProcessingEvent.rawType + " axis:" + m_AllowAxisEvents + " value:" + "(" + x + "," + y + ")");
+            var axisEventData = GetAxisEventData(movement.x, movement.y, 0.6f);
+            ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, axisEventData, ExecuteEvents.moveHandler);
+            if (!similarDir)
+                m_ConsecutiveMoveCount = 0;
+            m_ConsecutiveMoveCount++;
+            m_PrevActionTime = time;
+            m_LastMoveVector = movement;
+            return axisEventData.used;
+        }
+
+        protected bool SendUpdateEventToSelectedObject()
+        {
+            if (eventSystem.currentSelectedGameObject == null)
+                return false;
+
+            var data = GetBaseEventData();
+            ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, data, ExecuteEvents.updateSelectedHandler);
+            return data.used;
+        }
+    }
+}

Scripts/InputModules/GamePadInputModule.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 26158f38115d49a4a915f46c7eced4ab
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Scripts/Primatives/UICircle.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 namespace UnityEngine.UI.Extensions
 {
     [AddComponentMenu("UI/Extensions/Primitives/UI Circle")]
-    public class UICircle : Graphic
+    public class UICircle : MaskableGraphic
     {
         [SerializeField]
         Texture m_Texture;

Scripts/Utilities/HoverTooltip.cs

@@ -0,0 +1,314 @@
+/// Credit drHogan 
+/// Sourced from - http://www.hammerandravens.com/multi-use-tooltip-system-in-unity3d/
+
+namespace UnityEngine.UI.Extensions
+{
+    public class HoverTooltip : MonoBehaviour
+    {
+        //manually selectable padding for the background image
+        public int horizontalPadding;
+        public int verticalPadding;
+
+        //tooltip text
+        public Text thisText;
+
+        //horizontal layout of the tooltip
+        public HorizontalLayoutGroup hlG;
+
+        //tooltip background image
+        public RectTransform bgImage;
+        Image bgImageSource;
+
+        //needed as the layout refreshes only on the first Update() call
+        bool firstUpdate;
+
+        //if the tooltip is inside a UI element
+        bool inside;
+
+        //size of the tooltip, needed to track if out of screen
+        // public float width;
+        // public float height;
+
+        //detect canvas mode so to apply different behaviors to different canvas modes, currently only RenderMode.ScreenSpaceCamera implemented
+        int canvasMode;
+        RenderMode GUIMode;
+
+        //the scene GUI camera
+        Camera GUICamera;
+
+        //the default tooltip object has the following pivots, so that the offset from the mouse is always proportional to the screen resolution (the y pivot)
+        //Pivot(0.5,-0.5)
+
+        //screen viewport corners for out of screen detection
+        Vector3 lowerLeft;
+        Vector3 upperRight;
+
+        //scale factor of proportionality to the reference resolution (1280x720)
+        float currentYScaleFactor;
+        float currentXScaleFactor;
+
+        //standard X and Y offsets of the new tooltip
+        float defaultYOffset;
+        float defaultXOffset;
+
+        //real on screen sizes of the tooltip object
+        float tooltipRealHeight;
+        float tooltipRealWidth;
+
+        // Use this for initialization
+        void Start()
+        {
+            //in this line you need to change the string in order to get your Camera //TODO MAYBE DO IT FROM THE INSPECTOR
+            GUICamera = GameObject.Find("GUICamera").GetComponent<Camera>();
+            GUIMode = this.transform.parent.parent.GetComponent<Canvas>().renderMode;
+
+            bgImageSource = bgImage.GetComponent<Image>();
+
+            //at start the pointer is never to be considered over and UI element
+            inside = false;
+
+            //assign the tooltip to the singleton GUI class manager for fast access
+            //TacticalGUIManager.tgm.mmttp = this;
+
+            //hide the tooltip
+            HideTooltipVisibility();
+            this.transform.parent.gameObject.SetActive(false);
+        }
+
+
+        //single string input tooltip
+        public void SetTooltip(string text)
+        {
+            NewTooltip();
+
+            //init tooltip string
+            thisText.text = text;
+
+            //call the position function
+            OnScreenSpaceCamera();
+        }
+
+
+        //multi string/line input tooltip (each string of the input array is a new line)
+        public void SetTooltip(string[] texts)
+        {
+            NewTooltip();
+
+            //build up the tooltip line after line with the input
+            string tooltipText = "";
+            int index = 0;
+            foreach (string newLine in texts)
+            {
+                if (index == 0)
+                {
+                    tooltipText += newLine;
+                }
+                else
+                {
+                    tooltipText += ("\n" + newLine);
+                }
+                index++;
+            }
+
+            //init tooltip string
+            thisText.text = tooltipText;
+
+            //call the position function
+            OnScreenSpaceCamera();
+        }
+
+
+
+        //temporary call to don't fuck up old code, will be removed
+        public void SetTooltip(string text, bool test)
+        {
+            NewTooltip();
+
+            //init tooltip string
+            thisText.text = text;
+
+            //call the position function
+            OnScreenSpaceCamera();
+        }
+
+
+        //position function, currently not working correctly due to the use of pivots and not manual offsets, soon to be fixed
+        public void OnScreenSpaceCamera()
+        {
+            //get the dynamic position of the pous in viewport coordinates
+            Vector3 newPos = GUICamera.ScreenToViewportPoint(Input.mousePosition);
+
+            // store in val the updated position (x or y) of the tooltip edge of interest
+            float val;
+
+            //store the new offset to impose in case of out of screen
+            float yOffSet = 0f;
+            float xOffSet = 0f;
+
+            //check for right edge of screen
+            //obtain the x coordinate of the right edge of the tooltip
+            val = ((GUICamera.ViewportToScreenPoint(newPos).x) + (tooltipRealWidth * bgImage.pivot.x));
+
+            //evaluate if the right edge of the tooltip goes out of screen
+            if (val > (upperRight.x))
+            {
+                float distFromRight = upperRight.x - val;
+
+                xOffSet = distFromRight;
+
+                //assign the new modified coordinates to the tooltip and convert to screen coordinates
+                Vector3 newTooltipPos = new Vector3(GUICamera.ViewportToScreenPoint(newPos).x + xOffSet, 0f, 0f);
+
+                newPos.x = GUICamera.ScreenToViewportPoint(newTooltipPos).x;
+            }
+
+            //check for left edge of screen
+            //obtain the x coordinate of the left edge of the tooltip
+            val = ((GUICamera.ViewportToScreenPoint(newPos).x) - (tooltipRealWidth * bgImage.pivot.x));
+
+            //evaluate if the left edge of the tooltip goes out of screen
+            if (val < (lowerLeft.x))
+            {
+                float distFromLeft = lowerLeft.x - val;
+
+                xOffSet = -distFromLeft;
+
+                //assign the new modified coordinates to the tooltip and convert to screen coordinates
+                Vector3 newTooltipPos = new Vector3(GUICamera.ViewportToScreenPoint(newPos).x - xOffSet, 0f, 0f);
+
+                newPos.x = GUICamera.ScreenToViewportPoint(newTooltipPos).x;
+            }
+
+            //check for upper edge of the screen
+            //obtain the y coordinate of the upper edge of the tooltip
+            val = ((GUICamera.ViewportToScreenPoint(newPos).y) - ((bgImage.sizeDelta.y * currentYScaleFactor * (bgImage.pivot.y)) - (tooltipRealHeight)));
+            //evaluate if the upper edge of the tooltip goes out of screen
+            if (val > (upperRight.y))
+            {
+                float distFromUpper = upperRight.y - val;
+                yOffSet = (bgImage.sizeDelta.y * currentYScaleFactor * (bgImage.pivot.y));
+
+                if (distFromUpper > (defaultYOffset * 0.75))
+                {
+                    //shorten the temporary offset up to a certain distance from the tooltip
+                    yOffSet = distFromUpper;
+                }
+                else
+                {
+                    //if the distance becomes too short flip the tooltip to below the pointer (by offset+twice the height of the tooltip)
+                    yOffSet = ((defaultYOffset) - (tooltipRealHeight) * 2f);
+                }
+
+                //assign the new modified coordinates to the tooltip and convert to screen coordinates
+                Vector3 newTooltipPos = new Vector3(newPos.x, GUICamera.ViewportToScreenPoint(newPos).y + yOffSet, 0f);
+                newPos.y = GUICamera.ScreenToViewportPoint(newTooltipPos).y;
+            }
+
+            //check for lower edge of the screen
+            //obtain the y coordinate of the lower edge of the tooltip
+            val = ((GUICamera.ViewportToScreenPoint(newPos).y) - ((bgImage.sizeDelta.y * currentYScaleFactor * (bgImage.pivot.y))));
+
+            //evaluate if the upper edge of the tooltip goes out of screen
+            if (val < (lowerLeft.y))
+            {
+                float distFromLower = lowerLeft.y - val;
+                yOffSet = (bgImage.sizeDelta.y * currentYScaleFactor * (bgImage.pivot.y));
+
+                if (distFromLower < (defaultYOffset * 0.75 - tooltipRealHeight))
+                {
+                    //shorten the temporary offset up to a certain distance from the tooltip
+                    yOffSet = distFromLower;
+                }
+                else
+                {
+                    //if the distance becomes too short flip the tooltip to above the pointer (by twice the height of the tooltip)
+                    yOffSet = ((tooltipRealHeight) * 2f);
+                }
+
+                //assign the new modified coordinates to the tooltip and convert to screen coordinates
+                Vector3 newTooltipPos = new Vector3(newPos.x, GUICamera.ViewportToScreenPoint(newPos).y + yOffSet, 0f);
+                newPos.y = GUICamera.ScreenToViewportPoint(newTooltipPos).y;
+            }
+
+            this.transform.parent.transform.position = new Vector3(GUICamera.ViewportToWorldPoint(newPos).x, GUICamera.ViewportToWorldPoint(newPos).y, 0f);
+            this.transform.parent.gameObject.SetActive(true);
+            inside = true;
+        }
+
+        //call to hide tooltip when hovering out from the object
+        public void HideTooltip()
+        {
+            if (GUIMode == RenderMode.ScreenSpaceCamera)
+            {
+                if (this != null)
+                {
+                    this.transform.parent.gameObject.SetActive(false);
+                    inside = false;
+                    HideTooltipVisibility();
+                }
+            }
+        }
+
+        // Update is called once per frame
+        void Update()
+        {
+            LayoutInit();
+            if (inside)
+            {
+                if (GUIMode == RenderMode.ScreenSpaceCamera)
+                {
+                    OnScreenSpaceCamera();
+                }
+            }
+        }
+
+        //this function is used in order to setup the size of the tooltip by cheating on the HorizontalLayoutBehavior. The resize is done in the first update.
+        void LayoutInit()
+        {
+            if (firstUpdate)
+            {
+                firstUpdate = false;
+
+                bgImage.sizeDelta = new Vector2(hlG.preferredWidth + horizontalPadding, hlG.preferredHeight + verticalPadding);
+
+                defaultYOffset = (bgImage.sizeDelta.y * currentYScaleFactor * (bgImage.pivot.y));
+                defaultXOffset = (bgImage.sizeDelta.x * currentXScaleFactor * (bgImage.pivot.x));
+
+                tooltipRealHeight = bgImage.sizeDelta.y * currentYScaleFactor;
+                tooltipRealWidth = bgImage.sizeDelta.x * currentXScaleFactor;
+
+                ActivateTooltipVisibility();
+            }
+        }
+
+        //init basic variables on a new tooltip set
+        void NewTooltip()
+        {
+            firstUpdate = true;
+
+            lowerLeft = GUICamera.ViewportToScreenPoint(new Vector3(0.0f, 0.0f, 0.0f));
+            upperRight = GUICamera.ViewportToScreenPoint(new Vector3(1.0f, 1.0f, 0.0f));
+
+            currentYScaleFactor = Screen.height / this.transform.root.GetComponent<CanvasScaler>().referenceResolution.y;
+            currentXScaleFactor = Screen.width / this.transform.root.GetComponent<CanvasScaler>().referenceResolution.x;
+
+        }
+
+        //used to visualize the tooltip one update call after it has been built (to avoid flickers)
+        public void ActivateTooltipVisibility()
+        {
+            Color textColor = thisText.color;
+            thisText.color = new Color(textColor.r, textColor.g, textColor.b, 1f);
+            bgImageSource.color = new Color(bgImageSource.color.r, bgImageSource.color.g, bgImageSource.color.b, 0.8f);
+        }
+
+        //used to hide the tooltip so that it can be made visible one update call after it has been built (to avoid flickers)
+        public void HideTooltipVisibility()
+        {
+            Color textColor = thisText.color;
+            thisText.color = new Color(textColor.r, textColor.g, textColor.b, 0f);
+            bgImageSource.color = new Color(bgImageSource.color.r, bgImageSource.color.g, bgImageSource.color.b, 0f);
+        }
+
+    }
+}

Scripts/Utilities/HoverTooltip.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 87cd933870c6506418344281b3cb86fc
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: