Unity中父物体缩放与同步定位时曲线移动问题咨询

Great job getting the core functionality up and running—using coroutines for Lerp-based smooth transitions is a smart call! That curved movement issue you’re noticing when dealing with large, off-center child objects makes perfect sense, and it’s rooted in how position and scale interpolation interact when handled separately.

Why the Curve Happens #

When you Lerp the parent’s position and scale independently, two key problems crop up:

• The target position you calculate upfront is based on the parent’s initial scale, but as the parent scales during the animation, the child’s world space position shifts dynamically. This means your movement target is effectively changing mid-animation, forcing the parent onto a curved path.
• If the interpolation progress for position and scale isn’t perfectly synchronized (even slightly), the relative offset between the parent’s position and the child’s desired center point will wobble, amplifying the curve effect.

Step-by-Step Fixes #

1. Calculate the Correct Target Parent Position

First, you need to compute the parent’s final world position based on the target scale, not the initial scale. Here’s the key formula:

Parent’s target world position = Desired child center (world space) - (Child’s local position * Parent’s target scale)

This ensures that once the parent reaches its target scale and position, the child will land exactly at your desired center point—no surprises from scaling changes.

2. Sync Interpolation Progress for Position and Scale

Use a single interpolation factor (t) for both position and scale animations. This guarantees that position and scale change in lockstep, eliminating any desync that could cause path distortion.

3. Updated Coroutine Code Example

Here’s how to implement this in your coroutine:

IEnumerator AnimateParentToCenter(Transform targetChild, Vector3 targetParentScale, Vector3 desiredChildWorldCenter)
{
    Transform parentTransform = targetChild.parent;
    Vector3 startScale = parentTransform.localScale;
    Vector3 startPosition = parentTransform.position;

    // Calculate the exact target position for the parent (based on target scale)
    Vector3 targetParentPosition = desiredChildWorldCenter - targetChild.localPosition * targetParentScale;

    float animationDuration = 1.0f; // Adjust to your preferred speed
    float elapsedTime = 0f;

    while (elapsedTime < animationDuration)
    {
        elapsedTime += Time.deltaTime;
        float t = Mathf.Clamp01(elapsedTime / animationDuration);

        // Use the SAME t value for both scale and position Lerp
        parentTransform.localScale = Vector3.Lerp(startScale, targetParentScale, t);
        parentTransform.position = Vector3.Lerp(startPosition, targetParentPosition, t);

        yield return null;
    }

    // Ensure we end at the exact target state (prevents floating point drift)
    parentTransform.localScale = targetParentScale;
    parentTransform.position = targetParentPosition;
}

4. Bonus: Get the Correct Desired Center Point

If you’re targeting the screen center, convert it to world space properly (adjust for 2D/3D use cases):

// For 2D (orthographic camera)
Vector3 screenCenter = new Vector3(Screen.width / 2, Screen.height / 2, Camera.main.nearClipPlane);
Vector3 desiredChildWorldCenter = Camera.main.ScreenToWorldPoint(screenCenter);

// For 3D (perspective camera)
// Use a Z distance that makes sense for your scene
Vector3 screenCenter = new Vector3(Screen.width / 2, Screen.height / 2, 10f);
Vector3 desiredChildWorldCenter = Camera.main.ScreenToWorldPoint(screenCenter);

Final Notes #

By precomputing the parent’s target position with the final scale in mind and syncing the interpolation progress, you’ll eliminate the curved movement entirely. The parent will move in a straight line while scaling, and the child will end up perfectly centered as intended.

内容的提问来源于stack exchange，提问作者Dtb49