🔧 Use different noise implementation

src/extension/FireShader.js

@@ -49,7 +49,7 @@ var FireShader = GObject.registerClass({Properties: {}, Signals: {}},
       ${shaderSnippets.noise()}
 
       // These may be configurable in the future.
-      const float EDGE_FADE  = 70;
+      const float EDGE_FADE  = 90;
       const float FADE_WIDTH = 0.1;
       const float HIDE_TIME  = 0.4;
       const vec2  FIRE_SCALE = vec2(400, 600) * ${settings.get_double('flame-scale')};
@@ -124,7 +124,8 @@ var FireShader = GObject.registerClass({Properties: {}, Signals: {}},
         // Get a noise value which moves vertically in time.
         vec2 uv = cogl_tex_coord_in[0].st * vec2(uSizeX, uSizeY) / FIRE_SCALE;
         uv.y += uTime * FIRE_SPEED;
-        float noise = noise(uv * 5.0);
+        float noise = noise2D(uv * 7.5, 5);
+        //  float noise = noise3D(vec3(uv*7.5, uTime*FIRE_SPEED*4.0), 5);
 
         // Modulate noise by effect mask.
         vec2 effectMask = effectMask(HIDE_TIME, FADE_WIDTH, EDGE_FADE);

src/extension/MatrixShader.js

@@ -74,7 +74,7 @@ var MatrixShader = GObject.registerClass({Properties: {}, Signals: {}},
         vec2 block = pixelCoords/LETTER_SIZE - uv;
 
         // Choose random letter.
-        uv += floor(rand(floor(rand(block)*vec2(12.9898,78.233) + LETTER_FLICKER_SPEED*uTime + 42.254))*LETTER_TILES);
+        uv += floor(hash2D(floor(hash2D(block)*vec2(12.9898,78.233) + LETTER_FLICKER_SPEED*uTime + 42.254))*LETTER_TILES);
         
         return texture2D(uFontTexture, uv/LETTER_TILES).r;
       }

src/extension/TRexShader.js

@@ -65,7 +65,7 @@ var TRexShader = GObject.registerClass({Properties: {}, Signals: {}},
       vec2 getClawUV(vec2 texCoords, float gridScale, vec2 seed) {
 
         // Shift coordinates by a random offset and make sure the have a 1:1 aspect ratio.
-        vec2 coords = texCoords + rand(seed);
+        vec2 coords = texCoords + hash2D(seed);
         coords *= uSizeX < uSizeY ? vec2(1.0, 1.0 * uSizeY / uSizeX) : vec2(1.0 * uSizeX / uSizeY, 1.0);
         
         // Apply global scale.
@@ -78,10 +78,10 @@ var TRexShader = GObject.registerClass({Properties: {}, Signals: {}},
         vec2 cellID = coords-cellUV + vec2(362.456);
 
         // Add random rotation, scale and offset to each grid cell.
-        float scale    = mix(0.8, 1.0,         rand(cellID*seed*134.451).x);
+        float scale    = mix(0.8, 1.0,         hash(cellID*seed*134.451));
-        float offsetX  = mix(0.0, 1.0 - scale, rand(cellID*seed*54.4129).x);
+        float offsetX  = mix(0.0, 1.0 - scale, hash(cellID*seed*54.4129));
-        float offsetY  = mix(0.0, 1.0 - scale, rand(cellID*seed*25.3089).x);
+        float offsetY  = mix(0.0, 1.0 - scale, hash(cellID*seed*25.3089));
-        float rotation = mix(0.0, 2.0 * 3.141, rand(cellID*seed*2.99837).x);
+        float rotation = mix(0.0, 2.0 * 3.141, hash(cellID*seed*2.99837));
         
         cellUV -= vec2(offsetX, offsetY);
         cellUV /= scale;

src/extension/shaderSnippets.js

@@ -33,40 +33,92 @@ function standardUniforms() {
   `;
 }
 
-// This simplex noise algorithm is based on an implementation by Inigo Quilez which is
+// These noise algorithms are based on implementations by Inigo Quilez which are
-// available under the MIT License (Copyright © 2013 Inigo Quilez).
+// available under the MIT License.
-// https://www.shadertoy.com/view/Msf3WH.
+// https://www.shadertoy.com/view/lsf3WH
+// https://www.shadertoy.com/view/4sfGzS
+// https://www.shadertoy.com/view/Xsl3Dl
+// https://www.shadertoy.com/view/Msf3WH
 function noise() {
   return `
-  vec2 rand(vec2 p) { 
+
-    p = vec2(dot(p,vec2(127.1,311.7)), dot(p,vec2(269.5,183.3)));
+  vec2 hash2D(vec2 p) {
-    return fract(sin(p)*43758.5453123);
+    p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));
+    return fract(sin(p) * 43758.5453123);
   }
 
-  float noiseImpl(vec2 p) {
+  vec3 hash3D(vec3 p) {
-    const float K1 = 0.366025404; // (sqrt(3)-1)/2;
+    p = vec3(dot(p, vec3(127.1, 311.7,  74.7)),
-    const float K2 = 0.211324865; // (3-sqrt(3))/6;
+             dot(p, vec3(269.5, 183.3, 246.1)),
+             dot(p, vec3(113.5, 271.9, 124.6)));
+
+    return fract(sin(p) * 43758.5453123);
+  }
+
+  float hash(vec2 p) {
+    p = floor(p);
+    p = 50.0 * fract(p * 0.3183099 + vec2(0.71, 0.113));
+    return fract(p.x * p.y * (p.x + p.y));
+  }
+
+  float hash(vec3 p) {
+    p = fract(p * 0.3183099 + 0.1) * 17.0;
+    return fract(p.x * p.y * p.z * (p.x + p.y + p.z));
+  }
+
+  float noise2D(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+  
+    vec2 u = f * f * (3.0 - 2.0 * f);
+
+    return mix(mix(hash(i + vec2(0.0, 0.0)),
+                   hash(i + vec2(1.0, 0.0)), u.x),
+               mix(hash(i + vec2(0.0, 1.0)),
+                   hash(i + vec2(1.0, 1.0)), u.x), u.y);
+  }
+
+  float noise3D(vec3 p) {
+    vec3 i = floor(p);
+    vec3 f = fract(p);
+
+    f = f * f * (3.0 - 2.0 * f);
+	
+    return mix(mix(mix(hash(i+vec3(0, 0 ,0)),
+                       hash(i+vec3(1, 0 ,0)), f.x),
+                   mix(hash(i+vec3(0, 1 ,0)),
+                       hash(i+vec3(1, 1 ,0)), f.x), f.y),
+               mix(mix(hash(i+vec3(0, 0 ,1)),
+                       hash(i+vec3(1, 0 ,1)), f.x),
+                   mix(hash(i+vec3(0, 1 ,1)),
+                       hash(i+vec3(1, 1 ,1)), f.x),f.y), f.z);
+  }
+
+  float noise2D(vec2 p, int octaves) {
+    mat2 m = mat2( 1.6, 1.2,
+                  -1.2, 1.6);
+
+    float f  = 0;
     
-    vec2  i = floor(p + (p.x + p.y) * K1);
+    for (int i=1; i<=octaves; ++i) {
-    vec2  a = p - i + (i.x + i.y) * K2;
+      f += noise2D(p) / pow(2, i);
-    float m = step(a.y, a.x); 
+      p = m * p;
-    vec2  o = vec2(m, 1.0-m);
+    }
-    vec2  b = a - o + K2;
+  
-    vec2  c = a - 1.0 + 2.0*K2;
+    return f;
-    vec3  h = max(0.5 - vec3(dot(a, a), dot(b, b), dot(c, c)), 0.0);
-    vec3  n = h * h * h * h * vec3(dot(a, -1.0 + 2.0 * rand(i + 0.0)),
-                                   dot(b, -1.0 + 2.0 * rand(i + o)),
-                                   dot(c, -1.0 + 2.0 * rand(i + 1.0)));
-    return dot(n, vec3(70.0)) * 0.5 + 0.5;
   }
 
-  float noise(vec2 p) {
+  float noise3D(vec3 p, int octaves) {
-    mat2 m = mat2(1.6, 1.2, -1.2, 1.6);
+    const mat3 m = mat3( 0.00,  0.80,  0.60,
-    float f = 0.5000 * noiseImpl(p); p = m*p;
+                        -0.80,  0.36, -0.48,
-    f      += 0.2500 * noiseImpl(p); p = m*p;
+                        -0.60, -0.48,  0.64);
-    f      += 0.1250 * noiseImpl(p); p = m*p;
+    float f  = 0;
-    f      += 0.0625 * noiseImpl(p); p = m*p;
+    
-
+    for (int i=1; i<=octaves; ++i) {
+      f += noise3D(p) / pow(2, i);
+      p = m * p * 2.01;
+    }
+  
     return f;
   }
   `;