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 });
}
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);
}
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) });
}
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();
}
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);
}
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);
}
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);
}
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);
}
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)));
}
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);
}
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);
}
}
}
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);
}