propane 3.6.0-java → 3.10.0-java

data/src/main/java/monkstone/PropaneLibrary.java

@@ -28,6 +28,8 @@ public class PropaneLibrary implements Library {
      */
     public static void load(final Ruby runtime) {
         MathToolModule.createMathToolModule(runtime);
+        FastNoiseModuleJava.createNoiseModule(runtime);
+        SmoothNoiseModuleJava.createNoiseModule(runtime);
         Deglut.createDeglut(runtime);
         Vec2.createVec2(runtime);
         Vec3.createVec3(runtime);

data/src/main/java/monkstone/SmoothNoiseModuleJava.java

@@ -0,0 +1,127 @@
+/*
+ * 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;
+
+import monkstone.noise.OpenSimplex2S;
+import org.jruby.Ruby;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyModule;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author Martin Prout
+ */
+@JRubyModule(name = "SmoothNoise")
+public class SmoothNoiseModuleJava {
+
+    static OpenSimplex2S ng = new OpenSimplex2S(System.currentTimeMillis());
+
+    /**
+     *
+     * @param runtime Ruby
+     */
+    public static void createNoiseModule(Ruby runtime) {
+        RubyModule noiseModule = runtime.defineModule("SmoothNoise");
+        noiseModule.defineAnnotatedMethods(SmoothNoiseModuleJava.class);
+    }
+
+    /**
+     *
+     * @param context ThreadContext
+     * @param recv IRubyObject
+     * @param args array of numeric values
+     * @return mapped value RubyFloat
+     */
+    @JRubyMethod(name = "tnoise", rest = true, module = true)
+    public static IRubyObject terrainNoiseImpl(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        double result = 0;
+        double one;
+        double two;
+        double three;
+        double four;
+        switch (args.length) {
+            case 2:
+                two = args[1] instanceof RubyFloat ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+                one = args[0] instanceof RubyFloat ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+                result = ng.noise2_XBeforeY(one, two);
+                break;
+            case 3:
+                three = args[2] instanceof RubyFloat ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
+                two = args[1] instanceof RubyFloat ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+                one = args[0] instanceof RubyFloat ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+                result = ng.noise3_XYBeforeZ(one, two, three);
+                break;
+            case 4:
+                four = args[3] instanceof RubyFloat ? ((RubyFloat) args[3]).getValue() : ((RubyFixnum) args[3]).getDoubleValue();
+                three = args[2] instanceof RubyFloat ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
+                two = args[1] instanceof RubyFloat ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+                one = args[0] instanceof RubyFloat ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+                result = ng.noise4_XYBeforeZW(one, two, three, four);
+                break;
+            default:
+                throw new RuntimeException("Min 2D Max 4D Noise");
+        }
+        return RubyFloat.newFloat(context.runtime, result);
+    }
+
+    /**
+     *
+     * @param context ThreadContext
+     * @param recv IRubyObject
+     * @param args array of numeric values
+     * @return mapped value RubyFloat
+     */
+    @JRubyMethod(name = "noise", rest = true, module = true)
+    public static IRubyObject noiseImpl(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        double result = 0;
+        double one;
+        double two;
+        double three;
+        double four;
+        switch (args.length) {
+            case 1:
+                one = args[0] instanceof RubyFloat ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+                result = ng.noise2(one, 0);
+                break;
+            case 2:
+                two = args[1] instanceof RubyFloat ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+                one = args[0] instanceof RubyFloat ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+                result = ng.noise2(one, two);
+                break;
+            case 3:
+                three = args[2] instanceof RubyFloat ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
+                two = args[1] instanceof RubyFloat ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+                one = args[0] instanceof RubyFloat ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+                result = ng.noise3_Classic(one, two, three);
+                break;
+            case 4:
+                four = args[3] instanceof RubyFloat ? ((RubyFloat) args[3]).getValue() : ((RubyFixnum) args[3]).getDoubleValue();
+                three = args[2] instanceof RubyFloat ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
+                two = args[1] instanceof RubyFloat ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+                one = args[0] instanceof RubyFloat ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+                result = ng.noise4_Classic(one, two, three, four);
+                break;
+            default:
+                throw new RuntimeException("Maximum of 4D Noise");
+        }
+        return RubyFloat.newFloat(context.runtime, result);
+    }
+//    @JRubyMethod(name = "noise_seed", rest = true, module = true)
+//    public static IRubyObject noiseSeedImpl(ThreadContext context, IRubyObject recv, IRubyObject arg) {
+//        long seed;
+//        if (arg instanceof RubyNumeric) {
+//            seed = ((RubyNumeric) arg).getLongValue();
+//            ng = new OpenSimplex2S(seed);
+//            return RubyBoolean.newBoolean(context.runtime, true);
+//        }
+//       return RubyBoolean.newBoolean(context.runtime, false);
+//    }
+}

data/src/main/java/monkstone/fastmath/DegLutTables.java

@@ -0,0 +1,111 @@
+/* 
+ * Copyright (c) 2021 Martin Prout
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 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 Lesser 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
+ */
+package monkstone.fastmath;
+
+public final class DegLutTables {
+
+    /**
+     *
+     */
+   static public float PI = 3.1415927f;
+
+    /**
+     *
+     */
+   public static final float PI2 = PI * 2;
+    static private final int SIN_BITS = 15; // 16KB. Adjust for accuracy.
+    static private final int SIN_MASK = ~(-1 << SIN_BITS);
+    static private final int SIN_COUNT = SIN_MASK + 1;
+
+    private static final float RAD_FULL = PI * 2;
+    private static final float DEG_FULL = 360;
+    private static final float RAD_TO_INDEX = SIN_COUNT / RAD_FULL;
+    private static final float DEG_TO_INDEX = SIN_COUNT / DEG_FULL;
+
+    /**
+     * multiply by this to convert from radians to degrees
+     */
+   public static final float RADIANS_TO_DEGREES = 180f / PI;
+
+    /**
+     *
+     */
+   public static final float RAD_DEG = RADIANS_TO_DEGREES;
+    /**
+     * multiply by this to convert from degrees to radians
+     */
+   public static final float DEGREES_TO_RADIANS = PI / 180;
+
+    /**
+     *
+     */
+   public static final float DEG_RAD = DEGREES_TO_RADIANS;
+
+    static private class Sin {
+
+        static float[] table = new float[SIN_COUNT];
+
+        static {
+            for (int i = 0; i < SIN_COUNT; i++) {
+                table[i] = (float) Math.sin((i + 0.5f) / SIN_COUNT * RAD_FULL);
+            }
+            for (int i = 0; i < 360; i += 90) {
+                table[(int) (i * DEG_TO_INDEX) & SIN_MASK] = (float) Math.sin(i * DEGREES_TO_RADIANS);
+            }
+        }
+    }
+
+    /**
+     * Returns the sine in radians from a lookup table.
+     * @param radians
+     * @return 
+     */
+   static public float sin(float radians) {
+        return Sin.table[(int) (radians * RAD_TO_INDEX) & SIN_MASK];
+    }
+
+    /**
+     * Returns the cosine in radians from a lookup table.
+     * @param radians
+     * @return 
+     */
+   static public float cos(float radians) {
+        return Sin.table[(int) ((radians + PI / 2) * RAD_TO_INDEX) & SIN_MASK];
+    }
+
+    /**
+     * Returns the sine in radians from a lookup table.
+     * @param degrees
+     * @return 
+     */
+   static public float sinDeg(float degrees) {
+        return Sin.table[(int) (degrees * DEG_TO_INDEX) & SIN_MASK];
+    }
+
+    /**
+     * Returns the cosine in radians from a lookup table.
+     * @param degrees
+     * @return 
+     */
+   static public float cosDeg(float degrees) {
+        return Sin.table[(int) ((degrees + 90) * DEG_TO_INDEX) & SIN_MASK];
+    }
+}
+

data/src/main/java/monkstone/fastmath/Deglut.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2015-20 Martin Prout
+ * Copyright (c) 2015-21 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -20,7 +20,7 @@
 package monkstone.fastmath;
 
 import org.jruby.Ruby;
-import org.jruby.RubyInteger;
+import org.jruby.RubyNumeric;
 import org.jruby.RubyModule;
 import org.jruby.anno.JRubyModule;
 import org.jruby.anno.JRubyMethod;
@@ -34,38 +34,6 @@ import org.jruby.runtime.builtin.IRubyObject;
 @JRubyModule(name = "DegLut")
 public class Deglut {
 
-    /**
-     * Lookup table for degree cosine/sine, has a fixed precision 1.0 degrees
-     * Quite accurate but imprecise
-     *
-     * @author Martin Prout <martin_p@lineone.net>
-     */
-    static final double[] SIN_DEG_LUT = new double[91];
-    /**
-     *
-     */
-    public static final double TO_RADIANS = Math.PI / 180;
-    /**
-     *
-     */
-    private static boolean initialized = false;
-
-    private final static int NINETY = 90;
-    private final static int FULL = 360;
-    private static final long serialVersionUID = -1466528933765940101L;
-
-    /**
-     * Initialize sin table with values (first quadrant only)
-     */
-    public static final void initTable() {
-        if (initialized == false) {
-            for (int i = 0; i <= NINETY; i++) {
-                SIN_DEG_LUT[i] = Math.sin(TO_RADIANS * i);
-            }
-            initialized = true;
-        }
-    }
-
     /**
      *
      * @param runtime Ruby
@@ -73,7 +41,6 @@ public class Deglut {
     public static void createDeglut(final Ruby runtime) {
         RubyModule deglutModule = runtime.defineModule("DegLut");
         deglutModule.defineAnnotatedMethods(Deglut.class);
-        Deglut.initTable();
     }
 
     /**
@@ -84,18 +51,9 @@ public class Deglut {
      * @return sin IRubyObject
      */
     @JRubyMethod(name = "sin", module = true)
-
     public static IRubyObject sin(ThreadContext context, IRubyObject recv, IRubyObject other) {
-        int thet = (int) ((RubyInteger) other).getLongValue();
-        while (thet < 0) {
-            thet += FULL; // Needed because negative modulus plays badly in java
-        }
-        int theta = thet % FULL;
-        int y = theta % NINETY;
-        double result = (theta < NINETY) ? SIN_DEG_LUT[y] : (theta < 180)
-                ? SIN_DEG_LUT[NINETY - y] : (theta < 270)
-                        ? -SIN_DEG_LUT[y] : -SIN_DEG_LUT[NINETY - y];
-        return context.runtime.newFloat(result);
+        float thet = (float) ((RubyNumeric) other).getLongValue();
+        return context.runtime.newFloat(DegLutTables.sinDeg(thet));
     }
 
     /**
@@ -107,15 +65,7 @@ public class Deglut {
      */
     @JRubyMethod(name = "cos", module = true)
     public static IRubyObject cos(ThreadContext context, IRubyObject recv, IRubyObject other) {
-        int thet = (int) ((RubyInteger) other).getLongValue();
-        while (thet < 0) {
-            thet += FULL; // Needed because negative modulus plays badly in java
-        }
-        int theta = thet % FULL;
-        int y = theta % NINETY;
-        double result = (theta < NINETY) ? SIN_DEG_LUT[NINETY - y] : (theta < 180)
-                ? -SIN_DEG_LUT[y] : (theta < 270)
-                        ? -SIN_DEG_LUT[NINETY - y] : SIN_DEG_LUT[y];
-        return context.runtime.newFloat(result);
+        float thet = (float) ((RubyNumeric) other).getLongValue();
+        return context.runtime.newFloat(DegLutTables.cosDeg(thet));
     }
 }

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

@@ -35,5 +35,5 @@ import java.io.File;
 @FunctionalInterface 
 public interface Chooser {
 
-    public void file_selected(File selection);
+    void file_selected(File selection);
 }

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

@@ -0,0 +1,813 @@
+package monkstone.noise;
+/**
+ * K.jpg's OpenSimplex 2, faster variant
+ *
+ * - 2D is standard simplex implemented using a lookup table.
+ * - 3D is "Re-oriented 4-point BCC noise" which constructs a
+ *   congruent BCC lattice in a much different way than usual.
+ * - 4D constructs the lattice as a union of five copies of its
+ *   reciprocal. It successively finds the closest point on each.
+ *
+ * Multiple versions of each function are provided. See the
+ * documentation above each, for more info.
+ */
+public class OpenSimplex2F {
+
+	private static final int PSIZE = 2048;
+	private static final int PMASK = 2047;
+
+	private final short[] perm;
+	private final Grad2[] permGrad2;
+	private final Grad3[] permGrad3;
+	private final Grad4[] permGrad4;
+
+    /**
+     *
+     * @param seed
+     */
+    public OpenSimplex2F(long seed) {
+		perm = new short[PSIZE];
+		permGrad2 = new Grad2[PSIZE];
+		permGrad3 = new Grad3[PSIZE];
+		permGrad4 = new Grad4[PSIZE];
+		short[] source = new short[PSIZE];
+		for (short i = 0; i < PSIZE; i++)
+			source[i] = i;
+		for (int i = PSIZE - 1; i >= 0; i--) {
+			seed = seed * 6364136223846793005L + 1442695040888963407L;
+			int r = (int)((seed + 31) % (i + 1));
+			if (r < 0)
+				r += i + 1;
+			perm[i] = source[r];
+			permGrad2[i] = GRADIENTS_2D[perm[i]];
+			permGrad3[i] = GRADIENTS_3D[perm[i]];
+			permGrad4[i] = GRADIENTS_4D[perm[i]];
+			source[r] = source[i];
+		}
+	}
+
+	/*
+	 * Noise Evaluators
+	 */
+
+	/**
+	 * 2D Simplex noise, standard lattice orientation.
+     * @param x
+     * @param y
+     * @return 
+	 */
+	public double noise2(double x, double y) {
+
+		// Get points for A2* lattice
+		double s = 0.366025403784439 * (x + y);
+		double xs = x + s, ys = y + s;
+
+		return noise2_Base(xs, ys);
+	}
+
+	/**
+	 * 2D Simplex noise, with Y pointing down the main diagonal.Might be better for a 2D sandbox style game, where Y is vertical.Probably slightly less optimal for heightmaps or continent maps.
+     * @param x
+     * @param y
+     * @return 
+	 */
+	public double noise2_XBeforeY(double x, double y) {
+
+		// Skew transform and rotation baked into one.
+		double xx = x * 0.7071067811865476;
+		double yy = y * 1.224744871380249;
+
+		return noise2_Base(yy + xx, yy - xx);
+	}
+
+	/**
+	 * 2D Simplex noise base.
+	 * Lookup table implementation inspired by DigitalShadow.
+	 */
+	private double noise2_Base(double xs, double ys) {
+		double value = 0;
+
+		// Get base points and offsets
+		int xsb = fastFloor(xs), ysb = fastFloor(ys);
+		double xsi = xs - xsb, ysi = ys - ysb;
+
+		// Index to point list
+		int index = (int)((ysi - xsi) / 2 + 1);
+
+		double ssi = (xsi + ysi) * -0.211324865405187;
+		double xi = xsi + ssi, yi = ysi + ssi;
+
+		// Point contributions
+		for (int i = 0; i < 3; i++) {
+			LatticePoint2D c = LOOKUP_2D[index + i];
+
+			double dx = xi + c.dx, dy = yi + c.dy;
+			double attn = 0.5 - dx * dx - dy * dy;
+			if (attn <= 0) continue;
+
+			int pxm = (xsb + c.xsv) & PMASK, pym = (ysb + c.ysv) & PMASK;
+			Grad2 grad = permGrad2[perm[pxm] ^ pym];
+			double extrapolation = grad.dx * dx + grad.dy * dy;
+
+			attn *= attn;
+			value += attn * attn * extrapolation;
+		}
+
+		return value;
+	}
+
+	/**
+	 * 3D Re-oriented 4-point BCC noise, classic orientation.Proper substitute for 3D Simplex in light of Forbidden Formulae.Use noise3_XYBeforeZ or noise3_XZBeforeY instead, wherever appropriate.
+     * @param x
+     * @param y
+     * @param z
+     * @return 
+	 */
+	public double noise3_Classic(double x, double y, double z) {
+
+		// Re-orient the cubic lattices via rotation, to produce the expected look on cardinal planar slices.
+		// If texturing objects that don't tend to have cardinal plane faces, you could even remove this.
+		// Orthonormal rotation. Not a skew transform.
+		double r = (2.0 / 3.0) * (x + y + z);
+		double xr = r - x, yr = r - y, zr = r - z;
+
+		// Evaluate both lattices to form a BCC lattice.
+		return noise3_BCC(xr, yr, zr);
+	}
+
+	/**
+	 * 3D Re-oriented 4-point BCC noise, with better visual isotropy in (X, Y).Recommended for 3D terrain and time-varied animations.The Z coordinate should always be the "different" coordinate in your use case.If Y is vertical in world coordinates, call noise3_XYBeforeZ(x, z, Y) or use noise3_XZBeforeY.If Z is vertical in world coordinates, call noise3_XYBeforeZ(x, y, Z).
+	 * For a time varied animation, call noise3_XYBeforeZ(x, y, T).
+     * @param x
+     * @param y
+     * @param z
+     * @return 
+	 */
+	public double noise3_XYBeforeZ(double x, double y, double z) {
+
+		// Re-orient the cubic lattices without skewing, to make X and Y triangular like 2D.
+		// Orthonormal rotation. Not a skew transform.
+		double xy = x + y;
+		double s2 = xy * -0.211324865405187;
+		double zz = z * 0.577350269189626;
+		double xr = x + s2 - zz, yr = y + s2 - zz;
+		double zr = xy * 0.577350269189626 + zz;
+
+		// Evaluate both lattices to form a BCC lattice.
+		return noise3_BCC(xr, yr, zr);
+	}
+
+	/**
+	 * 3D Re-oriented 4-point BCC noise, with better visual isotropy in (X, Z).Recommended for 3D terrain and time-varied animations.The Y coordinate should always be the "different" coordinate in your use case.If Y is vertical in world coordinates, call noise3_XZBeforeY(x, Y, z).If Z is vertical in world coordinates, call noise3_XZBeforeY(x, Z, y) or use noise3_XYBeforeZ.
+	 * For a time varied animation, call noise3_XZBeforeY(x, T, y) or use noise3_XYBeforeZ.
+     * @param x
+     * @param y
+     * @param z
+     * @return 
+	 */
+	public double noise3_XZBeforeY(double x, double y, double z) {
+
+		// Re-orient the cubic lattices without skewing, to make X and Z triangular like 2D.
+		// Orthonormal rotation. Not a skew transform.
+		double xz = x + z;
+		double s2 = xz * -0.211324865405187;
+		double yy = y * 0.577350269189626;
+		double xr = x + s2 - yy; double zr = z + s2 - yy;
+		double yr = xz * 0.577350269189626 + yy;
+
+		// Evaluate both lattices to form a BCC lattice.
+		return noise3_BCC(xr, yr, zr);
+	}
+
+	/**
+	 * Generate overlapping cubic lattices for 3D Re-oriented BCC noise.
+	 * Lookup table implementation inspired by DigitalShadow.
+	 * It was actually faster to narrow down the points in the loop itself,
+	 * than to build up the index with enough info to isolate 4 points.
+	 */
+	private double noise3_BCC(double xr, double yr, double zr) {
+
+		// Get base and offsets inside cube of first lattice.
+		int xrb = fastFloor(xr), yrb = fastFloor(yr), zrb = fastFloor(zr);
+		double xri = xr - xrb, yri = yr - yrb, zri = zr - zrb;
+
+		// Identify which octant of the cube we're in. This determines which cell
+		// in the other cubic lattice we're in, and also narrows down one point on each.
+		int xht = (int)(xri + 0.5), yht = (int)(yri + 0.5), zht = (int)(zri + 0.5);
+		int index = (xht) | (yht << 1) | (zht << 2);
+
+		// Point contributions
+		double value = 0;
+		LatticePoint3D c = LOOKUP_3D[index];
+		while (c != null) {
+			double dxr = xri + c.dxr, dyr = yri + c.dyr, dzr = zri + c.dzr;
+			double attn = 0.5 - dxr * dxr - dyr * dyr - dzr * dzr;
+			if (attn < 0) {
+				c = c.nextOnFailure;
+			} else {
+				int pxm = (xrb + c.xrv) & PMASK, pym = (yrb + c.yrv) & PMASK, pzm = (zrb + c.zrv) & PMASK;
+				Grad3 grad = permGrad3[perm[perm[pxm] ^ pym] ^ pzm];
+				double extrapolation = grad.dx * dxr + grad.dy * dyr + grad.dz * dzr;
+
+				attn *= attn;
+				value += attn * attn * extrapolation;
+				c = c.nextOnSuccess;
+			}
+		}
+		return value;
+	}
+
+	/**
+	 * 4D OpenSimplex2F noise, classic lattice orientation.
+     * @param x
+     * @param y
+     * @param w
+     * @param z
+     * @return 
+	 */
+	public double noise4_Classic(double x, double y, double z, double w) {
+
+		// Get points for A4 lattice
+		double s = -0.138196601125011 * (x + y + z + w);
+		double xs = x + s, ys = y + s, zs = z + s, ws = w + s;
+
+		return noise4_Base(xs, ys, zs, ws);
+	}
+
+	/**
+	 * 4D OpenSimplex2F noise, with XY and ZW forming orthogonal triangular-based planes.Recommended for 3D terrain, where X and Y (or Z and W) are horizontal.Recommended for noise(x, y, sin(time), cos(time)) trick.
+     * @param x
+     * @param z
+     * @param y
+     * @param w
+     * @return 
+	 */
+	public double noise4_XYBeforeZW(double x, double y, double z, double w) {
+
+		double s2 = (x + y) * -0.178275657951399372 + (z + w) * 0.215623393288842828;
+		double t2 = (z + w) * -0.403949762580207112 + (x + y) * -0.375199083010075342;
+		double xs = x + s2, ys = y + s2, zs = z + t2, ws = w + t2;
+
+		return noise4_Base(xs, ys, zs, ws);
+	}
+
+	/**
+	 * 4D OpenSimplex2F noise, with XZ and YW forming orthogonal triangular-based planes.Recommended for 3D terrain, where X and Z (or Y and W) are horizontal.
+     * @param x
+     * @param z
+     * @param y
+     * @param w
+     * @return 
+	 */
+	public double noise4_XZBeforeYW(double x, double y, double z, double w) {
+
+		double s2 = (x + z) * -0.178275657951399372 + (y + w) * 0.215623393288842828;
+		double t2 = (y + w) * -0.403949762580207112 + (x + z) * -0.375199083010075342;
+		double xs = x + s2, ys = y + t2, zs = z + s2, ws = w + t2;
+
+		return noise4_Base(xs, ys, zs, ws);
+	}
+
+	/**
+	 * 4D OpenSimplex2F noise, with XYZ oriented like noise3_Classic,
+	 * and W for an extra degree of freedom.W repeats eventually.Recommended for time-varied animations which texture a 3D object (W=time)
+     * @param x
+     * @param w
+     * @param y
+     * @param z
+     * @return
+	 */
+	public double noise4_XYZBeforeW(double x, double y, double z, double w) {
+
+		double xyz = x + y + z;
+		double ww = w * 0.2236067977499788;
+		double s2 = xyz * -0.16666666666666666 + ww;
+		double xs = x + s2, ys = y + s2, zs = z + s2, ws = -0.5 * xyz + ww;
+
+		return noise4_Base(xs, ys, zs, ws);
+	}
+
+	/**
+	 * 4D OpenSimplex2F noise base.
+	 * Current implementation not fully optimized by lookup tables.
+	 * But still comes out slightly ahead of Gustavson's Simplex in tests.
+	 */
+	private double noise4_Base(double xs, double ys, double zs, double ws) {
+		double value = 0;
+
+		// Get base points and offsets
+		int xsb = fastFloor(xs), ysb = fastFloor(ys), zsb = fastFloor(zs), wsb = fastFloor(ws);
+		double xsi = xs - xsb, ysi = ys - ysb, zsi = zs - zsb, wsi = ws - wsb;
+
+		// If we're in the lower half, flip so we can repeat the code for the upper half. We'll flip back later.
+		double siSum = xsi + ysi + zsi + wsi;
+		double ssi = siSum * 0.309016994374947; // Prep for vertex contributions.
+		boolean inLowerHalf = siSum < 2;
+		if (inLowerHalf) {
+			xsi = 1 - xsi; ysi = 1 - ysi; zsi = 1 - zsi; wsi = 1 - wsi;
+			siSum = 4 - siSum;
+		}
+
+		// Consider opposing vertex pairs of the octahedron formed by the central cross-section of the stretched tesseract
+		double aabb = xsi + ysi - zsi - wsi, abab = xsi - ysi + zsi - wsi, abba = xsi - ysi - zsi + wsi;
+		double aabbScore = Math.abs(aabb), ababScore = Math.abs(abab), abbaScore = Math.abs(abba);
+
+		// Find the closest point on the stretched tesseract as if it were the upper half
+		int vertexIndex, via, vib;
+		double asi, bsi;
+		if (aabbScore > ababScore && aabbScore > abbaScore) {
+			if (aabb > 0) {
+				asi = zsi; bsi = wsi; vertexIndex = 0b0011; via = 0b0111; vib = 0b1011;
+			} else {
+				asi = xsi; bsi = ysi; vertexIndex = 0b1100; via = 0b1101; vib = 0b1110;
+			}
+		} else if (ababScore > abbaScore) {
+			if (abab > 0) {
+				asi = ysi; bsi = wsi; vertexIndex = 0b0101; via = 0b0111; vib = 0b1101;
+			} else {
+				asi = xsi; bsi = zsi; vertexIndex = 0b1010; via = 0b1011; vib = 0b1110;
+			}
+		} else {
+			if (abba > 0) {
+				asi = ysi; bsi = zsi; vertexIndex = 0b1001; via = 0b1011; vib = 0b1101;
+			} else {
+				asi = xsi; bsi = wsi; vertexIndex = 0b0110; via = 0b0111; vib = 0b1110;
+			}
+		}
+		if (bsi > asi) {
+			via = vib;
+			double temp = bsi;
+			bsi = asi;
+			asi = temp;
+		}
+		if (siSum + asi > 3) {
+			vertexIndex = via;
+			if (siSum + bsi > 4) {
+				vertexIndex = 0b1111;
+			}
+		}
+
+		// Now flip back if we're actually in the lower half.
+		if (inLowerHalf) {
+			xsi = 1 - xsi; ysi = 1 - ysi; zsi = 1 - zsi; wsi = 1 - wsi;
+			vertexIndex ^= 0b1111;
+		}
+
+		// Five points to add, total, from five copies of the A4 lattice.
+		for (int i = 0; i < 5; i++) {
+
+			// Update xsb/etc. and add the lattice point's contribution.
+			LatticePoint4D c = VERTICES_4D[vertexIndex];
+			xsb += c.xsv; ysb += c.ysv; zsb += c.zsv; wsb += c.wsv;
+			double xi = xsi + ssi, yi = ysi + ssi, zi = zsi + ssi, wi = wsi + ssi;
+			double dx = xi + c.dx, dy = yi + c.dy, dz = zi + c.dz, dw = wi + c.dw;
+			double attn = 0.5 - dx * dx - dy * dy - dz * dz - dw * dw;
+			if (attn > 0) {
+				int pxm = xsb & PMASK, pym = ysb & PMASK, pzm = zsb & PMASK, pwm = wsb & PMASK;
+				Grad4 grad = permGrad4[perm[perm[perm[pxm] ^ pym] ^ pzm] ^ pwm];
+				double ramped = grad.dx * dx + grad.dy * dy + grad.dz * dz + grad.dw * dw;
+
+				attn *= attn;
+				value += attn * attn * ramped;
+			}
+
+			// Maybe this helps the compiler/JVM/LLVM/etc. know we can end the loop here. Maybe not.
+			if (i == 4) break;
+
+			// Update the relative skewed coordinates to reference the vertex we just added.
+			// Rather, reference its counterpart on the lattice copy that is shifted down by
+			// the vector <-0.2, -0.2, -0.2, -0.2>
+			xsi += c.xsi; ysi += c.ysi; zsi += c.zsi; wsi += c.wsi;
+			ssi += c.ssiDelta;
+
+			// Next point is the closest vertex on the 4-simplex whose base vertex is the aforementioned vertex.
+			double score0 = 1.0 + ssi * (-1.0 / 0.309016994374947); // Seems slightly faster than 1.0-xsi-ysi-zsi-wsi
+			vertexIndex = 0b0000;
+			if (xsi >= ysi && xsi >= zsi && xsi >= wsi && xsi >= score0) {
+				vertexIndex = 0b0001;
+			}
+			else if (ysi > xsi && ysi >= zsi && ysi >= wsi && ysi >= score0) {
+				vertexIndex = 0b0010;
+			}
+			else if (zsi > xsi && zsi > ysi && zsi >= wsi && zsi >= score0) {
+				vertexIndex = 0b0100;
+			}
+			else if (wsi > xsi && wsi > ysi && wsi > zsi && wsi >= score0) {
+				vertexIndex = 0b1000;
+			}
+		}
+
+		return value;
+	}
+
+	/*
+	 * Utility
+	 */
+
+	private static int fastFloor(double x) {
+		int xi = (int)x;
+		return x < xi ? xi - 1 : xi;
+	}
+
+	/*
+	 * Definitions
+	 */
+
+	private static final LatticePoint2D[] LOOKUP_2D;
+	private static final LatticePoint3D[] LOOKUP_3D;
+	private static final LatticePoint4D[] VERTICES_4D;
+	static {
+		LOOKUP_2D = new LatticePoint2D[4];
+		LOOKUP_3D = new LatticePoint3D[8];
+		VERTICES_4D = new LatticePoint4D[16];
+
+		LOOKUP_2D[0] = new LatticePoint2D(1, 0);
+		LOOKUP_2D[1] = new LatticePoint2D(0, 0);
+		LOOKUP_2D[2] = new LatticePoint2D(1, 1);
+		LOOKUP_2D[3] = new LatticePoint2D(0, 1);
+
+		for (int i = 0; i < 8; i++) {
+			int i1, j1, k1, i2, j2, k2;
+			i1 = (i) & 1; j1 = (i >> 1) & 1; k1 = (i >> 2) & 1;
+			i2 = i1 ^ 1; j2 = j1 ^ 1; k2 = k1 ^ 1;
+
+			// The two points within this octant, one from each of the two cubic half-lattices.
+			LatticePoint3D c0 = new LatticePoint3D(i1, j1, k1, 0);
+			LatticePoint3D c1 = new LatticePoint3D(i1 + i2, j1 + j2, k1 + k2, 1);
+
+			// Each single step away on the first half-lattice.
+			LatticePoint3D c2 = new LatticePoint3D(i1 ^ 1, j1, k1, 0);
+			LatticePoint3D c3 = new LatticePoint3D(i1, j1 ^ 1, k1, 0);
+			LatticePoint3D c4 = new LatticePoint3D(i1, j1, k1 ^ 1, 0);
+
+			// Each single step away on the second half-lattice.
+			LatticePoint3D c5 = new LatticePoint3D(i1 + (i2 ^ 1), j1 + j2, k1 + k2, 1);
+			LatticePoint3D c6 = new LatticePoint3D(i1 + i2, j1 + (j2 ^ 1), k1 + k2, 1);
+			LatticePoint3D c7 = new LatticePoint3D(i1 + i2, j1 + j2, k1 + (k2 ^ 1), 1);
+
+			// First two are guaranteed.
+			c0.nextOnFailure = c0.nextOnSuccess = c1;
+			c1.nextOnFailure = c1.nextOnSuccess = c2;
+
+			// Once we find one on the first half-lattice, the rest are out.
+			// In addition, knowing c2 rules out c5.
+			c2.nextOnFailure = c3; c2.nextOnSuccess = c6;
+			c3.nextOnFailure = c4; c3.nextOnSuccess = c5;
+			c4.nextOnFailure = c4.nextOnSuccess = c5;
+
+			// Once we find one on the second half-lattice, the rest are out.
+			c5.nextOnFailure = c6; c5.nextOnSuccess = null;
+			c6.nextOnFailure = c7; c6.nextOnSuccess = null;
+			c7.nextOnFailure = c7.nextOnSuccess = null;
+
+			LOOKUP_3D[i] = c0;
+		}
+
+		for (int i = 0; i < 16; i++) {
+			VERTICES_4D[i] = new LatticePoint4D((i) & 1, (i >> 1) & 1, (i >> 2) & 1, (i >> 3) & 1);
+		}
+	}
+
+	private static class LatticePoint2D {
+		int xsv, ysv;
+		double dx, dy;
+		public LatticePoint2D(int xsv, int ysv) {
+			this.xsv = xsv; this.ysv = ysv;
+			double ssv = (xsv + ysv) * -0.211324865405187;
+			this.dx = -xsv - ssv;
+			this.dy = -ysv - ssv;
+		}
+	}
+
+	private static class LatticePoint3D {
+		public double dxr, dyr, dzr;
+		public int xrv, yrv, zrv;
+		LatticePoint3D nextOnFailure, nextOnSuccess;
+		public LatticePoint3D(int xrv, int yrv, int zrv, int lattice) {
+			this.dxr = -xrv + lattice * 0.5; this.dyr = -yrv + lattice * 0.5; this.dzr = -zrv + lattice * 0.5;
+			this.xrv = xrv + lattice * 1024; this.yrv = yrv + lattice * 1024; this.zrv = zrv + lattice * 1024;
+		}
+	}
+
+	private static class LatticePoint4D {
+		int xsv, ysv, zsv, wsv;
+		double dx, dy, dz, dw;
+		double xsi, ysi, zsi, wsi;
+		double ssiDelta;
+		public LatticePoint4D(int xsv, int ysv, int zsv, int wsv) {
+			this.xsv = xsv + 409; this.ysv = ysv + 409; this.zsv = zsv + 409; this.wsv = wsv + 409;
+			double ssv = (xsv + ysv + zsv + wsv) * 0.309016994374947;
+			this.dx = -xsv - ssv;
+			this.dy = -ysv - ssv;
+			this.dz = -zsv - ssv;
+			this.dw = -wsv - ssv;
+			this.xsi = xsi = 0.2 - xsv;
+			this.ysi = ysi = 0.2 - ysv;
+			this.zsi = zsi = 0.2 - zsv;
+			this.wsi = wsi = 0.2 - wsv;
+			this.ssiDelta = (0.8 - xsv - ysv - zsv - wsv) * 0.309016994374947;
+		}
+	}
+
+	/*
+	 * Gradients
+	 */
+
+	private static class Grad2 {
+		double dx, dy;
+		public Grad2(double dx, double dy) {
+			this.dx = dx; this.dy = dy;
+		}
+	}
+
+	private static class Grad3 {
+		double dx, dy, dz;
+		public Grad3(double dx, double dy, double dz) {
+			this.dx = dx; this.dy = dy; this.dz = dz;
+		}
+	}
+
+	private static class Grad4 {
+		double dx, dy, dz, dw;
+		public Grad4(double dx, double dy, double dz,  double dw) {
+			this.dx = dx; this.dy = dy; this.dz = dz; this.dw = dw;
+		}
+	}
+
+	private static final double N2 = 0.01001634121365712;
+	private static final double N3 = 0.030485933181293584;
+	private static final double N4 = 0.009202377986303158;
+	private static final Grad2[] GRADIENTS_2D;
+	private static final Grad3[] GRADIENTS_3D;
+	private static final Grad4[] GRADIENTS_4D;
+	static {
+
+		GRADIENTS_2D = new Grad2[PSIZE];
+		Grad2[] grad2 = {
+			new Grad2( 0.130526192220052,  0.99144486137381),
+			new Grad2( 0.38268343236509,   0.923879532511287),
+			new Grad2( 0.608761429008721,  0.793353340291235),
+			new Grad2( 0.793353340291235,  0.608761429008721),
+			new Grad2( 0.923879532511287,  0.38268343236509),
+			new Grad2( 0.99144486137381,   0.130526192220051),
+			new Grad2( 0.99144486137381,  -0.130526192220051),
+			new Grad2( 0.923879532511287, -0.38268343236509),
+			new Grad2( 0.793353340291235, -0.60876142900872),
+			new Grad2( 0.608761429008721, -0.793353340291235),
+			new Grad2( 0.38268343236509,  -0.923879532511287),
+			new Grad2( 0.130526192220052, -0.99144486137381),
+			new Grad2(-0.130526192220052, -0.99144486137381),
+			new Grad2(-0.38268343236509,  -0.923879532511287),
+			new Grad2(-0.608761429008721, -0.793353340291235),
+			new Grad2(-0.793353340291235, -0.608761429008721),
+			new Grad2(-0.923879532511287, -0.38268343236509),
+			new Grad2(-0.99144486137381,  -0.130526192220052),
+			new Grad2(-0.99144486137381,   0.130526192220051),
+			new Grad2(-0.923879532511287,  0.38268343236509),
+			new Grad2(-0.793353340291235,  0.608761429008721),
+			new Grad2(-0.608761429008721,  0.793353340291235),
+			new Grad2(-0.38268343236509,   0.923879532511287),
+			new Grad2(-0.130526192220052,  0.99144486137381)
+		};
+            for (Grad2 grad21 : grad2) {
+                grad21.dx /= N2;
+                grad21.dy /= N2;
+            }
+		for (int i = 0; i < PSIZE; i++) {
+			GRADIENTS_2D[i] = grad2[i % grad2.length];
+		}
+
+		GRADIENTS_3D = new Grad3[PSIZE];
+		Grad3[] grad3 = {
+			new Grad3(-2.22474487139,      -2.22474487139,      -1.0),
+			new Grad3(-2.22474487139,      -2.22474487139,       1.0),
+			new Grad3(-3.0862664687972017, -1.1721513422464978,  0.0),
+			new Grad3(-1.1721513422464978, -3.0862664687972017,  0.0),
+			new Grad3(-2.22474487139,      -1.0,                -2.22474487139),
+			new Grad3(-2.22474487139,       1.0,                -2.22474487139),
+			new Grad3(-1.1721513422464978,  0.0,                -3.0862664687972017),
+			new Grad3(-3.0862664687972017,  0.0,                -1.1721513422464978),
+			new Grad3(-2.22474487139,      -1.0,                 2.22474487139),
+			new Grad3(-2.22474487139,       1.0,                 2.22474487139),
+			new Grad3(-3.0862664687972017,  0.0,                 1.1721513422464978),
+			new Grad3(-1.1721513422464978,  0.0,                 3.0862664687972017),
+			new Grad3(-2.22474487139,       2.22474487139,      -1.0),
+			new Grad3(-2.22474487139,       2.22474487139,       1.0),
+			new Grad3(-1.1721513422464978,  3.0862664687972017,  0.0),
+			new Grad3(-3.0862664687972017,  1.1721513422464978,  0.0),
+			new Grad3(-1.0,                -2.22474487139,      -2.22474487139),
+			new Grad3( 1.0,                -2.22474487139,      -2.22474487139),
+			new Grad3( 0.0,                -3.0862664687972017, -1.1721513422464978),
+			new Grad3( 0.0,                -1.1721513422464978, -3.0862664687972017),
+			new Grad3(-1.0,                -2.22474487139,       2.22474487139),
+			new Grad3( 1.0,                -2.22474487139,       2.22474487139),
+			new Grad3( 0.0,                -1.1721513422464978,  3.0862664687972017),
+			new Grad3( 0.0,                -3.0862664687972017,  1.1721513422464978),
+			new Grad3(-1.0,                 2.22474487139,      -2.22474487139),
+			new Grad3( 1.0,                 2.22474487139,      -2.22474487139),
+			new Grad3( 0.0,                 1.1721513422464978, -3.0862664687972017),
+			new Grad3( 0.0,                 3.0862664687972017, -1.1721513422464978),
+			new Grad3(-1.0,                 2.22474487139,       2.22474487139),
+			new Grad3( 1.0,                 2.22474487139,       2.22474487139),
+			new Grad3( 0.0,                 3.0862664687972017,  1.1721513422464978),
+			new Grad3( 0.0,                 1.1721513422464978,  3.0862664687972017),
+			new Grad3( 2.22474487139,      -2.22474487139,      -1.0),
+			new Grad3( 2.22474487139,      -2.22474487139,       1.0),
+			new Grad3( 1.1721513422464978, -3.0862664687972017,  0.0),
+			new Grad3( 3.0862664687972017, -1.1721513422464978,  0.0),
+			new Grad3( 2.22474487139,      -1.0,                -2.22474487139),
+			new Grad3( 2.22474487139,       1.0,                -2.22474487139),
+			new Grad3( 3.0862664687972017,  0.0,                -1.1721513422464978),
+			new Grad3( 1.1721513422464978,  0.0,                -3.0862664687972017),
+			new Grad3( 2.22474487139,      -1.0,                 2.22474487139),
+			new Grad3( 2.22474487139,       1.0,                 2.22474487139),
+			new Grad3( 1.1721513422464978,  0.0,                 3.0862664687972017),
+			new Grad3( 3.0862664687972017,  0.0,                 1.1721513422464978),
+			new Grad3( 2.22474487139,       2.22474487139,      -1.0),
+			new Grad3( 2.22474487139,       2.22474487139,       1.0),
+			new Grad3( 3.0862664687972017,  1.1721513422464978,  0.0),
+			new Grad3( 1.1721513422464978,  3.0862664687972017,  0.0)
+		};
+            for (Grad3 grad31 : grad3) {
+                grad31.dx /= N3;
+                grad31.dy /= N3;
+                grad31.dz /= N3;
+            }
+		for (int i = 0; i < PSIZE; i++) {
+			GRADIENTS_3D[i] = grad3[i % grad3.length];
+		}
+
+		GRADIENTS_4D = new Grad4[PSIZE];
+		Grad4[] grad4 = {
+			new Grad4(-0.753341017856078,    -0.37968289875261624,  -0.37968289875261624,  -0.37968289875261624),
+			new Grad4(-0.7821684431180708,   -0.4321472685365301,   -0.4321472685365301,    0.12128480194602098),
+			new Grad4(-0.7821684431180708,   -0.4321472685365301,    0.12128480194602098,  -0.4321472685365301),
+			new Grad4(-0.7821684431180708,    0.12128480194602098,  -0.4321472685365301,   -0.4321472685365301),
+			new Grad4(-0.8586508742123365,   -0.508629699630796,     0.044802370851755174,  0.044802370851755174),
+			new Grad4(-0.8586508742123365,    0.044802370851755174, -0.508629699630796,     0.044802370851755174),
+			new Grad4(-0.8586508742123365,    0.044802370851755174,  0.044802370851755174, -0.508629699630796),
+			new Grad4(-0.9982828964265062,   -0.03381941603233842,  -0.03381941603233842,  -0.03381941603233842),
+			new Grad4(-0.37968289875261624,  -0.753341017856078,    -0.37968289875261624,  -0.37968289875261624),
+			new Grad4(-0.4321472685365301,   -0.7821684431180708,   -0.4321472685365301,    0.12128480194602098),
+			new Grad4(-0.4321472685365301,   -0.7821684431180708,    0.12128480194602098,  -0.4321472685365301),
+			new Grad4( 0.12128480194602098,  -0.7821684431180708,   -0.4321472685365301,   -0.4321472685365301),
+			new Grad4(-0.508629699630796,    -0.8586508742123365,    0.044802370851755174,  0.044802370851755174),
+			new Grad4( 0.044802370851755174, -0.8586508742123365,   -0.508629699630796,     0.044802370851755174),
+			new Grad4( 0.044802370851755174, -0.8586508742123365,    0.044802370851755174, -0.508629699630796),
+			new Grad4(-0.03381941603233842,  -0.9982828964265062,   -0.03381941603233842,  -0.03381941603233842),
+			new Grad4(-0.37968289875261624,  -0.37968289875261624,  -0.753341017856078,    -0.37968289875261624),
+			new Grad4(-0.4321472685365301,   -0.4321472685365301,   -0.7821684431180708,    0.12128480194602098),
+			new Grad4(-0.4321472685365301,    0.12128480194602098,  -0.7821684431180708,   -0.4321472685365301),
+			new Grad4( 0.12128480194602098,  -0.4321472685365301,   -0.7821684431180708,   -0.4321472685365301),
+			new Grad4(-0.508629699630796,     0.044802370851755174, -0.8586508742123365,    0.044802370851755174),
+			new Grad4( 0.044802370851755174, -0.508629699630796,    -0.8586508742123365,    0.044802370851755174),
+			new Grad4( 0.044802370851755174,  0.044802370851755174, -0.8586508742123365,   -0.508629699630796),
+			new Grad4(-0.03381941603233842,  -0.03381941603233842,  -0.9982828964265062,   -0.03381941603233842),
+			new Grad4(-0.37968289875261624,  -0.37968289875261624,  -0.37968289875261624,  -0.753341017856078),
+			new Grad4(-0.4321472685365301,   -0.4321472685365301,    0.12128480194602098,  -0.7821684431180708),
+			new Grad4(-0.4321472685365301,    0.12128480194602098,  -0.4321472685365301,   -0.7821684431180708),
+			new Grad4( 0.12128480194602098,  -0.4321472685365301,   -0.4321472685365301,   -0.7821684431180708),
+			new Grad4(-0.508629699630796,     0.044802370851755174,  0.044802370851755174, -0.8586508742123365),
+			new Grad4( 0.044802370851755174, -0.508629699630796,     0.044802370851755174, -0.8586508742123365),
+			new Grad4( 0.044802370851755174,  0.044802370851755174, -0.508629699630796,    -0.8586508742123365),
+			new Grad4(-0.03381941603233842,  -0.03381941603233842,  -0.03381941603233842,  -0.9982828964265062),
+			new Grad4(-0.6740059517812944,   -0.3239847771997537,   -0.3239847771997537,    0.5794684678643381),
+			new Grad4(-0.7504883828755602,   -0.4004672082940195,    0.15296486218853164,   0.5029860367700724),
+			new Grad4(-0.7504883828755602,    0.15296486218853164,  -0.4004672082940195,    0.5029860367700724),
+			new Grad4(-0.8828161875373585,    0.08164729285680945,   0.08164729285680945,   0.4553054119602712),
+			new Grad4(-0.4553054119602712,   -0.08164729285680945,  -0.08164729285680945,   0.8828161875373585),
+			new Grad4(-0.5029860367700724,   -0.15296486218853164,   0.4004672082940195,    0.7504883828755602),
+			new Grad4(-0.5029860367700724,    0.4004672082940195,   -0.15296486218853164,   0.7504883828755602),
+			new Grad4(-0.5794684678643381,    0.3239847771997537,    0.3239847771997537,    0.6740059517812944),
+			new Grad4(-0.3239847771997537,   -0.6740059517812944,   -0.3239847771997537,    0.5794684678643381),
+			new Grad4(-0.4004672082940195,   -0.7504883828755602,    0.15296486218853164,   0.5029860367700724),
+			new Grad4( 0.15296486218853164,  -0.7504883828755602,   -0.4004672082940195,    0.5029860367700724),
+			new Grad4( 0.08164729285680945,  -0.8828161875373585,    0.08164729285680945,   0.4553054119602712),
+			new Grad4(-0.08164729285680945,  -0.4553054119602712,   -0.08164729285680945,   0.8828161875373585),
+			new Grad4(-0.15296486218853164,  -0.5029860367700724,    0.4004672082940195,    0.7504883828755602),
+			new Grad4( 0.4004672082940195,   -0.5029860367700724,   -0.15296486218853164,   0.7504883828755602),
+			new Grad4( 0.3239847771997537,   -0.5794684678643381,    0.3239847771997537,    0.6740059517812944),
+			new Grad4(-0.3239847771997537,   -0.3239847771997537,   -0.6740059517812944,    0.5794684678643381),
+			new Grad4(-0.4004672082940195,    0.15296486218853164,  -0.7504883828755602,    0.5029860367700724),
+			new Grad4( 0.15296486218853164,  -0.4004672082940195,   -0.7504883828755602,    0.5029860367700724),
+			new Grad4( 0.08164729285680945,   0.08164729285680945,  -0.8828161875373585,    0.4553054119602712),
+			new Grad4(-0.08164729285680945,  -0.08164729285680945,  -0.4553054119602712,    0.8828161875373585),
+			new Grad4(-0.15296486218853164,   0.4004672082940195,   -0.5029860367700724,    0.7504883828755602),
+			new Grad4( 0.4004672082940195,   -0.15296486218853164,  -0.5029860367700724,    0.7504883828755602),
+			new Grad4( 0.3239847771997537,    0.3239847771997537,   -0.5794684678643381,    0.6740059517812944),
+			new Grad4(-0.6740059517812944,   -0.3239847771997537,    0.5794684678643381,   -0.3239847771997537),
+			new Grad4(-0.7504883828755602,   -0.4004672082940195,    0.5029860367700724,    0.15296486218853164),
+			new Grad4(-0.7504883828755602,    0.15296486218853164,   0.5029860367700724,   -0.4004672082940195),
+			new Grad4(-0.8828161875373585,    0.08164729285680945,   0.4553054119602712,    0.08164729285680945),
+			new Grad4(-0.4553054119602712,   -0.08164729285680945,   0.8828161875373585,   -0.08164729285680945),
+			new Grad4(-0.5029860367700724,   -0.15296486218853164,   0.7504883828755602,    0.4004672082940195),
+			new Grad4(-0.5029860367700724,    0.4004672082940195,    0.7504883828755602,   -0.15296486218853164),
+			new Grad4(-0.5794684678643381,    0.3239847771997537,    0.6740059517812944,    0.3239847771997537),
+			new Grad4(-0.3239847771997537,   -0.6740059517812944,    0.5794684678643381,   -0.3239847771997537),
+			new Grad4(-0.4004672082940195,   -0.7504883828755602,    0.5029860367700724,    0.15296486218853164),
+			new Grad4( 0.15296486218853164,  -0.7504883828755602,    0.5029860367700724,   -0.4004672082940195),
+			new Grad4( 0.08164729285680945,  -0.8828161875373585,    0.4553054119602712,    0.08164729285680945),
+			new Grad4(-0.08164729285680945,  -0.4553054119602712,    0.8828161875373585,   -0.08164729285680945),
+			new Grad4(-0.15296486218853164,  -0.5029860367700724,    0.7504883828755602,    0.4004672082940195),
+			new Grad4( 0.4004672082940195,   -0.5029860367700724,    0.7504883828755602,   -0.15296486218853164),
+			new Grad4( 0.3239847771997537,   -0.5794684678643381,    0.6740059517812944,    0.3239847771997537),
+			new Grad4(-0.3239847771997537,   -0.3239847771997537,    0.5794684678643381,   -0.6740059517812944),
+			new Grad4(-0.4004672082940195,    0.15296486218853164,   0.5029860367700724,   -0.7504883828755602),
+			new Grad4( 0.15296486218853164,  -0.4004672082940195,    0.5029860367700724,   -0.7504883828755602),
+			new Grad4( 0.08164729285680945,   0.08164729285680945,   0.4553054119602712,   -0.8828161875373585),
+			new Grad4(-0.08164729285680945,  -0.08164729285680945,   0.8828161875373585,   -0.4553054119602712),
+			new Grad4(-0.15296486218853164,   0.4004672082940195,    0.7504883828755602,   -0.5029860367700724),
+			new Grad4( 0.4004672082940195,   -0.15296486218853164,   0.7504883828755602,   -0.5029860367700724),
+			new Grad4( 0.3239847771997537,    0.3239847771997537,    0.6740059517812944,   -0.5794684678643381),
+			new Grad4(-0.6740059517812944,    0.5794684678643381,   -0.3239847771997537,   -0.3239847771997537),
+			new Grad4(-0.7504883828755602,    0.5029860367700724,   -0.4004672082940195,    0.15296486218853164),
+			new Grad4(-0.7504883828755602,    0.5029860367700724,    0.15296486218853164,  -0.4004672082940195),
+			new Grad4(-0.8828161875373585,    0.4553054119602712,    0.08164729285680945,   0.08164729285680945),
+			new Grad4(-0.4553054119602712,    0.8828161875373585,   -0.08164729285680945,  -0.08164729285680945),
+			new Grad4(-0.5029860367700724,    0.7504883828755602,   -0.15296486218853164,   0.4004672082940195),
+			new Grad4(-0.5029860367700724,    0.7504883828755602,    0.4004672082940195,   -0.15296486218853164),
+			new Grad4(-0.5794684678643381,    0.6740059517812944,    0.3239847771997537,    0.3239847771997537),
+			new Grad4(-0.3239847771997537,    0.5794684678643381,   -0.6740059517812944,   -0.3239847771997537),
+			new Grad4(-0.4004672082940195,    0.5029860367700724,   -0.7504883828755602,    0.15296486218853164),
+			new Grad4( 0.15296486218853164,   0.5029860367700724,   -0.7504883828755602,   -0.4004672082940195),
+			new Grad4( 0.08164729285680945,   0.4553054119602712,   -0.8828161875373585,    0.08164729285680945),
+			new Grad4(-0.08164729285680945,   0.8828161875373585,   -0.4553054119602712,   -0.08164729285680945),
+			new Grad4(-0.15296486218853164,   0.7504883828755602,   -0.5029860367700724,    0.4004672082940195),
+			new Grad4( 0.4004672082940195,    0.7504883828755602,   -0.5029860367700724,   -0.15296486218853164),
+			new Grad4( 0.3239847771997537,    0.6740059517812944,   -0.5794684678643381,    0.3239847771997537),
+			new Grad4(-0.3239847771997537,    0.5794684678643381,   -0.3239847771997537,   -0.6740059517812944),
+			new Grad4(-0.4004672082940195,    0.5029860367700724,    0.15296486218853164,  -0.7504883828755602),
+			new Grad4( 0.15296486218853164,   0.5029860367700724,   -0.4004672082940195,   -0.7504883828755602),
+			new Grad4( 0.08164729285680945,   0.4553054119602712,    0.08164729285680945,  -0.8828161875373585),
+			new Grad4(-0.08164729285680945,   0.8828161875373585,   -0.08164729285680945,  -0.4553054119602712),
+			new Grad4(-0.15296486218853164,   0.7504883828755602,    0.4004672082940195,   -0.5029860367700724),
+			new Grad4( 0.4004672082940195,    0.7504883828755602,   -0.15296486218853164,  -0.5029860367700724),
+			new Grad4( 0.3239847771997537,    0.6740059517812944,    0.3239847771997537,   -0.5794684678643381),
+			new Grad4( 0.5794684678643381,   -0.6740059517812944,   -0.3239847771997537,   -0.3239847771997537),
+			new Grad4( 0.5029860367700724,   -0.7504883828755602,   -0.4004672082940195,    0.15296486218853164),
+			new Grad4( 0.5029860367700724,   -0.7504883828755602,    0.15296486218853164,  -0.4004672082940195),
+			new Grad4( 0.4553054119602712,   -0.8828161875373585,    0.08164729285680945,   0.08164729285680945),
+			new Grad4( 0.8828161875373585,   -0.4553054119602712,   -0.08164729285680945,  -0.08164729285680945),
+			new Grad4( 0.7504883828755602,   -0.5029860367700724,   -0.15296486218853164,   0.4004672082940195),
+			new Grad4( 0.7504883828755602,   -0.5029860367700724,    0.4004672082940195,   -0.15296486218853164),
+			new Grad4( 0.6740059517812944,   -0.5794684678643381,    0.3239847771997537,    0.3239847771997537),
+			new Grad4( 0.5794684678643381,   -0.3239847771997537,   -0.6740059517812944,   -0.3239847771997537),
+			new Grad4( 0.5029860367700724,   -0.4004672082940195,   -0.7504883828755602,    0.15296486218853164),
+			new Grad4( 0.5029860367700724,    0.15296486218853164,  -0.7504883828755602,   -0.4004672082940195),
+			new Grad4( 0.4553054119602712,    0.08164729285680945,  -0.8828161875373585,    0.08164729285680945),
+			new Grad4( 0.8828161875373585,   -0.08164729285680945,  -0.4553054119602712,   -0.08164729285680945),
+			new Grad4( 0.7504883828755602,   -0.15296486218853164,  -0.5029860367700724,    0.4004672082940195),
+			new Grad4( 0.7504883828755602,    0.4004672082940195,   -0.5029860367700724,   -0.15296486218853164),
+			new Grad4( 0.6740059517812944,    0.3239847771997537,   -0.5794684678643381,    0.3239847771997537),
+			new Grad4( 0.5794684678643381,   -0.3239847771997537,   -0.3239847771997537,   -0.6740059517812944),
+			new Grad4( 0.5029860367700724,   -0.4004672082940195,    0.15296486218853164,  -0.7504883828755602),
+			new Grad4( 0.5029860367700724,    0.15296486218853164,  -0.4004672082940195,   -0.7504883828755602),
+			new Grad4( 0.4553054119602712,    0.08164729285680945,   0.08164729285680945,  -0.8828161875373585),
+			new Grad4( 0.8828161875373585,   -0.08164729285680945,  -0.08164729285680945,  -0.4553054119602712),
+			new Grad4( 0.7504883828755602,   -0.15296486218853164,   0.4004672082940195,   -0.5029860367700724),
+			new Grad4( 0.7504883828755602,    0.4004672082940195,   -0.15296486218853164,  -0.5029860367700724),
+			new Grad4( 0.6740059517812944,    0.3239847771997537,    0.3239847771997537,   -0.5794684678643381),
+			new Grad4( 0.03381941603233842,   0.03381941603233842,   0.03381941603233842,   0.9982828964265062),
+			new Grad4(-0.044802370851755174, -0.044802370851755174,  0.508629699630796,     0.8586508742123365),
+			new Grad4(-0.044802370851755174,  0.508629699630796,    -0.044802370851755174,  0.8586508742123365),
+			new Grad4(-0.12128480194602098,   0.4321472685365301,    0.4321472685365301,    0.7821684431180708),
+			new Grad4( 0.508629699630796,    -0.044802370851755174, -0.044802370851755174,  0.8586508742123365),
+			new Grad4( 0.4321472685365301,   -0.12128480194602098,   0.4321472685365301,    0.7821684431180708),
+			new Grad4( 0.4321472685365301,    0.4321472685365301,   -0.12128480194602098,   0.7821684431180708),
+			new Grad4( 0.37968289875261624,   0.37968289875261624,   0.37968289875261624,   0.753341017856078),
+			new Grad4( 0.03381941603233842,   0.03381941603233842,   0.9982828964265062,    0.03381941603233842),
+			new Grad4(-0.044802370851755174,  0.044802370851755174,  0.8586508742123365,    0.508629699630796),
+			new Grad4(-0.044802370851755174,  0.508629699630796,     0.8586508742123365,   -0.044802370851755174),
+			new Grad4(-0.12128480194602098,   0.4321472685365301,    0.7821684431180708,    0.4321472685365301),
+			new Grad4( 0.508629699630796,    -0.044802370851755174,  0.8586508742123365,   -0.044802370851755174),
+			new Grad4( 0.4321472685365301,   -0.12128480194602098,   0.7821684431180708,    0.4321472685365301),
+			new Grad4( 0.4321472685365301,    0.4321472685365301,    0.7821684431180708,   -0.12128480194602098),
+			new Grad4( 0.37968289875261624,   0.37968289875261624,   0.753341017856078,     0.37968289875261624),
+			new Grad4( 0.03381941603233842,   0.9982828964265062,    0.03381941603233842,   0.03381941603233842),
+			new Grad4(-0.044802370851755174,  0.8586508742123365,   -0.044802370851755174,  0.508629699630796),
+			new Grad4(-0.044802370851755174,  0.8586508742123365,    0.508629699630796,    -0.044802370851755174),
+			new Grad4(-0.12128480194602098,   0.7821684431180708,    0.4321472685365301,    0.4321472685365301),
+			new Grad4( 0.508629699630796,     0.8586508742123365,   -0.044802370851755174, -0.044802370851755174),
+			new Grad4( 0.4321472685365301,    0.7821684431180708,   -0.12128480194602098,   0.4321472685365301),
+			new Grad4( 0.4321472685365301,    0.7821684431180708,    0.4321472685365301,   -0.12128480194602098),
+			new Grad4( 0.37968289875261624,   0.753341017856078,     0.37968289875261624,   0.37968289875261624),
+			new Grad4( 0.9982828964265062,    0.03381941603233842,   0.03381941603233842,   0.03381941603233842),
+			new Grad4( 0.8586508742123365,   -0.044802370851755174, -0.044802370851755174,  0.508629699630796),
+			new Grad4( 0.8586508742123365,   -0.044802370851755174,  0.508629699630796,    -0.044802370851755174),
+			new Grad4( 0.7821684431180708,   -0.12128480194602098,   0.4321472685365301,    0.4321472685365301),
+			new Grad4( 0.8586508742123365,    0.508629699630796,    -0.044802370851755174, -0.044802370851755174),
+			new Grad4( 0.7821684431180708,    0.4321472685365301,   -0.12128480194602098,   0.4321472685365301),
+			new Grad4( 0.7821684431180708,    0.4321472685365301,    0.4321472685365301,   -0.12128480194602098),
+			new Grad4( 0.753341017856078,     0.37968289875261624,   0.37968289875261624,   0.37968289875261624)
+		};
+            for (Grad4 grad41 : grad4) {
+                grad41.dx /= N4;
+                grad41.dy /= N4;
+                grad41.dz /= N4;
+                grad41.dw /= N4;
+            }
+		for (int i = 0; i < PSIZE; i++) {
+			GRADIENTS_4D[i] = grad4[i % grad4.length];
+		}
+	}
+}