Ejemplo n.º 1
0
        public static float RadiusHandle(Quaternion rotation, Vector3 position, float radius, bool renderDisc = true)
        {
            var isStatic     = (!Tools.hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects));
            var prevDisabled = SceneHandles.disabled;
            var prevColor    = SceneHandles.color;

            var forward = rotation * Vector3.forward;
            var up      = rotation * Vector3.up;
            var right   = rotation * Vector3.right;

            // Radius handle in zenith
            bool temp = GUI.changed;


            // Radius handles at disc
            temp        = GUI.changed;
            GUI.changed = false;

            var isDisabled = isStatic || prevDisabled || Snapping.AxisLocking[1];

            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);

            radius = SizeSlider(position, up, forward, up, right, radius);
            radius = SizeSlider(position, -up, forward, up, right, radius);

            isDisabled         = isStatic || prevDisabled || Snapping.AxisLocking[0];
            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);

            radius = SizeSlider(position, right, forward, up, right, radius);
            radius = SizeSlider(position, -right, forward, up, right, radius);

            if (GUI.changed)
            {
                radius = Mathf.Max(0.0f, radius);
            }
            GUI.changed |= temp;

            isDisabled         = isStatic || prevDisabled || (Snapping.AxisLocking[0] && Snapping.AxisLocking[1]);
            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);

            // Draw gizmo
            if (radius > 0 && renderDisc)
            {
                SceneHandles.DrawWireDisc(position, forward, radius);
            }


            SceneHandles.disabled = prevDisabled;
            SceneHandles.color    = prevColor;
            return(radius);
        }
Ejemplo n.º 2
0
        public static float Radius2DHandle(Quaternion rotation, Vector3 position, float radius, float minRadius = 0, float maxRadius = float.PositiveInfinity, bool renderDisc = true)
        {
            minRadius = Mathf.Abs(minRadius);
            maxRadius = Mathf.Abs(maxRadius); if (maxRadius < minRadius)
            {
                maxRadius = minRadius;
            }

            var isStatic     = (!Tools.hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects));
            var prevDisabled = SceneHandles.disabled;
            var prevColor    = SceneHandles.color;

            var forward = rotation * Vector3.forward;
            var up      = rotation * Vector3.up;
            var right   = rotation * Vector3.right;

            bool temp = GUI.changed;

            GUI.changed = false;

            var isDisabled = isStatic || prevDisabled || Snapping.AxisLocking[1];

            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);

            radius = Size2DSlider(position, up, forward, up, right, radius);
            radius = Size2DSlider(position, -up, forward, up, right, radius);

            isDisabled         = isStatic || prevDisabled || Snapping.AxisLocking[0];
            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);

            radius = Size2DSlider(position, right, forward, up, right, radius);
            radius = Size2DSlider(position, -right, forward, up, right, radius);

            radius = Mathf.Max(minRadius, Mathf.Min(Mathf.Abs(radius), maxRadius));

            GUI.changed |= temp;

            if (radius > 0 && renderDisc)
            {
                isDisabled         = isStatic || prevDisabled || (Snapping.AxisLocking[0] && Snapping.AxisLocking[1]);
                SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);

                SceneHandles.DrawWireDisc(position, forward, radius);

                SceneHandles.disabled = prevDisabled;
                SceneHandles.color    = prevColor;
            }
            return(radius);
        }
Ejemplo n.º 3
0
        public static Vector3 RadiusHandle(Vector3 center, Vector3 up, Vector3 radius)
        {
            var isStatic     = (!Tools.hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects));
            var prevDisabled = SceneHandles.disabled;
            var prevColor    = SceneHandles.color;
            var prevChanged  = GUI.changed;


            var delta1 = radius - center;
            var delta2 = Quaternion.AngleAxis(90, up) * delta1;

            var position0 = center + delta1;
            var position1 = center - delta1;
            var position2 = center + delta2;
            var position3 = center - delta2;


            float   size;
            Vector3 forward;
            Vector3 right;

            GeometryUtility.CalculateTangents(up, out right, out forward);



            var isDisabled = isStatic || prevDisabled;

            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);


            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position0);
            position0   = Slider2DHandle(position0, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius = position0; prevChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position1);
            position1   = Slider2DHandle(position1, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius = center - (position1 - center); prevChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position2);
            position2   = Slider2DHandle(position2, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius = center + (Quaternion.AngleAxis(-90, up) * (position2 - center)); prevChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position3);
            position3   = Slider2DHandle(position3, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius = center - (Quaternion.AngleAxis(-90, up) * (position3 - center)); prevChanged = true;
            }



            GUI.changed |= prevChanged;

            isDisabled         = isStatic || prevDisabled || (Snapping.AxisLocking[0] && Snapping.AxisLocking[1]);
            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);


            float radiusMagnitude = delta1.magnitude;

            if (radiusMagnitude > 0)
            {
                SceneHandles.DrawWireDisc(center, up, radiusMagnitude);
            }


            SceneHandles.disabled = prevDisabled;
            SceneHandles.color    = prevColor;
            return(radius);
        }
Ejemplo n.º 4
0
        public static void RadiusHandle(Vector3 center, Vector3 up, ref Vector3 radius1, ref Vector3 radius2)
        {
            var isStatic     = (!Tools.hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects));
            var prevColor    = SceneHandles.color;
            var prevMatrix   = SceneHandles.matrix;
            var prevDisabled = SceneHandles.disabled;
            var prevChanged  = GUI.changed;


            var delta1 = radius1 - center;
            var delta2 = radius2 - center;

            var position0 = center + delta1;
            var position1 = center - delta1;
            var position2 = center + delta2;
            var position3 = center - delta2;


            float   size;
            Vector3 forward;
            Vector3 right;

            GeometryUtility.CalculateTangents(up, out right, out forward);



            var isDisabled = isStatic || prevDisabled;

            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);


            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position0);
            position0   = Slider2DHandle(position0, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius1     = position0;
                radius2     = center + (Quaternion.AngleAxis(-90, up) * ((radius1 - center).normalized * (radius2 - center).magnitude));
                prevChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position1);
            position1   = Slider2DHandle(position1, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius1     = center - (position1 - center);
                radius2     = center + (Quaternion.AngleAxis(-90, up) * ((radius1 - center).normalized * (radius2 - center).magnitude));
                prevChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position2);
            position2   = Slider2DHandle(position2, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius2     = center + (position2 - center);
                radius1     = center + (Quaternion.AngleAxis(-90, up) * ((radius2 - center).normalized * (radius1 - center).magnitude));
                prevChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position3);
            position3   = Slider2DHandle(position3, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius2     = center - (position3 - center);
                radius1     = center + (Quaternion.AngleAxis(-90, up) * ((radius2 - center).normalized * (radius1 - center).magnitude));
                prevChanged = true;
            }



            GUI.changed |= prevChanged;

            isDisabled         = isStatic || prevDisabled || (Snapping.AxisLocking[0] && Snapping.AxisLocking[1]);
            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);


            float radiusMagnitude1 = delta1.magnitude;
            float radiusMagnitude2 = delta2.magnitude;

            if (radiusMagnitude1 > 0 && radiusMagnitude2 > 0)
            {
                var ellipsis = Matrix4x4.TRS(center, Quaternion.identity, Vector3.one);

                ellipsis.m00 = delta1.x;
                ellipsis.m10 = delta1.y;
                ellipsis.m20 = delta1.z;

                ellipsis.m01 = delta2.x;
                ellipsis.m11 = delta2.y;
                ellipsis.m21 = delta2.z;

                ellipsis.m02 = up.x;
                ellipsis.m12 = up.y;
                ellipsis.m22 = up.z;

                ellipsis *= Matrix4x4.TRS(-center, Quaternion.identity, Vector3.one);

                var newMatrix = prevMatrix * ellipsis;

                SceneHandles.matrix = newMatrix;
                SceneHandles.DrawWireDisc(center, up, 1.0f);
            }


            SceneHandles.disabled = prevDisabled;
            SceneHandles.matrix   = prevMatrix;
            SceneHandles.color    = prevColor;
        }
Ejemplo n.º 5
0
        public static Vector3 Radius2DHandle(Vector3 center, Vector3 up, Vector3 radius, float minRadius = 0, float maxRadius = float.PositiveInfinity, bool renderDisc = true)
        {
            minRadius = Mathf.Abs(minRadius);
            maxRadius = Mathf.Abs(maxRadius); if (maxRadius < minRadius)
            {
                maxRadius = minRadius;
            }

            var isStatic     = (!Tools.hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects));
            var prevDisabled = SceneHandles.disabled;
            var prevColor    = SceneHandles.color;
            var prevChanged  = GUI.changed;
            var hasChanged   = false;


            var plane = new Plane(up, Vector3.zero);

            var delta1 = GeometryUtility.ProjectPointPlane(radius - center, plane);
            var delta2 = Quaternion.AngleAxis(90, up) * delta1;

            var position0 = center + delta1;
            var position1 = center - delta1;
            var position2 = center + delta2;
            var position3 = center - delta2;


            float   size;
            Vector3 forward;
            Vector3 right;

            GeometryUtility.CalculateTangents(up, out right, out forward);



            bool noRotation = Event.current.shift;

            var isDisabled = isStatic || prevDisabled;

            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);

            Vector3 moveDelta = Vector3.zero;

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position0);
            position0   = Slider2DHandle(position0, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                moveDelta = position0 - center; hasChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position1);
            position1   = Slider2DHandle(position1, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                moveDelta = -(position1 - center); hasChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position2);
            position2   = Slider2DHandle(position2, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                moveDelta = (Quaternion.AngleAxis(-90, up) * (position2 - center)); hasChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position3);
            position3   = Slider2DHandle(position3, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                moveDelta = -(Quaternion.AngleAxis(-90, up) * (position3 - center)); hasChanged = true;
            }

            if (hasChanged)
            {
                Vector3 prevRadius = radius;
                var     newRadius  = center + moveDelta;

                var newDelta = GeometryUtility.ProjectPointPlane((newRadius - center), plane);
                var length   = newDelta.magnitude;
                if (length < minRadius || length > maxRadius)
                {
                    var direction = (length > Vector3.kEpsilon) ? newDelta.normalized : ((delta1.magnitude > Vector3.kEpsilon) ? delta1.normalized : Vector3.up);
                    length = Mathf.Max(minRadius, Mathf.Min(length, maxRadius));
                    radius = center + (length * direction);
                }
                else
                {
                    radius = newRadius;
                }

                if (noRotation)
                {
                    var magnitude = newRadius.magnitude;
                    radius = prevRadius.normalized * magnitude;
                }
            }


            GUI.changed |= prevChanged | hasChanged;

            isDisabled         = isStatic || prevDisabled || (Snapping.AxisLocking[0] && Snapping.AxisLocking[1]);
            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);


            float radiusMagnitude = delta1.magnitude;

            if (radiusMagnitude > 0 && renderDisc)
            {
                SceneHandles.DrawWireDisc(center, up, radiusMagnitude);
            }


            SceneHandles.disabled = prevDisabled;
            SceneHandles.color    = prevColor;
            return(radius);
        }
Ejemplo n.º 6
0
        public static bool Radius2DHandle(Vector3 center, Vector3 up, ref Vector3 radius1, ref Vector3 radius2, float minRadius1 = 0, float minRadius2 = 0, float maxRadius1 = float.PositiveInfinity, float maxRadius2 = float.PositiveInfinity, bool renderDisc = true)
        {
            var positionId0 = GUIUtility.GetControlID(s_Radius2DHash, FocusType.Keyboard);
            var positionId1 = GUIUtility.GetControlID(s_Radius2DHash, FocusType.Keyboard);
            var positionId2 = GUIUtility.GetControlID(s_Radius2DHash, FocusType.Keyboard);
            var positionId3 = GUIUtility.GetControlID(s_Radius2DHash, FocusType.Keyboard);

            minRadius1 = Mathf.Abs(minRadius1);
            minRadius2 = Mathf.Abs(minRadius2);
            maxRadius1 = Mathf.Abs(maxRadius1); if (maxRadius1 < minRadius1)
            {
                maxRadius1 = minRadius1;
            }
            maxRadius2 = Mathf.Abs(maxRadius2); if (maxRadius2 < minRadius2)
            {
                maxRadius2 = minRadius2;
            }

            var isStatic     = (!Tools.hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects));
            var prevColor    = SceneHandles.color;
            var prevMatrix   = SceneHandles.matrix;
            var prevDisabled = SceneHandles.disabled;
            var prevChanged  = GUI.changed;

            float   size;
            Vector3 forward;
            Vector3 right;

            GeometryUtility.CalculateTangents(up, out right, out forward);

            var plane = new Plane(up, Vector3.zero);

            var delta1 = GeometryUtility.ProjectPointPlane(radius1 - center, plane);
            var delta2 = GeometryUtility.ProjectPointPlane(radius2 - center, plane);

            var delta1Magnitude = delta1.magnitude;
            var delta2Magnitude = delta2.magnitude;

            var delta1Normalized = (delta1Magnitude < Vector3.kEpsilon) ? Vector3.zero : (delta1 / delta1Magnitude);
            var delta2Normalized = (delta2Magnitude < Vector3.kEpsilon) ? Vector3.zero : (delta2 / delta2Magnitude);

            // useful to have when modifying the 'other' one
            var rotatedDelta1 = Quaternion.AngleAxis(-90, up) * delta1Normalized;
            var rotatedDelta2 = Quaternion.AngleAxis(90, up) * delta2Normalized;


            var position0 = center + delta1;
            var position1 = center - delta1;
            var position2 = center + delta2;
            var position3 = center - delta2;

            var isDisabled = isStatic || prevDisabled;

            SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);

            bool noRotation = Event.current.shift;

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position0);
            position0   = Slider2DHandle(positionId0, position0, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                var     moveDelta = (position0 - center);
                Vector3 newRadius;
                if (noRotation)
                {
                    newRadius = GeometryUtility.ProjectPointRay(center + moveDelta, center, rotatedDelta2);
                }
                else
                {
                    newRadius = center + moveDelta;
                }

                var newDelta = GeometryUtility.ProjectPointPlane(newRadius - center, plane);
                delta1Magnitude = newDelta.magnitude;

                if (!noRotation && delta1Magnitude > Vector3.kEpsilon)
                {
                    radius2 = center + ((Quaternion.AngleAxis(-90, up) * (newDelta / delta1Magnitude)) * delta2Magnitude);
                }

                // set this after setting radius2 since both may lead to same variable
                delta1      = newDelta;
                radius1     = newRadius;
                prevChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position1);
            position1   = Slider2DHandle(positionId1, position1, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                var     moveDelta = (position1 - center);
                Vector3 newRadius;
                if (noRotation)
                {
                    newRadius = GeometryUtility.ProjectPointRay(center - moveDelta, center, rotatedDelta2);
                }
                else
                {
                    newRadius = center - moveDelta;
                }

                var newDelta = GeometryUtility.ProjectPointPlane(newRadius - center, plane);
                delta1Magnitude = newDelta.magnitude;

                if (!noRotation && delta1Magnitude > Vector3.kEpsilon)
                {
                    radius2 = center + ((Quaternion.AngleAxis(-90, up) * (newDelta / delta1Magnitude)) * delta2Magnitude);
                }

                // set this after setting radius2 since both may lead to same variable
                delta1      = newDelta;
                radius1     = newRadius;
                prevChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position2);
            position2   = Slider2DHandle(positionId2, position2, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                var     moveDelta = (position2 - center);
                Vector3 newRadius;
                if (noRotation)
                {
                    newRadius = GeometryUtility.ProjectPointRay(center + moveDelta, center, rotatedDelta1);
                }
                else
                {
                    newRadius = center + moveDelta;
                }

                var newDelta = GeometryUtility.ProjectPointPlane(newRadius - center, plane);
                delta2Magnitude = newDelta.magnitude;

                if (!noRotation && delta2Magnitude > Vector3.kEpsilon)
                {
                    radius1 = center + ((Quaternion.AngleAxis(90, up) * (newDelta / delta2Magnitude)) * delta1Magnitude);
                }

                // set this after setting radius1 since both may lead to same variable
                delta2      = newDelta;
                radius2     = newRadius;
                prevChanged = true;
            }

            GUI.changed = false;
            size        = UnityEditor.HandleUtility.GetHandleSize(position3);
            position3   = Slider2DHandle(positionId3, position3, Vector3.zero, up, forward, right, size * 0.05f, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                var     moveDelta = (position3 - center);
                Vector3 newRadius;
                if (noRotation)
                {
                    newRadius = GeometryUtility.ProjectPointRay(center - moveDelta, center, rotatedDelta1);
                }
                else
                {
                    newRadius = center - moveDelta;
                }

                var newDelta = GeometryUtility.ProjectPointPlane(newRadius - center, plane);
                delta2Magnitude = newDelta.magnitude;

                if (!noRotation && delta2Magnitude > Vector3.kEpsilon)
                {
                    radius1 = center + ((Quaternion.AngleAxis(90, up) * (newDelta / delta2Magnitude)) * delta1Magnitude);
                }

                // set this after setting radius1 since both may lead to same variable
                delta2      = newDelta;
                radius2     = newRadius;
                prevChanged = true;
            }

            GUI.changed |= prevChanged;

            if (delta1Magnitude < minRadius1 || delta1Magnitude > maxRadius1)
            {
                if (delta2Magnitude < minRadius2 || delta2Magnitude > maxRadius2)
                {
                    delta1Magnitude = Mathf.Max(minRadius1, Mathf.Min(delta1Magnitude, maxRadius1));
                    delta2Magnitude = Mathf.Max(minRadius2, Mathf.Min(delta2Magnitude, maxRadius2));

                    delta1Normalized = right;
                    delta2Normalized = up;

                    delta1 = GeometryUtility.ProjectPointPlane(delta1Normalized * delta1Magnitude, plane);
                    delta2 = GeometryUtility.ProjectPointPlane(delta2Normalized * delta2Magnitude, plane);

                    rotatedDelta2 = delta2Normalized;
                    rotatedDelta1 = delta1Normalized;

                    radius1     = center + delta1;
                    radius2     = center + delta2;
                    GUI.changed = true;
                }
                else
                {
                    delta1Magnitude  = Mathf.Max(minRadius1, Mathf.Min(delta1Magnitude, maxRadius1));
                    delta1Normalized = rotatedDelta2;
                    delta1           = GeometryUtility.ProjectPointPlane(delta1Normalized * delta1Magnitude, plane);
                    radius1          = center + delta1;
                    GUI.changed      = true;
                }
            }
            else
            if (delta2Magnitude < minRadius2 || delta2Magnitude > maxRadius2)
            {
                delta2Magnitude  = Mathf.Max(minRadius2, Mathf.Min(delta2Magnitude, maxRadius2));
                delta2Normalized = rotatedDelta1;
                delta2           = delta2Normalized * delta2Magnitude;
                radius2          = center + delta2;
                GUI.changed      = true;
            }


            if (Event.current.type == EventType.Repaint)
            {
                isDisabled         = isStatic || prevDisabled || (Snapping.AxisLocking[0] && Snapping.AxisLocking[1]);
                SceneHandles.color = SceneHandles.StateColor(prevColor, isDisabled, false);


                if (delta1Magnitude > Vector3.kEpsilon && delta2Magnitude > Vector3.kEpsilon)
                {
                    var ellipsis = Matrix4x4.TRS(center, Quaternion.identity, Vector3.one);

                    ellipsis.m00 = delta1.x;
                    ellipsis.m10 = delta1.y;
                    ellipsis.m20 = delta1.z;

                    ellipsis.m01 = delta2.x;
                    ellipsis.m11 = delta2.y;
                    ellipsis.m21 = delta2.z;

                    ellipsis.m02 = up.x;
                    ellipsis.m12 = up.y;
                    ellipsis.m22 = up.z;

                    ellipsis *= Matrix4x4.TRS(-center, Quaternion.identity, Vector3.one);

                    var newMatrix = prevMatrix * ellipsis;

                    SceneHandles.matrix = newMatrix;
                    if (renderDisc)
                    {
                        SceneHandles.DrawWireDisc(center, Vector3.forward, 1.0f);
                    }
                }
                else
                if (delta1Magnitude > Vector3.kEpsilon)
                {
                    SceneHandles.DrawLine(position0, position1);
                }
                else
                if (delta2Magnitude > Vector3.kEpsilon)
                {
                    SceneHandles.DrawLine(position2, position3);
                }
            }

            SceneHandles.disabled = prevDisabled;
            SceneHandles.matrix   = prevMatrix;
            SceneHandles.color    = prevColor;

            var focus = SceneHandleUtility.focusControl;

            return((focus == positionId0) ||
                   (focus == positionId1) ||
                   (focus == positionId2) ||
                   (focus == positionId3));
        }
Ejemplo n.º 7
0
        public static void DrawAngle(UnityEngine.Vector3 center, UnityEngine.Vector3 direction, UnityEngine.Vector3 axis, float angle)
        {
            var rotation   = UnityEngine.Quaternion.AngleAxis(angle, axis);
            var centerSize = UnityEditor.HandleUtility.GetHandleSize(center);
            var maxSize    = direction.magnitude;
            var xdir       = direction / maxSize;
            //var ydir		= UnityEngine.Vector3.Cross(xdir, axis);
            var handleSize = Mathf.Min(centerSize, maxSize);
            var drawAngle  = UnityEngine.Mathf.Clamp(angle, -360, 360);
            var realLength = Mathf.Max(1, Mathf.CeilToInt((anglePoints.Length / 360.0f) * Mathf.Abs(drawAngle)));

            var pointSize = centerSize * 0.04f;

            SceneHandles.color = SceneHandles.StateColor(SceneHandles.measureColor);
            SceneHandles.DrawAAPolyLine(center + (xdir * pointSize), center + direction);
            SceneHandles.DrawAAPolyLine(center + (rotation * (xdir * pointSize)), center + (rotation * direction));

            SceneHandles.DrawWireDisc(center, Vector3.forward, pointSize);

            direction = xdir * handleSize;
            if (UnityEngine.Mathf.Abs(angle) > 0.0f)
            {
                var angleStep = drawAngle / realLength;
                var curAngle  = 0.0f;
                for (int i = 0; i < realLength; i++)
                {
                    anglePoints[i] = center + (UnityEngine.Quaternion.AngleAxis(curAngle, axis) * direction);
                    curAngle      += angleStep;
                }
                SceneHandles.DrawDottedLines(anglePoints.Take(realLength).ToArray(), 4.0f);

                rotation = UnityEngine.Quaternion.AngleAxis(angle, axis);
                var right     = rotation * Vector3.right;
                var endPoint  = center + (rotation * direction);
                var arrowSize = handleSize * 0.2f;                  // UnityEditor.HandleUtility.GetHandleSize(endPoint) * 0.2f;

                if (angle < 0.0f)
                {
                    DrawFlatArrow(endPoint, -right, arrowSize);
                }
                else
                {
                    DrawFlatArrow(endPoint, right, arrowSize);
                }
            }

            Vector3 facing;
            Vector3 position;

            if (handleSize == maxSize)
            {
                facing   = rotation * xdir;
                position = center + (facing * handleSize);
            }
            else
            {
                var halfRotation = UnityEngine.Quaternion.AngleAxis(drawAngle / 2.0f, axis);
                facing   = halfRotation * xdir;
                position = center;
            }

            DrawLabel(position, facing, 5, angle + "°");
        }
Ejemplo n.º 8
0
        public static float Radius3DHandle(Quaternion rotation, Vector3 position, float radius, float minRadius = 0, float maxRadius = float.PositiveInfinity)
        {
            minRadius = Mathf.Abs(minRadius);
            maxRadius = Mathf.Abs(maxRadius); if (maxRadius < minRadius)
            {
                maxRadius = minRadius;
            }

            const float kEpsilon = 0.000001F;

            var camera               = Camera.current;
            var cameraLocalPos       = SceneHandles.inverseMatrix.MultiplyPoint(camera.transform.position);
            var cameraLocalForward   = SceneHandles.inverseMatrix.MultiplyVector(camera.transform.forward);
            var isCameraInsideSphere = (cameraLocalPos - position).magnitude < radius;
            var isCameraOrthographic = camera.orthographic;

            var isStatic     = (!Tools.hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects));
            var prevDisabled = SceneHandles.disabled;
            var prevColor    = SceneHandles.color;

            var forward = rotation * Vector3.forward;
            var up      = rotation * Vector3.up;
            var right   = rotation * Vector3.right;

            bool guiHasChanged = GUI.changed;

            GUI.changed = false;

            Vector3 positiveXDir = right;
            Vector3 negativeXDir = -right;
            Vector3 positiveYDir = up;
            Vector3 negativeYDir = -up;
            Vector3 positiveZDir = forward;
            Vector3 negativeZDir = -forward;

            Vector3 positiveXHandle = position + positiveXDir * radius;
            Vector3 negativeXHandle = position + negativeXDir * radius;
            Vector3 positiveYHandle = position + positiveYDir * radius;
            Vector3 negativeYHandle = position + negativeYDir * radius;
            Vector3 positiveZHandle = position + positiveZDir * radius;
            Vector3 negativeZHandle = position + negativeZDir * radius;

            bool positiveXBackfaced = false;
            bool negativeXBackfaced = false;
            bool positiveYBackfaced = false;
            bool negativeYBackfaced = false;
            bool positiveZBackfaced = false;
            bool negativeZBackfaced = false;

            if (!isCameraInsideSphere)
            {
                float cosV;

                cosV = isCameraOrthographic ? Vector3.Dot(positiveXDir, -cameraLocalForward) :
                       Vector3.Dot(positiveXDir, (cameraLocalPos - positiveXHandle));
                positiveXBackfaced = (cosV < -0.0001f);

                cosV = isCameraOrthographic ? Vector3.Dot(negativeXDir, -cameraLocalForward) :
                       Vector3.Dot(negativeXDir, (cameraLocalPos - negativeXHandle));
                negativeXBackfaced = (cosV < -0.0001f);


                cosV = isCameraOrthographic ? Vector3.Dot(positiveYDir, -cameraLocalForward) :
                       Vector3.Dot(positiveYDir, (cameraLocalPos - positiveYHandle));
                positiveYBackfaced = (cosV < -0.0001f);

                cosV = isCameraOrthographic ? Vector3.Dot(negativeYDir, -cameraLocalForward) :
                       Vector3.Dot(negativeYDir, (cameraLocalPos - negativeYHandle));
                negativeYBackfaced = (cosV < -0.0001f);


                cosV = isCameraOrthographic ? Vector3.Dot(positiveZDir, -cameraLocalForward) :
                       Vector3.Dot(positiveZDir, (cameraLocalPos - positiveZHandle));
                positiveZBackfaced = (cosV < -0.0001f);

                cosV = isCameraOrthographic ? Vector3.Dot(negativeZDir, -cameraLocalForward) :
                       Vector3.Dot(negativeZDir, (cameraLocalPos - negativeZHandle));
                negativeZBackfaced = (cosV < -0.0001f);
            }

            float positiveXSize = UnityEditor.HandleUtility.GetHandleSize(positiveXHandle) * 0.05f * (positiveXBackfaced ? backfaceSizeMultiplier : 1);
            float negativeXSize = UnityEditor.HandleUtility.GetHandleSize(negativeXHandle) * 0.05f * (negativeXBackfaced ? backfaceSizeMultiplier : 1);
            float positiveYSize = UnityEditor.HandleUtility.GetHandleSize(positiveYHandle) * 0.05f * (positiveYBackfaced ? backfaceSizeMultiplier : 1);
            float negativeYSize = UnityEditor.HandleUtility.GetHandleSize(negativeYHandle) * 0.05f * (negativeYBackfaced ? backfaceSizeMultiplier : 1);
            float positiveZSize = UnityEditor.HandleUtility.GetHandleSize(positiveZHandle) * 0.05f * (positiveZBackfaced ? backfaceSizeMultiplier : 1);
            float negativeZSize = UnityEditor.HandleUtility.GetHandleSize(negativeZHandle) * 0.05f * (negativeZBackfaced ? backfaceSizeMultiplier : 1);



            var isDisabled     = isStatic || prevDisabled || Snapping.AxisLocking[0];
            var color          = SceneHandles.StateColor(prevColor, isDisabled, false);
            var backfacedColor = SceneHandles.MultiplyTransparency(color, SceneHandles.backfaceAlphaMultiplier);

            GUI.changed        = false;
            SceneHandles.color = positiveXBackfaced ? backfacedColor : color;
            positiveXHandle    = Slider2DHandle(positiveXHandle, Vector3.zero, forward, up, right, positiveXSize, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius = Vector3.Dot(positiveXHandle - position, positiveXDir); guiHasChanged = true;
            }

            GUI.changed        = false;
            SceneHandles.color = negativeXBackfaced ? backfacedColor : color;
            negativeXHandle    = Slider2DHandle(negativeXHandle, Vector3.zero, forward, up, right, negativeXSize, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius = Vector3.Dot(negativeXHandle - position, negativeXDir); guiHasChanged = true;
            }



            isDisabled     = isStatic || prevDisabled || Snapping.AxisLocking[1];
            color          = SceneHandles.StateColor(prevColor, isDisabled, false);
            backfacedColor = SceneHandles.MultiplyTransparency(color, SceneHandles.backfaceAlphaMultiplier);

            GUI.changed        = false;
            SceneHandles.color = positiveYBackfaced ? backfacedColor : color;
            positiveYHandle    = Slider2DHandle(positiveYHandle, Vector3.zero, forward, up, right, positiveYSize, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius = Vector3.Dot(positiveYHandle - position, positiveYDir); guiHasChanged = true;
            }

            GUI.changed        = false;
            SceneHandles.color = negativeYBackfaced ? backfacedColor : color;
            negativeYHandle    = Slider2DHandle(negativeYHandle, Vector3.zero, forward, up, right, negativeYSize, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius = Vector3.Dot(negativeYHandle - position, negativeYDir); guiHasChanged = true;
            }



            isDisabled     = isStatic || prevDisabled || Snapping.AxisLocking[2];
            color          = SceneHandles.StateColor(prevColor, isDisabled, false);
            backfacedColor = SceneHandles.MultiplyTransparency(color, SceneHandles.backfaceAlphaMultiplier);

            GUI.changed        = false;
            SceneHandles.color = positiveZBackfaced ? backfacedColor : color;
            positiveZHandle    = Slider2DHandle(positiveZHandle, Vector3.zero, up, forward, right, positiveZSize, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius = Vector3.Dot(positiveZHandle - position, positiveZDir); guiHasChanged = true;
            }

            GUI.changed        = false;
            SceneHandles.color = negativeZBackfaced ? backfacedColor : color;
            negativeZHandle    = Slider2DHandle(negativeZHandle, Vector3.zero, up, forward, right, negativeZSize, OutlinedDotHandleCap);
            if (GUI.changed)
            {
                radius = Vector3.Dot(negativeZHandle - position, negativeZDir); guiHasChanged = true;
            }


            radius = Mathf.Max(minRadius, Mathf.Min(Mathf.Abs(radius), maxRadius));


            GUI.changed |= guiHasChanged;

            if (radius > 0)
            {
                isDisabled     = isStatic || prevDisabled || (Snapping.AxisLocking[0] && Snapping.AxisLocking[1]);
                color          = SceneHandles.StateColor(prevColor, isDisabled, false);
                backfacedColor = SceneHandles.MultiplyTransparency(color, SceneHandles.backfaceAlphaMultiplier);
                var discOrientations = new Vector3[]
                {
                    rotation *Vector3.right,
                    rotation *Vector3.up,
                    rotation *Vector3.forward
                };

                var currentCamera   = Camera.current;
                var cameraTransform = currentCamera.transform;
                if (currentCamera.orthographic)
                {
                    var planeNormal = cameraTransform.forward;
                    SceneHandles.DrawWireDisc(position, planeNormal, radius);
                    planeNormal.Normalize();
                    for (int i = 0; i < 3; i++)
                    {
                        var discOrientation = discOrientations[i];
                        var discTangent     = Vector3.Cross(discOrientation, planeNormal);

                        // we may have view dir locked to one axis
                        if (discTangent.sqrMagnitude > kEpsilon)
                        {
                            SceneHandles.color = color;
                            SceneHandles.DrawWireArc(position, discOrientation, discTangent, 180, radius);
                            SceneHandles.color = backfacedColor;
                            SceneHandles.DrawWireArc(position, discOrientation, discTangent, -180, radius);
                        }
                    }
                }
                else
                {
                    // Since the geometry is transformed by Handles.matrix during rendering, we transform the camera position
                    // by the inverse matrix so that the two-shaded wireframe will have the proper orientation.
                    var invMatrix = SceneHandles.inverseMatrix;

                    var cameraCenter          = cameraTransform.position;
                    var cameraToCenter        = position - invMatrix.MultiplyPoint(cameraCenter);           // vector from camera to center
                    var sqrDistCameraToCenter = cameraToCenter.sqrMagnitude;
                    var sqrRadius             = radius * radius;                                            // squared radius
                    var sqrOffset             = sqrRadius * sqrRadius / sqrDistCameraToCenter;              // squared distance from actual center to drawn disc center
                    var insideAmount          = sqrOffset / sqrRadius;
                    if (insideAmount < 1)
                    {
                        if (Mathf.Abs(sqrDistCameraToCenter) < kEpsilon)
                        {
                            return(radius);
                        }

                        var horizonRadius = Mathf.Sqrt(sqrRadius - sqrOffset);
                        var horizonCenter = position - sqrRadius * cameraToCenter / sqrDistCameraToCenter;
                        SceneHandles.color = color;
                        SceneHandles.DrawWireDisc(horizonCenter, cameraToCenter, horizonRadius);

                        var planeNormal = cameraToCenter.normalized;
                        for (int i = 0; i < 3; i++)
                        {
                            var discOrientation = discOrientations[i];

                            var angleBetweenDiscAndNormal = Mathf.Acos(Vector3.Dot(discOrientation, planeNormal));
                            angleBetweenDiscAndNormal = (Mathf.PI * 0.5f) - Mathf.Min(angleBetweenDiscAndNormal, Mathf.PI - angleBetweenDiscAndNormal);

                            float f = Mathf.Tan(angleBetweenDiscAndNormal);
                            float g = Mathf.Sqrt(sqrOffset + f * f * sqrOffset) / radius;
                            if (g < 1)
                            {
                                var angleToHorizon         = Mathf.Asin(g) * Mathf.Rad2Deg;
                                var discTangent            = Vector3.Cross(discOrientation, planeNormal);
                                var vectorToPointOnHorizon = Quaternion.AngleAxis(angleToHorizon, discOrientation) * discTangent;
                                var horizonArcLength       = (90 - angleToHorizon) * 2.0f;

                                SceneHandles.color = color;
                                SceneHandles.DrawWireArc(position, discOrientation, vectorToPointOnHorizon, horizonArcLength, radius);
                                SceneHandles.color = backfacedColor;
                                SceneHandles.DrawWireArc(position, discOrientation, vectorToPointOnHorizon, horizonArcLength - 360, radius);
                            }
                            else
                            {
                                SceneHandles.color = backfacedColor;
                                SceneHandles.DrawWireDisc(position, discOrientation, radius);
                            }
                        }
                    }
                    else
                    {
                        SceneHandles.color = backfacedColor;
                        for (int i = 0; i < 3; i++)
                        {
                            var discOrientation = discOrientations[i];
                            SceneHandles.DrawWireDisc(position, discOrientation, radius);
                        }
                    }
                }
            }

            SceneHandles.disabled = prevDisabled;
            SceneHandles.color    = prevColor;

            return(radius);
        }