daily pastebin goal
19%
SHARE
TWEET

Untitled

a guest May 16th, 2018 105 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.util.Random;
  2.  
  3. /**
  4.  * A  well documented Java implementation of Perlin Noise.
  5.  *
  6.  * @author Ramon Millsteed
  7.  */
  8. public class PerlinNoise {
  9.  
  10.     /** The frequencies (2^i) for each octave. */
  11.     private static int[] frequencies = new int[32];
  12.  
  13.     /** The permutations for the random gradient generator. */
  14.     private static int[] permutations = new int[512];
  15.  
  16.     /**
  17.      * Initialises the static frequency exponentials.
  18.      */
  19.     static {
  20.         for (int i = 0; i < frequencies.length; i++) {
  21.             frequencies[i] = (int) Math.pow(2, i);
  22.         }
  23.     }
  24.  
  25.     /**
  26.      * Instantiates a new {@code PerlinNoise}.
  27.      *
  28.      * @param seed
  29.      *      The random number seed
  30.      */
  31.     public PerlinNoise(int seed) {
  32.         Random random = new Random(seed);
  33.         for (int i = 0; i < permutations.length / 2; i++) {
  34.             permutations[256 + i] = permutations[i] = random.nextInt(256);
  35.         }
  36.     }
  37.  
  38.     /**
  39.      * Returns a height value in a 3D plane using Perlin Noise with octave repetition.
  40.      *
  41.      * @param x
  42.      *      The x coordinate
  43.      * @param y
  44.      *      The y coordinate
  45.      * @param z
  46.      *      The z coordinate
  47.      * @param octaves
  48.      *      The number of successive octaves
  49.      * @return The height value
  50.      */
  51.     public float noise(float x, float y, float z, int octaves) {
  52.         float height = 0.0f;
  53.         for (int octave = 1; octave <= octaves; octave++) {
  54.             int frequency = frequencies[octave];
  55.             height += noise(x * frequency, y * frequency, z * frequency) / frequency;
  56.         }
  57.         return height;
  58.     }
  59.  
  60.     /**
  61.      * Returns a height value in a 3D plane using Perlin Noise without octave repetition.
  62.      *
  63.      * @param x
  64.      *      The x coordinate
  65.      * @param y
  66.      *      The y coordinate
  67.      * @param z
  68.      *      The z coordinate
  69.      * @return The height value
  70.      */
  71.     public float noise(float x, float y, float z) {
  72.         float fx = (float) Math.floor(x);
  73.         float fy = (float) Math.floor(y);
  74.         float fz = (float) Math.floor(z);
  75.  
  76.         int gx = (int) fx & 0xFF;
  77.         int gy = (int) fy & 0xFF;
  78.         int gz = (int) fz & 0xFF;
  79.  
  80.         float u = fade(x -= fx);
  81.         float v = fade(y -= fy);
  82.         float w = fade(z -= fz);
  83.  
  84.         int a0 = permutations[gx + 0] + gy;
  85.         int b0 = permutations[gx + 1] + gy;
  86.         int aa = permutations[a0 + 0] + gz;
  87.         int ab = permutations[a0 + 1] + gz;
  88.         int ba = permutations[b0 + 0] + gz;
  89.         int bb = permutations[b0 + 1] + gz;
  90.  
  91.         float x2y2z2 = gradient(permutations[bb + 1], x - 1, y - 1, z - 1);
  92.         float x1y2z2 = gradient(permutations[ab + 1], x - 0, y - 1, z - 1);
  93.         float x2y1z2 = gradient(permutations[ba + 1], x - 1, y - 0, z - 1);
  94.         float x1y1z2 = gradient(permutations[aa + 1], x - 0, y - 0, z - 1);
  95.         float x2y2z1 = gradient(permutations[bb + 0], x - 1, y - 1, z - 0);
  96.         float x1y2z1 = gradient(permutations[ab + 0], x - 0, y - 1, z - 0);
  97.         float x2y1z1 = gradient(permutations[ba + 0], x - 1, y - 0, z - 0);
  98.         float x1y1z1 = gradient(permutations[aa + 0], x - 0, y - 0, z - 0);
  99.  
  100.         float uInterpolatedY2Z2 = linearInterpolate(x1y2z2, x2y2z2, u);
  101.         float uInterpolatedY1Z2 = linearInterpolate(x1y1z2, x2y1z2, u);
  102.         float uInterpolatedY2Z1 = linearInterpolate(x1y2z1, x2y2z1, u);
  103.         float uInterpolatedY1Z1 = linearInterpolate(x1y1z1, x2y1z1, u);
  104.  
  105.         float vInterpolatedZ1 = linearInterpolate(uInterpolatedY1Z1, uInterpolatedY2Z1, v);
  106.         float vInterpolatedZ2 = linearInterpolate(uInterpolatedY1Z2, uInterpolatedY2Z2, v);
  107.  
  108.         return linearInterpolate(vInterpolatedZ1, vInterpolatedZ2, w);
  109.     }
  110.  
  111.     /**
  112.      * Finds the fade curve for a specified coordinate.
  113.      *
  114.      * @param coordinate
  115.      *      The decimal component of the coordinate
  116.      * @return The fade curve
  117.      */
  118.     private float fade(float coordinate) {
  119.         return (float) (Math.pow(coordinate, 3) * (coordinate * (coordinate * 6.0f - 15.0f) + 10.0f));
  120.     }
  121.  
  122.     /**
  123.      * Interpolates a value between two functions using a fade curve.
  124.      *
  125.      * @param a
  126.      *      The first function
  127.      * @param b
  128.      *      The second function
  129.      * @param fadeCurve
  130.      *      The coordinate fade curve
  131.      * @return The interpolated value
  132.      */
  133.     private float linearInterpolate(float a, float b, float fadeCurve) {
  134.         return a + fadeCurve * (b - a);
  135.     }
  136.  
  137.     /**
  138.      * Generates a random gradient using coordinates from a 3D plane.
  139.      *
  140.      * @param hash
  141.      *      The random hash permutation generated with a seed
  142.      * @param x
  143.      *      The x coordinate
  144.      * @param y
  145.      *      The y coordinate
  146.      * @param z
  147.      *      The z coordinate
  148.      * @return The random gradient
  149.      */
  150.     private float gradient(int hash, float x, float y, float z) {
  151.         hash &= 15;
  152.         float u = (hash < 8) ? x : y;
  153.         float v = (hash < 4) ? y : ((hash == 12 || hash == 14) ? x : z);
  154.         return ((hash & 1) == 0 ? u : -u) + ((hash & 2) == 0 ? v : -v);
  155.     }
  156.    
  157. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top