Jakie są najczęstsze splajny, które można znaleźć w tworzeniu gier?

Podaj tutaj najczęstsze splajny występujące w rozwoju gry, ile punktów metoda potrzebuje do interpolacji krzywej i jak zbudować typ danych, który pozwala uzyskać interpolację punktów krzywej. Przykłady: krzywe Beziera, splajny B, splajny sześcienne itp.

PS: Umieszczam to jako wiki społeczności, abyśmy mogli wymienić wszystkie rodzaje interpolacji splajnów.

Najprostszym przypadkiem jest interpolacja liniowa dla linii prostej:

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

Powiedz, że t jest między [0, 1]:

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

Splajny Catmull-Rom (rodzaj sześciennego splajnu pustelnika) mogą być bardzo przydatne, jeśli masz zestaw punktów, między którymi chcesz utworzyć gładką ścieżkę (bez definiowania dodatkowych punktów kontrolnych), takich jak ścieżki kamery

Dla wszystkich matematyki zobacz:

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

Jeśli używasz D3DX, masz do dyspozycji kilka przydatnych funkcji (D3DXVec3CatmullRom)

Edycja: Niestety, jak podkreśla Jason w komentarzu, następująca odpowiedź nie dotyczy splajnów, ale dwuwymiarowej interpolacji liniowej (lub dwuliniowej ). Wybieram, aby go nie usuwać na wypadek, gdyby ktoś uznał, że jest to informacja.

Stworzyłem prosty trójwymiarowy teren, a następnie chciałem, aby moja postać wędrowała po terenie. Aby znaleźć wysokość postaci w dowolnym punkcie terenu, zastosowałem interpolację dwuliniową .

Oto kod Java, którego używam do interpolacji dwuliniowej:

/**
 * 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},
            };
    }
}

Zauważ, że interpolacja dwuububowa może dawać płynniejszą lub bardziej realistyczną interpolację w odległych punktach; ale wybieram dwuliniowe, ponieważ mam gęstą siatkę, próbując zoptymalizować (być może przedwcześnie).