Problema di generazione del terreno a diamante quadrato

Ho implementato un algoritmo a diamante quadrato secondo questo articolo: http://www.lighthouse3d.com/opengl/terrain/index.php?mpd2

Il problema è che ho queste ripide scogliere su tutta la mappa. Succede ai bordi, quando il terreno è suddiviso ricorsivamente:

Ecco la fonte:

void DiamondSquare(unsigned x1,unsigned y1,unsigned x2,unsigned y2,float range)
    {      
    int c1 = (int)x2 - (int)x1;
    int c2 = (int)y2 - (int)y1;
    unsigned hx = (x2 - x1)/2;
    unsigned hy = (y2 - y1)/2;
    if((c1 <= 1) || (c2 <= 1))
            return;

// Diamond stage
float a = m_heightmap[x1][y1];
float b = m_heightmap[x2][y1];
float c = m_heightmap[x1][y2];
float d = m_heightmap[x2][y2];
float e = (a+b+c+d) / 4 + GetRnd() * range;

m_heightmap[x1 + hx][y1 + hy] = e;

// Square stage
float f = (a + c + e + e) / 4 + GetRnd() * range;
m_heightmap[x1][y1+hy] = f;
float g = (a + b + e + e) / 4 + GetRnd() * range;
m_heightmap[x1+hx][y1] = g;
float h = (b + d + e + e) / 4 + GetRnd() * range;
m_heightmap[x2][y1+hy] = h;
float i = (c + d + e + e) / 4 + GetRnd() * range;
m_heightmap[x1+hx][y2] = i;

DiamondSquare(x1, y1, x1+hx, y1+hy, range / 2.0);   // Upper left
DiamondSquare(x1+hx, y1, x2, y1+hy, range / 2.0);   // Upper right
DiamondSquare(x1, y1+hy, x1+hx, y2, range / 2.0);   // Lower left
DiamondSquare(x1+hx, y1+hy, x2, y2, range / 2.0);       // Lower right

}

Parametri: (x1, y1), (x2, y2) - coordinate che definiscono una regione su una heightmap (default (0,0) (128.128)). gamma - sostanzialmente max. altezza. (impostazione predefinita 32)

L'aiuto sarebbe molto apprezzato.

In ogni livello di suddivisione, il passo "quadrato" si basa sui risultati del "passo di diamante". Ma influenza anche il passo del diamante prodotto nella cella adiacente, che non si sta prendendo in considerazione. Riscriverei la funzione DiamondSquare per iterare Breadth-first, invece di depth-first come lo hai attualmente.

Il tuo primo problema è che dal momento che ricalcoli due volte i bordi quadrati, ignora il contributo del punto centrale adiacente. Ad esempio, nell'articolo a cui fai riferimento,

P = (J + G + K + E)/4 + RAND(d)

ma il tuo codice lo fa efficacemente

P = (J + G + J + E)/4 + RAND(d)

cioè tiene conto della corrente tiene conto del punto centrale due volte, non del punto centrale adiacente. Questo è il motivo per cui è necessario andare prima di tutto, in modo da avere i punti centrali precedenti calcolati.

Ecco il mio codice e l'output:.

void DiamondSquare(unsigned x1, unsigned y1, unsigned x2, unsigned y2, float range, unsigned level) {
    if (level < 1) return;

    // diamonds
    for (unsigned i = x1 + level; i < x2; i += level)
        for (unsigned j = y1 + level; j < y2; j += level) {
            float a = m_heightmap[i - level][j - level];
            float b = m_heightmap[i][j - level];
            float c = m_heightmap[i - level][j];
            float d = m_heightmap[i][j];
            float e = m_heightmap[i - level / 2][j - level / 2] = (a + b + c + d) / 4 + GetRnd() * range;
        }

    // squares
    for (unsigned i = x1 + 2 * level; i < x2; i += level)
        for (unsigned j = y1 + 2 * level; j < y2; j += level) {
            float a = m_heightmap[i - level][j - level];
            float b = m_heightmap[i][j - level];
            float c = m_heightmap[i - level][j];
            float d = m_heightmap[i][j];
            float e = m_heightmap[i - level / 2][j - level / 2];

            float f = m_heightmap[i - level][j - level / 2] = (a + c + e + m_heightmap[i - 3 * level / 2][j - level / 2]) / 4 + GetRnd() * range;
            float g = m_heightmap[i - level / 2][j - level] = (a + b + e + m_heightmap[i - level / 2][j - 3 * level / 2]) / 4 + GetRnd() * range;
        }

    DiamondSquare(x1, y1, x2, y2, range / 2, level / 2);
}

Una possibilità è che stai implementando un collegamento con l'implementazione che l'algoritmo nella tua pagina collegata non ha.

Per la fase quadrata, stai calcolando l'altezza dei punti con

float f = (a + c + e + e) / 4 + GetRnd() * range;
m_heightmap[x1][y1+hy] = f;

che l'algoritmo della pagina indica da usare se stai avvolgendo la tua mappa. Ciò dà l'impressione che si stia utilizzando il valore di altezza del "riquadro successivo" per calcolare questo valore. Nel primo caso più semplice, il punto centrale (con altezza 'e') viene utilizzato su entrambi i lati sinistro e destro per calcolare f.

Tuttavia, l'algoritmo a cui fai riferimento utilizza i valori effettivi degli altri quadrati / diamanti per aiutarti a calcolare il valore dell'altezza di questo punto quadrato. Nel loro algoritmo, il punto di secondo livello viene calcolato con la seguente formula:

N = (K + A + J + F)/4 + RAND(d)

Notare la mancanza di duplicazione di un valore lì dentro?

Penso che potresti voler provare a usare le versioni non-wrapping delle formule fornite, quelle che ricorderanno meglio, penso.

F = (A + C + E)/3 + ...
    instead of
F = (A + C + E + E)/4 + ...