//This helps keep the size consistent no matter how far we are from it.
 float GetDistanceMultiplier()
 {
     if (mainTargetRoot == null)
     {
         return(0f);
     }
     return(Mathf.Max(.01f, Mathf.Abs(ExtVector3.MagnitudeInDirection(pivotPoint - transform.position, myCamera.transform.forward))));
 }
Пример #2
0
        //Assumes the point is already on the line somewhere
        public static Vector3 ClampToSegment(Vector3 point, Vector3 linePoint1, Vector3 linePoint2)
        {
            Vector3 lineDirection = linePoint2 - linePoint1;

            if (!ExtVector3.IsInDirection(point - linePoint1, lineDirection))
            {
                point = linePoint1;
            }
            else if (ExtVector3.IsInDirection(point - linePoint2, lineDirection))
            {
                point = linePoint2;
            }

            return(point);
        }
 int AxisDirectionMultiplier(Vector3 direction, Vector3 otherDirection)
 {
     return(ExtVector3.IsInDirection(direction, otherDirection) ? 1 : -1);
 }
        IEnumerator TransformSelected(TransformType type)
        {
            isTransforming      = true;
            totalScaleAmount    = 0;
            totalRotationAmount = Quaternion.identity;

            Vector3 originalPivot = pivotPoint;

            Vector3 planeNormal           = (transform.position - originalPivot).normalized;
            Vector3 axis                  = GetNearAxisDirection();
            Vector3 projectedAxis         = Vector3.ProjectOnPlane(axis, planeNormal).normalized;
            Vector3 previousMousePosition = Vector3.zero;

            List <ICommand> transformCommands = new List <ICommand>();

            for (int i = 0; i < targetRootsOrdered.Count; i++)
            {
                transformCommands.Add(new TransformCommand(this, targetRootsOrdered[i]));
            }

            while (!Input.GetMouseButtonUp(0))
            {
                Ray     mouseRay      = myCamera.ScreenPointToRay(Input.mousePosition);
                Vector3 mousePosition = Geometry.LinePlaneIntersect(mouseRay.origin, mouseRay.direction, originalPivot, planeNormal);

                if (previousMousePosition != Vector3.zero && mousePosition != Vector3.zero)
                {
                    if (type == TransformType.Move)
                    {
                        float   moveAmount = ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projectedAxis) * moveSpeedMultiplier;
                        Vector3 movement   = axis * moveAmount;

                        for (int i = 0; i < targetRootsOrdered.Count; i++)
                        {
                            Transform target = targetRootsOrdered[i];

                            target.Translate(movement, Space.World);
                        }

                        SetPivotPointOffset(movement);
                    }
                    else if (type == TransformType.Scale)
                    {
                        Vector3 projected   = (nearAxis == Axis.Any) ? transform.right : projectedAxis;
                        float   scaleAmount = ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projected) * scaleSpeedMultiplier;

                        //WARNING - There is a bug in unity 5.4 and 5.5 that causes InverseTransformDirection to be affected by scale which will break negative scaling. Not tested, but updating to 5.4.2 should fix it - https://issuetracker.unity3d.com/issues/transformdirection-and-inversetransformdirection-operations-are-affected-by-scale
                        Vector3 localAxis = (space == TransformSpace.Local && nearAxis != Axis.Any) ? mainTargetRoot.InverseTransformDirection(axis) : axis;

                        Vector3 targetScaleAmount = Vector3.one;
                        if (nearAxis == Axis.Any)
                        {
                            targetScaleAmount = (ExtVector3.Abs(mainTargetRoot.localScale.normalized) * scaleAmount);
                        }
                        else
                        {
                            targetScaleAmount = localAxis * scaleAmount;
                        }

                        for (int i = 0; i < targetRootsOrdered.Count; i++)
                        {
                            Transform target = targetRootsOrdered[i];

                            Vector3 targetScale = target.localScale + targetScaleAmount;

                            if (pivot == TransformPivot.Pivot)
                            {
                                target.localScale = targetScale;
                            }
                            else if (pivot == TransformPivot.Center)
                            {
                                if (scaleType == ScaleType.FromPoint)
                                {
                                    target.SetScaleFrom(originalPivot, targetScale);
                                }
                                else if (scaleType == ScaleType.FromPointOffset)
                                {
                                    target.SetScaleFromOffset(originalPivot, targetScale);
                                }
                            }
                        }

                        totalScaleAmount += scaleAmount;
                    }
                    else if (type == TransformType.Rotate)
                    {
                        float   rotateAmount = 0;
                        Vector3 rotationAxis = axis;

                        if (nearAxis == Axis.Any)
                        {
                            Vector3 rotation = transform.TransformDirection(new Vector3(Input.GetAxis("Mouse Y"), -Input.GetAxis("Mouse X"), 0));
                            Quaternion.Euler(rotation).ToAngleAxis(out rotateAmount, out rotationAxis);
                            rotateAmount *= allRotateSpeedMultiplier;
                        }
                        else
                        {
                            Vector3 projected = (nearAxis == Axis.Any || ExtVector3.IsParallel(axis, planeNormal)) ? planeNormal : Vector3.Cross(axis, planeNormal);
                            rotateAmount = (ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projected) * rotateSpeedMultiplier) / GetDistanceMultiplier();
                        }

                        for (int i = 0; i < targetRootsOrdered.Count; i++)
                        {
                            Transform target = targetRootsOrdered[i];

                            if (pivot == TransformPivot.Pivot)
                            {
                                target.Rotate(rotationAxis, rotateAmount, Space.World);
                            }
                            else if (pivot == TransformPivot.Center)
                            {
                                target.RotateAround(originalPivot, rotationAxis, rotateAmount);
                            }
                        }

                        totalRotationAmount *= Quaternion.Euler(rotationAxis * rotateAmount);
                    }
                }

                previousMousePosition = mousePosition;

                yield return(null);
            }

            for (int i = 0; i < transformCommands.Count; i++)
            {
                ((TransformCommand)transformCommands[i]).StoreNewTransformValues();
            }
            CommandGroup commandGroup = new CommandGroup();

            commandGroup.Set(transformCommands);
            UndoRedoManager.Insert(commandGroup);

            totalRotationAmount = Quaternion.identity;
            totalScaleAmount    = 0;
            isTransforming      = false;

            SetPivotPoint();
        }
Пример #5
0
        IEnumerator TransformSelected(TransformType transType)
        {
            isTransforming      = true;
            totalRotationAmount = Quaternion.identity;

            var originalPivot         = pivotPoint;
            var axis                  = GetNearAxisDirection(out var otherAxis1, out var otherAxis2);
            var planeNormal           = hasTranslatingAxisPlane ? axis : (transform.position - originalPivot).normalized;
            var projectedAxis         = Vector3.ProjectOnPlane(axis, planeNormal).normalized;
            var previousMousePosition = Vector3.zero;

            var currentSnapMovementAmount = Vector3.zero;
            var currentSnapRotationAmount = 0f;

            while (!Input.GetMouseButtonUp(0))
            {
                var mouseRay      = myCamera.ScreenPointToRay(Input.mousePosition);
                var mousePosition = Geometry.LinePlaneIntersect(mouseRay.origin, mouseRay.direction, originalPivot, planeNormal);
                var isSnapping    = Input.GetKey(translationSnapping);

                if (previousMousePosition != Vector3.zero && mousePosition != Vector3.zero)
                {
                    switch (transType)
                    {
                    case TransformType.Move:
                    {
                        Vector3 movement = Vector3.zero;

                        if (hasTranslatingAxisPlane)
                        {
                            movement = mousePosition - previousMousePosition;
                        }
                        else
                        {
                            float moveAmount = ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projectedAxis) * moveSpeedMultiplier;
                            movement = axis * moveAmount;
                        }

                        if (isSnapping && movementSnap > 0)
                        {
                            currentSnapMovementAmount += movement;
                            movement = Vector3.zero;

                            if (hasTranslatingAxisPlane)
                            {
                                float amountInAxis1 = ExtVector3.MagnitudeInDirection(currentSnapMovementAmount, otherAxis1);
                                float amountInAxis2 = ExtVector3.MagnitudeInDirection(currentSnapMovementAmount, otherAxis2);

                                float snapAmount1 = CalculateSnapAmount(movementSnap, amountInAxis1, out var remainder1);
                                float snapAmount2 = CalculateSnapAmount(movementSnap, amountInAxis2, out var remainder2);

                                if (snapAmount1 != 0)
                                {
                                    var snapMove = (otherAxis1 * snapAmount1);
                                    movement += snapMove;
                                    currentSnapMovementAmount -= snapMove;
                                }

                                if (snapAmount2 != 0)
                                {
                                    var snapMove = (otherAxis2 * snapAmount2);
                                    movement += snapMove;
                                    currentSnapMovementAmount -= snapMove;
                                }
                            }
                            else
                            {
                                float snapAmount = CalculateSnapAmount(movementSnap, currentSnapMovementAmount.magnitude, out var remainder);

                                if (snapAmount != 0)
                                {
                                    movement = currentSnapMovementAmount.normalized * snapAmount;
                                    currentSnapMovementAmount = currentSnapMovementAmount.normalized * remainder;
                                }
                            }
                        }

                        for (int i = 0; i < targetRootsOrdered.Count; i++)
                        {
                            Transform target = targetRootsOrdered[i];

                            target.Translate(movement, Space.World);
                        }

                        SetPivotPointOffset(movement);
                    }
                    break;

                    case TransformType.Rotate:
                    {
                        float   rotateAmount = 0;
                        Vector3 rotationAxis = axis;

                        if (nearAxis == Axis.Any)
                        {
                            Vector3 rotation = transform.TransformDirection(new Vector3(Input.GetAxis("Mouse Y"), -Input.GetAxis("Mouse X"), 0));
                            Quaternion.Euler(rotation).ToAngleAxis(out rotateAmount, out rotationAxis);
                            rotateAmount *= allRotateSpeedMultiplier;
                        }
                        else
                        {
                            if (circularRotationMethod)
                            {
                                float angle = Vector3.SignedAngle(previousMousePosition - originalPivot, mousePosition - originalPivot, axis);
                                rotateAmount = angle * rotateSpeedMultiplier;
                            }
                            else
                            {
                                Vector3 projected = (nearAxis == Axis.Any || ExtVector3.IsParallel(axis, planeNormal)) ? planeNormal : Vector3.Cross(axis, planeNormal);
                                rotateAmount = (ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projected) * (rotateSpeedMultiplier * 100f)) / GetDistanceMultiplier();
                            }
                        }

                        if (isSnapping && rotationSnap > 0)
                        {
                            currentSnapRotationAmount += rotateAmount;
                            rotateAmount = 0;

                            float snapAmount = CalculateSnapAmount(rotationSnap, currentSnapRotationAmount, out var remainder);

                            if (snapAmount != 0)
                            {
                                rotateAmount = snapAmount;
                                currentSnapRotationAmount = remainder;
                            }
                        }

                        for (int i = 0; i < targetRootsOrdered.Count; i++)
                        {
                            Transform target = targetRootsOrdered[i];

                            if (pivot == TransformPivot.Pivot)
                            {
                                target.Rotate(rotationAxis, rotateAmount, Space.World);
                            }
                            else if (pivot == TransformPivot.Center)
                            {
                                target.RotateAround(originalPivot, rotationAxis, rotateAmount);
                            }
                        }

                        totalRotationAmount *= Quaternion.Euler(rotationAxis * rotateAmount);
                    }
                    break;
                    }
                }

                previousMousePosition = mousePosition;

                yield return(null);
            }

            totalRotationAmount = Quaternion.identity;
            isTransforming      = false;
            SetTranslatingAxis(transformType, Axis.None);

            SetPivotPoint();
        }
Пример #6
0
        IEnumerator TransformSelected(TransformType transType)
        {
            isTransforming      = true;
            totalScaleAmount    = 0;
            totalRotationAmount = Quaternion.identity;

            Vector3 originalPivot = pivotPoint;
            Vector3 otherAxis1, otherAxis2;
            Vector3 axis                  = GetNearAxisDirection(out otherAxis1, out otherAxis2);
            Vector3 planeNormal           = hasTranslatingAxisPlane ? axis : (transform.position - originalPivot).normalized;
            Vector3 projectedAxis         = Vector3.ProjectOnPlane(axis, planeNormal).normalized;
            Vector3 previousMousePosition = Vector3.zero;

            Vector3 currentSnapMovementAmount = Vector3.zero;
            float   currentSnapRotationAmount = 0;
            float   currentSnapScaleAmount    = 0;

            List <ICommand> transformCommands = new List <ICommand>();

            for (int i = 0; i < targetRootsOrdered.Count; i++)
            {
                transformCommands.Add(new TransformCommand(this, targetRootsOrdered[i]));
            }

            while (!Input.GetMouseButtonUp(0))
            {
                var mouseRay      = myCamera.ScreenPointToRay(Input.mousePosition);
                var mousePosition = Geometry.LinePlaneIntersect(mouseRay.origin, mouseRay.direction, originalPivot, planeNormal);
                var isSnapping    = Input.GetKey(translationSnapping);

                if (previousMousePosition != Vector3.zero && mousePosition != Vector3.zero)
                {
                    if (transType == TransformType.Move)
                    {
                        Vector3 movement = Vector3.zero;

                        if (hasTranslatingAxisPlane)
                        {
                            movement = mousePosition - previousMousePosition;
                        }
                        else
                        {
                            float moveAmount = ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projectedAxis) * moveSpeedMultiplier;
                            movement = axis * moveAmount;
                        }

                        if (isSnapping && movementSnap > 0)
                        {
                            currentSnapMovementAmount += movement;
                            movement = Vector3.zero;

                            if (hasTranslatingAxisPlane)
                            {
                                float amountInAxis1 = ExtVector3.MagnitudeInDirection(currentSnapMovementAmount, otherAxis1);
                                float amountInAxis2 = ExtVector3.MagnitudeInDirection(currentSnapMovementAmount, otherAxis2);

                                float snapAmount1 = CalculateSnapAmount(movementSnap, amountInAxis1, out var remainder1);
                                float snapAmount2 = CalculateSnapAmount(movementSnap, amountInAxis2, out var remainder2);

                                if (snapAmount1 != 0)
                                {
                                    var snapMove = (otherAxis1 * snapAmount1);
                                    movement += snapMove;
                                    currentSnapMovementAmount -= snapMove;
                                }
                                if (snapAmount2 != 0)
                                {
                                    var snapMove = (otherAxis2 * snapAmount2);
                                    movement += snapMove;
                                    currentSnapMovementAmount -= snapMove;
                                }
                            }
                            else
                            {
                                float snapAmount = CalculateSnapAmount(movementSnap, currentSnapMovementAmount.magnitude, out var remainder);

                                if (snapAmount != 0)
                                {
                                    movement = currentSnapMovementAmount.normalized * snapAmount;
                                    currentSnapMovementAmount = currentSnapMovementAmount.normalized * remainder;
                                }
                            }
                        }

                        for (int i = 0; i < targetRootsOrdered.Count; i++)
                        {
                            Transform target = targetRootsOrdered[i];

                            target.Translate(movement, Space.World);
                        }

                        SetPivotPointOffset(movement);
                    }
                    else if (transType == TransformType.Scale)
                    {
                        Vector3 projected   = (nearAxis == Axis.Any)? transform.right : projectedAxis;
                        float   scaleAmount = ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projected) * scaleSpeedMultiplier;

                        if (isSnapping && scaleSnap > 0)
                        {
                            currentSnapScaleAmount += scaleAmount;
                            scaleAmount             = 0;

                            float snapAmount = CalculateSnapAmount(scaleSnap, currentSnapScaleAmount, out var remainder);

                            if (snapAmount != 0)
                            {
                                scaleAmount            = snapAmount;
                                currentSnapScaleAmount = remainder;
                            }
                        }

                        //WARNING - There is a bug in unity 5.4 and 5.5 that causes InverseTransformDirection to be affected by scale which will break negative scaling. Not tested, but updating to 5.4.2 should fix it - https://issuetracker.unity3d.com/issues/transformdirection-and-inversetransformdirection-operations-are-affected-by-scale
                        Vector3 localAxis = (GetProperTransformSpace() == TransformSpace.Local && nearAxis != Axis.Any)? mainTargetRoot.InverseTransformDirection(axis) : axis;

                        Vector3 targetScaleAmount = Vector3.one;
                        if (nearAxis == Axis.Any)
                        {
                            targetScaleAmount = (ExtVector3.Abs(mainTargetRoot.localScale.normalized) * scaleAmount);
                        }
                        else
                        {
                            targetScaleAmount = localAxis * scaleAmount;
                        }

                        for (int i = 0; i < targetRootsOrdered.Count; i++)
                        {
                            Transform target = targetRootsOrdered[i];

                            Vector3 targetScale = target.localScale + targetScaleAmount;

                            if (pivot == TransformPivot.Pivot)
                            {
                                target.localScale = targetScale;
                            }
                            else if (pivot == TransformPivot.Center)
                            {
                                if (scaleType == ScaleType.FromPoint)
                                {
                                    target.SetScaleFrom(originalPivot, targetScale);
                                }
                                else if (scaleType == ScaleType.FromPointOffset)
                                {
                                    target.SetScaleFromOffset(originalPivot, targetScale);
                                }
                            }
                        }

                        totalScaleAmount += scaleAmount;
                    }
                    else if (transType == TransformType.Rotate)
                    {
                        float   rotateAmount = 0;
                        Vector3 rotationAxis = axis;

                        if (nearAxis == Axis.Any)
                        {
                            Vector3 rotation = transform.TransformDirection(new Vector3(Input.GetAxis("Mouse Y"), -Input.GetAxis("Mouse X"), 0));
                            Quaternion.Euler(rotation).ToAngleAxis(out rotateAmount, out rotationAxis);
                            rotateAmount *= allRotateSpeedMultiplier;
                        }
                        else
                        {
                            if (circularRotationMethod)
                            {
                                float angle = Vector3.SignedAngle(previousMousePosition - originalPivot, mousePosition - originalPivot, axis);
                                rotateAmount = angle * rotateSpeedMultiplier;
                            }
                            else
                            {
                                Vector3 projected = (nearAxis == Axis.Any || ExtVector3.IsParallel(axis, planeNormal))? planeNormal : Vector3.Cross(axis, planeNormal);
                                rotateAmount = (ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projected) * (rotateSpeedMultiplier * 100f)) / GetDistanceMultiplier();
                            }
                        }

                        if (isSnapping && rotationSnap > 0)
                        {
                            currentSnapRotationAmount += rotateAmount;
                            rotateAmount = 0;

                            float snapAmount = CalculateSnapAmount(rotationSnap, currentSnapRotationAmount, out var remainder);

                            if (snapAmount != 0)
                            {
                                rotateAmount = snapAmount;
                                currentSnapRotationAmount = remainder;
                            }
                        }

                        for (int i = 0; i < targetRootsOrdered.Count; i++)
                        {
                            Transform target = targetRootsOrdered[i];

                            if (pivot == TransformPivot.Pivot)
                            {
                                target.Rotate(rotationAxis, rotateAmount, Space.World);
                            }
                            else if (pivot == TransformPivot.Center)
                            {
                                target.RotateAround(originalPivot, rotationAxis, rotateAmount);
                            }
                        }

                        totalRotationAmount *= Quaternion.Euler(rotationAxis * rotateAmount);
                    }
                }

                previousMousePosition = mousePosition;

                yield return(null);
            }

            for (int i = 0; i < transformCommands.Count; i++)
            {
                ((TransformCommand)transformCommands[i]).StoreNewTransformValues();
            }
            CommandGroup commandGroup = new CommandGroup();

            commandGroup.Set(transformCommands);
            UndoRedoManager.Insert(commandGroup);

            totalRotationAmount = Quaternion.identity;
            totalScaleAmount    = 0;
            isTransforming      = false;
            SetTranslatingAxis(transformType, Axis.None);

            SetPivotPoint();
        }
Пример #7
0
        IEnumerator PRTransform()
        {
            _isTransforming          = true;
            TransformationHandleName = Manager.Instance.GET_COLLIDER_NAME;
            // Define what axis to project on
            string     transformType         = Manager.Instance.GET_COLLIDER_TAG;
            Vector3    translateAxis         = GetTranslateAxis();
            Plane      translatePlane        = GetTranslatePlane();
            Vector3    savedProjectedOnPlane = translatePlane.ClosestPointOnPlane(_savedHitLoc);
            Quaternion quaSavedRotation      = mainTargetRoot.localRotation;
            // Scale save
            Vector3    savedScale     = mainTargetRoot.localScale;
            Vector3    scaleAxis      = GetScaleAxis();
            Vector3    scaleAxisLocal = GetScaleAxisLocal();
            GameObject scaleCube      = null;
            Vector3    scaleCubeLoc   = Vector3.zero;
            Vector3    scaleCubeScale = Vector3.zero;
            // Edges and Vertices.
            PRGeo geo = mainTargetRoot.gameObject.GetComponent <PRGeo>();

            if (Manager.Instance.GET_COLLIDER_TAG == "GizmoScale" ||
                Manager.Instance.GET_COLLIDER_TAG == "GizmoScaleCenter")
            {
                scaleCube      = Manager.Instance.GET_COLLIDER_GO;
                scaleCubeLoc   = scaleCube.transform.position;
                scaleCubeScale = scaleCube.transform.localScale;
                // Unparent the edges to avoid deforming the edges whne the geometry is scaled.
                geo.PR_EDGE_GO.GetComponent <ParentEdge>().UnparentEdges();
                // Unparent vertices
                geo.PR_VERTEX_GO.GetComponent <ParentVertex>().UnparentVertices();
            }
            while (!InputUp)
            {
                if (transformType == "GizmoMove")
                {
                    //Debug.Log("Move");
                    // Project
                    float moveAmount = ExtVector3.MagnitudeInDirection(manipulationVec, translateAxis) *
                                       MoveMultiplier;
                    for (int i = 0; i < targetRootsOrdered.Count; i++)
                    {
                        Transform target = targetRootsOrdered[i];
                        // Save target position, in worder to add the movement Vector. Translate gives a continuos transformation.
                        Vector3 targetSavedPos = targetRootsOrderedSavedPos[i];
                        target.position = targetSavedPos + translateAxis * moveAmount;
                        if (target.tag == "PREdge" || target.tag == "PRFace" ||
                            target.tag == "PRVertex")
                        {
                            target.transform.parent.parent.GetComponent <PRGeo>().EdgeDimTempParet.SetActive(true);
                        }
                    }
                }
                else if (transformType == "GizmoPlaneMove")
                {
                    //Debug.Log("PlaneMove");
                    // Project the Manipulation vector onto the plane.
                    Vector3 projectedOnPlane = Vector3.ProjectOnPlane(manipulationVec, translatePlane.normal);
                    // Apply the projected manipulation vector for movement.
                    for (int i = 0; i < targetRootsOrdered.Count; i++)
                    {
                        Transform target = targetRootsOrdered[i];
                        // Save target position, in worder to add the movement Vector. Translate gives a continuos transformation.
                        Vector3 targetSavedPos = targetRootsOrderedSavedPos[i];
                        target.position = targetSavedPos + projectedOnPlane * MoveMultiplier;
                    }
                }
                else if (transformType == "GizmoRotate" &&
                         Manager.Instance.SelectedGeoCO.GeoModeActive)
                {
                    // Don't allow any rotation if I am not in the GeoMode.

                    //Debug.Log("Rotate");
                    // Get the world location of the manipolation in respect to the savedHit location.
                    Vector3 worldManip = savedProjectedOnPlane + manipulationVec;
                    // Project the worlManip to the translatePlane which has Gizmo coordinates.
                    Vector3 projectedOnPlane = translatePlane.ClosestPointOnPlane(worldManip);
                    // Get the quaterion with rotation between the savedHit and the actualHit that have the origin as the 0,0,0 coordinate, and not the gizmo.
                    Quaternion quaRotation = Quaternion.FromToRotation(savedProjectedOnPlane - GizmoGo.transform.position, projectedOnPlane - GizmoGo.transform.position);
                    // Apply quaternion.
                    for (int i = 0; i < targetRootsOrdered.Count; i++)
                    {
                        Transform target = targetRootsOrdered[i];
                        if (space == TransformSpace.Global)
                        {
                            target.rotation = quaRotation * quaSavedRotation;
                            // Update the Gizmo rotation while doing the global rotation.
                            GizmoGo.transform.rotation = quaRotation;
                        }
                        else if (space == TransformSpace.Local)
                        {
                            target.localRotation = quaRotation * quaSavedRotation;
                        }
                    }
                }
                else if (transformType == "GizmoScale")
                {
                    //Debug.Log("Scale");
                    float scaleAmount = ExtVector3.MagnitudeInDirection(manipulationVec, scaleAxis) *
                                        ScaleMultiplier;
                    for (int i = 0; i < targetRootsOrdered.Count; i++)
                    {
                        Transform target = targetRootsOrdered[i];
                        target.localScale = savedScale + scaleAxis * scaleAmount;
                        // Update the Gizmo position for scale cubes and scale rects.
                        scaleCube.transform.position = scaleCubeLoc + (scaleAxisLocal * scaleAmount);
                    }
                    // Turn ON edge dimentions
                    geo.EdgeDimTempParet.SetActive(true);
                }
                else if (transformType == "GizmoScaleCenter")
                {
                    // Get the porjection of the manipulation vector on the predifined plane during manipulation start.
                    Vector3 closest  = _scale3DPlane.ClosestPointOnPlane(GizmoGo.transform.position + manipulationVec);
                    float   magScale = 0;
                    // To have the scale go both ways (larger and smaller) check the angle between manipulation vector and plane normal.
                    if (Vector3.Angle(_scale3DPlane.normal, manipulationVec) < 90)
                    {
                        magScale = (closest - (GizmoGo.transform.position + manipulationVec)).magnitude * ScaleMultiplier;
                    }
                    else
                    {
                        magScale = -(closest - (GizmoGo.transform.position + manipulationVec)).magnitude * ScaleMultiplier;
                    }
                    for (int i = 0; i < targetRootsOrdered.Count; i++)
                    {
                        Transform target = targetRootsOrdered[i];
                        target.localScale = savedScale + new Vector3(magScale, magScale, magScale);
                        // Update the Gizmo position for scale cubes and scale rects.
                        scaleCube.transform.localScale = scaleCubeScale + new Vector3(magScale, magScale, magScale) * 2;
                    }
                    // Turn ON edge dimentions
                    geo.EdgeDimTempParet.SetActive(true);
                }
                // Update the Gizmo location while doing the global rotation.
                GizmoGo.transform.position = mainTargetRoot.transform.position;
                yield return(null);
            }
            // Reset scale elements.
            if (scaleCube)
            {
                // Turn ON edge dimentions
                geo.EdgeDimTempParet.SetActive(false);
                // Parent the edges and vertices back to the geometry, after the scale is finished.
                geo.PR_EDGE_GO.GetComponent <ParentEdge>().ParentEdges();
                geo.PR_VERTEX_GO.GetComponent <ParentVertex>().ParentVertices();
                scaleCube.transform.position   = scaleCubeLoc;
                scaleCube.transform.localScale = scaleCubeScale;
            }
            if (mainTargetRoot.tag == "PREdge" || mainTargetRoot.tag == "PRFace" ||
                mainTargetRoot.tag == "PRVertex")
            {
                mainTargetRoot.transform.parent.parent.GetComponent <PRGeo>().EdgeDimTempParet.SetActive(false);
            }

            _isTransforming = false;
        }
        IEnumerator TransformSelected(TransformType type)
        {
            isTransforming      = true;
            totalScaleAmount    = 0;
            totalRotationAmount = Quaternion.identity;

            Vector3 originalTargetPosition = target.position;
            Vector3 planeNormal            = (transform.position - target.position).normalized;
            Vector3 axis                  = GetSelectedAxisDirection();
            Vector3 projectedAxis         = Vector3.ProjectOnPlane(axis, planeNormal).normalized;
            Vector3 previousMousePosition = Vector3.zero;

            while (!Input.GetMouseButtonUp(0))
            {
                Ray     mouseRay      = myCamera.ScreenPointToRay(Input.mousePosition);
                Vector3 mousePosition = Geometry.LinePlaneIntersect(mouseRay.origin, mouseRay.direction, originalTargetPosition, planeNormal);

                if (previousMousePosition != Vector3.zero && mousePosition != Vector3.zero)
                {
                    if (type == TransformType.Move)
                    {
                        float moveAmount = ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projectedAxis) * moveSpeedMultiplier;
                        target.Translate(axis * moveAmount, Space.World);
                    }

                    if (type == TransformType.Scale)
                    {
                        Vector3 projected   = (selectedAxis == Axis.Any) ? transform.right : projectedAxis;
                        float   scaleAmount = ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projected) * scaleSpeedMultiplier;

                        //WARNING - There is a bug in unity 5.4 and 5.5 that causes InverseTransformDirection to be affected by scale which will break negative scaling. Not tested, but updating to 5.4.2 should fix it - https://issuetracker.unity3d.com/issues/transformdirection-and-inversetransformdirection-operations-are-affected-by-scale
                        Vector3 localAxis = (space == TransformSpace.Local && selectedAxis != Axis.Any) ? target.InverseTransformDirection(axis) : axis;

                        if (selectedAxis == Axis.Any)
                        {
                            target.localScale += (ExtVector3.Abs(target.localScale.normalized) * scaleAmount);
                        }
                        else
                        {
                            target.localScale += (localAxis * scaleAmount);
                        }

                        totalScaleAmount += scaleAmount;
                    }

                    if (type == TransformType.Rotate)
                    {
                        if (selectedAxis == Axis.Any)
                        {
                            Vector3 rotation = transform.TransformDirection(new Vector3(Input.GetAxis("Mouse Y"), -Input.GetAxis("Mouse X"), 0));
                            target.Rotate(rotation * allRotateSpeedMultiplier, Space.World);
                            totalRotationAmount *= Quaternion.Euler(rotation * allRotateSpeedMultiplier);
                        }
                        else
                        {
                            Vector3 projected    = (selectedAxis == Axis.Any || ExtVector3.IsParallel(axis, planeNormal)) ? planeNormal : Vector3.Cross(axis, planeNormal);
                            float   rotateAmount = (ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projected) * rotateSpeedMultiplier) / GetDistanceMultiplier();
                            target.Rotate(axis, rotateAmount, Space.World);
                            totalRotationAmount *= Quaternion.Euler(axis * rotateAmount);
                        }
                    }
                }

                previousMousePosition = mousePosition;

                yield return(null);
            }

            totalRotationAmount = Quaternion.identity;
            totalScaleAmount    = 0;
            isTransforming      = false;
        }
Пример #9
0
        IEnumerator TransformSelected(TransformType transType)
        {
            isTransforming      = true;
            totalScaleAmount    = 0;
            totalRotationAmount = Quaternion.identity;

            Vector3 originalPivot = pivotPoint;

            Vector3 axis                  = GetNearAxisDirection(out Vector3 otherAxis1, out Vector3 otherAxis2);
            Vector3 planeNormal           = hasTranslatingAxisPlane ? axis : (transform.position - originalPivot).normalized;
            Vector3 projectedAxis         = Vector3.ProjectOnPlane(axis, planeNormal).normalized;
            Vector3 previousMousePosition = Vector3.zero;

            Vector3 currentSnapMovementAmount = Vector3.zero;

            while (!Input.GetMouseButtonUp(0))
            {
                Ray     mouseRay      = myCamera.ScreenPointToRay(Input.mousePosition);
                Vector3 mousePosition = Geometry.LinePlaneIntersect(mouseRay.origin, mouseRay.direction, originalPivot, planeNormal);

                if (previousMousePosition != Vector3.zero && mousePosition != Vector3.zero)
                {
                    if (transType == TransformType.Move)
                    {
                        Vector3 movement;

                        if (hasTranslatingAxisPlane)
                        {
                            movement = mousePosition - previousMousePosition;
                        }
                        else
                        {
                            float moveAmount = ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projectedAxis) * moveSpeedMultiplier;
                            movement = axis * moveAmount;
                        }

                        Vector3 movementPerSecond = movement / Time.deltaTime;
                        movementPerSecond = movementPerSecond.normalized * Mathf.Min(movementPerSecond.magnitude, maxMovePerSecond);

                        movement = movementPerSecond * Time.deltaTime;
                        for (int i = 0; i < targetRootsOrdered.Count; i++)
                        {
                            Transform target = targetRootsOrdered[i];

                            target.Translate(movement, Space.World);
                        }

                        SetPivotPointOffset(movement);
                    }
                }


                previousMousePosition = mousePosition;

                yield return(null);
            }


            totalRotationAmount = Quaternion.identity;
            totalScaleAmount    = 0;
            isTransforming      = false;
            SetTranslatingAxis(transformType, Axis.None);

            SetPivotPoint();
        }