PointCloud: Initial rendering support for Workbenchtmp-pointcloud-render

Also includes outline overlays. Removes the temp overlay drawing

We make the geometry follow camera like billboards this uses less
geometry. Currently we use half octahedron for now. Goal would be
to use icospheres.

This patch also optimize the case when pointcloud has uniform radius.
However we should premultiply the radius prop by the default radius
beforehand to avoid a multiplication on CPU.

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

17 files changed, 788 insertions, 186 deletions

diff --git a/source/blender/nodes/CMakeLists.txt b/source/blender/nodes/CMakeLists.txt
index 31b5e922dab..2381e499eee 100644
--- a/source/blender/nodes/CMakeLists.txt
+++ b/source/blender/nodes/CMakeLists.txt
@@ -30,6 +30,7 @@ set(INC
   ../blenlib
   ../blentranslation
   ../depsgraph
+  ../functions
   ../gpu
   ../imbuf
   ../makesdna
@@ -37,6 +38,7 @@ set(INC
   ../render/extern/include
   ../../../intern/glew-mx
   ../../../intern/guardedalloc
+  ../../../intern/sky/include
 )
 
 set(INC_SYS
@@ -176,7 +178,7 @@ set(SRC
   shader/nodes/node_shader_light_path.c
   shader/nodes/node_shader_map_range.c
   shader/nodes/node_shader_mapping.c
-  shader/nodes/node_shader_math.c
+  shader/nodes/node_shader_math.cc
   shader/nodes/node_shader_mixRgb.c
   shader/nodes/node_shader_mix_shader.c
   shader/nodes/node_shader_normal.c
@@ -192,7 +194,7 @@ set(SRC
   shader/nodes/node_shader_script.c
   shader/nodes/node_shader_sepcombHSV.c
   shader/nodes/node_shader_sepcombRGB.c
-  shader/nodes/node_shader_sepcombXYZ.c
+  shader/nodes/node_shader_sepcombXYZ.cc
   shader/nodes/node_shader_shaderToRgb.c
   shader/nodes/node_shader_squeeze.c
   shader/nodes/node_shader_subsurface_scattering.c
@@ -214,10 +216,10 @@ set(SRC
   shader/nodes/node_shader_uvAlongStroke.c
   shader/nodes/node_shader_uvmap.c
   shader/nodes/node_shader_valToRgb.c
-  shader/nodes/node_shader_value.c
+  shader/nodes/node_shader_value.cc
   shader/nodes/node_shader_vectTransform.c
   shader/nodes/node_shader_vector_displacement.c
-  shader/nodes/node_shader_vector_math.c
+  shader/nodes/node_shader_vector_math.cc
   shader/nodes/node_shader_vector_rotate.c
   shader/nodes/node_shader_vertex_color.c
   shader/nodes/node_shader_volume_absorption.c
@@ -277,7 +279,7 @@ set(SRC
   intern/node_util.c
 
   composite/node_composite_util.h
-  function/node_function_util.h
+  function/node_function_util.hh
   shader/node_shader_util.h
   simulation/node_simulation_util.h
   texture/node_texture_util.h
@@ -296,6 +298,8 @@ set(SRC
 )
 
 set(LIB
+  bf_functions
+  bf_intern_sky
 )
 
 if(WITH_PYTHON)
diff --git a/source/blender/nodes/function/node_function_util.cc b/source/blender/nodes/function/node_function_util.cc
index 0927ba335fe..342c330a8fa 100644
--- a/source/blender/nodes/function/node_function_util.cc
+++ b/source/blender/nodes/function/node_function_util.cc
@@ -14,7 +14,7 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
-#include "node_function_util.h"
+#include "node_function_util.hh"
 #include "node_util.h"
 
 bool fn_node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *ntree)
diff --git a/source/blender/nodes/function/node_function_util.h b/source/blender/nodes/function/node_function_util.hh
index 85e252f9bdd..938cb5dd593 100644
--- a/source/blender/nodes/function/node_function_util.h
+++ b/source/blender/nodes/function/node_function_util.hh
@@ -19,6 +19,7 @@
 
 #include <string.h>
 
+#include "BLI_float3.hh"
 #include "BLI_utildefines.h"
 
 #include "MEM_guardedalloc.h"
@@ -26,6 +27,7 @@
 #include "DNA_node_types.h"
 
 #include "BKE_node.h"
+#include "BKE_node_tree_multi_function.hh"
 
 #include "BLT_translation.h"
 
@@ -33,6 +35,8 @@
 
 #include "node_util.h"
 
+#include "FN_multi_function_builder.hh"
+
 void fn_node_type_base(
     struct bNodeType *ntype, int type, const char *name, short nclass, short flag);
 bool fn_node_poll_default(struct bNodeType *ntype, struct bNodeTree *ntree);
diff --git a/source/blender/nodes/function/nodes/node_fn_boolean_math.cc b/source/blender/nodes/function/nodes/node_fn_boolean_math.cc
index 615ad4c6733..3a145311a08 100644
--- a/source/blender/nodes/function/nodes/node_fn_boolean_math.cc
+++ b/source/blender/nodes/function/nodes/node_fn_boolean_math.cc
@@ -19,7 +19,7 @@
 
 #include "RNA_enum_types.h"
 
-#include "node_function_util.h"
+#include "node_function_util.hh"
 
 static bNodeSocketTemplate fn_node_boolean_math_in[] = {
     {SOCK_BOOLEAN, N_("Boolean")},
@@ -50,6 +50,33 @@ static void node_boolean_math_label(bNodeTree *UNUSED(ntree), bNode *node, char
   BLI_strncpy(label, IFACE_(name), maxlen);
 }
 
+static const blender::fn::MultiFunction &get_multi_function(bNode &bnode)
+{
+  static blender::fn::CustomMF_SI_SI_SO<bool, bool, bool> and_fn{
+      "And", [](bool a, bool b) { return a && b; }};
+  static blender::fn::CustomMF_SI_SI_SO<bool, bool, bool> or_fn{
+      "Or", [](bool a, bool b) { return a || b; }};
+  static blender::fn::CustomMF_SI_SO<bool, bool> not_fn{"Not", [](bool a) { return !a; }};
+
+  switch (bnode.custom1) {
+    case NODE_BOOLEAN_MATH_AND:
+      return and_fn;
+    case NODE_BOOLEAN_MATH_OR:
+      return or_fn;
+    case NODE_BOOLEAN_MATH_NOT:
+      return not_fn;
+  }
+
+  BLI_assert(false);
+  return blender::fn::dummy_multi_function;
+}
+
+static void node_boolean_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder)
+{
+  const blender::fn::MultiFunction &fn = get_multi_function(builder.bnode());
+  builder.set_matching_fn(fn);
+}
+
 void register_node_type_fn_boolean_math()
 {
   static bNodeType ntype;
@@ -58,5 +85,6 @@ void register_node_type_fn_boolean_math()
   node_type_socket_templates(&ntype, fn_node_boolean_math_in, fn_node_boolean_math_out);
   node_type_label(&ntype, node_boolean_math_label);
   node_type_update(&ntype, node_boolean_math_update);
+  ntype.expand_in_mf_network = node_boolean_expand_in_mf_network;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/function/nodes/node_fn_combine_strings.cc b/source/blender/nodes/function/nodes/node_fn_combine_strings.cc
index 1b6091451d9..a880933bc12 100644
--- a/source/blender/nodes/function/nodes/node_fn_combine_strings.cc
+++ b/source/blender/nodes/function/nodes/node_fn_combine_strings.cc
@@ -1,4 +1,20 @@
-#include "node_function_util.h"
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "node_function_util.hh"
 
 static bNodeSocketTemplate fn_node_combine_strings_in[] = {
     {SOCK_STRING, N_("A")},
@@ -11,11 +27,20 @@ static bNodeSocketTemplate fn_node_combine_strings_out[] = {
     {-1, ""},
 };
 
+static void fn_node_combine_strings_expand_in_mf_network(
+    blender::bke::NodeMFNetworkBuilder &builder)
+{
+  static blender::fn::CustomMF_SI_SI_SO<std::string, std::string, std::string> combine_fn{
+      "Combine Strings", [](const std::string &a, const std::string &b) { return a + b; }};
+  builder.set_matching_fn(combine_fn);
+}
+
 void register_node_type_fn_combine_strings()
 {
   static bNodeType ntype;
 
   fn_node_type_base(&ntype, FN_NODE_COMBINE_STRINGS, "Combine Strings", 0, 0);
   node_type_socket_templates(&ntype, fn_node_combine_strings_in, fn_node_combine_strings_out);
+  ntype.expand_in_mf_network = fn_node_combine_strings_expand_in_mf_network;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/function/nodes/node_fn_float_compare.cc b/source/blender/nodes/function/nodes/node_fn_float_compare.cc
index 9788402850b..fb2c4d88caf 100644
--- a/source/blender/nodes/function/nodes/node_fn_float_compare.cc
+++ b/source/blender/nodes/function/nodes/node_fn_float_compare.cc
@@ -14,12 +14,14 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
+#include <cmath>
+
 #include "BLI_listbase.h"
 #include "BLI_string.h"
 
 #include "RNA_enum_types.h"
 
-#include "node_function_util.h"
+#include "node_function_util.hh"
 
 static bNodeSocketTemplate fn_node_float_compare_in[] = {
     {SOCK_FLOAT, N_("A"), 0.0f, 0.0f, 0.0f, 0.0f, -10000.0f, 10000.0f},
@@ -54,6 +56,46 @@ static void node_float_compare_label(bNodeTree *UNUSED(ntree),
   BLI_strncpy(label, IFACE_(name), maxlen);
 }
 
+static const blender::fn::MultiFunction &get_multi_function(bNode &node)
+{
+  static blender::fn::CustomMF_SI_SI_SO<float, float, bool> less_than_fn{
+      "Less Than", [](float a, float b) { return a < b; }};
+  static blender::fn::CustomMF_SI_SI_SO<float, float, bool> less_equal_fn{
+      "Less Equal", [](float a, float b) { return a <= b; }};
+  static blender::fn::CustomMF_SI_SI_SO<float, float, bool> greater_than_fn{
+      "Greater Than", [](float a, float b) { return a > b; }};
+  static blender::fn::CustomMF_SI_SI_SO<float, float, bool> greater_equal_fn{
+      "Greater Equal", [](float a, float b) { return a >= b; }};
+  static blender::fn::CustomMF_SI_SI_SI_SO<float, float, float, bool> equal_fn{
+      "Equal", [](float a, float b, float epsilon) { return std::abs(a - b) <= epsilon; }};
+  static blender::fn::CustomMF_SI_SI_SI_SO<float, float, float, bool> not_equal_fn{
+      "Not Equal", [](float a, float b, float epsilon) { return std::abs(a - b) > epsilon; }};
+
+  switch (node.custom1) {
+    case NODE_FLOAT_COMPARE_LESS_THAN:
+      return less_than_fn;
+    case NODE_FLOAT_COMPARE_LESS_EQUAL:
+      return less_equal_fn;
+    case NODE_FLOAT_COMPARE_GREATER_THAN:
+      return greater_than_fn;
+    case NODE_FLOAT_COMPARE_GREATER_EQUAL:
+      return greater_equal_fn;
+    case NODE_FLOAT_COMPARE_EQUAL:
+      return equal_fn;
+    case NODE_FLOAT_COMPARE_NOT_EQUAL:
+      return not_equal_fn;
+  }
+
+  BLI_assert(false);
+  return blender::fn::dummy_multi_function;
+}
+
+static void node_float_compare_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder)
+{
+  const blender::fn::MultiFunction &fn = get_multi_function(builder.bnode());
+  builder.set_matching_fn(fn);
+}
+
 void register_node_type_fn_float_compare()
 {
   static bNodeType ntype;
@@ -62,5 +104,6 @@ void register_node_type_fn_float_compare()
   node_type_socket_templates(&ntype, fn_node_float_compare_in, fn_node_float_compare_out);
   node_type_label(&ntype, node_float_compare_label);
   node_type_update(&ntype, node_float_compare_update);
+  ntype.expand_in_mf_network = node_float_compare_expand_in_mf_network;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/function/nodes/node_fn_group_instance_id.cc b/source/blender/nodes/function/nodes/node_fn_group_instance_id.cc
index 2ac86ee2407..c61c941ee0d 100644
--- a/source/blender/nodes/function/nodes/node_fn_group_instance_id.cc
+++ b/source/blender/nodes/function/nodes/node_fn_group_instance_id.cc
@@ -1,15 +1,45 @@
-#include "node_function_util.h"
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "node_function_util.hh"
 
 static bNodeSocketTemplate fn_node_group_instance_id_out[] = {
     {SOCK_STRING, N_("Identifier")},
     {-1, ""},
 };
 
+static void fn_node_group_instance_id_expand_in_mf_network(
+    blender::bke::NodeMFNetworkBuilder &builder)
+{
+  const blender::bke::DNode &node = builder.dnode();
+  std::string id = "/";
+  for (const blender::bke::DParentNode *parent = node.parent(); parent;
+       parent = parent->parent()) {
+    id = "/" + parent->node_ref().name() + id;
+  }
+  builder.construct_and_set_matching_fn<blender::fn::CustomMF_Constant<std::string>>(
+      std::move(id));
+}
+
 void register_node_type_fn_group_instance_id()
 {
   static bNodeType ntype;
 
   fn_node_type_base(&ntype, FN_NODE_GROUP_INSTANCE_ID, "Group Instance ID", 0, 0);
   node_type_socket_templates(&ntype, nullptr, fn_node_group_instance_id_out);
+  ntype.expand_in_mf_network = fn_node_group_instance_id_expand_in_mf_network;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/function/nodes/node_fn_switch.cc b/source/blender/nodes/function/nodes/node_fn_switch.cc
index cb721058875..281ddb05c76 100644
--- a/source/blender/nodes/function/nodes/node_fn_switch.cc
+++ b/source/blender/nodes/function/nodes/node_fn_switch.cc
@@ -15,7 +15,7 @@
  */
 
 #include "BLI_listbase.h"
-#include "node_function_util.h"
+#include "node_function_util.hh"
 
 static bNodeSocketTemplate fn_node_switch_in[] = {
     {SOCK_BOOLEAN, N_("Switch")},
diff --git a/source/blender/nodes/intern/node_socket.cc b/source/blender/nodes/intern/node_socket.cc
index b23511c3bdb..02124465dda 100644
--- a/source/blender/nodes/intern/node_socket.cc
+++ b/source/blender/nodes/intern/node_socket.cc
@@ -25,6 +25,8 @@
 
 #include "DNA_node_types.h"
 
+#include "BLI_color.hh"
+#include "BLI_float3.hh"
 #include "BLI_listbase.h"
 #include "BLI_math.h"
 #include "BLI_string.h"
@@ -32,6 +34,7 @@
 
 #include "BKE_lib_id.h"
 #include "BKE_node.h"
+#include "BKE_node_tree_multi_function.hh"
 
 #include "RNA_access.h"
 #include "RNA_types.h"
@@ -510,35 +513,105 @@ static bNodeSocketType *make_socket_type_control_flow(int type)
   return stype;
 }
 
+static bNodeSocketType *make_socket_type_bool()
+{
+  bNodeSocketType *socktype = make_standard_socket_type(SOCK_BOOLEAN, PROP_NONE);
+  socktype->get_mf_data_type = []() { return blender::fn::MFDataType::ForSingle<bool>(); };
+  socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) {
+    bool value = builder.socket_default_value<bNodeSocketValueBoolean>()->value;
+    builder.set_constant_value(value);
+  };
+  return socktype;
+}
+
+static bNodeSocketType *make_socket_type_float(PropertySubType subtype)
+{
+  bNodeSocketType *socktype = make_standard_socket_type(SOCK_FLOAT, subtype);
+  socktype->get_mf_data_type = []() { return blender::fn::MFDataType::ForSingle<float>(); };
+  socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) {
+    float value = builder.socket_default_value<bNodeSocketValueFloat>()->value;
+    builder.set_constant_value(value);
+  };
+  return socktype;
+}
+
+static bNodeSocketType *make_socket_type_int(PropertySubType subtype)
+{
+  bNodeSocketType *socktype = make_standard_socket_type(SOCK_INT, subtype);
+  socktype->get_mf_data_type = []() { return blender::fn::MFDataType::ForSingle<int>(); };
+  socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) {
+    int value = builder.socket_default_value<bNodeSocketValueInt>()->value;
+    builder.set_constant_value(value);
+  };
+  return socktype;
+}
+
+static bNodeSocketType *make_socket_type_vector(PropertySubType subtype)
+{
+  bNodeSocketType *socktype = make_standard_socket_type(SOCK_VECTOR, subtype);
+  socktype->get_mf_data_type = []() {
+    return blender::fn::MFDataType::ForSingle<blender::float3>();
+  };
+  socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) {
+    blender::float3 value = builder.socket_default_value<bNodeSocketValueVector>()->value;
+    builder.set_constant_value(value);
+  };
+  return socktype;
+}
+
+static bNodeSocketType *make_socket_type_rgba()
+{
+  bNodeSocketType *socktype = make_standard_socket_type(SOCK_RGBA, PROP_NONE);
+  socktype->get_mf_data_type = []() {
+    return blender::fn::MFDataType::ForSingle<blender::Color4f>();
+  };
+  socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) {
+    blender::Color4f value = builder.socket_default_value<bNodeSocketValueRGBA>()->value;
+    builder.set_constant_value(value);
+  };
+  return socktype;
+}
+
+static bNodeSocketType *make_socket_type_string()
+{
+  bNodeSocketType *socktype = make_standard_socket_type(SOCK_STRING, PROP_NONE);
+  socktype->get_mf_data_type = []() { return blender::fn::MFDataType::ForSingle<std::string>(); };
+  socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) {
+    std::string value = builder.socket_default_value<bNodeSocketValueString>()->value;
+    builder.set_constant_value(value);
+  };
+  return socktype;
+}
+
 void register_standard_node_socket_types(void)
 {
   /* draw callbacks are set in drawnode.c to avoid bad-level calls */
 
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_NONE));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_UNSIGNED));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_PERCENTAGE));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_FACTOR));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_ANGLE));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_TIME));
+  nodeRegisterSocketType(make_socket_type_float(PROP_NONE));
+  nodeRegisterSocketType(make_socket_type_float(PROP_UNSIGNED));
+  nodeRegisterSocketType(make_socket_type_float(PROP_PERCENTAGE));
+  nodeRegisterSocketType(make_socket_type_float(PROP_FACTOR));
+  nodeRegisterSocketType(make_socket_type_float(PROP_ANGLE));
+  nodeRegisterSocketType(make_socket_type_float(PROP_TIME));
 
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_NONE));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_UNSIGNED));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_PERCENTAGE));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_FACTOR));
+  nodeRegisterSocketType(make_socket_type_int(PROP_NONE));
+  nodeRegisterSocketType(make_socket_type_int(PROP_UNSIGNED));
+  nodeRegisterSocketType(make_socket_type_int(PROP_PERCENTAGE));
+  nodeRegisterSocketType(make_socket_type_int(PROP_FACTOR));
 
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_BOOLEAN, PROP_NONE));
+  nodeRegisterSocketType(make_socket_type_bool());
 
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_NONE));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_TRANSLATION));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_DIRECTION));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_VELOCITY));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_ACCELERATION));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_EULER));
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_XYZ));
+  nodeRegisterSocketType(make_socket_type_vector(PROP_NONE));
+  nodeRegisterSocketType(make_socket_type_vector(PROP_TRANSLATION));
+  nodeRegisterSocketType(make_socket_type_vector(PROP_DIRECTION));
+  nodeRegisterSocketType(make_socket_type_vector(PROP_VELOCITY));
+  nodeRegisterSocketType(make_socket_type_vector(PROP_ACCELERATION));
+  nodeRegisterSocketType(make_socket_type_vector(PROP_EULER));
+  nodeRegisterSocketType(make_socket_type_vector(PROP_XYZ));
 
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_RGBA, PROP_NONE));
+  nodeRegisterSocketType(make_socket_type_rgba());
 
-  nodeRegisterSocketType(make_standard_socket_type(SOCK_STRING, PROP_NONE));
+  nodeRegisterSocketType(make_socket_type_string());
 
   nodeRegisterSocketType(make_standard_socket_type(SOCK_SHADER, PROP_NONE));
 
diff --git a/source/blender/nodes/shader/node_shader_util.h b/source/blender/nodes/shader/node_shader_util.h
index fbb9979cdfa..fc262544b4f 100644
--- a/source/blender/nodes/shader/node_shader_util.h
+++ b/source/blender/nodes/shader/node_shader_util.h
@@ -70,6 +70,12 @@
 #include "GPU_uniformbuffer.h"
 
 #ifdef __cplusplus
+#  include "FN_multi_function_builder.hh"
+
+#  include "BKE_node_tree_multi_function.hh"
+
+#  include "BLI_float3.hh"
+
 extern "C" {
 #endif
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_math.c b/source/blender/nodes/shader/nodes/node_shader_math.c
deleted file mode 100644
index 8abebbf5081..00000000000
--- a/source/blender/nodes/shader/nodes/node_shader_math.c
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2005 Blender Foundation.
- * All rights reserved.
- */
-
-/** \file
- * \ingroup shdnodes
- */
-
-#include "node_shader_util.h"
-
-/* **************** SCALAR MATH ******************** */
-static bNodeSocketTemplate sh_node_math_in[] = {
-    {SOCK_FLOAT, N_("Value"), 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE},
-    {SOCK_FLOAT, N_("Value"), 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE},
-    {SOCK_FLOAT, N_("Value"), 0.0f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE},
-    {-1, ""}};
-
-static bNodeSocketTemplate sh_node_math_out[] = {{SOCK_FLOAT, N_("Value")}, {-1, ""}};
-
-static int gpu_shader_math(GPUMaterial *mat,
-                           bNode *node,
-                           bNodeExecData *UNUSED(execdata),
-                           GPUNodeStack *in,
-                           GPUNodeStack *out)
-{
-  static const char *names[] = {
-      [NODE_MATH_ADD] = "math_add",
-      [NODE_MATH_SUBTRACT] = "math_subtract",
-      [NODE_MATH_MULTIPLY] = "math_multiply",
-      [NODE_MATH_DIVIDE] = "math_divide",
-      [NODE_MATH_MULTIPLY_ADD] = "math_multiply_add",
-
-      [NODE_MATH_POWER] = "math_power",
-      [NODE_MATH_LOGARITHM] = "math_logarithm",
-      [NODE_MATH_EXPONENT] = "math_exponent",
-      [NODE_MATH_SQRT] = "math_sqrt",
-      [NODE_MATH_INV_SQRT] = "math_inversesqrt",
-      [NODE_MATH_ABSOLUTE] = "math_absolute",
-      [NODE_MATH_RADIANS] = "math_radians",
-      [NODE_MATH_DEGREES] = "math_degrees",
-
-      [NODE_MATH_MINIMUM] = "math_minimum",
-      [NODE_MATH_MAXIMUM] = "math_maximum",
-      [NODE_MATH_LESS_THAN] = "math_less_than",
-      [NODE_MATH_GREATER_THAN] = "math_greater_than",
-      [NODE_MATH_SIGN] = "math_sign",
-      [NODE_MATH_COMPARE] = "math_compare",
-      [NODE_MATH_SMOOTH_MIN] = "math_smoothmin",
-      [NODE_MATH_SMOOTH_MAX] = "math_smoothmax",
-
-      [NODE_MATH_ROUND] = "math_round",
-      [NODE_MATH_FLOOR] = "math_floor",
-      [NODE_MATH_CEIL] = "math_ceil",
-      [NODE_MATH_FRACTION] = "math_fraction",
-      [NODE_MATH_MODULO] = "math_modulo",
-      [NODE_MATH_TRUNC] = "math_trunc",
-      [NODE_MATH_SNAP] = "math_snap",
-      [NODE_MATH_WRAP] = "math_wrap",
-      [NODE_MATH_PINGPONG] = "math_pingpong",
-
-      [NODE_MATH_SINE] = "math_sine",
-      [NODE_MATH_COSINE] = "math_cosine",
-      [NODE_MATH_TANGENT] = "math_tangent",
-      [NODE_MATH_SINH] = "math_sinh",
-      [NODE_MATH_COSH] = "math_cosh",
-      [NODE_MATH_TANH] = "math_tanh",
-      [NODE_MATH_ARCSINE] = "math_arcsine",
-      [NODE_MATH_ARCCOSINE] = "math_arccosine",
-      [NODE_MATH_ARCTANGENT] = "math_arctangent",
-      [NODE_MATH_ARCTAN2] = "math_arctan2",
-  };
-
-  if (node->custom1 < ARRAY_SIZE(names) && names[node->custom1]) {
-    int ret = GPU_stack_link(mat, node, names[node->custom1], in, out);
-
-    if (ret && node->custom2 & SHD_MATH_CLAMP) {
-      float min[3] = {0.0f, 0.0f, 0.0f};
-      float max[3] = {1.0f, 1.0f, 1.0f};
-      GPU_link(
-          mat, "clamp_value", out[0].link, GPU_constant(min), GPU_constant(max), &out[0].link);
-    }
-    return ret;
-  }
-  else {
-    return 0;
-  }
-}
-
-void register_node_type_sh_math(void)
-{
-  static bNodeType ntype;
-
-  sh_fn_node_type_base(&ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, 0);
-  node_type_socket_templates(&ntype, sh_node_math_in, sh_node_math_out);
-  node_type_label(&ntype, node_math_label);
-  node_type_gpu(&ntype, gpu_shader_math);
-  node_type_update(&ntype, node_math_update);
-
-  nodeRegisterType(&ntype);
-}
diff --git a/source/blender/nodes/shader/nodes/node_shader_math.cc b/source/blender/nodes/shader/nodes/node_shader_math.cc
new file mode 100644
index 00000000000..a0eb5099f9d
--- /dev/null
+++ b/source/blender/nodes/shader/nodes/node_shader_math.cc
@@ -0,0 +1,196 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2005 Blender Foundation.
+ * All rights reserved.
+ */
+
+/** \file
+ * \ingroup shdnodes
+ */
+
+#include "node_shader_util.h"
+
+/* **************** SCALAR MATH ******************** */
+static bNodeSocketTemplate sh_node_math_in[] = {
+    {SOCK_FLOAT, N_("Value"), 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE},
+    {SOCK_FLOAT, N_("Value"), 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE},
+    {SOCK_FLOAT, N_("Value"), 0.0f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE},
+    {-1, ""}};
+
+static bNodeSocketTemplate sh_node_math_out[] = {{SOCK_FLOAT, N_("Value")}, {-1, ""}};
+
+static const char *gpu_shader_get_name(int mode)
+{
+  switch (mode) {
+    case NODE_MATH_ADD:
+      return "math_add";
+    case NODE_MATH_SUBTRACT:
+      return "math_subtract";
+    case NODE_MATH_MULTIPLY:
+      return "math_multiply";
+    case NODE_MATH_DIVIDE:
+      return "math_divide";
+    case NODE_MATH_MULTIPLY_ADD:
+      return "math_multiply_add";
+
+    case NODE_MATH_POWER:
+      return "math_power";
+    case NODE_MATH_LOGARITHM:
+      return "math_logarithm";
+    case NODE_MATH_EXPONENT:
+      return "math_exponent";
+    case NODE_MATH_SQRT:
+      return "math_sqrt";
+    case NODE_MATH_INV_SQRT:
+      return "math_inversesqrt";
+    case NODE_MATH_ABSOLUTE:
+      return "math_absolute";
+    case NODE_MATH_RADIANS:
+      return "math_radians";
+    case NODE_MATH_DEGREES:
+      return "math_degrees";
+
+    case NODE_MATH_MINIMUM:
+      return "math_minimum";
+    case NODE_MATH_MAXIMUM:
+      return "math_maximum";
+    case NODE_MATH_LESS_THAN:
+      return "math_less_than";
+    case NODE_MATH_GREATER_THAN:
+      return "math_greater_than";
+    case NODE_MATH_SIGN:
+      return "math_sign";
+    case NODE_MATH_COMPARE:
+      return "math_compare";
+    case NODE_MATH_SMOOTH_MIN:
+      return "math_smoothmin";
+    case NODE_MATH_SMOOTH_MAX:
+      return "math_smoothmax";
+
+    case NODE_MATH_ROUND:
+      return "math_round";
+    case NODE_MATH_FLOOR:
+      return "math_floor";
+    case NODE_MATH_CEIL:
+      return "math_ceil";
+    case NODE_MATH_FRACTION:
+      return "math_fraction";
+    case NODE_MATH_MODULO:
+      return "math_modulo";
+    case NODE_MATH_TRUNC:
+      return "math_trunc";
+    case NODE_MATH_SNAP:
+      return "math_snap";
+    case NODE_MATH_WRAP:
+      return "math_wrap";
+    case NODE_MATH_PINGPONG:
+      return "math_pingpong";
+
+    case NODE_MATH_SINE:
+      return "math_sine";
+    case NODE_MATH_COSINE:
+      return "math_cosine";
+    case NODE_MATH_TANGENT:
+      return "math_tangent";
+    case NODE_MATH_SINH:
+      return "math_sinh";
+    case NODE_MATH_COSH:
+      return "math_cosh";
+    case NODE_MATH_TANH:
+      return "math_tanh";
+    case NODE_MATH_ARCSINE:
+      return "math_arcsine";
+    case NODE_MATH_ARCCOSINE:
+      return "math_arccosine";
+    case NODE_MATH_ARCTANGENT:
+      return "math_arctangent";
+    case NODE_MATH_ARCTAN2:
+      return "math_arctan2";
+  }
+  return nullptr;
+}
+
+static int gpu_shader_math(GPUMaterial *mat,
+                           bNode *node,
+                           bNodeExecData *UNUSED(execdata),
+                           GPUNodeStack *in,
+                           GPUNodeStack *out)
+{
+  const char *name = gpu_shader_get_name(node->custom1);
+  if (name != nullptr) {
+    int ret = GPU_stack_link(mat, node, name, in, out);
+
+    if (ret && node->custom2 & SHD_MATH_CLAMP) {
+      float min[3] = {0.0f, 0.0f, 0.0f};
+      float max[3] = {1.0f, 1.0f, 1.0f};
+      GPU_link(
+          mat, "clamp_value", out[0].link, GPU_constant(min), GPU_constant(max), &out[0].link);
+    }
+    return ret;
+  }
+  else {
+    return 0;
+  }
+}
+
+static void sh_node_math_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder)
+{
+  /* TODO: Implement clamp and other operations. */
+  const int mode = builder.bnode().custom1;
+  switch (mode) {
+    case NODE_MATH_ADD: {
+      static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{
+          "Add", [](float a, float b) { return a + b; }};
+      builder.set_matching_fn(fn);
+      break;
+    }
+    case NODE_MATH_SUBTRACT: {
+      static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{
+          "Subtract", [](float a, float b) { return a - b; }};
+      builder.set_matching_fn(fn);
+      break;
+    }
+    case NODE_MATH_MULTIPLY: {
+      static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{
+          "Multiply", [](float a, float b) { return a * b; }};
+      builder.set_matching_fn(fn);
+      break;
+    }
+    case NODE_MATH_DIVIDE: {
+      static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{
+          "Divide", [](float a, float b) { return (b != 0.0f) ? a / b : 0.0f; }};
+      builder.set_matching_fn(fn);
+      break;
+    }
+    default:
+      BLI_assert(false);
+      break;
+  }
+}
+
+void register_node_type_sh_math(void)
+{
+  static bNodeType ntype;
+
+  sh_fn_node_type_base(&ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, 0);
+  node_type_socket_templates(&ntype, sh_node_math_in, sh_node_math_out);
+  node_type_label(&ntype, node_math_label);
+  node_type_gpu(&ntype, gpu_shader_math);
+  node_type_update(&ntype, node_math_update);
+  ntype.expand_in_mf_network = sh_node_math_expand_in_mf_network;
+
+  nodeRegisterType(&ntype);
+}
diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.c b/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.cc
index 429b1a3e818..4dbe10f3982 100644
--- a/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.c
+++ b/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.cc
@@ -44,6 +44,42 @@ static int gpu_shader_sepxyz(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "separate_xyz", in, out);
 }
 
+class MF_SeparateXYZ : public blender::fn::MultiFunction {
+ public:
+  MF_SeparateXYZ()
+  {
+    blender::fn::MFSignatureBuilder signature = this->get_builder("Separate XYZ");
+    signature.single_input<blender::float3>("XYZ");
+    signature.single_output<float>("X");
+    signature.single_output<float>("Y");
+    signature.single_output<float>("Z");
+  }
+
+  void call(blender::IndexMask mask,
+            blender::fn::MFParams params,
+            blender::fn::MFContext UNUSED(context)) const override
+  {
+    blender::fn::VSpan<blender::float3> vectors = params.readonly_single_input<blender::float3>(
+        0, "XYZ");
+    blender::MutableSpan<float> xs = params.uninitialized_single_output<float>(1, "X");
+    blender::MutableSpan<float> ys = params.uninitialized_single_output<float>(2, "Y");
+    blender::MutableSpan<float> zs = params.uninitialized_single_output<float>(3, "Z");
+
+    for (uint i : mask) {
+      blender::float3 xyz = vectors[i];
+      xs[i] = xyz.x;
+      ys[i] = xyz.y;
+      zs[i] = xyz.z;
+    }
+  }
+};
+
+static void sh_node_sepxyz_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder)
+{
+  static MF_SeparateXYZ separate_fn;
+  builder.set_matching_fn(separate_fn);
+}
+
 void register_node_type_sh_sepxyz(void)
 {
   static bNodeType ntype;
@@ -51,6 +87,7 @@ void register_node_type_sh_sepxyz(void)
   sh_fn_node_type_base(&ntype, SH_NODE_SEPXYZ, "Separate XYZ", NODE_CLASS_CONVERTOR, 0);
   node_type_socket_templates(&ntype, sh_node_sepxyz_in, sh_node_sepxyz_out);
   node_type_gpu(&ntype, gpu_shader_sepxyz);
+  ntype.expand_in_mf_network = sh_node_sepxyz_expand_in_mf_network;
 
   nodeRegisterType(&ntype);
 }
@@ -76,6 +113,39 @@ static int gpu_shader_combxyz(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "combine_xyz", in, out);
 }
 
+class MF_CombineXYZ : public blender::fn::MultiFunction {
+ public:
+  MF_CombineXYZ()
+  {
+    blender::fn::MFSignatureBuilder signature = this->get_builder("Combine XYZ");
+    signature.single_input<float>("X");
+    signature.single_input<float>("Y");
+    signature.single_input<float>("Z");
+    signature.single_output<blender::float3>("XYZ");
+  }
+
+  void call(blender::IndexMask mask,
+            blender::fn::MFParams params,
+            blender::fn::MFContext UNUSED(context)) const override
+  {
+    blender::fn::VSpan<float> xs = params.readonly_single_input<float>(0, "X");
+    blender::fn::VSpan<float> ys = params.readonly_single_input<float>(1, "Y");
+    blender::fn::VSpan<float> zs = params.readonly_single_input<float>(2, "Z");
+    blender::MutableSpan<blender::float3> vectors =
+        params.uninitialized_single_output<blender::float3>(3, "XYZ");
+
+    for (uint i : mask) {
+      vectors[i] = {xs[i], ys[i], zs[i]};
+    }
+  }
+};
+
+static void sh_node_combxyz_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder)
+{
+  static MF_CombineXYZ combine_fn;
+  builder.set_matching_fn(combine_fn);
+}
+
 void register_node_type_sh_combxyz(void)
 {
   static bNodeType ntype;
@@ -83,6 +153,7 @@ void register_node_type_sh_combxyz(void)
   sh_fn_node_type_base(&ntype, SH_NODE_COMBXYZ, "Combine XYZ", NODE_CLASS_CONVERTOR, 0);
   node_type_socket_templates(&ntype, sh_node_combxyz_in, sh_node_combxyz_out);
   node_type_gpu(&ntype, gpu_shader_combxyz);
+  ntype.expand_in_mf_network = sh_node_combxyz_expand_in_mf_network;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_sky.c b/source/blender/nodes/shader/nodes/node_shader_tex_sky.c
index 0daa948c139..d2c4413b862 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_sky.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_sky.c
@@ -18,6 +18,7 @@
  */
 
 #include "../node_shader_util.h"
+#include "sky_model.h"
 
 /* **************** OUTPUT ******************** */
 
@@ -43,9 +44,10 @@ static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node)
   tex->ground_albedo = 0.3f;
   tex->sun_disc = true;
   tex->sun_size = DEG2RADF(0.545);
+  tex->sun_intensity = 1.0f;
   tex->sun_elevation = M_PI_2;
   tex->sun_rotation = 0.0f;
-  tex->altitude = 0;
+  tex->altitude = 0.0f;
   tex->air_density = 1.0f;
   tex->dust_density = 1.0f;
   tex->ozone_density = 1.0f;
@@ -53,19 +55,172 @@ static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node)
   node->storage = tex;
 }
 
+typedef struct SkyModelPreetham {
+  float config_Y[5], config_x[5], config_y[5]; /* named after xyY color space */
+  float radiance[3];
+} SkyModelPreetham;
+
+typedef struct XYZ_to_RGB /* transposed imbuf_xyz_to_rgb, passed as 3x vec3 */
+{
+  float r[3], g[3], b[3];
+} XYZ_to_RGB;
+
+static float sky_perez_function(const float *lam, float theta, float gamma)
+{
+  float ctheta = cosf(theta);
+  float cgamma = cosf(gamma);
+
+  return (1.0 + lam[0] * expf(lam[1] / ctheta)) *
+         (1.0 + lam[2] * expf(lam[3] * gamma) + lam[4] * cgamma * cgamma);
+}
+
+static void sky_precompute_old(SkyModelPreetham *sunsky, const float sun_angles[], float turbidity)
+{
+  float theta = sun_angles[0];
+  float theta2 = theta * theta;
+  float theta3 = theta2 * theta;
+  float T = turbidity;
+  float T2 = T * T;
+  float chi = (4.0f / 9.0f - T / 120.0f) * (M_PI - 2.0f * theta);
+
+  sunsky->radiance[0] = (4.0453f * T - 4.9710f) * tanf(chi) - 0.2155f * T + 2.4192f;
+  sunsky->radiance[0] *= 0.06f;
+
+  sunsky->radiance[1] = (0.00166f * theta3 - 0.00375f * theta2 + 0.00209f * theta) * T2 +
+                        (-0.02903f * theta3 + 0.06377f * theta2 - 0.03202f * theta + 0.00394f) *
+                            T +
+                        (0.11693f * theta3 - 0.21196f * theta2 + 0.06052f * theta + 0.25886f);
+
+  sunsky->radiance[2] = (0.00275f * theta3 - 0.00610f * theta2 + 0.00317f * theta) * T2 +
+                        (-0.04214f * theta3 + 0.08970f * theta2 - 0.04153f * theta + 0.00516f) *
+                            T +
+                        (0.15346f * theta3 - 0.26756f * theta2 + 0.06670f * theta + 0.26688f);
+
+  sunsky->config_Y[0] = (0.1787f * T - 1.4630f);
+  sunsky->config_Y[1] = (-0.3554f * T + 0.4275f);
+  sunsky->config_Y[2] = (-0.0227f * T + 5.3251f);
+  sunsky->config_Y[3] = (0.1206f * T - 2.5771f);
+  sunsky->config_Y[4] = (-0.0670f * T + 0.3703f);
+
+  sunsky->config_x[0] = (-0.0193f * T - 0.2592f);
+  sunsky->config_x[1] = (-0.0665f * T + 0.0008f);
+  sunsky->config_x[2] = (-0.0004f * T + 0.2125f);
+  sunsky->config_x[3] = (-0.0641f * T - 0.8989f);
+  sunsky->config_x[4] = (-0.0033f * T + 0.0452f);
+
+  sunsky->config_y[0] = (-0.0167f * T - 0.2608f);
+  sunsky->config_y[1] = (-0.0950f * T + 0.0092f);
+  sunsky->config_y[2] = (-0.0079f * T + 0.2102f);
+  sunsky->config_y[3] = (-0.0441f * T - 1.6537f);
+  sunsky->config_y[4] = (-0.0109f * T + 0.0529f);
+
+  sunsky->radiance[0] /= sky_perez_function(sunsky->config_Y, 0, theta);
+  sunsky->radiance[1] /= sky_perez_function(sunsky->config_x, 0, theta);
+  sunsky->radiance[2] /= sky_perez_function(sunsky->config_y, 0, theta);
+}
+
+static void get_XYZ_to_RGB_for_gpu(XYZ_to_RGB *data)
+{
+  const float *xyz_to_rgb = IMB_colormangement_get_xyz_to_rgb();
+  data->r[0] = xyz_to_rgb[0];
+  data->r[1] = xyz_to_rgb[3];
+  data->r[2] = xyz_to_rgb[6];
+  data->g[0] = xyz_to_rgb[1];
+  data->g[1] = xyz_to_rgb[4];
+  data->g[2] = xyz_to_rgb[7];
+  data->b[0] = xyz_to_rgb[2];
+  data->b[1] = xyz_to_rgb[5];
+  data->b[2] = xyz_to_rgb[8];
+}
+
 static int node_shader_gpu_tex_sky(GPUMaterial *mat,
                                    bNode *node,
                                    bNodeExecData *UNUSED(execdata),
                                    GPUNodeStack *in,
                                    GPUNodeStack *out)
 {
-  if (!in[0].link) {
-    in[0].link = GPU_attribute(mat, CD_ORCO, "");
+  node_shader_gpu_default_tex_coord(mat, node, &in[0].link);
+  node_shader_gpu_tex_mapping(mat, node, in, out);
+  NodeTexSky *tex = (NodeTexSky *)node->storage;
+  float sun_angles[2]; /* [0]=theta=zenith angle  [1]=phi=azimuth */
+  sun_angles[0] = acosf(tex->sun_direction[2]);
+  sun_angles[1] = atan2f(tex->sun_direction[0], tex->sun_direction[1]);
+
+  if (tex->sky_model == 0) {
+    /* Preetham */
+    SkyModelPreetham sunsky;
+    sky_precompute_old(&sunsky, sun_angles, tex->turbidity);
+    XYZ_to_RGB xyz_to_rgb;
+    get_XYZ_to_RGB_for_gpu(&xyz_to_rgb);
+    return GPU_stack_link(mat,
+                          node,
+                          "node_tex_sky_preetham",
+                          in,
+                          out,
+                          /* Pass config_Y/x/y as 3x(vec4+float) */
+                          GPU_uniform(&sunsky.config_Y[0]),
+                          GPU_uniform(&sunsky.config_Y[4]),
+                          GPU_uniform(&sunsky.config_x[0]),
+                          GPU_uniform(&sunsky.config_x[4]),
+                          GPU_uniform(&sunsky.config_y[0]),
+                          GPU_uniform(&sunsky.config_y[4]),
+                          GPU_uniform(sun_angles),
+                          GPU_uniform(sunsky.radiance),
+                          GPU_uniform(xyz_to_rgb.r),
+                          GPU_uniform(xyz_to_rgb.g),
+                          GPU_uniform(xyz_to_rgb.b));
+  }
+  else if (tex->sky_model == 1) {
+    /* Hosek / Wilkie */
+    sun_angles[0] = fmin(M_PI_2, sun_angles[0]); /* clamp to horizon */
+    SKY_ArHosekSkyModelState *sky_state = SKY_arhosek_xyz_skymodelstate_alloc_init(
+        tex->turbidity, tex->ground_albedo, fmax(0.0, M_PI_2 - sun_angles[0]));
+    /* Pass sky_state->configs[3][9] as 3*(vec4+vec4)+vec3 */
+    float config_x07[8], config_y07[8], config_z07[8], config_xyz8[3];
+    for (int i = 0; i < 8; ++i) {
+      config_x07[i] = (float)sky_state->configs[0][i];
+      config_y07[i] = (float)sky_state->configs[1][i];
+      config_z07[i] = (float)sky_state->configs[2][i];
+    }
+    for (int i = 0; i < 3; ++i) {
+      config_xyz8[i] = (float)sky_state->configs[i][8];
+    }
+    float radiance[3];
+    for (int i = 0; i < 3; i++) {
+      radiance[i] = sky_state->radiances[i] * (2 * M_PI / 683);
+    }
+    SKY_arhosekskymodelstate_free(sky_state);
+    XYZ_to_RGB xyz_to_rgb;
+    get_XYZ_to_RGB_for_gpu(&xyz_to_rgb);
+    return GPU_stack_link(mat,
+                          node,
+                          "node_tex_sky_hosekwilkie",
+                          in,
+                          out,
+                          GPU_uniform(&config_x07[0]),
+                          GPU_uniform(&config_x07[4]),
+                          GPU_uniform(&config_y07[0]),
+                          GPU_uniform(&config_y07[4]),
+                          GPU_uniform(&config_z07[0]),
+                          GPU_uniform(&config_z07[4]),
+                          GPU_uniform(config_xyz8),
+                          GPU_uniform(sun_angles),
+                          GPU_uniform(radiance),
+                          GPU_uniform(xyz_to_rgb.r),
+                          GPU_uniform(xyz_to_rgb.g),
+                          GPU_uniform(xyz_to_rgb.b));
+  }
+  else {
+    return GPU_stack_link(mat, node, "node_tex_sky_nishita", in, out);
   }
+}
 
-  node_shader_gpu_tex_mapping(mat, node, in, out);
+static void node_shader_update_sky(bNodeTree *UNUSED(ntree), bNode *node)
+{
+  bNodeSocket *sockVector = nodeFindSocket(node, SOCK_IN, "Vector");
 
-  return GPU_stack_link(mat, node, "node_tex_sky", in, out);
+  NodeTexSky *tex = (NodeTexSky *)node->storage;
+  nodeSetSocketAvailability(sockVector, !(tex->sky_model == 2 && tex->sun_disc == 1));
 }
 
 /* node type definition */
@@ -79,6 +234,8 @@ void register_node_type_sh_tex_sky(void)
   node_type_init(&ntype, node_shader_init_tex_sky);
   node_type_storage(&ntype, "NodeTexSky", node_free_standard_storage, node_copy_standard_storage);
   node_type_gpu(&ntype, node_shader_gpu_tex_sky);
+  /* remove Vector input for Nishita */
+  node_type_update(&ntype, node_shader_update_sky);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_value.c b/source/blender/nodes/shader/nodes/node_shader_value.cc
index c32e9e1d581..64701018d63 100644
--- a/source/blender/nodes/shader/nodes/node_shader_value.c
+++ b/source/blender/nodes/shader/nodes/node_shader_value.cc
@@ -39,13 +39,21 @@ static int gpu_shader_value(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "set_value", in, out, link);
 }
 
+static void sh_node_value_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder)
+{
+  const bNodeSocket *bsocket = builder.dnode().output(0).bsocket();
+  const bNodeSocketValueFloat *value = (const bNodeSocketValueFloat *)bsocket->default_value;
+  builder.construct_and_set_matching_fn<blender::fn::CustomMF_Constant<float>>(value->value);
+}
+
 void register_node_type_sh_value(void)
 {
   static bNodeType ntype;
 
-  sh_node_type_base(&ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, 0);
+  sh_fn_node_type_base(&ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, 0);
   node_type_socket_templates(&ntype, NULL, sh_node_value_out);
   node_type_gpu(&ntype, gpu_shader_value);
+  ntype.expand_in_mf_network = sh_node_value_expand_in_mf_network;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_math.c b/source/blender/nodes/shader/nodes/node_shader_vector_math.cc
index b719fe03d9b..414d05e996a 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vector_math.c
+++ b/source/blender/nodes/shader/nodes/node_shader_vector_math.cc
@@ -34,44 +34,74 @@ static bNodeSocketTemplate sh_node_vector_math_in[] = {
 static bNodeSocketTemplate sh_node_vector_math_out[] = {
     {SOCK_VECTOR, N_("Vector")}, {SOCK_FLOAT, N_("Value")}, {-1, ""}};
 
+static const char *gpu_shader_get_name(int mode)
+{
+  switch (mode) {
+    case NODE_VECTOR_MATH_ADD:
+      return "vector_math_add";
+    case NODE_VECTOR_MATH_SUBTRACT:
+      return "vector_math_subtract";
+    case NODE_VECTOR_MATH_MULTIPLY:
+      return "vector_math_multiply";
+    case NODE_VECTOR_MATH_DIVIDE:
+      return "vector_math_divide";
+
+    case NODE_VECTOR_MATH_CROSS_PRODUCT:
+      return "vector_math_cross";
+    case NODE_VECTOR_MATH_PROJECT:
+      return "vector_math_project";
+    case NODE_VECTOR_MATH_REFLECT:
+      return "vector_math_reflect";
+    case NODE_VECTOR_MATH_DOT_PRODUCT:
+      return "vector_math_dot";
+
+    case NODE_VECTOR_MATH_DISTANCE:
+      return "vector_math_distance";
+    case NODE_VECTOR_MATH_LENGTH:
+      return "vector_math_length";
+    case NODE_VECTOR_MATH_SCALE:
+      return "vector_math_scale";
+    case NODE_VECTOR_MATH_NORMALIZE:
+      return "vector_math_normalize";
+
+    case NODE_VECTOR_MATH_SNAP:
+      return "vector_math_snap";
+    case NODE_VECTOR_MATH_FLOOR:
+      return "vector_math_floor";
+    case NODE_VECTOR_MATH_CEIL:
+      return "vector_math_ceil";
+    case NODE_VECTOR_MATH_MODULO:
+      return "vector_math_modulo";
+    case NODE_VECTOR_MATH_FRACTION:
+      return "vector_math_fraction";
+    case NODE_VECTOR_MATH_ABSOLUTE:
+      return "vector_math_absolute";
+    case NODE_VECTOR_MATH_MINIMUM:
+      return "vector_math_minimum";
+    case NODE_VECTOR_MATH_MAXIMUM:
+      return "vector_math_maximum";
+    case NODE_VECTOR_MATH_WRAP:
+      return "vector_math_wrap";
+    case NODE_VECTOR_MATH_SINE:
+      return "vector_math_sine";
+    case NODE_VECTOR_MATH_COSINE:
+      return "vector_math_cosine";
+    case NODE_VECTOR_MATH_TANGENT:
+      return "vector_math_tangent";
+  }
+
+  return nullptr;
+}
+
 static int gpu_shader_vector_math(GPUMaterial *mat,
                                   bNode *node,
                                   bNodeExecData *UNUSED(execdata),
                                   GPUNodeStack *in,
                                   GPUNodeStack *out)
 {
-  static const char *names[] = {
-      [NODE_VECTOR_MATH_ADD] = "vector_math_add",
-      [NODE_VECTOR_MATH_SUBTRACT] = "vector_math_subtract",
-      [NODE_VECTOR_MATH_MULTIPLY] = "vector_math_multiply",
-      [NODE_VECTOR_MATH_DIVIDE] = "vector_math_divide",
-
-      [NODE_VECTOR_MATH_CROSS_PRODUCT] = "vector_math_cross",
-      [NODE_VECTOR_MATH_PROJECT] = "vector_math_project",
-      [NODE_VECTOR_MATH_REFLECT] = "vector_math_reflect",
-      [NODE_VECTOR_MATH_DOT_PRODUCT] = "vector_math_dot",
-
-      [NODE_VECTOR_MATH_DISTANCE] = "vector_math_distance",
-      [NODE_VECTOR_MATH_LENGTH] = "vector_math_length",
-      [NODE_VECTOR_MATH_SCALE] = "vector_math_scale",
-      [NODE_VECTOR_MATH_NORMALIZE] = "vector_math_normalize",
-
-      [NODE_VECTOR_MATH_SNAP] = "vector_math_snap",
-      [NODE_VECTOR_MATH_FLOOR] = "vector_math_floor",
-      [NODE_VECTOR_MATH_CEIL] = "vector_math_ceil",
-      [NODE_VECTOR_MATH_MODULO] = "vector_math_modulo",
-      [NODE_VECTOR_MATH_FRACTION] = "vector_math_fraction",
-      [NODE_VECTOR_MATH_ABSOLUTE] = "vector_math_absolute",
-      [NODE_VECTOR_MATH_MINIMUM] = "vector_math_minimum",
-      [NODE_VECTOR_MATH_MAXIMUM] = "vector_math_maximum",
-      [NODE_VECTOR_MATH_WRAP] = "vector_math_wrap",
-      [NODE_VECTOR_MATH_SINE] = "vector_math_sine",
-      [NODE_VECTOR_MATH_COSINE] = "vector_math_cosine",
-      [NODE_VECTOR_MATH_TANGENT] = "vector_math_tangent",
-  };
-
-  if (node->custom1 < ARRAY_SIZE(names) && names[node->custom1]) {
-    return GPU_stack_link(mat, node, names[node->custom1], in, out);
+  const char *name = gpu_shader_get_name(node->custom1);
+  if (name != nullptr) {
+    return GPU_stack_link(mat, node, name, in, out);
   }
   else {
     return 0;
@@ -80,8 +110,8 @@ static int gpu_shader_vector_math(GPUMaterial *mat,
 
 static void node_shader_update_vector_math(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  bNodeSocket *sockB = BLI_findlink(&node->inputs, 1);
-  bNodeSocket *sockC = BLI_findlink(&node->inputs, 2);
+  bNodeSocket *sockB = (bNodeSocket *)BLI_findlink(&node->inputs, 1);
+  bNodeSocket *sockC = (bNodeSocket *)BLI_findlink(&node->inputs, 2);
   bNodeSocket *sockScale = nodeFindSocket(node, SOCK_IN, "Scale");
 
   bNodeSocket *sockVector = nodeFindSocket(node, SOCK_OUT, "Vector");
@@ -130,6 +160,43 @@ static void node_shader_update_vector_math(bNodeTree *UNUSED(ntree), bNode *node
   }
 }
 
+static void sh_node_vector_math_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder)
+{
+  using blender::float3;
+
+  /* TODO: Implement other operations. */
+  const int mode = builder.bnode().custom1;
+  switch (mode) {
+    case NODE_VECTOR_MATH_ADD: {
+      static blender::fn::CustomMF_SI_SI_SO<float3, float3, float3> fn{
+          "Add", [](float3 a, float3 b) { return a + b; }};
+      builder.set_matching_fn(fn);
+      break;
+    }
+    case NODE_VECTOR_MATH_SUBTRACT: {
+      static blender::fn::CustomMF_SI_SI_SO<float3, float3, float3> fn{
+          "Subtract", [](float3 a, float3 b) { return a - b; }};
+      builder.set_matching_fn(fn);
+      break;
+    }
+    case NODE_VECTOR_MATH_MULTIPLY: {
+      static blender::fn::CustomMF_SI_SI_SO<float3, float3, float3> fn{
+          "Multiply", [](float3 a, float3 b) { return a * b; }};
+      builder.set_matching_fn(fn);
+      break;
+    }
+    case NODE_VECTOR_MATH_DIVIDE: {
+      static blender::fn::CustomMF_SI_SI_SO<float3, float3, float3> fn{
+          "Divide", [](float3 a, float3 b) { return float3::safe_divide(a, b); }};
+      builder.set_matching_fn(fn);
+      break;
+    }
+    default:
+      BLI_assert(false);
+      break;
+  };
+}
+
 void register_node_type_sh_vect_math(void)
 {
   static bNodeType ntype;
@@ -139,6 +206,7 @@ void register_node_type_sh_vect_math(void)
   node_type_label(&ntype, node_vector_math_label);
   node_type_gpu(&ntype, gpu_shader_vector_math);
   node_type_update(&ntype, node_shader_update_vector_math);
+  ntype.expand_in_mf_network = sh_node_vector_math_expand_in_mf_network;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_vertex_color.c b/source/blender/nodes/shader/nodes/node_shader_vertex_color.c
index 70c924a7f85..40576b68dd5 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vertex_color.c
+++ b/source/blender/nodes/shader/nodes/node_shader_vertex_color.c
@@ -39,6 +39,10 @@ static int node_shader_gpu_vertex_color(GPUMaterial *mat,
                                         GPUNodeStack *out)
 {
   NodeShaderVertexColor *vertexColor = (NodeShaderVertexColor *)node->storage;
+  if (U.experimental.use_sculpt_vertex_colors) {
+    GPUNodeLink *vertexColorLink = GPU_attribute(mat, CD_PROP_COLOR, vertexColor->layer_name);
+    return GPU_stack_link(mat, node, "node_vertex_color", in, out, vertexColorLink);
+  }
   GPUNodeLink *vertexColorLink = GPU_attribute(mat, CD_MCOL, vertexColor->layer_name);
   return GPU_stack_link(mat, node, "node_vertex_color", in, out, vertexColorLink);
 }