Java LWJGL + Noise 3D Terrain Generation

Question

I'm new with the OpenGL code and I wanted to learn how to make a simple terrain, more of a chunk of blocks. I want to use SimplexNoise for this, and it's pretty difficult for me to understand how to do it.

I divided my files, to a main file that will render and "draw" all the blocks, and a chunk file, to create every chunk for itself. If you can help me understand better what I need to do, I'll appreciate it.

I need help understanding how to draw the blocks, and place the player. started with GL11.glVertexf, and GL11.glTranslatef. how can I combine them and do the things I need?

Thanks in advance, Goren.

Answer 1

I've edited the code a little bit and made it Java from http://devmag.org.za/2009/04/25/perlin-noise/

private static Random random = new Random(new Random().nextLong());

private static float[][] generateWhiteNoise(int width, int height) {
    float[][] noise = new float[width][height];

    for (int i = 0; i < width; i++) {
        for (int j = 0; j < height; j++) {
            noise[i][j] = (float) random.nextDouble() % 1;
        }
    }

    return noise;
}

private static float[][] generateSmoothNoise(float[][] baseNoise, int octave) {
    int width = baseNoise.length;
    int height = baseNoise[0].length;

    float[][] smoothNoise = new float[width][height];

    int samplePeriod = 1 << octave; // calculates 2 ^ k
    float sampleFrequency = 1.0f / samplePeriod;

    for (int i = 0; i < width; i++) {
        // calculate the horizontal sampling indices
        int sample_i0 = (i / samplePeriod) * samplePeriod;
        int sample_i1 = (sample_i0 + samplePeriod) % width; // wrap around
        float horizontal_blend = (i - sample_i0) * sampleFrequency;

        for (int j = 0; j < height; j++) {
            // calculate the vertical sampling indices
            int sample_j0 = (j / samplePeriod) * samplePeriod;
            int sample_j1 = (sample_j0 + samplePeriod) % height; // wrap
                                                                    // around
            float vertical_blend = (j - sample_j0) * sampleFrequency;

            // blend the top two corners
            float top = interpolate(baseNoise[sample_i0][sample_j0],
                    baseNoise[sample_i1][sample_j0], horizontal_blend);

            // blend the bottom two corners
            float bottom = interpolate(baseNoise[sample_i0][sample_j1],
                    baseNoise[sample_i1][sample_j1], horizontal_blend);

            // final blend
            smoothNoise[i][j] = interpolate(top, bottom, vertical_blend);
        }
    }

    return smoothNoise;
}

private static float interpolate(float x0, float x1, float alpha) {
    return x0 * (1 - alpha) + alpha * x1;
}

private static float[][] generatePerlinNoise(float[][] baseNoise,
        int octaveCount) {
    int width = baseNoise.length;
    int height = baseNoise[0].length;

    float[][][] smoothNoise = new float[octaveCount][][]; // an array of 2D
                                                            // arrays
                                                            // containing

    float persistance = 0.5f;

    // generate smooth noise
    for (int i = 0; i < octaveCount; i++) {
        smoothNoise[i] = generateSmoothNoise(baseNoise, i);
    }

    float[][] perlinNoise = new float[width][height];
    float amplitude = 0.0f; // the bigger, the more big mountains
    float totalAmplitude = 0.0f;

    // blend noise together
    for (int octave = octaveCount - 1; octave >= 0; octave--) {
        amplitude *= persistance;
        totalAmplitude += amplitude;

        for (int i = 0; i < width; i++) {
            for (int j = 0; j < height; j++) {
                perlinNoise[i][j] += smoothNoise[octave][i][j] * amplitude;
            }
        }
    }

    for (int i = 0; i < width; i++) {
        for (int j = 0; j < height; j++) {
            perlinNoise[i][j] /= totalAmplitude;
            perlinNoise[i][j] = (float) (Math.floor(perlinNoise[i][j] * 25));
        }
    }

    return perlinNoise;
}
private void generate(){
float[][] noise = generatePerlinNoise(generateWhiteNoise(width, height), 5/*octave count*/);
//...

}