¿Cuáles son las splines más comunes que encontrarás en el desarrollo de juegos?

Enumere aquí las splines más comunes que se encuentran en el desarrollo del juego, cuántos puntos necesita el método para interpolar una curva y cómo puede construir un tipo de datos que le permita obtener una interpolación de los puntos de la curva. Ejemplos: curvas Bezier, B-Splines, Cubic Splines, etc.

PD: pongo esto como un wiki de la comunidad para que podamos enumerar todo tipo de interpolación spline.

El caso más simple es una interpolación lineal para una línea recta:

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

Digamos que t está entre [0, 1]:

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

Las splines de Catmull-Rom (un tipo de spline de hermita cúbica) pueden ser bastante útiles, si tiene un conjunto de puntos entre los que desea crear un camino suave (sin definir ningún punto de control adicional), como los caminos de la cámara

Para todas las matemáticas, vea:

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

Si está utilizando D3DX, hay algunas funciones útiles para tratar con ellos (D3DXVec3CatmullRom)

Editar: Lo sentimos, como Jason señala en el comentario, la siguiente respuesta no se trata de splines sino de interpolación bidimensional lineal (o bilineal ). Elijo no eliminarlo en caso de que alguien pueda encontrarlo informativo.

Creé un terreno 3D simple y luego quería que mi personaje caminara por el terreno. Entonces, para encontrar la altura del personaje en cualquier punto del terreno, utilicé la interpolación bilineal .

Aquí está el código Java que uso para la interpolación bilineal:

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

Tenga en cuenta que la interpolación bicúbica puede presentar una interpolación más suave o más realista en puntos distantes; pero elijo ir con bilineal porque tengo una grilla densa, en un intento de optimizar (quizás prematuramente).