Exemple #1
0
        /*--------------------------------------------------------------------------------------------*/
        protected override void UpdateFillMesh(HoverMesh pSegmentMesh,
                                               SliderUtil.SegmentInfo pSegmentInfo, float pStartPos, float pEndPos)
        {
            HoverShapeRect meshShapeRect = pSegmentMesh.GetComponent <HoverShapeRect>();
            HoverMeshRect  meshRect      = (HoverMeshRect)pSegmentMesh;

            pSegmentMesh.Controllers.Set(SettingsControllerMap.TransformLocalPosition + ".x", this);
            pSegmentMesh.Controllers.Set(SettingsControllerMap.TransformLocalPosition + ".y", this);
            pSegmentMesh.Controllers.Set(HoverMesh.DisplayModeName, this);
            meshRect.Controllers.Set(HoverMeshRect.UvTopName, this);
            meshRect.Controllers.Set(HoverMeshRect.UvBottomName, this);

            meshShapeRect.SizeY      = pSegmentInfo.EndPosition - pSegmentInfo.StartPosition;
            pSegmentMesh.DisplayMode = (pSegmentInfo.IsFill ?
                                        HoverMesh.DisplayModeType.SliderFill : HoverMesh.DisplayModeType.Standard);
            meshRect.UvTop = (UseTrackUv ?
                              Mathf.InverseLerp(pStartPos, pEndPos, pSegmentInfo.StartPosition) : 0);
            meshRect.UvBottom = (UseTrackUv ?
                                 Mathf.InverseLerp(pStartPos, pEndPos, pSegmentInfo.EndPosition) : 1);

            Vector3 localPos = pSegmentMesh.transform.localPosition;

            localPos.x = (InsetLeft - InsetRight) / 2;
            localPos.y = (pSegmentInfo.StartPosition + pSegmentInfo.EndPosition) / 2;
            pSegmentMesh.transform.localPosition = localPos;
        }
        /*--------------------------------------------------------------------------------------------*/
        private void UpdateButtonRotations(HoverRendererSlider pRendSlider)
        {
            HoverRendererSliderSegments segs = gameObject.GetComponent <HoverRendererSliderSegments>();

            for (int i = 0; i < segs.SegmentInfoList.Count; i++)
            {
                SliderUtil.SegmentInfo segInfo = segs.SegmentInfoList[i];
                bool isHandle = (segInfo.Type == SliderUtil.SegmentType.Handle);
                bool isJump   = (segInfo.Type == SliderUtil.SegmentType.Jump);

                if (!isHandle && !isJump)
                {
                    continue;
                }

                HoverRendererButton button = (isHandle ?
                                              pRendSlider.HandleButton : pRendSlider.JumpButton);

                button.Controllers.Set(SettingsControllerMap.TransformLocalRotation + ".z", this);

                Vector3 buttonLocalEuler = button.transform.localRotation.eulerAngles;
                buttonLocalEuler.z             = (segInfo.StartPosition + segInfo.EndPosition) / 2;
                button.transform.localRotation = Quaternion.Euler(buttonLocalEuler);
            }
        }
Exemple #3
0
        /*--------------------------------------------------------------------------------------------*/
        protected virtual void BuildSegments()
        {
            SliderUtil.CalculateSegments(vInfo, SegmentInfoList);
            SliderUtil.CalculateTicks(vInfo, SegmentInfoList, TickInfoList);
            IsJumpVisible = false;

            for (int i = 0; i < SegmentInfoList.Count; i++)
            {
                SliderUtil.SegmentInfo segInfo = SegmentInfoList[i];

                if (segInfo.Type == SliderUtil.SegmentType.Jump)
                {
                    IsJumpVisible = true;
                    break;
                }
            }
        }
        /*--------------------------------------------------------------------------------------------*/
        protected override void UpdateTickMesh(HoverMesh pTickMesh, SliderUtil.SegmentInfo pTickInfo)
        {
            HoverShapeArc meshShapeArc = pTickMesh.GetComponent <HoverShapeArc>();

            pTickMesh.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
            pTickMesh.Controllers.Set(SettingsControllerMap.TransformLocalRotation, this);
            meshShapeArc.Controllers.Set(HoverShapeArc.OuterRadiusName, this);
            meshShapeArc.Controllers.Set(HoverShapeArc.InnerRadiusName, this);
            meshShapeArc.Controllers.Set(HoverShapeArc.ArcDegreesName, this);

            meshShapeArc.OuterRadius = vTickOuterRadius;
            meshShapeArc.InnerRadius = vTickInnerRadius;
            meshShapeArc.ArcDegrees  = pTickInfo.EndPosition - pTickInfo.StartPosition;

            pTickMesh.transform.localRotation = Quaternion.AngleAxis(
                (pTickInfo.StartPosition + pTickInfo.EndPosition) / 2, Vector3.forward);

            RendererUtil.SetActiveWithUpdate(pTickMesh, !pTickInfo.IsHidden);
        }
Exemple #5
0
        /*--------------------------------------------------------------------------------------------*/
        protected override void UpdateTickMesh(HoverMesh pTickMesh, SliderUtil.SegmentInfo pTickInfo)
        {
            HoverShapeRect meshShapeRect = pTickMesh.GetComponent <HoverShapeRect>();

            pTickMesh.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
            pTickMesh.Controllers.Set(SettingsControllerMap.TransformLocalPosition + ".x", this);
            pTickMesh.Controllers.Set(SettingsControllerMap.TransformLocalPosition + ".y", this);
            meshShapeRect.Controllers.Set(HoverShapeRect.SizeXName, this);
            meshShapeRect.Controllers.Set(HoverShapeRect.SizeYName, this);

            meshShapeRect.SizeX = vTickSizeX;
            meshShapeRect.SizeY = pTickInfo.EndPosition - pTickInfo.StartPosition;

            Vector3 localPos = pTickMesh.transform.localPosition;

            localPos.x = (InsetLeft - InsetRight) / 2;
            localPos.y = (pTickInfo.StartPosition + pTickInfo.EndPosition) / 2;
            pTickMesh.transform.localPosition = localPos;

            RendererUtil.SetActiveWithUpdate(pTickMesh, !pTickInfo.IsHidden);
        }
        /*--------------------------------------------------------------------------------------------*/
        protected override void UpdateFillMesh(HoverMesh pSegmentMesh,
                                               SliderUtil.SegmentInfo pSegmentInfo, float pStartPos, float pEndPos)
        {
            HoverShapeArc meshShapeArc = pSegmentMesh.GetComponent <HoverShapeArc>();
            HoverMeshArc  meshArc      = (HoverMeshArc)pSegmentMesh;

            pSegmentMesh.Controllers.Set(SettingsControllerMap.TransformLocalRotation, this);
            pSegmentMesh.Controllers.Set(HoverMesh.DisplayModeName, this);
            meshArc.Controllers.Set(HoverMeshArc.UvMinArcDegreeName, this);
            meshArc.Controllers.Set(HoverMeshArc.UvMaxArcDegreeName, this);

            meshShapeArc.ArcDegrees  = pSegmentInfo.EndPosition - pSegmentInfo.StartPosition;
            pSegmentMesh.DisplayMode = (pSegmentInfo.IsFill ?
                                        HoverMesh.DisplayModeType.SliderFill : HoverMesh.DisplayModeType.Standard);
            meshArc.UvMinArcDegree = (UseTrackUv ?
                                      Mathf.InverseLerp(pStartPos, pEndPos, pSegmentInfo.StartPosition) : 0);
            meshArc.UvMaxArcDegree = (UseTrackUv ?
                                      Mathf.InverseLerp(pStartPos, pEndPos, pSegmentInfo.EndPosition) : 1);

            pSegmentMesh.transform.localRotation = Quaternion.AngleAxis(
                (pSegmentInfo.StartPosition + pSegmentInfo.EndPosition) / 2, Vector3.forward);
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        protected virtual void UpdateFillMeshes()
        {
            HoverFillSlider fillSlider = gameObject.GetComponent <HoverFillSlider>();

            if (fillSlider.SegmentInfo == null)
            {
                return;
            }

            List <SliderUtil.SegmentInfo> segInfoList = fillSlider.SegmentInfo.SegmentInfoList;
            int   segCount = HoverFillSlider.SegmentCount;
            int   segIndex = 0;
            float startPos = segInfoList[0].StartPosition;
            float endPos   = segInfoList[segInfoList.Count - 1].EndPosition;

            for (int i = 0; i < segInfoList.Count; i++)
            {
                SliderUtil.SegmentInfo segInfo = segInfoList[i];

                if (segInfo.Type != SliderUtil.SegmentType.Track)
                {
                    continue;
                }

                UpdateUsedFillMesh(fillSlider.GetChildMesh(segIndex++), segInfo, startPos, endPos);
            }

            for (int i = 0; i < segCount; i++)
            {
                HoverMesh segMesh = fillSlider.GetChildMesh(i);

                if (i >= segIndex)
                {
                    UpdateUnusedFillMesh(segMesh);
                }

                ActivateFillMesh(segMesh);
            }
        }
 /*--------------------------------------------------------------------------------------------*/
 protected abstract void UpdateTickMesh(HoverMesh pTickMesh, SliderUtil.SegmentInfo pTickInfo);
 /*--------------------------------------------------------------------------------------------*/
 protected abstract void UpdateFillMesh(HoverMesh pSegmentMesh,
                                        SliderUtil.SegmentInfo pSegmentInfo, float pStartPos, float pEndPos);