propane 3.7.1-java → 3.8.0-java

data/src/main/java/monkstone/noise/NoiseGenerator.java

@@ -0,0 +1,63 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package monkstone.noise;
+
+/**
+ *
+ * @author Martin Prout
+ */
+public class NoiseGenerator implements Noise {
+
+    private Noise implementation;
+    private NoiseMode mode;
+
+    public NoiseGenerator() {
+        this.implementation = new ValueNoise();
+        this.mode = NoiseMode.PERLIN;
+    }
+
+    public void noiseMode(NoiseMode mode) {
+        if (this.mode != mode && this.mode != NoiseMode.PERLIN) {
+            this.implementation = new ValueNoise();
+            this.mode = NoiseMode.PERLIN;
+        }
+        if (this.mode != mode && this.mode != NoiseMode.SIMPLEX) {
+            this.implementation = new SimplexNoise();
+            this.mode = NoiseMode.SIMPLEX;
+        }
+    }
+
+    public NoiseMode noiseMode(){
+        return this.mode;
+    }
+
+    @Override
+    public float noise(float x, float y, float z) {
+        return implementation.noise(x, y, z);
+    }
+
+    @Override
+    public float noise(float x, float y, float z, float w) {
+      if (mode == NoiseMode.PERLIN) { return 0.5f;}
+        return implementation.noise(x, y, z, w);
+    }
+
+    @Override
+    public void noiseDetail(int lod) {
+        implementation.noiseDetail(lod);
+    }
+
+    @Override
+    public void noiseDetail(int lod, float falloff) {
+        implementation.noiseDetail(lod, falloff);
+    }
+
+    @Override
+    public void noiseSeed(long seed) {
+        implementation.noiseSeed(seed);
+    }
+
+}

data/src/main/java/monkstone/noise/NoiseMode.java

@@ -0,0 +1,15 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package monkstone.noise;
+
+/**
+ *
+ * @author tux
+ */
+public enum NoiseMode {
+   SIMPLEX,
+   PERLIN;
+}

data/src/main/java/monkstone/noise/SimplexNoise.java

@@ -1,3 +1,5 @@
+package monkstone.noise;
+
 /*
  * A speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
  *
@@ -14,9 +16,9 @@
  * attribution is appreciated.
  *
  */
-package monkstone.noise;
 
-public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
+
+public class SimplexNoise implements Noise{  // Simplex noise in 2D, 3D and 4D
 
     private static Grad grad3[] = {new Grad(1, 1, 0), new Grad(-1, 1, 0), new Grad(1, -1, 0), new Grad(-1, -1, 0),
         new Grad(1, 0, 1), new Grad(-1, 0, 1), new Grad(1, 0, -1), new Grad(-1, 0, -1),
@@ -56,43 +58,44 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
     }
 
     // Skewing and unskewing factors for 2, 3, and 4 dimensions
-    private static final double F2 = 0.5 * (Math.sqrt(3.0) - 1.0);
-    private static final double G2 = (3.0 - Math.sqrt(3.0)) / 6.0;
-    private static final double F3 = 1.0 / 3.0;
-    private static final double G3 = 1.0 / 6.0;
-    private static final double F4 = (Math.sqrt(5.0) - 1.0) / 4.0;
-    private static final double G4 = (5.0 - Math.sqrt(5.0)) / 20.0;
+    private static final float F2 = 0.5f * (float)(Math.sqrt(3.0) - 1.0);
+    private static final float G2 = (float)(3.0 - Math.sqrt(3.0)) / 6.0f;
+    private static final float F3 = 1.0f / 3.0f;
+    private static final float G3 = 1.0f / 6.0f;
+    private static final float F4 = (float)(Math.sqrt(5.0) - 1.0) / 4.0f;
+    private static final float G4 = (float)(5.0 - Math.sqrt(5.0)) / 20.0f;
 
     // This method is a *lot* faster than using (int)Math.floor(x)
-    private static int fastfloor(double x) {
+    private static int fastfloor(float x) {
         int xi = (int) x;
         return x < xi ? xi - 1 : xi;
     }
 
-    private static double dot(Grad g, double x, double y) {
+    private static float dot(Grad g, float x, float y) {
         return g.x * x + g.y * y;
     }
 
-    private static double dot(Grad g, double x, double y, double z) {
+    private static float dot(Grad g, float x, float y, float z) {
         return g.x * x + g.y * y + g.z * z;
     }
 
-    private static double dot(Grad g, double x, double y, double z, double w) {
+    private static float dot(Grad g, float x, float y, float z, float w) {
         return g.x * x + g.y * y + g.z * z + g.w * w;
     }
 
     // 2D simplex noise
-    public static double noise(double xin, double yin) {
-        double n0, n1, n2; // Noise contributions from the three corners
+    @Override
+    public float noise(float xin, float yin) {
+        float n0, n1, n2; // Noise contributions from the three corners
         // Skew the input space to determine which simplex cell we're in
-        double s = (xin + yin) * F2; // Hairy factor for 2D
+        float s = (xin + yin) * F2; // Hairy factor for 2D
         int i = fastfloor(xin + s);
         int j = fastfloor(yin + s);
-        double t = (i + j) * G2;
-        double X0 = i - t; // Unskew the cell origin back to (x,y) space
-        double Y0 = j - t;
-        double x0 = xin - X0; // The x,y distances from the cell origin
-        double y0 = yin - Y0;
+        float t = (i + j) * G2;
+        float X0 = i - t; // Unskew the cell origin back to (x,y) space
+        float Y0 = j - t;
+        float x0 = xin - X0; // The x,y distances from the cell origin
+        float y0 = yin - Y0;
         // For the 2D case, the simplex shape is an equilateral triangle.
         // Determine which simplex we are in.
         int i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
@@ -107,10 +110,10 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
         // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
         // c = (3-sqrt(3))/6
-        double x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
-        double y1 = y0 - j1 + G2;
-        double x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
-        double y2 = y0 - 1.0 + 2.0 * G2;
+        float x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
+        float y1 = y0 - j1 + G2;
+        float x2 = x0 - 1.0f + 2.0f * G2; // Offsets for last corner in (x,y) unskewed coords
+        float y2 = y0 - 1.0f + 2.0f * G2;
         // Work out the hashed gradient indices of the three simplex corners
         int ii = i & 255;
         int jj = j & 255;
@@ -118,47 +121,48 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         int gi1 = PERM_MOD_12[ii + i1 + PERM[jj + j1]];
         int gi2 = PERM_MOD_12[ii + 1 + PERM[jj + 1]];
         // Calculate the contribution from the three corners
-        double t0 = 0.5 - x0 * x0 - y0 * y0;
+        float t0 = 0.5f - x0 * x0 - y0 * y0;
         if (t0 < 0) {
-            n0 = 0.0;
+            n0 = 0.0f;
         } else {
             t0 *= t0;
             n0 = t0 * t0 * dot(grad3[gi0], x0, y0);  // (x,y) of grad3 used for 2D gradient
         }
-        double t1 = 0.5 - x1 * x1 - y1 * y1;
+        float t1 = 0.5f - x1 * x1 - y1 * y1;
         if (t1 < 0) {
-            n1 = 0.0;
+            n1 = 0.0f;
         } else {
             t1 *= t1;
             n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
         }
-        double t2 = 0.5 - x2 * x2 - y2 * y2;
+        float t2 = 0.5f - x2 * x2 - y2 * y2;
         if (t2 < 0) {
-            n2 = 0.0;
+            n2 = 0.0f;
         } else {
             t2 *= t2;
             n2 = t2 * t2 * dot(grad3[gi2], x2, y2);
         }
         // Add contributions from each corner to get the final noise value.
         // The result is scaled to return values in the interval [-1,1].
-        return 70.0 * (n0 + n1 + n2);
+        return 70.0f * (n0 + n1 + n2);
     }
 
     // 3D simplex noise
-    public static double noise(double xin, double yin, double zin) {
-        double n0, n1, n2, n3; // Noise contributions from the four corners
+    @Override
+    public float noise(float xin, float yin, float zin) {
+        float n0, n1, n2, n3; // Noise contributions from the four corners
         // Skew the input space to determine which simplex cell we're in
-        double s = (xin + yin + zin) * F3; // Very nice and simple skew factor for 3D
+        float s = (xin + yin + zin) * F3; // Very nice and simple skew factor for 3D
         int i = fastfloor(xin + s);
         int j = fastfloor(yin + s);
         int k = fastfloor(zin + s);
-        double t = (i + j + k) * G3;
-        double X0 = i - t; // Unskew the cell origin back to (x,y,z) space
-        double Y0 = j - t;
-        double Z0 = k - t;
-        double x0 = xin - X0; // The x,y,z distances from the cell origin
-        double y0 = yin - Y0;
-        double z0 = zin - Z0;
+        float t = (i + j + k) * G3;
+        float X0 = i - t; // Unskew the cell origin back to (x,y,z) space
+        float Y0 = j - t;
+        float Z0 = k - t;
+        float x0 = xin - X0; // The x,y,z distances from the cell origin
+        float y0 = yin - Y0;
+        float z0 = zin - Z0;
         // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
         // Determine which simplex we are in.
         int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
@@ -218,15 +222,15 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
         // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
         // c = 1/6.
-        double x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
-        double y1 = y0 - j1 + G3;
-        double z1 = z0 - k1 + G3;
-        double x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords
-        double y2 = y0 - j2 + 2.0 * G3;
-        double z2 = z0 - k2 + 2.0 * G3;
-        double x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords
-        double y3 = y0 - 1.0 + 3.0 * G3;
-        double z3 = z0 - 1.0 + 3.0 * G3;
+        float x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
+        float y1 = y0 - j1 + G3;
+        float z1 = z0 - k1 + G3;
+        float x2 = x0 - i2 + 2.0f * G3; // Offsets for third corner in (x,y,z) coords
+        float y2 = y0 - j2 + 2.0f * G3;
+        float z2 = z0 - k2 + 2.0f * G3;
+        float x3 = x0 - 1.0f + 3.0f * G3; // Offsets for last corner in (x,y,z) coords
+        float y3 = y0 - 1.0f + 3.0f * G3;
+        float z3 = z0 - 1.0f + 3.0f * G3;
         // Work out the hashed gradient indices of the four simplex corners
         int ii = i & 255;
         int jj = j & 255;
@@ -236,58 +240,68 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         int gi2 = PERM_MOD_12[ii + i2 + PERM[jj + j2 + PERM[kk + k2]]];
         int gi3 = PERM_MOD_12[ii + 1 + PERM[jj + 1 + PERM[kk + 1]]];
         // Calculate the contribution from the four corners
-        double t0 = 0.5 - x0 * x0 - y0 * y0 - z0 * z0;
+        float t0 = 0.5f - x0 * x0 - y0 * y0 - z0 * z0;
         if (t0 < 0) {
-            n0 = 0.0;
+            n0 = 0.0f;
         } else {
             t0 *= t0;
             n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0);
         }
-        double t1 = 0.5 - x1 * x1 - y1 * y1 - z1 * z1;
+        float t1 = 0.5f - x1 * x1 - y1 * y1 - z1 * z1;
         if (t1 < 0) {
-            n1 = 0.0;
+            n1 = 0.0f;
         } else {
             t1 *= t1;
             n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1);
         }
-        double t2 = 0.5 - x2 * x2 - y2 * y2 - z2 * z2;
+        float t2 = 0.5f - x2 * x2 - y2 * y2 - z2 * z2;
         if (t2 < 0) {
-            n2 = 0.0;
+            n2 = 0.0f;
         } else {
             t2 *= t2;
             n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2);
         }
-        double t3 = 0.5 - x3 * x3 - y3 * y3 - z3 * z3;
+        float t3 = 0.5f - x3 * x3 - y3 * y3 - z3 * z3;
         if (t3 < 0) {
-            n3 = 0.0;
+            n3 = 0.0f;
         } else {
             t3 *= t3;
             n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3);
         }
         // Add contributions from each corner to get the final noise value.
         // The result is scaled to stay just inside [-1,1]
-        return 32.0 * (n0 + n1 + n2 + n3);
+        return 32.0f * (n0 + n1 + n2 + n3);
     }
 
     // 4D simplex noise, better simplex rank ordering method 2012-03-09
-    public static double noise(double x, double y, double z, double w) {
 
-        double n0, n1, n2, n3, n4; // Noise contributions from the five corners
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     * @param w
+     * @return
+     */
+    @Override
+    public float noise(float x, float y, float z, float w) {
+
+        float n0, n1, n2, n3, n4; // Noise contributions from the five corners
         // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
-        double s = (x + y + z + w) * F4; // Factor for 4D skewing
+        float s = (x + y + z + w) * F4; // Factor for 4D skewing
         int i = fastfloor(x + s);
         int j = fastfloor(y + s);
         int k = fastfloor(z + s);
         int l = fastfloor(w + s);
-        double t = (i + j + k + l) * G4; // Factor for 4D unskewing
-        double X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
-        double Y0 = j - t;
-        double Z0 = k - t;
-        double W0 = l - t;
-        double x0 = x - X0;  // The x,y,z,w distances from the cell origin
-        double y0 = y - Y0;
-        double z0 = z - Z0;
-        double w0 = w - W0;
+        float t = (i + j + k + l) * G4; // Factor for 4D unskewing
+        float X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
+        float Y0 = j - t;
+        float Z0 = k - t;
+        float W0 = l - t;
+        float x0 = x - X0;  // The x,y,z,w distances from the cell origin
+        float y0 = y - Y0;
+        float z0 = z - Z0;
+        float w0 = w - W0;
         // For the 4D case, the simplex is a 4D shape I won't even try to describe.
         // To find out which of the 24 possible simplices we're in, we need to
         // determine the magnitude ordering of x0, y0, z0 and w0.
@@ -348,22 +362,22 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         k3 = rankz >= 1 ? 1 : 0;
         l3 = rankw >= 1 ? 1 : 0;
         // The fifth corner has all coordinate offsets = 1, so no need to compute that.
-        double x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
-        double y1 = y0 - j1 + G4;
-        double z1 = z0 - k1 + G4;
-        double w1 = w0 - l1 + G4;
-        double x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
-        double y2 = y0 - j2 + 2.0 * G4;
-        double z2 = z0 - k2 + 2.0 * G4;
-        double w2 = w0 - l2 + 2.0 * G4;
-        double x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
-        double y3 = y0 - j3 + 3.0 * G4;
-        double z3 = z0 - k3 + 3.0 * G4;
-        double w3 = w0 - l3 + 3.0 * G4;
-        double x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
-        double y4 = y0 - 1.0 + 4.0 * G4;
-        double z4 = z0 - 1.0 + 4.0 * G4;
-        double w4 = w0 - 1.0 + 4.0 * G4;
+        float x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
+        float y1 = y0 - j1 + G4;
+        float z1 = z0 - k1 + G4;
+        float w1 = w0 - l1 + G4;
+        float x2 = x0 - i2 + 20.f * G4; // Offsets for third corner in (x,y,z,w) coords
+        float y2 = y0 - j2 + 20.f * G4;
+        float z2 = z0 - k2 + 20.f * G4;
+        float w2 = w0 - l2 + 20.f * G4;
+        float x3 = x0 - i3 + 30.f * G4; // Offsets for fourth corner in (x,y,z,w) coords
+        float y3 = y0 - j3 + 30.f * G4;
+        float z3 = z0 - k3 + 30.f * G4;
+        float w3 = w0 - l3 + 30.f * G4;
+        float x4 = x0 - 1.0f + 40.f * G4; // Offsets for last corner in (x,y,z,w) coords
+        float y4 = y0 - 1.0f + 40.f * G4;
+        float z4 = z0 - 1.0f + 40.f * G4;
+        float w4 = w0 - 1.0f + 40.f * G4;
         // Work out the hashed gradient indices of the five simplex corners
         int ii = i & 255;
         int jj = j & 255;
@@ -375,58 +389,78 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         int gi3 = PERM[ii + i3 + PERM[jj + j3 + PERM[kk + k3 + PERM[ll + l3]]]] % 32;
         int gi4 = PERM[ii + 1 + PERM[jj + 1 + PERM[kk + 1 + PERM[ll + 1]]]] % 32;
         // Calculate the contribution from the five corners
-        double t0 = 0.5 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
+        float t0 = 0.5f - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
         if (t0 < 0) {
-            n0 = 0.0;
+            n0 = 0.0f;
         } else {
             t0 *= t0;
             n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0);
         }
-        double t1 = 0.5 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
+        float t1 = 0.5f - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
         if (t1 < 0) {
-            n1 = 0.0;
+            n1 = 0.0f;
         } else {
             t1 *= t1;
             n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1);
         }
-        double t2 = 0.5 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
+        float t2 = 0.5f - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
         if (t2 < 0) {
-            n2 = 0.0;
+            n2 = 0.0f;
         } else {
             t2 *= t2;
             n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2);
         }
-        double t3 = 0.5 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
+        float t3 = 0.5f - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
         if (t3 < 0) {
-            n3 = 0.0;
+            n3 = 0.0f;
         } else {
             t3 *= t3;
             n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3);
         }
-        double t4 = 0.5 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
+        float t4 = 0.5f - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
         if (t4 < 0) {
-            n4 = 0.0;
+            n4 = 0.0f;
         } else {
             t4 *= t4;
             n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4);
         }
         // Sum up and scale the result to cover the range [-1,1]
-        return 27.0 * (n0 + n1 + n2 + n3 + n4);
+        return 27.0f * (n0 + n1 + n2 + n3 + n4);
+    }
+
+    @Override
+    public void noiseDetail(int lod) {
+                
+    }
+
+    @Override
+    public void noiseDetail(int lod, float falloff) {
+        
+    }
+
+    @Override
+    public void noiseSeed(long seed) {
+                
+    }
+
+    @Override
+    public void noiseMode(NoiseMode mode) {
+        
     }
 
     // Inner class to speed upp gradient computations
     // (In Java, array access is a lot slower than member access)
     private static class Grad {
 
-        double x, y, z, w;
+        float x, y, z, w;
 
-        Grad(double x, double y, double z) {
+        Grad(float x, float y, float z) {
             this.x = x;
             this.y = y;
             this.z = z;
         }
 
-        Grad(double x, double y, double z, double w) {
+        Grad(float x, float y, float z, float w) {
             this.x = x;
             this.y = y;
             this.z = z;