Bezier eğrisinde düzgün hareket hızı nasıl elde edilir?

Bezier eğrisi boyunca bir görüntüyü taşımaya çalışıyorum. Bu nasıl yaparım:

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

}

Benim sorunum görüntünün düzgün hareket etmemesi. Başlangıçta yavaş hareket ediyor ve sonra yavaş yavaş hızlanıyor ve sonunda çok hızlı hareket ediyor. Bu ivmeden kurtulmak için ne yapmalıyım?

Pek çok parametrik yörünge için bu soruna bir çözüm bulmak mümkündür. Buradaki fikir şudur: Bir eğri üzerinde yeterince derin zoom yaparsanız, eğrinin kendisini o noktadaki teğetinden söyleyemezsiniz.

Bu varsayımı yaparak, precompute şey (kübik Bezier eğrileri için üç, ikiden fazla vektör gerek yoktur vb ).

Bu yüzden $M(t)$ eğrisi için teğet vektörünü d M hesaplıyoruz.$\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$

Uygulama: ikinci dereceden Bezier eğrisi

Bezier eğrisinin kontrol noktaları , ve ise, yörünge şöyle ifade edilebilir:$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}$$

Yani türev:

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

Yalnızca bir yerde ve vektörlerini saklamanız gerekir . Sonra, belirli bir , uzunluğunu ilerletmek istiyorsanız , şunları yapın:$\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)}$$

Kübik Bezier eğrileri

Aynı akıl yürütme dört , , ve kontrol noktalarına sahip bir eğri için de geçerlidir :$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}$$

Türev:

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

Üç vektörü önceden hesaplıyoruz:

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

ve son formül:

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

Doğruluk sorunları

Makul bir kare hızında çalışıyorsanız, (kare süresine göre hesaplanmalıdır), yaklaşık çalışmanın çalışması için yeterince küçük olacaktır.$L$

Ancak, aşırı durumlarda yanlışlıklar yaşayabilirsiniz. Eğer çok büyük, sen 10 parçalar kullanarak, örneğin hesaplama parçalı yapabilirsiniz:$L$

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

Eğriyi yeniden örneklemeniz gerekir. Bunu yapmanın en kolay yolu, eğrinin birkaç bölümünün yay uzunluklarını hesaplamak ve bunları nereden örneklemeniz gerektiğini bulmak için kullanmaktır. Örneğin, belki de t = 0.5'te (yarı yolda), "yarıda" konumunu almak için s = 0.7 değerini eğriye geçirmelisiniz. Bunu yapmak için çeşitli eğri kesimlerinin yay uzunluklarının bir listesini kaydetmeniz gerekir.

Muhtemelen daha iyi yollar var, ama işte bunu oyunda yapmak için yazdığım bazı çok basit C # kodları. Amaç C'ye taşınması kolay olmalı:

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

Düzenleme: Kübik bir eğrinin yay uzunluğunu elde etmek imkansız olduğundan, bunun size tam yay uzunluğunu vermeyeceğini belirtmeye değer. Tüm bunlar, çeşitli bölümlerin uzunluğunu tahmin etmektir. Eğrinin uzunluğuna bağlı olarak, yeni bir segmente ulaştığında hızları değiştirmesini önlemek için çözünürlüğü artırmanız gerekebilir. Genelde ~ 100 kullanıyorum, ki bununla hiç problem yaşamadım.

Çok hafif bir çözüm, eğriye yaklaşmak yerine hıza yaklaşmaktır. Aslında bu yaklaşım eğri fonksiyonundan bağımsızdır ve türev veya yaklaşım kullanmak yerine herhangi bir tam eğri kullanmanıza olanak tanır.

İşte C # Unity 3D kodunu:

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

Çözüm, eğri işlevinden bağımsız olmasına rağmen, burada bir Bezier eğrisi üzerinde sabit bir hıza nasıl ulaşacağımı ararken aynı zamanda not etmek istedim ve sonra bu çözümü buldum. Fonksiyonun popülaritesini göz önünde bulundurursak, bu burada yardımcı olabilir.

Cocos2 hakkında hiçbir şey bilmiyorum, ancak bir sınır eğrisi bir tür parametrik denklemdir, bu nedenle x ve y değerlerinizi zaman açısından elde edebilmelisiniz.