propane 3.4.2-java → 3.8.0-java

data/src/main/java/monkstone/filechooser/Chooser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-19 Martin Prout
+ * Copyright (c) 2015-20 Martin Prout
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

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

@@ -0,0 +1,116 @@
+package monkstone.noise;
+
+/*
+ * Copyright (c) 2021 Martin Prout
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 3.0 of the License, or (at your option) any later version.
+ *
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+public interface Noise {
+
+    /**
+     *
+     * @param x
+     * @return
+     */
+    default float noise(float x) {
+        return noise(x, 0);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @return
+     */
+    default float noise(float x, float y) {
+        return noise(x, y, 0);
+    }
+
+    /**
+     * <p>
+     * Returns the Perlin noise value at specified coordinates. Perlin noise is
+     * a random sequence generator producing a more natural ordered, harmonic
+     * succession of numbers compared to the standard <b>random()</b> function.
+     * It was invented by Ken Perlin in the 1980s and been used since in
+     * graphical applications to produce procedural textures, natural motion,
+     * shapes, terrains etc. The main difference to the
+     * <b>random()</b> function is that Perlin noise is defined in an infinite
+     * n-dimensional space where each pair of coordinates corresponds to a fixed
+     * semi-random value (fixed only for the lifespan of the program). The
+     * resulting value will always be between 0.0 and 1.0. Processing can
+     * compute 1D, 2D and 3D noise, depending on the number of coordinates
+     * given. The noise value can be animated by moving through the noise space
+     * as demonstrated in the example above. The 2nd and 3rd dimension can also
+     * be interpreted as time.The actual noise is structured similar to an audio
+     * signal, in respect to the function's use of frequencies. Similar to the
+     * concept of harmonics in physics, perlin noise is computed over several
+     * octaves which are added together for the final result. Another way to
+     * adjust the character of the resulting sequence is the scale of the input
+     * coordinates. As the function works within an infinite space the value of
+     * the coordinates doesn't matter as such, only the distance between
+     * successive coordinates does (eg. when using <b>noise()</b> within a
+     * loop). As a general rule the smaller the difference between coordinates,
+     * the smoother the resulting noise sequence will be. Steps of 0.005-0.03
+     * work best for most applications, but this will differ depending on use.
+     * <p>
+     * @param x x-coordinate in noise space
+     * @param y y-coordinate in noise space
+     * @param z z-coordinate in noise space
+     * @return
+     */
+    float noise(float x, float y, float z);
+
+    float noise(float x, float y, float z, float w);
+
+    void noiseMode(NoiseMode mode);
+
+    /**
+     * Adjusts the character and level of detail produced by the Perlin noise
+     * function.Similar to harmonics in physics, noise is computed over several
+     * octaves. Lower octaves contribute more to the output signal and as such
+     * define the overal intensity of the noise, whereas higher octaves create
+     * finer grained details in the noise sequence. By default, noise is
+     * computed over 4 octaves with each octave contributing exactly half than
+     * its predecessor, starting at 50% strength for the 1st octave. This
+     * falloff amount can be changed by adding an additional function parameter.
+     * Eg. a falloff factor of 0.75 means each octave will now have 75% impact
+     * (25% less) of the previous lower octave. Any value between 0.0 and 1.0 is
+     * valid, however note that values greater than 0.5 might result in greater
+     * than 1.0 values returned by <b>noise()</b>.By changing these parameters,
+     * the signal created by the <b>noise()</b>
+     * function can be adapted to fit very specific needs and characteristics.
+     *
+     * @param lod
+     */
+    void noiseDetail(int lod);
+
+    /**
+     * @param lod
+     * @param falloff falloff factor for each octave
+     */
+    void noiseDetail(int lod, float falloff);
+
+    /**
+     * Sets the seed value for <b>noise()</b>.By default, <b>noise()</b>
+     * produces different results each time the program is run. Set the
+     * <b>value</b> parameter to a constant to return the same pseudo-random
+     * numbers each time the software is run.
+     *
+     * @param seed
+     */
+    void noiseSeed(long seed);
+}

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),
@@ -31,7 +33,7 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         new Grad(1, 1, 1, 0), new Grad(1, 1, -1, 0), new Grad(1, -1, 1, 0), new Grad(1, -1, -1, 0),
         new Grad(-1, 1, 1, 0), new Grad(-1, 1, -1, 0), new Grad(-1, -1, 1, 0), new Grad(-1, -1, -1, 0)};
 
-    private static short p[] = {151, 160, 137, 91, 90, 15,
+    private final static short p[] = {151, 160, 137, 91, 90, 15,
         131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
         190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
         88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166,
@@ -45,7 +47,7 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254,
         138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180};
     // To remove the need for index wrapping, double the permutation table length
-    static short[] PERM = new short[512];
+    final static short[] PERM = new short[512];
     static short[] PERM_MOD_12 = new short[512];
 
     static {
@@ -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;