[Bf-blender-cvs] [958d0d4236b] master: Shader Nodes: Add Interpolation modes to Map Range node
Charlie Jolly
noreply at git.blender.org
Sat Dec 7 13:56:50 CET 2019
Commit: 958d0d4236b1cfa600a7f36f6bdc51fdd0d98a97
Author: Charlie Jolly
Date: Sat Dec 7 12:35:07 2019 +0000
Branches: master
https://developer.blender.org/rB958d0d4236b1cfa600a7f36f6bdc51fdd0d98a97
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
===================================================================
M intern/cycles/blender/blender_shader.cpp
M intern/cycles/kernel/shaders/node_clamp.osl
M intern/cycles/kernel/shaders/node_map_range.osl
M intern/cycles/kernel/svm/svm_clamp.h
M intern/cycles/kernel/svm/svm_map_range.h
M intern/cycles/kernel/svm/svm_types.h
M intern/cycles/render/nodes.cpp
M intern/cycles/render/nodes.h
M release/scripts/addons
M release/scripts/addons_contrib
M source/blender/editors/space_node/drawnode.c
M source/blender/gpu/intern/gpu_material_library.h
M source/blender/gpu/shaders/material/gpu_shader_material_clamp.glsl
M source/blender/gpu/shaders/material/gpu_shader_material_map_range.glsl
M source/blender/makesdna/DNA_node_types.h
M source/blender/makesrna/RNA_enum_types.h
M source/blender/makesrna/intern/rna_nodetree.c
M source/blender/nodes/NOD_static_types.h
M source/blender/nodes/shader/nodes/node_shader_clamp.c
M source/blender/nodes/shader/nodes/node_shader_map_range.c
===================================================================
diff --git a/intern/cycles/blender/blender_shader.cpp b/intern/cycles/blender/blender_shader.cpp
index 22dbc3fba79..412e54ea29d 100644
--- a/intern/cycles/blender/blender_shader.cpp
+++ b/intern/cycles/blender/blender_shader.cpp
@@ -301,10 +301,14 @@ static ShaderNode *add_node(Scene *scene,
BL::ShaderNodeMapRange b_map_range_node(b_node);
MapRangeNode *map_range_node = new MapRangeNode();
map_range_node->clamp = b_map_range_node.clamp();
+ map_range_node->type = (NodeMapRangeType)b_map_range_node.interpolation_type();
node = map_range_node;
}
else if (b_node.is_a(&RNA_ShaderNodeClamp)) {
- node = new ClampNode();
+ BL::ShaderNodeClamp b_clamp_node(b_node);
+ ClampNode *clamp_node = new ClampNode();
+ clamp_node->type = (NodeClampType)b_clamp_node.clamp_type();
+ node = clamp_node;
}
else if (b_node.is_a(&RNA_ShaderNodeMath)) {
BL::ShaderNodeMath b_math_node(b_node);
diff --git a/intern/cycles/kernel/shaders/node_clamp.osl b/intern/cycles/kernel/shaders/node_clamp.osl
index 87dc1ccdb12..d689ba7f809 100644
--- a/intern/cycles/kernel/shaders/node_clamp.osl
+++ b/intern/cycles/kernel/shaders/node_clamp.osl
@@ -16,7 +16,11 @@
#include "stdosl.h"
-shader node_clamp(float Value = 1.0, float Min = 0.0, float Max = 1.0, output float Result = 0.0)
+shader node_clamp(string type = "minmax",
+ float Value = 1.0,
+ float Min = 0.0,
+ float Max = 1.0,
+ output float Result = 0.0)
{
- Result = clamp(Value, Min, Max);
+ Result = (type == "range" && (Min > Max)) ? clamp(Value, Max, Min) : clamp(Value, Min, Max);
}
diff --git a/intern/cycles/kernel/shaders/node_map_range.osl b/intern/cycles/kernel/shaders/node_map_range.osl
index 8a28edf5f35..242ec4271ed 100644
--- a/intern/cycles/kernel/shaders/node_map_range.osl
+++ b/intern/cycles/kernel/shaders/node_map_range.osl
@@ -16,14 +16,43 @@
#include "stdosl.h"
-shader node_map_range(float Value = 1.0,
+float safe_divide(float a, float b)
+{
+ return (b != 0.0) ? a / b : 0.0;
+}
+
+float smootherstep(float edge0, float edge1, float x)
+{
+ float t = clamp(safe_divide((x - edge0), (edge1 - edge0)), 0.0, 1.0);
+ return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
+}
+
+shader node_map_range(string type = "linear",
+ float Value = 1.0,
float FromMin = 0.0,
float FromMax = 1.0,
float ToMin = 0.0,
float ToMax = 1.0,
+ float Steps = 4.0,
output float Result = 0.0)
{
if (FromMax != FromMin) {
- Result = ToMin + ((Value - FromMin) / (FromMax - FromMin)) * (ToMax - ToMin);
+ float Factor = Value;
+ if (type == "stepped") {
+ Factor = (Value - FromMin) / (FromMax - FromMin);
+ Factor = (Steps > 0) ? floor(Factor * (Steps + 1.0)) / Steps : 0.0;
+ }
+ else if (type == "smoothstep") {
+ Factor = (FromMin > FromMax) ? 1.0 - smoothstep(FromMax, FromMin, Value) :
+ smoothstep(FromMin, FromMax, Value);
+ }
+ else if (type == "smootherstep") {
+ Factor = (FromMin > FromMax) ? 1.0 - smootherstep(FromMax, FromMin, Value) :
+ smootherstep(FromMin, FromMax, Value);
+ }
+ else {
+ Factor = (Value - FromMin) / (FromMax - FromMin);
+ }
+ Result = ToMin + Factor * (ToMax - ToMin);
}
}
diff --git a/intern/cycles/kernel/svm/svm_clamp.h b/intern/cycles/kernel/svm/svm_clamp.h
index a45e70a3f15..a85fd82754e 100644
--- a/intern/cycles/kernel/svm/svm_clamp.h
+++ b/intern/cycles/kernel/svm/svm_clamp.h
@@ -26,8 +26,8 @@ ccl_device void svm_node_clamp(KernelGlobals *kg,
uint result_stack_offset,
int *offset)
{
- uint min_stack_offset, max_stack_offset;
- svm_unpack_node_uchar2(parameters_stack_offsets, &min_stack_offset, &max_stack_offset);
+ uint min_stack_offset, max_stack_offset, type;
+ svm_unpack_node_uchar3(parameters_stack_offsets, &min_stack_offset, &max_stack_offset, &type);
uint4 defaults = read_node(kg, offset);
@@ -35,7 +35,12 @@ ccl_device void svm_node_clamp(KernelGlobals *kg,
float min = stack_load_float_default(stack, min_stack_offset, defaults.x);
float max = stack_load_float_default(stack, max_stack_offset, defaults.y);
- stack_store_float(stack, result_stack_offset, clamp(value, min, max));
+ if (type == NODE_CLAMP_RANGE && (min > max)) {
+ stack_store_float(stack, result_stack_offset, clamp(value, max, min));
+ }
+ else {
+ stack_store_float(stack, result_stack_offset, clamp(value, min, max));
+ }
}
CCL_NAMESPACE_END
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;
diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h
index 8e312a515d6..040e7c6a0f8 100644
--- a/intern/cycles/kernel/svm/svm_types.h
+++ b/intern/cycles/kernel/svm/svm_types.h
@@ -325,6 +325,18 @@ typedef enum NodeVectorMathType {
NODE_VECTOR_MATH_MAXIMUM,
} NodeVectorMathType;
+typedef enum NodeClampType {
+ NODE_CLAMP_MINMAX,
+ NODE_CLAMP_RANGE,
+} NodeClampType;
+
+typedef enum NodeMapRangeType {
+ NODE_MAP_RANGE_LINEAR,
+ NODE_MAP_RANGE_STEPPED,
+ NODE_MAP_RANGE_SMOOTHSTEP,
+ NODE_MAP_RANGE_SMOOTHERSTEP,
+} NodeMapRangeType;
+
typedef enum NodeMappingType {
NODE_MAPPING_TYPE_POINT,
NODE_MAPPING_TYPE_TEXTURE,
diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp
index c6f1e8409eb..26f16d5ee80 100644
--- a/intern/cycles/render/nodes.cpp
+++ b/intern/cycles/render/nodes.cpp
@@ -5561,11 +5561,19 @@ NODE_DEFINE(MapRangeNode)
{
NodeType *type = NodeType::add("map_range", create, NodeType::SHADER);
+ static NodeEnum type_enum;
+ type_enum.insert("linear", NODE_MAP_RANGE_LINEAR);
+ type_enum.insert("stepped", NODE_MAP_RANGE_STEPPED);
+ type_enum.insert("smoothstep", NODE_MAP_RANGE_SMOOTHSTEP);
+ type_enum.insert("smootherstep", NODE_MAP_RANGE_SMOOTHERSTEP);
+ SOCKET_ENUM(type, "Type", type_enum, NODE_MAP_RANGE_LINEAR);
+
SOCKET_IN_FLOAT(value, "Value", 1.0f);
SOCKET_IN_FLOAT(from_min, "From Min", 0.0f);
SOCKET_IN_FLOAT(from_max, "From Max", 1.0f);
SOCKET_IN_FLOAT(to_min, "To Min", 0.0f);
SOCKET_IN_FLOAT(to_max, "To Max", 1.0f);
+ SOCKET_IN_FLOAT(steps, "Steps", 4.0f);
SOCKET_OUT_FLOAT(result, "Result");
@@ -5582,6 +5590,7 @@ void MapRangeNode::expand(ShaderGraph *graph)
ShaderOutput *result_out = output("Result");
if (!result_out->links.empty()) {
ClampNode *clamp_node = new ClampNode();
+ clamp_node->type = NODE_CLAMP_RANGE;
graph->add(clamp_node);
graph->relink(result_out, clamp_node->output("Result"));
graph->connect(result_out, clamp_node->input("Value"));
@@ -5601,20 +5610,6 @@ void MapRangeNode::expand(ShaderGraph *graph)
}
}
-void MapRangeNode::constant_fold(const ConstantFolder &folder)
-{
- if (folder.all_inputs_constant()) {
- float result;
- if (from_max != from_min) {
- result = to_min +
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list