Shader Nodes: Add Interpolation modes to Map Range node

Modes: Linear interpolation (default), stepped linear, smoothstep and smootherstep.

This also includes an additional option for the **Clamp node** to switch between **Min Max** (default) and **Range** mode.

This was needed to allow clamping when **To Max** is less than **To Min**.

Reviewed By: JacquesLucke, brecht

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

1 files changed, 36 insertions, 2 deletions

diff --git a/intern/cycles/kernel/svm/svm_map_range.h b/intern/cycles/kernel/svm/svm_map_range.h
index f2a68adbe61..533a631c837 100644
--- a/intern/cycles/kernel/svm/svm_map_range.h
+++ b/intern/cycles/kernel/svm/svm_map_range.h
@@ -18,32 +18,66 @@ CCL_NAMESPACE_BEGIN
 
 /* Map Range Node */
 
+ccl_device_inline float smootherstep(float edge0, float edge1, float x)
+{
+  x = clamp(safe_divide((x - edge0), (edge1 - edge0)), 0.0f, 1.0f);
+  return x * x * x * (x * (x * 6.0f - 15.0f) + 10.0f);
+}
+
 ccl_device void svm_node_map_range(KernelGlobals *kg,
                                    ShaderData *sd,
                                    float *stack,
                                    uint value_stack_offset,
                                    uint parameters_stack_offsets,
-                                   uint result_stack_offset,
+                                   uint results_stack_offsets,
                                    int *offset)
 {
   uint from_min_stack_offset, from_max_stack_offset, to_min_stack_offset, to_max_stack_offset;
+  uint type_stack_offset, steps_stack_offset, result_stack_offset;
   svm_unpack_node_uchar4(parameters_stack_offsets,
                          &from_min_stack_offset,
                          &from_max_stack_offset,
                          &to_min_stack_offset,
                          &to_max_stack_offset);
+  svm_unpack_node_uchar3(
+      results_stack_offsets, &type_stack_offset, &steps_stack_offset, &result_stack_offset);
 
   uint4 defaults = read_node(kg, offset);
+  uint4 defaults2 = read_node(kg, offset);
 
   float value = stack_load_float(stack, value_stack_offset);
   float from_min = stack_load_float_default(stack, from_min_stack_offset, defaults.x);
   float from_max = stack_load_float_default(stack, from_max_stack_offset, defaults.y);
   float to_min = stack_load_float_default(stack, to_min_stack_offset, defaults.z);
   float to_max = stack_load_float_default(stack, to_max_stack_offset, defaults.w);
+  float steps = stack_load_float_default(stack, steps_stack_offset, defaults2.x);
 
   float result;
+
   if (from_max != from_min) {
-    result = to_min + ((value - from_min) / (from_max - from_min)) * (to_max - to_min);
+    float factor = value;
+    switch (type_stack_offset) {
+      default:
+      case NODE_MAP_RANGE_LINEAR:
+        factor = (value - from_min) / (from_max - from_min);
+        break;
+      case NODE_MAP_RANGE_STEPPED: {
+        factor = (value - from_min) / (from_max - from_min);
+        factor = (steps > 0.0f) ? floorf(factor * (steps + 1.0f)) / steps : 0.0f;
+        break;
+      }
+      case NODE_MAP_RANGE_SMOOTHSTEP: {
+        factor = (from_min > from_max) ? 1.0f - smoothstep(from_max, from_min, factor) :
+                                         smoothstep(from_min, from_max, factor);
+        break;
+      }
+      case NODE_MAP_RANGE_SMOOTHERSTEP: {
+        factor = (from_min > from_max) ? 1.0f - smootherstep(from_max, from_min, factor) :
+                                         smootherstep(from_min, from_max, factor);
+        break;
+      }
+    }
+    result = to_min + factor * (to_max - to_min);
   }
   else {
     result = 0.0f;