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

6 files changed, 1395 insertions, 217 deletions

diff --git a/intern/cycles/blender/blender_shader.cpp b/intern/cycles/blender/blender_shader.cpp
index 4d7d0910765..7e784527a21 100644
--- a/intern/cycles/blender/blender_shader.cpp
+++ b/intern/cycles/blender/blender_shader.cpp
@@ -785,11 +785,12 @@ static ShaderNode *add_node(Scene *scene,
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexMusgrave)) {
     BL::ShaderNodeTexMusgrave b_musgrave_node(b_node);
-    MusgraveTextureNode *musgrave = new MusgraveTextureNode();
-    musgrave->type = (NodeMusgraveType)b_musgrave_node.musgrave_type();
+    MusgraveTextureNode *musgrave_node = new MusgraveTextureNode();
+    musgrave_node->type = (NodeMusgraveType)b_musgrave_node.musgrave_type();
+    musgrave_node->dimensions = b_musgrave_node.musgrave_dimensions();
     BL::TexMapping b_texture_mapping(b_musgrave_node.texture_mapping());
-    get_tex_mapping(&musgrave->tex_mapping, b_texture_mapping);
-    node = musgrave;
+    get_tex_mapping(&musgrave_node->tex_mapping, b_texture_mapping);
+    node = musgrave_node;
   }
   else if (b_node.is_a(&RNA_ShaderNodeTexCoord)) {
     BL::ShaderNodeTexCoord b_tex_coord_node(b_node);
diff --git a/intern/cycles/kernel/shaders/node_musgrave_texture.osl b/intern/cycles/kernel/shaders/node_musgrave_texture.osl
index 0bf462e2103..8861f9a671a 100644
--- a/intern/cycles/kernel/shaders/node_musgrave_texture.osl
+++ b/intern/cycles/kernel/shaders/node_musgrave_texture.osl
@@ -16,8 +16,342 @@
 
 #include "stdosl.h"
 #include "node_noise.h"
+#include "vector2.h"
+#include "vector4.h"
 
-/* Musgrave fBm
+#define vector3 point
+
+/* 1D 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"
+ */
+
+float noise_musgrave_fBm_1d(float co, float H, float lacunarity, float octaves)
+{
+  float p = co;
+  float value = 0.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < (int)octaves; i++) {
+    value += safe_snoise(p) * pwr;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value += rmd * safe_snoise(p) * pwr;
+  }
+
+  return value;
+}
+
+/* 1D Musgrave Multifractal
+ *
+ * H: highest fractal dimension
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ */
+
+float noise_musgrave_multi_fractal_1d(float co, float H, float lacunarity, float octaves)
+{
+  float p = co;
+  float value = 1.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < (int)octaves; i++) {
+    value *= (pwr * safe_snoise(p) + 1.0);
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value *= (rmd * pwr * safe_snoise(p) + 1.0); /* correct? */
+  }
+
+  return 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'
+ */
+
+float noise_musgrave_hetero_terrain_1d(
+    float co, float H, float lacunarity, float octaves, float offset)
+{
+  float p = co;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  /* first unscaled octave of function; later octaves are scaled */
+  float value = offset + safe_snoise(p);
+  p *= lacunarity;
+
+  for (int i = 1; i < (int)octaves; i++) {
+    float increment = (safe_snoise(p) + offset) * pwr * value;
+    value += increment;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    float increment = (safe_snoise(p) + offset) * pwr * value;
+    value += rmd * increment;
+  }
+
+  return 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'
+ */
+
+float noise_musgrave_hybrid_multi_fractal_1d(
+    float co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float p = co;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float value = safe_snoise(p) + offset;
+  float weight = gain * value;
+  p *= lacunarity;
+
+  for (int i = 1; (weight > 0.001) && (i < (int)octaves); i++) {
+    if (weight > 1.0) {
+      weight = 1.0;
+    }
+
+    float signal = (safe_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 * ((safe_snoise(p) + offset) * pwr);
+  }
+
+  return 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'
+ */
+
+float noise_musgrave_ridged_multi_fractal_1d(
+    float co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float p = co;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float signal = offset - fabs(safe_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 - fabs(safe_snoise(p));
+    signal *= signal;
+    signal *= weight;
+    value += signal * pwr;
+    pwr *= pwHL;
+  }
+
+  return 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"
+ */
+
+float noise_musgrave_fBm_2d(vector2 co, float H, float lacunarity, float octaves)
+{
+  vector2 p = co;
+  float value = 0.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < (int)octaves; i++) {
+    value += safe_snoise(p) * pwr;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value += rmd * safe_snoise(p) * pwr;
+  }
+
+  return value;
+}
+
+/* 2D Musgrave Multifractal
+ *
+ * H: highest fractal dimension
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ */
+
+float noise_musgrave_multi_fractal_2d(vector2 co, float H, float lacunarity, float octaves)
+{
+  vector2 p = co;
+  float value = 1.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < (int)octaves; i++) {
+    value *= (pwr * safe_snoise(p) + 1.0);
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value *= (rmd * pwr * safe_snoise(p) + 1.0); /* correct? */
+  }
+
+  return 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'
+ */
+
+float noise_musgrave_hetero_terrain_2d(
+    vector2 co, float H, float lacunarity, float octaves, float offset)
+{
+  vector2 p = co;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  /* first unscaled octave of function; later octaves are scaled */
+  float value = offset + safe_snoise(p);
+  p *= lacunarity;
+
+  for (int i = 1; i < (int)octaves; i++) {
+    float increment = (safe_snoise(p) + offset) * pwr * value;
+    value += increment;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    float increment = (safe_snoise(p) + offset) * pwr * value;
+    value += rmd * increment;
+  }
+
+  return 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'
+ */
+
+float noise_musgrave_hybrid_multi_fractal_2d(
+    vector2 co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  vector2 p = co;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float value = safe_snoise(p) + offset;
+  float weight = gain * value;
+  p *= lacunarity;
+
+  for (int i = 1; (weight > 0.001) && (i < (int)octaves); i++) {
+    if (weight > 1.0) {
+      weight = 1.0;
+    }
+
+    float signal = (safe_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 * ((safe_snoise(p) + offset) * pwr);
+  }
+
+  return 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'
+ */
+
+float noise_musgrave_ridged_multi_fractal_2d(
+    vector2 co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  vector2 p = co;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float signal = offset - fabs(safe_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 - fabs(safe_snoise(p));
+    signal *= signal;
+    signal *= weight;
+    value += signal * pwr;
+    pwr *= pwHL;
+  }
+
+  return value;
+}
+
+/* 3D Musgrave fBm
  *
  * H: fractal increment parameter
  * lacunarity: gap between successive frequencies
@@ -26,58 +360,56 @@
  * from "Texturing and Modelling: A procedural approach"
  */
 
-float noise_musgrave_fBm(point ip, float H, float lacunarity, float octaves)
+float noise_musgrave_fBm_3d(vector3 co, float H, float lacunarity, float octaves)
 {
-  float rmd;
+  vector3 p = co;
   float value = 0.0;
   float pwr = 1.0;
   float pwHL = pow(lacunarity, -H);
-  int i;
-  point p = ip;
 
-  for (i = 0; i < (int)octaves; i++) {
-    value += safe_noise(p) * pwr;
+  for (int i = 0; i < (int)octaves; i++) {
+    value += safe_snoise(p) * pwr;
     pwr *= pwHL;
     p *= lacunarity;
   }
 
-  rmd = octaves - floor(octaves);
-  if (rmd != 0.0)
-    value += rmd * safe_noise(p) * pwr;
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value += rmd * safe_snoise(p) * pwr;
+  }
 
   return 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(point ip, float H, float lacunarity, float octaves)
+float noise_musgrave_multi_fractal_3d(vector3 co, float H, float lacunarity, float octaves)
 {
-  float rmd;
+  vector3 p = co;
   float value = 1.0;
   float pwr = 1.0;
   float pwHL = pow(lacunarity, -H);
-  int i;
-  point p = ip;
 
-  for (i = 0; i < (int)octaves; i++) {
-    value *= (pwr * safe_noise(p) + 1.0);
+  for (int i = 0; i < (int)octaves; i++) {
+    value *= (pwr * safe_snoise(p) + 1.0);
     pwr *= pwHL;
     p *= lacunarity;
   }
 
-  rmd = octaves - floor(octaves);
-  if (rmd != 0.0)
-    value *= (rmd * pwr * safe_noise(p) + 1.0); /* correct? */
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value *= (rmd * pwr * safe_snoise(p) + 1.0); /* correct? */
+  }
 
   return value;
 }
 
-/* Musgrave Heterogeneous Terrain
+/* 3D Musgrave Heterogeneous Terrain
  *
  * H: fractal dimension of the roughest area
  * lacunarity: gap between successive frequencies
@@ -85,36 +417,34 @@ float noise_musgrave_multi_fractal(point ip, float H, float lacunarity, float oc
  * offset: raises the terrain from `sea level'
  */
 
-float noise_musgrave_hetero_terrain(
-    point ip, float H, float lacunarity, float octaves, float offset)
+float noise_musgrave_hetero_terrain_3d(
+    vector3 co, float H, float lacunarity, float octaves, float offset)
 {
-  float value, increment, rmd;
+  vector3 p = co;
   float pwHL = pow(lacunarity, -H);
   float pwr = pwHL;
-  int i;
-  point p = ip;
 
   /* first unscaled octave of function; later octaves are scaled */
-  value = offset + safe_noise(p);
+  float value = offset + safe_snoise(p);
   p *= lacunarity;
 
-  for (i = 1; i < (int)octaves; i++) {
-    increment = (safe_noise(p) + offset) * pwr * value;
+  for (int i = 1; i < (int)octaves; i++) {
+    float increment = (safe_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 = (safe_noise(p) + offset) * pwr * value;
+    float increment = (safe_snoise(p) + offset) * pwr * value;
     value += rmd * increment;
   }
 
   return value;
 }
 
-/* Hybrid Additive/Multiplicative Multifractal Terrain
+/* 3D Hybrid Additive/Multiplicative Multifractal Terrain
  *
  * H: fractal dimension of the roughest area
  * lacunarity: gap between successive frequencies
@@ -122,38 +452,38 @@ float noise_musgrave_hetero_terrain(
  * offset: raises the terrain from `sea level'
  */
 
-float noise_musgrave_hybrid_multi_fractal(
-    point ip, float H, float lacunarity, float octaves, float offset, float gain)
+float noise_musgrave_hybrid_multi_fractal_3d(
+    vector3 co, float H, float lacunarity, float octaves, float offset, float gain)
 {
-  float result, signal, weight, rmd;
+  vector3 p = co;
   float pwHL = pow(lacunarity, -H);
   float pwr = pwHL;
-  int i;
-  point p = ip;
 
-  result = safe_noise(p) + offset;
-  weight = gain * result;
+  float value = safe_snoise(p) + offset;
+  float weight = gain * value;
   p *= lacunarity;
 
-  for (i = 1; (weight > 0.001) && (i < (int)octaves); i++) {
-    if (weight > 1.0)
+  for (int i = 1; (weight > 0.001) && (i < (int)octaves); i++) {
+    if (weight > 1.0) {
       weight = 1.0;
+    }
 
-    signal = (safe_noise(p) + offset) * pwr;
+    float signal = (safe_snoise(p) + offset) * pwr;
     pwr *= pwHL;
-    result += weight * signal;
+    value += weight * signal;
     weight *= gain * signal;
     p *= lacunarity;
   }
 
-  rmd = octaves - floor(octaves);
-  if (rmd != 0.0)
-    result += rmd * ((safe_noise(p) + offset) * pwr);
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value += rmd * ((safe_snoise(p) + offset) * pwr);
+  }
 
-  return result;
+  return value;
 }
 
-/* Ridged Multifractal Terrain
+/* 3D Ridged Multifractal Terrain
  *
  * H: fractal dimension of the roughest area
  * lacunarity: gap between successive frequencies
@@ -161,73 +491,313 @@ float noise_musgrave_hybrid_multi_fractal(
  * offset: raises the terrain from `sea level'
  */
 
-float noise_musgrave_ridged_multi_fractal(
-    point ip, float H, float lacunarity, float octaves, float offset, float gain)
+float noise_musgrave_ridged_multi_fractal_3d(
+    vector3 co, float H, float lacunarity, float octaves, float offset, float gain)
 {
-  float result, signal, weight;
+  vector3 p = co;
   float pwHL = pow(lacunarity, -H);
   float pwr = pwHL;
-  int i;
-  point p = ip;
 
-  signal = offset - fabs(safe_noise(p));
+  float signal = offset - fabs(safe_snoise(p));
   signal *= signal;
-  result = signal;
-  weight = 1.0;
+  float value = signal;
+  float weight = 1.0;
 
-  for (i = 1; i < (int)octaves; i++) {
+  for (int i = 1; i < (int)octaves; i++) {
     p *= lacunarity;
     weight = clamp(signal * gain, 0.0, 1.0);
-    signal = offset - fabs(safe_noise(p));
+    signal = offset - fabs(safe_snoise(p));
     signal *= signal;
     signal *= weight;
-    result += signal * pwr;
+    value += signal * pwr;
+    pwr *= pwHL;
+  }
+
+  return value;
+}
+
+/* 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"
+ */
+
+float noise_musgrave_fBm_4d(vector4 co, float H, float lacunarity, float octaves)
+{
+  vector4 p = co;
+  float value = 0.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < (int)octaves; i++) {
+    value += safe_snoise(p) * pwr;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value += rmd * safe_snoise(p) * pwr;
+  }
+
+  return value;
+}
+
+/* 4D Musgrave Multifractal
+ *
+ * H: highest fractal dimension
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ */
+
+float noise_musgrave_multi_fractal_4d(vector4 co, float H, float lacunarity, float octaves)
+{
+  vector4 p = co;
+  float value = 1.0;
+  float pwr = 1.0;
+  float pwHL = pow(lacunarity, -H);
+
+  for (int i = 0; i < (int)octaves; i++) {
+    value *= (pwr * safe_snoise(p) + 1.0);
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    value *= (rmd * pwr * safe_snoise(p) + 1.0); /* correct? */
+  }
+
+  return 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'
+ */
+
+float noise_musgrave_hetero_terrain_4d(
+    vector4 co, float H, float lacunarity, float octaves, float offset)
+{
+  vector4 p = co;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  /* first unscaled octave of function; later octaves are scaled */
+  float value = offset + safe_snoise(p);
+  p *= lacunarity;
+
+  for (int i = 1; i < (int)octaves; i++) {
+    float increment = (safe_snoise(p) + offset) * pwr * value;
+    value += increment;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    float increment = (safe_snoise(p) + offset) * pwr * value;
+    value += rmd * increment;
+  }
+
+  return 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'
+ */
+
+float noise_musgrave_hybrid_multi_fractal_4d(
+    vector4 co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  vector4 p = co;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float value = safe_snoise(p) + offset;
+  float weight = gain * value;
+  p *= lacunarity;
+
+  for (int i = 1; (weight > 0.001) && (i < (int)octaves); i++) {
+    if (weight > 1.0) {
+      weight = 1.0;
+    }
+
+    float signal = (safe_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 * ((safe_snoise(p) + offset) * pwr);
   }
 
-  return result;
+  return value;
 }
 
-/* Shader */
+/* 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'
+ */
+
+float noise_musgrave_ridged_multi_fractal_4d(
+    vector4 co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  vector4 p = co;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  float signal = offset - fabs(safe_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 - fabs(safe_snoise(p));
+    signal *= signal;
+    signal *= weight;
+    value += signal * pwr;
+    pwr *= pwHL;
+  }
+
+  return value;
+}
 
 shader node_musgrave_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 type = "fBM",
+    string dimensions = "3D",
+    point Vector = P,
+    float W = 0.0,
     float Dimension = 2.0,
-    float Lacunarity = 1.0,
+    float Scale = 5.0,
     float Detail = 2.0,
+    float Lacunarity = 1.0,
     float Offset = 0.0,
     float Gain = 1.0,
-    float Scale = 5.0,
-    point Vector = P,
-    output float Fac = 0.0,
-    output color Color = 0.0)
+    output float Fac = 0.0)
 {
   float dimension = max(Dimension, 1e-5);
   float octaves = clamp(Detail, 0.0, 16.0);
   float lacunarity = max(Lacunarity, 1e-5);
-  float intensity = 1.0;
 
-  point p = Vector;
+  vector3 s = Vector;
 
   if (use_mapping)
-    p = transform(mapping, p);
-
-  p = p * Scale;
-
-  if (type == "multifractal")
-    Fac = intensity * noise_musgrave_multi_fractal(p, dimension, lacunarity, octaves);
-  else if (type == "fBM")
-    Fac = intensity * noise_musgrave_fBm(p, dimension, lacunarity, octaves);
-  else if (type == "hybrid_multifractal")
-    Fac = intensity *
-          noise_musgrave_hybrid_multi_fractal(p, dimension, lacunarity, octaves, Offset, Gain);
-  else if (type == "ridged_multifractal")
-    Fac = intensity *
-          noise_musgrave_ridged_multi_fractal(p, dimension, lacunarity, octaves, Offset, Gain);
-  else if (type == "hetero_terrain")
-    Fac = intensity * noise_musgrave_hetero_terrain(p, dimension, lacunarity, octaves, Offset);
-
-  Color = color(Fac, Fac, Fac);
+    s = transform(mapping, s);
+
+  if (dimensions == "1D") {
+    float p = W * Scale;
+    if (type == "multifractal") {
+      Fac = noise_musgrave_multi_fractal_1d(p, dimension, lacunarity, octaves);
+    }
+    else if (type == "fBM") {
+      Fac = noise_musgrave_fBm_1d(p, dimension, lacunarity, octaves);
+    }
+    else if (type == "hybrid_multifractal") {
+      Fac = noise_musgrave_hybrid_multi_fractal_1d(
+          p, dimension, lacunarity, octaves, Offset, Gain);
+    }
+    else if (type == "ridged_multifractal") {
+      Fac = noise_musgrave_ridged_multi_fractal_1d(
+          p, dimension, lacunarity, octaves, Offset, Gain);
+    }
+    else if (type == "hetero_terrain") {
+      Fac = noise_musgrave_hetero_terrain_1d(p, dimension, lacunarity, octaves, Offset);
+    }
+    else {
+      Fac = 0.0;
+    }
+  }
+  else if (dimensions == "2D") {
+    vector2 p = vector2(s[0], s[1]) * Scale;
+    if (type == "multifractal") {
+      Fac = noise_musgrave_multi_fractal_2d(p, dimension, lacunarity, octaves);
+    }
+    else if (type == "fBM") {
+      Fac = noise_musgrave_fBm_2d(p, dimension, lacunarity, octaves);
+    }
+    else if (type == "hybrid_multifractal") {
+      Fac = noise_musgrave_hybrid_multi_fractal_2d(
+          p, dimension, lacunarity, octaves, Offset, Gain);
+    }
+    else if (type == "ridged_multifractal") {
+      Fac = noise_musgrave_ridged_multi_fractal_2d(
+          p, dimension, lacunarity, octaves, Offset, Gain);
+    }
+    else if (type == "hetero_terrain") {
+      Fac = noise_musgrave_hetero_terrain_2d(p, dimension, lacunarity, octaves, Offset);
+    }
+    else {
+      Fac = 0.0;
+    }
+  }
+  else if (dimensions == "3D") {
+    vector3 p = s * Scale;
+    if (type == "multifractal") {
+      Fac = noise_musgrave_multi_fractal_3d(p, dimension, lacunarity, octaves);
+    }
+    else if (type == "fBM") {
+      Fac = noise_musgrave_fBm_3d(p, dimension, lacunarity, octaves);
+    }
+    else if (type == "hybrid_multifractal") {
+      Fac = noise_musgrave_hybrid_multi_fractal_3d(
+          p, dimension, lacunarity, octaves, Offset, Gain);
+    }
+    else if (type == "ridged_multifractal") {
+      Fac = noise_musgrave_ridged_multi_fractal_3d(
+          p, dimension, lacunarity, octaves, Offset, Gain);
+    }
+    else if (type == "hetero_terrain") {
+      Fac = noise_musgrave_hetero_terrain_3d(p, dimension, lacunarity, octaves, Offset);
+    }
+    else {
+      Fac = 0.0;
+    }
+  }
+  else if (dimensions == "4D") {
+    vector4 p = vector4(s[0], s[1], s[2], W) * Scale;
+    if (type == "multifractal") {
+      Fac = noise_musgrave_multi_fractal_4d(p, dimension, lacunarity, octaves);
+    }
+    else if (type == "fBM") {
+      Fac = noise_musgrave_fBm_4d(p, dimension, lacunarity, octaves);
+    }
+    else if (type == "hybrid_multifractal") {
+      Fac = noise_musgrave_hybrid_multi_fractal_4d(
+          p, dimension, lacunarity, octaves, Offset, Gain);
+    }
+    else if (type == "ridged_multifractal") {
+      Fac = noise_musgrave_ridged_multi_fractal_4d(
+          p, dimension, lacunarity, octaves, Offset, Gain);
+    }
+    else if (type == "hetero_terrain") {
+      Fac = noise_musgrave_hetero_terrain_4d(p, dimension, lacunarity, octaves, Offset);
+    }
+    else {
+      Fac = 0.0;
+    }
+  }
+  else {
+    Fac = 0.0;
+  }
 }
diff --git a/intern/cycles/kernel/svm/svm.h b/intern/cycles/kernel/svm/svm.h
index ce651a1b5ff..a192930937f 100644
--- a/intern/cycles/kernel/svm/svm.h
+++ b/intern/cycles/kernel/svm/svm.h
@@ -432,7 +432,7 @@ ccl_device_noinline void svm_eval_nodes(KernelGlobals *kg,
         svm_node_tex_voronoi(kg, sd, stack, node, &offset);
         break;
       case NODE_TEX_MUSGRAVE:
-        svm_node_tex_musgrave(kg, sd, stack, node, &offset);
+        svm_node_tex_musgrave(kg, sd, stack, node.y, node.z, node.w, &offset);
         break;
       case NODE_TEX_WAVE:
         svm_node_tex_wave(kg, sd, stack, node, &offset);
diff --git a/intern/cycles/kernel/svm/svm_musgrave.h b/intern/cycles/kernel/svm/svm_musgrave.h
index db87f04581f..571f62fe27f 100644
--- a/intern/cycles/kernel/svm/svm_musgrave.h
+++ b/intern/cycles/kernel/svm/svm_musgrave.h
@@ -16,7 +16,7 @@
 
 CCL_NAMESPACE_BEGIN
 
-/* Musgrave fBm
+/* 1D Musgrave fBm
  *
  * H: fractal increment parameter
  * lacunarity: gap between successive frequencies
@@ -25,62 +25,404 @@ CCL_NAMESPACE_BEGIN
  * from "Texturing and Modelling: A procedural approach"
  */
 
-ccl_device_noinline_cpu float noise_musgrave_fBm(float3 p,
-                                                 float H,
-                                                 float lacunarity,
-                                                 float octaves)
+ccl_device_noinline_cpu float noise_musgrave_fBm_1d(float co,
+                                                    float H,
+                                                    float lacunarity,
+                                                    float octaves)
 {
-  float rmd;
+  float p = co;
   float value = 0.0f;
   float pwr = 1.0f;
   float pwHL = powf(lacunarity, -H);
-  int i;
 
-  for (i = 0; i < float_to_int(octaves); i++) {
+  for (int i = 0; i < float_to_int(octaves); i++) {
+    value += snoise_1d(p) * pwr;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    value += rmd * snoise_1d(p) * pwr;
+  }
+
+  return value;
+}
+
+/* 1D Musgrave Multifractal
+ *
+ * H: highest fractal dimension
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_multi_fractal_1d(float co,
+                                                              float H,
+                                                              float lacunarity,
+                                                              float octaves)
+{
+  float p = co;
+  float value = 1.0f;
+  float pwr = 1.0f;
+  float pwHL = powf(lacunarity, -H);
+
+  for (int i = 0; i < float_to_int(octaves); i++) {
+    value *= (pwr * snoise_1d(p) + 1.0f);
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    value *= (rmd * pwr * snoise_1d(p) + 1.0f); /* correct? */
+  }
+
+  return 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'
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_hetero_terrain_1d(
+    float co, float H, float lacunarity, float octaves, float offset)
+{
+  float p = co;
+  float pwHL = powf(lacunarity, -H);
+  float pwr = pwHL;
+
+  /* first unscaled octave of function; later octaves are scaled */
+  float value = offset + snoise_1d(p);
+  p *= lacunarity;
+
+  for (int i = 1; i < float_to_int(octaves); i++) {
+    float increment = (snoise_1d(p) + offset) * pwr * value;
+    value += increment;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    float increment = (snoise_1d(p) + offset) * pwr * value;
+    value += rmd * increment;
+  }
+
+  return 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'
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_hybrid_multi_fractal_1d(
+    float co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float p = co;
+  float pwHL = powf(lacunarity, -H);
+  float pwr = pwHL;
+
+  float value = snoise_1d(p) + offset;
+  float weight = gain * value;
+  p *= lacunarity;
+
+  for (int i = 1; (weight > 0.001f) && (i < float_to_int(octaves)); i++) {
+    if (weight > 1.0f) {
+      weight = 1.0f;
+    }
+
+    float signal = (snoise_1d(p) + offset) * pwr;
+    pwr *= pwHL;
+    value += weight * signal;
+    weight *= gain * signal;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    value += rmd * ((snoise_1d(p) + offset) * pwr);
+  }
+
+  return 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'
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_ridged_multi_fractal_1d(
+    float co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float p = co;
+  float pwHL = powf(lacunarity, -H);
+  float pwr = pwHL;
+
+  float signal = offset - fabsf(snoise_1d(p));
+  signal *= signal;
+  float value = signal;
+  float weight = 1.0f;
+
+  for (int i = 1; i < float_to_int(octaves); i++) {
+    p *= lacunarity;
+    weight = saturate(signal * gain);
+    signal = offset - fabsf(snoise_1d(p));
+    signal *= signal;
+    signal *= weight;
+    value += signal * pwr;
+    pwr *= pwHL;
+  }
+
+  return 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"
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_fBm_2d(float2 co,
+                                                    float H,
+                                                    float lacunarity,
+                                                    float octaves)
+{
+  float2 p = co;
+  float value = 0.0f;
+  float pwr = 1.0f;
+  float pwHL = powf(lacunarity, -H);
+
+  for (int i = 0; i < float_to_int(octaves); i++) {
+    value += snoise_2d(p) * pwr;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    value += rmd * snoise_2d(p) * pwr;
+  }
+
+  return value;
+}
+
+/* 2D Musgrave Multifractal
+ *
+ * H: highest fractal dimension
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_multi_fractal_2d(float2 co,
+                                                              float H,
+                                                              float lacunarity,
+                                                              float octaves)
+{
+  float2 p = co;
+  float value = 1.0f;
+  float pwr = 1.0f;
+  float pwHL = powf(lacunarity, -H);
+
+  for (int i = 0; i < float_to_int(octaves); i++) {
+    value *= (pwr * snoise_2d(p) + 1.0f);
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    value *= (rmd * pwr * snoise_2d(p) + 1.0f); /* correct? */
+  }
+
+  return 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'
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_hetero_terrain_2d(
+    float2 co, float H, float lacunarity, float octaves, float offset)
+{
+  float2 p = co;
+  float pwHL = powf(lacunarity, -H);
+  float pwr = pwHL;
+
+  /* first unscaled octave of function; later octaves are scaled */
+  float value = offset + snoise_2d(p);
+  p *= lacunarity;
+
+  for (int i = 1; i < float_to_int(octaves); i++) {
+    float increment = (snoise_2d(p) + offset) * pwr * value;
+    value += increment;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    float increment = (snoise_2d(p) + offset) * pwr * value;
+    value += rmd * increment;
+  }
+
+  return 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'
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_hybrid_multi_fractal_2d(
+    float2 co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float2 p = co;
+  float pwHL = powf(lacunarity, -H);
+  float pwr = pwHL;
+
+  float value = snoise_2d(p) + offset;
+  float weight = gain * value;
+  p *= lacunarity;
+
+  for (int i = 1; (weight > 0.001f) && (i < float_to_int(octaves)); i++) {
+    if (weight > 1.0f) {
+      weight = 1.0f;
+    }
+
+    float signal = (snoise_2d(p) + offset) * pwr;
+    pwr *= pwHL;
+    value += weight * signal;
+    weight *= gain * signal;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    value += rmd * ((snoise_2d(p) + offset) * pwr);
+  }
+
+  return 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'
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_ridged_multi_fractal_2d(
+    float2 co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float2 p = co;
+  float pwHL = powf(lacunarity, -H);
+  float pwr = pwHL;
+
+  float signal = offset - fabsf(snoise_2d(p));
+  signal *= signal;
+  float value = signal;
+  float weight = 1.0f;
+
+  for (int i = 1; i < float_to_int(octaves); i++) {
+    p *= lacunarity;
+    weight = saturate(signal * gain);
+    signal = offset - fabsf(snoise_2d(p));
+    signal *= signal;
+    signal *= weight;
+    value += signal * pwr;
+    pwr *= pwHL;
+  }
+
+  return 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"
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_fBm_3d(float3 co,
+                                                    float H,
+                                                    float lacunarity,
+                                                    float octaves)
+{
+  float3 p = co;
+  float value = 0.0f;
+  float pwr = 1.0f;
+  float pwHL = powf(lacunarity, -H);
+
+  for (int i = 0; i < float_to_int(octaves); i++) {
     value += snoise_3d(p) * pwr;
     pwr *= pwHL;
     p *= lacunarity;
   }
 
-  rmd = octaves - floorf(octaves);
-  if (rmd != 0.0f)
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
     value += rmd * snoise_3d(p) * pwr;
+  }
 
   return value;
 }
 
-/* Musgrave Multifractal
+/* 3D Musgrave Multifractal
  *
  * H: highest fractal dimension
  * lacunarity: gap between successive frequencies
  * octaves: number of frequencies in the fBm
  */
 
-ccl_device_noinline_cpu float noise_musgrave_multi_fractal(float3 p,
-                                                           float H,
-                                                           float lacunarity,
-                                                           float octaves)
+ccl_device_noinline_cpu float noise_musgrave_multi_fractal_3d(float3 co,
+                                                              float H,
+                                                              float lacunarity,
+                                                              float octaves)
 {
-  float rmd;
+  float3 p = co;
   float value = 1.0f;
   float pwr = 1.0f;
   float pwHL = powf(lacunarity, -H);
-  int i;
 
-  for (i = 0; i < float_to_int(octaves); i++) {
+  for (int i = 0; i < float_to_int(octaves); i++) {
     value *= (pwr * snoise_3d(p) + 1.0f);
     pwr *= pwHL;
     p *= lacunarity;
   }
 
-  rmd = octaves - floorf(octaves);
-  if (rmd != 0.0f)
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
     value *= (rmd * pwr * snoise_3d(p) + 1.0f); /* correct? */
+  }
 
   return value;
 }
 
-/* Musgrave Heterogeneous Terrain
+/* 3D Musgrave Heterogeneous Terrain
  *
  * H: fractal dimension of the roughest area
  * lacunarity: gap between successive frequencies
@@ -88,35 +430,34 @@ ccl_device_noinline_cpu float noise_musgrave_multi_fractal(float3 p,
  * offset: raises the terrain from `sea level'
  */
 
-ccl_device_noinline_cpu float noise_musgrave_hetero_terrain(
-    float3 p, float H, float lacunarity, float octaves, float offset)
+ccl_device_noinline_cpu float noise_musgrave_hetero_terrain_3d(
+    float3 co, float H, float lacunarity, float octaves, float offset)
 {
-  float value, increment, rmd;
+  float3 p = co;
   float pwHL = powf(lacunarity, -H);
   float pwr = pwHL;
-  int i;
 
   /* first unscaled octave of function; later octaves are scaled */
-  value = offset + snoise_3d(p);
+  float value = offset + snoise_3d(p);
   p *= lacunarity;
 
-  for (i = 1; i < float_to_int(octaves); i++) {
-    increment = (snoise_3d(p) + offset) * pwr * value;
+  for (int i = 1; i < float_to_int(octaves); i++) {
+    float increment = (snoise_3d(p) + offset) * pwr * value;
     value += increment;
     pwr *= pwHL;
     p *= lacunarity;
   }
 
-  rmd = octaves - floorf(octaves);
+  float rmd = octaves - floorf(octaves);
   if (rmd != 0.0f) {
-    increment = (snoise_3d(p) + offset) * pwr * value;
+    float increment = (snoise_3d(p) + offset) * pwr * value;
     value += rmd * increment;
   }
 
   return value;
 }
 
-/* Hybrid Additive/Multiplicative Multifractal Terrain
+/* 3D Hybrid Additive/Multiplicative Multifractal Terrain
  *
  * H: fractal dimension of the roughest area
  * lacunarity: gap between successive frequencies
@@ -124,37 +465,38 @@ ccl_device_noinline_cpu float noise_musgrave_hetero_terrain(
  * offset: raises the terrain from `sea level'
  */
 
-ccl_device_noinline_cpu float noise_musgrave_hybrid_multi_fractal(
-    float3 p, float H, float lacunarity, float octaves, float offset, float gain)
+ccl_device_noinline_cpu float noise_musgrave_hybrid_multi_fractal_3d(
+    float3 co, float H, float lacunarity, float octaves, float offset, float gain)
 {
-  float result, signal, weight, rmd;
+  float3 p = co;
   float pwHL = powf(lacunarity, -H);
   float pwr = pwHL;
-  int i;
 
-  result = snoise_3d(p) + offset;
-  weight = gain * result;
+  float value = snoise_3d(p) + offset;
+  float weight = gain * value;
   p *= lacunarity;
 
-  for (i = 1; (weight > 0.001f) && (i < float_to_int(octaves)); i++) {
-    if (weight > 1.0f)
+  for (int i = 1; (weight > 0.001f) && (i < float_to_int(octaves)); i++) {
+    if (weight > 1.0f) {
       weight = 1.0f;
+    }
 
-    signal = (snoise_3d(p) + offset) * pwr;
+    float signal = (snoise_3d(p) + offset) * pwr;
     pwr *= pwHL;
-    result += weight * signal;
+    value += weight * signal;
     weight *= gain * signal;
     p *= lacunarity;
   }
 
-  rmd = octaves - floorf(octaves);
-  if (rmd != 0.0f)
-    result += rmd * ((snoise_3d(p) + offset) * pwr);
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    value += rmd * ((snoise_3d(p) + offset) * pwr);
+  }
 
-  return result;
+  return value;
 }
 
-/* Ridged Multifractal Terrain
+/* 3D Ridged Multifractal Terrain
  *
  * H: fractal dimension of the roughest area
  * lacunarity: gap between successive frequencies
@@ -162,93 +504,346 @@ ccl_device_noinline_cpu float noise_musgrave_hybrid_multi_fractal(
  * offset: raises the terrain from `sea level'
  */
 
-ccl_device_noinline_cpu float noise_musgrave_ridged_multi_fractal(
-    float3 p, float H, float lacunarity, float octaves, float offset, float gain)
+ccl_device_noinline_cpu float noise_musgrave_ridged_multi_fractal_3d(
+    float3 co, float H, float lacunarity, float octaves, float offset, float gain)
 {
-  float result, signal, weight;
+  float3 p = co;
   float pwHL = powf(lacunarity, -H);
   float pwr = pwHL;
-  int i;
 
-  signal = offset - fabsf(snoise_3d(p));
+  float signal = offset - fabsf(snoise_3d(p));
   signal *= signal;
-  result = signal;
-  weight = 1.0f;
+  float value = signal;
+  float weight = 1.0f;
 
-  for (i = 1; i < float_to_int(octaves); i++) {
+  for (int i = 1; i < float_to_int(octaves); i++) {
     p *= lacunarity;
     weight = saturate(signal * gain);
     signal = offset - fabsf(snoise_3d(p));
     signal *= signal;
     signal *= weight;
-    result += signal * pwr;
+    value += signal * pwr;
     pwr *= pwHL;
   }
 
-  return result;
+  return value;
 }
 
-/* Shader */
+/* 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"
+ */
 
-ccl_device float svm_musgrave(NodeMusgraveType type,
-                              float dimension,
-                              float lacunarity,
-                              float octaves,
-                              float offset,
-                              float intensity,
-                              float gain,
-                              float3 p)
+ccl_device_noinline_cpu float noise_musgrave_fBm_4d(float4 co,
+                                                    float H,
+                                                    float lacunarity,
+                                                    float octaves)
 {
-  if (type == NODE_MUSGRAVE_MULTIFRACTAL)
-    return intensity * noise_musgrave_multi_fractal(p, dimension, lacunarity, octaves);
-  else if (type == NODE_MUSGRAVE_FBM)
-    return intensity * noise_musgrave_fBm(p, dimension, lacunarity, octaves);
-  else if (type == NODE_MUSGRAVE_HYBRID_MULTIFRACTAL)
-    return intensity *
-           noise_musgrave_hybrid_multi_fractal(p, dimension, lacunarity, octaves, offset, gain);
-  else if (type == NODE_MUSGRAVE_RIDGED_MULTIFRACTAL)
-    return intensity *
-           noise_musgrave_ridged_multi_fractal(p, dimension, lacunarity, octaves, offset, gain);
-  else if (type == NODE_MUSGRAVE_HETERO_TERRAIN)
-    return intensity * noise_musgrave_hetero_terrain(p, dimension, lacunarity, octaves, offset);
+  float4 p = co;
+  float value = 0.0f;
+  float pwr = 1.0f;
+  float pwHL = powf(lacunarity, -H);
+
+  for (int i = 0; i < float_to_int(octaves); i++) {
+    value += snoise_4d(p) * pwr;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    value += rmd * snoise_4d(p) * pwr;
+  }
 
-  return 0.0f;
+  return value;
 }
 
-ccl_device void svm_node_tex_musgrave(
-    KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int *offset)
+/* 4D Musgrave Multifractal
+ *
+ * H: highest fractal dimension
+ * lacunarity: gap between successive frequencies
+ * octaves: number of frequencies in the fBm
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_multi_fractal_4d(float4 co,
+                                                              float H,
+                                                              float lacunarity,
+                                                              float octaves)
 {
-  uint4 node2 = read_node(kg, offset);
-  uint4 node3 = read_node(kg, offset);
+  float4 p = co;
+  float value = 1.0f;
+  float pwr = 1.0f;
+  float pwHL = powf(lacunarity, -H);
 
-  uint type, co_offset, color_offset, fac_offset;
-  uint dimension_offset, lacunarity_offset, detail_offset, offset_offset;
-  uint gain_offset, scale_offset;
+  for (int i = 0; i < float_to_int(octaves); i++) {
+    value *= (pwr * snoise_4d(p) + 1.0f);
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
 
-  svm_unpack_node_uchar4(node.y, &type, &co_offset, &color_offset, &fac_offset);
-  svm_unpack_node_uchar4(
-      node.z, &dimension_offset, &lacunarity_offset, &detail_offset, &offset_offset);
-  svm_unpack_node_uchar2(node.w, &gain_offset, &scale_offset);
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    value *= (rmd * pwr * snoise_4d(p) + 1.0f); /* correct? */
+  }
 
-  float3 co = stack_load_float3(stack, co_offset);
-  float dimension = stack_load_float_default(stack, dimension_offset, node2.x);
-  float lacunarity = stack_load_float_default(stack, lacunarity_offset, node2.y);
-  float detail = stack_load_float_default(stack, detail_offset, node2.z);
-  float foffset = stack_load_float_default(stack, offset_offset, node2.w);
-  float gain = stack_load_float_default(stack, gain_offset, node3.x);
-  float scale = stack_load_float_default(stack, scale_offset, node3.y);
+  return 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'
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_hetero_terrain_4d(
+    float4 co, float H, float lacunarity, float octaves, float offset)
+{
+  float4 p = co;
+  float pwHL = powf(lacunarity, -H);
+  float pwr = pwHL;
+
+  /* first unscaled octave of function; later octaves are scaled */
+  float value = offset + snoise_4d(p);
+  p *= lacunarity;
+
+  for (int i = 1; i < float_to_int(octaves); i++) {
+    float increment = (snoise_4d(p) + offset) * pwr * value;
+    value += increment;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    float increment = (snoise_4d(p) + offset) * pwr * value;
+    value += rmd * increment;
+  }
+
+  return 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'
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_hybrid_multi_fractal_4d(
+    float4 co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float4 p = co;
+  float pwHL = powf(lacunarity, -H);
+  float pwr = pwHL;
+
+  float value = snoise_4d(p) + offset;
+  float weight = gain * value;
+  p *= lacunarity;
+
+  for (int i = 1; (weight > 0.001f) && (i < float_to_int(octaves)); i++) {
+    if (weight > 1.0f) {
+      weight = 1.0f;
+    }
+
+    float signal = (snoise_4d(p) + offset) * pwr;
+    pwr *= pwHL;
+    value += weight * signal;
+    weight *= gain * signal;
+    p *= lacunarity;
+  }
+
+  float rmd = octaves - floorf(octaves);
+  if (rmd != 0.0f) {
+    value += rmd * ((snoise_4d(p) + offset) * pwr);
+  }
+
+  return value;
+}
+
+/* 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'
+ */
+
+ccl_device_noinline_cpu float noise_musgrave_ridged_multi_fractal_4d(
+    float4 co, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float4 p = co;
+  float pwHL = powf(lacunarity, -H);
+  float pwr = pwHL;
+
+  float signal = offset - fabsf(snoise_4d(p));
+  signal *= signal;
+  float value = signal;
+  float weight = 1.0f;
+
+  for (int i = 1; i < float_to_int(octaves); i++) {
+    p *= lacunarity;
+    weight = saturate(signal * gain);
+    signal = offset - fabsf(snoise_4d(p));
+    signal *= signal;
+    signal *= weight;
+    value += signal * pwr;
+    pwr *= pwHL;
+  }
+
+  return value;
+}
+
+ccl_device void svm_node_tex_musgrave(KernelGlobals *kg,
+                                      ShaderData *sd,
+                                      float *stack,
+                                      uint offsets1,
+                                      uint offsets2,
+                                      uint offsets3,
+                                      int *offset)
+{
+  uint type, dimensions, co_stack_offset, w_stack_offset;
+  uint scale_stack_offset, detail_stack_offset, dimension_stack_offset, lacunarity_stack_offset;
+  uint offset_stack_offset, gain_stack_offset, fac_stack_offset;
+
+  svm_unpack_node_uchar4(offsets1, &type, &dimensions, &co_stack_offset, &w_stack_offset);
+  svm_unpack_node_uchar4(offsets2,
+                         &scale_stack_offset,
+                         &detail_stack_offset,
+                         &dimension_stack_offset,
+                         &lacunarity_stack_offset);
+  svm_unpack_node_uchar3(offsets3, &offset_stack_offset, &gain_stack_offset, &fac_stack_offset);
+
+  uint4 defaults1 = read_node(kg, offset);
+  uint4 defaults2 = read_node(kg, offset);
+
+  float3 co = stack_load_float3(stack, co_stack_offset);
+  float w = stack_load_float_default(stack, w_stack_offset, defaults1.x);
+  float scale = stack_load_float_default(stack, scale_stack_offset, defaults1.y);
+  float detail = stack_load_float_default(stack, detail_stack_offset, defaults1.z);
+  float dimension = stack_load_float_default(stack, dimension_stack_offset, defaults1.w);
+  float lacunarity = stack_load_float_default(stack, lacunarity_stack_offset, defaults2.x);
+  float foffset = stack_load_float_default(stack, offset_stack_offset, defaults2.y);
+  float gain = stack_load_float_default(stack, gain_stack_offset, defaults2.z);
 
   dimension = fmaxf(dimension, 1e-5f);
   detail = clamp(detail, 0.0f, 16.0f);
   lacunarity = fmaxf(lacunarity, 1e-5f);
 
-  float f = svm_musgrave(
-      (NodeMusgraveType)type, dimension, lacunarity, detail, foffset, 1.0f, gain, co * scale);
+  float fac;
+
+  switch (dimensions) {
+    case 1: {
+      float p = w * scale;
+      switch ((NodeMusgraveType)type) {
+        case NODE_MUSGRAVE_MULTIFRACTAL:
+          fac = noise_musgrave_multi_fractal_1d(p, dimension, lacunarity, detail);
+          break;
+        case NODE_MUSGRAVE_FBM:
+          fac = noise_musgrave_fBm_1d(p, dimension, lacunarity, detail);
+          break;
+        case NODE_MUSGRAVE_HYBRID_MULTIFRACTAL:
+          fac = noise_musgrave_hybrid_multi_fractal_1d(
+              p, dimension, lacunarity, detail, foffset, gain);
+          break;
+        case NODE_MUSGRAVE_RIDGED_MULTIFRACTAL:
+          fac = noise_musgrave_ridged_multi_fractal_1d(
+              p, dimension, lacunarity, detail, foffset, gain);
+          break;
+        case NODE_MUSGRAVE_HETERO_TERRAIN:
+          fac = noise_musgrave_hetero_terrain_1d(p, dimension, lacunarity, detail, foffset);
+          break;
+        default:
+          fac = 0.0f;
+      }
+      break;
+    }
+    case 2: {
+      float2 p = make_float2(co.x, co.y) * scale;
+      switch ((NodeMusgraveType)type) {
+        case NODE_MUSGRAVE_MULTIFRACTAL:
+          fac = noise_musgrave_multi_fractal_2d(p, dimension, lacunarity, detail);
+          break;
+        case NODE_MUSGRAVE_FBM:
+          fac = noise_musgrave_fBm_2d(p, dimension, lacunarity, detail);
+          break;
+        case NODE_MUSGRAVE_HYBRID_MULTIFRACTAL:
+          fac = noise_musgrave_hybrid_multi_fractal_2d(
+              p, dimension, lacunarity, detail, foffset, gain);
+          break;
+        case NODE_MUSGRAVE_RIDGED_MULTIFRACTAL:
+          fac = noise_musgrave_ridged_multi_fractal_2d(
+              p, dimension, lacunarity, detail, foffset, gain);
+          break;
+        case NODE_MUSGRAVE_HETERO_TERRAIN:
+          fac = noise_musgrave_hetero_terrain_2d(p, dimension, lacunarity, detail, foffset);
+          break;
+        default:
+          fac = 0.0f;
+      }
+      break;
+    }
+    case 3: {
+      float3 p = co * scale;
+      switch ((NodeMusgraveType)type) {
+        case NODE_MUSGRAVE_MULTIFRACTAL:
+          fac = noise_musgrave_multi_fractal_3d(p, dimension, lacunarity, detail);
+          break;
+        case NODE_MUSGRAVE_FBM:
+          fac = noise_musgrave_fBm_3d(p, dimension, lacunarity, detail);
+          break;
+        case NODE_MUSGRAVE_HYBRID_MULTIFRACTAL:
+          fac = noise_musgrave_hybrid_multi_fractal_3d(
+              p, dimension, lacunarity, detail, foffset, gain);
+          break;
+        case NODE_MUSGRAVE_RIDGED_MULTIFRACTAL:
+          fac = noise_musgrave_ridged_multi_fractal_3d(
+              p, dimension, lacunarity, detail, foffset, gain);
+          break;
+        case NODE_MUSGRAVE_HETERO_TERRAIN:
+          fac = noise_musgrave_hetero_terrain_3d(p, dimension, lacunarity, detail, foffset);
+          break;
+        default:
+          fac = 0.0f;
+      }
+      break;
+    }
+    case 4: {
+      float4 p = make_float4(co.x, co.y, co.z, w) * scale;
+      switch ((NodeMusgraveType)type) {
+        case NODE_MUSGRAVE_MULTIFRACTAL:
+          fac = noise_musgrave_multi_fractal_4d(p, dimension, lacunarity, detail);
+          break;
+        case NODE_MUSGRAVE_FBM:
+          fac = noise_musgrave_fBm_4d(p, dimension, lacunarity, detail);
+          break;
+        case NODE_MUSGRAVE_HYBRID_MULTIFRACTAL:
+          fac = noise_musgrave_hybrid_multi_fractal_4d(
+              p, dimension, lacunarity, detail, foffset, gain);
+          break;
+        case NODE_MUSGRAVE_RIDGED_MULTIFRACTAL:
+          fac = noise_musgrave_ridged_multi_fractal_4d(
+              p, dimension, lacunarity, detail, foffset, gain);
+          break;
+        case NODE_MUSGRAVE_HETERO_TERRAIN:
+          fac = noise_musgrave_hetero_terrain_4d(p, dimension, lacunarity, detail, foffset);
+          break;
+        default:
+          fac = 0.0f;
+      }
+      break;
+    }
+    default:
+      fac = 0.0f;
+  }
 
-  if (stack_valid(fac_offset))
-    stack_store_float(stack, fac_offset, f);
-  if (stack_valid(color_offset))
-    stack_store_float3(stack, color_offset, make_float3(f, f, f));
+  stack_store_float(stack, fac_stack_offset, fac);
 }
 
 CCL_NAMESPACE_END
diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp
index 31dc986a4d1..01661a6d1e0 100644
--- a/intern/cycles/render/nodes.cpp
+++ b/intern/cycles/render/nodes.cpp
@@ -1183,6 +1183,13 @@ NODE_DEFINE(MusgraveTextureNode)
 
   TEXTURE_MAPPING_DEFINE(MusgraveTextureNode);
 
+  static NodeEnum dimensions_enum;
+  dimensions_enum.insert("1D", 1);
+  dimensions_enum.insert("2D", 2);
+  dimensions_enum.insert("3D", 3);
+  dimensions_enum.insert("4D", 4);
+  SOCKET_ENUM(dimensions, "Dimensions", dimensions_enum, 3);
+
   static NodeEnum type_enum;
   type_enum.insert("multifractal", NODE_MUSGRAVE_MULTIFRACTAL);
   type_enum.insert("fBM", NODE_MUSGRAVE_FBM);
@@ -1191,16 +1198,16 @@ NODE_DEFINE(MusgraveTextureNode)
   type_enum.insert("hetero_terrain", NODE_MUSGRAVE_HETERO_TERRAIN);
   SOCKET_ENUM(type, "Type", type_enum, NODE_MUSGRAVE_FBM);
 
+  SOCKET_IN_POINT(
+      vector, "Vector", make_float3(0.0f, 0.0f, 0.0f), SocketType::LINK_TEXTURE_GENERATED);
+  SOCKET_IN_FLOAT(w, "W", 0.0f);
   SOCKET_IN_FLOAT(scale, "Scale", 1.0f);
   SOCKET_IN_FLOAT(detail, "Detail", 2.0f);
   SOCKET_IN_FLOAT(dimension, "Dimension", 2.0f);
   SOCKET_IN_FLOAT(lacunarity, "Lacunarity", 1.0f);
   SOCKET_IN_FLOAT(offset, "Offset", 0.0f);
   SOCKET_IN_FLOAT(gain, "Gain", 1.0f);
-  SOCKET_IN_POINT(
-      vector, "Vector", make_float3(0.0f, 0.0f, 0.0f), SocketType::LINK_TEXTURE_GENERATED);
 
-  SOCKET_OUT_COLOR(color, "Color");
   SOCKET_OUT_FLOAT(fac, "Fac");
 
   return type;
@@ -1213,35 +1220,38 @@ MusgraveTextureNode::MusgraveTextureNode() : TextureNode(node_type)
 void MusgraveTextureNode::compile(SVMCompiler &compiler)
 {
   ShaderInput *vector_in = input("Vector");
+  ShaderInput *w_in = input("W");
   ShaderInput *scale_in = input("Scale");
+  ShaderInput *detail_in = input("Detail");
   ShaderInput *dimension_in = input("Dimension");
   ShaderInput *lacunarity_in = input("Lacunarity");
-  ShaderInput *detail_in = input("Detail");
   ShaderInput *offset_in = input("Offset");
   ShaderInput *gain_in = input("Gain");
   ShaderOutput *fac_out = output("Fac");
-  ShaderOutput *color_out = output("Color");
 
-  int vector_offset = tex_mapping.compile_begin(compiler, vector_in);
+  int vector_stack_offset = tex_mapping.compile_begin(compiler, vector_in);
+  int w_stack_offset = compiler.stack_assign_if_linked(w_in);
+  int scale_stack_offset = compiler.stack_assign_if_linked(scale_in);
+  int detail_stack_offset = compiler.stack_assign_if_linked(detail_in);
+  int dimension_stack_offset = compiler.stack_assign_if_linked(dimension_in);
+  int lacunarity_stack_offset = compiler.stack_assign_if_linked(lacunarity_in);
+  int offset_stack_offset = compiler.stack_assign_if_linked(offset_in);
+  int gain_stack_offset = compiler.stack_assign_if_linked(gain_in);
+  int fac_stack_offset = compiler.stack_assign(fac_out);
 
-  compiler.add_node(NODE_TEX_MUSGRAVE,
-                    compiler.encode_uchar4(type,
-                                           vector_offset,
-                                           compiler.stack_assign_if_linked(color_out),
-                                           compiler.stack_assign_if_linked(fac_out)),
-                    compiler.encode_uchar4(compiler.stack_assign_if_linked(dimension_in),
-                                           compiler.stack_assign_if_linked(lacunarity_in),
-                                           compiler.stack_assign_if_linked(detail_in),
-                                           compiler.stack_assign_if_linked(offset_in)),
-                    compiler.encode_uchar4(compiler.stack_assign_if_linked(gain_in),
-                                           compiler.stack_assign_if_linked(scale_in)));
-  compiler.add_node(__float_as_int(dimension),
-                    __float_as_int(lacunarity),
-                    __float_as_int(detail),
-                    __float_as_int(offset));
-  compiler.add_node(__float_as_int(gain), __float_as_int(scale));
+  compiler.add_node(
+      NODE_TEX_MUSGRAVE,
+      compiler.encode_uchar4(type, dimensions, vector_stack_offset, w_stack_offset),
+      compiler.encode_uchar4(scale_stack_offset,
+                             detail_stack_offset,
+                             dimension_stack_offset,
+                             lacunarity_stack_offset),
+      compiler.encode_uchar4(offset_stack_offset, gain_stack_offset, fac_stack_offset));
+  compiler.add_node(
+      __float_as_int(w), __float_as_int(scale), __float_as_int(detail), __float_as_int(dimension));
+  compiler.add_node(__float_as_int(lacunarity), __float_as_int(offset), __float_as_int(gain));
 
-  tex_mapping.compile_end(compiler, vector_in, vector_offset);
+  tex_mapping.compile_end(compiler, vector_in, vector_stack_offset);
 }
 
 void MusgraveTextureNode::compile(OSLCompiler &compiler)
@@ -1249,6 +1259,7 @@ void MusgraveTextureNode::compile(OSLCompiler &compiler)
   tex_mapping.compile(compiler);
 
   compiler.parameter(this, "type");
+  compiler.parameter(this, "dimensions");
   compiler.add(this, "node_musgrave_texture");
 }
 
diff --git a/intern/cycles/render/nodes.h b/intern/cycles/render/nodes.h
index 769687f1f19..5d7e074f62b 100644
--- a/intern/cycles/render/nodes.h
+++ b/intern/cycles/render/nodes.h
@@ -236,8 +236,9 @@ class MusgraveTextureNode : public TextureNode {
     return NODE_GROUP_LEVEL_2;
   }
 
+  int dimensions;
   NodeMusgraveType type;
-  float scale, detail, dimension, lacunarity, offset, gain;
+  float w, scale, detail, dimension, lacunarity, offset, gain;
   float3 vector;
 };