public static Size DivideBy(this Size size, RenderScale scale) => size.DivideBy((int)scale);
 public static RenderScale IncreaseQuality(this RenderScale scale) =>
 scale.IsMaximumQuality() ? scale : (RenderScale)((int)scale / 2);
 public static RenderScale IncreaseFidelity(this RenderScale scale) =>
 scale == RenderScale.Eighth ? RenderScale.Quarter : RenderScale.Normal;
 public static RenderScale DecreaseQuality(this RenderScale scale) =>
 scale.IsMinimumQuality() ? scale : (RenderScale)((int)scale * 2);
 public static bool IsMinimumQuality(this RenderScale scale) => scale == RenderScale.Eighth;
 public static bool IsMaximumQuality(this RenderScale scale) => scale == RenderScale.Normal;
Example #7
0
 public static Point DivideBy(this Point p, RenderScale renderScale) => p.DivideBy((int)renderScale);
        public void Update(DiscreteInput input)
        {
            switch (input)
            {
            case DiscreteInput.ToggleFollowMode:
                FollowMode = !FollowMode;
                _message.ShowMessage($"Follow mode is {(FollowMode ? "ON" : "OFF")}");
                FollowModeChanged?.Invoke(this, EventArgs.Empty);
                break;

            case DiscreteInput.ToggleRotateMode:
                RotateMode = !RotateMode;
                _message.ShowMessage($"Rotate mode is {(RotateMode ? "ON" : "OFF")}");
                RotateModeChanged?.Invoke(this, EventArgs.Empty);
                break;

            case DiscreteInput.ToggleLineAntiAliasing:
                DrawAntiAliased = !DrawAntiAliased;
                _message.ShowMessage($"Draw antialiased lines is {(DrawAntiAliased ? "ON" : "OFF")}");
                DrawAntiAliasedModeChanged?.Invoke(this, EventArgs.Empty);
                break;

            case DiscreteInput.ToggleShowRenderTime:
                ShowRenderTime = !ShowRenderTime;
                ShowRenderTimeChanged?.Invoke(this, EventArgs.Empty);
                break;

            case DiscreteInput.SwitchRenderer:
                Renderer = Renderer.Next();
                RendererChanged?.Invoke(this, EventArgs.Empty);
                break;

            case DiscreteInput.ToggleOverheadMap:
                if (Renderer == RendererType.FirstPerson)
                {
                    Renderer = RendererType.Overhead;
                    RendererChanged?.Invoke(this, EventArgs.Empty);
                }
                else if (Renderer == RendererType.Overhead)
                {
                    Renderer = RendererType.FirstPerson;
                    RendererChanged?.Invoke(this, EventArgs.Empty);
                }
                break;

            case DiscreteInput.DecreaseRenderFidelity:
            {
                var oldScale = RenderScale;
                RenderScale = RenderScale.DecreaseFidelity();
                if (oldScale != RenderScale)
                {
                    RenderScaleChanged?.Invoke(this, EventArgs.Empty);
                }
            }
            break;

            case DiscreteInput.IncreaseRenderFidelity:
            {
                var oldScale = RenderScale;
                RenderScale = RenderScale.IncreaseFidelity();
                if (oldScale != RenderScale)
                {
                    RenderScaleChanged?.Invoke(this, EventArgs.Empty);
                }
            }
            break;

            default:
                break;
            }
        }