protected override Vector3 DrawHandle(int index, Vector3 vector3, out Handler.DragHandleResult dhResult)
        {
            Handles.DrawSolidDisc(vector3, Vector3.forward, 0.2f);

            if (SelectedVectors.Contains(index))
            {
                Handles.color = Color.black;
                Handles.DrawSolidDisc(vector3, new Vector3(0, 0, 1), 0.1f);
                Handles.color = Color.white;
            }

            Handles.color = Color.white;
            return(Handler.DragHandle(vector3, 0.2f, Color.green, out dhResult));
        }
        /// <summary>
        /// Checks if there's an event triggered to change the vectorList
        /// </summary>
        /// <param name="dhResult"></param>
        /// <param name="vectorIndex"></param>
        /// <param name="secondVector3"></param>
        private void HandleKnob(Handler.DragHandleResult dhResult, int vectorIndex, Vector3 secondVector3)
        {
            if (dhResult == Handler.DragHandleResult.none)
            {
                return;
            }

            switch (dhResult)
            {
            case Handler.DragHandleResult.LMBRelease:

                StartMovingCircleLMB = false;

                break;

            case Handler.DragHandleResult.LMBDrag:

                var clearAtEnd = false;

                if (StartMovingCircleLMB == false)
                {
                    Undo.RecordObject(target, "Moving vertex");
                    StartMovingCircleLMB = true;
                }

                if (!SelectedVectors.Any() || !SelectedVectors.Contains(vectorIndex))
                {
                    SelectedVectors = new List <int>()
                    {
                        vectorIndex
                    };
                    clearAtEnd = true;
                }

                if (VectorListTarget.CanMoveVertex(SelectedVectors, secondVector3))
                {
                    MoveVertex(vectorIndex, SelectedVectors, secondVector3);
                }

                if (clearAtEnd)
                {
                    ClearSelectedVectors();
                }

                break;

            case Handler.DragHandleResult.RMBDrag:
                if (VectorListTarget.CanInsertVertex(secondVector3))
                {
                    if (CanCreateCircle)
                    {
                        StartCirclePosition = VectorListTarget.GetWorldVectorCoord(vectorIndex);

                        int nextIndex     = VectorListTarget.LocalVector3Coords.NextIndex(vectorIndex);
                        int previousIndex = VectorListTarget.LocalVector3Coords.PreviousIndex(vectorIndex);

                        DistanceChecker.InitialNextVertexDistance =
                            DistanceChecker.CheckDistance(StartCirclePosition,
                                                          VectorListTarget.GetWorldVectorCoord(nextIndex));
                        DistanceChecker.InitialPreviousVertexDistance =
                            DistanceChecker.CheckDistance(StartCirclePosition,
                                                          VectorListTarget.GetWorldVectorCoord(previousIndex));

                        CreatingCircle  = true;
                        CanCreateCircle = false;
                        MovingCircle    = false;
                    }
                    else if (CreatingCircle && CreationMovingDistanceReached(secondVector3))
                    {
                        int nextIndex     = VectorListTarget.LocalVector3Coords.NextIndex(vectorIndex);
                        int previousIndex = VectorListTarget.LocalVector3Coords.PreviousIndex(vectorIndex);

                        DistanceChecker.FinalNextVertexDistance = DistanceChecker.CheckDistance(secondVector3,
                                                                                                VectorListTarget.GetWorldVectorCoord(nextIndex));
                        DistanceChecker.FinalPreviousVertexDistance = DistanceChecker.CheckDistance(secondVector3,
                                                                                                    VectorListTarget.GetWorldVectorCoord(previousIndex));

                        InsertVertex(vectorIndex, secondVector3);
                        CreatingCircle = false;
                        MovingCircle   = true;
                    }
                    else if (MovingCircle)
                    {
                        MoveVertex(vectorIndex, new List <int>()
                        {
                            vectorIndex
                        }, secondVector3);
                    }
                }

                break;

            case Handler.DragHandleResult.RMBRelease:
                ClearSelectedVectors();
                CanCreateCircle = true;
                MovingCircle    = false;
                ResetVertexOrderList();
                break;

            case Handler.DragHandleResult.LMBDoubleClick:

                if (VectorListTarget.CanDeleteVertex(vectorIndex))
                {
                    DeleteVertex(vectorIndex);
                }

                ClearSelectedVectors();
                break;

            case Handler.DragHandleResult.LMBClick:

                if (Event.current.control)
                {
                    // Unselect element
                    if (SelectedVectors.Contains(vectorIndex))
                    {
                        SelectedVectors.Remove(vectorIndex);
                    }
                    // Select element
                    else
                    {
                        SelectedVectors.Add(vectorIndex);
                    }
                }
                else
                {
                    ClearSelectedVectors();
                }

                break;
            }
        }
 protected abstract Vector3 DrawHandle(int index, Vector3 vector3, out Handler.DragHandleResult dhResult);
Пример #4
0
 protected override Vector3 DrawHandle(int index, Vector3 vector3, out Handler.DragHandleResult dhResult)
 {
     Handles.DrawSolidDisc(vector3, Vector3.forward, 0.2f);
     return(Handler.DragHandle(vector3, 0.2f, Color.green, out dhResult));
 }
        protected override Vector3 DrawHandle(int index, Vector3 vector3, out Handler.DragHandleResult dhResult)
        {
            Handles.SphereHandleCap(vector3.GetHashCode(), vector3, Quaternion.identity, 0.2f, EventType.Repaint);

            return(Handler.DragHandle(vector3, 0.1f, Color.green, out dhResult));
        }