public void Create_UrdfJoint_Succeeds(UrdfJoint.JointTypes urdfJointType, ArticulationJointType articulationJointType)
        {
            GameObject       linkObject       = new GameObject("link");
            UrdfJoint        urdfJoint        = UrdfJoint.Create(linkObject, urdfJointType);
            ArticulationBody articulationBody = linkObject.GetComponent <ArticulationBody>();

            Assert.IsNotNull(urdfJoint);
            Assert.IsNotNull(articulationBody);
            Assert.AreEqual(urdfJointType, urdfJoint.JointType);
            Assert.AreEqual(articulationJointType, articulationBody.jointType);

            Object.DestroyImmediate(linkObject);
        }
Ejemplo n.º 2
0
        public override void OnInspectorGUI()
        {
            GUILayout.Space(5);
            urdfLink.IsBaseLink = EditorGUILayout.Toggle("Is Base Link", urdfLink.IsBaseLink);
            GUILayout.Space(5);

            EditorGUILayout.BeginVertical("HelpBox");
            jointType = (UrdfJoint.JointTypes)EditorGUILayout.EnumPopup(
                "Child Joint Type", jointType);

            if (GUILayout.Button("Add child link (with joint)"))
            {
                UrdfLink childLink = UrdfLinkExtensions.Create(urdfLink.transform);
                UrdfJoint.Create(childLink.gameObject, jointType);
            }
            EditorGUILayout.EndVertical();
        }
Ejemplo n.º 3
0
        public override void OnInspectorGUI()
        {
            urdfJoint = (UrdfJoint)target;

            GUILayout.Space(5);

            UrdfJoint.JointTypes newJointType = urdfJoint.JointType;

            EditorGUILayout.BeginVertical("HelpBox");
            newJointType = (UrdfJoint.JointTypes)EditorGUILayout.EnumPopup(
                "Type of joint", newJointType);
            if (newJointType != urdfJoint.JointType)
            {
                if (EditorUtility.DisplayDialog("Confirm joint type change",
                                                "Are you sure you want to change the joint type? This will erase all information currently stored in the joint.",
                                                "Continue", "Cancel"))
                {
                    UrdfJoint.ChangeJointType(urdfJoint.gameObject, newJointType);
                }
            }
            EditorGUILayout.EndVertical();

            showDetails = EditorGUILayout.Foldout(showDetails, "Joint URDF Configuration", true);
            if (showDetails)
            {
                urdfJoint.JointName = EditorGUILayout.TextField("Name", urdfJoint.JointName);

                if (urdfJoint.JointType != UrdfJoint.JointTypes.Fixed)
                {
                    GUILayout.BeginVertical("HelpBox");
                }
                switch (urdfJoint.JointType)
                {
                case UrdfJoint.JointTypes.Fixed:
                    break;

                case UrdfJoint.JointTypes.Continuous:
                    DisplayDynamicsMessage("HingeJoint > Spring > Damper (for damping) and Spring (for friction)");
                    DisplayAxisMessage("HingeJoint > Axis");
                    break;

                case UrdfJoint.JointTypes.Revolute:
                    DisplayDynamicsMessage("HingeJoint > Spring > Damper (for damping) and Spring (for friction)");
                    DisplayAxisMessage("HingeJoint > Axis");
                    DisplayRequiredLimitMessage("Hinge Joint Limits Manager > Large Angle Limit  / Max");
                    break;

                case UrdfJoint.JointTypes.Floating:
                    DisplayDynamicsMessage("ConfigurableJoint > xDrive > Position Damper (for Damping) and Position Spring (for friction)");
                    break;

                case UrdfJoint.JointTypes.Prismatic:
                    DisplayDynamicsMessage("ConfigurableJoint > xDrive > Position Damper (for Damping) and Position Spring (for friction)");
                    DisplayAxisMessage("ConfigurableJoint > Axis");
                    DisplayRequiredLimitMessage("Prismatic Joint Limits Manager > Position Limit Min / Max");
                    break;

                case UrdfJoint.JointTypes.Planar:
                    DisplayDynamicsMessage("ConfigurableJoint > xDrive > Position Damper (for Damping) and Position Spring (for friction)");
                    DisplayAxisMessage("ConfigurableJoint > Axis and Secondary Axis");
                    DisplayRequiredLimitMessage("ConfigurableJoint > Linear Limit > Limit");
                    break;
                }

                if (urdfJoint.JointType != UrdfJoint.JointTypes.Fixed)
                {
                    GUILayout.EndVertical();
                }
            }
        }
Ejemplo n.º 4
0
        public static void Create(GameObject linkObject, UrdfJoint.JointTypes jointType, Joint joint)
        {
            Rigidbody parentRigidbody = linkObject.transform.parent.gameObject.GetComponent <Rigidbody>();

            if (parentRigidbody == null)
            {
                Debug.LogError("No rigidbody (intertial) in joints parent link, not adding joint.");
                return;
            }

            if (jointType == UrdfJoint.JointTypes.Fixed)
            {
                UnityEngine.Joint unityJoint = linkObject.AddComponent <FixedJoint>();
                unityJoint.autoConfigureConnectedAnchor = true;
                unityJoint.connectedBody = linkObject.transform.parent.gameObject.GetComponent <Rigidbody>();
            }
            else if (jointType == UrdfJoint.JointTypes.Continuous)
            {
                UnityEngine.Joint unityJoint = linkObject.AddComponent <HingeJoint>();
                unityJoint.autoConfigureConnectedAnchor = true;
                unityJoint.connectedBody = linkObject.transform.parent.gameObject.GetComponent <Rigidbody>();
                unityJoint.axis          = (joint.axis != null) ? GetAxis(joint.axis) : GetDefaultAxis();
                JointInterface jointInterface = linkObject.AddComponent <JointInterface>();
                jointInterface.JointName = joint.name;
                jointInterface.JointType = "continuous";
            }
            else if (jointType == UrdfJoint.JointTypes.Revolute)
            {
                HingeJoint unityJoint = linkObject.AddComponent <HingeJoint>();
                unityJoint.autoConfigureConnectedAnchor = true;
                unityJoint.useLimits     = true;
                unityJoint.connectedBody = linkObject.transform.parent.gameObject.GetComponent <Rigidbody>();
                unityJoint.axis          = (joint.axis != null) ? GetAxis(joint.axis) : GetDefaultAxis();

                //HingeJointLimitsManager limitsManager = linkObject.AddComponent<HingeJointLimitsManager>();
                //if (joint.limit != null)
                //{
                //    limitsManager.InitializeLimits(joint.limit, unityJoint);
                //}

                JointInterface jointInterface = linkObject.AddComponent <JointInterface>();
                jointInterface.JointName = joint.name;
                jointInterface.JointType = "revolute";
                jointInterface.Axis      = (joint.axis != null) ? GetAxis(joint.axis) : GetDefaultAxis();

                if (joint.limit != null)
                {
                    jointInterface.EnableJointLimits = true;
                    jointInterface.UpperLimit        = joint.limit.upper;
                    jointInterface.LowerLimit        = joint.limit.lower;
                }
            }
            else if (jointType == UrdfJoint.JointTypes.Prismatic)
            {
                ConfigurableJoint unityJoint = linkObject.AddComponent <ConfigurableJoint>();
                unityJoint.autoConfigureConnectedAnchor = true;
                unityJoint.connectedBody = linkObject.transform.parent.gameObject.GetComponent <Rigidbody>();
                unityJoint.axis          = (joint.axis != null) ? GetAxis(joint.axis) : GetDefaultAxis();

                JointInterface jointInterface = linkObject.AddComponent <JointInterface>();
                jointInterface.JointName = joint.name;
                jointInterface.JointType = "prismatic";
                jointInterface.Axis      = (joint.axis != null) ? GetAxis(joint.axis) : GetDefaultAxis();

                if (joint.limit != null)
                {
                    jointInterface.EnableJointLimits = true;
                    jointInterface.UpperLimit        = joint.limit.upper;
                    jointInterface.LowerLimit        = joint.limit.lower;
                }
            }
            else
            {
                Debug.LogError("Joint type not yet supported, not adding joint." + jointType);
            }
        }