Shading: Extend Musgrave node to other dimensions.

This patch extends Musgrave noise to operate in 1D, 2D, 3D, and 4D
space. The Color output was also removed because it was identical
to the Fac output.

Reviewed By: brecht

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

7 files changed, 877 insertions, 88 deletions

diff --git a/source/blender/blenkernel/BKE_blender_version.h b/source/blender/blenkernel/BKE_blender_version.h
index 24a48b2913b..b9ea85e7a00 100644
--- a/source/blender/blenkernel/BKE_blender_version.h
+++ b/source/blender/blenkernel/BKE_blender_version.h
@@ -27,7 +27,7 @@
  * \note Use #STRINGIFY() rather than defining with quotes.
  */
 #define BLENDER_VERSION 281
-#define BLENDER_SUBVERSION 9
+#define BLENDER_SUBVERSION 10
 /** Several breakages with 280, e.g. collections vs layers. */
 #define BLENDER_MINVERSION 280
 #define BLENDER_MINSUBVERSION 0
diff --git a/source/blender/blenloader/intern/versioning_cycles.c b/source/blender/blenloader/intern/versioning_cycles.c
index d4d940daba5..98f8820e4ad 100644
--- a/source/blender/blenloader/intern/versioning_cycles.c
+++ b/source/blender/blenloader/intern/versioning_cycles.c
@@ -911,6 +911,34 @@ static void update_mapping_node_inputs_and_properties(bNodeTree *ntree)
   }
 }
 
+/* The Musgrave node now has a dimension property. This property should
+ * be initialized to 3 by default.
+ */
+static void update_musgrave_node_dimensions(bNodeTree *ntree)
+{
+  for (bNode *node = ntree->nodes.first; node; node = node->next) {
+    if (node->type == SH_NODE_TEX_MUSGRAVE) {
+      NodeTexMusgrave *tex = (NodeTexMusgrave *)node->storage;
+      tex->dimensions = 3;
+    }
+  }
+}
+
+/* The Color output of the Musgrave node has been removed. Previously, this
+ * output was just equal to the Fac output. To correct this, we move links
+ * from the Color output to the Fac output if they exist.
+ */
+static void update_musgrave_node_color_output(bNodeTree *ntree)
+{
+  LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
+    if (link->fromnode && link->fromnode->type == SH_NODE_TEX_MUSGRAVE) {
+      if (link->fromsock->type == SOCK_RGBA) {
+        link->fromsock = link->fromsock->next;
+      }
+    }
+  }
+}
+
 void blo_do_versions_cycles(FileData *UNUSED(fd), Library *UNUSED(lib), Main *bmain)
 {
   /* Particle shape shared with Eevee. */
@@ -952,6 +980,15 @@ void blo_do_versions_cycles(FileData *UNUSED(fd), Library *UNUSED(lib), Main *bm
     }
     FOREACH_NODETREE_END;
   }
+
+  if (!MAIN_VERSION_ATLEAST(bmain, 281, 10)) {
+    FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
+      if (ntree->type == NTREE_SHADER) {
+        update_musgrave_node_color_output(ntree);
+      }
+    }
+    FOREACH_NODETREE_END;
+  }
 }
 
 void do_versions_after_linking_cycles(Main *bmain)
@@ -1101,4 +1138,13 @@ void do_versions_after_linking_cycles(Main *bmain)
     }
     FOREACH_NODETREE_END;
   }
+
+  if (!MAIN_VERSION_ATLEAST(bmain, 281, 10)) {
+    FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
+      if (ntree->type == NTREE_SHADER) {
+        update_musgrave_node_dimensions(ntree);
+      }
+    }
+    FOREACH_NODETREE_END;
+  }
 }
diff --git a/source/blender/editors/space_node/drawnode.c b/source/blender/editors/space_node/drawnode.c
index 23d452412ea..c707a1eed92 100644
--- a/source/blender/editors/space_node/drawnode.c
+++ b/source/blender/editors/space_node/drawnode.c
@@ -908,6 +908,7 @@ static void node_shader_buts_tex_wave(uiLayout *layout, bContext *UNUSED(C), Poi
 
 static void node_shader_buts_tex_musgrave(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
 {
+  uiItemR(layout, ptr, "musgrave_dimensions", 0, "", ICON_NONE);
   uiItemR(layout, ptr, "musgrave_type", 0, "", ICON_NONE);
 }
 
diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_tex_musgrave.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_tex_musgrave.glsl
index 52332c45c3d..7ecca286acd 100644
--- a/source/blender/gpu/shaders/material/gpu_shader_material_tex_musgrave.glsl
+++ b/source/blender/gpu/shaders/material/gpu_shader_material_tex_musgrave.glsl
@@ -1,4 +1,4 @@
-/* Musgrave fBm
+/* 1D Musgrave fBm
  *
  * H: fractal increment parameter
  * lacunarity: gap between successive frequencies
@@ -7,9 +7,465 @@
  * from "Texturing and Modelling: A procedural approach"
  */
 
-float noise_musgrave_fBm(vec3 p, float H, float lacunarity, float octaves)
+void node_tex_musgrave_fBm_1d(vec3 co,
+                              float w,
+                              float scale,
+                              float detail,
+                              float dimension,
+                              float lac,
+                              float offset,
+                              float gain,
+                              out float fac)
 {
-  float rmd;
+  float p = w * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float value = 0.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < int(octaves); i++) {
+    value += snoise(p) * pwr;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value += rmd * snoise(p) * pwr;
+  }
+
+  fac = value;
+}
+
+/* 1D Musgrave Multifractal
+ *
+ * H: highest fractal dimension
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ */
+
+void node_tex_musgrave_multi_fractal_1d(vec3 co,
+                                        float w,
+                                        float scale,
+                                        float detail,
+                                        float dimension,
+                                        float lac,
+                                        float offset,
+                                        float gain,
+                                        out float fac)
+{
+  float p = w * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float value = 1.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < int(octaves); i++) {
+    value *= (pwr * snoise(p) + 1.0);
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value *= (rmd * pwr * snoise(p) + 1.0); /* correct? */
+  }
+
+  fac = value;
+}
+
+/* 1D Musgrave Heterogeneous Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+void node_tex_musgrave_hetero_terrain_1d(vec3 co,
+                                         float w,
+                                         float scale,
+                                         float detail,
+                                         float dimension,
+                                         float lac,
+                                         float offset,
+                                         float gain,
+                                         out float fac)
+{
+  float p = w * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  /* first unscaled octave of function; later octaves are scaled */
+  float value = offset + snoise(p);
+  p *= lacunarity;
+
+  for (int i = 1; i < int(octaves); i++) {
+    float increment = (snoise(p) + offset) * pwr * value;
+    value += increment;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    float increment = (snoise(p) + offset) * pwr * value;
+    value += rmd * increment;
+  }
+
+  fac = value;
+}
+
+/* 1D Hybrid Additive/Multiplicative Multifractal Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+void node_tex_musgrave_hybrid_multi_fractal_1d(vec3 co,
+                                               float w,
+                                               float scale,
+                                               float detail,
+                                               float dimension,
+                                               float lac,
+                                               float offset,
+                                               float gain,
+                                               out float fac)
+{
+  float p = w * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float value = snoise(p) + offset;
+  float weight = gain * value;
+  p *= lacunarity;
+
+  for (int i = 1; (weight > 0.001f) && (i < int(octaves)); i++) {
+    if (weight > 1.0) {
+      weight = 1.0;
+    }
+
+    float signal = (snoise(p) + offset) * pwr;
+    pwr *= pwHL;
+    value += weight * signal;
+    weight *= gain * signal;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value += rmd * ((snoise(p) + offset) * pwr);
+  }
+
+  fac = value;
+}
+
+/* 1D Ridged Multifractal Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+void node_tex_musgrave_ridged_multi_fractal_1d(vec3 co,
+                                               float w,
+                                               float scale,
+                                               float detail,
+                                               float dimension,
+                                               float lac,
+                                               float offset,
+                                               float gain,
+                                               out float fac)
+{
+  float p = w * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float signal = offset - abs(snoise(p));
+  signal *= signal;
+  float value = signal;
+  float weight = 1.0;
+
+  for (int i = 1; i < int(octaves); i++) {
+    p *= lacunarity;
+    weight = clamp(signal * gain, 0.0, 1.0);
+    signal = offset - abs(snoise(p));
+    signal *= signal;
+    signal *= weight;
+    value += signal * pwr;
+    pwr *= pwHL;
+  }
+
+  fac = value;
+}
+
+/* 2D Musgrave fBm
+ *
+ * H: fractal increment parameter
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ *
+ * from "Texturing and Modelling: A procedural approach"
+ */
+
+void node_tex_musgrave_fBm_2d(vec3 co,
+                              float w,
+                              float scale,
+                              float detail,
+                              float dimension,
+                              float lac,
+                              float offset,
+                              float gain,
+                              out float fac)
+{
+  vec2 p = co.xy * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float value = 0.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < int(octaves); i++) {
+    value += snoise(p) * pwr;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value += rmd * snoise(p) * pwr;
+  }
+
+  fac = value;
+}
+
+/* 2D Musgrave Multifractal
+ *
+ * H: highest fractal dimension
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ */
+
+void node_tex_musgrave_multi_fractal_2d(vec3 co,
+                                        float w,
+                                        float scale,
+                                        float detail,
+                                        float dimension,
+                                        float lac,
+                                        float offset,
+                                        float gain,
+                                        out float fac)
+{
+  vec2 p = co.xy * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float value = 1.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < int(octaves); i++) {
+    value *= (pwr * snoise(p) + 1.0);
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value *= (rmd * pwr * snoise(p) + 1.0); /* correct? */
+  }
+
+  fac = value;
+}
+
+/* 2D Musgrave Heterogeneous Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+void node_tex_musgrave_hetero_terrain_2d(vec3 co,
+                                         float w,
+                                         float scale,
+                                         float detail,
+                                         float dimension,
+                                         float lac,
+                                         float offset,
+                                         float gain,
+                                         out float fac)
+{
+  vec2 p = co.xy * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  /* first unscaled octave of function; later octaves are scaled */
+  float value = offset + snoise(p);
+  p *= lacunarity;
+
+  for (int i = 1; i < int(octaves); i++) {
+    float increment = (snoise(p) + offset) * pwr * value;
+    value += increment;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    float increment = (snoise(p) + offset) * pwr * value;
+    value += rmd * increment;
+  }
+
+  fac = value;
+}
+
+/* 2D Hybrid Additive/Multiplicative Multifractal Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+void node_tex_musgrave_hybrid_multi_fractal_2d(vec3 co,
+                                               float w,
+                                               float scale,
+                                               float detail,
+                                               float dimension,
+                                               float lac,
+                                               float offset,
+                                               float gain,
+                                               out float fac)
+{
+  vec2 p = co.xy * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float value = snoise(p) + offset;
+  float weight = gain * value;
+  p *= lacunarity;
+
+  for (int i = 1; (weight > 0.001f) && (i < int(octaves)); i++) {
+    if (weight > 1.0) {
+      weight = 1.0;
+    }
+
+    float signal = (snoise(p) + offset) * pwr;
+    pwr *= pwHL;
+    value += weight * signal;
+    weight *= gain * signal;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value += rmd * ((snoise(p) + offset) * pwr);
+  }
+
+  fac = value;
+}
+
+/* 2D Ridged Multifractal Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+void node_tex_musgrave_ridged_multi_fractal_2d(vec3 co,
+                                               float w,
+                                               float scale,
+                                               float detail,
+                                               float dimension,
+                                               float lac,
+                                               float offset,
+                                               float gain,
+                                               out float fac)
+{
+  vec2 p = co.xy * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float signal = offset - abs(snoise(p));
+  signal *= signal;
+  float value = signal;
+  float weight = 1.0;
+
+  for (int i = 1; i < int(octaves); i++) {
+    p *= lacunarity;
+    weight = clamp(signal * gain, 0.0, 1.0);
+    signal = offset - abs(snoise(p));
+    signal *= signal;
+    signal *= weight;
+    value += signal * pwr;
+    pwr *= pwHL;
+  }
+
+  fac = value;
+}
+
+/* 3D Musgrave fBm
+ *
+ * H: fractal increment parameter
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ *
+ * from "Texturing and Modelling: A procedural approach"
+ */
+
+void node_tex_musgrave_fBm_3d(vec3 co,
+                              float w,
+                              float scale,
+                              float detail,
+                              float dimension,
+                              float lac,
+                              float offset,
+                              float gain,
+                              out float fac)
+{
+  vec3 p = co * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
   float value = 0.0;
   float pwr = 1.0;
   float pwHL = pow(lacunarity, -H);
@@ -20,24 +476,36 @@ float noise_musgrave_fBm(vec3 p, float H, float lacunarity, float octaves)
     p *= lacunarity;
   }
 
-  rmd = octaves - floor(octaves);
+  float rmd = octaves - floor(octaves);
   if (rmd != 0.0) {
     value += rmd * snoise(p) * pwr;
   }
 
-  return value;
+  fac = value;
 }
 
-/* Musgrave Multifractal
+/* 3D Musgrave Multifractal
  *
  * H: highest fractal dimension
  * lacunarity: gap between successive frequencies
  * octaves: number of frequencies in the fBm
  */
 
-float noise_musgrave_multi_fractal(vec3 p, float H, float lacunarity, float octaves)
+void node_tex_musgrave_multi_fractal_3d(vec3 co,
+                                        float w,
+                                        float scale,
+                                        float detail,
+                                        float dimension,
+                                        float lac,
+                                        float offset,
+                                        float gain,
+                                        out float fac)
 {
-  float rmd;
+  vec3 p = co * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
   float value = 1.0;
   float pwr = 1.0;
   float pwHL = pow(lacunarity, -H);
@@ -48,15 +516,15 @@ float noise_musgrave_multi_fractal(vec3 p, float H, float lacunarity, float octa
     p *= lacunarity;
   }
 
-  rmd = octaves - floor(octaves);
+  float rmd = octaves - floor(octaves);
   if (rmd != 0.0) {
     value *= (rmd * pwr * snoise(p) + 1.0); /* correct? */
   }
 
-  return value;
+  fac = value;
 }
 
-/* Musgrave Heterogeneous Terrain
+/* 3D Musgrave Heterogeneous Terrain
  *
  * H: fractal dimension of the roughest area
  * lacunarity: gap between successive frequencies
@@ -64,33 +532,45 @@ float noise_musgrave_multi_fractal(vec3 p, float H, float lacunarity, float octa
  * offset: raises the terrain from `sea level'
  */
 
-float noise_musgrave_hetero_terrain(vec3 p, float H, float lacunarity, float octaves, float offset)
+void node_tex_musgrave_hetero_terrain_3d(vec3 co,
+                                         float w,
+                                         float scale,
+                                         float detail,
+                                         float dimension,
+                                         float lac,
+                                         float offset,
+                                         float gain,
+                                         out float fac)
 {
-  float value, increment, rmd;
+  vec3 p = co * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
   float pwHL = pow(lacunarity, -H);
   float pwr = pwHL;
 
   /* first unscaled octave of function; later octaves are scaled */
-  value = offset + snoise(p);
+  float value = offset + snoise(p);
   p *= lacunarity;
 
   for (int i = 1; i < int(octaves); i++) {
-    increment = (snoise(p) + offset) * pwr * value;
+    float increment = (snoise(p) + offset) * pwr * value;
     value += increment;
     pwr *= pwHL;
     p *= lacunarity;
   }
 
-  rmd = octaves - floor(octaves);
+  float rmd = octaves - floor(octaves);
   if (rmd != 0.0) {
-    increment = (snoise(p) + offset) * pwr * value;
+    float increment = (snoise(p) + offset) * pwr * value;
     value += rmd * increment;
   }
 
-  return value;
+  fac = value;
 }
 
-/* Hybrid Additive/Multiplicative Multifractal Terrain
+/* 3D Hybrid Additive/Multiplicative Multifractal Terrain
  *
  * H: fractal dimension of the roughest area
  * lacunarity: gap between successive frequencies
@@ -98,15 +578,26 @@ float noise_musgrave_hetero_terrain(vec3 p, float H, float lacunarity, float oct
  * offset: raises the terrain from `sea level'
  */
 
-float noise_musgrave_hybrid_multi_fractal(
-    vec3 p, float H, float lacunarity, float octaves, float offset, float gain)
+void node_tex_musgrave_hybrid_multi_fractal_3d(vec3 co,
+                                               float w,
+                                               float scale,
+                                               float detail,
+                                               float dimension,
+                                               float lac,
+                                               float offset,
+                                               float gain,
+                                               out float fac)
 {
-  float result, signal, weight, rmd;
+  vec3 p = co * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
   float pwHL = pow(lacunarity, -H);
   float pwr = pwHL;
 
-  result = snoise(p) + offset;
-  weight = gain * result;
+  float value = snoise(p) + offset;
+  float weight = gain * value;
   p *= lacunarity;
 
   for (int i = 1; (weight > 0.001f) && (i < int(octaves)); i++) {
@@ -114,22 +605,22 @@ float noise_musgrave_hybrid_multi_fractal(
       weight = 1.0;
     }
 
-    signal = (snoise(p) + offset) * pwr;
+    float signal = (snoise(p) + offset) * pwr;
     pwr *= pwHL;
-    result += weight * signal;
+    value += weight * signal;
     weight *= gain * signal;
     p *= lacunarity;
   }
 
-  rmd = octaves - floor(octaves);
+  float rmd = octaves - floor(octaves);
   if (rmd != 0.0) {
-    result += rmd * ((snoise(p) + offset) * pwr);
+    value += rmd * ((snoise(p) + offset) * pwr);
   }
 
-  return result;
+  fac = value;
 }
 
-/* Ridged Multifractal Terrain
+/* 3D Ridged Multifractal Terrain
  *
  * H: fractal dimension of the roughest area
  * lacunarity: gap between successive frequencies
@@ -137,17 +628,28 @@ float noise_musgrave_hybrid_multi_fractal(
  * offset: raises the terrain from `sea level'
  */
 
-float noise_musgrave_ridged_multi_fractal(
-    vec3 p, float H, float lacunarity, float octaves, float offset, float gain)
+void node_tex_musgrave_ridged_multi_fractal_3d(vec3 co,
+                                               float w,
+                                               float scale,
+                                               float detail,
+                                               float dimension,
+                                               float lac,
+                                               float offset,
+                                               float gain,
+                                               out float fac)
 {
-  float result, signal, weight;
+  vec3 p = co * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
   float pwHL = pow(lacunarity, -H);
   float pwr = pwHL;
 
-  signal = offset - abs(snoise(p));
+  float signal = offset - abs(snoise(p));
   signal *= signal;
-  result = signal;
-  weight = 1.0;
+  float value = signal;
+  float weight = 1.0;
 
   for (int i = 1; i < int(octaves); i++) {
     p *= lacunarity;
@@ -155,54 +657,231 @@ float noise_musgrave_ridged_multi_fractal(
     signal = offset - abs(snoise(p));
     signal *= signal;
     signal *= weight;
-    result += signal * pwr;
+    value += signal * pwr;
     pwr *= pwHL;
   }
 
-  return result;
+  fac = value;
 }
 
-float svm_musgrave(int type,
-                   float dimension,
-                   float lacunarity,
-                   float octaves,
-                   float offset,
-                   float intensity,
-                   float gain,
-                   vec3 p)
+/* 4D Musgrave fBm
+ *
+ * H: fractal increment parameter
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ *
+ * from "Texturing and Modelling: A procedural approach"
+ */
+
+void node_tex_musgrave_fBm_4d(vec3 co,
+                              float w,
+                              float scale,
+                              float detail,
+                              float dimension,
+                              float lac,
+                              float offset,
+                              float gain,
+                              out float fac)
 {
-  if (type == 0 /* NODE_MUSGRAVE_MULTIFRACTAL */) {
-    return intensity * noise_musgrave_multi_fractal(p, dimension, lacunarity, octaves);
+  vec4 p = vec4(co, w) * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float value = 0.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < int(octaves); i++) {
+    value += snoise(p) * pwr;
+    pwr *= pwHL;
+    p *= lacunarity;
   }
-  else if (type == 1 /* NODE_MUSGRAVE_FBM */) {
-    return intensity * noise_musgrave_fBm(p, dimension, lacunarity, octaves);
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value += rmd * snoise(p) * pwr;
   }
-  else if (type == 2 /* NODE_MUSGRAVE_HYBRID_MULTIFRACTAL */) {
-    return intensity *
-           noise_musgrave_hybrid_multi_fractal(p, dimension, lacunarity, octaves, offset, gain);
+
+  fac = value;
+}
+
+/* 4D Musgrave Multifractal
+ *
+ * H: highest fractal dimension
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ */
+
+void node_tex_musgrave_multi_fractal_4d(vec3 co,
+                                        float w,
+                                        float scale,
+                                        float detail,
+                                        float dimension,
+                                        float lac,
+                                        float offset,
+                                        float gain,
+                                        out float fac)
+{
+  vec4 p = vec4(co, w) * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float value = 1.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < int(octaves); i++) {
+    value *= (pwr * snoise(p) + 1.0);
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value *= (rmd * pwr * snoise(p) + 1.0); /* correct? */
+  }
+
+  fac = value;
+}
+
+/* 4D Musgrave Heterogeneous Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+void node_tex_musgrave_hetero_terrain_4d(vec3 co,
+                                         float w,
+                                         float scale,
+                                         float detail,
+                                         float dimension,
+                                         float lac,
+                                         float offset,
+                                         float gain,
+                                         out float fac)
+{
+  vec4 p = vec4(co, w) * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  /* first unscaled octave of function; later octaves are scaled */
+  float value = offset + snoise(p);
+  p *= lacunarity;
+
+  for (int i = 1; i < int(octaves); i++) {
+    float increment = (snoise(p) + offset) * pwr * value;
+    value += increment;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    float increment = (snoise(p) + offset) * pwr * value;
+    value += rmd * increment;
   }
-  else if (type == 3 /* NODE_MUSGRAVE_RIDGED_MULTIFRACTAL */) {
-    return intensity *
-           noise_musgrave_ridged_multi_fractal(p, dimension, lacunarity, octaves, offset, gain);
+
+  fac = value;
+}
+
+/* 4D Hybrid Additive/Multiplicative Multifractal Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+void node_tex_musgrave_hybrid_multi_fractal_4d(vec3 co,
+                                               float w,
+                                               float scale,
+                                               float detail,
+                                               float dimension,
+                                               float lac,
+                                               float offset,
+                                               float gain,
+                                               out float fac)
+{
+  vec4 p = vec4(co, w) * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float value = snoise(p) + offset;
+  float weight = gain * value;
+  p *= lacunarity;
+
+  for (int i = 1; (weight > 0.001f) && (i < int(octaves)); i++) {
+    if (weight > 1.0) {
+      weight = 1.0;
+    }
+
+    float signal = (snoise(p) + offset) * pwr;
+    pwr *= pwHL;
+    value += weight * signal;
+    weight *= gain * signal;
+    p *= lacunarity;
   }
-  else if (type == 4 /* NODE_MUSGRAVE_HETERO_TERRAIN */) {
-    return intensity * noise_musgrave_hetero_terrain(p, dimension, lacunarity, octaves, offset);
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value += rmd * ((snoise(p) + offset) * pwr);
   }
-  return 0.0;
+
+  fac = value;
 }
 
-void node_tex_musgrave(vec3 co,
-                       float scale,
-                       float detail,
-                       float dimension,
-                       float lacunarity,
-                       float offset,
-                       float gain,
-                       float type,
-                       out vec4 color,
-                       out float fac)
+/* 4D Ridged Multifractal Terrain
+ *
+ * H: fractal dimension of the roughest area
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ * offset: raises the terrain from `sea level'
+ */
+
+void node_tex_musgrave_ridged_multi_fractal_4d(vec3 co,
+                                               float w,
+                                               float scale,
+                                               float detail,
+                                               float dimension,
+                                               float lac,
+                                               float offset,
+                                               float gain,
+                                               out float fac)
 {
-  fac = svm_musgrave(int(type), dimension, lacunarity, detail, offset, 1.0, gain, co *scale);
+  vec4 p = vec4(co, w) * scale;
+  float H = max(dimension, 1e-5);
+  float octaves = clamp(detail, 0.0, 16.0);
+  float lacunarity = max(lac, 1e-5);
+
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float signal = offset - abs(snoise(p));
+  signal *= signal;
+  float value = signal;
+  float weight = 1.0;
+
+  for (int i = 1; i < int(octaves); i++) {
+    p *= lacunarity;
+    weight = clamp(signal * gain, 0.0, 1.0);
+    signal = offset - abs(snoise(p));
+    signal *= signal;
+    signal *= weight;
+    value += signal * pwr;
+    pwr *= pwHL;
+  }
 
-  color = vec4(fac, fac, fac, 1.0);
+  fac = value;
 }
diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h
index 6d2b278472f..b4e12484bdc 100644
--- a/source/blender/makesdna/DNA_node_types.h
+++ b/source/blender/makesdna/DNA_node_types.h
@@ -885,7 +885,7 @@ typedef struct NodeTexVoronoi {
 typedef struct NodeTexMusgrave {
   NodeTexBase base;
   int musgrave_type;
-  char _pad[4];
+  int dimensions;
 } NodeTexMusgrave;
 
 typedef struct NodeTexWave {
diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c
index 0598f4807ec..a6481341868 100644
--- a/source/blender/makesrna/intern/rna_nodetree.c
+++ b/source/blender/makesrna/intern/rna_nodetree.c
@@ -4389,11 +4389,17 @@ static void def_sh_tex_musgrave(StructRNA *srna)
   RNA_def_struct_sdna_from(srna, "NodeTexMusgrave", "storage");
   def_sh_tex(srna);
 
+  prop = RNA_def_property(srna, "musgrave_dimensions", PROP_ENUM, PROP_NONE);
+  RNA_def_property_enum_sdna(prop, NULL, "dimensions");
+  RNA_def_property_enum_items(prop, rna_enum_node_tex_dimensions_items);
+  RNA_def_property_ui_text(prop, "Dimensions", "");
+  RNA_def_property_update(prop, 0, "rna_ShaderNode_socket_update");
+
   prop = RNA_def_property(srna, "musgrave_type", PROP_ENUM, PROP_NONE);
   RNA_def_property_enum_sdna(prop, NULL, "musgrave_type");
   RNA_def_property_enum_items(prop, prop_musgrave_type);
   RNA_def_property_ui_text(prop, "Type", "");
-  RNA_def_property_update(prop, 0, "rna_Node_update");
+  RNA_def_property_update(prop, 0, "rna_ShaderNode_socket_update");
 }
 
 static void def_sh_tex_voronoi(StructRNA *srna)
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c
index 1a959b8faa8..daf4053f182 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c
@@ -23,6 +23,7 @@
 
 static bNodeSocketTemplate sh_node_tex_musgrave_in[] = {
     {SOCK_VECTOR, 1, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {SOCK_FLOAT, 1, N_("W"), 0.0f, 0.0f, 0.0f, 0.0f, -1000.0f, 1000.0f},
     {SOCK_FLOAT, 1, N_("Scale"), 5.0f, 0.0f, 0.0f, 0.0f, -1000.0f, 1000.0f},
     {SOCK_FLOAT, 1, N_("Detail"), 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 16.0f},
     {SOCK_FLOAT, 1, N_("Dimension"), 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@@ -33,17 +34,6 @@ static bNodeSocketTemplate sh_node_tex_musgrave_in[] = {
 };
 
 static bNodeSocketTemplate sh_node_tex_musgrave_out[] = {
-    {SOCK_RGBA,
-     0,
-     N_("Color"),
-     0.0f,
-     0.0f,
-     0.0f,
-     0.0f,
-     0.0f,
-     1.0f,
-     PROP_NONE,
-     SOCK_NO_INTERNAL_LINK},
     {SOCK_FLOAT,
      0,
      N_("Fac"),
@@ -64,6 +54,7 @@ static void node_shader_init_tex_musgrave(bNodeTree *UNUSED(ntree), bNode *node)
   BKE_texture_mapping_default(&tex->base.tex_mapping, TEXMAP_TYPE_POINT);
   BKE_texture_colormapping_default(&tex->base.color_mapping);
   tex->musgrave_type = SHD_MUSGRAVE_FBM;
+  tex->dimensions = 3;
 
   node->storage = tex;
 }
@@ -78,12 +69,77 @@ static int node_shader_gpu_tex_musgrave(GPUMaterial *mat,
   node_shader_gpu_tex_mapping(mat, node, in, out);
 
   NodeTexMusgrave *tex = (NodeTexMusgrave *)node->storage;
-  float type = tex->musgrave_type;
+  int dimensions = tex->dimensions;
+  int type = tex->musgrave_type;
+
+  static const char *names[][5] = {
+      [SHD_MUSGRAVE_MULTIFRACTAL] =
+          {
+              "",
+              "node_tex_musgrave_multi_fractal_1d",
+              "node_tex_musgrave_multi_fractal_2d",
+              "node_tex_musgrave_multi_fractal_3d",
+              "node_tex_musgrave_multi_fractal_4d",
+          },
+      [SHD_MUSGRAVE_FBM] =
+          {
+              "",
+              "node_tex_musgrave_fBm_1d",
+              "node_tex_musgrave_fBm_2d",
+              "node_tex_musgrave_fBm_3d",
+              "node_tex_musgrave_fBm_4d",
+          },
+      [SHD_MUSGRAVE_HYBRID_MULTIFRACTAL] =
+          {
+              "",
+              "node_tex_musgrave_hybrid_multi_fractal_1d",
+              "node_tex_musgrave_hybrid_multi_fractal_2d",
+              "node_tex_musgrave_hybrid_multi_fractal_3d",
+              "node_tex_musgrave_hybrid_multi_fractal_4d",
+          },
+      [SHD_MUSGRAVE_RIDGED_MULTIFRACTAL] =
+          {
+              "",
+              "node_tex_musgrave_ridged_multi_fractal_1d",
+              "node_tex_musgrave_ridged_multi_fractal_2d",
+              "node_tex_musgrave_ridged_multi_fractal_3d",
+              "node_tex_musgrave_ridged_multi_fractal_4d",
+          },
+      [SHD_MUSGRAVE_HETERO_TERRAIN] =
+          {
+              "",
+              "node_tex_musgrave_hetero_terrain_1d",
+              "node_tex_musgrave_hetero_terrain_2d",
+              "node_tex_musgrave_hetero_terrain_3d",
+              "node_tex_musgrave_hetero_terrain_4d",
+          },
+  };
+
+  BLI_assert(type >= 0 && type < 5);
+  BLI_assert(dimensions > 0 && dimensions < 5);
+
+  return GPU_stack_link(mat, node, names[type][dimensions], in, out);
+}
+
+static void node_shader_update_tex_musgrave(bNodeTree *UNUSED(ntree), bNode *node)
+{
+  NodeTexMusgrave *tex = (NodeTexMusgrave *)node->storage;
+
+  bNodeSocket *inVectorSock = nodeFindSocket(node, SOCK_IN, "Vector");
+  bNodeSocket *inWSock = nodeFindSocket(node, SOCK_IN, "W");
+  bNodeSocket *inOffsetSock = nodeFindSocket(node, SOCK_IN, "Offset");
+  bNodeSocket *inGainSock = nodeFindSocket(node, SOCK_IN, "Gain");
 
-  return GPU_stack_link(mat, node, "node_tex_musgrave", in, out, GPU_constant(&type));
+  nodeSetSocketAvailability(inVectorSock, tex->dimensions != 1);
+  nodeSetSocketAvailability(inWSock, tex->dimensions == 1 || tex->dimensions == 4);
+  nodeSetSocketAvailability(inOffsetSock,
+                            tex->musgrave_type != SHD_MUSGRAVE_MULTIFRACTAL &&
+                                tex->musgrave_type != SHD_MUSGRAVE_FBM);
+  nodeSetSocketAvailability(inGainSock,
+                            tex->musgrave_type == SHD_MUSGRAVE_HYBRID_MULTIFRACTAL &&
+                                tex->musgrave_type != SHD_MUSGRAVE_RIDGED_MULTIFRACTAL);
 }
 
-/* node type definition */
 void register_node_type_sh_tex_musgrave(void)
 {
   static bNodeType ntype;
@@ -95,6 +151,7 @@ void register_node_type_sh_tex_musgrave(void)
   node_type_storage(
       &ntype, "NodeTexMusgrave", node_free_standard_storage, node_copy_standard_storage);
   node_type_gpu(&ntype, node_shader_gpu_tex_musgrave);
+  node_type_update(&ntype, node_shader_update_tex_musgrave);
 
   nodeRegisterType(&ntype);
 }