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

4 files changed, 139 insertions, 5 deletions

diff --git a/intern/cycles/util/util_hash.h b/intern/cycles/util/util_hash.h
index 2b1f26de03d..53140e40fc9 100644
--- a/intern/cycles/util/util_hash.h
+++ b/intern/cycles/util/util_hash.h
@@ -213,6 +213,109 @@ ccl_device_inline float3 hash_float4_to_float3(float4 k)
                      hash_float4_to_float(make_float4(k.w, k.z, k.y, k.x)));
 }
 
+/* SSE Versions Of Jenkins Lookup3 Hash Functions */
+
+#ifdef __KERNEL_SSE2__
+#  define rot(x, k) (((x) << (k)) | (srl(x, 32 - (k))))
+
+#  define mix(a, b, c) \
+    { \
+      a -= c; \
+      a ^= rot(c, 4); \
+      c += b; \
+      b -= a; \
+      b ^= rot(a, 6); \
+      a += c; \
+      c -= b; \
+      c ^= rot(b, 8); \
+      b += a; \
+      a -= c; \
+      a ^= rot(c, 16); \
+      c += b; \
+      b -= a; \
+      b ^= rot(a, 19); \
+      a += c; \
+      c -= b; \
+      c ^= rot(b, 4); \
+      b += a; \
+    }
+
+#  define final(a, b, c) \
+    { \
+      c ^= b; \
+      c -= rot(b, 14); \
+      a ^= c; \
+      a -= rot(c, 11); \
+      b ^= a; \
+      b -= rot(a, 25); \
+      c ^= b; \
+      c -= rot(b, 16); \
+      a ^= c; \
+      a -= rot(c, 4); \
+      b ^= a; \
+      b -= rot(a, 14); \
+      c ^= b; \
+      c -= rot(b, 24); \
+    }
+
+ccl_device_inline ssei hash_ssei(ssei kx)
+{
+  ssei a, b, c;
+  a = b = c = ssei(0xdeadbeef + (1 << 2) + 13);
+
+  a += kx;
+  final(a, b, c);
+
+  return c;
+}
+
+ccl_device_inline ssei hash_ssei2(ssei kx, ssei ky)
+{
+  ssei a, b, c;
+  a = b = c = ssei(0xdeadbeef + (2 << 2) + 13);
+
+  b += ky;
+  a += kx;
+  final(a, b, c);
+
+  return c;
+}
+
+ccl_device_inline ssei hash_ssei3(ssei kx, ssei ky, ssei kz)
+{
+  ssei a, b, c;
+  a = b = c = ssei(0xdeadbeef + (3 << 2) + 13);
+
+  c += kz;
+  b += ky;
+  a += kx;
+  final(a, b, c);
+
+  return c;
+}
+
+ccl_device_inline ssei hash_ssei4(ssei kx, ssei ky, ssei kz, ssei kw)
+{
+  ssei a, b, c;
+  a = b = c = ssei(0xdeadbeef + (4 << 2) + 13);
+
+  a += kx;
+  b += ky;
+  c += kz;
+  mix(a, b, c);
+
+  a += kw;
+  final(a, b, c);
+
+  return c;
+}
+
+#  undef rot
+#  undef final
+#  undef mix
+
+#endif
+
 #ifndef __KERNEL_GPU__
 static inline uint hash_string(const char *str)
 {
diff --git a/intern/cycles/util/util_math.h b/intern/cycles/util/util_math.h
index ebddd56bd40..17bb766445d 100644
--- a/intern/cycles/util/util_math.h
+++ b/intern/cycles/util/util_math.h
@@ -318,6 +318,12 @@ ccl_device_inline int quick_floor_to_int(float x)
   return float_to_int(x) - ((x < 0) ? 1 : 0);
 }
 
+ccl_device_inline float floorfrac(float x, int *i)
+{
+  *i = quick_floor_to_int(x);
+  return x - *i;
+}
+
 ccl_device_inline int ceil_to_int(float f)
 {
   return float_to_int(ceilf(f));
diff --git a/intern/cycles/util/util_ssef.h b/intern/cycles/util/util_ssef.h
index e6610dbb197..fa525daf37c 100644
--- a/intern/cycles/util/util_ssef.h
+++ b/intern/cycles/util/util_ssef.h
@@ -523,13 +523,29 @@ __forceinline ssei truncatei(const ssef &a)
   return _mm_cvttps_epi32(a.m128);
 }
 
+/* This is about 25% faster than straightforward floor to integer conversion
+ * due to better pipelining.
+ *
+ * Unsaturated add 0xffffffff (a < 0) is the same as subtract -1.
+ */
 __forceinline ssei floori(const ssef &a)
 {
-#  if defined(__KERNEL_SSE41__)
-  return ssei(floor(a));
-#  else
-  return ssei(a - ssef(0.5f));
-#  endif
+  return truncatei(a) + cast((a < 0.0f).m128);
+}
+
+__forceinline ssef floorfrac(const ssef &x, ssei *i)
+{
+  *i = floori(x);
+  return x - ssef(*i);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Common Functions
+////////////////////////////////////////////////////////////////////////////////
+
+__forceinline ssef mix(const ssef &a, const ssef &b, const ssef &t)
+{
+  return madd(t, b, (ssef(1.0f) - t) * a);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/intern/cycles/util/util_ssei.h b/intern/cycles/util/util_ssei.h
index 86429260a0e..e2bf81310cc 100644
--- a/intern/cycles/util/util_ssei.h
+++ b/intern/cycles/util/util_ssei.h
@@ -310,6 +310,15 @@ __forceinline ssei &operator|=(ssei &a, const int32_t &b)
   return a = a | b;
 }
 
+__forceinline ssei &operator^=(ssei &a, const ssei &b)
+{
+  return a = a ^ b;
+}
+__forceinline ssei &operator^=(ssei &a, const int32_t &b)
+{
+  return a = a ^ b;
+}
+
 __forceinline ssei &operator<<=(ssei &a, const int32_t &b)
 {
   return a = a << b;