void ConfigureAnchoredJoint(AnchoredJoint2D joint, Rigidbody2D connectedBody)
{
ConfigureJoint(joint, connectedBody);
joint.autoConfigureConnectedAnchor = autoConfigureConnectedAnchor;
joint.connectedAnchor = connectedAnchor;
joint.anchor = anchor;
}
protected override void ExtraMenuItems(GenericMenu menu, AnchoredJoint2D joint)
{
base.ExtraMenuItems(menu, joint);
var springJoint2D = joint as SpringJoint2D;
var mousePosition = Event.current.mousePosition;
menu.AddItem(new GUIContent("Configure Spring"), false, () => ShowUtility("Configure Spring",
new Rect(mousePosition.x - 250, mousePosition.y + 15, 500, EditorGUIUtility.singleLineHeight * 6),
delegate(Action close, bool focused) {
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_DampingRatio"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_Frequency"));
if (EditorGUI.EndChangeCheck())
{
using (new Modification("Configure Spring", springJoint2D)) {
serializedObject.ApplyModifiedProperties();
}
}
if (GUILayout.Button("Done") ||
(Event.current.isKey &&
(Event.current.keyCode == KeyCode.Escape) &&
focused))
{
close();
}
}));
}
public static Type GetEditorType(AnchoredJoint2D joint2D)
{
Type editorType = null;
if (joint2D is HingeJoint2D)
{
editorType = typeof(HingeJoint2DEditor);
}
else if (joint2D is DistanceJoint2D)
{
editorType = typeof(DistanceJoint2DEditor);
}
else if (joint2D is SliderJoint2D)
{
editorType = typeof(SliderJoint2DEditor);
}
else if (joint2D is SpringJoint2D)
{
editorType = typeof(SpringJoint2DEditor);
}
else if (joint2D is WheelJoint2D)
{
editorType = typeof(WheelJoint2DEditor);
}
return(editorType);
}
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);
}
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);
}
public void OnSceneGUI()
{
this.anchorJoint2D = (AnchoredJoint2D)this.target;
if (this.anchorJoint2D.enabled)
{
Vector3 position = Joint2DEditor.TransformPoint(this.anchorJoint2D.transform, (Vector3)this.anchorJoint2D.anchor);
Vector3 connectedAnchor = (Vector3)this.anchorJoint2D.connectedAnchor;
if (this.anchorJoint2D.connectedBody != null)
{
connectedAnchor = Joint2DEditor.TransformPoint(this.anchorJoint2D.connectedBody.transform, connectedAnchor);
}
Vector3 vector4 = connectedAnchor - position;
Vector3 vector3 = position + ((Vector3)((vector4.normalized * HandleUtility.GetHandleSize(position)) * 0.1f));
Handles.color = Color.green;
Vector3[] points = new Vector3[] { vector3, connectedAnchor };
Handles.DrawAAPolyLine(points);
if (base.HandleAnchor(ref connectedAnchor, true))
{
connectedAnchor = Joint2DEditor.SnapToPoint(this.SnapToSprites(connectedAnchor), position, 0.13f);
if (this.anchorJoint2D.connectedBody != null)
{
connectedAnchor = Joint2DEditor.InverseTransformPoint(this.anchorJoint2D.connectedBody.transform, connectedAnchor);
}
Undo.RecordObject(this.anchorJoint2D, "Move Connected Anchor");
this.anchorJoint2D.connectedAnchor = connectedAnchor;
}
if (base.HandleAnchor(ref position, false))
{
position = Joint2DEditor.SnapToPoint(this.SnapToSprites(position), connectedAnchor, 0.13f);
Undo.RecordObject(this.anchorJoint2D, "Move Anchor");
this.anchorJoint2D.anchor = Joint2DEditor.InverseTransformPoint(this.anchorJoint2D.transform, position);
}
}
}
protected override void OwnershipMoved(AnchoredJoint2D cloneJoint)
{
//swap limits
var hingeJoint2D = cloneJoint as HingeJoint2D;
if (!hingeJoint2D)
{
return;
}
var settings = SettingsHelper.GetOrCreate <HingeJoint2DSettings>(hingeJoint2D);
if (settings.anchorPriority == HingeJoint2DSettings.AnchorPriority.Main)
{
settings.anchorPriority = HingeJoint2DSettings.AnchorPriority.Connected;
}
else if (settings.anchorPriority == HingeJoint2DSettings.AnchorPriority.Connected)
{
settings.anchorPriority = HingeJoint2DSettings.AnchorPriority.Main;
}
var useLimits = hingeJoint2D.useLimits;
var limits = hingeJoint2D.limits;
limits.min = -hingeJoint2D.limits.max;
limits.max = -hingeJoint2D.limits.min;
hingeJoint2D.limits = limits;
hingeJoint2D.useLimits = useLimits;
}
protected override void OwnershipMoved(AnchoredJoint2D cloneJoint)
{
//swap limits
var sliderJoint2D = cloneJoint as SliderJoint2D;
if (!sliderJoint2D)
{
return;
}
var settings = SettingsHelper.GetOrCreate <SliderJoint2DSettings>(sliderJoint2D);
if (settings.anchorPriority == JointSettingsWithBias.AnchorPriority.Main)
{
settings.anchorPriority = JointSettingsWithBias.AnchorPriority.Connected;
}
else if (settings.anchorPriority == JointSettingsWithBias.AnchorPriority.Connected)
{
settings.anchorPriority = JointSettingsWithBias.AnchorPriority.Main;
}
var worldAngle = sliderJoint2D.connectedBody.transform.eulerAngles.z + sliderJoint2D.angle;
sliderJoint2D.angle = (180.0f + worldAngle) - sliderJoint2D.transform.eulerAngles.z;
}
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 static Vector2 GetConnectedAnchorPosition(AnchoredJoint2D joint2D)
{
if (joint2D.connectedBody)
{
return(Helpers2D.TransformPoint(joint2D.connectedBody.transform, joint2D.connectedAnchor));
}
return(joint2D.connectedAnchor);
}
private void Start()
{
joint = GetComponent <AnchoredJoint2D>();
line = GetComponent <LineRenderer>();
line.positionCount = 2;
line.material.mainTexture = sprite.texture;
line.sortingLayerName = "JointLine";
line.SetPosition(0, joint.anchor);
}
// Use this for initialization
void Start()
{
joint = GetComponent <AnchoredJoint2D>();
joint.enabled = false;
StartTime = Time.time;
InvokeRepeating("Spawn", Offset, Timer);
InvokeRepeating("Release", Offset + Timer / 2, Timer);
}
public override void Init()
{
Joint = GetComponent <AnchoredJoint2D>();
PointsLenght = 4;
MultipliedPoints = new Vector2[PointsLenght];
IsClosed = false;
base.Init();
}
protected override void ExtraMenuItems(GenericMenu menu, AnchoredJoint2D joint)
{
base.ExtraMenuItems(menu, joint);
var jointWithDistance = joint as T;
var mousePosition = Event.current.mousePosition;
AddDistanceContextItem(jointWithDistance, menu, mousePosition);
}
public static Vector2 GetTargetPosition(AnchoredJoint2D joint2D, AnchorBias bias = AnchorBias.Either)
{
var transform = GetTargetTransform(joint2D, bias);
if (transform == null)
{
return(Vector2.zero);
}
return(transform.position);
}
void GetJoint()
{
foreach (AnchoredJoint2D joint in FindObjectsOfType <AnchoredJoint2D> ())
{
if (joint.connectedBody == body2D)
{
anchoredJoint = joint;
return;
}
}
}
// Use this for initialization
void Start()
{
m_Joint = GetComponent <AnchoredJoint2D>();
m_Rigi = GetComponent <Rigidbody2D>();
m_Joint.connectedBody = m_ConnectRigi;
m_Line = GameObject.Instantiate(m_LinePrefab.gameObject).GetComponent <ChainLine>();
m_Line.transform.SetParent(transform);
m_Line.transform.position = Vector3.zero;
m_Line.SetChainLine(transform, m_Joint.connectedBody.gameObject.transform);
m_ConnectRigi.freezeRotation = true;
}
private void OnJointBreak2D(Joint2D brokenJoint)
{
if (brokenJoint != connectionJoint)
{
return;
}
StartCoroutine(HandleJointBreaking());
connectionJoint = null;
}
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));
}
public static float GetTargetRotation(AnchoredJoint2D joint2D, AnchorBias bias = AnchorBias.Either)
{
var transform = GetTargetTransform(joint2D, bias);
if (transform == null)
{
return(0);
}
return(transform.rotation.eulerAngles.z);
}
public static Vector2 GetAnchorPosition(AnchoredJoint2D joint2D, AnchorBias bias = AnchorBias.Either)
{
switch (bias)
{
case AnchorBias.Connected:
return(GetConnectedAnchorPosition(joint2D));
default:
return(GetMainAnchorPosition(joint2D));
}
}
public void OnSceneGUI()
{
if (!target)
{
return;
}
anchorJoint2D = (AnchoredJoint2D)target;
// Ignore disabled joint.
if (!anchorJoint2D.enabled)
{
return;
}
Vector3 worldAnchor = TransformPoint(anchorJoint2D.transform, anchorJoint2D.anchor);
Vector3 worldConnectedAnchor = anchorJoint2D.connectedAnchor;
if (anchorJoint2D.connectedBody)
{
worldConnectedAnchor = TransformPoint(anchorJoint2D.connectedBody.transform, worldConnectedAnchor);
}
// Draw line between anchors
Vector3 startPoint = worldAnchor + (worldConnectedAnchor - worldAnchor).normalized * HandleUtility.GetHandleSize(worldAnchor) * 0.1f;
Handles.color = Color.green;
Handles.DrawAAPolyLine(new Vector3[] { startPoint, worldConnectedAnchor });
// Connected anchor
if (HandleAnchor(ref worldConnectedAnchor, true))
{
worldConnectedAnchor = SnapToSprites(worldConnectedAnchor);
worldConnectedAnchor = SnapToPoint(worldConnectedAnchor, worldAnchor, k_SnapDistance);
if (anchorJoint2D.connectedBody)
{
worldConnectedAnchor = InverseTransformPoint(anchorJoint2D.connectedBody.transform, worldConnectedAnchor);
}
Undo.RecordObject(anchorJoint2D, "Move Connected Anchor");
anchorJoint2D.connectedAnchor = worldConnectedAnchor;
}
// Anchor
if (HandleAnchor(ref worldAnchor, false))
{
worldAnchor = SnapToSprites(worldAnchor);
worldAnchor = SnapToPoint(worldAnchor, worldConnectedAnchor, k_SnapDistance);
Undo.RecordObject(anchorJoint2D, "Move Anchor");
anchorJoint2D.anchor = InverseTransformPoint(anchorJoint2D.transform, worldAnchor);
}
}
public static void SetWorldConnectedAnchorPosition(AnchoredJoint2D joint2D, Vector2 worldConnectedAnchor)
{
if (joint2D.connectedBody)
{
joint2D.connectedAnchor = Helpers2D.InverseTransformPoint(joint2D.connectedBody.transform,
worldConnectedAnchor);
}
else
{
joint2D.connectedAnchor = worldConnectedAnchor;
}
}
private void OnJointBreak2D(Joint2D brokenJoint)
{
if (brokenJoint != joint)
{
return;
}
// we can't delete (BoxCollider)/create blocks during phyisic simulation
bBreakBlock = true;
otherRB = joint.connectedBody;
joint = null;
}
protected override void ExtraMenuItems(GenericMenu menu, AnchoredJoint2D joint)
{
var distanceJoint2D = joint as DistanceJoint2D;
if (distanceJoint2D != null)
{
menu.AddItem(new GUIContent("Max Distance Only"), distanceJoint2D.maxDistanceOnly, () =>
{
EditorHelpers.RecordUndo("Max Distance Only", distanceJoint2D);
distanceJoint2D.maxDistanceOnly = !distanceJoint2D.maxDistanceOnly;
EditorUtility.SetDirty(distanceJoint2D);
});
}
}
public static Transform GetTargetTransform(AnchoredJoint2D joint2D, AnchorBias bias = AnchorBias.Either)
{
Transform transform;
if (bias == AnchorBias.Connected)
{
transform = joint2D.connectedBody != null ? joint2D.connectedBody.transform : null;
}
else
{
transform = joint2D.transform;
}
return(transform);
}
protected override void ExtraMenuItems(GenericMenu menu, AnchoredJoint2D joint)
{
base.ExtraMenuItems(menu, joint);
var sliderJoint2D = joint as TJointType;
if (sliderJoint2D == null)
{
return;
}
var mousePosition = Event.current.mousePosition;
AddEditAngleMenuItem(sliderJoint2D, menu, mousePosition);
}
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;
}
}
private void Update()
{
boxPointList = new Vector3[boxColliders2D.Length][];
for (int i = 0; i < boxColliders2D.Length; i++)
{
BoxCollider2D collider = boxColliders2D[i];
Vector3[] boundPoints = GetBoxPoints(collider);
boxPointList[i] = boundPoints;
}
circlePointList = new Vector3[circleColliders2D.Length][];
for (int i = 0; i < circleColliders2D.Length; i++)
{
CircleCollider2D collider = circleColliders2D[i];
Vector3[] circlePoints = GetCircleColliderPoints(collider, CIRCLE_COLLIDER_SEGMENTS);
circlePointList[i] = circlePoints;
}
polygonPointList = new Vector3[polygonColliders2D.Length][];
for (int i = 0; i < polygonColliders2D.Length; i++)
{
PolygonCollider2D collider = polygonColliders2D[i];
Vector3[] polygonPoints = GetPolygonPoints(collider);
polygonPointList[i] = polygonPoints;
}
edgePointList = new Vector3[edgeColliders2D.Length][];
for (int i = 0; i < edgeColliders2D.Length; i++)
{
EdgeCollider2D collider = edgeColliders2D[i];
Vector3[] edgePoints = GetEdgePoints(collider);
edgePointList[i] = edgePoints;
}
anchoredJointPointList = new Vector3[anchoredJoints2D.Length][];
for (int i = 0; i < anchoredJoints2D.Length; i++)
{
AnchoredJoint2D anchoredJoint = anchoredJoints2D[i];
Vector3[] anchoredJointPoints = GetAnchoredJointPoints(anchoredJoint);
anchoredJointPointList[i] = anchoredJointPoints;
}
}
