Swapped noise function to simplex noise

src/shaders/noise.cs.glsl

@@ -2,13 +2,13 @@
 uniform int dim;
 uniform float scale;
 
-uniform int octaves = 4;
+uniform int octaves = 10;
 uniform float persistance = 0.5;
 uniform float lacunarity = 2;
 
 uniform int seed;
 
-layout(local_size_x = 4, local_size_y = 4) in;
+layout(local_size_x = 8, local_size_y = 8) in;
 
 layout(std430, binding = 0) buffer noise_map {
     float map[];
@@ -19,53 +19,78 @@ layout(std430, binding = 1) buffer Height_Data {
     int max_height;
 } height_data;
 
-float mod289(float x) {
+int half_dim = dim / 2;
+
+//
+// Description : Array and textureless GLSL 2D simplex noise function.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : stegu
+//     Lastmod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//               https://github.com/stegu/webgl-noise
+//
+
+vec3 mod289(vec3 x) {
     return x - floor(x * (1.0 / 289.0)) * 289.0;
 }
-vec4 mod289(vec4 x) {
+
+vec2 mod289(vec2 x) {
     return x - floor(x * (1.0 / 289.0)) * 289.0;
 }
-vec4 permute(vec4 x) {
-    return mod289(((x * 34.0) + 1.0) * x);
-}
-//	Classic Perlin 2D Noise
-//	by Stefan Gustavson
-//
-vec2 fade(vec2 t) {
-    return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
+
+vec3 permute(vec3 x) {
+    return mod289(((x * 34.0) + 10.0) * x);
 }
 
-float noise(vec2 P) {
-    vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
-    vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
-    Pi = mod(Pi, 289.0); // To avoid truncation effects in permutation
-    vec4 ix = Pi.xzxz;
-    vec4 iy = Pi.yyww;
-    vec4 fx = Pf.xzxz;
-    vec4 fy = Pf.yyww;
-    vec4 i = permute(permute(ix) + iy);
-    vec4 gx = 2.0 * fract(i * 0.0243902439) - 1.0; // 1/41 = 0.024...
-    vec4 gy = abs(gx) - 0.5;
-    vec4 tx = floor(gx + 0.5);
-    gx = gx - tx;
-    vec2 g00 = vec2(gx.x, gy.x);
-    vec2 g10 = vec2(gx.y, gy.y);
-    vec2 g01 = vec2(gx.z, gy.z);
-    vec2 g11 = vec2(gx.w, gy.w);
-    vec4 norm = 1.79284291400159 - 0.85373472095314 *
-                vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11));
-    g00 *= norm.x;
-    g01 *= norm.y;
-    g10 *= norm.z;
-    g11 *= norm.w;
-    float n00 = dot(g00, vec2(fx.x, fy.x));
-    float n10 = dot(g10, vec2(fx.y, fy.y));
-    float n01 = dot(g01, vec2(fx.z, fy.z));
-    float n11 = dot(g11, vec2(fx.w, fy.w));
-    vec2 fade_xy = fade(Pf.xy);
-    vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
-    float n_xy = mix(n_x.x, n_x.y, fade_xy.y);
-    return 2.3 * n_xy;
+float noise(vec2 v)
+{
+    const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
+            0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
+            -0.577350269189626, // -1.0 + 2.0 * C.x
+            0.024390243902439); // 1.0 / 41.0
+    // First corner
+    vec2 i = floor(v + dot(v, C.yy));
+    vec2 x0 = v - i + dot(i, C.xx);
+
+    // Other corners
+    vec2 i1;
+    //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+    //i1.y = 1.0 - i1.x;
+    i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+    // x0 = x0 - 0.0 + 0.0 * C.xx ;
+    // x1 = x0 - i1 + 1.0 * C.xx ;
+    // x2 = x0 - 1.0 + 2.0 * C.xx ;
+    vec4 x12 = x0.xyxy + C.xxzz;
+    x12.xy -= i1;
+
+    // Permutations
+    i = mod289(i); // Avoid truncation effects in permutation
+    vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))
+                + i.x + vec3(0.0, i1.x, 1.0));
+
+    vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
+    m = m * m;
+    m = m * m;
+
+    // Gradients: 41 points uniformly over a line, mapped onto a diamond.
+    // The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+    vec3 x = 2.0 * fract(p * C.www) - 1.0;
+    vec3 h = abs(x) - 0.5;
+    vec3 ox = floor(x + 0.5);
+    vec3 a0 = x - ox;
+
+    // Normalise gradients implicitly by scaling m
+    // Approximation of: m *= inversesqrt( a0*a0 + h*h );
+    m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
+
+    // Compute final noise value at P
+    vec3 g;
+    g.x = a0.x * x0.x + h.x * x0.y;
+    g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+    return 130.0 * dot(m, g);
 }
 
 void main() {
@@ -77,7 +102,7 @@ void main() {
     float height = 0;
 
     for (int i = 0; i < octaves; i++) {
-        vec2 sample_coords = vec2(float(noise_coord.x) / scale * frequency + seed, float(noise_coord.y) / scale * frequency + seed);
+        vec2 sample_coords = vec2(float(noise_coord.x - half_dim) / scale * frequency + seed, float(noise_coord.y - half_dim) / scale * frequency + seed);
         float noise_value = noise(sample_coords);
         height += noise_value * amplitude;