View difference between Paste ID: KsfZ99Xa and k4LSNDqv

 import java.util.Random;
 
 public class PerlinNoise {
 
 	final static int TABLE_SIZE = 64;
 
 	private final static double WEIGHT(double T) {
 		return ((2.0 * Math.abs(T) - 3.0) * (T) * (T) + 1.0);
 	}
 
 	private final int CLAMP(int val, int min, int max) {
 		return ((val < min ? min : val) > max ? max : val);
 	}
 
 	private final double CLAMP(double val, double min, double max) {
 		return ((val < min ? min : val) > max ? max : val);
 	}
 
 	final int SCALE_WIDTH = 128;
 	final double MIN_SIZE = 0.1;
 	final double MAX_SIZE = 16.0;
 
 	private boolean tilable = false;
 	private boolean turbulent = false;
 	private long seed = 0;
 	private int detail = 1;
 	private double size = 8.0;
 
 	private static int clip;
 	private static double offset, factor;
 	static int[] perm_tab = new int[TABLE_SIZE];
 	static Vector2d[] grad_tab = new Vector2d[TABLE_SIZE];
 
 	public PerlinNoise(long seed) {
 		this.seed = seed;
 		init();
 	}
 
 	public double noise2(double x, double y) {
 		x /= 100;
 		y /= 100;
 		return noise(x, y);
 	}
 
 	void init() {
 		int i, j, k, t;
 		double m;
 		Random r;
 
 		r = new Random(seed);
 
 		/* Force sane parameters */
 		detail = CLAMP(detail, 0, 15);
 		size = CLAMP(size, MIN_SIZE, MAX_SIZE);
 
 		/* Set scaling factors */
 		if (tilable) {
 			this.size = Math.ceil(size);
 			clip = (int) size;
 		}
 
 		/* Set totally empiric normalization values */
 		if (turbulent) {
 			offset = 0.0;
 			factor = 1.0;
 		} else {
 			offset = 0.94;
 			factor = 0.526;
 		}
 
 		/* Initialize the permutation table */
 		for (i = 0; i < TABLE_SIZE; i++)
 			perm_tab[i] = i;
 
 		for (i = 0; i < (TABLE_SIZE >> 1); i++) {
 			j = r.nextInt(TABLE_SIZE);
 			k = r.nextInt(TABLE_SIZE);
 			t = perm_tab[j];
 			perm_tab[j] = perm_tab[k];
 			perm_tab[k] = t;
 		}
 
 		/* Initialize the gradient table */
 		for (i = 0; i < TABLE_SIZE; i++) {
 			grad_tab[i] = new Vector2d();
 			do {
 				grad_tab[i].setX((r.nextDouble() * 2) - 1);
 				grad_tab[i].setY((r.nextDouble() * 2) - 1);
 				m = grad_tab[i].getX() * grad_tab[i].getX() + grad_tab[i].getY() * grad_tab[i].getY();
 			} while (m == 0.0 || m > 1.0);
 
 			m = 1.0 / Math.sqrt(m);
 			grad_tab[i].setX(grad_tab[i].getX() * m);
 			grad_tab[i].setY(grad_tab[i].getY() * m);
 		}
 
 		r = null;
 	}
 
 	double plain_noise(double x, double y, int s) {
 		Vector2d v = new Vector2d();
 		int a, b, i, j, n;
 		double sum;
 
 		sum = 0.0;
 		x *= s;
 		y *= s;
 		a = (int) Math.floor(x);
 		b = (int) Math.floor(y);
 
 		for (i = 0; i < 2; i++)
 			for (j = 0; j < 2; j++) {
 				if (tilable)
-					// n = perm_tab[(((a + i) % (xclip * s)) + perm_tab[((b + j)
+
-					// % (yclip * s)) % TABLE_SIZE]) % TABLE_SIZE];
+
 					n = perm_tab[betterMod(a + i + perm_tab[betterMod(b + j, TABLE_SIZE)], TABLE_SIZE)];
 				v.setX(x - a - i);
 				v.setY(y - b - j);
 				sum += WEIGHT(v.getX()) * WEIGHT(v.getY()) * (grad_tab[n].getX() * v.getX() + grad_tab[n].getY() * v.getY());
 			}
 
 		return sum / s;
 	}
 
         /** Modified modulus, so that negative numbers wrap correctly! */
 	private int betterMod(int val, int range) {
 		return (val % range + range) % range;
 	}
 
 	double noise(double x, double y) {
 		int i;
 		int s;
 		double sum;
 
 		s = 1;
 		sum = 0.0;
 		x *= size;
 		y *= size;
 
 		for (i = 0; i <= detail; i++) {
 			if (turbulent)
 				sum += Math.abs(plain_noise(x, y, s));
 			else
 				sum += plain_noise(x, y, s);
 			s <<= 1;
 		}
 
 		return (sum + offset) * factor;
 	}
 }