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