4 files changed, 384 insertions, 2 deletions

diff --git a/intern/cycles/scene/constant_fold.cpp b/intern/cycles/scene/constant_fold.cpp
index 4bce5661f9b..1aa4515a087 100644
--- a/intern/cycles/scene/constant_fold.cpp
+++ b/intern/cycles/scene/constant_fold.cpp
@@ -291,6 +291,101 @@ void ConstantFolder::fold_mix(NodeMix type, bool clamp) const
   }
 }
 
+void ConstantFolder::fold_mix_color(NodeMix type, bool clamp_factor, bool clamp) const
+{
+  ShaderInput *fac_in = node->input("Factor");
+  ShaderInput *color1_in = node->input("A");
+  ShaderInput *color2_in = node->input("B");
+
+  float fac = clamp_factor ? saturatef(node->get_float(fac_in->socket_type)) :
+                             node->get_float(fac_in->socket_type);
+  bool fac_is_zero = !fac_in->link && fac == 0.0f;
+  bool fac_is_one = !fac_in->link && fac == 1.0f;
+
+  /* remove no-op node when factor is 0.0 */
+  if (fac_is_zero) {
+    /* note that some of the modes will clamp out of bounds values even without use_clamp */
+    if (!(type == NODE_MIX_LIGHT || type == NODE_MIX_DODGE || type == NODE_MIX_BURN)) {
+      if (try_bypass_or_make_constant(color1_in, clamp)) {
+        return;
+      }
+    }
+  }
+
+  switch (type) {
+    case NODE_MIX_BLEND:
+      /* remove useless mix colors nodes */
+      if (color1_in->link && color2_in->link) {
+        if (color1_in->link == color2_in->link) {
+          try_bypass_or_make_constant(color1_in, clamp);
+          break;
+        }
+      }
+      else if (!color1_in->link && !color2_in->link) {
+        float3 color1 = node->get_float3(color1_in->socket_type);
+        float3 color2 = node->get_float3(color2_in->socket_type);
+        if (color1 == color2) {
+          try_bypass_or_make_constant(color1_in, clamp);
+          break;
+        }
+      }
+      /* remove no-op mix color node when factor is 1.0 */
+      if (fac_is_one) {
+        try_bypass_or_make_constant(color2_in, clamp);
+        break;
+      }
+      break;
+    case NODE_MIX_ADD:
+      /* 0 + X (fac 1) == X */
+      if (is_zero(color1_in) && fac_is_one) {
+        try_bypass_or_make_constant(color2_in, clamp);
+      }
+      /* X + 0 (fac ?) == X */
+      else if (is_zero(color2_in)) {
+        try_bypass_or_make_constant(color1_in, clamp);
+      }
+      break;
+    case NODE_MIX_SUB:
+      /* X - 0 (fac ?) == X */
+      if (is_zero(color2_in)) {
+        try_bypass_or_make_constant(color1_in, clamp);
+      }
+      /* X - X (fac 1) == 0 */
+      else if (color1_in->link && color1_in->link == color2_in->link && fac_is_one) {
+        make_zero();
+      }
+      break;
+    case NODE_MIX_MUL:
+      /* X * 1 (fac ?) == X, 1 * X (fac 1) == X */
+      if (is_one(color1_in) && fac_is_one) {
+        try_bypass_or_make_constant(color2_in, clamp);
+      }
+      else if (is_one(color2_in)) {
+        try_bypass_or_make_constant(color1_in, clamp);
+      }
+      /* 0 * ? (fac ?) == 0, ? * 0 (fac 1) == 0 */
+      else if (is_zero(color1_in)) {
+        make_zero();
+      }
+      else if (is_zero(color2_in) && fac_is_one) {
+        make_zero();
+      }
+      break;
+    case NODE_MIX_DIV:
+      /* X / 1 (fac ?) == X */
+      if (is_one(color2_in)) {
+        try_bypass_or_make_constant(color1_in, clamp);
+      }
+      /* 0 / ? (fac ?) == 0 */
+      else if (is_zero(color1_in)) {
+        make_zero();
+      }
+      break;
+    default:
+      break;
+  }
+}
+
 void ConstantFolder::fold_math(NodeMathType type) const
 {
   ShaderInput *value1_in = node->input("Value1");
diff --git a/intern/cycles/scene/constant_fold.h b/intern/cycles/scene/constant_fold.h
index 090ce367e6c..246ff2d31ee 100644
--- a/intern/cycles/scene/constant_fold.h
+++ b/intern/cycles/scene/constant_fold.h
@@ -51,6 +51,7 @@ class ConstantFolder {
 
   /* Specific nodes. */
   void fold_mix(NodeMix type, bool clamp) const;
+  void fold_mix_color(NodeMix type, bool clamp_factor, bool clamp) const;
   void fold_math(NodeMathType type) const;
   void fold_vector_math(NodeVectorMathType type) const;
   void fold_mapping(NodeMappingType type) const;
diff --git a/intern/cycles/scene/shader_nodes.cpp b/intern/cycles/scene/shader_nodes.cpp
index bedb0fe2902..a9cd453947b 100644
--- a/intern/cycles/scene/shader_nodes.cpp
+++ b/intern/cycles/scene/shader_nodes.cpp
@@ -4950,7 +4950,7 @@ NODE_DEFINE(MixNode)
   type_enum.insert("hue", NODE_MIX_HUE);
   type_enum.insert("saturation", NODE_MIX_SAT);
   type_enum.insert("value", NODE_MIX_VAL);
-  type_enum.insert("color", NODE_MIX_COLOR);
+  type_enum.insert("color", NODE_MIX_COL);
   type_enum.insert("soft_light", NODE_MIX_SOFT);
   type_enum.insert("linear_light", NODE_MIX_LINEAR);
   SOCKET_ENUM(mix_type, "Type", type_enum, NODE_MIX_BLEND);
@@ -4999,13 +4999,253 @@ void MixNode::compile(OSLCompiler &compiler)
 void MixNode::constant_fold(const ConstantFolder &folder)
 {
   if (folder.all_inputs_constant()) {
-    folder.make_constant_clamp(svm_mix(mix_type, fac, color1, color2), use_clamp);
+    folder.make_constant_clamp(svm_mix_clamped_factor(mix_type, fac, color1, color2), use_clamp);
   }
   else {
     folder.fold_mix(mix_type, use_clamp);
   }
 }
 
+/* Mix Color */
+
+NODE_DEFINE(MixColorNode)
+{
+  NodeType *type = NodeType::add("mix_color", create, NodeType::SHADER);
+
+  static NodeEnum type_enum;
+  type_enum.insert("mix", NODE_MIX_BLEND);
+  type_enum.insert("add", NODE_MIX_ADD);
+  type_enum.insert("multiply", NODE_MIX_MUL);
+  type_enum.insert("screen", NODE_MIX_SCREEN);
+  type_enum.insert("overlay", NODE_MIX_OVERLAY);
+  type_enum.insert("subtract", NODE_MIX_SUB);
+  type_enum.insert("divide", NODE_MIX_DIV);
+  type_enum.insert("difference", NODE_MIX_DIFF);
+  type_enum.insert("darken", NODE_MIX_DARK);
+  type_enum.insert("lighten", NODE_MIX_LIGHT);
+  type_enum.insert("dodge", NODE_MIX_DODGE);
+  type_enum.insert("burn", NODE_MIX_BURN);
+  type_enum.insert("hue", NODE_MIX_HUE);
+  type_enum.insert("saturation", NODE_MIX_SAT);
+  type_enum.insert("value", NODE_MIX_VAL);
+  type_enum.insert("color", NODE_MIX_COL);
+  type_enum.insert("soft_light", NODE_MIX_SOFT);
+  type_enum.insert("linear_light", NODE_MIX_LINEAR);
+  SOCKET_ENUM(blend_type, "Type", type_enum, NODE_MIX_BLEND);
+
+  SOCKET_IN_FLOAT(fac, "Factor", 0.5f);
+  SOCKET_IN_COLOR(a, "A", zero_float3());
+  SOCKET_IN_COLOR(b, "B", zero_float3());
+  SOCKET_BOOLEAN(use_clamp_result, "Use Clamp Result", false);
+  SOCKET_BOOLEAN(use_clamp, "Use Clamp", true);
+
+  SOCKET_OUT_COLOR(result, "Result");
+
+  return type;
+}
+
+MixColorNode::MixColorNode() : ShaderNode(get_node_type())
+{
+}
+
+void MixColorNode::compile(SVMCompiler &compiler)
+{
+  ShaderInput *fac_in = input("Factor");
+  ShaderInput *a_in = input("A");
+  ShaderInput *b_in = input("B");
+  ShaderOutput *result_out = output("Result");
+
+  int fac_in_stack_offset = compiler.stack_assign(fac_in);
+  int a_in_stack_offset = compiler.stack_assign(a_in);
+  int b_in_stack_offset = compiler.stack_assign(b_in);
+
+  compiler.add_node(
+      NODE_MIX_COLOR,
+      compiler.encode_uchar4(use_clamp, blend_type, use_clamp_result),
+      compiler.encode_uchar4(fac_in_stack_offset, a_in_stack_offset, b_in_stack_offset),
+      compiler.stack_assign(result_out));
+}
+
+void MixColorNode::compile(OSLCompiler &compiler)
+{
+  compiler.parameter(this, "blend_type");
+  compiler.parameter(this, "use_clamp");
+  compiler.parameter(this, "use_clamp_result");
+  compiler.add(this, "node_mix_color");
+}
+
+void MixColorNode::constant_fold(const ConstantFolder &folder)
+{
+  if (folder.all_inputs_constant()) {
+    if (use_clamp) {
+      fac = clamp(fac, 0.0f, 1.0f);
+    }
+    folder.make_constant_clamp(svm_mix(blend_type, fac, a, b), use_clamp_result);
+  }
+  else {
+    folder.fold_mix_color(blend_type, use_clamp, use_clamp_result);
+  }
+}
+
+/* Mix Float */
+
+NODE_DEFINE(MixFloatNode)
+{
+  NodeType *type = NodeType::add("mix_float", create, NodeType::SHADER);
+
+  SOCKET_IN_FLOAT(fac, "Factor", 0.5f);
+  SOCKET_IN_FLOAT(a, "A", 0.0f);
+  SOCKET_IN_FLOAT(b, "B", 0.0f);
+  SOCKET_BOOLEAN(use_clamp, "Use Clamp", true);
+  SOCKET_OUT_FLOAT(result, "Result");
+
+  return type;
+}
+
+MixFloatNode::MixFloatNode() : ShaderNode(get_node_type())
+{
+}
+
+void MixFloatNode::compile(SVMCompiler &compiler)
+{
+  ShaderInput *fac_in = input("Factor");
+  ShaderInput *a_in = input("A");
+  ShaderInput *b_in = input("B");
+  ShaderOutput *result_out = output("Result");
+
+  int fac_in_stack_offset = compiler.stack_assign(fac_in);
+  int a_in_stack_offset = compiler.stack_assign(a_in);
+  int b_in_stack_offset = compiler.stack_assign(b_in);
+
+  compiler.add_node(
+      NODE_MIX_FLOAT,
+      use_clamp,
+      compiler.encode_uchar4(fac_in_stack_offset, a_in_stack_offset, b_in_stack_offset),
+      compiler.stack_assign(result_out));
+}
+
+void MixFloatNode::compile(OSLCompiler &compiler)
+{
+  compiler.parameter(this, "use_clamp");
+  compiler.add(this, "node_mix_float");
+}
+
+void MixFloatNode::constant_fold(const ConstantFolder &folder)
+{
+  if (folder.all_inputs_constant()) {
+    if (use_clamp) {
+      fac = clamp(fac, 0.0f, 1.0f);
+    }
+    folder.make_constant(a * (1 - fac) + b * fac);
+  }
+}
+
+/* Mix Vector */
+
+NODE_DEFINE(MixVectorNode)
+{
+  NodeType *type = NodeType::add("mix_vector", create, NodeType::SHADER);
+
+  SOCKET_IN_FLOAT(fac, "Factor", 0.5f);
+  SOCKET_IN_VECTOR(a, "A", zero_float3());
+  SOCKET_IN_VECTOR(b, "B", zero_float3());
+  SOCKET_BOOLEAN(use_clamp, "Use Clamp", true);
+
+  SOCKET_OUT_VECTOR(result, "Result");
+
+  return type;
+}
+
+MixVectorNode::MixVectorNode() : ShaderNode(get_node_type())
+{
+}
+
+void MixVectorNode::compile(SVMCompiler &compiler)
+{
+  ShaderInput *fac_in = input("Factor");
+  ShaderInput *a_in = input("A");
+  ShaderInput *b_in = input("B");
+  ShaderOutput *result_out = output("Result");
+
+  int fac_in_stack_offset = compiler.stack_assign(fac_in);
+  int a_in_stack_offset = compiler.stack_assign(a_in);
+  int b_in_stack_offset = compiler.stack_assign(b_in);
+
+  compiler.add_node(
+      NODE_MIX_VECTOR,
+      compiler.encode_uchar4(use_clamp, fac_in_stack_offset, a_in_stack_offset, b_in_stack_offset),
+      compiler.stack_assign(result_out));
+}
+
+void MixVectorNode::compile(OSLCompiler &compiler)
+{
+  compiler.parameter(this, "use_clamp");
+  compiler.add(this, "node_mix_vector");
+}
+
+void MixVectorNode::constant_fold(const ConstantFolder &folder)
+{
+  if (folder.all_inputs_constant()) {
+    if (use_clamp) {
+      fac = clamp(fac, 0.0f, 1.0f);
+    }
+    folder.make_constant(a * (one_float3() - fac) + b * fac);
+  }
+}
+
+/* Mix Vector Non Uniform */
+
+NODE_DEFINE(MixVectorNonUniformNode)
+{
+  NodeType *type = NodeType::add("mix_vector_non_uniform", create, NodeType::SHADER);
+
+  SOCKET_IN_VECTOR(fac, "Factor", make_float3(0.5f, 0.5f, 0.5f));
+  SOCKET_IN_VECTOR(a, "A", zero_float3());
+  SOCKET_IN_VECTOR(b, "B", zero_float3());
+  SOCKET_BOOLEAN(use_clamp, "Use Clamp", true);
+
+  SOCKET_OUT_VECTOR(result, "Result");
+
+  return type;
+}
+
+MixVectorNonUniformNode::MixVectorNonUniformNode() : ShaderNode(get_node_type())
+{
+}
+
+void MixVectorNonUniformNode::compile(SVMCompiler &compiler)
+{
+  ShaderInput *fac_in = input("Factor");
+  ShaderInput *a_in = input("A");
+  ShaderInput *b_in = input("B");
+  ShaderOutput *result_out = output("Result");
+
+  int fac_in_stack_offset = compiler.stack_assign(fac_in);
+  int a_in_stack_offset = compiler.stack_assign(a_in);
+  int b_in_stack_offset = compiler.stack_assign(b_in);
+
+  compiler.add_node(
+      NODE_MIX_VECTOR_NON_UNIFORM,
+      compiler.encode_uchar4(use_clamp, fac_in_stack_offset, a_in_stack_offset, b_in_stack_offset),
+      compiler.stack_assign(result_out));
+}
+
+void MixVectorNonUniformNode::compile(OSLCompiler &compiler)
+{
+  compiler.parameter(this, "use_clamp");
+  compiler.add(this, "node_mix_vector_non_uniform");
+}
+
+void MixVectorNonUniformNode::constant_fold(const ConstantFolder &folder)
+{
+  if (folder.all_inputs_constant()) {
+    if (use_clamp) {
+      fac = saturate(fac);
+    }
+    folder.make_constant(a * (one_float3() - fac) + b * fac);
+  }
+}
+
 /* Combine Color */
 
 NODE_DEFINE(CombineColorNode)
diff --git a/intern/cycles/scene/shader_nodes.h b/intern/cycles/scene/shader_nodes.h
index ac40a397c1e..cc3a71a0697 100644
--- a/intern/cycles/scene/shader_nodes.h
+++ b/intern/cycles/scene/shader_nodes.h
@@ -1101,6 +1101,52 @@ class MixNode : public ShaderNode {
   NODE_SOCKET_API(float, fac)
 };
 
+class MixColorNode : public ShaderNode {
+ public:
+  SHADER_NODE_CLASS(MixColorNode)
+  void constant_fold(const ConstantFolder &folder);
+
+  NODE_SOCKET_API(float3, a)
+  NODE_SOCKET_API(float3, b)
+  NODE_SOCKET_API(float, fac)
+  NODE_SOCKET_API(bool, use_clamp)
+  NODE_SOCKET_API(bool, use_clamp_result)
+  NODE_SOCKET_API(NodeMix, blend_type)
+};
+
+class MixFloatNode : public ShaderNode {
+ public:
+  SHADER_NODE_CLASS(MixFloatNode)
+  void constant_fold(const ConstantFolder &folder);
+
+  NODE_SOCKET_API(float, a)
+  NODE_SOCKET_API(float, b)
+  NODE_SOCKET_API(float, fac)
+  NODE_SOCKET_API(bool, use_clamp)
+};
+
+class MixVectorNode : public ShaderNode {
+ public:
+  SHADER_NODE_CLASS(MixVectorNode)
+  void constant_fold(const ConstantFolder &folder);
+
+  NODE_SOCKET_API(float3, a)
+  NODE_SOCKET_API(float3, b)
+  NODE_SOCKET_API(float, fac)
+  NODE_SOCKET_API(bool, use_clamp)
+};
+
+class MixVectorNonUniformNode : public ShaderNode {
+ public:
+  SHADER_NODE_CLASS(MixVectorNonUniformNode)
+  void constant_fold(const ConstantFolder &folder);
+
+  NODE_SOCKET_API(float3, a)
+  NODE_SOCKET_API(float3, b)
+  NODE_SOCKET_API(float3, fac)
+  NODE_SOCKET_API(bool, use_clamp)
+};
+
 class CombineColorNode : public ShaderNode {
  public:
   SHADER_NODE_CLASS(CombineColorNode)