Exemplo n.º 1
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            switch (args.Key)
            {
                case Key.Up:
                case Key.Down:
                    ActionRequested?.Invoke(state);
                    return true;
            }

            return base.OnKeyDown(state, args);
        }
Exemplo n.º 2
0
        void OnKeyDown(KeyDownEventArgs e)
        {
            switch (e.Key)
            {
            case Key.Esc:
                //Exit();
                break;

            case Key.R:
                RotateRootNode(false);
                rootNode.Rotation = new Quaternion(0, 0, 0);
                RotateRootNode(true);
                break;

            case Key.H:
                HandMode = !HandMode;
                break;

            case Key.Space:
                DrawDebugFrame = !DrawDebugFrame;
                break;

            case Key.Q:
                console?.Toggle();
                break;

            case Key.E:
                debugHud?.ToggleAll();
                break;

            case Key.KP_Plus:
                if (Input.GetKeyDown(Key.B))
                {
                    Brightness += 0.2f;
                }
                break;

            case Key.KP_Minus:
                if (Input.GetKeyDown(Key.B))
                {
                    Brightness -= 0.2f;
                }
                break;
            }
        }
Exemplo n.º 3
0
            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
            {
                switch (args.Key)
                {
                case Key.Right:
                    beatDivisor.Next();
                    OnUserChange();
                    return(true);

                case Key.Left:
                    beatDivisor.Previous();
                    OnUserChange();
                    return(true);

                default:
                    return(false);
                }
            }
Exemplo n.º 4
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            if (state.Keyboard.ControlPressed)
            {
                switch (args.Key)
                {
                case Key.Minus:
                    transformTimeSpanTo(TimeSpan + time_span_step, 200, EasingTypes.OutQuint);
                    break;

                case Key.Plus:
                    transformTimeSpanTo(TimeSpan - time_span_step, 200, EasingTypes.OutQuint);
                    break;
                }
            }

            return(false);
        }
Exemplo n.º 5
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            if (!args.Repeat)
            {
                switch (args.Key)
                {
                case Key.Escape:
                    exit();
                    return(true);

                case Key.F11:
                    toggleFullScreen();
                    return(true);
                }
            }

            return(base.OnKeyDown(state, args));
        }
Exemplo n.º 6
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            base.OnKeyDown(state, args);

            if (state.Keyboard.ControlPressed && !args.Repeat && args.Key >= Key.Number1 && args.Key <= Key.Number9)
            {
                int requested = args.Key - Key.Number1;

                RulesetInfo found = rulesets.AvailableRulesets.Skip(requested).FirstOrDefault();
                if (found != null)
                {
                    ruleset.Value = found;
                }
                return(true);
            }

            return(false);
        }
Exemplo n.º 7
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            if (args.Repeat)
            {
                return(false);
            }

            if (state.Keyboard.ControlPressed)
            {
                if (args.Key == Key.H && ReplayLoaded)
                {
                    ToggleVisibility();
                    return(true);
                }
            }

            return(base.OnKeyDown(state, args));
        }
Exemplo n.º 8
0
        public override void OnKeyDown(KeyDownEventArgs e)
        {
            if (Enabled && (_leftView.Enabled || _rightView.Enabled))
            {
                if (e.Key == Keys.TAB)
                {
                    _leftView.Enabled  = !_leftView.Enabled;
                    _rightView.Enabled = !_rightView.Enabled;
                }
                if (e.Key == Keys.F1)
                {
                    _operationSourceItem = GetSourceItem();
                    if (_operationSourceItem != null)
                    {
                        _operation = Operation.Copy;
                    }
                }
                if (e.Key == Keys.F2)
                {
                    _operationSourceItem = GetSourceItem();
                    if (_operationSourceItem != null)
                    {
                        _operation = Operation.Move;
                    }
                }
                if (e.Key == Keys.F3)
                {
                    switch (_operation)
                    {
                    case Operation.Copy:
                        StartOperation();
                        break;

                    case Operation.Move:
                        StartOperation();
                        _operation = Operation.None;
                        break;

                    default:
                        break;
                    }
                }
            }
        }
Exemplo n.º 9
0
            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
            {
                if (args.Repeat)
                {
                    return(false);
                }

                Drawable target = null;
                Drawable back   = null;

                if (args.Key == CentreKey)
                {
                    target = centreHit;
                    back   = centre;
                }
                else if (args.Key == RimKey)
                {
                    target = rimHit;
                    back   = rim;
                }

                if (target != null)
                {
                    const float scale_amount = 0.05f;
                    const float alpha_amount = 0.5f;

                    const float down_time = 40;
                    const float up_time   = 1000;

                    back.ScaleTo(target.Scale.X - scale_amount, down_time, Easing.OutQuint)
                    .Then()
                    .ScaleTo(1, up_time, Easing.OutQuint);

                    target.Animate(
                        t => t.ScaleTo(target.Scale.X - scale_amount, down_time, Easing.OutQuint),
                        t => t.FadeTo(Math.Min(target.Alpha + alpha_amount, 1), down_time, Easing.OutQuint)
                        ).Then(
                        t => t.ScaleTo(1, up_time, Easing.OutQuint),
                        t => t.FadeOut(up_time, Easing.OutQuint)
                        );
                }

                return(false);
            }
Exemplo n.º 10
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            if (args.Repeat)
            {
                return(false);
            }

            if (state.Keyboard.ShiftPressed)
            {
                switch (args.Key)
                {
                case Key.Tab:
                    showHud.Value = !showHud.Value;
                    return(true);
                }
            }

            return(base.OnKeyDown(state, args));
        }
Exemplo n.º 11
0
        /// <summary>
        /// Switches camera mode to/from free float mode,
        /// based on the current camera mode.
        /// </summary>
        /// <param name="args">The key down event data.</param>
        void CameraSwitchMode(KeyDownEventArgs args)
        {
            activeCameraMovement.StopAll();

            if (cameraType == CameraMovementType.FreeFloat)
            {
                camera.SwitchToFixed();
                cameraType = CameraMovementType.Fixed;
                input.ShowCursor();
            }
            else
            {
                camera.SwitchToFree();
                cameraType = CameraMovementType.FreeFloat;
                input.HideCursor();
                input.Level.Map.DisableHighlight();
                input.Level.ToolManager.DisableTools();
            }
        }
Exemplo n.º 12
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            switch (args.Key)
            {
            case Key.Enter:
                footer.StartButton.TriggerClick();
                return(true);

            case Key.Delete:
                if (Beatmap != null)
                {
                    Beatmap.Dispose();
                    database.Delete(Beatmap.BeatmapSetInfo);
                }
                return(true);
            }

            return(base.OnKeyDown(state, args));
        }
Exemplo n.º 13
0
 public override void OnKeyDown(KeyDownEventArgs e)
 {
     if (e.Key == Keys.RETURN)
     {
         if (_okButton.Selected)
         {
             Action();
         }
         Close();
     }
     if (e.Key == Keys.LEFT || e.Key == Keys.RIGHT)
     {
         ChangeSelectedButton();
     }
     if (e.Key == Keys.ESCAPE)
     {
         Close();
     }
 }
Exemplo n.º 14
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            // Check if we've handled the initial key
            if (!Judgement.Result.HasValue)
            {
                bool result = base.OnKeyDown(state, args);

                if (result)
                {
                    firstHitTime = Time.Current;
                    firstHitKey  = args.Key;
                }

                return(result);
            }

            // If we've already hit the second key, don't handle this object any further
            if (Judgement.SecondHit)
            {
                return(false);
            }

            // Don't handle represses of the same key
            if (firstHitKey == args.Key)
            {
                return(false);
            }

            // Don't handle invalid hit key presses
            if (!HitKeys.Contains(args.Key))
            {
                return(false);
            }

            // If we're not holding the first key down still, assume the intention
            // was not to hit the accented hit with both keys simultaneously
            if (!state.Keyboard.Keys.Contains(firstHitKey))
            {
                return(false);
            }

            return(UpdateJudgement(true));
        }
Exemplo n.º 15
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            if (args.Repeat)
            {
                return(false);
            }

            switch (args.Key)
            {
            case Key.Space:
                logo?.TriggerOnClick(state);
                return(true);

            case Key.Escape:
                return(goBack());
            }

            return(false);
        }
Exemplo n.º 16
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            if (Judgement.Result != HitResult.None)
            {
                return(false);
            }

            if (args.Key != Key)
            {
                return(false);
            }

            if (args.Repeat)
            {
                return(false);
            }

            return(UpdateJudgement(true));
        }
Exemplo n.º 17
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            switch (args.Key)
            {
            case Key.Enter:
                footer.StartButton.TriggerClick();
                return(true);

            case Key.Delete:
                if (state.Keyboard.ShiftPressed)
                {
                    promptDelete();
                    return(true);
                }
                break;
            }

            return(base.OnKeyDown(state, args));
        }
Exemplo n.º 18
0
        private bool globalHotkeyPressed(InputState state, KeyDownEventArgs args)
        {
            if (args.Repeat || intro == null)
            {
                return(false);
            }

            switch (args.Key)
            {
            case Key.F8:
                chat.ToggleVisibility();
                return(true);

            case Key.PageUp:
            case Key.PageDown:
                var swClock = (Clock as ThrottledFrameClock)?.Source as StopwatchClock;
                if (swClock == null)
                {
                    return(false);
                }

                swClock.Rate *= args.Key == Key.PageUp ? 1.1f : 0.9f;
                Logger.Log($@"Adjusting game clock to {swClock.Rate}", LoggingTarget.Debug);
                return(true);
            }

            if (state.Keyboard.ControlPressed)
            {
                switch (args.Key)
                {
                case Key.T:
                    Toolbar.ToggleVisibility();
                    return(true);

                case Key.O:
                    options.ToggleVisibility();
                    return(true);
                }
            }

            return(false);
        }
Exemplo n.º 19
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            switch (args.Key)
            {
            case Key.Space:
                osuLogo.TriggerClick(state);
                return(true);

            case Key.Escape:
                if (State == MenuState.Initial)
                {
                    return(false);
                }

                State = MenuState.Initial;
                return(true);
            }

            return(false);
        }
Exemplo n.º 20
0
        private bool globalKeyDown(InputState state, KeyDownEventArgs args)
        {
            if (state.Keyboard.ControlPressed)
            {
                switch (args.Key)
                {
                case Key.F11:
                    switch (FrameStatisticsMode)
                    {
                    case FrameStatisticsMode.None:
                        FrameStatisticsMode = FrameStatisticsMode.Minimal;
                        break;

                    case FrameStatisticsMode.Minimal:
                        FrameStatisticsMode = FrameStatisticsMode.Full;
                        break;

                    case FrameStatisticsMode.Full:
                        FrameStatisticsMode = FrameStatisticsMode.None;
                        break;
                    }
                    return(true);

                case Key.F1:
                    DrawVisualiser.ToggleVisibility();
                    return(true);

                case Key.F10:
                    logOverlay.ToggleVisibility();
                    return(true);
                }
            }

            if (state.Keyboard.AltPressed && args.Key == Key.Enter)
            {
                Window?.CycleMode();
                return(true);
            }

            return(false);
        }
Exemplo n.º 21
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            if (state.Keyboard.ControlPressed)
            {
                switch (args.Key)
                {
                case Key.F11:
                    switch (performanceContainer.State)
                    {
                    case FrameStatisticsMode.None:
                        performanceContainer.State = FrameStatisticsMode.Minimal;
                        break;

                    case FrameStatisticsMode.Minimal:
                        performanceContainer.State = FrameStatisticsMode.Full;
                        break;

                    case FrameStatisticsMode.Full:
                        performanceContainer.State = FrameStatisticsMode.None;
                        break;
                    }
                    return(true);

                case Key.F1:
                    DrawVisualiser.ToggleVisibility();
                    return(true);

                case Key.F10:
                    logOverlay.ToggleVisibility();
                    return(true);
                }
            }

            if (state.Keyboard.AltPressed && args.Key == Key.Enter)
            {
                Window?.CycleMode();
                return(true);
            }

            return(base.OnKeyDown(state, args));
        }
Exemplo n.º 22
0
        private bool globalHotkeyPressed(InputState state, KeyDownEventArgs args)
        {
            switch (args.Key)
            {
            case Key.F8:
                chat.ToggleVisibility();
                return(true);
            }

            if (state.Keyboard.ControlPressed)
            {
                switch (args.Key)
                {
                case Key.O:
                    Options.ToggleVisibility();
                    return(true);
                }
            }

            return(base.OnKeyDown(state, args));
        }
Exemplo n.º 23
0
 private void UIActionHandler(object sender, KeyDownEventArgs e)
 {
     if (e.Action == GameActionType.MoveLeft)
     {
         if (this.Hunter.Position.Left > 0)
         {
             this.Hunter.MoveLeft();
         }
     }
     else if (e.Action == GameActionType.MoveRight)
     {
         if (this.Hunter.Position.Left < this.Renderer.ScreenWidth - this.Hunter.Bounds.Width)
         {
             this.Hunter.MoveRight();
         }
     }
     else if (e.Action == GameActionType.Fire)
     {
         FireBullet();
     }
 }
Exemplo n.º 24
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            if (HandlePendingText(state))
            {
                return(true);
            }

            if (!state.Keyboard.ControlPressed && !state.Keyboard.ShiftPressed)
            {
                switch (args.Key)
                {
                case Key.Left:
                case Key.Right:
                case Key.Up:
                case Key.Down:
                    return(false);
                }
            }

            if (!AllowCommit)
            {
                switch (args.Key)
                {
                case Key.KeypadEnter:
                case Key.Enter:
                    return(false);
                }
            }

            if (state.Keyboard.ShiftPressed)
            {
                switch (args.Key)
                {
                case Key.Delete:
                    return(false);
                }
            }

            return(base.OnKeyDown(state, args));
        }
 protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
 {
     /*ArrayList inputs = new ArrayList();
      * if (state.Keyboard.IsPressed(OpenTK.Input.Key.D))
      * {
      *  inputs.Add(InvadersAction.Right);
      * }
      * if (state.Keyboard.IsPressed(OpenTK.Input.Key.W))
      * {
      *  inputs.Add(InvadersAction.Up);
      * }
      * if (state.Keyboard.IsPressed(OpenTK.Input.Key.A))
      * {
      *  inputs.Add(InvadersAction.Left);
      * }
      * if (state.Keyboard.IsPressed(OpenTK.Input.Key.S))
      * {
      *  inputs.Add(InvadersAction.Down);
      * }
      * blocker.OnPressed(inputs);*/
     return(false);
 }
Exemplo n.º 26
0
 // Token: 0x06015605 RID: 87557 RVA: 0x0056C36C File Offset: 0x0056A56C
 private void _ProcessKeyboard()
 {
     if (Event.current != null && Event.current.isKey)
     {
         if (Event.current.rawType == EventType.KeyDown)
         {
             KeyDownEventArgs e = new KeyDownEventArgs(Event.current.keyCode);
             if (this.OnKeyDown != null)
             {
                 this.OnKeyDown(this, e);
             }
         }
         else if (Event.current.rawType == EventType.KeyUp)
         {
             KeyUpEventArgs e2 = new KeyUpEventArgs(Event.current.keyCode);
             if (this.OnKeyUp != null)
             {
                 this.OnKeyUp(this, e2);
             }
         }
     }
 }
Exemplo n.º 27
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            var step = KeyboardStep;

            if (Bindable.IsInteger)
            {
                step = Math.Ceiling(step);
            }
            switch (args.Key)
            {
            case Key.Right:
                Bindable.Add(step);
                return(true);

            case Key.Left:
                Bindable.Add(step);
                return(true);

            default:
                return(false);
            }
        }
Exemplo n.º 28
0
 public override void OnKeyDown(KeyDownEventArgs e)
 {
     if (Enabled)
     {
         if (e.Key == Keys.DOWN && SelectedIndex < _items.Count - 1)
         {
             Move(MoveDirection.Down);
         }
         else if (e.Key == Keys.UP && SelectedIndex > 0)
         {
             Move(MoveDirection.Up);
         }
         if (e.Key == Keys.RETURN)
         {
             ChooseCurrentItem();
         }
         if (e.Key == Keys.BACK)
         {
             Back();
         }
         if (e.Key == Keys.F4)
         {
             FSViewer.GoToFolder(string.Empty);
             Update(true);
         }
         if (e.Key == Keys.F5)
         {
             OpenPropertiesView();
         }
         if (e.Key == Keys.F6)
         {
             OpenRenameView();
         }
         if (e.Key == Keys.F7)
         {
             OpenCreateFolderView();
         }
     }
 }
Exemplo n.º 29
0
        /// <summary>
        ///     如果鍵盤有按下去
        ///     如果時間差在 可以接受篁E��內就回傳true
        /// </summary>
        /// <param name="state"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            if (args.Repeat)
            {
                return(false);
            }

            var pressDelay = Math.Abs(Time.Current - _baseRPObject.StartTime);

            //Hit at the time
            if (pressDelay < _baseRPObject.hit50 && _nowPressMatchKey == Key.Unknown)
            {
                //目前符合的key
                var pressKeyList = FilterMatchKey(state);

                //如果過濾後發現沒有Key
                if (pressKeyList.Count > 0)
                {
                    PressDownDelayTime = pressDelay;
                    _nowPressMatchKey  = pressKeyList[0];
                    _pressValid        = true;
                    return(Hit?.Invoke() ?? false);
                }
            }
            else if (false) //outside the time
            {
                //目前符合的key
                var pressKeyList = FilterMatchKey(state);

                //如果過濾後發現沒有Key
                if (pressKeyList.Count >= 0)
                {
                    _nowPressMatchKey = pressKeyList[0];
                }
                ;
            }
            return(false);
        }
Exemplo n.º 30
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            switch (args.Key)
            {
            case Key.Enter:
                footer.StartButton.TriggerClick();
                return(true);

            case Key.Delete:
                if (state.Keyboard.ShiftPressed)
                {
                    if (Beatmap != null)
                    {
                        dialogOverlay?.Push(new BeatmapDeleteDialog(Beatmap));
                    }

                    return(true);
                }
                break;
            }

            return(base.OnKeyDown(state, args));
        }
Exemplo n.º 31
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            if (!UserScrollSpeedAdjustment)
            {
                return(false);
            }

            if (state.Keyboard.ControlPressed)
            {
                switch (args.Key)
                {
                case Key.Minus:
                    this.TransformBindableTo(VisibleTimeRange, VisibleTimeRange + time_span_step, 600, Easing.OutQuint);
                    break;

                case Key.Plus:
                    this.TransformBindableTo(VisibleTimeRange, VisibleTimeRange - time_span_step, 600, Easing.OutQuint);
                    break;
                }
            }

            return(false);
        }
Exemplo n.º 32
0
        private void HandleUiActionHappend(object sender, KeyDownEventArgs e)
        {
            var left = this.Player.Position.Left;
            var top = this.Player.Position.Top;

            var possibleMovements = this.Player.PossibleMovements(Maze);

            switch (e.Command)
            {
                case GameCommand.MoveDown:
                    if(possibleMovements.Contains(Direction.Down))
                        this.Player.Position = new Position(left, top + AppSettings.MopvementSpeed);
                        this.Player.LastMoveDirection = Direction.Down;
                        this.ItemsToCollect = this.Player.PosibleCollection(this.ItemsToCollect);
                    break;
                case GameCommand.MoveUp:
                    if (possibleMovements.Contains(Direction.Up))
                        this.Player.Position = new Position(left, top - AppSettings.MopvementSpeed);
                        this.Player.LastMoveDirection = Direction.Up;
                        this.ItemsToCollect = this.Player.PosibleCollection(this.ItemsToCollect);
                    break;
                case GameCommand.MoveLeft:
                    if (possibleMovements.Contains(Direction.Left))
                        this.Player.Position = new Position(left - AppSettings.MopvementSpeed, top);
                        this.Player.LastMoveDirection = Direction.Left;
                        this.ItemsToCollect = this.Player.PosibleCollection(this.ItemsToCollect);
                    break;
                case GameCommand.MoveRight:
                    if (possibleMovements.Contains(Direction.Right))
                        this.Player.Position = new Position(left + AppSettings.MopvementSpeed, top);
                        this.Player.LastMoveDirection = Direction.Right;
                        this.ItemsToCollect = this.Player.PosibleCollection(this.ItemsToCollect);
                    break;
                case GameCommand.Attack:
                    this.Fire();
                    break;
            }
        }
Exemplo n.º 33
0
		void HandleKeyDown(KeyDownEventArgs e)
		{
			switch (e.Key)
			{
				case Key.Esc:
					Exit();
					return;
				case Key.F1:
					console.Toggle();
					return;
				case Key.F2:
					debugHud.ToggleAll();
					return;
			}

			var renderer = Renderer;
			switch (e.Key)
			{
				case Key.N1:
					var quality = renderer.TextureQuality;
					++quality;
					if (quality > 2)
						quality = 0;
					renderer.TextureQuality = quality;
					break;

				case Key.N2:
					var mquality = renderer.MaterialQuality;
					++mquality;
					if (mquality > 2)
						mquality = 0;
					renderer.MaterialQuality = mquality;
					break;

				case Key.N3:
					renderer.SpecularLighting = !renderer.SpecularLighting;
					break;

				case Key.N4:
					renderer.DrawShadows = !renderer.DrawShadows;
					break;

				case Key.N5:
					var shadowMapSize = renderer.ShadowMapSize;
					shadowMapSize *= 2;
					if (shadowMapSize > 2048)
						shadowMapSize = 512;
					renderer.ShadowMapSize = shadowMapSize;
					break;

				// shadow depth and filtering quality
				case Key.N6:
					var q = (int)renderer.ShadowQuality++;
					if (q > 3)
						q = 0;
					renderer.ShadowQuality = (ShadowQuality)q;
					break;

				// occlusion culling
				case Key.N7:
					var o = !(renderer.MaxOccluderTriangles > 0);
					renderer.MaxOccluderTriangles = o ? 5000 : 0;
					break;

				// instancing
				case Key.N8:
					renderer.DynamicInstancing = !renderer.DynamicInstancing;
					break;

				case Key.N9:
					Image screenshot = new Image();
					Graphics.TakeScreenShot(screenshot);
					screenshot.SavePNG(FileSystem.ProgramDir + $"Data/Screenshot_{GetType().Name}_{DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss", CultureInfo.InvariantCulture)}.png");
					break;
			}
		}
Exemplo n.º 34
0
Arquivo: OsuGame.cs Projeto: yheno/osu
        private bool globalHotkeyPressed(InputState state, KeyDownEventArgs args)
        {
            if (args.Repeat) return false;

            switch (args.Key)
            {
                case Key.F8:
                    chat.ToggleVisibility();
                    return true;
                case Key.PageUp:
                case Key.PageDown:
                    var rate = ((Clock as ThrottledFrameClock).Source as StopwatchClock).Rate * (args.Key == Key.PageUp ? 1.1f : 0.9f);
                    ((Clock as ThrottledFrameClock).Source as StopwatchClock).Rate = rate;
                    Logger.Log($@"Adjusting game clock to {rate}", LoggingTarget.Debug);
                    return true;
            }

            if (state.Keyboard.ControlPressed)
            {
                switch (args.Key)
                {
                    case Key.O:
                        options.ToggleVisibility();
                        return true;
                }
            }

            return base.OnKeyDown(state, args);
        }
Exemplo n.º 35
0
 protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
 {
     return Handler(state, args);
 }
Exemplo n.º 36
0
 protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
 {
     switch (args.Key)
     {
         case Key.Escape:
             if (State == Visibility.Hidden) return false;
             Hide();
             return true;
     }
     return base.OnKeyDown(state, args);
 }
Exemplo n.º 37
0
 protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
 {
     if (args.Key == this.Key) IsLit = true;
     return base.OnKeyDown(state, args);
 }
Exemplo n.º 38
0
		void HandleEscKeyDown(KeyDownEventArgs args)
		{
			// Unlike the other samples, exiting the engine when ESC is pressed instead of just closing the console
			if (args.Key == Key.Esc)
				Engine.Exit();
		}
Exemplo n.º 39
0
        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            switch (args.Key)
            {
                case Key.Enter:
                    start();
                    return true;
            }

            return base.OnKeyDown(state, args);
        }
Exemplo n.º 40
0
		void HandleKeyDown(KeyDownEventArgs e)
		{
			switch (e.Key)
			{
				case Key.Esc:
					Exit();
					return;
				case Key.F1:
					console.Toggle();
					return;
				case Key.F2:
					debugHud.ToggleAll();
					return;
			}

			if (UI.FocusElement == null)
				return;

			var renderer = Renderer;
			switch (e.Key)
			{
				case Key.N1:
					var quality = renderer.TextureQuality;
					++quality;
					if (quality > 2)
						quality = 0;
					renderer.TextureQuality = quality;
					break;

				case Key.N2:
					var mquality = renderer.MaterialQuality;
					++mquality;
					if (mquality > 2)
						mquality = 0;
					renderer.MaterialQuality = mquality;
					break;

				case Key.N3:
					renderer.SpecularLighting = !renderer.SpecularLighting;
					break;

				case Key.N4:
					renderer.DrawShadows = !renderer.DrawShadows;
					break;

				case Key.N5:
					var shadowMapSize = renderer.ShadowMapSize;
					shadowMapSize *= 2;
					if (shadowMapSize > 2048)
						shadowMapSize = 512;
					renderer.ShadowMapSize = shadowMapSize;
					break;

				// shadow depth and filtering quality
				case Key.N6:
					var q = (int)renderer.ShadowQuality++;
					if (q > 3)
						q = 0;
					renderer.ShadowQuality = (ShadowQuality)q;
					break;

				// occlusion culling
				case Key.N7:
					var o = !(renderer.MaxOccluderTriangles > 0);
					renderer.MaxOccluderTriangles = o ? 5000 : 0;
					break;

				// instancing
				case Key.N8:
					renderer.DynamicInstancing = !renderer.DynamicInstancing;
					break;
			}
		}