Oyun geliştirmede bulacağınız en yaygın spline'lar nelerdir?

Burada oyun geliştirmede bulunan en yaygın spline'ları, yöntemin bir eğriyi enterpole etmek için kaç puan gerektiğini ve eğri noktalarının enterpolasyonunu almanızı sağlayan bir veri türünü nasıl oluşturabileceğinizi listeleyin. Örnekler: Bezier eğrileri, B-Spline'lar, Kübik Spline'lar vb.

Not: Bunu bir topluluk wiki'si olarak koyuyorum, böylece her türlü spline enterpolasyonunu listeleyebiliriz.

En basit durum düz bir çizgi için doğrusal enterpolasyon:

(x0, y0) * ------------------------ * (x1, y1)

T ifadesinin [0, 1] arasında olduğunu söyleyin:

function lerp((x0, y0), (x1, y1), t):
    return (x0+(x1-x0)*t, y0+(y1-y0)*t)

Kamera yolları gibi (ek kontrol noktalarını tanımlamaksızın) arasında düzgün bir yol oluşturmak istediğiniz bir dizi noktanız varsa, Catmull-Rom spline'lar (bir tür kübik hermite spline) oldukça yararlı olabilir.

Tüm matematik için bakınız:

http://en.wikipedia.org/wiki/Cubic_Hermite_spline

D3DX kullanıyorsanız, bunlarla başa çıkmak için bazı kullanışlı işlevler vardır (D3DXVec3CatmullRom)

Düzenleme: Üzgünüm, Jason yorumda belirttiği gibi, aşağıdaki cevap spline değil, iki boyutlu doğrusal (veya bilinear ) enterpolasyon ile ilgilidir. Birisinin bilgilendirici bulabilmesi durumunda silmemeyi tercih ediyorum.

Basit bir 3D arazi oluşturdum ve karakterimin arazi boyunca yürümesini istedim. Bu yüzden, arazinin herhangi bir noktasında karakterin yüksekliğini bulmak için bilinear enterpolasyon kullandım .

İşte bilinear enterpolasyon için kullandığım Java kodu:

/**
 * Interpolates the value of a point in a two dimensional surface using bilinear spline interpolation.
 * The value is calculated using the position of the point and the values of the 4 surrounding points.
 * Note that the returned value can be more or less than any of the values of the surrounding points. 
 * 
 * @param p A 2x2 array containing the heights of the 4 surrounding points
 * @param x The horizontal position, between 0 and 1
 * @param y The vertical position, between 0 and 1
 * @return the interpolated height
 */
private static float bilinearInterpolate (float[][] p, float x, float y) {
    return p[0][0]*(1.0f-x)*(1.0f-y) + p[1][0]*x*(1.0f-y) + p[0][1]*(1.0f-x)*y + p[1][1]*x*y;
}

/**
 * Finds a 2-dimensional array of the heights of the four points that 
 * surround (x,y).
 *
 * Uses the member variable "verts", an 2D array of Vertex objects which have
 * a member "height" that is the specific vertex's height.
 */
private float[][] nearestFour(float x, float y) {
    int xf = (int) Math.floor(x);
    int yf = (int) Math.floor(y);

    if(xf < 0 || yf < 0 || xf > verts[0].length-2 || yf > verts.length-2) {
        // TODO do something better than just return 0s
        return new float[][]{
                {0.0f, 0.0f},
                {0.0f, 0.0f}
            };
    } else {
        return new float[][]{
                {verts[yf][xf].height, verts[yf][xf+1].height},
                {verts[yf+1][xf].height, verts[yf+1][xf+1].height},
            };
    }
}

Bikubik enterpolasyonun uzak noktalarda daha pürüzsüz veya daha gerçekçi enterpolasyon gösterebileceğini unutmayın; ancak bilinear ile gitmeyi seçiyorum çünkü optimize etmek için yoğun bir ızgaram var (belki de erken).