Example #1
0
        private void _panel_MouseClick(object sender, MouseEventArgs e)
        {
            Point point = new Point(e.X, e.Y);

            Engine.QueueForRenderDispatcher(() =>
            {
                if (e.Button == MouseButtons.Left)
                {
                    Ray ray;
                    RaySceneQueryResult.Enumerator itr = GetRaySceneQuery(point.X, point.Y, out ray);

                    if (itr != null)
                    {
                        while (itr.MoveNext())
                        {
                            RaySceneQueryResultEntry entry = itr.Current;
                            SceneNode parentNode           = entry.movable.ParentSceneNode;

                            PositionedInstance instance = Engine.SceneNodeStore.GetInstance(parentNode);

                            if (instance != null)
                            {
                                Engine.RunOnUIThread(() =>
                                {
                                    IoC.Get <IExplorer>().SelectInstance(instance);
                                });

                                ActiveScene.SelectedInstance = instance;

                                SetActiveSelectedNode(parentNode);
                                return;
                            }
                        }
                        SceneNode node;
                        if (ExistsSelectedNode(out node))
                        {
                            PositionedInstance oldInstance = Engine.SceneNodeStore.GetInstance(node);
                            if (oldInstance != null)
                            {
                                SizedInstance oldSized = oldInstance as SizedInstance;
                                if (oldSized != null)
                                {
                                    oldSized.IsSelected           = false;
                                    oldSized.IsBoundingBoxEnabled = false;
                                }
                            }

                            ActiveScene.SelectedInstance = null;

                            oldInstance.RemoveGizmoVisual();

                            ClearSelectedNode();
                        }
                    }
                }
            });
        }
Example #2
0
        public void SetActiveSelectedNode(SceneNode newNode)
        {
            PositionedInstance instance = Engine.SceneNodeStore.GetInstance(newNode);

            if (instance == null)
            {
                return;
            }
            SceneNode node;

            if (ExistsSelectedNode(out node))
            {
                if (!newNode.Equals(node))
                {
                    PositionedInstance oldInstance = Engine.SceneNodeStore.GetInstance(node);
                    if (oldInstance != null)
                    {
                        SizedInstance oldSized = oldInstance as SizedInstance;
                        if (oldSized != null)
                        {
                            oldSized.IsSelected           = false;
                            oldSized.IsBoundingBoxEnabled = false;
                        }
                        oldInstance.RemoveGizmoVisual();
                        ClearSelectedNode();
                    }
                    SizedInstance sized = instance as SizedInstance;
                    if (sized != null)
                    {
                        sized.IsBoundingBoxEnabled = true;
                        sized.IsSelected           = true;
                    }
                    SetSelectedNode(newNode);

                    instance.SetGizmoVisual(new GizmoVisual(_gizmoNode));
                }
            }
            else
            {
                SizedInstance sized = instance as SizedInstance;
                if (sized != null)
                {
                    sized.IsBoundingBoxEnabled = true;
                    sized.IsSelected           = true;
                }

                SetSelectedNode(newNode);

                instance.SetGizmoVisual(new GizmoVisual(_gizmoNode));
            }
        }
Example #3
0
        public void AddToHoverNode(SceneNode newNode)
        {
            if (!IsAlreadyHovered(newNode))
            {
                if (!IsSelectedNode(newNode))
                {
                    PositionedInstance instance = Engine.SceneNodeStore.GetInstance(newNode);
                    if (instance != null)
                    {
                        SizedInstance sized = instance as SizedInstance;
                        if (sized != null)
                        {
                            sized.IsBoundingBoxEnabled = true;
                        }

                        MarkAsHovered(newNode);
                    }
                }
            }
        }
Example #4
0
 Task ICommandHandler <PasteInstanceCommandDefinition> .Run(Command command)
 {
     if (ActiveScene.CopiedInstance != null)
     {
         Instance      instance   = ActiveScene.CopiedInstance.clone();
         SizedInstance positioned = instance as SizedInstance;
         if (positioned != null)
         {
             Vector3 vector = Engine.GetBestLocationFromYDown(
                 new Vector3(
                     positioned.position.x + (positioned.size.x / 2),
                     positioned.position.y + (positioned.size.y / 2),
                     positioned.position.z + (positioned.size.z / 2)
                     ),
                 positioned.position.y + (positioned.size.y / 2),
                 positioned.size.y / 2);
             positioned.position.y = vector.y;
         }
     }
     return(TaskUtility.Completed);
 }
Example #5
0
        private void _panel_MouseMove(object sender, MouseEventArgs e)
        {
            if (_oldMousePosition == null)
            {
                _oldMousePosition = new Point(e.X, e.Y);
                return;
            }
            Point point = new Point(e.X, e.Y);

            Engine.QueueForRenderDispatcher(() =>
            {
                double deltaDirectionX = point.X - _oldMousePosition.X;
                double deltaDirectionY = point.Y - _oldMousePosition.Y;

                if (e.Button.HasFlag(MouseButtons.Right))
                {
                    ActiveScene.Context.ActiveWorld.Camera.pitch(new Radian((float)-deltaDirectionY / 200f).ValueDegrees);
                    ActiveScene.Context.ActiveWorld.Camera.yaw(new Radian((float)-deltaDirectionX / 200f).ValueDegrees);
                }

                IEnumerable <SceneNode> selected = GetSelectedNode();
                SceneNode selectedNode           = null;
                if (selected != null)
                {
                    selectedNode = selected.FirstOrDefault();
                }

                if (_translateDragging != TransformDragging.NONE && ActiveScene.ActiveGizmoType == Misc.Runtime.GizmoType.TRANSLATE)
                {
                    if (selectedNode != null)
                    {
                        Plane plane = new Plane();
                        if (_translateDragging == TransformDragging.X)
                        {
                            Vector3 normal = Vector3.UNIT_Y;
                            plane          = new Plane(normal, selectedNode.Position);
                        }
                        else if (_translateDragging == TransformDragging.Y)
                        {
                            Vector3 normal = (Engine.Renderer.Camera.Position - selectedNode.Position).NormalisedCopy;
                            normal.y       = 0;
                            plane          = new Plane(normal, selectedNode.Position);
                        }
                        else if (_translateDragging == TransformDragging.Z)
                        {
                            Vector3 normal = Vector3.UNIT_Y;
                            plane          = new Plane(normal, selectedNode.Position);
                        }

                        Vector3 translateVector;
                        if (GetRaySceneLocationWithPlane(point.X, point.Y, plane, out translateVector, selectedNode))
                        {
                            PositionedInstance instance = Engine.SceneNodeStore.GetInstance(selectedNode);

                            SizedInstance sized = instance as SizedInstance;

                            if (sized != null)
                            {
                                translateVector -= _translateDragDifference;

                                if (_translateDragging == TransformDragging.X)
                                {
                                    instance.position.x = (float)System.Math.Round(translateVector.x - (sized.size.x / 2));
                                    //PhysicsEngine.GetCollisionVectorResolvement(instance as PhysicsInstance);
                                }
                                else if (_translateDragging == TransformDragging.Y)
                                {
                                    instance.position.y = (float)System.Math.Round(translateVector.y - (sized.size.y / 2));
                                    //PhysicsEngine.GetCollisionVectorResolvement(instance as PhysicsInstance);
                                }
                                else if (_translateDragging == TransformDragging.Z)
                                {
                                    instance.position.z = (float)System.Math.Round(translateVector.z - (sized.size.z / 2));
                                    //PhysicsEngine.GetCollisionVectorResolvement(instance as PhysicsInstance);
                                }
                            }
                        }
                    }
                }
                else if (_scaleDragging != DirectionalTransformDragging.NONE && ActiveScene.ActiveGizmoType == Misc.Runtime.GizmoType.SCALE)
                {
                    if (selectedNode != null)
                    {
                        Plane plane = new Plane();
                        if (_scaleDragging == DirectionalTransformDragging.XA || _scaleDragging == DirectionalTransformDragging.XB)
                        {
                            Vector3 normal = Vector3.UNIT_Y;
                            plane          = new Plane(normal, selectedNode.Position);
                        }
                        else if (_scaleDragging == DirectionalTransformDragging.YA || _scaleDragging == DirectionalTransformDragging.YB)
                        {
                            Vector3 normal = (Engine.Renderer.Camera.Position - selectedNode.Position).NormalisedCopy;
                            normal.y       = 0;
                            plane          = new Plane(normal, selectedNode.Position);
                        }
                        else if (_scaleDragging == DirectionalTransformDragging.ZA || _scaleDragging == DirectionalTransformDragging.ZB)
                        {
                            Vector3 normal = Vector3.UNIT_Y;
                            plane          = new Plane(normal, selectedNode.Position);
                        }

                        Vector3 scaleVector;
                        if (GetRaySceneLocationWithPlane(point.X, point.Y, plane, out scaleVector, selectedNode))
                        {
                            PositionedInstance instance = Engine.SceneNodeStore.GetInstance(selectedNode);

                            SizedInstance sized = instance as SizedInstance;

                            if (sized != null)
                            {
                                int magicOffsetA = 2;

                                if (_scaleDragging == DirectionalTransformDragging.XA)
                                {
                                    sized.size.x = System.Math.Max(1, (float)System.Math.Round(scaleVector.x - (sized.position.x) - magicOffsetA));
                                }
                                else if (_scaleDragging == DirectionalTransformDragging.YA)
                                {
                                    sized.size.y = System.Math.Max(1, (float)System.Math.Round(scaleVector.y - (sized.position.y) - magicOffsetA));
                                }
                                else if (_scaleDragging == DirectionalTransformDragging.ZA)
                                {
                                    sized.size.z = System.Math.Max(1, (float)System.Math.Round(scaleVector.z - (sized.position.z) - magicOffsetA));
                                }
                                else if (_scaleDragging == DirectionalTransformDragging.XB)
                                {
                                    //TODO: fix
                                    float newX  = scaleVector.x + (sized.size.x / 2) + _scaleDragDifference.x; //wtf?
                                    float delta = (sized.position.x - newX);

                                    float rounded = (float)System.Math.Round(delta);

                                    sized.position.x -= rounded;
                                    sized.size.x     += rounded;
                                }
                                else if (_scaleDragging == DirectionalTransformDragging.YB)
                                {
                                }
                                else if (_scaleDragging == DirectionalTransformDragging.ZB)
                                {
                                }
                            }
                        }
                    }
                }

                Cursor cursor = null;
                if (_translateFreeDragging && _scaleDragging == DirectionalTransformDragging.NONE && _translateDragging == TransformDragging.NONE)
                {
                    if (selectedNode != null)
                    {
                        Plane plane = new Plane(Vector3.UNIT_Y, Engine.Renderer.Camera.Position.y - 16);

                        Vector3 vector;
                        if (GetRaySceneLocationWithPlane(point.X, point.Y, plane, out vector, selectedNode))
                        {
                            PositionedInstance instance = Engine.SceneNodeStore.GetInstance(selectedNode);

                            SizedInstance sized = instance as SizedInstance;

                            if (sized != null)
                            {
                                instance.position.x = (float)System.Math.Round(vector.x - (sized.size.x / 2));
                                instance.position.y = (float)System.Math.Round(vector.y - (sized.size.y / 2));
                                instance.position.z = (float)System.Math.Round(vector.z - (sized.size.z / 2));
                            }
                        }

                        cursor = Cursors.NoMove2D;
                    }
                    else
                    {
                        _translateFreeDragging = false;
                    }
                }

                Ray ray;
                RaySceneQueryResult.Enumerator itr = GetRaySceneQuery(point.X, point.Y, out ray);

                if (itr != null)
                {
                    bool nothing = true;
                    while (itr.MoveNext())
                    {
                        RaySceneQueryResultEntry entry = itr.Current;

                        if (entry.movable.QueryFlags != (uint)QueryFlags.IGNORE_ALL)
                        {
                            nothing = false;
                        }

                        if (entry.movable.QueryFlags == (uint)QueryFlags.INSTANCE_ENTITY)
                        {
                            SceneNode parentNode = entry.movable.ParentSceneNode;
                            if (selectedNode != null && selectedNode.Equals(parentNode) && e.Button.HasFlag(MouseButtons.Left) && _translateDragging == TransformDragging.NONE)
                            {
                                if (System.Math.Abs(deltaDirectionX) >= TRANSLATE_DRAG_THRESHOLD || System.Math.Abs(deltaDirectionY) >= TRANSLATE_DRAG_THRESHOLD)
                                {
                                    _translateFreeDragging = true;
                                }
                            }
                            if (!IsAlreadyHovered(parentNode))
                            {
                                IEnumerable <SceneNode> hovered = GetHoveredNodes();
                                if (hovered != null)
                                {
                                    foreach (SceneNode node in hovered)
                                    {
                                        if (!IsSelectedNode(node))
                                        {
                                            PositionedInstance oldInstance = Engine.SceneNodeStore.GetInstance(node);
                                            if (oldInstance != null)
                                            {
                                                SizedInstance oldSized = oldInstance as SizedInstance;
                                                if (oldSized != null)
                                                {
                                                    oldSized.IsBoundingBoxEnabled = false;
                                                }
                                            }
                                        }
                                    }
                                    ClearHovered();
                                }
                                AddToHoverNode(parentNode);
                            }
                            break;
                        }
                    }
                    if (nothing)
                    {
                        if (cursor == null)
                        {
                            cursor = Cursors.Default;
                        }
                        IEnumerable <SceneNode> hovered = GetHoveredNodes();
                        if (hovered != null)
                        {
                            foreach (SceneNode node in hovered)
                            {
                                if (!IsSelectedNode(node))
                                {
                                    PositionedInstance oldInstance = Engine.SceneNodeStore.GetInstance(node);
                                    if (oldInstance != null)
                                    {
                                        SizedInstance oldSized = oldInstance as SizedInstance;
                                        if (oldSized != null)
                                        {
                                            oldSized.IsBoundingBoxEnabled = false;
                                        }
                                    }
                                }
                            }
                            ClearHovered();
                        }
                    }
                    else
                    {
                        if (cursor == null)
                        {
                            cursor = Cursors.Hand;
                        }
                    }
                }
                if (cursor != null)
                {
                    System.Windows.Application.Current.Dispatcher.InvokeAsync(() => _panel.Cursor = cursor, DispatcherPriority.Background);
                }
                _oldMousePosition = point;
            });
        }