Ejemplo n.º 1
0
        public static void SetIndicatorSprite(this HUDNavigationElement element, Sprite sharedOffscreenSprite, bool offscreen = false)
        {
            if (element.Indicator == null)
            {
                return;
            }

            // get indicator icon settings
            IconSettings iconSettings = element.IndicatorIcon;

            if (offscreen)
            {
                iconSettings = element.OffscreenIndicatorIcon;
            }

            // get new indicator sprite
            Sprite newSprite = (iconSettings.OverrideIcon != null) ? iconSettings.OverrideIcon : element.Icon;

            if (offscreen && iconSettings.OverrideIcon == null)
            {
                newSprite = sharedOffscreenSprite;
            }

            // set new indicator sprite
            if (element.Indicator.sprite != newSprite)
            {
                element.Indicator.sprite = newSprite;
            }

            // set indicator size and color
            element.Indicator.rectTransform.sizeDelta = Vector2.one * iconSettings.IconSize;
            element.Indicator.color = iconSettings.IconColor;
        }
Ejemplo n.º 2
0
        public static void SetMarkerActive(this HUDNavigationElement element, NavigationElementType elementType, bool value)
        {
            Image marker = null;

            if (elementType == NavigationElementType.Radar)
            {
                marker = element.RadarMarker;
            }
            else if (elementType == NavigationElementType.CompassBar)
            {
                marker = element.CompassBarMarker;
            }

            // set marker active/inactive
            if (marker != null)
            {
                // only update whifen value has changed
                if (value != marker.gameObject.activeSelf)
                {
                    if (value)                     // appeared
                    {
                        element.OnAppear.Invoke(elementType);
                    }
                    else                     // disappeared
                    {
                        element.OnDisappear.Invoke(elementType);
                    }

                    // set active state
                    marker.gameObject.SetActive(value);
                }
            }
        }
Ejemplo n.º 3
0
 public static void SetIndicatorOffscreenRotation(this HUDNavigationElement element, Quaternion rotation)
 {
     // set indicator rotation
     if (element.Indicator.OffscreenPointer != null)
     {
         element.Indicator.OffscreenPointer.transform.rotation = rotation;
     }
 }
        public void RemoveNavigationElement(HUDNavigationElement element)
        {
            if (element == null)
            {
                return;
            }

            // remove element from list
            NavigationElements.Remove(element);
        }
Ejemplo n.º 5
0
        public static void SetIndicatorRotation(this HUDNavigationElement element, Quaternion rotation)
        {
            if (element.Indicator == null)
            {
                return;
            }

            // set indicator rotation
            element.Indicator.transform.rotation = rotation;
        }
Ejemplo n.º 6
0
        public static void SetIndicatorPosition(this HUDNavigationElement element, Vector3 indicatorPos, RectTransform parentRect)
        {
            if (element.Indicator == null)
            {
                return;
            }

            // set indicator position
            element.Indicator.transform.position = new Vector3(indicatorPos.x + parentRect.localPosition.x, indicatorPos.y + parentRect.localPosition.y, 0f) + element.IndicatorOffset;
        }
Ejemplo n.º 7
0
        public static void SetIndicatorScale(this HUDNavigationElement element, bool scalingEnabled, float distance, float scaleRadius, float minScale)
        {
            if (!scalingEnabled || element.ignoreIndicatorScaling)
            {
                return;
            }

            // set indicator scale
            float scale = (distance - 1f) / (scaleRadius - 1f);

            element.Indicator.PrefabRect.localScale = Vector2.Lerp(Vector2.one * minScale, Vector2.one, Mathf.Clamp01(scale));
        }
Ejemplo n.º 8
0
        public static void SetIndicatorFade(this HUDNavigationElement element, bool fadingEnabled, float distance, float fadeRadius, float minFade)
        {
            if (!fadingEnabled || element.ignoreIndicatorFading || element.Indicator.PrefabCanvasGroup == null)
            {
                return;
            }

            // set indicator fade
            float fade = (distance - 1f) / (fadeRadius - 1f);

            element.Indicator.PrefabCanvasGroup.alpha = Mathf.Lerp(1f * minFade, 1f, Mathf.Clamp01(fade));
        }
Ejemplo n.º 9
0
        public static void ShowRadarAboveArrow(this HUDNavigationElement element, bool value)
        {
            if (element.Radar.ArrowAbove == null)
            {
                return;
            }

            // only update if value has changed
            if (value != element.Radar.ArrowAbove.gameObject.activeSelf)
            {
                element.Radar.ArrowAbove.gameObject.SetActive(value);
            }
        }
Ejemplo n.º 10
0
        public static void ShowMinimapBelowArrow(this HUDNavigationElement element, bool value)
        {
            if (element.Minimap.ArrowBelow == null)
            {
                return;
            }

            // only update if value has changed
            if (value != element.Minimap.ArrowBelow.gameObject.activeSelf)
            {
                element.Minimap.ArrowBelow.gameObject.SetActive(value);
            }
        }
        public void AddNavigationElement(HUDNavigationElement element)
        {
            if (element == null)
            {
                return;
            }

            // add element, if it doesn't exist yet
            if (!NavigationElements.Contains(element))
            {
                NavigationElements.Add(element);
            }
        }
Ejemplo n.º 12
0
        public static void SetIndicatorScale(this HUDNavigationElement element, float distance, float scaleRadius, float minScale)
        {
            if (element.Indicator == null)
            {
                return;
            }

            // set indicator scale
            float scale = (distance - 1f) / (scaleRadius - 1f);

            scale = Mathf.Clamp01(scale);
            element.Indicator.rectTransform.localScale = Vector2.Lerp(Vector2.one * minScale, Vector2.one, scale);
        }
Ejemplo n.º 13
0
        public static void ShowIndicatorDistance(this HUDNavigationElement element, bool value)
        {
            if (element.IndicatorDistance == null)
            {
                return;
            }

            // only update if value has changed
            if (value != element.IndicatorDistance.gameObject.activeSelf)
            {
                element.IndicatorDistance.gameObject.SetActive(value);
            }
        }
        void UpdateCompassBarElement(HUDNavigationElement element, Vector3 screenPos, float distance)
        {
            // check if element is hidden within the compass bar
            if (element.HideInCompassBar)
            {
                element.SetMarkerActive(NavigationElementType.CompassBar, false);
                return;
            }

            // update distance text
            if (useCompassBarDistanceText && element.Distance != null)
            {
                element.Distance.text = string.Format(CompassBarDistanceText.TextFormat, (int)distance);
            }

            // check distance
            if (distance > CompassBarRadius && !element.IgnoreCompassBarRadius)
            {
                element.SetMarkerActive(NavigationElementType.CompassBar, false);

                // invoke events
                if (element.IsInCompassBarRadius)
                {
                    element.IsInCompassBarRadius = false;
                    element.OnLeaveRadius.Invoke(NavigationElementType.CompassBar);
                }

                return;
            }

            // invoke events
            if (!element.IsInCompassBarRadius)
            {
                element.IsInCompassBarRadius = true;
                element.OnEnterRadius.Invoke(NavigationElementType.CompassBar);
            }

            // set marker position
            if (screenPos.z <= 0)
            {
                // hide marker and skip element
                element.SetMarkerActive(NavigationElementType.CompassBar, false);
                return;
            }

            // set marker active
            element.SetMarkerActive(NavigationElementType.CompassBar, true);

            // set marker position
            element.SetMarkerPosition(NavigationElementType.CompassBar, screenPos, _HUDNavigationCanvas.CompassBar.ElementContainer);
        }
Ejemplo n.º 15
0
 public static void SetMarkerPosition(this HUDNavigationElement element, NavigationElementType elementType, Vector3 markerPos, RectTransform parentRect = null)
 {
     // set marker position
     if (elementType == NavigationElementType.Radar)
     {
         element.Radar.transform.localPosition = markerPos;
     }
     else if (elementType == NavigationElementType.CompassBar)
     {
         element.CompassBar.transform.position = new Vector3(markerPos.x + parentRect.localPosition.x, parentRect.position.y, 0f);
     }
     else if (elementType == NavigationElementType.Minimap)
     {
         element.Minimap.transform.localPosition = markerPos;
     }
 }
Ejemplo n.º 16
0
        void UpdateCompassBarElement(HUDNavigationElement element, Vector3 screenPos, float distance)
        {
            // check if element is hidden within the compass bar
            if (element.hideInCompassBar)
            {
                element.SetMarkerActive(NavigationElementType.CompassBar, false);
                return;
            }

            // check distance
            if (distance > compassBarRadius && !element.ignoreCompassBarRadius)
            {
                element.SetMarkerActive(NavigationElementType.CompassBar, false);

                // invoke events
                if (element.IsInCompassBarRadius)
                {
                    element.IsInCompassBarRadius = false;
                    element.OnLeaveRadius.Invoke(element, NavigationElementType.CompassBar);
                }
                return;
            }

            // invoke events
            if (!element.IsInCompassBarRadius)
            {
                element.IsInCompassBarRadius = true;
                element.OnEnterRadius.Invoke(element, NavigationElementType.CompassBar);
            }

            // set marker position
            if (screenPos.z <= 0)
            {
                // hide marker and skip element
                element.SetMarkerActive(NavigationElementType.CompassBar, false);
                return;
            }

            // show compass bar distance?
            element.ShowCompassBarDistance((int)distance);

            // set marker active
            element.SetMarkerActive(NavigationElementType.CompassBar, true);

            // set marker position
            element.SetMarkerPosition(NavigationElementType.CompassBar, screenPos, _HUDNavigationCanvas.CompassBar.ElementContainer);
        }
Ejemplo n.º 17
0
        public static void SetMarkerActive(this HUDNavigationElement element, NavigationElementType elementType, bool value)
        {
            // get marker gameobject
            GameObject markerGO = null;

            switch (elementType)
            {
            case NavigationElementType.Radar:
                markerGO = element.Radar.gameObject;
                break;

            case NavigationElementType.CompassBar:
                markerGO = element.CompassBar.gameObject;
                break;

            case NavigationElementType.Minimap:
                markerGO = element.Minimap.gameObject;
                break;

            default:
                break;
            }

            // set marker gameobject active/inactive
            if (markerGO != null)
            {
                // only update if value has changed
                if (value != markerGO.activeSelf)
                {
                    // invoke events
                    if (value)                     // appeared
                    {
                        element.OnAppear.Invoke(element, elementType);
                    }
                    else                     // disappeared
                    {
                        element.OnDisappear.Invoke(element, elementType);
                    }

                    // set active state
                    markerGO.gameObject.SetActive(value);
                }
            }
        }
Ejemplo n.º 18
0
        public static void SetIndicatorActive(this HUDNavigationElement element, bool value)
        {
            // only update, if value has changed
            if (value != element.Indicator.gameObject.activeSelf)
            {
                // invoke events
                if (value)                 // appeared
                {
                    element.OnAppear.Invoke(element, NavigationElementType.Indicator);
                }
                else                 // disappeared
                {
                    element.OnDisappear.Invoke(element, NavigationElementType.Indicator);
                }

                // set indicator active/inactive
                element.Indicator.gameObject.SetActive(value);
            }
        }
Ejemplo n.º 19
0
        public static void ShowCompassBarDistance(this HUDNavigationElement element, int distance = 0)
        {
            if (element.CompassBar.DistanceText == null)
            {
                return;
            }

            // only update if value has changed
            bool useDistanceText = element.useCompassBarDistanceText;

            if (useDistanceText != element.CompassBar.DistanceText.gameObject.activeSelf)
            {
                element.CompassBar.DistanceText.gameObject.SetActive(useDistanceText);
            }

            // update distance text if active
            if (useDistanceText)             // TODO add TextMeshPro support?
            {
                element.CompassBar.DistanceText.text = string.Format(element.compassBarDistanceTextFormat, distance);
            }
        }
Ejemplo n.º 20
0
        public void CopySettings(HUDNavigationElement element)
        {
            if (element == null)
            {
                return;
            }

            // misc
            this.Prefabs = element.Prefabs;

            // radar settings
            this.hideInRadar          = element.hideInRadar;
            this.ignoreRadarRadius    = element.ignoreRadarRadius;
            this.rotateWithGameObject = element.rotateWithGameObject;
            this.useRadarHeightSystem = element.useRadarHeightSystem;

            // compass bar settings
            this.hideInCompassBar             = element.hideInCompassBar;
            this.ignoreCompassBarRadius       = element.ignoreCompassBarRadius;
            this.useCompassBarDistanceText    = element.useCompassBarDistanceText;
            this.compassBarDistanceTextFormat = element.compassBarDistanceTextFormat;

            // indicator settings
            this.showIndicator                        = element.showIndicator;
            this.showOffscreenIndicator               = element.showOffscreenIndicator;
            this.ignoreIndicatorRadius                = element.ignoreIndicatorRadius;
            this.ignoreIndicatorHideDistance          = element.ignoreIndicatorHideDistance;
            this.ignoreIndicatorScaling               = element.ignoreIndicatorScaling;
            this.ignoreIndicatorFading                = element.ignoreIndicatorFading;
            this.useIndicatorDistanceText             = element.useIndicatorDistanceText;
            this.showOffscreenIndicatorDistance       = element.showOffscreenIndicatorDistance;
            this.indicatorOnscreenDistanceTextFormat  = element.indicatorOnscreenDistanceTextFormat;
            this.indicatorOffscreenDistanceTextFormat = element.indicatorOffscreenDistanceTextFormat;

            // minimap settings
            this.hideInMinimap          = element.hideInMinimap;
            this.ignoreMinimapRadius    = element.ignoreMinimapRadius;
            this.rotateWithGameObjectMM = element.rotateWithGameObjectMM;
            this.useMinimapHeightSystem = element.useMinimapHeightSystem;
        }
Ejemplo n.º 21
0
        public static void SetIndicatorOnOffscreen(this HUDNavigationElement element, bool value)
        {
            // show/hide onscreen rect
            if (element.Indicator.OnscreenRect != null)
            {
                // only update, if value has changed
                if (value != element.Indicator.OnscreenRect.gameObject.activeSelf)
                {
                    element.Indicator.OnscreenRect.gameObject.SetActive(value);
                }
            }

            // show/hide offscreen rect
            if (element.Indicator.OffscreenRect != null)
            {
                // only update, if value has changed
                if (!value != element.Indicator.OffscreenRect.gameObject.activeSelf)
                {
                    element.Indicator.OffscreenRect.gameObject.SetActive(!value);
                }
            }
        }
Ejemplo n.º 22
0
        public static void ShowIndicatorDistance(this HUDNavigationElement element, bool onScreen, int distance = 0)
        {
            // show/hide distance text
            Text distanceText = (onScreen) ? element.Indicator.OnscreenDistanceText : element.Indicator.OffscreenDistanceText;

            if (distanceText != null)
            {
                bool showDistance = (onScreen) ? element.useIndicatorDistanceText : element.useIndicatorDistanceText && element.showOffscreenIndicatorDistance;

                // only update if value has changed
                if (showDistance != distanceText.gameObject.activeSelf)
                {
                    distanceText.gameObject.SetActive(showDistance);
                }

                // update distance text if active
                if (showDistance)                 // TODO add TextMeshPro support?
                {
                    distanceText.text = string.Format((onScreen) ? element.indicatorOnscreenDistanceTextFormat : element.indicatorOffscreenDistanceTextFormat, distance);
                }
            }
        }
Ejemplo n.º 23
0
 public static bool IsVisibleOnScreen(this HUDNavigationElement element, Vector3 screenPos)
 {
     return(screenPos.z > 0 && screenPos.x > 0 && screenPos.x < Screen.width && screenPos.y > 0 && screenPos.y < Screen.height);
 }
Ejemplo n.º 24
0
        public static float GetIconRadius(this HUDNavigationElement element, NavigationElementType elementType)
        {
            float radius = (elementType == NavigationElementType.Radar) ? element.Radar.PrefabRect.sizeDelta.x : element.Minimap.PrefabRect.sizeDelta.x;

            return(radius / 2f);
        }
        void UpdateRadarElement(HUDNavigationElement element, Vector3 screenPos, float distance)
        {
            float _scaledRadius    = RadarRadius * RadarZoom;
            float _scaledMaxRadius = RadarMaxRadius * RadarZoom;

            // check for destroyed marker
            if (element.RadarMarker == null)
            {
                return;
            }

            // check if element is hidden within the compass bar
            if (element.HideInRadar)
            {
                element.SetMarkerActive(NavigationElementType.Radar, false);
                return;
            }

            // check distance
            if (distance > _scaledRadius)
            {
                // invoke events
                if (element.IsInRadarRadius)
                {
                    element.IsInRadarRadius = false;
                    element.OnLeaveRadius.Invoke(NavigationElementType.Radar);
                }

                // check max distance
                if (distance > _scaledMaxRadius)
                {
                    element.SetMarkerActive(NavigationElementType.Radar, false);
                    return;
                }

                // set scaled distance when out of range
                distance = _scaledRadius;
            }
            else
            {
                // rotate marker
                Transform rotationReference = GetRotationReference();
                if (RadarType == RadarTypes.RotateRadar)
                {
                    element.RadarMarker.transform.rotation = Quaternion.Euler(new Vector3(0f, 0f, -element.transform.eulerAngles.y + rotationReference.eulerAngles.y));
                }
                else
                {
                    element.RadarMarker.transform.rotation = Quaternion.Euler(new Vector3(0f, 0f, -element.transform.eulerAngles.y));
                }

                // invoke events
                if (!element.IsInRadarRadius)
                {
                    element.IsInRadarRadius = true;
                    element.OnEnterRadius.Invoke(NavigationElementType.Radar);
                }
            }

            // set marker active
            element.SetMarkerActive(NavigationElementType.Radar, true);

            // calculate marker position
            Vector3 posOffset = element.GetPositionOffset(PlayerController);
            Vector3 markerPos = new Vector3(posOffset.x, posOffset.z, 0f);

            markerPos.Normalize();
            markerPos *= (distance / _scaledRadius) * (_HUDNavigationCanvas.Radar.ElementContainer.GetRadius() - element.GetIconRadius());

            // set marker position
            element.SetMarkerPosition(NavigationElementType.Radar, markerPos);
        }
        void UpdateIndicatorElement(HUDNavigationElement element, Vector3 screenPos, float distance)
        {
            if (useIndicators && element.ShowIndicator)
            {
                // update distance text
                if (useIndicatorDistanceText && element.IndicatorDistance != null)
                {
                    element.IndicatorDistance.text = string.Format(IndicatorDistanceText.TextFormat, (int)distance);
                }

                // check distance and visibility
                if ((distance > IndicatorRadius && !element.IgnoreIndicatorRadius) || (screenPos.z <= 0 && !useIndicatorOffscreen))
                {
                    element.SetIndicatorActive(false);

                    // invoke events
                    if (element.IsInIndicatorRadius)
                    {
                        element.IsInIndicatorRadius = false;
                        element.OnLeaveRadius.Invoke(NavigationElementType.Indicator);
                    }
                }
                else
                {
                    // calculate off-screen position, if indicator is not in sight
                    if (useIndicatorOffscreen && !element.IsVisibleOnScreen(screenPos))
                    {
                        // flip if indicator is behind us
                        if (screenPos.z < 0f)
                        {
                            screenPos.x = Screen.width - screenPos.x;
                            screenPos.y = Screen.height - screenPos.y;
                        }

                        // calculate off-screen position/rotation
                        Vector3 screenCenter = new Vector3(Screen.width, Screen.height, 0f) / 2f;
                        screenPos -= screenCenter;
                        float angle = Mathf.Atan2(screenPos.y, screenPos.x);
                        angle -= 90f * Mathf.Deg2Rad;
                        float cos       = Mathf.Cos(angle);
                        float sin       = -Mathf.Sin(angle);
                        float cotangent = cos / sin;
                        screenPos = screenCenter + new Vector3(sin * 50f, cos * 50f, 0f);

                        // is indicator inside the defined bounds?
                        Vector3 screenBounds = screenCenter * (1f - IndicatorOffscreenBorder);
                        float   boundsY      = (cos > 0f) ? screenBounds.y : -screenBounds.y;
                        screenPos = new Vector3(boundsY / cotangent, boundsY, 0f);

                        // when out of bounds, get point on appropriate side
                        if (screenPos.x > screenBounds.x)                         // out => right
                        {
                            screenPos = new Vector3(screenBounds.x, screenBounds.x * cotangent, 0f);
                        }
                        else if (screenPos.x < -screenBounds.x)                         // out => left
                        {
                            screenPos = new Vector3(-screenBounds.x, -screenBounds.x * cotangent, 0f);
                        }
                        screenPos += screenCenter;

                        // update indicator rotation
                        element.SetIndicatorRotation(Quaternion.Euler(0f, 0f, angle * Mathf.Rad2Deg));

                        // update indicator icon
                        element.SetIndicatorSprite(IndicatorOffscreenSprite, true);

                        // show indicator distance offscreen?
                        element.ShowIndicatorDistance(!hideIndicatorDistanceOffscreen);
                    }
                    else
                    {
                        // reset indicator rotation
                        element.SetIndicatorRotation(Quaternion.identity);

                        // reset indicator icon
                        element.SetIndicatorSprite(null, false);

                        // show indicator distance
                        element.ShowIndicatorDistance(useIndicatorDistanceText);
                    }

                    // update indicator values
                    element.SetIndicatorPosition(screenPos, _HUDNavigationCanvas.Indicator.ElementContainer);
                    element.SetIndicatorScale(distance, IndicatorScaleRadius, IndicatorMinScale);
                    element.SetIndicatorActive(true);

                    // invoke events
                    if (!element.IsInIndicatorRadius)
                    {
                        element.IsInIndicatorRadius = true;
                        element.OnEnterRadius.Invoke(NavigationElementType.Indicator);
                    }
                }
            }
            else
            {
                element.SetIndicatorActive(false);
            }
        }
Ejemplo n.º 27
0
 public static float GetDistance(this HUDNavigationElement element, Transform other)
 {
     return(Vector2.Distance(new Vector2(element.transform.position.x, element.transform.position.z), new Vector2(other.position.x, other.position.z)));
 }
Ejemplo n.º 28
0
 public static void SetIndicatorPosition(this HUDNavigationElement element, Vector3 indicatorPos, RectTransform parentRect)
 {
     // set indicator position
     element.Indicator.transform.position = new Vector3(indicatorPos.x + parentRect.localPosition.x, indicatorPos.y + parentRect.localPosition.y, 0f);
 }
Ejemplo n.º 29
0
 public static Vector3 GetPositionOffset(this HUDNavigationElement element, Vector3 otherPosition)
 {
     return(element.transform.position - otherPosition);
 }
Ejemplo n.º 30
0
 public static Vector3 GetPosition(this HUDNavigationElement element)
 {
     return(element.transform.position);
 }