Shading: Add More Features To The Voronoi Node.

This patch allows the Voronoi node to operate in 1D, 2D, and 4D space.
It also adds a Randomness input to control the randomness of the texture.
Additionally, it adds three new modes of operation:

- Smooth F1: A smooth version of F1 Voronoi with no discontinuities.
- Distance To Edge: Returns the distance to the edges of the cells.
- N-Sphere Radius: Returns the radius of the n-sphere inscribed in
the cells. In other words, it is half the distance between the
closest feature point and the feature point closest to it.

And it removes the following three modes of operation:

- F3.
- F4.
- Cracks.

The Distance metric is now called Euclidean, and it computes the actual
euclidean distance as opposed to the old method of computing the squared
euclidean distance.

This breaks backward compatibility in many ways, including the base case.

Reviewers: brecht, JacquesLucke

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

3 files changed, 1042 insertions, 105 deletions

diff --git a/intern/cycles/kernel/shaders/CMakeLists.txt b/intern/cycles/kernel/shaders/CMakeLists.txt
index a45c43e01ed..38ba113a184 100644
--- a/intern/cycles/kernel/shaders/CMakeLists.txt
+++ b/intern/cycles/kernel/shaders/CMakeLists.txt
@@ -97,6 +97,7 @@ set(SRC_OSL
 set(SRC_OSL_HEADERS
   node_color.h
   node_fresnel.h
+  node_hash.h
   node_noise.h
   node_ramp_util.h
   stdosl.h
diff --git a/intern/cycles/kernel/shaders/node_hash.h b/intern/cycles/kernel/shaders/node_hash.h
new file mode 100644
index 00000000000..7affe432bf2
--- /dev/null
+++ b/intern/cycles/kernel/shaders/node_hash.h
@@ -0,0 +1,81 @@
+#include "stdosl.h"
+#include "vector2.h"
+#include "vector4.h"
+
+#define vector3 point
+
+/* **** Hash a float or vector[234] into a float [0, 1] **** */
+
+float hash_float_to_float(float k)
+{
+  return hashnoise(k);
+}
+
+float hash_vector2_to_float(vector2 k)
+{
+  return hashnoise(k.x, k.y);
+}
+
+float hash_vector3_to_float(vector3 k)
+{
+  return hashnoise(k);
+}
+
+float hash_vector4_to_float(vector4 k)
+{
+  return hashnoise(vector3(k.x, k.y, k.z), k.w);
+}
+
+/* **** Hash a vector[234] into a vector[234] [0, 1] **** */
+
+vector2 hash_vector2_to_vector2(vector2 k)
+{
+  return vector2(hash_vector2_to_float(k), hash_vector3_to_float(vector3(k.x, k.y, 1.0)));
+}
+
+vector3 hash_vector3_to_vector3(vector3 k)
+{
+  return vector3(hash_vector3_to_float(k),
+                 hash_vector4_to_float(vector4(k[0], k[1], k[2], 1.0)),
+                 hash_vector4_to_float(vector4(k[0], k[1], k[2], 2.0)));
+}
+
+vector4 hash_vector4_to_vector4(vector4 k)
+{
+  return vector4(hash_vector4_to_float(k),
+                 hash_vector4_to_float(vector4(k.w, k.x, k.y, k.z)),
+                 hash_vector4_to_float(vector4(k.z, k.w, k.x, k.y)),
+                 hash_vector4_to_float(vector4(k.y, k.z, k.w, k.x)));
+}
+
+/* **** Hash a float or a vec[234] into a color [0, 1] **** */
+
+color hash_float_to_color(float k)
+{
+  return color(hash_float_to_float(k),
+               hash_vector2_to_float(vector2(k, 1.0)),
+               hash_vector2_to_float(vector2(k, 2.0)));
+}
+
+color hash_vector2_to_color(vector2 k)
+{
+  return color(hash_vector2_to_float(k),
+               hash_vector3_to_float(vector3(k.x, k.y, 1.0)),
+               hash_vector3_to_float(vector3(k.x, k.y, 2.0)));
+}
+
+color hash_vector3_to_color(vector3 k)
+{
+  return color(hash_vector3_to_float(k),
+               hash_vector4_to_float(vector4(k[0], k[1], k[2], 1.0)),
+               hash_vector4_to_float(vector4(k[0], k[1], k[2], 2.0)));
+}
+
+color hash_vector4_to_color(vector4 k)
+{
+  return color(hash_vector4_to_float(k),
+               hash_vector4_to_float(vector4(k.z, k.x, k.w, k.y)),
+               hash_vector4_to_float(vector4(k.w, k.z, k.y, k.x)));
+}
+
+#undef vector3
diff --git a/intern/cycles/kernel/shaders/node_voronoi_texture.osl b/intern/cycles/kernel/shaders/node_voronoi_texture.osl
index 0d547b4b615..5de4aeef943 100644
--- a/intern/cycles/kernel/shaders/node_voronoi_texture.osl
+++ b/intern/cycles/kernel/shaders/node_voronoi_texture.osl
@@ -15,158 +15,1013 @@
  */
 
 #include "stdosl.h"
+#include "vector2.h"
+#include "vector4.h"
+#include "node_hash.h"
 
-color cellnoise_color(point p)
+#define vector3 point
+
+/* **** Distance Functions **** */
+
+float distance(float a, float b)
+{
+  return abs(a - b);
+}
+
+float distance(vector2 a, vector2 b)
+{
+  return length(a - b);
+}
+
+float distance(vector4 a, vector4 b)
+{
+  return length(a - b);
+}
+
+/* **** Safe Division **** */
+
+vector2 safe_divide(vector2 a, float b)
+{
+  return vector2((b != 0.0) ? a.x / b : 0.0, (b != 0.0) ? a.y / b : 0.0);
+}
+
+vector4 safe_divide(vector4 a, float b)
 {
-  float r = cellnoise(p);
-  float g = cellnoise(point(p[1], p[0], p[2]));
-  float b = cellnoise(point(p[1], p[2], p[0]));
+  return vector4((b != 0.0) ? a.x / b : 0.0,
+                 (b != 0.0) ? a.y / b : 0.0,
+                 (b != 0.0) ? a.z / b : 0.0,
+                 (b != 0.0) ? a.w / b : 0.0);
+}
+
+/*
+ * Smooth Voronoi:
+ *
+ * - https://wiki.blender.org/wiki/User:OmarSquircleArt/GSoC2019/Documentation/Smooth_Voronoi
+ *
+ * Distance To Edge:
+ *
+ * - https://www.shadertoy.com/view/llG3zy
+ *
+ */
 
-  return color(r, g, b);
+/* **** 1D Voronoi **** */
+
+float voronoi_distance(float a, float b, string metric, float exponent)
+{
+  return abs(a - b);
 }
 
-void voronoi_m(point p, string metric, float e, float da[4], point pa[4])
+void voronoi_f1_1d(float w,
+                   float exponent,
+                   float randomness,
+                   string metric,
+                   output float outDistance,
+                   output color outColor,
+                   output float outW)
 {
-  /* Compute the distance to and the position of the four closest neighbors to p.
-   *
-   * The neighbors are randomly placed, 1 each in a 3x3x3 grid (Worley pattern).
-   * The distances and points are returned in ascending order, i.e. da[0] and pa[0] will
-   * contain the distance to the closest point and its coordinates respectively.
-   */
-  int xx, yy, zz, xi, yi, zi;
+  float cellPosition = floor(w);
+  float localPosition = w - cellPosition;
 
-  xi = (int)floor(p[0]);
-  yi = (int)floor(p[1]);
-  zi = (int)floor(p[2]);
+  float minDistance = 8.0;
+  float targetOffset, targetPosition;
+  for (int i = -1; i <= 1; i++) {
+    float cellOffset = float(i);
+    float pointPosition = cellOffset + hash_float_to_float(cellPosition + cellOffset) * randomness;
+    float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+    if (distanceToPoint < minDistance) {
+      targetOffset = cellOffset;
+      minDistance = distanceToPoint;
+      targetPosition = pointPosition;
+    }
+  }
+  outDistance = minDistance;
+  outColor = hash_float_to_color(cellPosition + targetOffset);
+  outW = targetPosition + cellPosition;
+}
 
-  da[0] = 1e10;
-  da[1] = 1e10;
-  da[2] = 1e10;
-  da[3] = 1e10;
+void voronoi_smooth_f1_1d(float w,
+                          float smoothness,
+                          float exponent,
+                          float randomness,
+                          string metric,
+                          output float outDistance,
+                          output color outColor,
+                          output float outW)
+{
+  float cellPosition = floor(w);
+  float localPosition = w - cellPosition;
 
-  for (xx = xi - 1; xx <= xi + 1; xx++) {
-    for (yy = yi - 1; yy <= yi + 1; yy++) {
-      for (zz = zi - 1; zz <= zi + 1; zz++) {
-        point ip = point(xx, yy, zz);
-        point vp = (point)cellnoise_color(ip);
-        point pd = p - (vp + ip);
+  float smoothDistance = 8.0;
+  float smoothPosition = 0.0;
+  color smoothColor = color(0.0);
+  for (int i = -2; i <= 2; i++) {
+    float cellOffset = float(i);
+    float pointPosition = cellOffset + hash_float_to_float(cellPosition + cellOffset) * randomness;
+    float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+    float h = smoothstep(0.0, 1.0, 0.5 + 0.5 * (smoothDistance - distanceToPoint) / smoothness);
+    float correctionFactor = smoothness * h * (1.0 - h);
+    smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
+    correctionFactor /= 1.0 + 3.0 * smoothness;
+    color cellColor = hash_float_to_color(cellPosition + cellOffset);
+    smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
+    smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
+  }
+  outDistance = smoothDistance;
+  outColor = smoothColor;
+  outW = cellPosition + smoothPosition;
+}
+
+void voronoi_f2_1d(float w,
+                   float exponent,
+                   float randomness,
+                   string metric,
+                   output float outDistance,
+                   output color outColor,
+                   output float outW)
+{
+  float cellPosition = floor(w);
+  float localPosition = w - cellPosition;
+
+  float distanceF1 = 8.0;
+  float distanceF2 = 8.0;
+  float offsetF1 = 0.0;
+  float positionF1 = 0.0;
+  float offsetF2, positionF2;
+  for (int i = -1; i <= 1; i++) {
+    float cellOffset = float(i);
+    float pointPosition = cellOffset + hash_float_to_float(cellPosition + cellOffset) * randomness;
+    float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+    if (distanceToPoint < distanceF1) {
+      distanceF2 = distanceF1;
+      distanceF1 = distanceToPoint;
+      offsetF2 = offsetF1;
+      offsetF1 = cellOffset;
+      positionF2 = positionF1;
+      positionF1 = pointPosition;
+    }
+    else if (distanceToPoint < distanceF2) {
+      distanceF2 = distanceToPoint;
+      offsetF2 = cellOffset;
+      positionF2 = pointPosition;
+    }
+  }
+  outDistance = distanceF2;
+  outColor = hash_float_to_color(cellPosition + offsetF2);
+  outW = positionF2 + cellPosition;
+}
+
+void voronoi_distance_to_edge_1d(float w, float randomness, output float outDistance)
+{
+  float cellPosition = floor(w);
+  float localPosition = w - cellPosition;
+
+  float minDistance = 8.0;
+  for (int i = -1; i <= 1; i++) {
+    float cellOffset = float(i);
+    float pointPosition = cellOffset + hash_float_to_float(cellPosition + cellOffset) * randomness;
+    float distanceToPoint = distance(pointPosition, localPosition);
+    minDistance = min(distanceToPoint, minDistance);
+  }
+  outDistance = minDistance;
+}
+
+void voronoi_n_sphere_radius_1d(float w, float randomness, output float outRadius)
+{
+  float cellPosition = floor(w);
+  float localPosition = w - cellPosition;
+
+  float closestPoint;
+  float closestPointOffset;
+  float minDistance = 8.0;
+  for (int i = -1; i <= 1; i++) {
+    float cellOffset = float(i);
+    float pointPosition = cellOffset + hash_float_to_float(cellPosition + cellOffset) * randomness;
+    float distanceToPoint = distance(pointPosition, localPosition);
+    if (distanceToPoint < minDistance) {
+      minDistance = distanceToPoint;
+      closestPoint = pointPosition;
+      closestPointOffset = cellOffset;
+    }
+  }
+
+  minDistance = 8.0;
+  float closestPointToClosestPoint;
+  for (int i = -1; i <= 1; i++) {
+    if (i == 0) {
+      continue;
+    }
+    float cellOffset = float(i) + closestPointOffset;
+    float pointPosition = cellOffset + hash_float_to_float(cellPosition + cellOffset) * randomness;
+    float distanceToPoint = distance(closestPoint, pointPosition);
+    if (distanceToPoint < minDistance) {
+      minDistance = distanceToPoint;
+      closestPointToClosestPoint = pointPosition;
+    }
+  }
+  outRadius = distance(closestPointToClosestPoint, closestPoint) / 2.0;
+}
+
+/* **** 2D Voronoi **** */
+
+float voronoi_distance(vector2 a, vector2 b, string metric, float exponent)
+{
+  if (metric == "euclidean") {
+    return distance(a, b);
+  }
+  else if (metric == "manhattan") {
+    return abs(a.x - b.x) + abs(a.y - b.y);
+  }
+  else if (metric == "chebychev") {
+    return max(abs(a.x - b.x), abs(a.y - b.y));
+  }
+  else if (metric == "minkowski") {
+    return pow(pow(abs(a.x - b.x), exponent) + pow(abs(a.y - b.y), exponent), 1.0 / exponent);
+  }
+  else {
+    return 0.0;
+  }
+}
+
+void voronoi_f1_2d(vector2 coord,
+                   float exponent,
+                   float randomness,
+                   string metric,
+                   output float outDistance,
+                   output color outColor,
+                   output vector2 outPosition)
+{
+  vector2 cellPosition = floor(coord);
+  vector2 localPosition = coord - cellPosition;
+
+  float minDistance = 8.0;
+  vector2 targetOffset, targetPosition;
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      vector2 cellOffset = vector2(i, j);
+      vector2 pointPosition = cellOffset +
+                              hash_vector2_to_vector2(cellPosition + cellOffset) * randomness;
+      float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+      if (distanceToPoint < minDistance) {
+        targetOffset = cellOffset;
+        minDistance = distanceToPoint;
+        targetPosition = pointPosition;
+      }
+    }
+  }
+  outDistance = minDistance;
+  outColor = hash_vector2_to_color(cellPosition + targetOffset);
+  outPosition = targetPosition + cellPosition;
+}
+
+void voronoi_smooth_f1_2d(vector2 coord,
+                          float smoothness,
+                          float exponent,
+                          float randomness,
+                          string metric,
+                          output float outDistance,
+                          output color outColor,
+                          output vector2 outPosition)
+{
+  vector2 cellPosition = floor(coord);
+  vector2 localPosition = coord - cellPosition;
+
+  float smoothDistance = 8.0;
+  color smoothColor = color(0.0);
+  vector2 smoothPosition = vector2(0.0, 0.0);
+  for (int j = -2; j <= 2; j++) {
+    for (int i = -2; i <= 2; i++) {
+      vector2 cellOffset = vector2(i, j);
+      vector2 pointPosition = cellOffset +
+                              hash_vector2_to_vector2(cellPosition + cellOffset) * randomness;
+      float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+      float h = smoothstep(0.0, 1.0, 0.5 + 0.5 * (smoothDistance - distanceToPoint) / smoothness);
+      float correctionFactor = smoothness * h * (1.0 - h);
+      smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
+      correctionFactor /= 1.0 + 3.0 * smoothness;
+      color cellColor = hash_vector2_to_color(cellPosition + cellOffset);
+      smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
+      smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
+    }
+  }
+  outDistance = smoothDistance;
+  outColor = smoothColor;
+  outPosition = cellPosition + smoothPosition;
+}
+
+void voronoi_f2_2d(vector2 coord,
+                   float exponent,
+                   float randomness,
+                   string metric,
+                   output float outDistance,
+                   output color outColor,
+                   output vector2 outPosition)
+{
+  vector2 cellPosition = floor(coord);
+  vector2 localPosition = coord - cellPosition;
+
+  float distanceF1 = 8.0;
+  float distanceF2 = 8.0;
+  vector2 offsetF1 = vector2(0.0, 0.0);
+  vector2 positionF1 = vector2(0.0, 0.0);
+  vector2 offsetF2, positionF2;
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      vector2 cellOffset = vector2(i, j);
+      vector2 pointPosition = cellOffset +
+                              hash_vector2_to_vector2(cellPosition + cellOffset) * randomness;
+      float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+      if (distanceToPoint < distanceF1) {
+        distanceF2 = distanceF1;
+        distanceF1 = distanceToPoint;
+        offsetF2 = offsetF1;
+        offsetF1 = cellOffset;
+        positionF2 = positionF1;
+        positionF1 = pointPosition;
+      }
+      else if (distanceToPoint < distanceF2) {
+        distanceF2 = distanceToPoint;
+        offsetF2 = cellOffset;
+        positionF2 = pointPosition;
+      }
+    }
+  }
+  outDistance = distanceF2;
+  outColor = hash_vector2_to_color(cellPosition + offsetF2);
+  outPosition = positionF2 + cellPosition;
+}
+
+void voronoi_distance_to_edge_2d(vector2 coord, float randomness, output float outDistance)
+{
+  vector2 cellPosition = floor(coord);
+  vector2 localPosition = coord - cellPosition;
+
+  vector2 vectorToClosest;
+  float minDistance = 8.0;
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      vector2 cellOffset = vector2(i, j);
+      vector2 vectorToPoint = cellOffset +
+                              hash_vector2_to_vector2(cellPosition + cellOffset) * randomness -
+                              localPosition;
+      float distanceToPoint = dot(vectorToPoint, vectorToPoint);
+      if (distanceToPoint < minDistance) {
+        minDistance = distanceToPoint;
+        vectorToClosest = vectorToPoint;
+      }
+    }
+  }
+
+  minDistance = 8.0;
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      vector2 cellOffset = vector2(i, j);
+      vector2 vectorToPoint = cellOffset +
+                              hash_vector2_to_vector2(cellPosition + cellOffset) * randomness -
+                              localPosition;
+      vector2 perpendicularToEdge = vectorToPoint - vectorToClosest;
+      if (dot(perpendicularToEdge, perpendicularToEdge) > 0.0001) {
+        float distanceToEdge = dot((vectorToClosest + vectorToPoint) / 2.0,
+                                   normalize(perpendicularToEdge));
+        minDistance = min(minDistance, distanceToEdge);
+      }
+    }
+  }
+  outDistance = minDistance;
+}
+
+void voronoi_n_sphere_radius_2d(vector2 coord, float randomness, output float outRadius)
+{
+  vector2 cellPosition = floor(coord);
+  vector2 localPosition = coord - cellPosition;
+
+  vector2 closestPoint;
+  vector2 closestPointOffset;
+  float minDistance = 8.0;
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      vector2 cellOffset = vector2(i, j);
+      vector2 pointPosition = cellOffset +
+                              hash_vector2_to_vector2(cellPosition + cellOffset) * randomness;
+      float distanceToPoint = distance(pointPosition, localPosition);
+      if (distanceToPoint < minDistance) {
+        minDistance = distanceToPoint;
+        closestPoint = pointPosition;
+        closestPointOffset = cellOffset;
+      }
+    }
+  }
+
+  minDistance = 8.0;
+  vector2 closestPointToClosestPoint;
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      if (i == 0 && j == 0) {
+        continue;
+      }
+      vector2 cellOffset = vector2(i, j) + closestPointOffset;
+      vector2 pointPosition = cellOffset +
+                              hash_vector2_to_vector2(cellPosition + cellOffset) * randomness;
+      float distanceToPoint = distance(closestPoint, pointPosition);
+      if (distanceToPoint < minDistance) {
+        minDistance = distanceToPoint;
+        closestPointToClosestPoint = pointPosition;
+      }
+    }
+  }
+  outRadius = distance(closestPointToClosestPoint, closestPoint) / 2.0;
+}
+
+/* **** 3D Voronoi **** */
+
+float voronoi_distance(vector3 a, vector3 b, string metric, float exponent)
+{
+  if (metric == "euclidean") {
+    return distance(a, b);
+  }
+  else if (metric == "manhattan") {
+    return abs(a[0] - b[0]) + abs(a[1] - b[1]) + abs(a[2] - b[2]);
+  }
+  else if (metric == "chebychev") {
+    return max(abs(a[0] - b[0]), max(abs(a[1] - b[1]), abs(a[2] - b[2])));
+  }
+  else if (metric == "minkowski") {
+    return pow(pow(abs(a[0] - b[0]), exponent) + pow(abs(a[1] - b[1]), exponent) +
+                   pow(abs(a[2] - b[2]), exponent),
+               1.0 / exponent);
+  }
+  else {
+    return 0.0;
+  }
+}
 
-        float d = 0.0;
-        if (metric == "distance") {
-          d = dot(pd, pd);
+void voronoi_f1_3d(vector3 coord,
+                   float exponent,
+                   float randomness,
+                   string metric,
+                   output float outDistance,
+                   output color outColor,
+                   output vector3 outPosition)
+{
+  vector3 cellPosition = floor(coord);
+  vector3 localPosition = coord - cellPosition;
+
+  float minDistance = 8.0;
+  vector3 targetOffset, targetPosition;
+  for (int k = -1; k <= 1; k++) {
+    for (int j = -1; j <= 1; j++) {
+      for (int i = -1; i <= 1; i++) {
+        vector3 cellOffset = vector3(i, j, k);
+        vector3 pointPosition = cellOffset +
+                                hash_vector3_to_vector3(cellPosition + cellOffset) * randomness;
+        float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+        if (distanceToPoint < minDistance) {
+          targetOffset = cellOffset;
+          minDistance = distanceToPoint;
+          targetPosition = pointPosition;
+        }
+      }
+    }
+  }
+  outDistance = minDistance;
+  outColor = hash_vector3_to_color(cellPosition + targetOffset);
+  outPosition = targetPosition + cellPosition;
+}
+
+void voronoi_smooth_f1_3d(vector3 coord,
+                          float smoothness,
+                          float exponent,
+                          float randomness,
+                          string metric,
+                          output float outDistance,
+                          output color outColor,
+                          output vector3 outPosition)
+{
+  vector3 cellPosition = floor(coord);
+  vector3 localPosition = coord - cellPosition;
+
+  float smoothDistance = 8.0;
+  color smoothColor = color(0.0);
+  vector3 smoothPosition = vector3(0.0);
+  for (int k = -2; k <= 2; k++) {
+    for (int j = -2; j <= 2; j++) {
+      for (int i = -2; i <= 2; i++) {
+        vector3 cellOffset = vector3(i, j, k);
+        vector3 pointPosition = cellOffset +
+                                hash_vector3_to_vector3(cellPosition + cellOffset) * randomness;
+        float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+        float h = smoothstep(
+            0.0, 1.0, 0.5 + 0.5 * (smoothDistance - distanceToPoint) / smoothness);
+        float correctionFactor = smoothness * h * (1.0 - h);
+        smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
+        correctionFactor /= 1.0 + 3.0 * smoothness;
+        color cellColor = hash_vector3_to_color(cellPosition + cellOffset);
+        smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
+        smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
+      }
+    }
+  }
+  outDistance = smoothDistance;
+  outColor = smoothColor;
+  outPosition = cellPosition + smoothPosition;
+}
+
+void voronoi_f2_3d(vector3 coord,
+                   float exponent,
+                   float randomness,
+                   string metric,
+                   output float outDistance,
+                   output color outColor,
+                   output vector3 outPosition)
+{
+  vector3 cellPosition = floor(coord);
+  vector3 localPosition = coord - cellPosition;
+
+  float distanceF1 = 8.0;
+  float distanceF2 = 8.0;
+  vector3 offsetF1 = vector3(0.0);
+  vector3 positionF1 = vector3(0.0);
+  vector3 offsetF2, positionF2;
+  for (int k = -1; k <= 1; k++) {
+    for (int j = -1; j <= 1; j++) {
+      for (int i = -1; i <= 1; i++) {
+        vector3 cellOffset = vector3(i, j, k);
+        vector3 pointPosition = cellOffset +
+                                hash_vector3_to_vector3(cellPosition + cellOffset) * randomness;
+        float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+        if (distanceToPoint < distanceF1) {
+          distanceF2 = distanceF1;
+          distanceF1 = distanceToPoint;
+          offsetF2 = offsetF1;
+          offsetF1 = cellOffset;
+          positionF2 = positionF1;
+          positionF1 = pointPosition;
+        }
+        else if (distanceToPoint < distanceF2) {
+          distanceF2 = distanceToPoint;
+          offsetF2 = cellOffset;
+          positionF2 = pointPosition;
+        }
+      }
+    }
+  }
+  outDistance = distanceF2;
+  outColor = hash_vector3_to_color(cellPosition + offsetF2);
+  outPosition = positionF2 + cellPosition;
+}
+
+void voronoi_distance_to_edge_3d(vector3 coord, float randomness, output float outDistance)
+{
+  vector3 cellPosition = floor(coord);
+  vector3 localPosition = coord - cellPosition;
+
+  vector3 vectorToClosest;
+  float minDistance = 8.0;
+  for (int k = -1; k <= 1; k++) {
+    for (int j = -1; j <= 1; j++) {
+      for (int i = -1; i <= 1; i++) {
+        vector3 cellOffset = vector3(i, j, k);
+        vector3 vectorToPoint = cellOffset +
+                                hash_vector3_to_vector3(cellPosition + cellOffset) * randomness -
+                                localPosition;
+        float distanceToPoint = dot(vectorToPoint, vectorToPoint);
+        if (distanceToPoint < minDistance) {
+          minDistance = distanceToPoint;
+          vectorToClosest = vectorToPoint;
+        }
+      }
+    }
+  }
+
+  minDistance = 8.0;
+  for (int k = -1; k <= 1; k++) {
+    for (int j = -1; j <= 1; j++) {
+      for (int i = -1; i <= 1; i++) {
+        vector3 cellOffset = vector3(i, j, k);
+        vector3 vectorToPoint = cellOffset +
+                                hash_vector3_to_vector3(cellPosition + cellOffset) * randomness -
+                                localPosition;
+        vector3 perpendicularToEdge = vectorToPoint - vectorToClosest;
+        if (dot(perpendicularToEdge, perpendicularToEdge) > 0.0001) {
+          float distanceToEdge = dot((vectorToClosest + vectorToPoint) / 2.0,
+                                     normalize(perpendicularToEdge));
+          minDistance = min(minDistance, distanceToEdge);
         }
-        else if (metric == "manhattan") {
-          d = fabs(pd[0]) + fabs(pd[1]) + fabs(pd[2]);
+      }
+    }
+  }
+  outDistance = minDistance;
+}
+
+void voronoi_n_sphere_radius_3d(vector3 coord, float randomness, output float outRadius)
+{
+  vector3 cellPosition = floor(coord);
+  vector3 localPosition = coord - cellPosition;
+
+  vector3 closestPoint;
+  vector3 closestPointOffset;
+  float minDistance = 8.0;
+  for (int k = -1; k <= 1; k++) {
+    for (int j = -1; j <= 1; j++) {
+      for (int i = -1; i <= 1; i++) {
+        vector3 cellOffset = vector3(i, j, k);
+        vector3 pointPosition = cellOffset +
+                                hash_vector3_to_vector3(cellPosition + cellOffset) * randomness;
+        float distanceToPoint = distance(pointPosition, localPosition);
+        if (distanceToPoint < minDistance) {
+          minDistance = distanceToPoint;
+          closestPoint = pointPosition;
+          closestPointOffset = cellOffset;
         }
-        else if (metric == "chebychev") {
-          d = max(fabs(pd[0]), max(fabs(pd[1]), fabs(pd[2])));
+      }
+    }
+  }
+
+  minDistance = 8.0;
+  vector3 closestPointToClosestPoint;
+  for (int k = -1; k <= 1; k++) {
+    for (int j = -1; j <= 1; j++) {
+      for (int i = -1; i <= 1; i++) {
+        if (i == 0 && j == 0 && k == 0) {
+          continue;
         }
-        else if (metric == "minkowski") {
-          d = pow(pow(fabs(pd[0]), e) + pow(fabs(pd[1]), e) + pow(fabs(pd[2]), e), 1.0 / e);
+        vector3 cellOffset = vector3(i, j, k) + closestPointOffset;
+        vector3 pointPosition = cellOffset +
+                                hash_vector3_to_vector3(cellPosition + cellOffset) * randomness;
+        float distanceToPoint = distance(closestPoint, pointPosition);
+        if (distanceToPoint < minDistance) {
+          minDistance = distanceToPoint;
+          closestPointToClosestPoint = pointPosition;
         }
+      }
+    }
+  }
+  outRadius = distance(closestPointToClosestPoint, closestPoint) / 2.0;
+}
+
+/* **** 4D Voronoi **** */
+
+float voronoi_distance(vector4 a, vector4 b, string metric, float exponent)
+{
+  if (metric == "euclidean") {
+    return distance(a, b);
+  }
+  else if (metric == "manhattan") {
+    return abs(a.x - b.x) + abs(a.y - b.y) + abs(a.z - b.z) + abs(a.w - b.w);
+  }
+  else if (metric == "chebychev") {
+    return max(abs(a.x - b.x), max(abs(a.y - b.y), max(abs(a.z - b.z), abs(a.w - b.w))));
+  }
+  else if (metric == "minkowski") {
+    return pow(pow(abs(a.x - b.x), exponent) + pow(abs(a.y - b.y), exponent) +
+                   pow(abs(a.z - b.z), exponent) + pow(abs(a.w - b.w), exponent),
+               1.0 / exponent);
+  }
+  else {
+    return 0.0;
+  }
+}
+
+void voronoi_f1_4d(vector4 coord,
+                   float exponent,
+                   float randomness,
+                   string metric,
+                   output float outDistance,
+                   output color outColor,
+                   output vector4 outPosition)
+{
+  vector4 cellPosition = floor(coord);
+  vector4 localPosition = coord - cellPosition;
 
-        vp += point(xx, yy, zz);
+  float minDistance = 8.0;
+  vector4 targetOffset, targetPosition;
+  for (int u = -1; u <= 1; u++) {
+    for (int k = -1; k <= 1; k++) {
+      for (int j = -1; j <= 1; j++) {
+        for (int i = -1; i <= 1; i++) {
+          vector4 cellOffset = vector4(i, j, k, u);
+          vector4 pointPosition = cellOffset +
+                                  hash_vector4_to_vector4(cellPosition + cellOffset) * randomness;
+          float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+          if (distanceToPoint < minDistance) {
+            targetOffset = cellOffset;
+            minDistance = distanceToPoint;
+            targetPosition = pointPosition;
+          }
+        }
+      }
+    }
+  }
+  outDistance = minDistance;
+  outColor = hash_vector4_to_color(cellPosition + targetOffset);
+  outPosition = targetPosition + cellPosition;
+}
 
-        if (d < da[0]) {
-          da[3] = da[2];
-          da[2] = da[1];
-          da[1] = da[0];
-          da[0] = d;
+void voronoi_smooth_f1_4d(vector4 coord,
+                          float smoothness,
+                          float exponent,
+                          float randomness,
+                          string metric,
+                          output float outDistance,
+                          output color outColor,
+                          output vector4 outPosition)
+{
+  vector4 cellPosition = floor(coord);
+  vector4 localPosition = coord - cellPosition;
 
-          pa[3] = pa[2];
-          pa[2] = pa[1];
-          pa[1] = pa[0];
-          pa[0] = vp;
+  float smoothDistance = 8.0;
+  color smoothColor = color(0.0);
+  vector4 smoothPosition = vector4(0.0, 0.0, 0.0, 0.0);
+  for (int u = -2; u <= 2; u++) {
+    for (int k = -2; k <= 2; k++) {
+      for (int j = -2; j <= 2; j++) {
+        for (int i = -2; i <= 2; i++) {
+          vector4 cellOffset = vector4(i, j, k, u);
+          vector4 pointPosition = cellOffset +
+                                  hash_vector4_to_vector4(cellPosition + cellOffset) * randomness;
+          float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+          float h = smoothstep(
+              0.0, 1.0, 0.5 + 0.5 * (smoothDistance - distanceToPoint) / smoothness);
+          float correctionFactor = smoothness * h * (1.0 - h);
+          smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
+          correctionFactor /= 1.0 + 3.0 * smoothness;
+          color cellColor = hash_vector4_to_color(cellPosition + cellOffset);
+          smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
+          smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
         }
-        else if (d < da[1]) {
-          da[3] = da[2];
-          da[2] = da[1];
-          da[1] = d;
-
-          pa[3] = pa[2];
-          pa[2] = pa[1];
-          pa[1] = vp;
+      }
+    }
+  }
+  outDistance = smoothDistance;
+  outColor = smoothColor;
+  outPosition = cellPosition + smoothPosition;
+}
+
+void voronoi_f2_4d(vector4 coord,
+                   float exponent,
+                   float randomness,
+                   string metric,
+                   output float outDistance,
+                   output color outColor,
+                   output vector4 outPosition)
+{
+  vector4 cellPosition = floor(coord);
+  vector4 localPosition = coord - cellPosition;
+
+  float distanceF1 = 8.0;
+  float distanceF2 = 8.0;
+  vector4 offsetF1 = vector4(0.0, 0.0, 0.0, 0.0);
+  vector4 positionF1 = vector4(0.0, 0.0, 0.0, 0.0);
+  vector4 offsetF2, positionF2;
+  for (int u = -1; u <= 1; u++) {
+    for (int k = -1; k <= 1; k++) {
+      for (int j = -1; j <= 1; j++) {
+        for (int i = -1; i <= 1; i++) {
+          vector4 cellOffset = vector4(i, j, k, u);
+          vector4 pointPosition = cellOffset +
+                                  hash_vector4_to_vector4(cellPosition + cellOffset) * randomness;
+          float distanceToPoint = voronoi_distance(pointPosition, localPosition, metric, exponent);
+          if (distanceToPoint < distanceF1) {
+            distanceF2 = distanceF1;
+            distanceF1 = distanceToPoint;
+            offsetF2 = offsetF1;
+            offsetF1 = cellOffset;
+            positionF2 = positionF1;
+            positionF1 = pointPosition;
+          }
+          else if (distanceToPoint < distanceF2) {
+            distanceF2 = distanceToPoint;
+            offsetF2 = cellOffset;
+            positionF2 = pointPosition;
+          }
         }
-        else if (d < da[2]) {
-          da[3] = da[2];
-          da[2] = d;
+      }
+    }
+  }
+  outDistance = distanceF2;
+  outColor = hash_vector4_to_color(cellPosition + offsetF2);
+  outPosition = positionF2 + cellPosition;
+}
+
+void voronoi_distance_to_edge_4d(vector4 coord, float randomness, output float outDistance)
+{
+  vector4 cellPosition = floor(coord);
+  vector4 localPosition = coord - cellPosition;
 
-          pa[3] = pa[2];
-          pa[2] = vp;
+  vector4 vectorToClosest;
+  float minDistance = 8.0;
+  for (int u = -1; u <= 1; u++) {
+    for (int k = -1; k <= 1; k++) {
+      for (int j = -1; j <= 1; j++) {
+        for (int i = -1; i <= 1; i++) {
+          vector4 cellOffset = vector4(i, j, k, u);
+          vector4 vectorToPoint = cellOffset +
+                                  hash_vector4_to_vector4(cellPosition + cellOffset) * randomness -
+                                  localPosition;
+          float distanceToPoint = dot(vectorToPoint, vectorToPoint);
+          if (distanceToPoint < minDistance) {
+            minDistance = distanceToPoint;
+            vectorToClosest = vectorToPoint;
+          }
         }
-        else if (d < da[3]) {
-          da[3] = d;
-          pa[3] = vp;
+      }
+    }
+  }
+
+  minDistance = 8.0;
+  for (int u = -1; u <= 1; u++) {
+    for (int k = -1; k <= 1; k++) {
+      for (int j = -1; j <= 1; j++) {
+        for (int i = -1; i <= 1; i++) {
+          vector4 cellOffset = vector4(i, j, k, u);
+          vector4 vectorToPoint = cellOffset +
+                                  hash_vector4_to_vector4(cellPosition + cellOffset) * randomness -
+                                  localPosition;
+          vector4 perpendicularToEdge = vectorToPoint - vectorToClosest;
+          if (dot(perpendicularToEdge, perpendicularToEdge) > 0.0001) {
+            float distanceToEdge = dot((vectorToClosest + vectorToPoint) / 2.0,
+                                       normalize(perpendicularToEdge));
+            minDistance = min(minDistance, distanceToEdge);
+          }
         }
       }
     }
   }
+  outDistance = minDistance;
 }
 
-/* Voronoi */
+void voronoi_n_sphere_radius_4d(vector4 coord, float randomness, output float outRadius)
+{
+  vector4 cellPosition = floor(coord);
+  vector4 localPosition = coord - cellPosition;
+
+  vector4 closestPoint;
+  vector4 closestPointOffset;
+  float minDistance = 8.0;
+  for (int u = -1; u <= 1; u++) {
+    for (int k = -1; k <= 1; k++) {
+      for (int j = -1; j <= 1; j++) {
+        for (int i = -1; i <= 1; i++) {
+          vector4 cellOffset = vector4(i, j, k, u);
+          vector4 pointPosition = cellOffset +
+                                  hash_vector4_to_vector4(cellPosition + cellOffset) * randomness;
+          float distanceToPoint = distance(pointPosition, localPosition);
+          if (distanceToPoint < minDistance) {
+            minDistance = distanceToPoint;
+            closestPoint = pointPosition;
+            closestPointOffset = cellOffset;
+          }
+        }
+      }
+    }
+  }
+
+  minDistance = 8.0;
+  vector4 closestPointToClosestPoint;
+  for (int u = -1; u <= 1; u++) {
+    for (int k = -1; k <= 1; k++) {
+      for (int j = -1; j <= 1; j++) {
+        for (int i = -1; i <= 1; i++) {
+          if (i == 0 && j == 0 && k == 0 && u == 0) {
+            continue;
+          }
+          vector4 cellOffset = vector4(i, j, k, u) + closestPointOffset;
+          vector4 pointPosition = cellOffset +
+                                  hash_vector4_to_vector4(cellPosition + cellOffset) * randomness;
+          float distanceToPoint = distance(closestPoint, pointPosition);
+          if (distanceToPoint < minDistance) {
+            minDistance = distanceToPoint;
+            closestPointToClosestPoint = pointPosition;
+          }
+        }
+      }
+    }
+  }
+  outRadius = distance(closestPointToClosestPoint, closestPoint) / 2.0;
+}
 
 shader node_voronoi_texture(
     int use_mapping = 0,
     matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
-    string coloring = "intensity",
-    string metric = "distance",
-    string feature = "F1",
-    float Exponent = 1.0,
+    string dimensions = "3D",
+    string feature = "f1",
+    string metric = "euclidean",
+    vector3 Vector = P,
+    float WIn = 0.0,
     float Scale = 5.0,
-    point Vector = P,
-    output float Fac = 0.0,
-    output color Color = 0.0)
+    float Smoothness = 5.0,
+    float Exponent = 1.0,
+    float Randomness = 1.0,
+    output float Distance = 0.0,
+    output color Color = 0.0,
+    output vector3 Position = P,
+    output float WOut = 0.0,
+    output float Radius = 0.0)
 {
-  point p = Vector;
+  float randomness = clamp(Randomness, 0.0, 1.0);
+  float smoothness = clamp(Smoothness / 2.0, 0.0, 0.5);
 
+  vector3 coord = Vector;
   if (use_mapping)
-    p = transform(mapping, p);
+    coord = transform(mapping, coord);
 
-  /* compute distance and point coordinate of 4 nearest neighbours */
-  float da[4];
-  point pa[4];
+  float w = WIn * Scale;
+  coord *= Scale;
 
-  /* compute distance and point coordinate of 4 nearest neighbours */
-  voronoi_m(p * Scale, metric, Exponent, da, pa);
-
-  if (coloring == "intensity") {
-    /* Intensity output */
-    if (feature == "F1") {
-      Fac = fabs(da[0]);
+  if (dimensions == "1D") {
+    if (feature == "f1") {
+      voronoi_f1_1d(w, Exponent, randomness, metric, Distance, Color, WOut);
+    }
+    else if (feature == "smooth_f1") {
+      voronoi_smooth_f1_1d(w, smoothness, Exponent, randomness, metric, Distance, Color, WOut);
     }
-    else if (feature == "F2") {
-      Fac = fabs(da[1]);
+    else if (feature == "f2") {
+      voronoi_f2_1d(w, Exponent, randomness, metric, Distance, Color, WOut);
     }
-    else if (feature == "F3") {
-      Fac = fabs(da[2]);
+    else if (feature == "distance_to_edge") {
+      voronoi_distance_to_edge_1d(w, randomness, Distance);
     }
-    else if (feature == "F4") {
-      Fac = fabs(da[3]);
+    else if (feature == "n_sphere_radius") {
+      voronoi_n_sphere_radius_1d(w, randomness, Radius);
     }
-    else if (feature == "F2F1") {
-      Fac = fabs(da[1] - da[0]);
+    else {
+      error("Unknown feature!");
     }
-    Color = color(Fac);
+    WOut = (Scale != 0.0) ? WOut / Scale : 0.0;
   }
-  else {
-    /* Color output */
-    if (feature == "F1") {
-      Color = pa[0];
+  else if (dimensions == "2D") {
+    vector2 coord2D = vector2(coord[0], coord[1]);
+    vector2 outPosition2D;
+    if (feature == "f1") {
+      voronoi_f1_2d(coord2D, Exponent, randomness, metric, Distance, Color, outPosition2D);
     }
-    else if (feature == "F2") {
-      Color = pa[1];
+    else if (feature == "smooth_f1") {
+      voronoi_smooth_f1_2d(
+          coord2D, smoothness, Exponent, randomness, metric, Distance, Color, outPosition2D);
     }
-    else if (feature == "F3") {
-      Color = pa[2];
+    else if (feature == "f2") {
+      voronoi_f2_2d(coord2D, Exponent, randomness, metric, Distance, Color, outPosition2D);
     }
-    else if (feature == "F4") {
-      Color = pa[3];
+    else if (feature == "distance_to_edge") {
+      voronoi_distance_to_edge_2d(coord2D, randomness, Distance);
     }
-    else if (feature == "F2F1") {
-      Color = fabs(pa[1] - pa[0]);
+    else if (feature == "n_sphere_radius") {
+      voronoi_n_sphere_radius_2d(coord2D, randomness, Radius);
     }
-
-    Color = cellnoise_color(Color);
-    Fac = (Color[0] + Color[1] + Color[2]) * (1.0 / 3.0);
+    else {
+      error("Unknown feature!");
+    }
+    outPosition2D = safe_divide(outPosition2D, Scale);
+    Position = vector3(outPosition2D.x, outPosition2D.y, 0.0);
+  }
+  else if (dimensions == "3D") {
+    if (feature == "f1") {
+      voronoi_f1_3d(coord, Exponent, randomness, metric, Distance, Color, Position);
+    }
+    else if (feature == "smooth_f1") {
+      voronoi_smooth_f1_3d(
+          coord, smoothness, Exponent, randomness, metric, Distance, Color, Position);
+    }
+    else if (feature == "f2") {
+      voronoi_f2_3d(coord, Exponent, randomness, metric, Distance, Color, Position);
+    }
+    else if (feature == "distance_to_edge") {
+      voronoi_distance_to_edge_3d(coord, randomness, Distance);
+    }
+    else if (feature == "n_sphere_radius") {
+      voronoi_n_sphere_radius_3d(coord, randomness, Radius);
+    }
+    else {
+      error("Unknown feature!");
+    }
+    Position = (Scale != 0.0) ? Position / Scale : vector3(0.0);
+  }
+  else if (dimensions == "4D") {
+    vector4 coord4D = vector4(coord[0], coord[1], coord[2], w);
+    vector4 outPosition4D;
+    if (feature == "f1") {
+      voronoi_f1_4d(coord4D, Exponent, randomness, metric, Distance, Color, outPosition4D);
+    }
+    else if (feature == "smooth_f1") {
+      voronoi_smooth_f1_4d(
+          coord4D, smoothness, Exponent, randomness, metric, Distance, Color, outPosition4D);
+    }
+    else if (feature == "f2") {
+      voronoi_f2_4d(coord4D, Exponent, randomness, metric, Distance, Color, outPosition4D);
+    }
+    else if (feature == "distance_to_edge") {
+      voronoi_distance_to_edge_4d(coord4D, randomness, Distance);
+    }
+    else if (feature == "n_sphere_radius") {
+      voronoi_n_sphere_radius_4d(coord4D, randomness, Radius);
+    }
+    else {
+      error("Unknown feature!");
+    }
+    outPosition4D = safe_divide(outPosition4D, Scale);
+    Position = vector3(outPosition4D.x, outPosition4D.y, outPosition4D.z);
+    WOut = outPosition4D.w;
+  }
+  else {
+    error("Unknown dimension!");
   }
 }