Làm thế nào để đạt được tốc độ di chuyển đồng đều trên một đường cong bezier?

Tôi đang cố gắng di chuyển một hình ảnh dọc theo đường cong Bezier. Đây là cách tôi làm điều đó:

- (void)startFly
{    
 [self runAction:[CCSequence actions:
             [CCBezierBy actionWithDuration:timeFlying bezier:[self getPathWithDirection:currentDirection]],
             [CCCallFuncN actionWithTarget:self selector:@selector(endFly)],
             nil]];

}

Vấn đề của tôi là hình ảnh di chuyển không đồng đều. Ban đầu, nó di chuyển chậm và sau đó nó tăng tốc dần dần và cuối cùng nó di chuyển rất nhanh. Tôi nên làm gì để thoát khỏi sự tăng tốc này?

Có thể tính gần đúng một giải pháp cho vấn đề này đối với hầu hết các quỹ đạo tham số. Ý tưởng là như sau: nếu bạn phóng to đủ sâu trên một đường cong, bạn không thể nói chính đường cong đó từ tiếp tuyến của nó tại điểm đó.

Bằng cách đưa ra giả định này, không cần phải tính toán trước bất kỳ thứ gì ngoài hai vectơ (ba cho các đường cong Bezier hình khối, v.v. ).

Vì vậy, đối với đường cong chúng ta tính toán vectơ tiếp tuyến của nó tại điểm . Định mức của vectơ này là và do đó, quãng đường di chuyển trong một khoảng thời gian có thể xấp xỉ là . Theo sau đó, một quãng đường được di chuyển trong một khoảng thời gian .$M(t)$$\frac{dM}{dt}$$t$$\lVert \frac{dM}{dT} \rVert$$\Delta t$$\lVert \frac{dM}{dT} \rVert \Delta t$$L$$L \div \lVert \frac{dM}{dT} \rVert$

Ứng dụng: đường cong Bezier bậc hai

Nếu các điểm kiểm soát của đường cong Bezier là , và , quỹ đạo có thể được biểu thị là:$A$$B$$C$

$$\begin{align} M(t) &= (1-t)^2A + 2t(1-t)B + t^2C \\ &= t^2(A - 2B + C) + t(-2A + 2B) + A \end{align}$$

Vậy đạo hàm là:

$$\frac{dM}{dt} = t(2A - 4B + 2C) + (-2A + 2B)$$

Bạn chỉ cần lưu trữ vectơ và ở đâu đó. Sau đó, với một cho trước , nếu bạn muốn tăng chiều dài , bạn làm:$\vec v_1 = 2A - 4B + 2C$$\vec v_2 = -2A + 2B$$t$$L$

$$t = t + {L \over length(t \cdot \vec v_1 + \vec v_2)}$$

Đường cong hình khối Bezier

Lý do tương tự áp dụng cho một đường cong có bốn điểm kiểm soát , , và :$A$$B$$C$$D$

$$\begin{align} M(t) &= (1-t)^3A + 3t(1-t)^2B + 3t^2(1-t)C + t^3D \\ &= t^3(-A + 3B - 3C + D) + t^2(3A - 6B + 3C) + t(-3A + 3B) + A \end{align}$$

Đạo hàm là:

$$\frac{dM}{dt} = t^2(-3A + 9B - 9C + 3D) + t(6A - 12B + 6C) + (-3A + 3B)$$

Chúng tôi tính toán trước ba vectơ:

$$\begin{align} \vec v_1 &= -3A + 9B - 9C + 3D \\ \vec v_2 &= 6A - 12B + 6C \\ \vec v_3 &= -3A + 3B \end{align}$$

và công thức cuối cùng là:

$$t = t + {L \over length(t^2 \cdot \vec v_1 + t \cdot \vec v_2 + \vec v_3)}$$

Vấn đề chính xác

Nếu bạn đang chạy ở tốc độ khung hình hợp lý, (cần được tính theo thời lượng khung hình) sẽ đủ nhỏ để phép tính gần đúng hoạt động.$L$

Tuy nhiên, bạn có thể gặp sự không chính xác trong trường hợp cực đoan. Nếu quá lớn, bạn có thể thực hiện phép tính toán, ví dụ như sử dụng 10 phần:$L$

for (int i = 0; i < 10; i++)
    t = t + (L / 10) / length(t * v1 + v2);

Bạn cần phải chỉnh sửa lại đường cong. Cách dễ nhất để làm điều này là tính độ dài cung của một số đoạn của đường cong và sử dụng chúng để tìm ra nơi bạn nên lấy mẫu từ đó. Ví dụ: có thể tại t = 0,5 (nửa chừng), bạn nên chuyển s = 0,7 đến đường cong để có được vị trí "nửa chừng". Bạn cần lưu trữ một danh sách các độ dài cung của các đoạn đường cong khác nhau để làm điều này.

Có thể có nhiều cách tốt hơn, nhưng đây là một số mã C # rất đơn giản mà tôi đã viết để làm điều này trong trò chơi của mình. Nên dễ dàng chuyển đến Mục tiêu C:

public sealed class CurveMap<TCurve> where TCurve : struct, ICurve
{
    private readonly float[] _arcLengths;
    private readonly float _ratio;
    public float length { get; private set; }
    public TCurve curve { get; private set; }
    public bool isSet { get { return !length.isNaN(); } }
    public int resolution { get { return _arcLengths.Length; } }

    public CurveMap(int resolution)
    {
        _arcLengths = new float[resolution];
        _ratio = 1f / resolution;
        length = float.NaN;
    }

    public void set(TCurve c)
    {
        curve = c;
        Vector2 o = c.sample(0);
        float ox = o.X;
        float oy = o.Y;
        float clen = 0;
        int nSamples = _arcLengths.Length;
        for(int i = 0; i < nSamples; i++)
        {
            float t = (i + 1) * _ratio;
            Vector2 p = c.sample(t);
            float dx = ox - p.X;
            float dy = oy - p.Y;
            clen += (dx * dx + dy * dy).sqrt();
            _arcLengths[i] = clen;
            ox = p.X;
            oy = p.Y;
        }
        length = clen;
    }

    public Vector2 sample(float u)
    {
        if(u <= 0) return curve.sample(0);
        if(u >= 1) return curve.sample(1);

        int index = 0;
        int low = 0;
        int high = resolution - 1;
        float target = u * length;
        float found = float.NaN;

        // Binary search to find largest value <= target
        while(low < high)
        {
            index = (low + high) / 2;
            found = _arcLengths[index];
            if (found < target)
                low = index + 1;
            else
                high = index;
        }

        // If the value we found is greater than the target value, retreat
        if (found > target)
            index--;

        if(index < 0) return curve.sample(0);
        if(index >= resolution - 1) return curve.sample(1);

        // Linear interpolation for index
        float min = _arcLengths[index];
        float max = _arcLengths[index + 1];
        Debug.Assert(min <= target && max >= target);
        float interp = (target - min) / (max - min);
        Debug.Assert(interp >= 0 && interp <= 1);
        return curve.sample((index + interp + 1) * _ratio);
    }
}

Chỉnh sửa: Điều đáng chú ý là điều này sẽ không cung cấp cho bạn độ dài cung chính xác, vì không thể có được độ dài cung của một đường cong hình khối. Tất cả điều này không phải là ước tính độ dài của các phân khúc khác nhau. Tùy thuộc vào độ dài của đường cong, bạn có thể cần tăng độ phân giải để ngăn nó thay đổi tốc độ khi đến một đoạn mới. Tôi thường sử dụng ~ 100, mà tôi chưa bao giờ có vấn đề với.

Một giải pháp rất nhẹ là xấp xỉ tốc độ chứ không phải xấp xỉ đường cong. Trên thực tế phương pháp này độc lập với hàm đường cong và cho phép bạn sử dụng bất kỳ đường cong chính xác nào thay vì sử dụng các đạo hàm hoặc xấp xỉ.

Đây là mã cho C # Unity 3D:

public float speed; // target linear speed

// determine an initial value by checking where speedFactor converges
float speedFactor = speed / 10; 

float targetStepSize = speed / 60f; // divide by fixedUpdate frame rate
float lastStepSize;

void Update ()
{   
    // Take a note of your previous position.
    Vector3 previousPosition = transform.position;

    // Advance on the curve to the next t;
    transform.position = BezierOrOtherCurveFunction(p0, p1, ..., t);

    // Measure your movement length
    lastStepSize = Vector3.Magnitude(transform.position - previousPosition);

    // Accelerate or decelerate according to your latest step size.
    if (lastStepSize < targetStepSize) 
    {
        speedFactor *= 1.1f;
    }
    else
    {
        speedFactor *= 0.9f;
    }

    t += speedFactor * Time.deltaTime;
}

Mặc dù giải pháp không phụ thuộc vào chức năng đường cong, tôi muốn lưu ý nó ở đây vì tôi cũng đang tìm cách làm thế nào để đạt được tốc độ không đổi trên đường cong Bezier, và sau đó tôi nghĩ ra giải pháp này. Xem xét mức độ phổ biến của chức năng này có thể hữu ích ở đây.

Tôi không biết gì về cocos2, nhưng đường cong bezier là một loại phương trình tham số, vì vậy bạn sẽ có thể nhận được giá trị x và y của mình theo thời gian.