Perlines Rauschen nahtlos kacheln, ohne es zu wiederholen, um eine unendliche 3D-Welt zu erzeugen

Ich arbeite seit einiger Zeit mit LWJGL an einem 3D-Spiel in Java. Ich versuche, prozedural erzeugtes unendliches 3D-Terrain zu erstellen, das um den Player herum erzeugt wird.

Bisher habe ich:

• 3D-Geländestücke, die beim Bewegen des Spielers geladen und entladen werden. Diese Stücke bestehen aus Dreiecken, nicht aus Quads, und sind 128 x 128 Eckpunkte.
• Eine Perlin-Rauschklasse, die erfolgreich Perlin-Rauschen erzeugen kann. (Ich denke, es ist eigentlich so etwas wie Wertrauschen, aber es funktioniert)
• Eine Weltklasse, die das Laden und Entladen von Chunks und das Anwenden der Höhenkarten auf die Chunks übernimmt.

All dies funktioniert so, wie es codiert ist, aber nicht so, wie ich es möchte. Ich weiß nicht, wie ich den Lärm nahtlos kacheln soll.

Wie würde ich die Lärmkachel herstellen und wie würde ich darüber hinaus große Strukturen wie Berge erzeugen, die wahrscheinlich bis zu Hunderte von Brocken einnehmen?

Folgendes passiert derzeit mit den nicht kachelnden Brocken und Geräuschen:

Hier ist mein Perlin-Rauschcode:

private float[][] perlinNoise(int width, int height, int octave, float[][] whiteNoise)
{
    float[][] result = new float[width][height];

    int samplePeriod = 1 << octave;
    float sampleFrequency = 1.0f / samplePeriod;

    for (int i = 0; i < width; i++)
    {
        int x1 = (i / samplePeriod) * samplePeriod;
        int x2 = (x1 + samplePeriod) % width;
        float xBlend = (i - x1) * sampleFrequency;

        for (int j = 0; j < height; j++)
        {
            int y1 = (j / samplePeriod) * samplePeriod;
            int y2 = (y1 + samplePeriod) % height;
            float yBlend = (j - y1) * sampleFrequency;

            float top = (float) MathHelper.interpolateLinear(whiteNoise[x1][y1], whiteNoise[x2][y1], xBlend);

            float bottom = (float) MathHelper.interpolateLinear(whiteNoise[x1][y2], whiteNoise[x2][y2], xBlend);

            result[i][j] = (float) MathHelper.interpolateLinear(top, bottom, yBlend);
        }
    }
    return result;
}

public float[][] generatePerlinNoise(int width, int height, Random random, int octaveCount)
{
    float[][] whiteNoise = new float[width][height];
    float[][][] totalNoise = new float[octaveCount][][];
    float[][] perlinNoise = new float[width][height];
    float amplitude = 1.0f;
    float totalAmplitude = 0.0f;
    float persistance = 0.5f;

    for (int i = 0; i < width; i++)
    {
        for (int j = 0; j < height; j++)
        {
            whiteNoise[i][j] = random.nextFloat() % 1;
        }
    }
    for (int i = 0; i < octaveCount; i++)
    {
        totalNoise[i] = perlinNoise(width, height, i, whiteNoise);
    }
    for (int o = octaveCount - 1; o >= 0; o--)
    {
        amplitude *= persistance;
        totalAmplitude += amplitude;

        for (int i = 0; i < width; i++)
        {
            for (int j = 0; j < height; j++)
            {
                perlinNoise[i][j] += totalNoise[o][i][j] * amplitude;
            }
        }
    }
    for (int i = 0; i < width; i++)
    {
        for (int j = 0; j < height; j++)
        {
            perlinNoise[i][j] /= totalAmplitude;
        }
    }
    return perlinNoise;
}

Ich denke, es wäre auch erwähnenswert, dass ich auch bei StackOverflow danach gefragt habe .

Alan Wolfe wurde für das, was er auf "INFINITELY tile" sagte, gewürdigt. Ein 2d-Perlin-Rauschen (oder ein 2d-einfaches Rauschen) hat kein Nahtproblem, sofern Sie sich von Rauschgrenzen fernhalten (definiert durch Fließkommadimensionierung). Referenzieren des Bildes:

und sagte, dass Sie Chunks mit 128X128 Vertex haben, in Chunk i, j berechnen Sie jeden Vertex als:

for x : 0 .. 128-1
 for y : 0 .. 128-1
  PerlinNoise2d.getValue(i*128 + x, j*128 + y)

Dies wird nahtlos zwischen Chunks gewähren.

Wenn Sie eine unendliche Welt unabhängig von Rauschgrenzen simulieren möchten, können Sie ein 3D-Rauschen verwenden und die Werte auf der Oberfläche einer Kugel berücksichtigen. Dies ist jedoch eine andere Geschichte.