[Bf-blender-cvs] [c634918c99f] soc-2019-cycles-procedural: 1D, 2D, and 4D musgrave texture

OmarSquircleArt noreply at git.blender.org
Thu Jul 4 17:26:50 CEST 2019


Commit: c634918c99f86f7f284c7a87319bcdbd1cc4cb13
Author: OmarSquircleArt
Date:   Thu Jul 4 17:27:44 2019 +0200
Branches: soc-2019-cycles-procedural
https://developer.blender.org/rBc634918c99f86f7f284c7a87319bcdbd1cc4cb13

1D, 2D, and 4D musgrave texture

===================================================================

M	intern/cycles/blender/blender_shader.cpp
M	intern/cycles/kernel/shaders/node_musgrave_texture.osl
M	intern/cycles/kernel/svm/svm.h
M	intern/cycles/kernel/svm/svm_musgrave.h
M	intern/cycles/render/nodes.cpp
M	intern/cycles/render/nodes.h
M	source/blender/editors/space_node/drawnode.c
M	source/blender/gpu/shaders/gpu_shader_material.glsl
M	source/blender/makesdna/DNA_node_types.h
M	source/blender/makesrna/intern/rna_nodetree.c
M	source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c

===================================================================

diff --git a/intern/cycles/blender/blender_shader.cpp b/intern/cycles/blender/blender_shader.cpp
index cf38a03de31..62ed6e9bf12 100644
--- a/intern/cycles/blender/blender_shader.cpp
+++ b/intern/cycles/blender/blender_shader.cpp
@@ -780,6 +780,7 @@ static ShaderNode *add_node(Scene *scene,
     BL::ShaderNodeTexMusgrave b_musgrave_node(b_node);
     MusgraveTextureNode *musgrave = new MusgraveTextureNode();
     musgrave->type = (NodeMusgraveType)b_musgrave_node.musgrave_type();
+    musgrave->dimensions = b_musgrave_node.dimensions();
     BL::TexMapping b_texture_mapping(b_musgrave_node.texture_mapping());
     get_tex_mapping(&musgrave->tex_mapping, b_texture_mapping);
     node = musgrave;
diff --git a/intern/cycles/kernel/shaders/node_musgrave_texture.osl b/intern/cycles/kernel/shaders/node_musgrave_texture.osl
index 7b46573fcb9..1ef10035891 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_texture.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 p, float H, float lacunarity, float octaves)
+{
+  float rmd;
+  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;
+  }
+
+  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 p, float H, float lacunarity, float octaves)
+{
+  float rmd;
+  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;
+  }
+
+  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 p, float H, float lacunarity, float octaves, float offset)
+{
+  float value, increment, rmd;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  /* first unscaled octave of function; later octaves are scaled */
+  value = offset + safe_snoise(p);
+  p *= lacunarity;
+
+  for (int i = 1; i < (int)octaves; i++) {
+    increment = (safe_snoise(p) + offset) * pwr * value;
+    value += increment;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    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 p, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float result, signal, weight, rmd;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  result = safe_snoise(p) + offset;
+  weight = gain * result;
+  p *= lacunarity;
+
+  for (int i = 1; (weight > 0.001) && (i < (int)octaves); i++) {
+    if (weight > 1.0) {
+      weight = 1.0;
+    }
+
+    signal = (safe_snoise(p) + offset) * pwr;
+    pwr *= pwHL;
+    result += weight * signal;
+    weight *= gain * signal;
+    p *= lacunarity;
+  }
+
+  rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    result += rmd * ((safe_snoise(p) + offset) * pwr);
+  }
+
+  return result;
+}
+
+/* 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 p, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float result, signal, weight;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  signal = offset - fabs(safe_snoise(p));
+  signal *= signal;
+  result = signal;
+  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;
+    result += signal * pwr;
+    pwr *= pwHL;
+  }
+
+  return result;
+}
+
+/* 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 p, float H, float lacunarity, float octaves)
+{
+  float rmd;
+  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;
+  }
+
+  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 p, float H, float lacunarity, float octaves)
+{
+  float rmd;
+  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;
+  }
+
+  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 p, float H, float lacunarity, float octaves, float offset)
+{
+  float value, increment, rmd;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  /* first unscaled octave of function; later octaves are scaled */
+  value = offset + safe_snoise(p);
+  p *= lacunarity;
+
+  for (int i = 1; i < (int)octaves; i++) {
+    increment = (safe_snoise(p) + offset) * pwr * value;
+    value += increment;
+    pwr *= pwHL;
+    p *= lacunarity;
+  }
+
+  rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    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 p, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float result, signal, weight, rmd;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  result = safe_snoise(p) + offset;
+  weight = gain * result;
+  p *= lacunarity;
+
+  for (int i = 1; (weight > 0.001) && (i < (int)octaves); i++) {
+    if (weight > 1.0) {
+      weight = 1.0;
+    }
+
+    signal = (safe_snoise(p) + offset) * pwr;
+    pwr *= pwHL;
+    result += weight * signal;
+    weight *= gain * signal;
+    p *= lacunarity;
+  }
+
+  rmd = octaves - floor(octaves);
+  if (rmd != 0.0) {
+    result += rmd * ((safe_snoise(p) + offset) * pwr);
+  }
+
+  return result;
+}
+
+/* 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 p, float H, float lacunarity, float octaves, float offset, float gain)
+{
+  float result, signal, weight;
+  float pwHL = pow(lacunarity, -H);
+  float pwr = pwHL;
+
+  signal = offset - fabs(safe_snoise(p));
+  signal *= signal;
+  result = signal;
+  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;
+    result += signal * pwr;
+    pwr *= pwHL;
+  }
+
+  return result;
+}
+
+/* 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 p, float H, float lacunarity, float octaves)
 {
   float rmd;
   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++) {
+  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)
+  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 

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list