Пример #1
0
        /*--------------------------------------------------------------------------------------------*/
        private void BuildCustomize()
        {
            vMenuOpacity = 0.5f;

            CustomizeDark              = new NavItemRadio("Dark Theme");
            CustomizeDark.OnSelected  += HandleDarkThemeSelected;
            CustomizeDark.Value        = true;
            CustomizeLight             = new NavItemRadio("Light Theme");
            CustomizeLight.OnSelected += HandleLightThemeSelected;
            CustomizeColor             = new NavItemRadio("Color Theme");
            CustomizeColor.OnSelected += HandleColorThemeSelected;

            CustomizeFontsize = new NavItemSlider("Size", 3);
            CustomizeFontsize.ValueToLabel = ((v, sv) =>
                                              "Size: " + Math.Round(Mathf.Lerp(MinFontSize, MaxFontSize, sv)));
            CustomizeFontsize.Value           = Mathf.InverseLerp(MinFontSize, MaxFontSize, 30);
            CustomizeFontsize.OnValueChanged += HandleFontSizeChanged;

            CustomizeOpacity = new NavItemSlider("Bg Alpha", 3);
            CustomizeOpacity.ValueToLabel    = ((v, sv) => "Bg Alpha: " + Math.Round(v * 100) + "%");
            CustomizeOpacity.Value           = vMenuOpacity;
            CustomizeOpacity.OnValueChanged += HandleOpacityChanged;

            CustomizeSwitch             = new NavItemSelector("Switch Hands!");
            CustomizeSwitch.OnSelected += HandleSwitchHands;

            Customize = new NavItemParent("Customize");
            Customize.ChildLevel.Items = new NavItem[] { CustomizeDark, CustomizeLight, CustomizeColor,
                                                         CustomizeFontsize, CustomizeOpacity, CustomizeSwitch };
        }
Пример #2
0
        /*--------------------------------------------------------------------------------------------*/
        private void BuildLight()
        {
            LightPos   = new NavItemSlider("Position", 2);
            LightInten = new NavItemSlider("Power", 2);
            LightSpot  = new NavItemSticky("Spotlight");

            Light = new NavItemParent("Lighting");
            Light.ChildLevel.Items = new NavItem[] { LightPos, LightInten, LightSpot };
        }
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public void Awake() {
			vRootSettings = GameObject.Find("DemoEnvironment/MenuData")
				.GetComponent<HovercastCustomizationProvider>()
				.GetSegmentSettings(null);

			vHueSettings = new SegmentSettings();
			
			vHueSlider = (NavItemSlider)gameObject.GetComponent<HovercastNavItem>().GetItem();
			vHueSlider.OnValueChanged += HandleValueChanged;
		}
Пример #4
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        private void BuildColors()
        {
            ColorWhite  = new NavItemRadio("White");
            ColorRandom = new NavItemRadio("Random");
            ColorCustom = new NavItemRadio("Custom");
            ColorHue    = new NavItemSlider("Hue", 3);

            Color = new NavItemParent("Color");
            Color.ChildLevel.Items = new NavItem[] { ColorWhite, ColorRandom, ColorCustom, ColorHue };
        }
Пример #5
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public void Awake()
        {
            vRootSettings = GameObject.Find("DemoEnvironment/MenuData")
                            .GetComponent <HovercastCustomizationProvider>()
                            .GetSegmentSettings(null);

            vHueSettings = new SegmentSettings();

            vHueSlider = (NavItemSlider)gameObject.GetComponent <HovercastNavItem>().GetItem();
            vHueSlider.OnValueChanged += HandleValueChanged;
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        private void HandleValueChanged(NavItem <bool> pNavItem)
        {
            if (!pNavItem.Value)
            {
                return;
            }

            NavItemSlider hue = (NavItemSlider)HueSlider.GetItem();

            hue.IsEnabled = (Mode == DemoEnvironment.ColorMode.Custom);
            Enviro.SetColorMode(Mode, hue.RangeValue);
        }
Пример #7
0
        /*--------------------------------------------------------------------------------------------*/
        private void BuildMotions()
        {
            MotionOrbit = new NavItemCheckbox("Orbit");
            MotionSpin  = new NavItemCheckbox("Spin");
            MotionBob   = new NavItemCheckbox("Bob");
            MotionGrow  = new NavItemCheckbox("Grow");
            MotionSpeed = new NavItemSlider("Speed", 4);

            Motion = new NavItemParent("Motion");
            Motion.ChildLevel.Items = new NavItem[] { MotionOrbit, MotionSpin, MotionBob, MotionGrow,
                                                      MotionSpeed };
        }
Пример #8
0
        /*--------------------------------------------------------------------------------------------*/
        private void UpdateSliderValue()
        {
            NavItemSlider slider = ((NavItemSlider)vSegState.NavItem);

            if (!vSegState.IsNearestHighlight || vSegState.HighlightProgress <= 0)
            {
                slider.HoverValue = null;
                return;
            }

            Vector3 cursorLocal = vCursorLocalPos;

            cursorLocal.y = 0;

            Vector3    cursorDir = cursorLocal.normalized;
            Quaternion diff      = Quaternion.FromToRotation(vSlideDir0, cursorDir);

            float   cursorDeg;
            Vector3 cursorAxis;

            diff.ToAngleAxis(out cursorDeg, out cursorAxis);

            if (cursorAxis.y < 0)
            {
                cursorDeg = 0;
            }

            if (slider.IsStickySelected)
            {
                slider.Value      = cursorDeg / vSlideDegrees;
                slider.HoverValue = null;
            }
            else if (slider.AllowJump)
            {
                slider.HoverValue = cursorDeg / vSlideDegrees;
            }
            else
            {
                slider.HoverValue = null;
            }
        }
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		public virtual void Build(ArcState pArcState, SegmentState pSegState,
														float pArcAngle, SegmentSettings pSettings) {
			vArcState = pArcState;
			vSegState = pSegState;
			vAngle0 = -pArcAngle/2f+UiSlice.AngleInset;
			vAngle1 = pArcAngle/2f-UiSlice.AngleInset;
			vSettings = pSettings;
			vNavSlider = (NavItemSlider)vSegState.NavItem;

			const float pi = (float)Math.PI;
			const float radInner = 1.04f;
			const float radOuter = 1.46f;

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

			////

			vHiddenSlice = new UiSlice(gameObject, true);
			vHiddenSlice.Resize(pArcAngle);
			vHiddenSlice.UpdateBackground(Color.clear);

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

			////

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

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

				vTicks = new GameObject[vNavSlider.Ticks];

				for ( int i = 0 ; i < vNavSlider.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<UiSliderGrabRenderer>();
			vGrab.Build(vArcState, vSegState, 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 UiSlice(hoverObj, false, "Hover");
		}
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public virtual void Build(ArcState pArcState, SegmentState pSegState,
                                  float pArcAngle, SegmentSettings pSettings)
        {
            vArcState  = pArcState;
            vSegState  = pSegState;
            vAngle0    = -pArcAngle / 2f + UiSlice.AngleInset;
            vAngle1    = pArcAngle / 2f - UiSlice.AngleInset;
            vSettings  = pSettings;
            vNavSlider = (NavItemSlider)vSegState.NavItem;

            const float pi       = (float)Math.PI;
            const float radInner = 1.04f;
            const float radOuter = 1.46f;

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

            ////

            vHiddenSlice = new UiSlice(gameObject, true);
            vHiddenSlice.Resize(pArcAngle);
            vHiddenSlice.UpdateBackground(Color.clear);

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

            ////

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

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

                vTicks = new GameObject[vNavSlider.Ticks];

                for (int i = 0; i < vNavSlider.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 <UiSliderGrabRenderer>();
            vGrab.Build(vArcState, vSegState, 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 UiSlice(hoverObj, false, "Hover");
        }
Пример #11
0
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*--------------------------------------------------------------------------------------------*/
        public virtual void Build(ArcState pArcState, ArcSegmentState pSegState,
                                  float pArcAngle, ArcSegmentSettings pSettings)
        {
            vArcState  = pArcState;
            vSegState  = pSegState;
            vAngle0    = -pArcAngle / 2f + UiSelectRenderer.AngleInset;
            vAngle1    = pArcAngle / 2f - UiSelectRenderer.AngleInset;
            vSettings  = pSettings;
            vNavSlider = (NavItemSlider)vSegState.NavItem;
            vMeshSteps = (int)Math.Round(Math.Max(2, (vAngle1 - vAngle0) / Math.PI * 60));

            const float pi = (float)Math.PI;

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

            ////

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

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

            vTrackMesh = vTrack.GetComponent <MeshFilter>().mesh;
            vFillMesh  = vFill.GetComponent <MeshFilter>().mesh;

            ////

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

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

                vTicks = new GameObject[vNavSlider.Ticks];

                for (int i = 0; i < vNavSlider.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 <UiSliderGrabRenderer>();
            vGrab.Build(vArcState, vSegState, vSliderAngleHalf * 2, pSettings);
        }