Quais são os splines mais comuns que você encontrará no desenvolvimento de jogos?

Liste aqui os splines mais comuns encontrados no desenvolvimento de jogos, quantos pontos o método precisa para interpolar uma curva e como criar um tipo de dados que permita obter uma interpolação dos pontos da curva. Exemplos: curvas de Bézier, splines B, splines cúbicos etc.

PS: Estou colocando isso como um wiki da comunidade para que possamos listar todos os tipos de interpolação de splines.

O caso mais simples é uma interpolação linear para uma linha reta:

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

Digamos que t esteja entre [0, 1]:

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

Os splines Catmull-Rom (um tipo de spline cúbico de hermita) podem ser bastante úteis, se você tiver um conjunto de pontos nos quais deseja criar um caminho suave entre (sem definir pontos de controle adicionais), como caminhos da câmera

Para todas as matemáticas, consulte:

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

Se você estiver usando o D3DX, existem algumas funções úteis para lidar com eles (D3DXVec3CatmullRom)

Edit: Desculpe, como Jason aponta no comentário, a resposta a seguir não é sobre splines, mas sobre interpolação linear bidimensional (ou bilinear ). Estou optando por não excluí-lo, caso alguém ache informativo.

Eu criei um terreno 3D simples e depois quis que meu personagem atravessasse o terreno. Então, para encontrar a altura do personagem em qualquer ponto do terreno, usei interpolação bilinear .

Aqui está o código Java que eu uso para a interpolação bilinear:

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

Observe que a interpolação bicúbica pode apresentar interpolação mais suave ou mais realista em pontos distantes; mas eu escolho ir com o bilinear porque tenho uma grade densa, na tentativa de otimizar (talvez prematuramente).