Configure Joint Articulation

SDF <joint>
  │
  ├─ Import.Joint.cs: ImportJoint()
  │  ├─ Resolve parent/child links by name
  │  ├─ Create ArticulationBody on child link
  │  ├─ Call Implement.Joint methods
  │  └─ Store joint metadata on Helper.Link
  │
  └─ Implement.Joint.cs: MakeJoint()
     ├─ SetArticulationBodyRelationship() → parent-child hierarchy + anchor pose
     ├─ SetAnchor() → anchor position/rotation
     └─ Type dispatch:
        ├─ Revolute/Continuous → MakeRevoluteJoint()
        ├─ Prismatic → MakePrismaticJoint()
        ├─ Ball → MakeBallJoint()
        ├─ Universal/Revolute2 → MakeRevoluteJoint2()
        └─ Fixed → MakeFixedJoint()

// Link resolution — searches by name in the model hierarchy
var linkObjectParent = targetObject.FindTransformByName(joint.ParentName);
var linkObjectChild = targetObject.FindTransformByName(joint.ChildName);

// Create ArticulationBody if not present
var articulationBodyChild = linkObjectChild.GetComponent<ArticulationBody>();
if (articulationBodyChild == null)
	articulationBodyChild = CreateArticulationBody(linkObjectChild.gameObject);

// Establish parent-child and compute anchor pose
var anchorPose = Implement.Joint.SetArticulationBodyRelationship(
	joint, linkObjectParent, linkObjectChild);
articulationBodyChild.SetAnchor(anchorPose);

// Configure joint type
articulationBodyChild.MakeJoint(joint);

// Same model → child link becomes child of parent link
linkChild.SetParent(linkParent);

// Cross-model → child model root becomes child of parent link
modelTransformChild.SetParent(linkParent);

// Anchor pose starts at identity, then adds joint pose offset
var (jointPos, jointRot) = joint.RawPose.ToUnity();
anchorPose.position += jointPos;
anchorPose.rotation *= jointRot;

private static void MakeRevoluteJoint(this ArticulationBody body, in JointAxis axis)
{
	body.jointType = ArticulationJointType.SphericalJoint;
	body.linearDamping = 1.5f;
	body.angularDamping = 2f;

	var drive = new ArticulationDrive();

	// CRITICAL: Limits are swapped via CurveOrientation
	if (axis.HasJointLimits())
	{
		drive.lowerLimit = SDF2Unity.CurveOrientation((float)axis.Upper); // Upper → lower
		drive.upperLimit = SDF2Unity.CurveOrientation((float)axis.Lower); // Lower → upper
	}

	drive.forceLimit = double.IsInfinity(axis.Effort)
		? float.MaxValue : (float)axis.Effort;
	drive.stiffness = (float)axis.SpringStiffness;
	drive.target = SDF2Unity.CurveOrientation((float)axis.SpringReference);
	drive.damping = (float)axis.Damping;

	body.jointFriction = (float)axis.Friction;
	body.maxJointVelocity = (float)axis.MaxVelocity;

	// Axis alignment — determines which DOF is active
	var jointAxis = axis.Xyz.ToUnity().normalized;
	// Assign to xDrive/yDrive/zDrive based on dominant axis component
}

var absX = Mathf.Abs(jointAxis.x);
var absY = Mathf.Abs(jointAxis.y);
var absZ = Mathf.Abs(jointAxis.z);

if (absX >= absY && absX >= absZ)
{
	// X-dominant: rotate anchor to align, use xDrive
	body.anchorRotation *= Quaternion.FromToRotation(Vector3.right, jointAxis);
	body.xDrive = drive;
	body.twistLock = hasLimits
		? ArticulationDofLock.LimitedMotion : ArticulationDofLock.FreeMotion;
	body.swingYLock = ArticulationDofLock.LockedMotion;
	body.swingZLock = ArticulationDofLock.LockedMotion;
}
else if (absY >= absX && absY >= absZ)
{
	// Y-dominant: use yDrive, lock twist and swingZ
	body.anchorRotation *= Quaternion.FromToRotation(Vector3.up, jointAxis);
	body.yDrive = drive;
	body.twistLock = ArticulationDofLock.LockedMotion;
	body.swingYLock = hasLimits
		? ArticulationDofLock.LimitedMotion : ArticulationDofLock.FreeMotion;
	body.swingZLock = ArticulationDofLock.LockedMotion;
}
else
{
	// Z-dominant: use zDrive, lock twist and swingY
	body.anchorRotation *= Quaternion.FromToRotation(Vector3.forward, jointAxis);
	body.zDrive = drive;
	body.twistLock = ArticulationDofLock.LockedMotion;
	body.swingYLock = ArticulationDofLock.LockedMotion;
	body.swingZLock = hasLimits
		? ArticulationDofLock.LimitedMotion : ArticulationDofLock.FreeMotion;
}

private static void MakePrismaticJoint(this ArticulationBody body, in JointAxis axis)
{
	body.jointType = ArticulationJointType.PrismaticJoint;

	var drive = new ArticulationDrive();

	// Direct limit mapping (no CurveOrientation swap)
	if (axis.HasJointLimits())
	{
		drive.lowerLimit = (float)axis.Lower;
		drive.upperLimit = (float)axis.Upper;
	}

	drive.target = (float)axis.SpringReference; // No CurveOrientation
	// ... same force/stiffness/damping pattern as revolute

	// Axis alignment uses linearLockX/Y/Z instead of twist/swing
	if (absX >= absY && absX >= absZ)
	{
		body.xDrive = drive;
		body.linearLockX = hasLimits
			? ArticulationDofLock.LimitedMotion : ArticulationDofLock.FreeMotion;
		body.linearLockY = ArticulationDofLock.LockedMotion;
		body.linearLockZ = ArticulationDofLock.LockedMotion;
	}
	// ... similar for Y and Z
}

// Ball — 3-DOF free rotation
body.jointType = ArticulationJointType.SphericalJoint;
body.swingYLock = ArticulationDofLock.FreeMotion;
body.swingZLock = ArticulationDofLock.FreeMotion;
body.twistLock = ArticulationDofLock.FreeMotion;

// Fixed — no motion, zero solver iterations
body.jointType = ArticulationJointType.FixedJoint;
body.solverIterations = 0;
body.solverVelocityIterations = 0;

// Revolute2/Universal — apply axis1 then overlay axis2
MakeRevoluteJoint(body, axis1);
// Override second DOF with axis2 parameters

var linkHelper = linkObjectChild.GetComponent<Helper.Link>();
linkHelper.JointName = joint.Name;
linkHelper.JointParentLinkName = joint.ParentName;
linkHelper.JointChildLinkName = joint.ChildName;

// Axis orientation conversion differs by joint type
if (joint.Type == JointType.Prismatic)
	axisSpringReference = (float)joint.Axis.SpringReference; // Direct
else
	axisSpringReference = SDF2Unity.CurveOrientation(...);    // Curve transform

linkHelper.SetJointPoseTarget(axis1xyz, axisSpringReference,
	axis2xyz, axis2SpringReference);