Add procedural landmass generation demo using Perlin noise

Author: ArtifactForms

src/main/java/engine/demos/landmass/MapGenerator.java

@@ -0,0 +1,125 @@
+package engine.demos.landmass;
+
+import math.Color;
+import math.Mathf;
+
+/**
+ * A procedural landmass generator, ported from Sebastian Lague's Unity script. This class generates
+ * a height map and a color map based on Perlin noise and terrain types. It supports adjustable
+ * parameters for map size, noise generation, and biome regions.
+ *
+ * <p>The generated maps can be used to create terrains with realistic variations in height and
+ * color.
+ */
+public class MapGenerator {
+
+  private int chunkSize = 241;
+  private int mapWidth = chunkSize;
+  private int mapHeight = chunkSize;
+  private int seed = 221;
+  private int octaves = 4;
+  private float scale = 50;
+  private float persistance = 0.5f;
+  private float lacunarity = 2f;
+  private float[][] heightMap;
+  private TerrainType[] regions;
+
+  /** Constructs a new {@code MapGenerator} and initializes the height map and terrain regions. */
+  public MapGenerator() {
+    initializeRegions();
+    heightMap =
+        Noise.createHeightMap(mapWidth, mapHeight, seed, scale, octaves, persistance, lacunarity);
+  }
+
+  /**
+   * Initializes the predefined terrain regions for the map. Each region is associated with a
+   * specific height threshold, name, and color.
+   */
+  private void initializeRegions() {
+    regions = new TerrainType[8];
+
+    regions[0] = new TerrainType(0.3f, "Water Deep", Color.getColorFromInt(52, 99, 196));
+    regions[1] = new TerrainType(0.4f, "Water Shallow", Color.getColorFromInt(54, 102, 199));
+    regions[2] = new TerrainType(0.45f, "Sand", Color.getColorFromInt(206, 209, 125));
+    regions[3] = new TerrainType(0.55f, "Grass", Color.getColorFromInt(86, 151, 24));
+    regions[4] = new TerrainType(0.6f, "Grass 2", Color.getColorFromInt(62, 107, 18));
+    regions[5] = new TerrainType(0.7f, "Rock", Color.getColorFromInt(90, 69, 62));
+    regions[6] = new TerrainType(0.9f, "Rock 2", Color.getColorFromInt(77, 69, 56));
+    regions[7] = new TerrainType(1.0f, "Snow", Color.getColorFromInt(253, 253, 253));
+  }
+
+  /**
+   * Generates a grayscale noise map representing the terrain height. The noise values are mapped to
+   * a color gradient ranging from black (low) to white (high).
+   *
+   * @return an array of RGBA color values representing the noise map
+   */
+  public int[] createNoiseMap() {
+    int[] colorMap = new int[heightMap.length * heightMap[9].length];
+
+    for (int y = 0; y < mapHeight; y++) {
+      for (int x = 0; x < mapWidth; x++) {
+        float lerpedValue = Mathf.lerp(0, 1, heightMap[x][y]);
+        colorMap[y * mapWidth + x] = new Color(lerpedValue, lerpedValue, lerpedValue).getRGBA();
+      }
+    }
+    return colorMap;
+  }
+
+  /**
+   * Generates a color map based on predefined terrain regions. The height values in the height map
+   * are compared against the thresholds of each terrain type to determine the color.
+   *
+   * @return an array of RGBA color values representing the color map
+   */
+  public int[] createColorMap() {
+    int[] colorMap = new int[mapWidth * mapHeight];
+
+    for (int y = 0; y < mapHeight; y++) {
+      for (int x = 0; x < mapWidth; x++) {
+        float currentHeight = heightMap[x][y];
+        for (int i = 0; i < regions.length; i++) {
+          if (currentHeight <= regions[i].height) {
+            colorMap[y * mapWidth + x] = regions[i].color.getRGBA();
+            break;
+          }
+        }
+      }
+    }
+    return colorMap;
+  }
+
+  /**
+   * Returns the generated height map. The height map is a 2D array of floats, where each value
+   * represents the elevation at a specific point.
+   *
+   * @return a 2D float array representing the height map
+   */
+  public float[][] getHeightMap() {
+    return heightMap;
+  }
+
+  /**
+   * Represents a terrain type, which includes a height threshold, a name, and a color. Terrain
+   * types are used to categorize different regions of the generated map.
+   */
+  public class TerrainType {
+
+    public float height;
+    public String name;
+    public Color color;
+
+    /**
+     * Constructs a new {@code TerrainType} with the specified height threshold, name, and color.
+     *
+     * @param height the height threshold for this terrain type
+     * @param name the name of the terrain type
+     * @param color the color associated with this terrain type
+     */
+    public TerrainType(float height, String name, Color color) {
+      this.height = height;
+      this.name = name;
+      this.color = color;
+    }
+  }
+}

src/main/java/engine/demos/landmass/Noise.java

@@ -0,0 +1,96 @@
+package engine.demos.landmass;
+
+import math.Mathf;
+import math.PerlinNoise;
+
+/**
+ * Utility class for generating procedural height maps using Perlin noise.
+ *
+ * <p>This class is a Java adaptation of Sebastian Lague's Unity script for procedural landmass
+ * creation. It generates a two-dimensional array representing height values for a terrain based on
+ * various noise parameters.
+ */
+public class Noise {
+
+  /**
+   * Generates a height map using Perlin noise.
+   *
+   * <p>The height map is generated by layering multiple octaves of Perlin noise, each with varying
+   * amplitude and frequency, allowing for detailed and natural-looking terrain generation.
+   *
+   * @param mapWidth the width of the height map to be generated
+   * @param mapHeight the height of the height map to be generated
+   * @param seed the seed value for the noise generation, ensuring reproducibility
+   * @param scale the scale of the noise; smaller values zoom in on noise patterns
+   * @param octaves the number of noise layers (octaves) to combine for more complex patterns
+   * @param persistance the rate at which the amplitude of each octave decreases
+   * @param lacunarity the rate at which the frequency of each octave increases
+   * @return a two-dimensional float array representing the generated height map
+   */
+  public static float[][] createHeightMap(
+      int mapWidth,
+      int mapHeight,
+      int seed,
+      float scale,
+      int octaves,
+      float persistance,
+      float lacunarity) {
+
+    // Initialize Perlin noise with the provided seed
+    PerlinNoise perlinNoise = new PerlinNoise(seed);
+    float[][] noiseMap = new float[mapWidth][mapHeight];
+
+    // Prevent division by zero by ensuring a minimum scale value
+    if (scale <= 0) {
+      scale = 0.0001f;
+    }
+
+    // Variables to track the min and max noise values for normalization
+    float maxNoiseHeight = Float.MIN_VALUE;
+    float minNoiseHeight = Float.MAX_VALUE;
+
+    // Generate noise values for each point in the map
+    for (int y = 0; y < mapHeight; y++) {
+      for (int x = 0; x < mapWidth; x++) {
+
+        float amplitude = 1;
+        float frequency = 1;
+        float noiseHeight = 0;
+
+        // Generate noise using multiple octaves
+        for (int i = 0; i < octaves; i++) {
+          // Sample points in the Perlin noise space
+          float sampleX = x / scale * frequency;
+          float sampleY = y / scale * frequency;
+
+          // Calculate the Perlin noise value and adjust it to allow negative values
+          float perlinValue = (float) perlinNoise.noise(sampleX, sampleY) * 2 - 1;
+          noiseHeight += perlinValue * amplitude;
+
+          // Decrease amplitude and increase frequency for the next octave
+          amplitude *= persistance;
+          frequency *= lacunarity;
+        }
+
+        // Update min and max noise height values
+        if (noiseHeight > maxNoiseHeight) {
+          maxNoiseHeight = noiseHeight;
+        } else if (noiseHeight < minNoiseHeight) {
+          minNoiseHeight = noiseHeight;
+        }
+
+        // Assign the calculated noise height to the map
+        noiseMap[x][y] = noiseHeight;
+      }
+    }
+
+    // Normalize the noise map values to a range between 0 and 1
+    for (int y = 0; y < mapHeight; y++) {
+      for (int x = 0; x < mapWidth; x++) {
+        noiseMap[x][y] = Mathf.inverseLerp(minNoiseHeight, maxNoiseHeight, noiseMap[x][y]);
+      }
+    }
+
+    return noiseMap;
+  }
+}

src/main/java/engine/demos/landmass/NoiseMapDisplay.java

@@ -0,0 +1,131 @@
+package engine.demos.landmass;
+
+import engine.components.AbstractComponent;
+import engine.components.Geometry;
+import engine.components.RenderableComponent;
+import engine.render.Material;
+import engine.resources.FilterMode;
+import engine.resources.Texture2D;
+import engine.scene.SceneNode;
+import mesh.Mesh3D;
+import mesh.creator.primitives.PlaneCreator;
+import workspace.ui.Graphics;
+
+/**
+ * The {@code NoiseMapDisplay} class is responsible for rendering a noise map texture onto a 3D
+ * plane. It creates a textured plane mesh that displays pixel data generated by procedural noise
+ * algorithms. This class extends {@link AbstractComponent} and implements {@link
+ * RenderableComponent}, making it suitable for integration within a 3D scene graph.
+ *
+ * <p>Usage:
+ *
+ * <ul>
+ *   <li>Create an instance by specifying the width and height of the noise map.
+ *   <li>Set pixel data using the {@link #setPixels(int[])} method.
+ *   <li>The texture is automatically mapped onto a 3D plane and rendered during the scene's render
+ *       phase.
+ * </ul>
+ *
+ * <p>This class is typically used in terrain generation demos to visualize height maps or color
+ * maps.
+ */
+public class NoiseMapDisplay extends AbstractComponent implements RenderableComponent {
+
+  /** The 3D mesh representing a flat plane on which the noise map texture is rendered. */
+  private Mesh3D planeMesh;
+
+  /** The geometry component that combines the plane mesh with a material for rendering. */
+  private Geometry planeGeometry;
+
+  /** The texture representing the noise map, used to display pixel data on the plane mesh. */
+  private Texture2D texture;
+
+  /**
+   * Constructs a new {@code NoiseMapDisplay} with a specified texture size.
+   *
+   * @param width the width of the noise map texture in pixels
+   * @param height the height of the noise map texture in pixels
+   */
+  public NoiseMapDisplay(int width, int height) {
+    createPlaneMesh();
+    texture = new Texture2D(width, height);
+    texture.setFilterMode(FilterMode.POINT); // Use point filtering for a pixelated look
+  }
+
+  /**
+   * Initializes the plane mesh used for displaying the noise map. The plane is created with UV
+   * coordinates to map the texture correctly.
+   */
+  private void createPlaneMesh() {
+    planeMesh = new PlaneCreator(30).create();
+    planeMesh.addUvCoordinate(0, 0);
+    planeMesh.addUvCoordinate(1, 0);
+    planeMesh.addUvCoordinate(1, 1);
+    planeMesh.addUvCoordinate(0, 1);
+    planeMesh.getFaceAt(0).setUvIndices(0, 1, 2, 3);
+  }
+
+  /**
+   * Sets the pixel data for the noise map texture. The provided array should match the size of the
+   * texture (width * height).
+   *
+   * @param pixels an array of pixel color values in ARGB format
+   */
+  public void setPixels(int[] pixels) {
+    texture.setPixels(pixels);
+    Material material = new Material.Builder().setDiffuseTexture(texture).build();
+    planeGeometry = new Geometry(planeMesh, material);
+  }
+
+  /**
+   * Returns the noise map texture used by this display.
+   *
+   * @return the {@link Texture2D} instance representing the noise map
+   */
+  public Texture2D getTexture() {
+    return texture;
+  }
+
+  /**
+   * Renders the noise map display using the provided {@link Graphics} context. The method checks if
+   * the plane geometry is initialized before rendering.
+   *
+   * @param g the {@link Graphics} context used for rendering
+   */
+  @Override
+  public void render(Graphics g) {
+    if (planeGeometry == null) {
+      return;
+    }
+    planeGeometry.render(g);
+  }
+
+  /**
+   * Called each frame to update the component's state. This implementation does not perform any
+   * updates, but can be extended if needed.
+   *
+   * @param tpf time per frame, in seconds
+   */
+  @Override
+  public void update(float tpf) {
+    // No updates are required for this component
+  }
+
+  /**
+   * Called when this component is attached to a {@link SceneNode}. This method is a lifecycle hook
+   * that can be used to initialize resources or state.
+   */
+  @Override
+  public void onAttach() {
+    // No special actions needed on attach
+  }
+
+  /**
+   * Called when this component is detached from a {@link SceneNode}. This method is a lifecycle
+   * hook that can be used to clean up resources or state.
+   */
+  @Override
+  public void onDetach() {
+    // No special actions needed on detach
+  }
+}