////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public override void Build(IHoverboardPanelState pPanelState,
                                   IHoverboardLayoutState pLayoutState, IBaseItemState pItemState,
                                   IItemVisualSettings pSettings)
        {
            base.Build(pPanelState, pLayoutState, pItemState, pSettings);

            vLabel.AlignLeft = true;

            ////

            vIcon = new GameObject("Icon");
            vIcon.transform.SetParent(gameObject.transform, false);
            vIcon.transform.localRotation =
                vLabel.gameObject.transform.localRotation * vLabel.CanvasLocalRotation;
            vIcon.transform.localScale = GetIconScale();
            vIcon.AddComponent <MeshRenderer>();

            MeshFilter iconFilt = vIcon.AddComponent <MeshFilter>();

            vIconMeshBuilder = new MeshBuilder();
            MeshUtil.BuildQuadMesh(vIconMeshBuilder);
            Materials.SetMeshIconCoords(vIconMeshBuilder, GetIconOffset());
            vIconMeshBuilder.Commit();
            vIconMeshBuilder.CommitColors(Color.clear);
            iconFilt.sharedMesh = vIconMeshBuilder.Mesh;
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        protected override IItemVisualSettings GetSettingsInner(IBaseItem pItem,
												IItemVisualSettings pDefault, bool pFillWithDefault)
        {
            var sett = new ItemVisualSettingsStandard();

            if ( pFillWithDefault ) {
                sett.FillWith(pDefault, false);
            }
            else {
                sett.TextSize = TextSize;
                sett.TextColor = TextColor;
                sett.TextFont = TextFont;
                sett.ArrowIconColor = ArrowIconColor;
                sett.ToggleIconColor = ToggleIconColor;
                sett.BackgroundColor = BackgroundColor;
                sett.EdgeColor = EdgeColor;
                sett.HighlightColor = HighlightColor;
                sett.SelectionColor = SelectionColor;
                sett.SliderTrackColor = SliderTrackColor;
                sett.SliderFillColor = SliderFillColor;
                sett.SliderTickColor = SliderTickColor;
            sett.ExpandSize = ExpandSize;
            }

            sett.Renderer = GetRendererForItem(pItem);
            return sett;
        }
Example #3
0
        /*--------------------------------------------------------------------------------------------*/
        public override IItemVisualSettings GetSettings(IBaseItem pItem)
        {
            if (vDefaultSettings == null)
            {
                vDefaultItem     = new SelectorItem();
                vDefaultSettings = GetSettingsInner(vDefaultItem, null, false);
                vSettingsMap.Add(vDefaultItem, vDefaultSettings);
            }

            if (pItem == null)
            {
                return(vDefaultSettings);
            }

            if (vSettingsMap.ContainsKey(pItem))
            {
                return(vSettingsMap[pItem]);
            }

            if (IsDefaultSettingsComponent)
            {
                IItemVisualSettings sett = TryGetCustomItem(pItem);

                if (sett != null)
                {
                    vSettingsMap.Add(pItem, sett);
                    return(sett);
                }
            }

            return(GetVerifyAndSaveSettings(pItem, vDefaultSettings, true));
        }
Example #4
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public virtual void Build(MenuState pMenuState, IItemVisualSettings pSettings,
                                  float pAngle0, float pAngle1)
        {
            vMenuState   = pMenuState;
            vSettings    = (ItemVisualSettingsStandard)pSettings;
            vAngle0      = pAngle0;
            vAngle1      = pAngle1;
            vMeshSteps   = (int)Math.Round(Math.Max(2, (vAngle1 - vAngle0) / Math.PI * 60));
            vInnerRadius = 0.17f;

            ////

            vBackground = new GameObject("Background");
            vBackground.transform.SetParent(gameObject.transform, false);
            vBackground.AddComponent <MeshFilter>();
            vBackground.AddComponent <MeshRenderer>();
            vBackground.renderer.sharedMaterial              = new Material(Shader.Find("Unlit/AlphaSelfIllum"));
            vBackground.renderer.sharedMaterial.renderQueue -= 100;
            vBackground.renderer.sharedMaterial.color        = Color.clear;

            BuildMesh(vBackground.GetComponent <MeshFilter>().mesh);

            ////

            var labelObj = new GameObject("Label");

            labelObj.transform.SetParent(gameObject.transform, false);
            labelObj.transform.localPosition = new Vector3(0, 0, vInnerRadius);
            labelObj.transform.localRotation = Quaternion.FromToRotation(Vector3.back, Vector3.right);
            labelObj.transform.localScale    = new Vector3((vMenuState.IsOnLeftSide ? 1 : -1), 1, 1);

            vLabel           = labelObj.AddComponent <UiLabel>();
            vLabel.AlignLeft = vMenuState.IsOnLeftSide;
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        internal void Build(IHoverboardPanelState pPanelState, IHoverboardLayoutState pLayoutState,
                            BaseItemState pItemState, IItemVisualSettings pVisualSettings)
        {
            vPanelState = pPanelState;
            vItemState  = pItemState;

            vSlideX0 = 0.5f;
            vSlideZ0 = 0.5f;
            vSlideW  = vItemState.Item.Width - vSlideX0 * 2;
            vSlideH  = vItemState.Item.Height - vSlideZ0 * 2;
            vIsVert  = (vItemState.Item.Height > vItemState.Item.Width);

            ////

            vRendererObj = new GameObject("Renderer");
            vRendererObj.transform.SetParent(gameObject.transform, false);

            vRenderer = (IUiItemRenderer)vRendererObj.AddComponent(pVisualSettings.Renderer);
            vRenderer.Build(pPanelState, pLayoutState, vItemState, pVisualSettings);
            vRenderer.SetDepthHint(vPanelState.DisplayDepthHint);
            vPrevDepth = vPanelState.DisplayDepthHint;

            vItemState.HoverPointUpdater = vRenderer.UpdateHoverPoints;

            gameObject.transform.localPosition = Vector3.zero;
            gameObject.transform.localRotation = Quaternion.identity;
            gameObject.transform.localScale    = Vector3.one;
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public virtual void Build(IHovercastMenuState pMenuState, IBaseItemState pItemState,
                                  float pArcAngle, IItemVisualSettings pSettings)
        {
            vMenuState = pMenuState;
            vItemState = pItemState;
            vSettings  = (ItemVisualSettingsStandard)pSettings;

            ////

            vHoverSlice = new UiHoverMeshSlice(gameObject, true);
            vHoverSlice.UpdateSize(UiItemSelectRenderer.InnerRadius,
                                   UiItemSelectRenderer.OuterRadius, pArcAngle);

            ////

            var labelObj = new GameObject("Label");

            labelObj.transform.SetParent(gameObject.transform, false);
            labelObj.transform.localPosition = new Vector3(0, 0, 1);
            labelObj.transform.localRotation = Quaternion.FromToRotation(Vector3.back, Vector3.right);
            labelObj.transform.localScale    = new Vector3((vMenuState.IsOnLeftSide ? 1 : -1), 1, 1);

            vLabel           = labelObj.AddComponent <UiLabel>();
            vLabel.AlignLeft = vMenuState.IsOnLeftSide;
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public override void Build(IHovercastMenuState pMenuState, IBaseItemState pItemState,
                                   float pArcAngle, IItemVisualSettings pSettings)
        {
            base.Build(pMenuState, pItemState, pArcAngle, pSettings);

            ////

            vOuter = new GameObject("ToggleOuter");
            vOuter.transform.SetParent(gameObject.transform, false);
            vOuter.transform.localRotation = vLabel.CanvasLocalRotation;
            vOuter.AddComponent <MeshRenderer>();

            MeshFilter outerFilt = vOuter.AddComponent <MeshFilter>();

            vOuterMesh = outerFilt.mesh;
            MeshUtil.BuildQuadMesh(vOuterMesh);
            Materials.SetMeshColor(vOuterMesh, Color.clear);
            Materials.SetMeshIconCoords(vOuterMesh, GetOuterIconOffset());

            ////

            vInner = new GameObject("ToggleInner");
            vInner.transform.SetParent(gameObject.transform, false);
            vInner.transform.localRotation = vLabel.CanvasLocalRotation;
            vInner.AddComponent <MeshRenderer>();

            MeshFilter iconFilt = vInner.AddComponent <MeshFilter>();

            vInnerMesh = iconFilt.mesh;
            MeshUtil.BuildQuadMesh(vInnerMesh);
            Materials.SetMeshColor(vInnerMesh, Color.clear);
            Materials.SetMeshIconCoords(vInnerMesh, GetInnerIconOffset());
        }
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public virtual void Build(IHovercastMenuState pMenuState, IBaseItemState pItemState,
													float pArcAngle, IItemVisualSettings pSettings) {
			vMenuState = pMenuState;
			vItemState = pItemState;
			vSelItem = (vItemState.Item as ISelectableItem);
			vSettings = (ItemVisualSettingsStandard)pSettings;

			////

			vHoverSlice = new UiHoverMeshSlice(gameObject);
			vHoverSlice.DrawOuterEdge = true;
			vHoverSlice.UpdateSize(InnerRadius, OuterRadius, pArcAngle);

			////
			
			vIcon = new GameObject("Icon");
			vIcon.transform.SetParent(gameObject.transform, false);
			vIcon.transform.localRotation = Quaternion.FromToRotation(Vector3.forward, Vector3.up)*
				Quaternion.FromToRotation(Vector3.right, Vector3.up);
			vIcon.AddComponent<MeshRenderer>();

			MeshFilter iconFilt = vIcon.AddComponent<MeshFilter>();
			vIconMeshBuilder = new MeshBuilder();
			MeshUtil.BuildQuadMesh(vIconMeshBuilder);
			Materials.SetMeshIconCoords(vIconMeshBuilder, Materials.IconOffset.Parent);
			vIconMeshBuilder.Commit();
			vIconMeshBuilder.CommitColors(Color.clear);
			iconFilt.sharedMesh = vIconMeshBuilder.Mesh;
		}
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public virtual void Build(MenuState pMenuState, IItemVisualSettings pSettings,
                                  float pAngle0, float pAngle1)
        {
            vMenuState = pMenuState;
            vSettings  = (ItemVisualSettingsStandard)pSettings;
            vAngle0    = pAngle0;
            vAngle1    = pAngle1;
            vMeshSteps = (int)Math.Round(Math.Max(2, (vAngle1 - vAngle0) / Math.PI * 60));

            ////

            vBackground = new GameObject("Background");
            vBackground.transform.SetParent(gameObject.transform, false);
            vBackground.AddComponent <MeshRenderer>();

            MeshFilter bgFilt = vBackground.AddComponent <MeshFilter>();

            vBackgroundMesh = bgFilt.mesh;
            BuildMesh(vBackgroundMesh);
            Materials.SetMeshColor(vBackgroundMesh, Color.clear);

            ////

            var labelObj = new GameObject("Label");

            labelObj.transform.SetParent(gameObject.transform, false);
            labelObj.transform.localPosition = new Vector3(0, 0, InnerRadius);
            labelObj.transform.localRotation = Quaternion.FromToRotation(Vector3.back, Vector3.right);
            labelObj.transform.localScale    = new Vector3((vMenuState.IsOnLeftSide ? 1 : -1), 1, 1);

            vLabel           = labelObj.AddComponent <UiLabel>();
            vLabel.AlignLeft = vMenuState.IsOnLeftSide;
        }
Example #10
0
 /*--------------------------------------------------------------------------------------------*/
 protected override IItemVisualSettings GetSettingsInner(IBaseItem pItem,
                                                         IItemVisualSettings pDefault, bool pFillWithDefault)
 {
     vDefaultSettings = (ItemVisualSettingsStandard)pDefault;
     HandleValueChanged(null);
     return(vHueSettings);
 }
Example #11
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        internal void Build(IHoverboardPanelState pPanelState, LayoutState pLayoutState,
                            IItemVisualSettingsProvider pItemVisualSettProv)
        {
            Vector2 dir    = pLayoutState.ItemLayout.Direction;
            Vector2 pos    = Vector2.zero;
            Vector2 posMin = Vector2.zero;
            Vector2 posMax = Vector2.zero;

            for (int i = 0; i < pLayoutState.FullItems.Length; i++)
            {
                BaseItemState       itemState  = pLayoutState.FullItems[i];
                IItemVisualSettings visualSett = pItemVisualSettProv.GetSettings(itemState.Item);
                GameObject          itemObj    = (GameObject)itemState.Item.DisplayContainer;

                UiItem uiItem = itemObj.AddComponent <UiItem>();
                uiItem.Build(pPanelState, pLayoutState, itemState, visualSett);
                uiItem.transform.localPosition = new Vector3(pos.x, 0, pos.y) * UiItem.Size;

                var itemSize = new Vector2(itemState.Item.Width, itemState.Item.Height);

                posMin = Vector2.Min(posMin, pos);
                posMax = Vector2.Max(posMax, pos + itemSize);
                pos   += Vector2.Scale(itemSize, dir);
            }

            Vector2 size = posMax - posMin;

            Bounds = new Rect(posMin.x, posMin.y, size.x, size.y);

            gameObject.transform.localPosition = Vector3.zero;
            gameObject.transform.localRotation = Quaternion.identity;
            gameObject.transform.localScale    = Vector3.one;
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public override void Build(IHovercastMenuState pMenuState, IBaseItemState pItemState,
													float pArcAngle, IItemVisualSettings pSettings)
        {
            base.Build(pMenuState, pItemState, pArcAngle, pSettings);

            ////

            vOuter = new GameObject("ToggleOuter");
            vOuter.transform.SetParent(gameObject.transform, false);
            vOuter.transform.localRotation = vLabel.CanvasLocalRotation;
            vOuter.AddComponent<MeshRenderer>();

            MeshFilter outerFilt = vOuter.AddComponent<MeshFilter>();
            vOuterMesh = outerFilt.mesh;
            MeshUtil.BuildQuadMesh(vOuterMesh);
            Materials.SetMeshColor(vOuterMesh, Color.clear);
            Materials.SetMeshIconCoords(vOuterMesh, GetOuterIconOffset());

            ////

            vInner = new GameObject("ToggleInner");
            vInner.transform.SetParent(gameObject.transform, false);
            vInner.transform.localRotation = vLabel.CanvasLocalRotation;
            vInner.AddComponent<MeshRenderer>();

            MeshFilter iconFilt = vInner.AddComponent<MeshFilter>();
            vInnerMesh = iconFilt.mesh;
            MeshUtil.BuildQuadMesh(vInnerMesh);
            Materials.SetMeshColor(vInnerMesh, Color.clear);
            Materials.SetMeshIconCoords(vInnerMesh, GetInnerIconOffset());
        }
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public virtual void Build(MenuState pMenuState, IItemVisualSettings pSettings, 
																		float pAngle0, float pAngle1) {
			vMenuState = pMenuState;
			vSettings = (ItemVisualSettingsStandard)pSettings;
			vAngle0 = pAngle0;
			vAngle1 = pAngle1;
			vMeshSteps = (int)Math.Round(Math.Max(2, (vAngle1-vAngle0)/Math.PI*60));

			////

			vBackground = new GameObject("Background");
			vBackground.transform.SetParent(gameObject.transform, false);
			vBackground.AddComponent<MeshRenderer>();
			
			MeshFilter bgFilt = vBackground.AddComponent<MeshFilter>();
			vBackgroundMeshBuilder = new MeshBuilder();
			BuildMesh(vBackgroundMeshBuilder);
			vBackgroundMeshBuilder.Commit();
			vBackgroundMeshBuilder.CommitColors(Color.clear);
			bgFilt.sharedMesh = vBackgroundMeshBuilder.Mesh;

			////

			var labelObj = new GameObject("Label");
			labelObj.transform.SetParent(gameObject.transform, false);
			labelObj.transform.localPosition = new Vector3(0, 0, InnerRadius);
			labelObj.transform.localRotation = Quaternion.FromToRotation(Vector3.back, Vector3.right);
			labelObj.transform.localScale = new Vector3((vMenuState.IsOnLeftSide ? 1 : -1), 1, 1);

			vLabel = labelObj.AddComponent<UiLabel>();
			vLabel.AlignLeft = vMenuState.IsOnLeftSide;
		}
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		internal void Build(IHoverboardPanelState pPanelState, IHoverboardLayoutState pLayoutState, 
										BaseItemState pItemState, IItemVisualSettings pVisualSettings) {
			vPanelState = pPanelState;
			vItemState = pItemState;

			vSlideX0 = 0.5f;
			vSlideZ0 = 0.5f;
			vSlideW = vItemState.Item.Width-vSlideX0*2;
			vSlideH = vItemState.Item.Height-vSlideZ0*2;
			vIsVert = (vItemState.Item.Height > vItemState.Item.Width);

			////
			
			vRendererObj = new GameObject("Renderer");
			vRendererObj.transform.SetParent(gameObject.transform, false);

			vRenderer = (IUiItemRenderer)vRendererObj.AddComponent(pVisualSettings.Renderer);
			vRenderer.Build(pPanelState, pLayoutState, vItemState, pVisualSettings);
			vRenderer.SetDepthHint(vPanelState.DisplayDepthHint);
			vPrevDepth = vPanelState.DisplayDepthHint;

			vItemState.HoverPointUpdater = vRenderer.UpdateHoverPoints;

			gameObject.transform.localPosition = Vector3.zero;
			gameObject.transform.localRotation = Quaternion.identity;
			gameObject.transform.localScale = Vector3.one;
		}
Example #15
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        internal void Build(MenuState pMenuState, BaseItemState pItemState, float pArcAngle,
                            IItemVisualSettings pVisualSettings)
        {
            vMenuState = pMenuState;
            vItemState = pItemState;
            ArcAngle   = pArcAngle;

            const float pi = (float)Math.PI;
            const float slideBufferAngle = pi / 80f;

            vSlideDegrees = (pArcAngle - slideBufferAngle * 2) / (float)Math.PI * 180;
            vSlideDir0    = MeshUtil.GetRingPoint(1, -pArcAngle / 2f + slideBufferAngle);

            ////

            vRendererObj = new GameObject("Renderer");
            vRendererObj.transform.SetParent(gameObject.transform, false);

            vRenderer = (IUiItemRenderer)vRendererObj.AddComponent(pVisualSettings.Renderer);
            vRenderer.Build(vMenuState, vItemState, pArcAngle, pVisualSettings);
            vRenderer.SetDepthHint(vMenuState.DisplayDepthHint);
            vPrevDepth = vMenuState.DisplayDepthHint;

            vItemState.HoverPointUpdater = vRenderer.UpdateHoverPoints;
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        protected override IItemVisualSettings GetSettingsInner(IBaseItem pItem,
                                                                IItemVisualSettings pDefault, bool pFillWithDefault)
        {
            var sett = new ItemVisualSettingsStandard();

            if (pFillWithDefault)
            {
                sett.FillWith(pDefault, false);
            }
            else
            {
                sett.TextSize         = TextSize;
                sett.TextColor        = TextColor;
                sett.TextFont         = TextFont;
                sett.ArrowIconColor   = ArrowIconColor;
                sett.ToggleIconColor  = ToggleIconColor;
                sett.BackgroundColor  = BackgroundColor;
                sett.EdgeColor        = EdgeColor;
                sett.HighlightColor   = HighlightColor;
                sett.SelectionColor   = SelectionColor;
                sett.SliderTrackColor = SliderTrackColor;
                sett.SliderFillColor  = SliderFillColor;
                sett.SliderTickColor  = SliderTickColor;
            }

            sett.Renderer = GetRendererForItem(pItem);
            return(sett);
        }
Example #17
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        internal void Build(MenuState pMenuState, IItemVisualSettingsProvider pVisualSettingsProv)
        {
            vMenuState   = pMenuState;
            vItemObjList = new List <GameObject>();

            ReadOnlyCollection <BaseItemState> itemStates = vMenuState.GetItems();
            int   itemCount = itemStates.Count;
            float degree    = 170 + DegreeFull / 2f;
            float sizeSum   = 0;

            for (int i = 0; i < itemCount; i++)
            {
                sizeSum += itemStates[i].Item.Height;
            }

            for (int i = 0; i < itemCount; i++)
            {
                BaseItemState       itemState   = itemStates[i];
                float               itemPerc    = itemState.Item.Height / sizeSum;
                float               itemAngle   = AngleFull * itemPerc;
                float               itemDegHalf = itemAngle * ToDegrees / 2f;
                IItemVisualSettings visualSett  = pVisualSettingsProv.GetSettings(itemState.Item);

                var itemObj = new GameObject("Item" + vItemObjList.Count);
                itemObj.transform.SetParent(gameObject.transform, false);
                vItemObjList.Add(itemObj);

                UiItem uiItem = itemObj.AddComponent <UiItem>();
                uiItem.Build(vMenuState, itemState, itemAngle, visualSett);

                degree -= itemDegHalf;
                itemObj.transform.localRotation = Quaternion.AngleAxis(degree, Vector3.up);
                degree -= itemDegHalf;
            }
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public override void Build(IHoverboardPanelState pPanelState,
										IHoverboardLayoutState pLayoutState, IBaseItemState pItemState,
										IItemVisualSettings pSettings)
        {
            base.Build(pPanelState, pLayoutState, pItemState, pSettings);

            vLabel.AlignLeft = true;
            vLabel.transform.localPosition = new Vector3(-vItemState.Item.Width/2, 0, 0);

            ////

            vOuter = new GameObject("ToggleOuter");
            vOuter.transform.SetParent(gameObject.transform, false);
            vOuter.transform.localRotation = vLabel.CanvasLocalRotation;
            vOuter.AddComponent<MeshRenderer>();

            MeshFilter outerFilt = vOuter.AddComponent<MeshFilter>();
            vOuterMesh = outerFilt.mesh;
            MeshUtil.BuildQuadMesh(vOuterMesh);
            Materials.SetMeshColor(vOuterMesh, Color.clear);
            Materials.SetMeshIconCoords(vOuterMesh, GetOuterIconOffset());

            ////

            vInner = new GameObject("ToggleInner");
            vInner.transform.SetParent(gameObject.transform, false);
            vInner.transform.localRotation = vLabel.CanvasLocalRotation;
            vInner.AddComponent<MeshRenderer>();

            MeshFilter iconFilt = vInner.AddComponent<MeshFilter>();
            vInnerMesh = iconFilt.mesh;
            MeshUtil.BuildQuadMesh(vInnerMesh);
            Materials.SetMeshColor(vInnerMesh, Color.clear);
            Materials.SetMeshIconCoords(vInnerMesh, GetInnerIconOffset());
        }
Example #19
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public virtual void Build(IHovercastMenuState pMenuState, IBaseItemState pItemState,
                                  float pArcAngle, IItemVisualSettings pSettings)
        {
            vMenuState = pMenuState;
            vItemState = pItemState;
            vSelItem   = (vItemState.Item as ISelectableItem);
            vSettings  = (ItemVisualSettingsStandard)pSettings;

            ////

            vHoverSlice = new UiHoverMeshSlice(gameObject);
            vHoverSlice.DrawOuterEdge = true;
            vHoverSlice.UpdateSize(InnerRadius, OuterRadius, pArcAngle);

            ////

            vIcon = new GameObject("Icon");
            vIcon.transform.SetParent(gameObject.transform, false);
            vIcon.transform.localRotation = Quaternion.FromToRotation(Vector3.forward, Vector3.up) *
                                            Quaternion.FromToRotation(Vector3.right, Vector3.up);
            vIcon.AddComponent <MeshRenderer>();

            MeshFilter iconFilt = vIcon.AddComponent <MeshFilter>();

            vIconMeshBuilder = new MeshBuilder();
            MeshUtil.BuildQuadMesh(vIconMeshBuilder);
            Materials.SetMeshIconCoords(vIconMeshBuilder, Materials.IconOffset.Parent);
            vIconMeshBuilder.Commit();
            vIconMeshBuilder.CommitColors(Color.clear);
            iconFilt.sharedMesh = vIconMeshBuilder.Mesh;
        }
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public override void Build(IHoverboardPanelState pPanelState,
										IHoverboardLayoutState pLayoutState, IBaseItemState pItemState,
										IItemVisualSettings pSettings) {
			base.Build(pPanelState, pLayoutState, pItemState, pSettings);

			if ( !IsVert ) {
				vIcon.transform.localRotation *= IconRot;
			}
		}
Example #21
0
        /*--------------------------------------------------------------------------------------------*/
        protected internal override IItemVisualSettings GetVerifyAndSaveSettings(IBaseItem pItem,
                                                                                 IItemVisualSettings pDefault, bool pFillWithDefault)
        {
            IItemVisualSettings sett = GetSettingsInner(pItem, pDefault, pFillWithDefault);

            CustomUtil.VerifyRenderer <TRend>(sett.Renderer, pItem.Label, GetDomain(), GetRendererUnit());
            vSettingsMap.Add(pItem, sett);
            return(sett);
        }
Example #22
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public override void Build(IHoverboardPanelState pPanelState,
                                   IHoverboardLayoutState pLayoutState, IBaseItemState pItemState,
                                   IItemVisualSettings pSettings)
        {
            base.Build(pPanelState, pLayoutState, pItemState, pSettings);

            if (!IsVert)
            {
                vIcon.transform.localRotation *= IconRot;
            }
        }
Example #23
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public override void Build(MenuState pMenuState, IBaseItemState pItemState,
                                   float pArcAngle, IItemVisualSettings pSettings)
        {
            base.Build(pMenuState, pItemState, pArcAngle, pSettings);

            vIcon      = GameObject.CreatePrimitive(PrimitiveType.Quad);
            vIcon.name = "Icon";
            vIcon.transform.SetParent(gameObject.transform, false);
            vIcon.renderer.sharedMaterial             = new Material(Shader.Find("Unlit/AlphaSelfIllum"));
            vIcon.renderer.sharedMaterial.color       = Color.clear;
            vIcon.renderer.sharedMaterial.mainTexture = GetIconTexture();
            vIcon.transform.localRotation             =
                vLabel.gameObject.transform.localRotation * vLabel.CanvasLocalRotation;
        }
Example #24
0
        /*--------------------------------------------------------------------------------------------*/
        private static void SetColor(IItemVisualSettings pSettings)
        {
            ItemVisualSettingsStandard sett = (ItemVisualSettingsStandard)pSettings;

            sett.TextColor        = new Color(1, 1, 0.7f);
            sett.ArrowIconColor   = new Color(1, 1, 0.7f);
            sett.ToggleIconColor  = new Color(1, 1, 0.7f);
            sett.BackgroundColor  = new Color(0.05f, 0.25f, 0.45f, 0.5f);
            sett.EdgeColor        = new Color(0.1f, 0.9f, 0.2f);
            sett.HighlightColor   = new Color(0.1f, 0.5f, 0.9f);
            sett.SelectionColor   = new Color(0.1f, 0.9f, 0.2f);
            sett.SliderTrackColor = new Color(0.1f, 0.5f, 0.9f, 0.5f);
            sett.SliderFillColor  = new Color(0.1f, 0.9f, 0.2f, 0.5f);
            sett.SliderTickColor  = new Color(1, 1, 1, 0.2f);
            DemoCustomBgListener.UpdateSettingsWithBgAlpha(sett);
        }
Example #25
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        internal void Build(BaseItemState pItemState, IItemVisualSettings pVisualSettings)
        {
            vItemState = pItemState;

            vRendererObj = new GameObject("Renderer");
            vRendererObj.transform.SetParent(gameObject.transform, false);

            vRenderer = (IUiItemRenderer)vRendererObj.AddComponent(pVisualSettings.Renderer);
            vRenderer.Build(vItemState, pVisualSettings);

            vItemState.HoverPointUpdater = vRenderer.UpdateHoverPoints;

            gameObject.transform.localPosition = Vector3.zero;
            gameObject.transform.localRotation = Quaternion.identity;
            gameObject.transform.localScale    = Vector3.one;
        }
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public override void Build(IHovercastMenuState pMenuState, IBaseItemState pItemState,
													float pArcAngle, IItemVisualSettings pSettings) {
			base.Build(pMenuState, pItemState, pArcAngle, pSettings);

			vIcon = new GameObject("Icon");
			vIcon.transform.SetParent(gameObject.transform, false);
			vIcon.transform.localRotation = 
				vLabel.gameObject.transform.localRotation*vLabel.CanvasLocalRotation;
			vIcon.transform.localScale = GetIconScale();
			vIcon.AddComponent<MeshRenderer>();

			MeshFilter iconFilt = vIcon.AddComponent<MeshFilter>();
			vIconMeshBuilder = new MeshBuilder();
			MeshUtil.BuildQuadMesh(vIconMeshBuilder);
			Materials.SetMeshIconCoords(vIconMeshBuilder, GetIconOffset());
			vIconMeshBuilder.Commit();
			vIconMeshBuilder.CommitColors(Color.clear);
			iconFilt.sharedMesh = vIconMeshBuilder.Mesh;
		}
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public virtual void Build(IHoverboardPanelState pPanelState, 
										IHoverboardLayoutState pLayoutState, IBaseItemState pItemState,
										IItemVisualSettings pSettings) {
			vPanelState = pPanelState;
			vLayoutState = pLayoutState;
			vItemState = pItemState;
			vSettings = (ItemVisualSettingsStandard)pSettings;

			gameObject.transform.SetParent(gameObject.transform, false);

			vHoverRect = new UiHoverMeshRect(gameObject);

			var labelObj = new GameObject("Label");
			labelObj.transform.SetParent(gameObject.transform, false);
			vLabel = labelObj.AddComponent<UiLabel>();

			float width = UiItem.Size*vItemState.Item.Width;
			float height = UiItem.Size*vItemState.Item.Height;
			SetCustomSize(width, height);
		}
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public void FillWith(IItemVisualSettings pSourceSettings, bool pIncludeRenderer) {
			ItemVisualSettingsStandard sett = (ItemVisualSettingsStandard)pSourceSettings;

			if ( pIncludeRenderer ) {
				Renderer = sett.Renderer;
			}

			TextSize = sett.TextSize;
			TextColor = sett.TextColor;
			TextFont = sett.TextFont;
			ArrowIconColor = sett.ArrowIconColor;
			ToggleIconColor = sett.ToggleIconColor;
			BackgroundColor = sett.BackgroundColor;
			EdgeColor = sett.EdgeColor;
			HighlightColor = sett.HighlightColor;
			SelectionColor = sett.SelectionColor;
			SliderTrackColor = sett.SliderTrackColor;
			SliderFillColor = sett.SliderFillColor;
			SliderTickColor = sett.SliderTickColor;
		}
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public void Build(IBaseItemState pItemState, IItemVisualSettings pSettings)
        {
            vItemState      = pItemState;
            vVisualSettings = (ItemVisualSettingsStandard)pSettings;

            float       width  = UiItem.Size * vItemState.Item.Width;
            const float height = UiItem.Size;

            gameObject.transform.SetParent(gameObject.transform, false);
            gameObject.transform.localPosition = new Vector3(width / 2, 0, height / 2f);

            vHoverRect = new UiHoverMeshRect(gameObject);
            vHoverRect.UpdateSize(width, height);

            var labelObj = new GameObject("Label");

            labelObj.transform.SetParent(gameObject.transform, false);
            vLabel = labelObj.AddComponent <UiLabel>();
            vLabel.SetSize(width, height, ArcCanvasScale);
        }
Example #30
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public override void Build(IHoverboardPanelState pPanelState,
                                   IHoverboardLayoutState pLayoutState, IBaseItemState pItemState,
                                   IItemVisualSettings pSettings)
        {
            base.Build(pPanelState, pLayoutState, pItemState, pSettings);

            vLabel.AlignLeft = true;
            vLabel.transform.localPosition = new Vector3(-vItemState.Item.Width / 2, 0, 0);

            ////

            vOuter = new GameObject("ToggleOuter");
            vOuter.transform.SetParent(gameObject.transform, false);
            vOuter.transform.localRotation = vLabel.CanvasLocalRotation;
            vOuter.AddComponent <MeshRenderer>();

            MeshFilter outerFilt = vOuter.AddComponent <MeshFilter>();

            vOuterMeshBuilder = new MeshBuilder();
            MeshUtil.BuildQuadMesh(vOuterMeshBuilder);
            Materials.SetMeshIconCoords(vOuterMeshBuilder, GetOuterIconOffset());
            vOuterMeshBuilder.Commit();
            vOuterMeshBuilder.CommitColors(Color.clear);
            outerFilt.sharedMesh = vOuterMeshBuilder.Mesh;

            ////

            vInner = new GameObject("ToggleInner");
            vInner.transform.SetParent(gameObject.transform, false);
            vInner.transform.localRotation = vLabel.CanvasLocalRotation;
            vInner.AddComponent <MeshRenderer>();

            MeshFilter innerFilt = vInner.AddComponent <MeshFilter>();

            vInnerMeshBuilder = new MeshBuilder();
            MeshUtil.BuildQuadMesh(vInnerMeshBuilder);
            Materials.SetMeshIconCoords(vInnerMeshBuilder, GetInnerIconOffset());
            vInnerMeshBuilder.Commit();
            vInnerMeshBuilder.CommitColors(Color.clear);
            innerFilt.sharedMesh = vInnerMeshBuilder.Mesh;
        }
Example #31
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public void FillWith(IItemVisualSettings pSourceSettings, bool pIncludeRenderer)
        {
            ItemVisualSettingsStandard sett = (ItemVisualSettingsStandard)pSourceSettings;

            if (pIncludeRenderer)
            {
                Renderer = sett.Renderer;
            }

            TextSize         = sett.TextSize;
            TextColor        = sett.TextColor;
            TextFont         = sett.TextFont;
            ArrowIconColor   = sett.ArrowIconColor;
            ToggleIconColor  = sett.ToggleIconColor;
            BackgroundColor  = sett.BackgroundColor;
            EdgeColor        = sett.EdgeColor;
            HighlightColor   = sett.HighlightColor;
            SelectionColor   = sett.SelectionColor;
            SliderTrackColor = sett.SliderTrackColor;
            SliderFillColor  = sett.SliderFillColor;
            SliderTickColor  = sett.SliderTickColor;
        }
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public virtual void Build(IHovercastMenuState pMenuState, IBaseItemState pItemState,
													float pArcAngle, IItemVisualSettings pSettings) {
			vMenuState = pMenuState;
			vItemState = pItemState;
			vSettings = (ItemVisualSettingsStandard)pSettings;

			////

			vHoverSlice = new UiHoverMeshSlice(gameObject);
			vHoverSlice.UpdateSize(InnerRadius, OuterRadius, pArcAngle);

			////

			var labelObj = new GameObject("Label");
			labelObj.transform.SetParent(gameObject.transform, false);
			labelObj.transform.localPosition = new Vector3(0, 0, 1);
			labelObj.transform.localRotation = Quaternion.FromToRotation(Vector3.back, Vector3.right);
			labelObj.transform.localScale = new Vector3((vMenuState.IsOnLeftSide ? 1 : -1), 1, 1);
			
			vLabel = labelObj.AddComponent<UiLabel>();
			vLabel.AlignLeft = vMenuState.IsOnLeftSide;
		}
Example #33
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public virtual void Build(IHoverboardPanelState pPanelState,
                                  IHoverboardLayoutState pLayoutState, IBaseItemState pItemState,
                                  IItemVisualSettings pSettings)
        {
            vPanelState  = pPanelState;
            vLayoutState = pLayoutState;
            vItemState   = pItemState;
            vSettings    = (ItemVisualSettingsStandard)pSettings;

            gameObject.transform.SetParent(gameObject.transform, false);

            vHoverRect = new UiHoverMeshRect(gameObject);

            var labelObj = new GameObject("Label");

            labelObj.transform.SetParent(gameObject.transform, false);
            vLabel = labelObj.AddComponent <UiLabel>();

            float width  = UiItem.Size * vItemState.Item.Width;
            float height = UiItem.Size * vItemState.Item.Height;

            SetCustomSize(width, height);
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public virtual void Build(IHoverboardPanelState pPanelState,
                                  IHoverboardLayoutState pLayoutState, IBaseItemState pItemState,
                                  IItemVisualSettings pSettings)
        {
            vPanelState  = pPanelState;
            vLayoutState = pLayoutState;
            vItemState   = pItemState;
            vSettings    = (ItemVisualSettingsStandard)pSettings;
            vWidth       = UiItem.Size * vItemState.Item.Width;
            vHeight      = UiItem.Size * vItemState.Item.Height;

            gameObject.transform.SetParent(gameObject.transform, false);
            gameObject.transform.localPosition = new Vector3(vWidth / 2, 0, vHeight / 2f);

            vHoverRect = new UiHoverMeshRectBg(gameObject);
            vHoverRect.UpdateSize(vWidth, vHeight);

            var labelObj = new GameObject("Label");

            labelObj.transform.SetParent(gameObject.transform, false);
            vLabel = labelObj.AddComponent <UiLabel>();
            vLabel.SetSize(vWidth, vHeight, vSettings.TextSize * 0.25f, LabelCanvasScale);
        }
Example #35
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        internal void Build(GridState pGridState, IItemVisualSettingsProvider pItemVisualSettProv)
        {
            int cols = pGridState.ItemGrid.Cols;
            int gi   = 0;

            for (int i = 0; i < pGridState.Items.Length; i++)
            {
                BaseItemState       itemState  = pGridState.Items[i];
                IItemVisualSettings visualSett = pItemVisualSettProv.GetSettings(itemState.Item);
                GameObject          itemObj    = (GameObject)itemState.Item.DisplayContainer;
                var pos = new Vector3(gi % cols, 0, (float)Math.Floor((float)gi / cols));

                UiItem uiItem = itemObj.AddComponent <UiItem>();
                uiItem.Build(itemState, visualSett);
                uiItem.transform.localPosition = pos * UiItem.Size;

                gi += (int)itemState.Item.Width;
            }

            gameObject.transform.localPosition = Vector3.zero;
            gameObject.transform.localRotation = Quaternion.identity;
            gameObject.transform.localScale    = Vector3.one;
        }
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		internal void Build(MenuState pMenuState, BaseItemState pItemState, float pArcAngle, 
																IItemVisualSettings pVisualSettings) {
			vMenuState = pMenuState;
			vItemState = pItemState;
			ArcAngle = pArcAngle;

			const float pi = (float)Math.PI;
			const float slideBufferAngle = pi/80f;

			vSlideDegrees = (pArcAngle-slideBufferAngle*2)/(float)Math.PI*180;
			vSlideDir0 = MeshUtil.GetRingPoint(1, -pArcAngle/2f+slideBufferAngle);

			////

			vRendererObj = new GameObject("Renderer");
			vRendererObj.transform.SetParent(gameObject.transform, false);

			vRenderer = (IUiItemRenderer)vRendererObj.AddComponent(pVisualSettings.Renderer);
			vRenderer.Build(vMenuState, vItemState, pArcAngle, pVisualSettings);
			vRenderer.SetDepthHint(vMenuState.DisplayDepthHint);
			vPrevDepth = vMenuState.DisplayDepthHint;

			vItemState.HoverPointUpdater = vRenderer.UpdateHoverPoints;
		}
Example #37
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public virtual void Build(IHovercastMenuState pMenuState, IBaseItemState pItemState,
                                  float pArcAngle, IItemVisualSettings pSettings)
        {
            vMenuState  = pMenuState;
            vItemState  = pItemState;
            vAngle0     = -pArcAngle / 2f;
            vAngle1     = pArcAngle / 2f;
            vSettings   = (ItemVisualSettingsStandard)pSettings;
            vSliderItem = (ISliderItem)vItemState.Item;
            vTicks      = new GameObject[vSliderItem.Ticks];

            const float pi = (float)Math.PI;

            vGrabArc      = pi / 40f;
            vSlideDegree0 = (vAngle0 + vGrabArc / 2) / pi * 180;
            vSlideDegrees = (vAngle1 - vAngle0 - vGrabArc) / pi * 180;
            vZeroValue    = (0 - vSliderItem.RangeMin) / (vSliderItem.RangeMax - vSliderItem.RangeMin);

            ////

            vHiddenSlice = new UiHoverMeshSlice(gameObject, true);
            vHiddenSlice.UpdateSize(1, 1.5f, pArcAngle);
            vHiddenSlice.UpdateBackground(Color.clear);

            var trackObj = new GameObject("Track");

            trackObj.transform.SetParent(gameObject.transform, false);
            trackObj.transform.localRotation = Quaternion.AngleAxis(vAngle0 / pi * 180, Vector3.up);

            vTrack         = new UiItemSliderTrackRenderer(trackObj);
            vTrackSegments = new ReadList <DisplayUtil.TrackSegment>();
            vTrackCuts     = new ReadList <DisplayUtil.TrackSegment>();

            ////

            if (vSliderItem.Ticks > 1)
            {
                Vector3 quadScale   = new Vector3(UiHoverMeshSlice.AngleInset * 2, 0.36f, 0.1f);
                float   percPerTick = 1 / (float)(vSliderItem.Ticks - 1);

                vTickMeshBuilder = new MeshBuilder();
                MeshUtil.BuildQuadMesh(vTickMeshBuilder);
                vTickMeshBuilder.Commit();
                vTickMeshBuilder.CommitColors(Color.clear);

                for (int i = 0; i < vSliderItem.Ticks; ++i)
                {
                    var tickObj = new GameObject("Tick" + i);
                    tickObj.transform.SetParent(gameObject.transform, false);
                    tickObj.transform.localRotation = Quaternion.AngleAxis(
                        vSlideDegree0 + vSlideDegrees * i * percPerTick, Vector3.up);
                    vTicks[i] = tickObj;

                    var quadObj = new GameObject("Quad");
                    quadObj.transform.SetParent(tickObj.transform, false);
                    quadObj.transform.localPosition = new Vector3(0, 0, 1.25f);
                    quadObj.transform.localRotation = TickQuatRot;
                    quadObj.transform.localScale    = quadScale;
                    quadObj.AddComponent <MeshRenderer>();

                    MeshFilter quadFilt = quadObj.AddComponent <MeshFilter>();
                    quadFilt.sharedMesh = vTickMeshBuilder.Mesh;
                }
            }

            ////

            vGrabHold = new GameObject("GrabHold");
            vGrabHold.transform.SetParent(gameObject.transform, false);

            var grabObj = new GameObject("Grab");

            grabObj.transform.SetParent(vGrabHold.transform, false);

            vGrab = grabObj.AddComponent <UiItemSliderGrabRenderer>();
            vGrab.Build(vMenuState, vItemState, vGrabArc, pSettings);

            ////

            vHoverHold = new GameObject("HoverHold");
            vHoverHold.transform.SetParent(gameObject.transform, false);

            var hoverObj = new GameObject("Hover");

            hoverObj.transform.SetParent(vHoverHold.transform, false);

            vHover = new UiHoverMeshSlice(hoverObj, false, "Hover");
        }
 ////////////////////////////////////////////////////////////////////////////////////////////////
 /*--------------------------------------------------------------------------------------------*/
 protected internal abstract IItemVisualSettings GetVerifyAndSaveSettings(IBaseItem pItem,
                                                                          IItemVisualSettings pDefault, bool pFillWithDefault);
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public virtual void Build(IHoverboardPanelState pPanelState,
										IHoverboardLayoutState pLayoutState, IBaseItemState pItemState,
										IItemVisualSettings pSettings) {
			vPanelState = pPanelState;
			vLayoutState = pLayoutState;
			vItemState = pItemState;
			vSettings = (ItemVisualSettingsStandard)pSettings;
			vSliderItem = (ISliderItem)vItemState.Item;
			vTicks = new GameObject[vSliderItem.Ticks];

			vWidth = UiItem.Size*vSliderItem.Width;
			vHeight = UiItem.Size*vSliderItem.Height;
			vIsVert = (vHeight > vWidth);
			vGrabW = 1;
			vZeroValue = (0-vSliderItem.RangeMin)/(vSliderItem.RangeMax-vSliderItem.RangeMin);

			gameObject.transform.SetParent(gameObject.transform, false);
			gameObject.transform.localPosition = new Vector3(vWidth/2, 0, vHeight/2f);
			gameObject.transform.localRotation = Quaternion.AngleAxis((vIsVert ? 90 : 0), Vector3.up);

			if ( vIsVert ) { //swap dimensions here + rotate graphics later
				float tempW = vWidth;
				vWidth = vHeight;
				vHeight = tempW;
			}

			vSlideX0 = (vGrabW-vWidth)/2;
			vSlideW = vWidth-vGrabW;

			////

			vHiddenRect = new UiHoverMeshRectBg(gameObject);
			vHiddenRect.UpdateSize(vWidth, vHeight);

			var trackObj = new GameObject("Track");
			trackObj.transform.SetParent(gameObject.transform, false);
			trackObj.transform.localPosition = new Vector3(-vWidth/2, 0, 0);

			vTrack = new UiItemSliderTrackRenderer(trackObj);
			vTrackSegments = new ReadList<DisplayUtil.TrackSegment>();
			vTrackCuts = new ReadList<DisplayUtil.TrackSegment>();

			////

			if ( vSliderItem.Ticks > 1 ) {
				Vector3 quadScale = new Vector3(UiHoverMeshRect.SizeInset*2, 0.36f, 0.1f);
				float percPerTick = 1/(float)(vSliderItem.Ticks-1);

				vTickMeshBuilder = new MeshBuilder();
				MeshUtil.BuildQuadMesh(vTickMeshBuilder);
				vTickMeshBuilder.Commit();
				vTickMeshBuilder.CommitColors(Color.clear);

				for ( int i = 0 ; i < vSliderItem.Ticks ; ++i ) {
					GameObject tickObj = new GameObject("Tick"+i);
					tickObj.transform.SetParent(gameObject.transform, false);
					tickObj.transform.localPosition = Vector3.right*(vSlideX0+vSlideW*i*percPerTick);
					tickObj.transform.localRotation = TickQuatRot;
					tickObj.transform.localScale = quadScale;
					tickObj.AddComponent<MeshRenderer>();

					MeshFilter tickFilt = tickObj.AddComponent<MeshFilter>();
					tickFilt.sharedMesh = vTickMeshBuilder.Mesh;

					vTicks[i] = tickObj;
				}
			}

			////

			vGrabHold = new GameObject("GrabHold");
			vGrabHold.transform.SetParent(gameObject.transform, false);
			vGrabHold.transform.localRotation = Quaternion.Inverse(gameObject.transform.localRotation);

			var grabObj = new GameObject("Grab");
			grabObj.transform.SetParent(vGrabHold.transform, false);

			vGrab = grabObj.AddComponent<UiItemSliderGrabRenderer>();
			vGrab.IsVert = vIsVert;
			vGrab.Build(vPanelState, vLayoutState, vItemState, vSettings);

			if ( vIsVert ) {
				vGrab.SetCustomSize(vHeight, vGrabW, false);
			}
			else {
				vGrab.SetCustomSize(vGrabW, vHeight, false);
			}

			////

			vHoverHold = new GameObject("HoverHold");
			vHoverHold.transform.SetParent(gameObject.transform, false);

			var hoverObj = new GameObject("Hover");
			hoverObj.transform.SetParent(vHoverHold.transform, false);

			vHover = new UiHoverMeshRect(hoverObj, "Hover");
		}
		/*--------------------------------------------------------------------------------------------*/
		protected override IItemVisualSettings GetSettingsInner(IBaseItem pItem,
												IItemVisualSettings pDefault, bool pFillWithDefault) {
			vDefaultSettings = (ItemVisualSettingsStandard)pDefault;
			HandleValueChanged(null);
			return vHueSettings;
		}
Example #41
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public virtual void Build(MenuState pMenuState, IBaseItemState pItemState,
                                  float pArcAngle, IItemVisualSettings pSettings)
        {
            vMenuState  = pMenuState;
            vItemState  = pItemState;
            vAngle0     = -pArcAngle / 2f + UiHoverMeshSlice.AngleInset;
            vAngle1     = pArcAngle / 2f - UiHoverMeshSlice.AngleInset;
            vSettings   = (ItemVisualSettingsStandard)pSettings;
            vSliderItem = (ISliderItem)vItemState.Item;

            const float pi = (float)Math.PI;

            vGrabArcHalf  = pi / 80f;
            vSlideDegree0 = (vAngle0 + vGrabArcHalf) / pi * 180;
            vSlideDegrees = (vAngle1 - vAngle0 - vGrabArcHalf * 2) / pi * 180;

            ////

            vHiddenSlice = new UiHoverMeshSlice(gameObject, true);
            vHiddenSlice.Resize(1, 1.5f, pArcAngle);
            vHiddenSlice.UpdateBackground(Color.clear);

            vTrackA = new UiHoverMeshSlice(gameObject, true, "TrackA");
            vTrackB = new UiHoverMeshSlice(gameObject, true, "TrackB");
            vFillA  = new UiHoverMeshSlice(gameObject, true, "FillA");
            vFillB  = new UiHoverMeshSlice(gameObject, true, "FillB");

            ////

            vTickMat              = new Material(Shader.Find("Unlit/AlphaSelfIllum"));
            vTickMat.renderQueue -= 400;
            vTickMat.color        = Color.clear;

            if (vSliderItem.Ticks > 1)
            {
                Vector3 quadScale   = new Vector3(UiHoverMeshSlice.AngleInset * 2, 0.36f, 0.1f);
                float   percPerTick = 1 / (float)(vSliderItem.Ticks - 1);

                vTicks = new GameObject[vSliderItem.Ticks];

                for (int i = 0; i < vSliderItem.Ticks; ++i)
                {
                    var tick = new GameObject("Tick" + i);
                    tick.transform.SetParent(gameObject.transform, false);
                    tick.transform.localRotation = Quaternion.AngleAxis(
                        vSlideDegree0 + vSlideDegrees * i * percPerTick, Vector3.up);
                    vTicks[i] = tick;

                    var quad = GameObject.CreatePrimitive(PrimitiveType.Quad);
                    quad.renderer.sharedMaterial = vTickMat;
                    quad.transform.SetParent(tick.transform, false);
                    quad.transform.localPosition = new Vector3(0, 0, 1.25f);
                    quad.transform.localRotation =
                        Quaternion.FromToRotation(Vector3.back, Vector3.down);
                    quad.transform.localScale = quadScale;
                }
            }

            ////

            vGrabHold = new GameObject("GrabHold");
            vGrabHold.transform.SetParent(gameObject.transform, false);

            var grabObj = new GameObject("Grab");

            grabObj.transform.SetParent(vGrabHold.transform, false);

            vGrab = grabObj.AddComponent <UiItemSliderGrabRenderer>();
            vGrab.Build(vMenuState, vItemState, vGrabArcHalf * 2, pSettings);

            ////

            vHoverHold = new GameObject("HoverHold");
            vHoverHold.transform.SetParent(gameObject.transform, false);

            var hoverObj = new GameObject("Hover");

            hoverObj.transform.SetParent(vHoverHold.transform, false);

            vHover = new UiHoverMeshSlice(hoverObj, false, "Hover");
        }
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public virtual void Build(IHovercastMenuState pMenuState, IBaseItemState pItemState,
													float pArcAngle, IItemVisualSettings pSettings) {
			vMenuState = pMenuState;
			vItemState = pItemState;
			vAngle0 = -pArcAngle/2f;
			vAngle1 = pArcAngle/2f;
			vSettings = (ItemVisualSettingsStandard)pSettings;
			vSliderItem = (ISliderItem)vItemState.Item;
			vTicks = new GameObject[vSliderItem.Ticks];

			const float pi = (float)Math.PI;

			vGrabArc = pi/40f;
			vSlideDegree0 = (vAngle0+vGrabArc/2)/pi*180;
			vSlideDegrees = (vAngle1-vAngle0-vGrabArc)/pi*180;
			vZeroValue = (0-vSliderItem.RangeMin)/(vSliderItem.RangeMax-vSliderItem.RangeMin);

			////

			vHiddenSlice = new UiHoverMeshSlice(gameObject, true);
			vHiddenSlice.UpdateSize(1, 1.5f, pArcAngle);
			vHiddenSlice.UpdateBackground(Color.clear);

			var trackObj = new GameObject("Track");
			trackObj.transform.SetParent(gameObject.transform, false);
			trackObj.transform.localRotation = Quaternion.AngleAxis(vAngle0/pi*180, Vector3.up);

			vTrack = new UiItemSliderTrackRenderer(trackObj);
			vTrackSegments = new ReadList<DisplayUtil.TrackSegment>();
			vTrackCuts = new ReadList<DisplayUtil.TrackSegment>();

			////

			if ( vSliderItem.Ticks > 1 ) {
				Vector3 quadScale = new Vector3(UiHoverMeshSlice.AngleInset*2, 0.36f, 0.1f);
				float percPerTick = 1/(float)(vSliderItem.Ticks-1);

				vTickMeshBuilder = new MeshBuilder();
				MeshUtil.BuildQuadMesh(vTickMeshBuilder);
				vTickMeshBuilder.Commit();
				vTickMeshBuilder.CommitColors(Color.clear);

				for ( int i = 0 ; i < vSliderItem.Ticks ; ++i ) {
					var tickObj = new GameObject("Tick"+i);
					tickObj.transform.SetParent(gameObject.transform, false);
					tickObj.transform.localRotation = Quaternion.AngleAxis(
						vSlideDegree0+vSlideDegrees*i*percPerTick, Vector3.up);
					vTicks[i] = tickObj;

					var quadObj = new GameObject("Quad");
					quadObj.transform.SetParent(tickObj.transform, false);
					quadObj.transform.localPosition = new Vector3(0, 0, 1.25f);
					quadObj.transform.localRotation = TickQuatRot;
					quadObj.transform.localScale = quadScale;
					quadObj.AddComponent<MeshRenderer>();

					MeshFilter quadFilt = quadObj.AddComponent<MeshFilter>();
					quadFilt.sharedMesh = vTickMeshBuilder.Mesh;
				}
			}

			////

			vGrabHold = new GameObject("GrabHold");
			vGrabHold.transform.SetParent(gameObject.transform, false);

			var grabObj = new GameObject("Grab");
			grabObj.transform.SetParent(vGrabHold.transform, false);

			vGrab = grabObj.AddComponent<UiItemSliderGrabRenderer>();
			vGrab.Build(vMenuState, vItemState, vGrabArc, pSettings);

			////

			vHoverHold = new GameObject("HoverHold");
			vHoverHold.transform.SetParent(gameObject.transform, false);

			var hoverObj = new GameObject("Hover");
			hoverObj.transform.SetParent(vHoverHold.transform, false);

			vHover = new UiHoverMeshSlice(hoverObj, false, "Hover");
		}
 /*--------------------------------------------------------------------------------------------*/
 protected abstract IItemVisualSettings GetSettingsInner(IBaseItem pItem,
                                                         IItemVisualSettings pDefault, bool pFillWithDefault);
		/*--------------------------------------------------------------------------------------------*/
		protected abstract IItemVisualSettings GetSettingsInner(IBaseItem pItem,
			IItemVisualSettings pDefault, bool pFillWithDefault);
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		protected internal abstract IItemVisualSettings GetVerifyAndSaveSettings(IBaseItem pItem,
			IItemVisualSettings pDefault, bool pFillWithDefault);
Example #46
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public virtual void Build(IHoverboardPanelState pPanelState,
                                  IHoverboardLayoutState pLayoutState, IBaseItemState pItemState,
                                  IItemVisualSettings pSettings)
        {
            vPanelState  = pPanelState;
            vLayoutState = pLayoutState;
            vItemState   = pItemState;
            vSettings    = (ItemVisualSettingsStandard)pSettings;
            vSliderItem  = (ISliderItem)vItemState.Item;
            vTicks       = new GameObject[vSliderItem.Ticks];

            vWidth     = UiItem.Size * vSliderItem.Width;
            vHeight    = UiItem.Size * vSliderItem.Height;
            vIsVert    = (vHeight > vWidth);
            vGrabW     = 1;
            vZeroValue = (0 - vSliderItem.RangeMin) / (vSliderItem.RangeMax - vSliderItem.RangeMin);

            gameObject.transform.SetParent(gameObject.transform, false);
            gameObject.transform.localPosition = new Vector3(vWidth / 2, 0, vHeight / 2f);
            gameObject.transform.localRotation = Quaternion.AngleAxis((vIsVert ? 90 : 0), Vector3.up);

            if (vIsVert)                 //swap dimensions here + rotate graphics later
            {
                float tempW = vWidth;
                vWidth  = vHeight;
                vHeight = tempW;
            }

            vSlideX0 = (vGrabW - vWidth) / 2;
            vSlideW  = vWidth - vGrabW;

            ////

            vHiddenRect = new UiHoverMeshRectBg(gameObject);
            vHiddenRect.UpdateSize(vWidth, vHeight);

            var trackObj = new GameObject("Track");

            trackObj.transform.SetParent(gameObject.transform, false);
            trackObj.transform.localPosition = new Vector3(-vWidth / 2, 0, 0);

            vTrack         = new UiItemSliderTrackRenderer(trackObj);
            vTrackSegments = new ReadList <DisplayUtil.TrackSegment>();
            vTrackCuts     = new ReadList <DisplayUtil.TrackSegment>();

            ////

            if (vSliderItem.Ticks > 1)
            {
                Vector3 quadScale   = new Vector3(UiHoverMeshRect.SizeInset * 2, 0.36f, 0.1f);
                float   percPerTick = 1 / (float)(vSliderItem.Ticks - 1);

                vTickMeshBuilder = new MeshBuilder();
                MeshUtil.BuildQuadMesh(vTickMeshBuilder);
                vTickMeshBuilder.Commit();
                vTickMeshBuilder.CommitColors(Color.clear);

                for (int i = 0; i < vSliderItem.Ticks; ++i)
                {
                    GameObject tickObj = new GameObject("Tick" + i);
                    tickObj.transform.SetParent(gameObject.transform, false);
                    tickObj.transform.localPosition = Vector3.right * (vSlideX0 + vSlideW * i * percPerTick);
                    tickObj.transform.localRotation = TickQuatRot;
                    tickObj.transform.localScale    = quadScale;
                    tickObj.AddComponent <MeshRenderer>();

                    MeshFilter tickFilt = tickObj.AddComponent <MeshFilter>();
                    tickFilt.sharedMesh = vTickMeshBuilder.Mesh;

                    vTicks[i] = tickObj;
                }
            }

            ////

            vGrabHold = new GameObject("GrabHold");
            vGrabHold.transform.SetParent(gameObject.transform, false);
            vGrabHold.transform.localRotation = Quaternion.Inverse(gameObject.transform.localRotation);

            var grabObj = new GameObject("Grab");

            grabObj.transform.SetParent(vGrabHold.transform, false);

            vGrab        = grabObj.AddComponent <UiItemSliderGrabRenderer>();
            vGrab.IsVert = vIsVert;
            vGrab.Build(vPanelState, vLayoutState, vItemState, vSettings);

            if (vIsVert)
            {
                vGrab.SetCustomSize(vHeight, vGrabW, false);
            }
            else
            {
                vGrab.SetCustomSize(vGrabW, vHeight, false);
            }

            ////

            vHoverHold = new GameObject("HoverHold");
            vHoverHold.transform.SetParent(gameObject.transform, false);

            var hoverObj = new GameObject("Hover");

            hoverObj.transform.SetParent(vHoverHold.transform, false);

            vHover = new UiHoverMeshRect(hoverObj, "Hover");
        }