Shading: Extend Noise node to other dimenstions.

This patch extends perlin noise to operate in 1D, 2D, 3D, and 4D
space. The noise code has also been refactored to be more readable.

The Color output and distortion patterns changed, so this patch
breaks backward compatibility. This is due to the fact that we
now use random offsets as noise seeds, as opposed to swizzling
and constants offsets.

Reviewers: brecht, JacquesLucke

Differential Revision: https://developer.blender.org/D5560

3 files changed, 431 insertions, 52 deletions

diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_fractal_noise.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_fractal_noise.glsl
index 2a925c2a622..701b07b4aae 100644
--- a/source/blender/gpu/shaders/material/gpu_shader_material_fractal_noise.glsl
+++ b/source/blender/gpu/shaders/material/gpu_shader_material_fractal_noise.glsl
@@ -1,4 +1,89 @@
-float noise_turbulence(vec3 p, float octaves, int hard)
+/* The fractal_noise functions are all exactly the same except for the input type. */
+float fractal_noise(float p, float octaves)
+{
+  float fscale = 1.0;
+  float amp = 1.0;
+  float sum = 0.0;
+  octaves = clamp(octaves, 0.0, 16.0);
+  int n = int(octaves);
+  for (int i = 0; i <= n; i++) {
+    float t = noise(fscale * p);
+    sum += t * amp;
+    amp *= 0.5;
+    fscale *= 2.0;
+  }
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    float t = noise(fscale * p);
+    float sum2 = sum + t * amp;
+    sum *= (float(1 << n) / float((1 << (n + 1)) - 1));
+    sum2 *= (float(1 << (n + 1)) / float((1 << (n + 2)) - 1));
+    return (1.0 - rmd) * sum + rmd * sum2;
+  }
+  else {
+    sum *= (float(1 << n) / float((1 << (n + 1)) - 1));
+    return sum;
+  }
+}
+
+/* The fractal_noise functions are all exactly the same except for the input type. */
+float fractal_noise(vec2 p, float octaves)
+{
+  float fscale = 1.0;
+  float amp = 1.0;
+  float sum = 0.0;
+  octaves = clamp(octaves, 0.0, 16.0);
+  int n = int(octaves);
+  for (int i = 0; i <= n; i++) {
+    float t = noise(fscale * p);
+    sum += t * amp;
+    amp *= 0.5;
+    fscale *= 2.0;
+  }
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    float t = noise(fscale * p);
+    float sum2 = sum + t * amp;
+    sum *= (float(1 << n) / float((1 << (n + 1)) - 1));
+    sum2 *= (float(1 << (n + 1)) / float((1 << (n + 2)) - 1));
+    return (1.0 - rmd) * sum + rmd * sum2;
+  }
+  else {
+    sum *= (float(1 << n) / float((1 << (n + 1)) - 1));
+    return sum;
+  }
+}
+
+/* The fractal_noise functions are all exactly the same except for the input type. */
+float fractal_noise(vec3 p, float octaves)
+{
+  float fscale = 1.0;
+  float amp = 1.0;
+  float sum = 0.0;
+  octaves = clamp(octaves, 0.0, 16.0);
+  int n = int(octaves);
+  for (int i = 0; i <= n; i++) {
+    float t = noise(fscale * p);
+    sum += t * amp;
+    amp *= 0.5;
+    fscale *= 2.0;
+  }
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    float t = noise(fscale * p);
+    float sum2 = sum + t * amp;
+    sum *= (float(1 << n) / float((1 << (n + 1)) - 1));
+    sum2 *= (float(1 << (n + 1)) / float((1 << (n + 2)) - 1));
+    return (1.0 - rmd) * sum + rmd * sum2;
+  }
+  else {
+    sum *= (float(1 << n) / float((1 << (n + 1)) - 1));
+    return sum;
+  }
+}
+
+/* The fractal_noise functions are all exactly the same except for the input type. */
+float fractal_noise(vec4 p, float octaves)
 {
   float fscale = 1.0;
   float amp = 1.0;
@@ -7,9 +92,6 @@ float noise_turbulence(vec3 p, float octaves, int hard)
   int n = int(octaves);
   for (int i = 0; i <= n; i++) {
     float t = noise(fscale * p);
-    if (hard != 0) {
-      t = abs(2.0 * t - 1.0);
-    }
     sum += t * amp;
     amp *= 0.5;
     fscale *= 2.0;
@@ -17,9 +99,6 @@ float noise_turbulence(vec3 p, float octaves, int hard)
   float rmd = octaves - floor(octaves);
   if (rmd != 0.0) {
     float t = noise(fscale * p);
-    if (hard != 0) {
-      t = abs(2.0 * t - 1.0);
-    }
     float sum2 = sum + t * amp;
     sum *= (float(1 << n) / float((1 << (n + 1)) - 1));
     sum2 *= (float(1 << (n + 1)) / float((1 << (n + 2)) - 1));
diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_noise.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_noise.glsl
index 8c6a10e3fe7..c184c61c269 100644
--- a/source/blender/gpu/shaders/material/gpu_shader_material_noise.glsl
+++ b/source/blender/gpu/shaders/material/gpu_shader_material_noise.glsl
@@ -1,16 +1,106 @@
-float noise_fade(float t)
+/* Bilinear Interpolation:
+ *
+ * v2          v3
+ *  @ + + + + @       y
+ *  +         +       ^
+ *  +         +       |
+ *  +         +       |
+ *  @ + + + + @       @------> x
+ * v0          v1
+ *
+ */
+float bi_mix(float v0, float v1, float v2, float v3, float x, float y)
+{
+  float x1 = 1.0 - x;
+  return (1.0 - y) * (v0 * x1 + v1 * x) + y * (v2 * x1 + v3 * x);
+}
+
+/* Trilinear Interpolation:
+ *
+ *   v6               v7
+ *     @ + + + + + + @
+ *     +\            +\
+ *     + \           + \
+ *     +  \          +  \
+ *     +   \ v4      +   \ v5
+ *     +    @ + + + +++ + @          z
+ *     +    +        +    +      y   ^
+ *  v2 @ + +++ + + + @ v3 +       \  |
+ *      \   +         \   +        \ |
+ *       \  +          \  +         \|
+ *        \ +           \ +          +---------> x
+ *         \+            \+
+ *          @ + + + + + + @
+ *        v0               v1
+ */
+float tri_mix(float v0,
+              float v1,
+              float v2,
+              float v3,
+              float v4,
+              float v5,
+              float v6,
+              float v7,
+              float x,
+              float y,
+              float z)
+{
+  float x1 = 1.0 - x;
+  float y1 = 1.0 - y;
+  float z1 = 1.0 - z;
+  return z1 * (y1 * (v0 * x1 + v1 * x) + y * (v2 * x1 + v3 * x)) +
+         z * (y1 * (v4 * x1 + v5 * x) + y * (v6 * x1 + v7 * x));
+}
+
+float quad_mix(float v0,
+               float v1,
+               float v2,
+               float v3,
+               float v4,
+               float v5,
+               float v6,
+               float v7,
+               float v8,
+               float v9,
+               float v10,
+               float v11,
+               float v12,
+               float v13,
+               float v14,
+               float v15,
+               float x,
+               float y,
+               float z,
+               float w)
+{
+  return mix(tri_mix(v0, v1, v2, v3, v4, v5, v6, v7, x, y, z),
+             tri_mix(v8, v9, v10, v11, v12, v13, v14, v15, x, y, z),
+             w);
+}
+
+float fade(float t)
 {
   return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
 }
 
-float noise_scale3(float result)
+float negate_if(float value, uint condition)
 {
-  return 0.9820 * result;
+  return (condition != 0u) ? -value : value;
 }
 
-float noise_nerp(float t, float a, float b)
+float noise_grad(uint hash, float x)
 {
-  return (1.0 - t) * a + t * b;
+  uint h = hash & 15u;
+  float g = 1u + (h & 7u);
+  return negate_if(g, h & 8u) * x;
+}
+
+float noise_grad(uint hash, float x, float y)
+{
+  uint h = hash & 7u;
+  float u = h < 4u ? x : y;
+  float v = 2.0 * (h < 4u ? y : x);
+  return negate_if(u, h & 1u) + negate_if(v, h & 2u);
 }
 
 float noise_grad(uint hash, float x, float y, float z)
@@ -19,56 +109,186 @@ float noise_grad(uint hash, float x, float y, float z)
   float u = h < 8u ? x : y;
   float vt = ((h == 12u) || (h == 14u)) ? x : z;
   float v = h < 4u ? y : vt;
-  return (((h & 1u) != 0u) ? -u : u) + (((h & 2u) != 0u) ? -v : v);
+  return negate_if(u, h & 1u) + negate_if(v, h & 2u);
+}
+
+float noise_grad(uint hash, float x, float y, float z, float w)
+{
+  uint h = hash & 31u;
+  float u = h < 24u ? x : y;
+  float v = h < 16u ? y : z;
+  float s = h < 8u ? z : w;
+  return negate_if(u, h & 1u) + negate_if(v, h & 2u) + negate_if(s, h & 4u);
 }
 
-float noise_perlin(float x, float y, float z)
+float noise_perlin(float x)
 {
   int X;
   float fx = floorfrac(x, X);
+  float u = fade(fx);
+
+  float r = mix(noise_grad(hash_int(X), fx), noise_grad(hash_int(X + 1), fx - 1.0), u);
+
+  return r;
+}
+
+float noise_perlin(vec2 vec)
+{
+  int X;
+  int Y;
+
+  float fx = floorfrac(vec.x, X);
+  float fy = floorfrac(vec.y, Y);
+
+  float u = fade(fx);
+  float v = fade(fy);
+
+  float r = bi_mix(noise_grad(hash_int2(X, Y), fx, fy),
+                   noise_grad(hash_int2(X + 1, Y), fx - 1.0, fy),
+                   noise_grad(hash_int2(X, Y + 1), fx, fy - 1.0),
+                   noise_grad(hash_int2(X + 1, Y + 1), fx - 1.0, fy - 1.0),
+                   u,
+                   v);
+
+  return r;
+}
+
+float noise_perlin(vec3 vec)
+{
+  int X;
   int Y;
-  float fy = floorfrac(y, Y);
   int Z;
-  float fz = floorfrac(z, Z);
 
-  float u = noise_fade(fx);
-  float v = noise_fade(fy);
-  float w = noise_fade(fz);
+  float fx = floorfrac(vec.x, X);
+  float fy = floorfrac(vec.y, Y);
+  float fz = floorfrac(vec.z, Z);
+
+  float u = fade(fx);
+  float v = fade(fy);
+  float w = fade(fz);
 
-  float noise_u[2], noise_v[2];
+  float r = tri_mix(noise_grad(hash_int3(X, Y, Z), fx, fy, fz),
+                    noise_grad(hash_int3(X + 1, Y, Z), fx - 1, fy, fz),
+                    noise_grad(hash_int3(X, Y + 1, Z), fx, fy - 1, fz),
+                    noise_grad(hash_int3(X + 1, Y + 1, Z), fx - 1, fy - 1, fz),
+                    noise_grad(hash_int3(X, Y, Z + 1), fx, fy, fz - 1),
+                    noise_grad(hash_int3(X + 1, Y, Z + 1), fx - 1, fy, fz - 1),
+                    noise_grad(hash_int3(X, Y + 1, Z + 1), fx, fy - 1, fz - 1),
+                    noise_grad(hash_int3(X + 1, Y + 1, Z + 1), fx - 1, fy - 1, fz - 1),
+                    u,
+                    v,
+                    w);
 
-  noise_u[0] = noise_nerp(u,
-                          noise_grad(hash_int3(X, Y, Z), fx, fy, fz),
-                          noise_grad(hash_int3(X + 1, Y, Z), fx - 1.0, fy, fz));
+  return r;
+}
 
-  noise_u[1] = noise_nerp(u,
-                          noise_grad(hash_int3(X, Y + 1, Z), fx, fy - 1.0, fz),
-                          noise_grad(hash_int3(X + 1, Y + 1, Z), fx - 1.0, fy - 1.0, fz));
+float noise_perlin(vec4 vec)
+{
+  int X;
+  int Y;
+  int Z;
+  int W;
 
-  noise_v[0] = noise_nerp(v, noise_u[0], noise_u[1]);
+  float fx = floorfrac(vec.x, X);
+  float fy = floorfrac(vec.y, Y);
+  float fz = floorfrac(vec.z, Z);
+  float fw = floorfrac(vec.w, W);
 
-  noise_u[0] = noise_nerp(u,
-                          noise_grad(hash_int3(X, Y, Z + 1), fx, fy, fz - 1.0),
-                          noise_grad(hash_int3(X + 1, Y, Z + 1), fx - 1.0, fy, fz - 1.0));
+  float u = fade(fx);
+  float v = fade(fy);
+  float t = fade(fz);
+  float s = fade(fw);
 
-  noise_u[1] = noise_nerp(
+  float r = quad_mix(
+      noise_grad(hash_int4(X, Y, Z, W), fx, fy, fz, fw),
+      noise_grad(hash_int4(X + 1, Y, Z, W), fx - 1.0, fy, fz, fw),
+      noise_grad(hash_int4(X, Y + 1, Z, W), fx, fy - 1.0, fz, fw),
+      noise_grad(hash_int4(X + 1, Y + 1, Z, W), fx - 1.0, fy - 1.0, fz, fw),
+      noise_grad(hash_int4(X, Y, Z + 1, W), fx, fy, fz - 1.0, fw),
+      noise_grad(hash_int4(X + 1, Y, Z + 1, W), fx - 1.0, fy, fz - 1.0, fw),
+      noise_grad(hash_int4(X, Y + 1, Z + 1, W), fx, fy - 1.0, fz - 1.0, fw),
+      noise_grad(hash_int4(X + 1, Y + 1, Z + 1, W), fx - 1.0, fy - 1.0, fz - 1.0, fw),
+      noise_grad(hash_int4(X, Y, Z, W + 1), fx, fy, fz, fw - 1.0),
+      noise_grad(hash_int4(X + 1, Y, Z, W + 1), fx - 1.0, fy, fz, fw - 1.0),
+      noise_grad(hash_int4(X, Y + 1, Z, W + 1), fx, fy - 1.0, fz, fw - 1.0),
+      noise_grad(hash_int4(X + 1, Y + 1, Z, W + 1), fx - 1.0, fy - 1.0, fz, fw - 1.0),
+      noise_grad(hash_int4(X, Y, Z + 1, W + 1), fx, fy, fz - 1.0, fw - 1.0),
+      noise_grad(hash_int4(X + 1, Y, Z + 1, W + 1), fx - 1.0, fy, fz - 1.0, fw - 1.0),
+      noise_grad(hash_int4(X, Y + 1, Z + 1, W + 1), fx, fy - 1.0, fz - 1.0, fw - 1.0),
+      noise_grad(hash_int4(X + 1, Y + 1, Z + 1, W + 1), fx - 1.0, fy - 1.0, fz - 1.0, fw - 1.0),
       u,
-      noise_grad(hash_int3(X, Y + 1, Z + 1), fx, fy - 1.0, fz - 1.0),
-      noise_grad(hash_int3(X + 1, Y + 1, Z + 1), fx - 1.0, fy - 1.0, fz - 1.0));
+      v,
+      t,
+      s);
 
-  noise_v[1] = noise_nerp(v, noise_u[0], noise_u[1]);
+  return r;
+}
 
-  float r = noise_scale3(noise_nerp(w, noise_v[0], noise_v[1]));
+/* Remap the output of noise to a predictable range [-1, 1].
+ * The scale values were computed experimentally by the OSL developers.
+ */
+float noise_scale1(float result)
+{
+  return 0.2500 * result;
+}
 
-  return (isinf(r)) ? 0.0 : r;
+float noise_scale2(float result)
+{
+  return 0.6616 * result;
 }
 
-float noise(vec3 p)
+float noise_scale3(float result)
+{
+  return 0.9820 * result;
+}
+
+float noise_scale4(float result)
+{
+  return 0.8344 * result;
+}
+
+/* Safe Signed And Unsigned Noise */
+
+float snoise(float p)
+{
+  float r = noise_perlin(p);
+  return (isinf(r)) ? 0.0 : noise_scale1(r);
+}
+
+float noise(float p)
+{
+  return 0.5 * snoise(p) + 0.5;
+}
+
+float snoise(vec2 p)
 {
-  return 0.5 * noise_perlin(p.x, p.y, p.z) + 0.5;
+  float r = noise_perlin(p);
+  return (isinf(r)) ? 0.0 : noise_scale2(r);
+}
+
+float noise(vec2 p)
+{
+  return 0.5 * snoise(p) + 0.5;
 }
 
 float snoise(vec3 p)
 {
-  return noise_perlin(p.x, p.y, p.z);
+  float r = noise_perlin(p);
+  return (isinf(r)) ? 0.0 : noise_scale3(r);
+}
+
+float noise(vec3 p)
+{
+  return 0.5 * snoise(p) + 0.5;
+}
+
+float snoise(vec4 p)
+{
+  float r = noise_perlin(p);
+  return (isinf(r)) ? 0.0 : noise_scale4(r);
+}
+
+float noise(vec4 p)
+{
+  return 0.5 * snoise(p) + 0.5;
 }
diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_tex_noise.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_tex_noise.glsl
index 30e27da16e8..e56b4a1d135 100644
--- a/source/blender/gpu/shaders/material/gpu_shader_material_tex_noise.glsl
+++ b/source/blender/gpu/shaders/material/gpu_shader_material_tex_noise.glsl
@@ -1,19 +1,99 @@
-void node_tex_noise(
-    vec3 co, float scale, float detail, float distortion, out vec4 color, out float fac)
+/* The following offset functions generate random offsets to be added to texture
+ * coordinates to act as a seed since the noise functions don't have seed values.
+ * A seed value is needed for generating distortion textures and color outputs.
+ * The offset's components are in the range [100, 200], not too high to cause
+ * bad precision and not to small to be noticeable. We use float seed because
+ * OSL only support float hashes.
+ */
+
+float random_float_offset(float seed)
+{
+  return 100.0 + hash_float_to_float(seed) * 100.0;
+}
+
+vec2 random_vec2_offset(float seed)
+{
+  return vec2(100.0 + hash_vec2_to_float(vec2(seed, 0.0)) * 100.0,
+              100.0 + hash_vec2_to_float(vec2(seed, 1.0)) * 100.0);
+}
+
+vec3 random_vec3_offset(float seed)
+{
+  return vec3(100.0 + hash_vec2_to_float(vec2(seed, 0.0)) * 100.0,
+              100.0 + hash_vec2_to_float(vec2(seed, 1.0)) * 100.0,
+              100.0 + hash_vec2_to_float(vec2(seed, 2.0)) * 100.0);
+}
+
+vec4 random_vec4_offset(float seed)
+{
+  return vec4(100.0 + hash_vec2_to_float(vec2(seed, 0.0)) * 100.0,
+              100.0 + hash_vec2_to_float(vec2(seed, 1.0)) * 100.0,
+              100.0 + hash_vec2_to_float(vec2(seed, 2.0)) * 100.0,
+              100.0 + hash_vec2_to_float(vec2(seed, 3.0)) * 100.0);
+}
+
+void node_noise_texture_1d(
+    vec3 co, float w, float scale, float detail, float distortion, out float value, out vec4 color)
+{
+  float p = w * scale;
+  if (distortion != 0.0) {
+    p += noise(p + random_float_offset(0.0)) * distortion;
+  }
+
+  value = fractal_noise(p, detail);
+  color = vec4(value,
+               fractal_noise(p + random_float_offset(1.0), detail),
+               fractal_noise(p + random_float_offset(2.0), detail),
+               1.0);
+}
+
+void node_noise_texture_2d(
+    vec3 co, float w, float scale, float detail, float distortion, out float value, out vec4 color)
+{
+  vec2 p = co.xy * scale;
+  if (distortion != 0.0) {
+    p += vec2(noise(p + random_vec2_offset(0.0)) * distortion,
+              noise(p + random_vec2_offset(1.0)) * distortion);
+  }
+
+  value = fractal_noise(p, detail);
+  color = vec4(value,
+               fractal_noise(p + random_vec2_offset(2.0), detail),
+               fractal_noise(p + random_vec2_offset(3.0), detail),
+               1.0);
+}
+
+void node_noise_texture_3d(
+    vec3 co, float w, float scale, float detail, float distortion, out float value, out vec4 color)
 {
   vec3 p = co * scale;
-  int hard = 0;
   if (distortion != 0.0) {
-    vec3 r, offset = vec3(13.5, 13.5, 13.5);
-    r.x = noise(p + offset) * distortion;
-    r.y = noise(p) * distortion;
-    r.z = noise(p - offset) * distortion;
-    p += r;
+    p += vec3(noise(p + random_vec3_offset(0.0)) * distortion,
+              noise(p + random_vec3_offset(1.0)) * distortion,
+              noise(p + random_vec3_offset(2.0)) * distortion);
+  }
+
+  value = fractal_noise(p, detail);
+  color = vec4(value,
+               fractal_noise(p + random_vec3_offset(3.0), detail),
+               fractal_noise(p + random_vec3_offset(4.0), detail),
+               1.0);
+}
+
+void node_noise_texture_4d(
+    vec3 co, float w, float scale, float detail, float distortion, out float value, out vec4 color)
+{
+  vec4 p = vec4(co, w) * scale;
+  if (distortion != 0.0) {
+    p += vec4(noise(p + random_vec4_offset(0.0)) * distortion,
+              noise(p + random_vec4_offset(1.0)) * distortion,
+              noise(p + random_vec4_offset(2.0)) * distortion,
+              noise(p + random_vec4_offset(3.0)) * distortion);
   }
 
-  fac = noise_turbulence(p, detail, hard);
-  color = vec4(fac,
-               noise_turbulence(vec3(p.y, p.x, p.z), detail, hard),
-               noise_turbulence(vec3(p.y, p.z, p.x), detail, hard),
-               1);
+  value = fractal_noise(p, detail);
+  color = vec4(value,
+               fractal_noise(p + random_vec4_offset(4.0), detail),
+               fractal_noise(p + random_vec4_offset(5.0), detail),
+               1.0);
 }