protected override IEnumerable <Vector2> GetSnapPositions(AnchoredJoint2D joint2D, AnchorInfo anchorInfo,
                                                              JointHelpers.AnchorBias bias, Vector2 anchorPosition)
    {
        if (!EditorGUI.actionKey)
        {
            return(null);
        }

        var otherBias = bias == JointHelpers.AnchorBias.Main
            ? JointHelpers.AnchorBias.Connected
            : JointHelpers.AnchorBias.Main;

        var jointWithDistance = (T)joint2D;

        var anchorSliderState     = StateObject.Get <AnchorSliderState>(anchorInfo.GetControlID("slider"));
        var currentMousePosition  = Helpers2D.GUIPointTo2DPosition(Event.current.mousePosition);
        var currentAnchorPosition = currentMousePosition - anchorSliderState.mouseOffset;

        var otherAnchorPosition = JointHelpers.GetAnchorPosition(jointWithDistance, otherBias);
        var diff = otherAnchorPosition - currentAnchorPosition;

        if (diff.magnitude <= Mathf.Epsilon)
        {
            diff = -Vector2.up;
        }

        var normalizedDiff = diff.normalized;

        var wantedAnchorPosition = otherAnchorPosition - normalizedDiff * GetDistance(jointWithDistance);

        return(new[] { wantedAnchorPosition });
    }
Exemplo n.º 2
0
 public void SetOffset(JointHelpers.AnchorBias bias, Vector2 newOffset)
 {
     if (bias == JointHelpers.AnchorBias.Connected)
     {
         connectedBodyOffset = newOffset;
         return;
     }
     mainBodyOffset = newOffset;
 }
    private static Vector2 GetWantedAnchorPosition(AnchoredJoint2D anchoredJoint2D, JointHelpers.AnchorBias bias,
                                                   Vector2 position)
    {
        var wheelJoint2D = (WheelJoint2D)anchoredJoint2D;

        var otherBias = JointHelpers.GetOppositeBias(bias);

        var worldAngle = wheelJoint2D.transform.eulerAngles.z + wheelJoint2D.suspension.angle;

        var slideRay = new Ray(JointHelpers.GetAnchorPosition(wheelJoint2D, otherBias),
                               Helpers2D.GetDirection(worldAngle));
        var wantedAnchorPosition = Helpers2D.ClosestPointToRay(slideRay, position);

        return(wantedAnchorPosition);
    }
Exemplo n.º 4
0
    protected override void ReAlignAnchors(AnchoredJoint2D joint2D, JointHelpers.AnchorBias alignmentBias)
    {
        var sliderJoint2D = (SliderJoint2D)joint2D;

        //align the angle to the connected anchor
        var direction = JointHelpers.GetConnectedAnchorPosition(joint2D) -
                        JointHelpers.GetMainAnchorPosition(joint2D);

        if (direction.magnitude > AnchorEpsilon)
        {
            var wantedAngle = Helpers2D.GetAngle(direction);

            EditorHelpers.RecordUndo("Realign angle", sliderJoint2D);
            sliderJoint2D.angle = wantedAngle - sliderJoint2D.transform.eulerAngles.z;
        }
    }
    protected override bool PostAnchorGUI(AnchoredJoint2D joint2D, AnchorInfo info, List <Vector2> otherAnchors,
                                          JointHelpers.AnchorBias bias)
    {
        var wheelJoint2D = joint2D as WheelJoint2D;

        if (wheelJoint2D == null)
        {
            return(false);
        }


        var suspensionAngleControlID = info.GetControlID("suspensionAngle");

        if (Event.current.type == EventType.repaint)
        {
            if (EditorHelpers.IsWarm(suspensionAngleControlID) && DragAndDrop.objectReferences.Length == 0)
            {
                var suspensionAngle = wheelJoint2D.suspension.angle;

                var     labelContent       = new GUIContent(String.Format("{0:0.00}", suspensionAngle));
                Vector3 mainAnchorPosition = Helpers2D.GUIPointTo2DPosition(Event.current.mousePosition);

                var fontSize = HandleUtility.GetHandleSize(mainAnchorPosition) * (1f / 64f);

                var labelOffset = fontSize * EditorHelpers.FontWithBackgroundStyle.CalcSize(labelContent).y;

                EditorHelpers.OverlayLabel(mainAnchorPosition + (Camera.current.transform.up * labelOffset),
                                           labelContent,
                                           EditorHelpers.FontWithBackgroundStyle);
            }
        }
        else
        {
            if (EditorHelpers.IsWarm(suspensionAngleControlID) &&
                DragAndDrop.objectReferences.Length == 0)
            {
                if (SceneView.lastActiveSceneView)
                {
                    SceneView.lastActiveSceneView.Repaint();
                }
            }
        }

        return(false);
    }
    protected override IEnumerable <Vector2> GetSnapPositions(AnchoredJoint2D joint2D, AnchorInfo anchorInfo,
                                                              JointHelpers.AnchorBias bias, Vector2 anchorPosition)
    {
        if (!EditorGUI.actionKey)
        {
            return(null);
        }

        var wheelJoint2D = (WheelJoint2D)joint2D;

        if (SettingsHelper.GetOrCreate(joint2D).lockAnchors ||
            Vector2.Distance(JointHelpers.GetMainAnchorPosition(joint2D),
                             JointHelpers.GetConnectedAnchorPosition(joint2D)) <= AnchorEpsilon)
        {
            return(null);
        }

        return(new[] { GetWantedAnchorPosition(wheelJoint2D, bias, anchorPosition) });
    }
Exemplo n.º 7
0
    private void DrawLinesAndDiscs(HingeJoint2D hingeJoint2D, AnchorInfo anchorInfo, JointHelpers.AnchorBias bias)
    {
        var center = JointHelpers.GetAnchorPosition(hingeJoint2D, bias);

        var scale      = editorSettings.anchorScale;
        var handleSize = HandleUtility.GetHandleSize(center) * scale;

        var mainBodyPosition      = GetTargetPosition(hingeJoint2D, JointHelpers.AnchorBias.Main);
        var connectedBodyPosition = GetTargetPosition(hingeJoint2D, JointHelpers.AnchorBias.Connected);

        var settings = SettingsHelper.GetOrCreate <HingeJoint2DSettings>(hingeJoint2D);

        if (bias == JointHelpers.AnchorBias.Main)
        {
            float angleToMain;

            if (Vector2.Distance(mainBodyPosition, center) > AnchorEpsilon)
            {
                angleToMain = Helpers2D.GetAngle(mainBodyPosition - center);
            }
            else
            {
                angleToMain = JointHelpers.GetTargetRotation(hingeJoint2D, JointHelpers.AnchorBias.Main);
            }

            using (new HandleColor(GetAdjustedColor(editorSettings.anchorsToMainBodyColor)))
            {
                Handles.DrawLine(center,
                                 center + Helpers2D.GetDirection(angleToMain + settings.mainAngleOffset) * handleSize);
            }
        }
        else if (bias == JointHelpers.AnchorBias.Connected)
        {
            if (hingeJoint2D.connectedBody)
            {
                float angleToConnected;

                if (Vector2.Distance(connectedBodyPosition, center) > AnchorEpsilon)
                {
                    angleToConnected = Helpers2D.GetAngle(connectedBodyPosition - center);
                }
                else
                {
                    angleToConnected = JointHelpers.GetTargetRotation(hingeJoint2D, JointHelpers.AnchorBias.Connected);
                }

                using (new HandleColor(GetAdjustedColor(editorSettings.anchorsToConnectedBodyColor)))
                {
                    Handles.DrawLine(center,
                                     center + Helpers2D.GetDirection(angleToConnected + settings.connectedAngleOffset) * handleSize);
                }
            }
            else
            {
                using (new HandleColor(GetAdjustedColor(editorSettings.anchorsToConnectedBodyColor)))
                {
                    Handles.DrawLine(center, center + Helpers2D.GetDirection(settings.connectedAngleOffset) * handleSize);
                }
            }
        }

        if (settings.showDiscs)
        {
            var sliderControlID = anchorInfo.GetControlID("slider");

            if (editorSettings.ringDisplayMode == JointEditorSettings.RingDisplayMode.Always ||
                (editorSettings.ringDisplayMode == JointEditorSettings.RingDisplayMode.Hover &&
                 //if nothing else is hot and we are being hovered, or the anchor's widgets are hot
                 ((GUIUtility.hotControl == 0 && HandleUtility.nearestControl == sliderControlID) ||
                  GUIUtility.hotControl == sliderControlID))
                )
            {
                using (new HandleColor(GetAdjustedColor(editorSettings.mainRingColor)))
                {
                    Handles.DrawWireDisc(center, Vector3.forward, Vector2.Distance(center, mainBodyPosition));
                }

                if (hingeJoint2D.connectedBody)
                {
                    using (new HandleColor((editorSettings.connectedRingColor))) {
                        Handles.DrawWireDisc(center, Vector3.forward,
                                             Vector2.Distance(center,
                                                              connectedBodyPosition));
                    }
                }
            }
        }

        HandleUtility.Repaint();
    }
Exemplo n.º 8
0
    protected override bool PostAnchorGUI(AnchoredJoint2D joint2D, AnchorInfo info, List <Vector2> otherAnchors,
                                          JointHelpers.AnchorBias bias)
    {
        var hingeJoint2D = joint2D as HingeJoint2D;

        if (hingeJoint2D == null)
        {
            return(false);
        }

        if (!hingeJoint2D.useLimits)
        {
            return(false);
        }

        var   showAngle    = false;
        float angle        = 0;
        float displayAngle = 0;

        float jointAngle;

        if (EditorApplication.isPlayingOrWillChangePlaymode || Application.isPlaying)
        {
            jointAngle = hingeJoint2D.jointAngle;
        }
        else
        {
            jointAngle = 0;
        }

        var startPosition = JointHelpers.GetAnchorPosition(hingeJoint2D, bias);

        var mainBodyPosition = GetTargetPosition(hingeJoint2D, JointHelpers.AnchorBias.Main);

        var mainBodyAngle = JointHelpers.AngleFromAnchor(startPosition, mainBodyPosition,
                                                         JointHelpers.GetTargetRotation(hingeJoint2D, JointHelpers.AnchorBias.Main));

        var connectedBodyPosition = GetTargetPosition(hingeJoint2D, JointHelpers.AnchorBias.Connected);

        float connectedBodyAngle;

        if (hingeJoint2D.connectedBody)
        {
            connectedBodyAngle = JointHelpers.AngleFromAnchor(startPosition, connectedBodyPosition,
                                                              JointHelpers.GetTargetRotation(hingeJoint2D, JointHelpers.AnchorBias.Connected));
        }
        else
        {
            connectedBodyAngle = 0;
        }

        var angleDiff = jointAngle - (connectedBodyAngle - mainBodyAngle);

        var liveMainAngle = connectedBodyAngle + angleDiff;

        var minMainAngle = liveMainAngle - hingeJoint2D.limits.min;
        var maxMainAngle = liveMainAngle - hingeJoint2D.limits.max;

        var labelText = "";

        float angleOffset = 0;

        var settings = SettingsHelper.GetOrCreate <HingeJoint2DSettings>(hingeJoint2D);

        if (EditorHelpers.IsWarm(info.GetControlID("lowerMainAngle")))
        {
            showAngle    = true;
            angle        = minMainAngle;
            displayAngle = hingeJoint2D.limits.min;
            labelText    = "Lower: ";
            angleOffset  = settings.mainAngleOffset;
        }
        else if (EditorHelpers.IsWarm(info.GetControlID("upperMainAngle")))
        {
            showAngle    = true;
            angle        = maxMainAngle;
            displayAngle = hingeJoint2D.limits.max;
            labelText    = "Upper: ";
            angleOffset  = settings.mainAngleOffset;
        }
        else if (EditorHelpers.IsWarm(info.GetControlID("lowerConnectedAngle")))
        {
            showAngle     = true;
            angle         = hingeJoint2D.limits.min;
            displayAngle  = angle;
            labelText     = "Lower: ";
            startPosition = JointHelpers.GetConnectedAnchorPosition(hingeJoint2D);
            angleOffset   = settings.connectedAngleOffset;
        }
        else if (EditorHelpers.IsWarm(info.GetControlID("upperConnectedAngle")))
        {
            showAngle     = true;
            angle         = hingeJoint2D.limits.max;
            labelText     = "Upper: ";
            displayAngle  = angle;
            startPosition = JointHelpers.GetConnectedAnchorPosition(hingeJoint2D);
            angleOffset   = settings.connectedAngleOffset;
        }

        LimitContext(hingeJoint2D, info.GetControlID("lowerMainAngle"), Limit.Min);
        LimitContext(hingeJoint2D, info.GetControlID("upperMainAngle"), Limit.Max);
        LimitContext(hingeJoint2D, info.GetControlID("lowerConnectedAngle"), Limit.Min);
        LimitContext(hingeJoint2D, info.GetControlID("upperConnectedAngle"), Limit.Max);

        if (showAngle)
        {
            var distanceFromCenter = GetAngleSliderRadius(startPosition);


            var anglePosition = startPosition + Helpers2D.GetDirection(angle + angleOffset) * distanceFromCenter;

            var labelContent = new GUIContent(labelText + "\n" + String.Format("{0:0.00}", displayAngle));

            var fontSize = HandleUtility.GetHandleSize(anglePosition) * (1f / 64f);

            var labelOffset = fontSize * EditorHelpers.FontWithBackgroundStyle.CalcSize(labelContent).y;

            EditorHelpers.OverlayLabel((Vector3)anglePosition + (Camera.current.transform.up * labelOffset),
                                       labelContent,
                                       EditorHelpers.FontWithBackgroundStyle);
        }
        return(false);
    }
Exemplo n.º 9
0
    private bool DrawAngleLimits(HingeJoint2D hingeJoint2D, AnchorInfo anchorInfo, JointHelpers.AnchorBias bias)
    {
        var changed  = false;
        var settings = SettingsHelper.GetOrCreate <HingeJoint2DSettings>(hingeJoint2D);

        if (!settings.showAngleLimits)
        {
            return(false);
        }

        if (hingeJoint2D.useLimits)
        {
            var limits   = hingeJoint2D.limits;
            var minLimit = limits.min;
            var maxLimit = limits.max;


            var anchorPriority = settings.anchorPriority;

            var showMain = anchorPriority == HingeJoint2DSettings.AnchorPriority.Main ||
                           anchorPriority == HingeJoint2DSettings.AnchorPriority.Both;

            var showConnected = (anchorPriority == HingeJoint2DSettings.AnchorPriority.Connected ||
                                 anchorPriority == HingeJoint2DSettings.AnchorPriority.Both);

            var anchorPosition = JointHelpers.GetAnchorPosition(hingeJoint2D, bias);

            var distanceFromCenter = GetAngleSliderRadius(anchorPosition);
            var angleHandleSize    = editorSettings.angleHandleSize;

            float jointAngle;
            var   isPlaying = EditorApplication.isPlayingOrWillChangePlaymode || Application.isPlaying;
            if (isPlaying)
            {
                jointAngle = hingeJoint2D.jointAngle;
            }
            else
            {
                jointAngle = 0;
            }

            var mainBodyPosition = GetTargetPosition(hingeJoint2D, JointHelpers.AnchorBias.Main);

            var mainBodyAngle = JointHelpers.AngleFromAnchor(anchorPosition, mainBodyPosition,
                                                             JointHelpers.GetTargetRotation(hingeJoint2D, JointHelpers.AnchorBias.Main));

            var connectedBodyPosition = GetTargetPosition(hingeJoint2D, JointHelpers.AnchorBias.Connected);

            float connectedBodyAngle;
            if (hingeJoint2D.connectedBody)
            {
                connectedBodyAngle = JointHelpers.AngleFromAnchor(anchorPosition, connectedBodyPosition,
                                                                  JointHelpers.GetTargetRotation(hingeJoint2D, JointHelpers.AnchorBias.Connected));
            }
            else
            {
                connectedBodyAngle = 0;
            }

            var angleDiff = jointAngle - (connectedBodyAngle - mainBodyAngle);

            var liveMainAngle = connectedBodyAngle + angleDiff;

            var minMainAngle = liveMainAngle - minLimit;
            var maxMainAngle = liveMainAngle - maxLimit;

            var limitDifference = maxLimit - minLimit;

            Color limitColor, limitAreaColor;
            if (!isPlaying
                &&
                ((minLimit < jointAngle && maxLimit < jointAngle) || (minLimit > jointAngle && maxLimit > jointAngle)))
            {
                limitColor     = editorSettings.incorrectLimitsColor;
                limitAreaColor = editorSettings.incorrectLimitsArea;
            }
            else
            {
                limitColor     = editorSettings.correctLimitsColor;
                limitAreaColor = editorSettings.limitsAreaColor;
            }

            var angleWidgetColor = editorSettings.angleWidgetColor;
            var activeAngleColor = editorSettings.activeAngleColor;
            var hoverAngleColor  = editorSettings.hoverAngleColor;

            if (isCreatedByTarget)
            {
                angleWidgetColor.a *= editorSettings.connectedJointTransparency;
                activeAngleColor.a *= editorSettings.connectedJointTransparency;
                hoverAngleColor.a  *= editorSettings.connectedJointTransparency;

                limitColor.a     *= editorSettings.connectedJointTransparency;
                limitAreaColor.a *= editorSettings.connectedJointTransparency;
            }

            if (showMain && bias != JointHelpers.AnchorBias.Connected)   //main or 'both'
            {
                changed = HandleMainLimits(hingeJoint2D, anchorInfo, limitAreaColor, limitDifference, anchorPosition, distanceFromCenter, maxMainAngle, settings, limitColor, minMainAngle, angleWidgetColor, activeAngleColor, hoverAngleColor, angleHandleSize, limits, liveMainAngle);
            }
            if (showConnected && bias != JointHelpers.AnchorBias.Main)   //connected or both?
            {
                changed = HandleConnectedLimits(hingeJoint2D, anchorInfo, mainBodyAngle, angleDiff, minLimit, maxLimit, limitAreaColor, limitDifference, anchorPosition, distanceFromCenter, settings, limitColor, angleWidgetColor, activeAngleColor, hoverAngleColor, angleHandleSize, limits, changed);
            }
        }

        return(changed);
    }
Exemplo n.º 10
0
    protected override bool SingleAnchorGUI(AnchoredJoint2D joint2D, AnchorInfo anchorInfo, JointHelpers.AnchorBias bias)
    {
        var hingeJoint2D = joint2D as HingeJoint2D;

        if (hingeJoint2D == null)
        {
            return(false);
        }

        if (bias == JointHelpers.AnchorBias.Either)
        {
            DrawLinesAndDiscs(hingeJoint2D, anchorInfo, JointHelpers.AnchorBias.Main);
            DrawLinesAndDiscs(hingeJoint2D, anchorInfo, JointHelpers.AnchorBias.Connected);
        }
        else
        {
            DrawLinesAndDiscs(hingeJoint2D, anchorInfo, bias);
        }

        var mainAnchorPosition      = JointHelpers.GetMainAnchorPosition(hingeJoint2D);
        var connectedAnchorPosition = JointHelpers.GetConnectedAnchorPosition(hingeJoint2D);

        if (bias == JointHelpers.AnchorBias.Main &&
            Vector2.Distance(mainAnchorPosition, connectedAnchorPosition) > AnchorEpsilon)
        {
            using (new HandleColor(GetAdjustedColor(Color.green))) {
                Handles.DrawLine(mainAnchorPosition, connectedAnchorPosition);
            }
        }
        return(false);
    }
Exemplo n.º 11
0
    protected override bool PreSliderGUI(AnchoredJoint2D joint2D, AnchorInfo anchorInfo, JointHelpers.AnchorBias bias)
    {
        var hingeJoint2D = joint2D as HingeJoint2D;

        if (hingeJoint2D == null)
        {
            return(false);
        }

        return(DrawAngleLimits(hingeJoint2D, anchorInfo, bias));
    }
    protected override bool SingleAnchorGUI(AnchoredJoint2D joint2D, AnchorInfo anchorInfo, JointHelpers.AnchorBias bias)
    {
        var wheelJoint2D = (WheelJoint2D)joint2D;

        var mainAnchorPosition      = JointHelpers.GetMainAnchorPosition(wheelJoint2D);
        var connectedAnchorPosition = JointHelpers.GetConnectedAnchorPosition(wheelJoint2D);

        var suspensionAngleControlID = anchorInfo.GetControlID("suspensionAngle");


        if (bias != JointHelpers.AnchorBias.Connected &&
            (GUIUtility.hotControl == suspensionAngleControlID || !Event.current.shift))
        {
            DrawAngleWidget(wheelJoint2D, suspensionAngleControlID);
        }

        var snapLineColor = GetAdjustedColor(new Color(1, 1, 1, .5f));

        //if the joint anchors are being moved, then show snap lines
        var sliderControlID = anchorInfo.GetControlID("slider");

        if (GUIUtility.hotControl == sliderControlID)
        {
            var snap = GetWantedAnchorPosition(wheelJoint2D, bias);
            using (new HandleColor(snapLineColor)) {
                Handles.DrawLine(connectedAnchorPosition, snap);
                Handles.DrawLine(mainAnchorPosition, snap);
            }
        }

        using (new HandleColor(snapLineColor))
        {
            Handles.DrawLine(mainAnchorPosition, connectedAnchorPosition);
            if (wheelJoint2D.connectedBody && GUIUtility.hotControl == suspensionAngleControlID)
            {
                Handles.DrawLine(mainAnchorPosition, GetTargetPosition(wheelJoint2D, JointHelpers.AnchorBias.Connected));
            }
        }
        return(false);
    }
Exemplo n.º 13
0
    protected override bool SingleAnchorGUI(AnchoredJoint2D joint2D, AnchorInfo anchorInfo, JointHelpers.AnchorBias bias)
    {
        var sliderJoint2D = (SliderJoint2D)joint2D;

        var mainAnchorPosition      = JointHelpers.GetMainAnchorPosition(sliderJoint2D);
        var connectedAnchorPosition = JointHelpers.GetConnectedAnchorPosition(sliderJoint2D);

        var sliderAngleControlID = anchorInfo.GetControlID("sliderAngle");

        if (bias != JointHelpers.AnchorBias.Connected &&
            (
                GUIUtility.hotControl == sliderAngleControlID ||
                GUIUtility.hotControl == anchorInfo.GetControlID("minLimit") ||
                GUIUtility.hotControl == anchorInfo.GetControlID("maxLimit") ||
                !Event.current.shift))
        {
            DrawAngleWidget(sliderJoint2D, sliderAngleControlID);

            if (sliderJoint2D.useLimits)
            {
                HandleLimits(sliderJoint2D, anchorInfo);
            }
        }

        if (GUIUtility.hotControl == anchorInfo.GetControlID("slider"))
        {
            var snap = GetWantedAnchorPosition(sliderJoint2D, bias);
            using (
                new HandleColor(new Color(1, 1, 1,
                                          isCreatedByTarget ? .5f * editorSettings.connectedJointTransparency : .5f))) {
                Handles.DrawLine(connectedAnchorPosition, snap);
                Handles.DrawLine(mainAnchorPosition, snap);
            }
        }

        using (
            new HandleColor(new Color(1, 1, 1,
                                      0.125f * (isCreatedByTarget ? editorSettings.connectedJointTransparency : 1.0f)))) {
            Handles.DrawLine(mainAnchorPosition, connectedAnchorPosition);
            if (sliderJoint2D.connectedBody && GUIUtility.hotControl == sliderAngleControlID)
            {
                Handles.DrawLine(mainAnchorPosition, GetTargetPosition(sliderJoint2D, JointHelpers.AnchorBias.Connected));
            }
        }
        return(false);
    }
 protected override Vector2 GetWantedAnchorPosition(AnchoredJoint2D anchoredJoint2D, JointHelpers.AnchorBias bias)
 {
     return(GetWantedAnchorPosition(anchoredJoint2D, bias, JointHelpers.GetAnchorPosition(anchoredJoint2D, bias)));
 }
Exemplo n.º 15
0
    protected override IEnumerable <Vector2> GetSnapPositions(AnchoredJoint2D joint2D, AnchorInfo anchorInfo, JointHelpers.AnchorBias bias, Vector2 anchorPosition)
    {
        var sliderJoint2D = (SliderJoint2D)joint2D;

        var lockAnchors            = SettingsHelper.GetOrCreate(sliderJoint2D).lockAnchors;
        var oppositeBias           = JointHelpers.GetOppositeBias(bias);
        var oppositeAnchorPosition = JointHelpers.GetAnchorPosition(sliderJoint2D, oppositeBias);

        var snapPositions = new List <Vector2>();

        Vector2[] targetPositions;

        if (joint2D.connectedBody)
        {
            targetPositions = new[] {
                GetTargetPosition(joint2D, JointHelpers.AnchorBias.Main),
                GetTargetPosition(joint2D, JointHelpers.AnchorBias.Connected)
            };
        }
        else
        {
            targetPositions = new[] {
                GetTargetPosition(joint2D, JointHelpers.AnchorBias.Main)
            };
        }

        if (sliderJoint2D.useLimits)
        {
            Ray slideRay;

            var min = sliderJoint2D.limits.min;
            var max = sliderJoint2D.limits.max;


            if (lockAnchors)
            {
                slideRay = new Ray(oppositeAnchorPosition,
                                   (anchorPosition - oppositeAnchorPosition).normalized);

                foreach (var targetPosition in targetPositions)
                {
                    if (Vector2.Distance(oppositeAnchorPosition, targetPosition) <= AnchorEpsilon)
                    {
                        continue;
                    }

                    var fromConnectedToTarget = new Ray(oppositeAnchorPosition,
                                                        (targetPosition - oppositeAnchorPosition).normalized);

                    var closestPointToRay = Helpers2D.ClosestPointToRay(fromConnectedToTarget, anchorPosition);

                    var ray = new Ray(oppositeAnchorPosition, (closestPointToRay - oppositeAnchorPosition).normalized);

                    Vector2 wantedMinPosition = ray.GetPoint(min);
                    Vector2 wantedMaxPosition = ray.GetPoint(max);

                    snapPositions.Add(wantedMinPosition);
                    snapPositions.Add(wantedMaxPosition);
                }
            }
            else
            {
                var worldAngle = sliderJoint2D.transform.eulerAngles.z + sliderJoint2D.angle;

                if (bias == JointHelpers.AnchorBias.Main)
                {
                    worldAngle += 180;
                }

                slideRay = new Ray(oppositeAnchorPosition,
                                   Helpers2D.GetDirection(worldAngle));
            }


            Vector2 minPos = slideRay.GetPoint(min);

            snapPositions.Add(minPos);


            Vector2 maxPos = slideRay.GetPoint(max);

            snapPositions.Add(maxPos);
        }

        if (lockAnchors)
        {
            //align onto the rays from either target towards the opposite bias
            foreach (var targetPosition in targetPositions)
            {
                if (Vector2.Distance(targetPosition, oppositeAnchorPosition) <= AnchorEpsilon)
                {
                    continue;
                }
                var fromConnectedToTarget = new Ray(oppositeAnchorPosition,
                                                    (targetPosition - oppositeAnchorPosition).normalized);

//                if (Helpers2D.DistanceToLine(fromConnectedToTarget, anchorPosition) < snapDistance)
                {
                    var closestPointToRay = Helpers2D.ClosestPointToRay(fromConnectedToTarget, anchorPosition);
                    snapPositions.Add(closestPointToRay);
                }
            }
        }

        if (!lockAnchors &&
            !(Vector2.Distance(JointHelpers.GetMainAnchorPosition(joint2D),
                               JointHelpers.GetConnectedAnchorPosition(joint2D)) <= AnchorEpsilon))
        {
            var wantedAnchorPosition = GetWantedAnchorPosition(sliderJoint2D, bias, anchorPosition);

            snapPositions.Add(wantedAnchorPosition);
        }

        return(snapPositions);
    }
Exemplo n.º 16
0
    private void LimitWidget(SliderJoint2D sliderJoint2D, AnchorInfo anchorInfo, JointHelpers.AnchorBias bias,
                             float worldAngle)
    {
        var anchorPosition = JointHelpers.GetAnchorPosition(sliderJoint2D, bias);

        var oppositeBias = JointHelpers.GetOppositeBias(bias);

        var oppositeAnchorPosition = JointHelpers.GetAnchorPosition(sliderJoint2D, oppositeBias);
        var direction = Helpers2D.GetDirection(worldAngle);

        if (bias == JointHelpers.AnchorBias.Connected)
        {
            direction *= -1f;
        }
        var delta = oppositeAnchorPosition - anchorPosition;

        var angleDiff = Mathf.DeltaAngle(Helpers2D.GetAngle(delta), worldAngle);

        Vector2 rotatedDelta = Helpers2D.Rotate(angleDiff) * delta;

        var wantedOppositeAnchorPosition  = anchorPosition + rotatedDelta;
        var wantedOppositeAnchorPosition2 = anchorPosition - rotatedDelta;

        var minLimitControlID = anchorInfo.GetControlID("minLimit");
        var maxLimitControlID = anchorInfo.GetControlID("maxLimit");

        LimitContext(sliderJoint2D, minLimitControlID, Limit.Min);
        LimitContext(sliderJoint2D, maxLimitControlID, Limit.Max);

        var limitColor = sliderJoint2D.limits.min > sliderJoint2D.limits.max
            ? editorSettings.incorrectLimitsColor
            : editorSettings.correctLimitsColor;

        if (isCreatedByTarget)
        {
            limitColor.a *= editorSettings.connectedJointTransparency;
        }

        using (new HandleColor(limitColor)) {
            Handles.DrawLine(anchorPosition + direction * sliderJoint2D.limits.min,
                             anchorPosition + direction * sliderJoint2D.limits.max);

            if (Event.current.type == EventType.repaint)
            {
                float fontSize;
                if (EditorHelpers.IsWarm(minLimitControlID) && DragAndDrop.objectReferences.Length == 0)
                {
                    var labelContent = new GUIContent(string.Format("Min: {0:0.00}", sliderJoint2D.limits.min));

                    var sliderPosition = anchorPosition + (direction) * (sliderJoint2D.limits.min);

                    fontSize = HandleUtility.GetHandleSize(sliderPosition) * ONE_OVER64;

                    var labelOffset = fontSize * EditorHelpers.FontWithBackgroundStyle.CalcSize(labelContent).y +
                                      fontSize * 20 *
                                      Mathf.Abs(Mathf.Cos(Mathf.Deg2Rad * Helpers2D.GetAngle(direction)));

                    EditorHelpers.OverlayLabel((Vector3)sliderPosition + (Camera.current.transform.up * labelOffset),
                                               labelContent, EditorHelpers.FontWithBackgroundStyle);
                }
                if (EditorHelpers.IsWarm(maxLimitControlID) && DragAndDrop.objectReferences.Length == 0)
                {
                    var labelContent = new GUIContent(string.Format("Max: {0:0.00}", sliderJoint2D.limits.max));

                    var sliderPosition = anchorPosition + (direction) * (sliderJoint2D.limits.max);

                    fontSize = HandleUtility.GetHandleSize(sliderPosition) * ONE_OVER64;

                    var labelOffset = fontSize * EditorHelpers.FontWithBackgroundStyle.CalcSize(labelContent).y +
                                      fontSize * 20 *
                                      Mathf.Abs(Mathf.Cos(Mathf.Deg2Rad * Helpers2D.GetAngle(direction)));

                    EditorHelpers.OverlayLabel((Vector3)sliderPosition + (Camera.current.transform.up * labelOffset),
                                               labelContent, EditorHelpers.FontWithBackgroundStyle);
                }
            }

            if (GUIUtility.hotControl == minLimitControlID ||
                GUIUtility.hotControl == maxLimitControlID)
            {
                using (
                    new HandleColor(new Color(1, 1, 1,
                                              0.25f * (isCreatedByTarget ? editorSettings.connectedJointTransparency : 1.0f)))) {
                    var handleSize = HandleUtility.GetHandleSize(wantedOppositeAnchorPosition) * ONE_OVER16;

                    Handles.DrawLine(wantedOppositeAnchorPosition - direction * handleSize,
                                     wantedOppositeAnchorPosition + direction * handleSize);
                    handleSize = HandleUtility.GetHandleSize(wantedOppositeAnchorPosition2) * ONE_OVER16;
                    Handles.DrawLine(wantedOppositeAnchorPosition2 - direction * handleSize,
                                     wantedOppositeAnchorPosition2 + direction * handleSize);
                    Handles.DrawWireArc(anchorPosition, Vector3.forward, wantedOppositeAnchorPosition, 360,
                                        Vector2.Distance(wantedOppositeAnchorPosition, anchorPosition));
                }
            }


            var actionKey = EditorGUI.actionKey;

            List <Vector2> snapList = null;
            if (actionKey)
            {
                snapList = new List <Vector2> {
                    anchorPosition,
                    wantedOppositeAnchorPosition,
                    wantedOppositeAnchorPosition2
                };
            }

            var minLimitColor = editorSettings.minLimitColor;
            var maxLimitColor = editorSettings.maxLimitColor;

            if (isCreatedByTarget)
            {
                minLimitColor.a *= editorSettings.connectedJointTransparency;
                maxLimitColor.a *= editorSettings.connectedJointTransparency;
            }

            using (new HandleColor(minLimitColor)) {
                DrawLimitSlider(sliderJoint2D, minLimitControlID, anchorPosition, direction, snapList, Limit.Min);
            }
            using (new HandleColor(maxLimitColor)) {
                DrawLimitSlider(sliderJoint2D, maxLimitControlID, anchorPosition, direction, snapList, Limit.Max);
            }
        }
    }
Exemplo n.º 17
0
 public Vector2 GetOffset(JointHelpers.AnchorBias bias)
 {
     return(bias == JointHelpers.AnchorBias.Connected ? connectedBodyOffset : mainBodyOffset);
 }
    private void DrawDistance(T jointWithDistance, AnchorInfo anchorInfo, JointHelpers.AnchorBias bias)
    {
        if (jointWithDistance == null)
        {
            return;
        }

        var otherBias = bias == JointHelpers.AnchorBias.Main
            ? JointHelpers.AnchorBias.Connected
            : JointHelpers.AnchorBias.Main;

        var anchorPosition      = JointHelpers.GetAnchorPosition(jointWithDistance, bias);
        var otherAnchorPosition = JointHelpers.GetAnchorPosition(jointWithDistance, otherBias);
        var diff = anchorPosition - otherAnchorPosition;

        if (diff.magnitude <= Mathf.Epsilon)
        {
            diff = Vector2.up * (bias == JointHelpers.AnchorBias.Connected ? 1 : -1);
        }
        var normalizedDiff = diff.normalized;

        JointHelpers.AnchorBias wantedBias;
        switch (GetSettings(jointWithDistance).anchorPriority)
        {
        case JointSettingsWithBias.AnchorPriority.Main:
            wantedBias = JointHelpers.AnchorBias.Main;
            break;

        case JointSettingsWithBias.AnchorPriority.Connected:
            wantedBias = JointHelpers.AnchorBias.Connected;
            break;

        default:
            throw new ArgumentOutOfRangeException();
        }

        if (bias == wantedBias && EditorGUI.actionKey && GUIUtility.hotControl == anchorInfo.GetControlID("slider"))
        {
            Handles.DrawWireDisc(otherAnchorPosition, Vector3.forward, GetDistance(jointWithDistance));
        }

        if (bias != wantedBias)
        {
            var distanceControlID = anchorInfo.GetControlID("distance");

            EditorGUI.BeginChangeCheck();

            float newDistance;
            using (
                new HandleColor(isCreatedByTarget
                    ? new Color(1, 1, 1, editorSettings.connectedJointTransparency)
                    : Color.white)) {
                newDistance = EditorHelpers.LineSlider(distanceControlID, otherAnchorPosition,
                                                       GetDistance(jointWithDistance), Helpers2D.GetAngle(normalizedDiff), 0.125f, true);

                EditorHelpers.DrawThickLine(anchorPosition, otherAnchorPosition + normalizedDiff * newDistance,
                                            Vector2.Distance(anchorPosition, otherAnchorPosition) > newDistance ? 2 : 1, true);
            }

            if (Event.current.type == EventType.repaint)
            {
                if (EditorHelpers.IsWarm(distanceControlID) && DragAndDrop.objectReferences.Length == 0)
                {
                    var labelContent =
                        new GUIContent(string.Format("Distance: {0:0.00}", GetDistance(jointWithDistance)));

                    var sliderPosition = otherAnchorPosition + normalizedDiff * GetDistance(jointWithDistance);

                    var fontSize = HandleUtility.GetHandleSize(sliderPosition) * (1f / 64f);

                    var labelOffset = fontSize * EditorHelpers.FontWithBackgroundStyle.CalcSize(labelContent).y +
                                      fontSize * 20 *
                                      Mathf.Abs(Mathf.Cos(Mathf.Deg2Rad * Helpers2D.GetAngle(normalizedDiff)));

                    EditorHelpers.OverlayLabel((Vector3)sliderPosition + (Camera.current.transform.up * labelOffset),
                                               labelContent, EditorHelpers.FontWithBackgroundStyle);
                }
            }


            if (EditorGUI.EndChangeCheck())
            {
                using (new Modification("Change Distance", jointWithDistance)) {
                    if (newDistance < 0)
                    {
                        SetDistance(jointWithDistance, 0f);
                    }
                    else
                    {
                        var distanceBetweenAnchors = Vector2.Distance(otherAnchorPosition, anchorPosition);
                        SetDistance(jointWithDistance,
                                    EditorGUI.actionKey && Mathf.Abs(newDistance - distanceBetweenAnchors) <
                                    HandleUtility.GetHandleSize(anchorPosition) * 0.125f
                                ? distanceBetweenAnchors
                                : newDistance);
                    }
                }
            }

            DistanceContext(jointWithDistance, distanceControlID);
        }
    }
    protected override bool SingleAnchorGUI(AnchoredJoint2D joint2D, AnchorInfo anchorInfo, JointHelpers.AnchorBias bias)
    {
        var jointWithDistance = joint2D as T;

        if (!jointWithDistance)
        {
            return(false);
        }

        var mainAnchorPosition      = JointHelpers.GetMainAnchorPosition(jointWithDistance);
        var connectedAnchorPosition = JointHelpers.GetConnectedAnchorPosition(jointWithDistance);

        if (Vector2.Distance(mainAnchorPosition, connectedAnchorPosition) > AnchorEpsilon)
        {
            using (new HandleColor(Color.green)) {
                Handles.DrawLine(mainAnchorPosition, connectedAnchorPosition);
            }
        }


        DrawDistance(jointWithDistance, anchorInfo, bias);

        Handles.DrawLine(mainAnchorPosition, connectedAnchorPosition);

        return(false);
    }