示例#1
0
        public override void ToolGUI(SceneView view, Vector3 handlePosition, bool isStatic)
        {
            Quaternion targetRotation = (Selection.transforms.Length <= 1) ? Tools.handleLocalRotation : Tools.handleRotation;

            TransformManipulator.DebugAlignment(targetRotation);
            if (Event.current.type == EventType.MouseDown)
            {
                s_CurrentScale = Vector3.one;
            }
            EditorGUI.BeginChangeCheck();
            TransformManipulator.BeginManipulationHandling(true);
            s_CurrentScale = Handles.ScaleHandle(s_CurrentScale, handlePosition, targetRotation, HandleUtility.GetHandleSize(handlePosition));
            TransformManipulator.EndManipulationHandling();
            if (EditorGUI.EndChangeCheck() && !isStatic)
            {
                TransformManipulator.SetScaleDelta(s_CurrentScale, targetRotation);
            }
        }
示例#2
0
        public override void ToolGUI(SceneView view, Vector3 handlePosition, bool isStatic)
        {
            Quaternion quaternion = Selection.transforms.Length <= 1 ? Tools.handleLocalRotation : Tools.handleRotation;

            TransformManipulator.DebugAlignment(quaternion);
            if (Event.current.type == EventType.MouseDown)
            {
                ScaleTool.s_CurrentScale = Vector3.one;
            }
            EditorGUI.BeginChangeCheck();
            TransformManipulator.BeginManipulationHandling(true);
            ScaleTool.s_CurrentScale = Handles.ScaleHandle(ScaleTool.s_CurrentScale, handlePosition, quaternion, HandleUtility.GetHandleSize(handlePosition));
            int num = (int)TransformManipulator.EndManipulationHandling();

            if (!EditorGUI.EndChangeCheck() || isStatic)
            {
                return;
            }
            TransformManipulator.SetScaleDelta(ScaleTool.s_CurrentScale, quaternion);
        }
示例#3
0
        protected override void ToolGUI(SceneView view, Vector3 handlePosition, bool isStatic)
        {
            // Allow global space scaling for multi-selection but not for a single object
            Quaternion handleRotation = Selection.transforms.Length > 1 ?
                                        Tools.handleRotation : Tools.handleLocalRotation;

            TransformManipulator.DebugAlignment(handleRotation);

            if (Event.current.type == EventType.MouseDown)
            {
                s_CurrentScale = Vector3.one;
            }

            EditorGUI.BeginChangeCheck();

            TransformManipulator.BeginManipulationHandling(true);
            s_CurrentScale = Handles.ScaleHandle(s_CurrentScale, handlePosition, handleRotation, HandleUtility.GetHandleSize(handlePosition));
            TransformManipulator.EndManipulationHandling();

            if (EditorGUI.EndChangeCheck() && !isStatic)
            {
                TransformManipulator.SetScaleDelta(s_CurrentScale, handleRotation);
            }
        }
示例#4
0
        public static bool MovePoints(IEditablePoint points, Transform cloudTransform, List <int> selection)
        {
            if (selection.Count == 0)
            {
                return(false);
            }
            if (Event.current.type == EventType.MouseUp)
            {
                PointEditor.s_EditingScale    = Vector3.one;
                PointEditor.s_EditingRotation = Quaternion.identity;
            }
            if (Camera.current)
            {
                Vector3 vector = Vector3.zero;
                vector = ((Tools.pivotMode != PivotMode.Pivot) ? (selection.Aggregate(vector, (Vector3 current, int index) => current + points.GetPosition(index)) / (float)selection.Count) : points.GetPosition(selection[0]));
                vector = cloudTransform.TransformPoint(vector);
                switch (Tools.current)
                {
                case Tool.Move:
                {
                    Vector3 position = Handles.PositionHandle(vector, (Tools.pivotRotation != PivotRotation.Local) ? Quaternion.identity : cloudTransform.rotation);
                    if (GUI.changed)
                    {
                        Vector3 b = cloudTransform.InverseTransformPoint(position) - cloudTransform.InverseTransformPoint(vector);
                        foreach (int current4 in selection)
                        {
                            points.SetPosition(current4, points.GetPosition(current4) + b);
                        }
                        return(true);
                    }
                    break;
                }

                case Tool.Rotate:
                {
                    Quaternion rotation = Handles.RotationHandle(PointEditor.s_EditingRotation, vector);
                    if (GUI.changed)
                    {
                        Vector3 b2 = cloudTransform.InverseTransformPoint(vector);
                        foreach (int current2 in selection)
                        {
                            Vector3 vector2 = points.GetPosition(current2) - b2;
                            vector2  = Quaternion.Inverse(PointEditor.s_EditingRotation) * vector2;
                            vector2  = rotation * vector2;
                            vector2 += b2;
                            points.SetPosition(current2, vector2);
                        }
                        PointEditor.s_EditingRotation = rotation;
                        return(true);
                    }
                    break;
                }

                case Tool.Scale:
                {
                    Vector3 vector3 = Handles.ScaleHandle(PointEditor.s_EditingScale, vector, Quaternion.identity, HandleUtility.GetHandleSize(vector));
                    if (GUI.changed)
                    {
                        Vector3 b3 = cloudTransform.InverseTransformPoint(vector);
                        foreach (int current3 in selection)
                        {
                            Vector3 vector4 = points.GetPosition(current3) - b3;
                            vector4.x /= PointEditor.s_EditingScale.x;
                            vector4.y /= PointEditor.s_EditingScale.y;
                            vector4.z /= PointEditor.s_EditingScale.z;
                            vector4.x *= vector3.x;
                            vector4.y *= vector3.y;
                            vector4.z *= vector3.z;
                            vector4   += b3;
                            points.SetPosition(current3, vector4);
                        }
                        PointEditor.s_EditingScale = vector3;
                        return(true);
                    }
                    break;
                }
                }
            }
            return(false);
        }
示例#5
0
        public static bool MovePoints(IEditablePoint points, Transform cloudTransform, List <int> selection)
        {
            // ISSUE: object of a compiler-generated type is created
            // ISSUE: variable of a compiler-generated type
            PointEditor.\u003CMovePoints\u003Ec__AnonStorey40 pointsCAnonStorey40 = new PointEditor.\u003CMovePoints\u003Ec__AnonStorey40();
            // ISSUE: reference to a compiler-generated field
            pointsCAnonStorey40.points = points;
            if (selection.Count == 0)
            {
                return(false);
            }
            if (Event.current.type == EventType.MouseUp)
            {
                PointEditor.s_EditingScale    = Vector3.one;
                PointEditor.s_EditingRotation = Quaternion.identity;
            }
            if ((bool)((UnityEngine.Object)Camera.current))
            {
                Vector3 zero = Vector3.zero;
                // ISSUE: reference to a compiler-generated method
                // ISSUE: reference to a compiler-generated field
                Vector3 position1 = Tools.pivotMode != PivotMode.Pivot ? selection.Aggregate <int, Vector3>(zero, new Func <Vector3, int, Vector3>(pointsCAnonStorey40.\u003C\u003Em__57)) / (float)selection.Count : pointsCAnonStorey40.points.GetPosition(selection[0]);
                Vector3 position2 = cloudTransform.TransformPoint(position1);
                switch (Tools.current)
                {
                case Tool.Move:
                    Vector3 position3 = Handles.PositionHandle(position2, Tools.pivotRotation != PivotRotation.Local ? Quaternion.identity : cloudTransform.rotation);
                    if (GUI.changed)
                    {
                        Vector3 vector3 = cloudTransform.InverseTransformPoint(position3) - cloudTransform.InverseTransformPoint(position2);
                        using (List <int> .Enumerator enumerator = selection.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                int current = enumerator.Current;
                                // ISSUE: reference to a compiler-generated field
                                // ISSUE: reference to a compiler-generated field
                                pointsCAnonStorey40.points.SetPosition(current, pointsCAnonStorey40.points.GetPosition(current) + vector3);
                            }
                        }
                        return(true);
                    }
                    break;

                case Tool.Rotate:
                    Quaternion quaternion = Handles.RotationHandle(PointEditor.s_EditingRotation, position2);
                    if (GUI.changed)
                    {
                        Vector3 vector3_1 = cloudTransform.InverseTransformPoint(position2);
                        using (List <int> .Enumerator enumerator = selection.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                int current = enumerator.Current;
                                // ISSUE: reference to a compiler-generated field
                                Vector3 vector3_2 = pointsCAnonStorey40.points.GetPosition(current) - vector3_1;
                                Vector3 vector3_3 = Quaternion.Inverse(PointEditor.s_EditingRotation) * vector3_2;
                                Vector3 position4 = quaternion * vector3_3 + vector3_1;
                                // ISSUE: reference to a compiler-generated field
                                pointsCAnonStorey40.points.SetPosition(current, position4);
                            }
                        }
                        PointEditor.s_EditingRotation = quaternion;
                        return(true);
                    }
                    break;

                case Tool.Scale:
                    Vector3 vector3_4 = Handles.ScaleHandle(PointEditor.s_EditingScale, position2, Quaternion.identity, HandleUtility.GetHandleSize(position2));
                    if (GUI.changed)
                    {
                        Vector3 vector3_1 = cloudTransform.InverseTransformPoint(position2);
                        using (List <int> .Enumerator enumerator = selection.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                int current = enumerator.Current;
                                // ISSUE: reference to a compiler-generated field
                                Vector3 position4 = pointsCAnonStorey40.points.GetPosition(current) - vector3_1;
                                position4.x /= PointEditor.s_EditingScale.x;
                                position4.y /= PointEditor.s_EditingScale.y;
                                position4.z /= PointEditor.s_EditingScale.z;
                                position4.x *= vector3_4.x;
                                position4.y *= vector3_4.y;
                                position4.z *= vector3_4.z;
                                position4   += vector3_1;
                                // ISSUE: reference to a compiler-generated field
                                pointsCAnonStorey40.points.SetPosition(current, position4);
                            }
                        }
                        PointEditor.s_EditingScale = vector3_4;
                        return(true);
                    }
                    break;
                }
            }
            return(false);
        }