Example #1
0
 protected override void Awake()
 {
     base.Awake();
     controller    = GetComponent <EntityController>();
     viewDirection = startdirection;
     ChangeViewDirection();
 }
Example #2
0
 private void ChangeViewDirection()
 {
     if (Mathf.Abs(direction.x) > Mathf.Abs(direction.y))
     {
         if (direction.x > 0.0f)
         {
             viewDirection = ViewDirection.right;
         }
         else if (direction.x < 0.0f)
         {
             viewDirection = ViewDirection.left;
         }
     }
     else
     {
         if (direction.y > 0.0f)
         {
             viewDirection = ViewDirection.up;
         }
         else if (direction.y < 0.0f)
         {
             viewDirection = ViewDirection.down;
         }
     }
 }
Example #3
0
        public static void ResolveTangents(Vector2 from, Vector2 to, ViewDirection direction, float curvature, out Vector2 fromTangent, out Vector2 toTangent)
        {
            switch (direction)
            {
            case ViewDirection.Vertical:
                var tangentY = Mathf.Abs(from.y - to.y) * curvature;
                tangentY = Mathf.Max(tangentY, 25);

                fromTangent = new Vector2(0, tangentY);
                toTangent   = new Vector2(0, -tangentY);
                break;

            case ViewDirection.Horizontal:
                var tangentX = Mathf.Abs(from.x - to.x) * curvature;
                tangentX    = Mathf.Max(tangentX, 25);
                fromTangent = new Vector2(tangentX, 0);
                toTangent   = new Vector2(-tangentX, 0);
                break;

            default:
                fromTangent = default;
                toTangent   = default;
                break;
            }
        }
Example #4
0
 public Viewport2D(ViewDirection direction)
 {
     Zoom         = 1;
     Position     = new Coordinate(0, 0, 0);
     Direction    = direction;
     CenterScreen = new Coordinate(Width / 2m, Height / 2m, 0);
 }
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            int           max           = Settings.MaxSize;
            int           y             = (int)values[4];
            int           z             = (int)values[5];
            ViewDirection viewDirection = (ViewDirection)values[6];
            bool          fullSize      = (bool)values[7];
            int           factor        = fullSize ? Settings.LargeFactor : Settings.SmallFactor;
            bool          fromSelection = (bool)values[8];
            int           selectId      = (int)values[9];
            bool          isDragged     = (bool)values[10];

            if (fromSelection && !isDragged)
            {
                return((double)(max - 2 * selectId + 1) * factor);
            }

            switch (viewDirection)
            {
            case ViewDirection.TopView:
                return((double)(factor * y));

            case ViewDirection.FrontView:
            case ViewDirection.BackView:
            case ViewDirection.LeftView:
            case ViewDirection.RightView:
                return((double)(factor * z));

            default:
                return((double)(factor * y));
            }
        }
Example #6
0
 public Viewport2D(ViewDirection direction)
 {
     Zoom = 1;
     Position = new Coordinate(0, 0, 0);
     Direction = direction;
     CenterScreen = new Coordinate(Width / 2m, Height / 2m, 0);
 }
Example #7
0
 public Viewport2D(ViewDirection direction, RenderContext context) : base(context)
 {
     Zoom         = 1;
     Position     = new Coordinate(0, 0, 0);
     Direction    = direction;
     CenterScreen = new Coordinate(Width / 2m, Height / 2m, 0);
 }
Example #8
0
 private void ChangeViewDirection()
 {
     if (Mathf.Abs(direction.x) > Mathf.Abs(direction.y))
     {
         if (direction.x > 0.0f)
         {
             viewRange.transform.rotation = Quaternion.Euler(0, 0, 270);
             viewDirection = ViewDirection.right;
         }
         else if (direction.x < 0.0f)
         {
             viewRange.transform.rotation = Quaternion.Euler(0, 0, 90);
             viewDirection = ViewDirection.left;
         }
     }
     else
     {
         if (direction.y > 0.0f)
         {
             viewRange.transform.rotation = Quaternion.Euler(0, 0, 0);
             viewDirection = ViewDirection.up;
         }
         else if (direction.y < 0.0f)
         {
             viewRange.transform.rotation = Quaternion.Euler(0, 0, 180);
             viewDirection = ViewDirection.down;
         }
     }
 }
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            Cuboid        cuboid        = (Cuboid)values[0];
            ViewDirection viewDirection = (ViewDirection)values[1];
            bool          fullSize      = (bool)values[2];
            int           factor        = fullSize ? Settings.LargeFactor : Settings.SmallFactor;

            if (cuboid.FromSelection && !cuboid.IsDragged)
            {
                return(fullSize ? Settings.LargeFactor : 0.0);
            }

            switch (viewDirection)
            {
            case ViewDirection.TopView:
            case ViewDirection.FrontView:
            case ViewDirection.BackView:
                return((double)(factor * cuboid.Width));

            case ViewDirection.LeftView:
            case ViewDirection.RightView:
                return((double)(factor * cuboid.Depth));

            default:
                return((double)(factor * cuboid.Width));
            }
        }
Example #10
0
    private void TurnAround()
    {
        switch (viewDirection)
        {
        case ViewDirection.up:
            viewRange.transform.rotation = Quaternion.Euler(0, 0, 180);
            viewDirection = ViewDirection.down;
            break;

        case ViewDirection.down:
            viewRange.transform.rotation = Quaternion.Euler(0, 0, 0);
            viewDirection = ViewDirection.up;
            break;

        case ViewDirection.right:
            viewRange.transform.rotation = Quaternion.Euler(0, 0, 90);
            viewDirection = ViewDirection.left;
            break;

        case ViewDirection.left:
            viewRange.transform.rotation = Quaternion.Euler(0, 0, 270);
            viewDirection = ViewDirection.right;
            break;

        default:
            break;
        }
    }
Example #11
0
        public BarShape11(Drawing drawing, Dimensions dimensions, ViewDirection viewDirection)
        {
            Drawing       = drawing;
            Dimensions    = dimensions;
            ViewDirection = viewDirection;

            Parts = new List <IFigure>();
        }
Example #12
0
 public Viewport2D(ViewDirection direction, RenderContext context)
     : base(context)
 {
     Zoom = 1;
     Position = new Coordinate(0, 0, 0);
     Direction = direction;
     CenterScreen = new Coordinate(Width / 2m, Height / 2m, 0);
 }
Example #13
0
        public BarShape13(Drawing drawing, Dimensions dimensions, ViewDirection viewDirection, Point _insertPoint)
        {
            Drawing       = drawing;
            Dimensions    = dimensions;
            ViewDirection = viewDirection;

            Parts            = new List <IFigure>();
            DependencyPoints = new List <Point>();
        }
Example #14
0
        /// <summary>
        /// Moves the camera to the midpoint of all the specified occurrences. Used in the wizard to point out the specified occurence.
        /// </summary>
        /// <param name="occurrences">The <see cref="ComponentOccurrence"/>s for the <see cref="Camera"/> to focus on</param>
        /// <param name="viewDistance">The distence from <paramref name="occurrence"/> that the camera will be</param>
        /// <param name="camera"></param>
        /// <param name="zoom"></param>
        /// <param name="viewDirection">The direction of the camera</param>
        /// <param name="animate">True if you want to animate the camera moving to the new position</param>
        public static void FocusCameraOnOccurrences(List <ComponentOccurrence> occurrences, double viewDistance, Camera camera, double zoom,
                                                    ViewDirection viewDirection = ViewDirection.Y, bool animate = false)
        {
            if (occurrences.Count < 1)
            {
                return;
            }

            var translation = GetOccurrencesCenter(occurrences);

            SetCameraView(translation, viewDistance, camera, zoom, viewDirection, animate);
        }
Example #15
0
    private void rotateViewBasedOnVelocityAndUpdateViewDirection(Vector3 velocity)
    {
        if (velocity.sqrMagnitude > 0f && animator)
        {
            animator.SetBool("isMoving", true);
        }
        else if (velocity.sqrMagnitude <= 0f && animator)
        {
            animator.SetBool("isMoving", false);
        }

        float degreeAngleToDirection = Mathf.Atan2(velocity.y, velocity.x) * 180f / Mathf.PI;

        viewPivot.rotation = Quaternion.Euler(0, 0, degreeAngleToDirection);


        //update viewDirection variable

        if (degreeAngleToDirection < 0f)
        {
            degreeAngleToDirection += 360f;
        }
        else if (degreeAngleToDirection > 360f)
        {
            degreeAngleToDirection -= 360f;
        }

        if (degreeAngleToDirection < 45f || degreeAngleToDirection >= 315f)
        {
            viewDirection = ViewDirection.Right;
        }
        else if (degreeAngleToDirection < 135f && degreeAngleToDirection >= 45f)
        {
            viewDirection = ViewDirection.Up;
        }
        else if (degreeAngleToDirection < 225f && degreeAngleToDirection >= 135f)
        {
            viewDirection = ViewDirection.Left;
        }
        else if (degreeAngleToDirection < 315f && degreeAngleToDirection >= 225f)
        {
            viewDirection = ViewDirection.Down;
        }
        if (animator)
        {
            animator.SetInteger("View Direction", (int)viewDirection);
        }
    }
Example #16
0
        private static Coordinate GetUnusedCoordinate(Coordinate c, ViewDirection direction)
        {
            switch (direction)
            {
            case ViewDirection.Top:
                return(new Coordinate(0, 0, c.Z));

            case ViewDirection.Front:
                return(new Coordinate(c.X, 0, 0));

            case ViewDirection.Side:
                return(new Coordinate(0, c.Y, 0));

            default:
                throw new ArgumentOutOfRangeException("direction");
            }
        }
Example #17
0
        private static Matrix4 GetMatrixFor(ViewDirection dir)
        {
            switch (dir)
            {
            case ViewDirection.Top:
                return(TopMatrix);

            case ViewDirection.Front:
                return(FrontMatrix);

            case ViewDirection.Side:
                return(SideMatrix);

            default:
                throw new ArgumentOutOfRangeException("dir");
            }
        }
Example #18
0
        private void View_Checked(object sender, RoutedEventArgs e)
        {
            try
            {
                if (!_isInitialized)
                {
                    return;
                }

                if (radViewFront.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Front;
                }
                else if (radViewRight.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Right;
                }
                else if (radViewLeft.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Left;
                }
                else if (radViewTop.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Top;
                }
                else if (radViewBottom.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Bottom;
                }
                else if (radViewBack.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Back;
                }
                else
                {
                    throw new ApplicationException("Unknown view direction");
                }

                SetVelocityViewerCameraPosition();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
Example #19
0
        public static void ResetZIndexes(Canvas canvas, ViewDirection viewDirection)
        {
            foreach (UIElement child in canvas.Children)
            {
                int zIndex = 0;
                if (child is CuboidControl)
                {
                    CuboidControl cuboidControl = child as CuboidControl;
                    switch (viewDirection)
                    {
                    case ViewDirection.TopView:
                        zIndex = cuboidControl.Cuboid.Z;
                        break;

                    case ViewDirection.FrontView:
                        zIndex = Settings.MaxSize - cuboidControl.Cuboid.Y;
                        break;

                    case ViewDirection.BackView:
                        zIndex = cuboidControl.Cuboid.Y;
                        break;

                    case ViewDirection.LeftView:
                        zIndex = Settings.MaxSize - cuboidControl.Cuboid.X;
                        break;

                    case ViewDirection.RightView:
                        zIndex = cuboidControl.Cuboid.X;
                        break;
                    }
                }
                else
                {
                    zIndex = Settings.MaxSize + 1;
                }
                Canvas.SetZIndex(child, zIndex);
            }
        }
Example #20
0
 private void RotateViewDirection()
 {
     if (viewDirection == ViewDirection.Right)
     {
         viewDirection = ViewDirection.Up;
     }
     else if (viewDirection == ViewDirection.Up)
     {
         viewDirection = ViewDirection.Left;
     }
     else if (viewDirection == ViewDirection.Left)
     {
         viewDirection = ViewDirection.Down;
     }
     else //(viewDirection == ViewDirection.Down)
     {
         viewDirection = ViewDirection.Right;
     }
     if (animator)
     {
         animator.SetInteger("View Direction", (int)viewDirection);
     }
 }
 private void rightRotation_Tapped(object sender, TappedRoutedEventArgs e)
 {
     UserViewDirection = (ViewDirection)Mod((int)UserViewDirection + 1, 4);
     ChangeDirections();
 }
Example #22
0
    // Update is called once per frame
    void Update()
    {
        float hAxis = Input.GetAxis("Horizontal");
        float vAxis = Input.GetAxis("Vertical");
        if (hAxis != 0) {
            if (hAxis < -0.1f && viewRef == ViewDirection.right){
                viewRef = ViewDirection.left;
                //enemiesList = new List<GameObject>();
                Debug.Log("looking for left side enemies");
                //areaTargetRef.localScale = new Vector2(-1f, 1f);
                actualTarget = GetClosestEnemy(enemiesList);
            }
            if (hAxis > 0.1f && viewRef == ViewDirection.left)
            {
                viewRef = ViewDirection.right;
                Debug.Log("looking for right side enemies");
                //enemiesList = new List<GameObject>();
                //areaTargetRef.localScale = new Vector2(1f, 1f);
            }
            actualTarget = GetClosestEnemy(enemiesList);

            if (actualTarget != null) {
                targetName = actualTarget.GetComponent<EnemyScript>().eName;
            }
        }

        if (Input.GetButtonDown("Jump")) {
            FindObjectOfType<PlayerMovement>().spelling_flag = true;
        }
        else if  (Input.GetButtonUp("Jump")){
            FindObjectOfType<PlayerMovement>().spelling_flag = false;
        }
    }
 private void rightRotation_Tapped(object sender, TappedRoutedEventArgs e)
 {
     UserViewDirection = (ViewDirection)Mod((int)UserViewDirection + 1, 4);
     ChangeDirections();
 }
        private static void DrawField(WriteableBitmap bitmap, FluidField3D field, ViewDirection viewDirection, byte[] colorZFront, byte[] colorZBack)
        {
            Int32Rect rect = new Int32Rect(0, 0, field.Size, field.Size);
            int size = rect.Width * rect.Height * 4;
            byte[] pixels = new byte[size];

            double[] ink = field.Ink;
            bool[] blocked = field.Blocked;

            switch (viewDirection)
            {
                case ViewDirection.Front:
                    #region Front

                    DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                        new AxisFor(Axis.X, 0, field.Size - 1),
                        new AxisFor(Axis.Y, 0, field.Size - 1),
                        new AxisFor(Axis.Z, field.Size - 1, 0));        // pixel z needs to start at the back, because the colors are overlaid

                    #endregion
                    break;

                case ViewDirection.Right:
                    #region Right

                    DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                        new AxisFor(Axis.Z, 0, field.Size - 1),
                        new AxisFor(Axis.Y, 0, field.Size - 1),
                        new AxisFor(Axis.X, 0, field.Size - 1));

                    #endregion
                    break;

                case ViewDirection.Left:
                    #region Left

                    DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                        new AxisFor(Axis.Z, field.Size - 1, 0),
                        new AxisFor(Axis.Y, 0, field.Size - 1),
                        new AxisFor(Axis.X, field.Size - 1, 0));

                    #endregion
                    break;

                case ViewDirection.Top:
                    #region Top

                    DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                        new AxisFor(Axis.X, 0, field.Size - 1),
                        new AxisFor(Axis.Z, field.Size - 1, 0),
                        new AxisFor(Axis.Y, field.Size - 1, 0));

                    #endregion
                    break;

                case ViewDirection.Bottom:
                    #region Bottom

                    DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                        new AxisFor(Axis.X, 0, field.Size - 1),
                        new AxisFor(Axis.Z, 0, field.Size - 1),
                        new AxisFor(Axis.Y, 0, field.Size - 1));

                    #endregion
                    break;

                case ViewDirection.Back:
                    #region Back

                    //NOTE: This one is up for interpretation.  I will rotate left to right, because I think that is more intuitive.  If rotating
                    //top to bottom, it would be upside down from the way I am presenting
                    DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                        new AxisFor(Axis.X, field.Size - 1, 0),
                        new AxisFor(Axis.Y, 0, field.Size - 1),
                        new AxisFor(Axis.Z, 0, field.Size - 1));

                    // The alternate
                    //DrawField_DoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                    //    new AxisFor(Axis.X, 0, field.Size - 1),
                    //    new AxisFor(Axis.Y, field.Size - 1, 0),
                    //    new AxisFor(Axis.Z, 0, field.Size - 1));

                    #endregion
                    break;

                default:
                    throw new ApplicationException("Unknown ViewDirection: " + viewDirection.ToString());
            }

            bitmap.WritePixels(rect, pixels, rect.Width * 4, 0);
        }
Example #25
0
		/// <summary>
		/// Sets the camera view direction.
		/// </summary>
		public void SetViewDirection(ViewDirection direction)
		{
			lastDirection = direction;
			GetDirectionVectors(direction, out _center, out _position, out _upVec);
			RecomputeUpVector();
//			_scene.Resize();
			_scene.OnDirectionChanged();
		}
Example #26
0
        /// <summary>
        /// Sets the position and target of the camera.
        /// </summary>
        /// <param name="focus">Point that camera should look at.</param>
        /// <param name="viewDistance">Distance the camera should be from that point</param>
        /// <param name="camera"></param>
        /// <param name="zoom"></param>
        /// <param name="viewDirection">Direction to view the point from.</param>
        /// <param name="animate">True to animate movement of camera.</param>
        public static void SetCameraView(Vector focus, double viewDistance, double width, double height, Camera camera, ViewDirection viewDirection = ViewDirection.Y, bool animate = true)
        {
            Point focusPoint = RobotExporterAddInServer.Instance.Application.TransientGeometry.CreatePoint(focus.X, focus.Y, focus.Z);

            camera.SetExtents(width, height);

            camera.Target = focusPoint;

            // Flip view for negative direction
            if ((viewDirection & ViewDirection.Negative) == ViewDirection.Negative)
            {
                viewDistance = -viewDistance;
            }

            UnitVector up = null;

            // Find camera position and upwards direction
            if ((viewDirection & ViewDirection.X) == ViewDirection.X)
            {
                focus.X += viewDistance;
                up       = RobotExporterAddInServer.Instance.Application.TransientGeometry.CreateUnitVector(0, 1, 0);
            }

            if ((viewDirection & ViewDirection.Y) == ViewDirection.Y)
            {
                focus.Y += viewDistance;
                up       = RobotExporterAddInServer.Instance.Application.TransientGeometry.CreateUnitVector(0, 0, 1);
            }

            if ((viewDirection & ViewDirection.Z) == ViewDirection.Z)
            {
                focus.Z += viewDistance;
                up       = RobotExporterAddInServer.Instance.Application.TransientGeometry.CreateUnitVector(0, 1, 0);
            }

            camera.Eye      = RobotExporterAddInServer.Instance.Application.TransientGeometry.CreatePoint(focus.X, focus.Y, focus.Z);
            camera.UpVector = up;

            // Apply settings
            if (animate)
            {
                camera.Apply();
            }
            else
            {
                camera.ApplyWithoutTransition();
            }
        }
Example #27
0
 private static Coordinate ZeroUnusedCoordinate(Coordinate c, ViewDirection direction)
 {
     switch (direction)
     {
         case ViewDirection.Top:
             return new Coordinate(c.X, c.Y, 0);
         case ViewDirection.Front:
             return new Coordinate(0, c.Y, c.Z);
         case ViewDirection.Side:
             return new Coordinate(c.X, 0, c.Z);
         default:
             throw new ArgumentOutOfRangeException("direction");
     }
 }
Example #28
0
 private static Matrix4 GetMatrixFor(ViewDirection dir)
 {
     switch (dir)
     {
         case ViewDirection.Top:
             return TopMatrix;
         case ViewDirection.Front:
             return FrontMatrix;
         case ViewDirection.Side:
             return SideMatrix;
         default:
             throw new ArgumentOutOfRangeException("dir");
     }
 }
Example #29
0
        private static void DrawField(WriteableBitmap bitmap, FluidField3D field, ViewDirection viewDirection, byte[] colorZFront, byte[] colorZBack)
        {
            Int32Rect rect = new Int32Rect(0, 0, field.Size, field.Size);
            int       size = rect.Width * rect.Height * 4;

            byte[] pixels = new byte[size];

            double[] ink     = field.Ink;
            bool[]   blocked = field.Blocked;

            switch (viewDirection)
            {
            case ViewDirection.Front:
                #region Front

                DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                                  new AxisFor(Axis.X, 0, field.Size - 1),
                                  new AxisFor(Axis.Y, 0, field.Size - 1),
                                  new AxisFor(Axis.Z, field.Size - 1, 0)); // pixel z needs to start at the back, because the colors are overlaid

                #endregion
                break;

            case ViewDirection.Right:
                #region Right

                DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                                  new AxisFor(Axis.Z, 0, field.Size - 1),
                                  new AxisFor(Axis.Y, 0, field.Size - 1),
                                  new AxisFor(Axis.X, 0, field.Size - 1));

                #endregion
                break;

            case ViewDirection.Left:
                #region Left

                DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                                  new AxisFor(Axis.Z, field.Size - 1, 0),
                                  new AxisFor(Axis.Y, 0, field.Size - 1),
                                  new AxisFor(Axis.X, field.Size - 1, 0));

                #endregion
                break;

            case ViewDirection.Top:
                #region Top

                DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                                  new AxisFor(Axis.X, 0, field.Size - 1),
                                  new AxisFor(Axis.Z, field.Size - 1, 0),
                                  new AxisFor(Axis.Y, field.Size - 1, 0));

                #endregion
                break;

            case ViewDirection.Bottom:
                #region Bottom

                DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                                  new AxisFor(Axis.X, 0, field.Size - 1),
                                  new AxisFor(Axis.Z, 0, field.Size - 1),
                                  new AxisFor(Axis.Y, 0, field.Size - 1));

                #endregion
                break;

            case ViewDirection.Back:
                #region Back

                //NOTE: This one is up for interpretation.  I will rotate left to right, because I think that is more intuitive.  If rotating
                //top to bottom, it would be upside down from the way I am presenting
                DrawFieldSprtDoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                                  new AxisFor(Axis.X, field.Size - 1, 0),
                                  new AxisFor(Axis.Y, 0, field.Size - 1),
                                  new AxisFor(Axis.Z, 0, field.Size - 1));

                // The alternate
                //DrawField_DoIt(pixels, ink, blocked, field.Size, colorZFront, colorZBack,
                //    new AxisFor(Axis.X, 0, field.Size - 1),
                //    new AxisFor(Axis.Y, field.Size - 1, 0),
                //    new AxisFor(Axis.Z, 0, field.Size - 1));

                #endregion
                break;

            default:
                throw new ApplicationException("Unknown ViewDirection: " + viewDirection.ToString());
            }

            bitmap.WritePixels(rect, pixels, rect.Width * 4, 0);
        }
Example #30
0
    // Update is called once per frame
    void Update()
    {
        // /*for debugging fieldOfView
        //  * will delete when testing is done
        // */
        // Vector3 mousePosition = Input.mousePosition;
        // Vector3 mousePositionInWorld = Camera.main.ScreenToWorldPoint(mousePosition);
        // Vector3 directionFromPlayerToMouse = mousePositionInWorld - transform.position;
        // float radiansToMouse = Mathf.Atan2(directionFromPlayerToMouse.y, directionFromPlayerToMouse.x);
        // float angleToMouse = radiansToMouse * 180f / Mathf.PI;
        // fieldOfView.setDirection(angleToMouse);
        // fieldOfView.setOrigin(transform.position);

        if (animator)
        {
            animator.SetBool("isMoving", false);
            animator.SetInteger("Role", (int)role);
            animator.SetInteger("View Direction", (int)viewDirection);
        }

        //directional movement with a-s-d-w
        Vector3 deltaVect = new Vector3(0, 0, 0);

        if (Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.LeftArrow))
        {
            Vector3 tempVect = new Vector3(-1, 0, 0);
            deltaVect += tempVect.normalized * SPEED * Time.deltaTime;

            viewDirection = ViewDirection.Left;
            if (animator)
            {
                animator.SetBool("isMoving", true);
                animator.SetInteger("View Direction", (int)viewDirection);
            }
        }
        if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow))
        {
            Vector3 tempVect = new Vector3(1, 0, 0);
            tempVect   = tempVect.normalized * SPEED * Time.deltaTime;
            deltaVect += tempVect.normalized * SPEED * Time.deltaTime;

            viewDirection = ViewDirection.Right;
            if (animator)
            {
                animator.SetBool("isMoving", true);
                animator.SetInteger("View Direction", (int)viewDirection);
            }
        }
        if (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.UpArrow))
        {
            Vector3 tempVect = new Vector3(0, 1, 0);
            tempVect   = tempVect.normalized * SPEED * Time.deltaTime;
            deltaVect += tempVect.normalized * SPEED * Time.deltaTime;

            viewDirection = ViewDirection.Up;
            if (animator)
            {
                animator.SetBool("isMoving", true);
                animator.SetInteger("View Direction", (int)viewDirection);
            }
        }
        if (Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.DownArrow))
        {
            Vector3 tempVect = new Vector3(0, -1, 0);
            tempVect   = tempVect.normalized * SPEED * Time.deltaTime;
            deltaVect += tempVect.normalized * SPEED * Time.deltaTime;

            viewDirection = ViewDirection.Down;
            if (animator)
            {
                animator.SetBool("isMoving", true);
                animator.SetInteger("View Direction", (int)viewDirection);
            }
        }
        rb.MovePosition(transform.position + deltaVect);
        if (npcsInRange.Count != 0)
        {
            findClosestRole();
        }
        else
        {
            closestRole = Role.Player;
        }

        //change player sprites to fit colors
        //can take out some colors or add refresh time
        if (Input.GetKeyDown(KeyCode.Space))
        {
            //sr.sprite = getSprite(closestRole);
            if (npcsInRange.Count != 0 && closestRole != role)
            {
                updateRoleAndSprite();
                canChangeRole = false;
                ChangeRoleEvent.Invoke();
            }
        }

        if (GameComplete)
        {
            viewDirection = ViewDirection.Down;
            animator.SetBool("isMoving", false);
            animator.SetInteger("View Direction", (int)viewDirection);
            transform.position = Vector3.zero;
        }
    }
Example #31
0
        /// <summary>
        /// Sets the position and target of the camera.
        /// </summary>
        /// <param name="focus">Point that camera should look at.</param>
        /// <param name="viewDistance">Distance the camera should be from that point</param>
        /// <param name="camera"></param>
        /// <param name="zoom"></param>
        /// <param name="viewDirection">Direction to view the point from.</param>
        /// <param name="animate">True to animate movement of camera.</param>
        public static void SetCameraView(Vector focus, double viewDistance, Camera camera, double zoom, ViewDirection viewDirection = ViewDirection.Y, bool animate = true)
        {
            camera.Fit(); // TODO: Determine model size properly
            camera.GetExtents(out var width, out var height);

            SetCameraView(focus, viewDistance, height * zoom, height * zoom, camera, viewDirection, animate);
        }
Example #32
0
		/// <summary>
		/// Animates to the given view direction.
		/// </summary>
		/// <param name="direction"></param>
		public void AnimateTo(ViewDirection direction)
		{
			Vector center, position, upVec;
			GetDirectionVectors(direction, out center, out position, out upVec);
			AnimateTo(center, position, upVec);
			lastDirection = direction;
		}
        private void View_Checked(object sender, RoutedEventArgs e)
        {
            try
            {
                if (!_isInitialized)
                {
                    return;
                }

                if (radViewFront.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Front;
                }
                else if (radViewRight.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Right;
                }
                else if (radViewLeft.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Left;
                }
                else if (radViewTop.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Top;
                }
                else if (radViewBottom.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Bottom;
                }
                else if (radViewBack.IsChecked.Value)
                {
                    _viewDirection = ViewDirection.Back;
                }
                else
                {
                    throw new ApplicationException("Unknown view direction");
                }

                SetVelocityViewerCameraPosition();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
Example #34
0
		/// <summary>
		/// Gets the view vectors for the given view position.
		/// </summary>
		/// <param name="direction"> A <see cref="ViewDirection"/>./ </param>
		/// <param name="centerOut"> The center. </param>
		/// <param name="posOut"> The position. </param>
		/// <param name="upVecOut"> The up vector. </param>
		public void GetDirectionVectors(ViewDirection direction, out Vector centerOut, out Vector posOut, out Vector upVecOut)
		{
//			_scene.RenderList.ResetBounds();
			Bounds bounds = _scene.RenderList.Bounds;
			
			// determine the distance needed to view all renderables
			double dist = 0;
			if (_scene.RenderList.ActorCount > 0 && bounds.IsSet)
			{
				dist = bounds.MaxWidth / (fov * 0.5).Tan();				
				centerOut = bounds.Center;
			}
			else
			{
				dist = 1 / (fov * 0.5).Tan();
				centerOut = new Vector();
			}
			
			Vector travel;
			switch (direction)
			{
			case ViewDirection.Front:
				travel = new Vector(0, -1, 0);
				upVecOut = new Vector(0, 0, 1);
				break;
			case ViewDirection.Back:
				travel = new Vector(0, 1, 0);
				upVecOut = new Vector(0, 0, 1);
				break;
			case ViewDirection.Left:
				travel = new Vector(-1, 0, 0);
				upVecOut = new Vector(0, 0, 1);
				break;
			case ViewDirection.Right:
				travel = new Vector(1, 0, 0);
				upVecOut = new Vector(0, 0, 1);
				break;
			case ViewDirection.Top:
				travel = new Vector(0, 0, 1);
				upVecOut = new Vector(0, 1, 0);
				break;
			case ViewDirection.Bottom:
				travel = new Vector(0, 0, -1);
				upVecOut = new Vector(0, 1, 0);
				break;
			default:
				travel = new Vector(1, -1, 0.5);
				travel.Normalize();
				dist = 0.8 * dist;
				upVecOut = new Vector(0, 0, 1);
				break;
			}
			posOut = (travel * dist) + centerOut;
		}
        /// <summary>
        /// This takes the click point, and returns a point from 0 to 1
        /// </summary>
        private static Point3D GetScaledPoint(MouseEventArgs e, FrameworkElement relativeTo, double depth, ViewDirection direction)
        {
            Point clickPoint = e.GetPosition(relativeTo);

            double width = relativeTo.ActualWidth;
            double height = relativeTo.ActualHeight;

            if (Math1D.IsNearZero(width) || Math1D.IsNearZero(height))
            {
                // The window has no size
                return new Point3D(0, 0, 0);
            }

            Point3D point = new Point3D(clickPoint.X / width, clickPoint.Y / height, depth);

            switch (direction)
            {
                case ViewDirection.Front:
                    return new Point3D(point.X, point.Y, point.Z);

                case ViewDirection.Right:
                    return new Point3D(1d - point.Z, point.Y, point.X);

                case ViewDirection.Left:
                    return new Point3D(point.Z, point.Y, 1d - point.X);

                case ViewDirection.Top:
                    return new Point3D(point.X, point.Z, 1d - point.Y);

                case ViewDirection.Bottom:
                    return new Point3D(point.X, 1d - point.Z, point.Y);

                case ViewDirection.Back:
                    return new Point3D(1d - point.X, point.Y, 1d - point.Z);

                default:
                    throw new ApplicationException("Unknown ViewDirection: " + direction.ToString());
            }
        }
Example #36
0
        /// <summary>
        /// This takes the click point, and returns a point from 0 to 1
        /// </summary>
        private static Point3D GetScaledPoint(MouseEventArgs e, FrameworkElement relativeTo, double depth, ViewDirection direction)
        {
            Point clickPoint = e.GetPosition(relativeTo);

            double width  = relativeTo.ActualWidth;
            double height = relativeTo.ActualHeight;

            if (Math1D.IsNearZero(width) || Math1D.IsNearZero(height))
            {
                // The window has no size
                return(new Point3D(0, 0, 0));
            }

            Point3D point = new Point3D(clickPoint.X / width, clickPoint.Y / height, depth);

            switch (direction)
            {
            case ViewDirection.Front:
                return(new Point3D(point.X, point.Y, point.Z));

            case ViewDirection.Right:
                return(new Point3D(1d - point.Z, point.Y, point.X));

            case ViewDirection.Left:
                return(new Point3D(point.Z, point.Y, 1d - point.X));

            case ViewDirection.Top:
                return(new Point3D(point.X, point.Z, 1d - point.Y));

            case ViewDirection.Bottom:
                return(new Point3D(point.X, 1d - point.Z, point.Y));

            case ViewDirection.Back:
                return(new Point3D(1d - point.X, point.Y, 1d - point.Z));

            default:
                throw new ApplicationException("Unknown ViewDirection: " + direction.ToString());
            }
        }
Example #37
0
    void Update()
    {
        if (IngameHandlerBehaviour.Instance.Handler.ActiveTimeLayer != TimeLayer.First)
        {
            return;
        }

        if (drawDebug)
        {
            Debug.DrawLine(new Vector3(cam.transform.position.x - border, transform.position.y + 2, transform.position.z),
                           new Vector3(cam.transform.position.x - border, transform.position.y - 2, transform.position.z));

            Debug.DrawLine(new Vector3(cam.transform.position.x + border, transform.position.y + 2, transform.position.z),
                           new Vector3(cam.transform.position.x + border, transform.position.y - 2, transform.position.z));
        }

        if (oldViewDirection != viewDirection)
        {
            datRunningVar    = 0;
            viewChanged      = true;
            oldViewDirection = viewDirection;
        }

        float lerpedCameraX = 0;

        if (viewChanged && viewDirection == ViewDirection.LEFT)
        {
            datRunningVar += cameraChangeSpeed * Time.deltaTime;
            lerpedCameraX  = Mathf.Lerp(cam.transform.position.x, transform.position.x + border, datRunningVar);

            if (datRunningVar >= 1)
            {
                datRunningVar = 0;
                viewChanged   = false;
            }
        }
        else if (viewChanged && viewDirection == ViewDirection.RIGHT)
        {
            datRunningVar += cameraChangeSpeed * Time.deltaTime;
            lerpedCameraX  = Mathf.Lerp(cam.transform.position.x, transform.position.x - border, datRunningVar);

            if (datRunningVar >= 1)
            {
                datRunningVar = 0;
                viewChanged   = false;
            }
        }
        else
        {
            if (viewDirection == ViewDirection.LEFT)
            {
                lerpedCameraX = transform.position.x + border;
            }
            else
            {
                lerpedCameraX = transform.position.x - border;
            }
        }

        oldViewDirection = viewDirection;

        cam.transform.position = new Vector3(lerpedCameraX, transform.position.y, cam.transform.position.z);
    }