Example #1
0
        public void Update(EditorMouseState state, GameTime gameTime)
        {
            switch (ProjectionType)
            {
            case CameraProjectionType.Perspective:
                updatePerspectiveCamera(state, gameTime);
                break;

            case CameraProjectionType.Orthographic:
                updateOrtographicCamera(state, gameTime);
                break;
            }
        }
Example #2
0
        private void updatePerspectiveCamera(EditorMouseState state, GameTime gameTime)
        {
            float elapsedTime = (float)gameTime.ElapsedGameTime.TotalMilliseconds / 1000.0f;

            if (lastMouseState == null || !state.onControl || state.RightButton == ButtonState.Released)
            {
                lastMouseState = new EditorMouseState(state);
                return;
            }
            float deltaX = state.Position.X - lastMouseState.Position.X;
            float deltaY = state.Position.Y - lastMouseState.Position.Y;

            Yaw   -= RotationSpeed * deltaX * elapsedTime;
            Pitch += RotationSpeed * deltaY * elapsedTime;


            Vector3       translation = new Vector3(0, 0, 0);
            KeyboardState keyState    = Keyboard.GetState();

            if (keyState.IsKeyDown(Keys.W))
            {
                translation += new Vector3(0, 0, TranslationSpeed) * elapsedTime;
            }

            if (keyState.IsKeyDown(Keys.S))
            {
                translation += new Vector3(0, 0, -TranslationSpeed) * elapsedTime;
            }

            if (keyState.IsKeyDown(Keys.D))
            {
                translation += new Vector3(-TranslationSpeed, 0, 0) * elapsedTime;
            }

            if (keyState.IsKeyDown(Keys.A))
            {
                translation += new Vector3(TranslationSpeed, 0, 0) * elapsedTime;
            }

            Matrix rotationMatrix = Matrix.CreateFromYawPitchRoll(Yaw, Pitch, 0);


            Vector3 Up = Vector3.Transform(Vector3.Up, rotationMatrix);

            Position += Vector3.Transform(translation, rotationMatrix);
            Forward   = Vector3.Transform(new Vector3(0, 0, 1), rotationMatrix);
            Vector3 cameraFinalTarget = Position + Forward;

            View           = Matrix.CreateLookAt(Position, cameraFinalTarget, Up);
            lastMouseState = new EditorMouseState(state);
        }
Example #3
0
        private void updateOrtographicCamera(EditorMouseState state, GameTime gameTime)
        {
            float elapsedTime = (float)gameTime.ElapsedGameTime.TotalMilliseconds / 1000.0f;
            float zoomDelta   = (state.ScrollValue - lastMouseState.ScrollValue) * zoomSpeed;

            ortZoom += zoomDelta * ortZoom;
            Yaw      = 0;
            Pitch    = 0;
            Vector3 ortPosition = new Vector3(Position.X, Position.Y, -50f);

            View           = Matrix.CreateLookAt(ortPosition, ortPosition + new Vector3(0, 0, 1), Vector3.Up);
            Projection     = Matrix.CreateOrthographic(device.Viewport.Width * ortZoom, device.Viewport.Height * ortZoom, 0.1f, 1000f);
            lastMouseState = new EditorMouseState(state);

            Vector3       translation = Vector3.Zero;
            KeyboardState keyState    = Keyboard.GetState();

            if (keyState.IsKeyDown(Keys.W))
            {
                translation += new Vector3(0, TranslationSpeed, 0) * elapsedTime;
            }

            if (keyState.IsKeyDown(Keys.S))
            {
                translation += new Vector3(0, -TranslationSpeed, 0) * elapsedTime;
            }

            if (keyState.IsKeyDown(Keys.D))
            {
                translation += new Vector3(-TranslationSpeed, 0, 0) * elapsedTime;
            }

            if (keyState.IsKeyDown(Keys.A))
            {
                translation += new Vector3(TranslationSpeed, 0, 0) * elapsedTime;
            }
            Position += translation;
        }
        protected override void OnPreviewMouseLeftButtonUp(MouseButtonEventArgs e)
        {
        //    base.OnPreviewMouseLeftButtonUp(e);
        //}
        //protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
        //{
            if (PreviewMode)
            {
                //Point mousePosition = e.GetPosition(this);
                //VisualContainer.MouseUp(new Point(mousePosition.X / ZoomFactor, mousePosition.Y / ZoomFactor));
                //e.Handled = true;
                return;
            }

            switch (_mouseState)
            {
                case EditorMouseState.SelectStart:
                    if (SelectedItems.Count > 0)
                    {
                        SelectedItems.Clear();
                    }
                    break;

                case EditorMouseState.Move:
                    if (_snapManager.Action != SnapAction.None)
                    {
                        if (_snapManager.IsValidDrag)
                        {
                            ConfigManager.UndoManager.StartBatch();
                            foreach (HeliosVisual panel in SelectedItems)
                            {
                                panel.Left += _snapManager.LocationOffset.X;
                                panel.Top += _snapManager.LocationOffset.Y;
                            }
                            ConfigManager.UndoManager.CloseBatch();
                        }
                    }
                    _snapManager.Action = SnapAction.None;
                    GetSelectionAdorner().InvalidateVisual();
                    Cursor = null;
                    break;

                case EditorMouseState.Selecting:
                    DragSelectionAdorner dragAdorner = GetDragSelectionAdorner();
                    foreach (HeliosVisual visual in VisualContainer.Children.Reverse())
                    {
                        Rect visualRect = visual.DisplayRectangle;
                        visualRect.Scale(ZoomFactor, ZoomFactor);
                        if (!visual.IsLocked && dragAdorner.Rectangle.IntersectsWith(visualRect) && !SelectedItems.Contains(
                            visual))
                        {
                            SelectedItems.Add(visual);
                        }
                    }
                    break;
            }

            _mouseState = EditorMouseState.Idle;
            RemoveDragSelectionAdorner();
            ReleaseMouseCapture();
        }
        protected override void OnPreviewMouseMove(MouseEventArgs e)
        {
        //    base.OnPreviewMouseMove(e);
        //}


        //protected override void OnMouseMove(MouseEventArgs e)
        //{
            if (PreviewMode)
            {
                //Point mousePosition = e.GetPosition(this);
                //VisualContainer.MouseDrag(new Point(mousePosition.X / ZoomFactor, mousePosition.Y / ZoomFactor));
                //e.Handled = true;
                return;
            }

            Point resizePosition = e.GetPosition(this);

            _dragVector = e.GetPosition(Window.GetWindow(this)) - _mouseDownPosition;

            if (e.LeftButton == MouseButtonState.Pressed &&
                    (Math.Abs(_dragVector.X) > SystemParameters.MinimumHorizontalDragDistance ||
                     Math.Abs(_dragVector.Y) > SystemParameters.MinimumVerticalDragDistance))
            {
                switch (_mouseState)
                {
                    case EditorMouseState.SelectStart:
                        if (!Keyboard.Modifiers.HasFlag(ModifierKeys.Control))
                        {
                            SelectedItems.Clear();
                        }
                        _mouseState = EditorMouseState.Selecting;
                        break;
                }
            }

            switch (_mouseState)
            {
                case EditorMouseState.Move:
                    _snapManager.ForceProportions = Keyboard.Modifiers.HasFlag(ModifierKeys.Shift);
                    _snapManager.IgnoreTargets = Keyboard.Modifiers.HasFlag(ModifierKeys.Control);
                    _snapManager.DragVector = _dragVector;
                    GetSelectionAdorner().InvalidateVisual();                    
                    break;

                case EditorMouseState.Selecting:
                    GetDragSelectionAdorner().DragVector = _dragVector;
                    break;
            }

            e.Handled = true;
        }
        protected override void OnPreviewMouseLeftButtonDown(MouseButtonEventArgs e)
        {
            if (PreviewMode)
            {
                return;
            }

            Focus();

            _mouseDownPosition = e.GetPosition(Window.GetWindow(this));
            _snapManager.DragVector = new Vector(0, 0);
            _snapManager.Action = SnapAction.None;

            Point resizePosition = e.GetPosition(this);

            Rect selectionRectangle = SelectedItems.Rectangle;
            selectionRectangle.Scale(ZoomFactor, ZoomFactor);

            if (e.ClickCount == 2)
            {
                foreach (HeliosVisual visual in VisualContainer.Children.Reverse())
                {
                    Rect visualRect = visual.DisplayRectangle;
                    visualRect.Scale(ZoomFactor, ZoomFactor);

                    if (!visual.IsLocked  && !visual.IsHidden && visualRect.Contains(resizePosition))
                    {
                        Helios.Controls.HeliosPanel panel = visual as Helios.Controls.HeliosPanel;
                        if (panel != null)
                        {
                            if (ProfileEditorCommands.OpenProfileItem.CanExecute(panel, this))
                            {
                                ProfileEditorCommands.OpenProfileItem.Execute(panel, this);
                                e.Handled = true;
                                break;
                            }
                        }
                    }
                }
                return;
            }

            if (_mouseState == EditorMouseState.Idle && SelectedItems.Count > 0 && selectionRectangle.Contains(resizePosition) && !Keyboard.Modifiers.HasFlag(ModifierKeys.Control))
            {
                LoadSnapTargets(true);
                _snapManager.Location = SelectedItems.Rectangle.Location;
                _snapManager.Size = SelectedItems.Rectangle.Size;
                _snapManager.Action = SnapAction.Move;
                _mouseState = EditorMouseState.Move;
                Cursor = Cursors.SizeAll;
            }

            if (_mouseState == EditorMouseState.Idle)
            {
                bool controlClicked = false;

                foreach (HeliosVisual visual in VisualContainer.Children.Reverse())
                {
                    Rect visualRect = visual.DisplayRectangle;
                    visualRect.Scale(ZoomFactor, ZoomFactor);

                    if (!visual.IsLocked && !visual.IsHidden && visualRect.Contains(resizePosition))
                    {
                        controlClicked = true;
                        if (!SelectedItems.Contains(visual))
                        {
                            if (Keyboard.Modifiers != ModifierKeys.Control)
                            {
                                SelectedItems.Clear();
                            }

                            SelectedItems.Add(visual);
                            break;
                        }
                        else if (Keyboard.Modifiers == ModifierKeys.Control)
                        {
                            SelectedItems.Remove(visual);
                        }
                    }
                }

                if (!controlClicked)
                {
                    _mouseState = EditorMouseState.SelectStart;
                    DragSelectionAdorner adorner = GetDragSelectionAdorner();
                    adorner.StartLocation = e.GetPosition(this);
                    if (!Keyboard.Modifiers.HasFlag(ModifierKeys.Control))
                    {
                        SelectedItems.Clear();
                    }
                }
            }

            e.Handled = true;
            CaptureMouse();
        }