Procedural terrain generation is a cornerstone of game development, simulations, and graphics applications. While random noise creates harsh, unnatural landscapes, Perlin Noise—developed by Ken Perlin—produces smooth, organic-looking patterns that perfectly mimic natural terrain. This guide explores implementing Perlin Noise to generate realistic 3D terrain in Java.
Understanding Perlin Noise
Perlin Noise is a gradient noise function that generates smooth, continuous values. Unlike random noise, it creates coherent patterns by interpolating between random gradients, resulting in natural-looking features like hills, valleys, and plains.
Key Characteristics:
- Smooth and Continuous: No sudden jumps between values
- Self-Similar: Exhibits fractal properties at different scales
- Controllable: Parameters allow tuning of feature size and complexity
- Natural Results: Perfect for terrain, clouds, textures, and organic patterns
Basic Perlin Noise Implementation
Let's start with a 2D Perlin Noise implementation:
import java.util.Random;
public class PerlinNoise {
private final int[] permutation;
private final Random random;
public PerlinNoise(long seed) {
this.random = new Random(seed);
this.permutation = generatePermutation();
}
private int[] generatePermutation() {
int[] p = new int[512];
// Initialize with values 0-255
for (int i = 0; i < 256; i++) {
p[i] = i;
}
// Shuffle the array
for (int i = 0; i < 256; i++) {
int j = random.nextInt(256);
int temp = p[i];
p[i] = p[j];
p[j] = temp;
}
// Duplicate for overflow prevention
for (int i = 0; i < 256; i++) {
p[256 + i] = p[i];
}
return p;
}
private double fade(double t) {
// Smooth interpolation function: 6t^5 - 15t^4 + 10t^3
return t * t * t * (t * (t * 6 - 15) + 10);
}
private double lerp(double t, double a, double b) {
return a + t * (b - a);
}
private double grad(int hash, double x, double y, double z) {
int h = hash & 15;
double u = h < 8 ? x : y;
double v = h < 4 ? y : (h == 12 || h == 14 ? x : z);
return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
}
public double noise(double x, double y, double z) {
// Find unit cube that contains the point
int X = (int) Math.floor(x) & 255;
int Y = (int) Math.floor(y) & 255;
int Z = (int) Math.floor(z) & 255;
// Find relative x, y, z of point in cube
x -= Math.floor(x);
y -= Math.floor(y);
z -= Math.floor(z);
// Compute fade curves for each dimension
double u = fade(x);
double v = fade(y);
double w = fade(z);
// Hash coordinates of the 8 cube corners
int A = permutation[X] + Y;
int AA = permutation[A] + Z;
int AB = permutation[A + 1] + Z;
int B = permutation[X + 1] + Y;
int BA = permutation[B] + Z;
int BB = permutation[B + 1] + Z;
// Add blended results from 8 corners of cube
double result = lerp(w,
lerp(v,
lerp(u, grad(permutation[AA], x, y, z),
grad(permutation[BA], x - 1, y, z)),
lerp(u, grad(permutation[AB], x, y - 1, z),
grad(permutation[BB], x - 1, y - 1, z))),
lerp(v,
lerp(u, grad(permutation[AA + 1], x, y, z - 1),
grad(permutation[BA + 1], x - 1, y, z - 1)),
lerp(u, grad(permutation[AB + 1], x, y - 1, z - 1),
grad(permutation[BB + 1], x - 1, y - 1, z - 1))));
// Normalize to [0, 1]
return (result + 1.0) / 2.0;
}
// 2D convenience method
public double noise(double x, double y) {
return noise(x, y, 0);
}
}
Generating Heightmaps
The core of terrain generation is creating a 2D heightmap using Perlin Noise:
public class HeightmapGenerator {
private final PerlinNoise perlin;
public HeightmapGenerator(long seed) {
this.perlin = new PerlinNoise(seed);
}
public double[][] generateHeightmap(int width, int height, double scale) {
return generateHeightmap(width, height, scale, 0, 0);
}
public double[][] generateHeightmap(int width, int height, double scale,
double offsetX, double offsetY) {
double[][] heightmap = new double[width][height];
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
double sampleX = (x + offsetX) / scale;
double sampleY = (y + offsetY) / scale;
heightmap[x][y] = perlin.noise(sampleX, sampleY);
}
}
return heightmap;
}
// Generate heightmap with multiple octaves (fractal noise)
public double[][] generateFractalHeightmap(int width, int height,
double scale, int octaves,
double persistence, double lacunarity) {
double[][] heightmap = new double[width][height];
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
double amplitude = 1.0;
double frequency = 1.0;
double value = 0.0;
double maxValue = 0.0;
for (int octave = 0; octave < octaves; octave++) {
double sampleX = (x * frequency) / scale;
double sampleY = (y * frequency) / scale;
double noiseValue = perlin.noise(sampleX, sampleY) * 2.0 - 1.0;
value += noiseValue * amplitude;
maxValue += amplitude;
amplitude *= persistence;
frequency *= lacunarity;
}
// Normalize the value
heightmap[x][y] = value / maxValue;
}
}
return heightmap;
}
// Normalize heightmap to 0-1 range
public double[][] normalizeHeightmap(double[][] heightmap) {
int width = heightmap.length;
int height = heightmap[0].length;
double min = Double.MAX_VALUE;
double max = Double.MIN_VALUE;
// Find min and max values
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
min = Math.min(min, heightmap[x][y]);
max = Math.max(max, heightmap[x][y]);
}
}
// Normalize to [0, 1]
double[][] normalized = new double[width][height];
double range = max - min;
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
normalized[x][y] = (heightmap[x][y] - min) / range;
}
}
return normalized;
}
}
Visualizing Heightmaps
Let's create a simple Swing visualization to see our generated terrain:
import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;
public class HeightmapVisualizer extends JPanel {
private double[][] heightmap;
private Color lowColor = Color.BLUE;
private Color highColor = Color.GREEN;
private Color peakColor = Color.WHITE;
public HeightmapVisualizer(double[][] heightmap) {
this.heightmap = heightmap;
setPreferredSize(new Dimension(heightmap.length, heightmap[0].length));
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
int width = getWidth();
int height = getHeight();
int hmWidth = heightmap.length;
int hmHeight = heightmap[0].length;
BufferedImage image = new BufferedImage(hmWidth, hmHeight, BufferedImage.TYPE_INT_RGB);
for (int x = 0; x < hmWidth; x++) {
for (int y = 0; y < hmHeight; y++) {
double value = heightmap[x][y];
Color color = getColorForHeight(value);
image.setRGB(x, y, color.getRGB());
}
}
g.drawImage(image, 0, 0, width, height, this);
}
private Color getColorForHeight(double height) {
if (height < 0.3) {
return lowColor; // Water
} else if (height < 0.6) {
return interpolateColor(lowColor, highColor, (height - 0.3) / 0.3); // Beach to grass
} else if (height < 0.8) {
return interpolateColor(highColor, Color.GRAY, (height - 0.6) / 0.2); // Grass to rock
} else {
return interpolateColor(Color.GRAY, peakColor, (height - 0.8) / 0.2); // Rock to snow
}
}
private Color interpolateColor(Color start, Color end, double factor) {
int red = (int) (start.getRed() + (end.getRed() - start.getRed()) * factor);
int green = (int) (start.getGreen() + (end.getGreen() - start.getGreen()) * factor);
int blue = (int) (start.getBlue() + (end.getBlue() - start.getBlue()) * factor);
return new Color(red, green, blue);
}
public static void visualizeHeightmap(double[][] heightmap, String title) {
JFrame frame = new JFrame(title);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
HeightmapVisualizer visualizer = new HeightmapVisualizer(heightmap);
frame.add(visualizer);
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
public static void main(String[] args) {
HeightmapGenerator generator = new HeightmapGenerator(42);
// Generate simple heightmap
double[][] simpleHeightmap = generator.generateHeightmap(512, 512, 100.0);
simpleHeightmap = generator.normalizeHeightmap(simpleHeightmap);
visualizeHeightmap(simpleHeightmap, "Simple Perlin Noise");
// Generate fractal heightmap
double[][] fractalHeightmap = generator.generateFractalHeightmap(
512, 512, 100.0, 6, 0.5, 2.0);
fractalHeightmap = generator.normalizeHeightmap(fractalHeightmap);
visualizeHeightmap(fractalHeightmap, "Fractal Perlin Noise");
}
}
3D Terrain Generation with jMonkeyEngine
Now let's create actual 3D terrain using jMonkeyEngine:
import com.jme3.app.SimpleApplication;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector3f;
import com.jme3.scene.Geometry;
import com.jme3.scene.Mesh;
import com.jme3.scene.VertexBuffer;
import com.jme3.terrain.heightmap.AbstractHeightMap;
public class PerlinTerrainDemo extends SimpleApplication {
private PerlinNoise perlin;
private int terrainSize = 128;
private float terrainScale = 2.0f;
private float heightScale = 20.0f;
@Override
public void simpleInitApp() {
// Initialize Perlin noise with seed
perlin = new PerlinNoise(42);
// Generate terrain
Geometry terrain = createTerrainGeometry();
rootNode.attachChild(terrain);
// Setup camera
cam.setLocation(new Vector3f(terrainSize / 2, 30, terrainSize / 2));
cam.lookAt(new Vector3f(terrainSize / 2, 0, terrainSize / 2), Vector3f.UNIT_Y);
// Add lighting
setupLighting();
flyCam.setMoveSpeed(50);
}
private Geometry createTerrainGeometry() {
// Generate height data
float[] heightData = generateHeightData();
// Create mesh
Mesh terrainMesh = createTerrainMesh(heightData);
// Create geometry
Geometry terrain = new Geometry("Terrain", terrainMesh);
// Create material
Material terrainMat = new Material(assetManager,
"Common/MatDefs/Light/Lighting.j3md");
terrainMat.setBoolean("UseMaterialColors", true);
terrainMat.setColor("Ambient", ColorRGBA.Green);
terrainMat.setColor("Diffuse", ColorRGBA.Green);
terrainMat.setColor("Specular", ColorRGBA.White);
terrainMat.setFloat("Shininess", 64f);
terrain.setMaterial(terrainMat);
terrain.setLocalTranslation(0, 0, 0);
return terrain;
}
private float[] generateHeightData() {
float[] heightData = new float[terrainSize * terrainSize];
// Generate fractal noise
for (int x = 0; x < terrainSize; x++) {
for (int z = 0; z < terrainSize; z++) {
double height = 0.0;
double amplitude = 1.0;
double frequency = 1.0;
double maxAmplitude = 0.0;
// Fractal noise with 4 octaves
for (int octave = 0; octave < 4; octave++) {
double sampleX = (x * frequency) / (terrainSize / terrainScale);
double sampleZ = (z * frequency) / (terrainSize / terrainScale);
double noiseValue = perlin.noise(sampleX, sampleZ) * 2.0 - 1.0;
height += noiseValue * amplitude;
maxAmplitude += amplitude;
amplitude *= 0.5; // persistence
frequency *= 2.0; // lacunarity
}
// Normalize and scale height
height /= maxAmplitude;
height = (height + 1.0) / 2.0; // Convert to [0,1]
// Apply power curve to make terrain more interesting
height = Math.pow(height, 1.5);
heightData[x * terrainSize + z] = (float) (height * heightScale);
}
}
return heightData;
}
private Mesh createTerrainMesh(float[] heightData) {
Mesh mesh = new Mesh();
int vertexCount = terrainSize * terrainSize;
int triangleCount = (terrainSize - 1) * (terrainSize - 1) * 2;
Vector3f[] vertices = new Vector3f[vertexCount];
Vector3f[] normals = new Vector3f[vertexCount];
int[] indices = new int[triangleCount * 3];
// Create vertices
for (int x = 0; x < terrainSize; x++) {
for (int z = 0; z < terrainSize; z++) {
int index = x * terrainSize + z;
float height = heightData[index];
vertices[index] = new Vector3f(x, height, z);
normals[index] = new Vector3f(0, 1, 0); // Temporary normal
}
}
// Create indices for triangles
int indicesIndex = 0;
for (int x = 0; x < terrainSize - 1; x++) {
for (int z = 0; z < terrainSize - 1; z++) {
int bottomLeft = x * terrainSize + z;
int bottomRight = bottomLeft + 1;
int topLeft = (x + 1) * terrainSize + z;
int topRight = topLeft + 1;
// First triangle
indices[indicesIndex++] = bottomLeft;
indices[indicesIndex++] = topLeft;
indices[indicesIndex++] = bottomRight;
// Second triangle
indices[indicesIndex++] = bottomRight;
indices[indicesIndex++] = topLeft;
indices[indicesIndex++] = topRight;
}
}
// Calculate normals
calculateNormals(vertices, normals, indices);
// Set mesh buffers
mesh.setBuffer(VertexBuffer.Type.Position, 3,
convertVectorArray(vertices));
mesh.setBuffer(VertexBuffer.Type.Normal, 3,
convertVectorArray(normals));
mesh.setBuffer(VertexBuffer.Type.Index, 3, indices);
mesh.updateBound();
return mesh;
}
private void calculateNormals(Vector3f[] vertices, Vector3f[] normals, int[] indices) {
// Reset normals
for (int i = 0; i < normals.length; i++) {
normals[i] = new Vector3f(0, 0, 0);
}
// Calculate face normals and accumulate
for (int i = 0; i < indices.length; i += 3) {
int i1 = indices[i];
int i2 = indices[i + 1];
int i3 = indices[i + 2];
Vector3f v1 = vertices[i1];
Vector3f v2 = vertices[i2];
Vector3f v3 = vertices[i3];
Vector3f edge1 = v2.subtract(v1);
Vector3f edge2 = v3.subtract(v1);
Vector3f normal = edge1.cross(edge2).normalize();
normals[i1].addLocal(normal);
normals[i2].addLocal(normal);
normals[i3].addLocal(normal);
}
// Normalize all normals
for (Vector3f normal : normals) {
normal.normalizeLocal();
}
}
private float[] convertVectorArray(Vector3f[] vectors) {
float[] array = new float[vectors.length * 3];
for (int i = 0; i < vectors.length; i++) {
array[i * 3] = vectors[i].x;
array[i * 3 + 1] = vectors[i].y;
array[i * 3 + 2] = vectors[i].z;
}
return array;
}
private void setupLighting() {
// jME handles basic lighting automatically with the Lighting.j3md material
// Additional directional light for better illumination
DirectionalLight sun = new DirectionalLight();
sun.setDirection(new Vector3f(-0.5f, -0.5f, -0.5f).normalizeLocal());
sun.setColor(ColorRGBA.White);
rootNode.addLight(sun);
}
public static void main(String[] args) {
PerlinTerrainDemo app = new PerlinTerrainDemo();
app.start();
}
}
Advanced Terrain Features
1. Multi-Biome Terrain
public class BiomeTerrainGenerator {
private PerlinNoise heightNoise;
private PerlinNoise moistureNoise;
private PerlinNoise temperatureNoise;
public enum Biome {
OCEAN, BEACH, GRASSLAND, FOREST, DESERT, TUNDRA, MOUNTAIN, SNOW
}
public BiomeTerrainGenerator(long seed) {
this.heightNoise = new PerlinNoise(seed);
this.moistureNoise = new PerlinNoise(seed + 1);
this.temperatureNoise = new PerlinNoise(seed + 2);
}
public Biome getBiome(double x, double z, double scale) {
double height = sampleFractalNoise(heightNoise, x, z, scale, 6, 0.5, 2.0);
double moisture = sampleFractalNoise(moistureNoise, x, z, scale, 4, 0.5, 2.0);
double temperature = sampleFractalNoise(temperatureNoise, x, z, scale, 4, 0.5, 2.0);
return determineBiome(height, moisture, temperature);
}
private double sampleFractalNoise(PerlinNoise noise, double x, double z,
double scale, int octaves,
double persistence, double lacunarity) {
double value = 0.0;
double amplitude = 1.0;
double frequency = 1.0;
double maxValue = 0.0;
for (int i = 0; i < octaves; i++) {
value += noise.noise(x * frequency / scale, z * frequency / scale) * amplitude;
maxValue += amplitude;
amplitude *= persistence;
frequency *= lacunarity;
}
return value / maxValue;
}
private Biome determineBiome(double height, double moisture, double temperature) {
if (height < 0.3) return Biome.OCEAN;
if (height < 0.35) return Biome.BEACH;
if (height > 0.8) {
if (temperature < 0.3) return Biome.SNOW;
return Biome.MOUNTAIN;
}
if (temperature < 0.3) return Biome.TUNDRA;
if (moisture < 0.3) return Biome.DESERT;
if (moisture < 0.6) return Biome.GRASSLAND;
return Biome.FOREST;
}
public Color getBiomeColor(Biome biome) {
switch (biome) {
case OCEAN: return new Color(0, 0, 139); // Dark blue
case BEACH: return new Color(238, 214, 175); // Sand
case GRASSLAND: return new Color(34, 139, 34); // Forest green
case FOREST: return new Color(0, 100, 0); // Dark green
case DESERT: return new Color(238, 203, 173); // Light sand
case TUNDRA: return new Color(221, 221, 187); // Light brown
case MOUNTAIN: return new Color(139, 137, 137); // Gray
case SNOW: return Color.WHITE;
default: return Color.GRAY;
}
}
}
2. Erosion Simulation
public class TerrainErosion {
public static void applyHydraulicErosion(float[][] heightmap, int iterations) {
int width = heightmap.length;
int height = heightmap[0].length;
for (int iter = 0; iter < iterations; iter++) {
// Simulate water droplet erosion
for (int droplet = 0; droplet < 1000; droplet++) {
simulateWaterDroplet(heightmap, width, height);
}
if (iter % 100 == 0) {
System.out.println("Erosion iteration: " + iter);
}
}
}
private static void simulateWaterDroplet(float[][] heightmap, int width, int height) {
Random random = new Random();
// Start droplet at random position
int x = random.nextInt(width - 2) + 1;
int y = random.nextInt(height - 2) + 1;
float sediment = 0;
float water = 1.0f;
float inertia = 0.05f;
for (int step = 0; step < 30; step++) {
// Calculate gradient
float currentHeight = heightmap[x][y];
// Find lowest neighbor
int[] dx = {-1, 0, 1, -1, 1, -1, 0, 1};
int[] dy = {-1, -1, -1, 0, 0, 1, 1, 1};
float minHeight = currentHeight;
int minX = x, minY = y;
for (int i = 0; i < 8; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
if (heightmap[nx][ny] < minHeight) {
minHeight = heightmap[nx][ny];
minX = nx;
minY = ny;
}
}
}
// If no downward path, stop
if (minX == x && minY == y) break;
// Calculate sediment capacity
float sedimentCapacity = Math.max(-(minHeight - currentHeight), 0.01f) * water * 4.0f;
// Deposit or erode sediment
if (sediment > sedimentCapacity || minHeight > currentHeight) {
// Deposit
float depositAmount = (sediment - sedimentCapacity) * 0.3f;
heightmap[x][y] += depositAmount;
sediment -= depositAmount;
} else {
// Erode
float erodeAmount = Math.min((sedimentCapacity - sediment) * 0.3f, 0.01f);
heightmap[x][y] -= erodeAmount;
sediment += erodeAmount;
}
// Move to next position
x = minX;
y = minY;
// Evaporate water
water *= 0.95f;
if (water < 0.01f) break;
}
}
}
Performance Optimization
1. Chunked Terrain Generation
public class ChunkedTerrain {
private final int chunkSize = 64;
private final int renderDistance = 3; // chunks
private final Map<String, Geometry> loadedChunks = new HashMap<>();
private final PerlinNoise perlin;
public ChunkedTerrain(long seed) {
this.perlin = new PerlinNoise(seed);
}
public void updateChunks(Vector3f playerPosition) {
int playerChunkX = (int) (playerPosition.x / chunkSize);
int playerChunkZ = (int) (playerPosition.z / chunkSize);
// Unload distant chunks
unloadDistantChunks(playerChunkX, playerChunkZ);
// Load new chunks
for (int x = playerChunkX - renderDistance; x <= playerChunkX + renderDistance; x++) {
for (int z = playerChunkZ - renderDistance; z <= playerChunkZ + renderDistance; z++) {
String chunkKey = x + "_" + z;
if (!loadedChunks.containsKey(chunkKey)) {
Geometry chunk = generateChunk(x, z);
loadedChunks.put(chunkKey, chunk);
// Attach to scene graph
}
}
}
}
private Geometry generateChunk(int chunkX, int chunkZ) {
// Generate heightmap for this chunk
float[] heightData = new float[chunkSize * chunkSize];
for (int x = 0; x < chunkSize; x++) {
for (int z = 0; z < chunkSize; z++) {
double worldX = (chunkX * chunkSize + x);
double worldZ = (chunkZ * chunkSize + z);
double height = perlin.noise(worldX / 100.0, worldZ / 100.0);
heightData[x * chunkSize + z] = (float) height * 20.0f;
}
}
// Create mesh from heightData (similar to previous examples)
return createChunkMesh(heightData, chunkX, chunkZ);
}
private void unloadDistantChunks(int centerX, int centerZ) {
Iterator<Map.Entry<String, Geometry>> iterator = loadedChunks.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Geometry> entry = iterator.next();
String[] parts = entry.getKey().split("_");
int chunkX = Integer.parseInt(parts[0]);
int chunkZ = Integer.parseInt(parts[1]);
if (Math.abs(chunkX - centerX) > renderDistance ||
Math.abs(chunkZ - centerZ) > renderDistance) {
// Detach from scene graph and remove
entry.getValue().removeFromParent();
iterator.remove();
}
}
}
}
Conclusion
Perlin Noise terrain generation in Java provides:
- Natural-looking landscapes with smooth, organic features
- Controllable complexity through octaves, persistence, and lacunarity
- Performance optimization through chunking and LOD
- Rich biome systems using multiple noise layers
- Realistic erosion through hydraulic simulation
Key parameters to experiment with:
- Scale: Controls the size of terrain features
- Octaves: Adds detail at different frequencies
- Persistence: Controls amplitude reduction between octaves
- Lacunarity: Controls frequency increase between octaves
By mastering these techniques, you can create everything from rolling hills to dramatic mountain ranges, all generated algorithmically with infinite variation and natural appearance.