Exemplo n.º 1
0
        /*--------------------------------------------------------------------------------------------*/
        public virtual void TreeUpdate()
        {
            HoverItem hoverItem = GetComponent <HoverItem>();

            DestroyRenderersIfNecessary();
            TryRebuildWithItemType(hoverItem.ItemType);

            ////

            HoverItemHighlightState highState      = GetComponent <HoverItemHighlightState>();
            HoverItemSelectionState selState       = GetComponent <HoverItemSelectionState>();
            HoverRenderer           activeRenderer = ((HoverRenderer)ButtonRenderer ?? SliderRenderer);

            UpdateRenderer(activeRenderer, hoverItem);
            UpdateRendererCanvas(activeRenderer, hoverItem);
            UpdateRendererIndicator(activeRenderer, highState, selState);

            if (ButtonRenderer != null)
            {
                UpdateButtonSettings(highState);
            }

            if (SliderRenderer != null)
            {
                UpdateSliderSettings(hoverItem);
                UpdateSliderSettings(hoverItem, highState);
            }

            Controllers.TryExpireControllers();
        }
Exemplo n.º 2
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        private void TryResetSelection(HoverItemHighlightState pHighState,
                                       IItemDataSelectable pSelData)
        {
            if (!pHighState.IsHighlightPrevented)
            {
                return;
            }

            vSelectionStart = null;
            pSelData?.DeselectStickySelections();
        }
Exemplo n.º 3
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public void UpdateViaManager()
        {
            HoverItemHighlightState highState = GetComponent <HoverItemHighlightState>();
            HoverItemData           itemData  = GetComponent <HoverItem>().Data;
            IItemDataSelectable     selData   = (itemData as IItemDataSelectable);

            TryResetSelection(highState, selData);
            UpdateSelectionProgress(highState, selData);
            UpdateNearestCursor(highState);
            UpdateState(selData);
        }
Exemplo n.º 4
0
        /*--------------------------------------------------------------------------------------------*/
        private void UpdateNearestCursor(HoverItemHighlightState pHighState)
        {
            HoverItemHighlightState.Highlight?nearestHigh = pHighState.NearestHighlight;

            if (nearestHigh == null)
            {
                return;
            }

            ICursorData cursor = nearestHigh.Value.Cursor;

            cursor.MaxItemSelectionProgress = Mathf.Max(
                cursor.MaxItemSelectionProgress, SelectionProgress);
        }
Exemplo n.º 5
0
        /*--------------------------------------------------------------------------------------------*/
        private void UpdateRendererIndicator(HoverRenderer pRenderer,
                                             HoverItemHighlightState pHighState, HoverItemSelectionState pSelState)
        {
            HoverIndicator rendInd = pRenderer.GetIndicator();

            rendInd.Controllers.Set(HoverIndicator.HighlightProgressName, this);
            rendInd.Controllers.Set(HoverIndicator.SelectionProgressName, this);

            rendInd.HighlightProgress = pHighState.MaxHighlightProgress;
            rendInd.SelectionProgress = pSelState.SelectionProgress;

            if (pSelState.WasSelectedThisFrame)
            {
                rendInd.LatestSelectionTime = DateTime.UtcNow;
            }
        }
Exemplo n.º 6
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public void PerformBuild()
        {
            TreeUpdater treeUp = gameObject.AddComponent <TreeUpdater>();

            HoverItem item = gameObject.AddComponent <HoverItem>();

            item.ItemType = ItemType;

            HoverItemHighlightState highState = gameObject.AddComponent <HoverItemHighlightState>();

            gameObject.AddComponent <HoverItemSelectionState>();

            HoverItemRendererUpdater rendUp = gameObject.AddComponent <HoverItemRendererUpdater>();

            rendUp.ButtonRendererPrefab = ButtonRendererPrefab;
            rendUp.SliderRendererPrefab = SliderRendererPrefab;
            highState.ProximityProvider = rendUp;

            treeUp.Update();             //forces the entire item to update
        }
Exemplo n.º 7
0
        /*--------------------------------------------------------------------------------------------*/
        private void UpdateSelectionProgress(HoverItemHighlightState pHighState,
                                             IItemDataSelectable pSelData)
        {
            if (vSelectionStart == null)
            {
                if (pSelData == null || !pSelData.IsStickySelected)
                {
                    SelectionProgress = 0;
                    return;
                }

                HoverItemHighlightState.Highlight?nearestHigh = pHighState.NearestHighlight;
                float nearDist    = pHighState.InteractionSettings.StickyReleaseDistance;
                float minHighDist = nearestHigh?.Distance ?? float.MaxValue;

                SelectionProgress = Mathf.InverseLerp(nearDist, vDistanceUponSelection, minHighDist);
                return;
            }

            float ms = (float)(DateTime.UtcNow - (DateTime)vSelectionStart).TotalMilliseconds;

            SelectionProgress = Math.Min(1, ms / pHighState.InteractionSettings.SelectionMilliseconds);
        }
Exemplo n.º 8
0
        /*--------------------------------------------------------------------------------------------*/
        private void UpdateSliderSettings(HoverItem pHoverItem, HoverItemHighlightState pHighState)
        {
            HoverItemDataSlider data = (HoverItemDataSlider)pHoverItem.Data;

            HoverItemHighlightState.Highlight?high = pHighState.NearestHighlight;
            float highProg  = pHighState.MaxHighlightProgress;
            bool  isNearest = pHighState.IsNearestAcrossAllItemsForAnyCursor;

            SliderRenderer.Controllers.Set(HoverRendererSlider.JumpValueName, this);
            SliderRenderer.Controllers.Set(HoverRendererSlider.ShowButtonEdgesName, this);

            SliderRenderer.ShowButtonEdges = (isNearest && highProg > 0);

            if (high == null || highProg <= 0 || !isNearest)
            {
                data.HoverValue          = null;
                SliderRenderer.JumpValue = -1;
                return;
            }

            float value = SliderRenderer.GetValueViaNearestWorldPosition(high.Value.NearestWorldPos);

            data.HoverValue = value;

            float snapValue = (float)data.SnappedHoverValue;
            //float easePower = (1-high.Value.Progress)*5+1; //gets "snappier" as you pull away
            float showValue = DisplayUtil.GetEasedValue(data.Snaps, value, snapValue, 3);

            SliderRenderer.JumpValue = showValue;

            if (data.IsStickySelected)
            {
                data.Value = value;
                SliderRenderer.Controllers.Set(HoverRendererSlider.HandleValueName, this);
                SliderRenderer.HandleValue = showValue;
            }
        }
Exemplo n.º 9
0
 ////////////////////////////////////////////////////////////////////////////////////////////////
 /*--------------------------------------------------------------------------------------------*/
 private void UpdateButtonSettings(HoverItemHighlightState pHighState)
 {
     ButtonRenderer.Fill.Controllers.Set(HoverFillButton.ShowEdgeName, this);
     ButtonRenderer.Fill.ShowEdge = (pHighState.IsNearestAcrossAllItemsForAnyCursor &&
                                     pHighState.MaxHighlightProgress > 0);
 }
Exemplo n.º 10
0
        /*--------------------------------------------------------------------------------------------*/
        private bool UpdateState(IItemDataSelectable pSelData)
        {
            WasSelectedThisFrame = false;

            if (pSelData == null || pSelData.IgnoreSelection)
            {
                return(false);
            }

            ////

            HoverItemHighlightState highState = GetComponent <HoverItemHighlightState>();
            bool hasNearestCursorWithFullHigh = false;

            bool canDeselect = (
                highState.IsHighlightPrevented ||
                !highState.IsNearestAcrossAllItemsForAnyCursor ||
                !pSelData.IsEnabled
                );

            for (int i = 0; i < highState.Highlights.Count; i++)
            {
                HoverItemHighlightState.Highlight high = highState.Highlights[i];

                if (high.IsNearestAcrossAllItems && high.Progress >= 1)
                {
                    hasNearestCursorWithFullHigh = true;
                    break;
                }
            }

            if (SelectionProgress <= 0 || canDeselect)
            {
                pSelData.DeselectStickySelections();
            }

            if (!highState.IsNearestAcrossAllItemsForAnyCursor || !hasNearestCursorWithFullHigh)
            {
                IsSelectionPrevented = false;
            }

            if (canDeselect || !hasNearestCursorWithFullHigh)
            {
                vSelectionStart = null;
                return(false);
            }

            ////

            if (IsSelectionPrevented)
            {
                vSelectionStart = null;
                return(false);
            }

            if (vSelectionStart == null)
            {
                vSelectionStart = DateTime.UtcNow;
                return(false);
            }

            if (SelectionProgress < 1)
            {
                return(false);
            }

            vSelectionStart        = null;
            IsSelectionPrevented   = true;
            WasSelectedThisFrame   = true;
            vDistanceUponSelection = highState.NearestHighlight.Value.Distance;
            pSelData.Select();
            return(true);
        }